ReactOS  0.4.15-dev-506-ga3ec01c
rxprocs.h File Reference
#include "backpack.h"
#include "rxlog.h"
#include "rxtimer.h"
#include "rxstruc.h"
Include dependency graph for rxprocs.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define RxLogFailure(DO, Originator, Event, Status)   RxLogEventDirect(DO, Originator, Event, Status, __LINE__)
 
#define FCB_MODE_EXCLUSIVE   1
 
#define FCB_MODE_SHARED   2
 
#define FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE   3
 
#define FCB_MODE_SHARED_STARVE_EXCLUSIVE   4
 
#define CHANGE_BUFFERING_STATE_CONTEXT   ((PRX_CONTEXT)IntToPtr(0xffffffff))
 
#define CHANGE_BUFFERING_STATE_CONTEXT_WAIT   ((PRX_CONTEXT)IntToPtr(0xfffffffe))
 
#define RxAcquireExclusiveFcb(R, F)   __RxAcquireFcb((F), (R), FCB_MODE_EXCLUSIVE)
 
#define RX_GET_MRX_FCB(F)   ((PMRX_FCB)((F)))
 
#define RxAcquireSharedFcb(R, F)   __RxAcquireFcb((F), (R), FCB_MODE_SHARED)
 
#define RxAcquireSharedFcbWaitForEx(R, F)   __RxAcquireFcb((F), (R), FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE)
 
#define RxReleaseFcb(R, F)   __RxReleaseFcb((R), RX_GET_MRX_FCB(F))
 
#define RxReleaseFcbForThread(R, F, T)   __RxReleaseFcbForThread((R), RX_GET_MRX_FCB(F), (T))
 
#define RxTrackerUpdateHistory(R, F, O, L, F, S)   { NOTHING; }
 
#define RxIsFcbAcquiredShared(Fcb)   ExIsResourceAcquiredSharedLite((Fcb)->Header.Resource)
 
#define RxIsFcbAcquiredExclusive(Fcb)   ExIsResourceAcquiredExclusiveLite((Fcb)->Header.Resource)
 
#define RxIsFcbAcquired(Fcb)
 
#define RxAcquirePagingIoResource(RxContext, Fcb)
 
#define RxAcquirePagingIoResourceShared(RxContext, Fcb, Flag)
 
#define RxReleasePagingIoResource(RxContext, Fcb)
 
#define RxReleasePagingIoResourceForThread(RxContext, Fcb, Thread)
 
#define RxConvertToSharedFcb(R, F)   ExConvertExclusiveToSharedLite(RX_GET_MRX_FCB(F)->Header.Resource)
 
#define QuadAlign(V)   (ALIGN_UP(V, ULONGLONG))
 
#define RxCompleteAsynchronousRequest(C, S)   RxCompleteRequest(C, S)
 
#define RxDumpWantedAccess(w1, w2, wlt, DA, DSA)   {NOTHING;}
 
#define RxDumpCurrentAccess(w1, w2, wlt, SA)   {NOTHING;}
 
#define RxCheckShareAccess(a1, a2, a3, a4, a5, a6, a7)   IoCheckShareAccess(a1, a2, a3, a4, a5)
 
#define RxRemoveShareAccess(a1, a2, a3, a4)   IoRemoveShareAccess(a1, a2)
 
#define RxSetShareAccess(a1, a2, a3, a4, a5, a6)   IoSetShareAccess(a1, a2, a3, a4)
 
#define RxUpdateShareAccess(a1, a2, a3, a4)   IoUpdateShareAccess(a1, a2)
 
#define RxEqualConnectionId(C1, C2)   RtlEqualMemory(C1, C2, sizeof(RX_CONNECTION_ID))
 

Typedefs

typedef enum _RX_NAME_CONJURING_METHODS RX_NAME_CONJURING_METHODS
 

Enumerations

enum  _RX_NAME_CONJURING_METHODS { VNetRoot_As_Prefix, VNetRoot_As_UNC_Name, VNetRoot_As_DriveLetter }
 

Functions

VOID NTAPI RxLogEventDirect (_In_ PRDBSS_DEVICE_OBJECT DeviceObject, _In_ PUNICODE_STRING OriginatorId, _In_ ULONG EventId, _In_ NTSTATUS Status, _In_ ULONG Line)
 
VOID NTAPI RxLogEventWithAnnotation (_In_ PRDBSS_DEVICE_OBJECT DeviceObject, _In_ ULONG EventId, _In_ NTSTATUS Status, _In_ PVOID DataBuffer, _In_ USHORT DataBufferLength, _In_ PUNICODE_STRING Annotation, _In_ ULONG AnnotationCount)
 
NTSTATUS RxPrefixClaim (_In_ PRX_CONTEXT RxContext)
 
VOID RxpPrepareCreateContextForReuse (_In_ PRX_CONTEXT RxContext)
 
NTSTATUS RxLowIoCompletionTail (_In_ PRX_CONTEXT RxContext)
 
LUID RxGetUid (_In_ PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext)
 
ULONG RxGetSessionId (_In_ PIO_STACK_LOCATION IrpSp)
 
NTSTATUS RxFindOrCreateConnections (_In_ PRX_CONTEXT RxContext, _In_ PUNICODE_STRING CanonicalName, _In_ NET_ROOT_TYPE NetRootType, _Out_ PUNICODE_STRING LocalNetRootName, _Out_ PUNICODE_STRING FilePathName, _Inout_ PLOCK_HOLDING_STATE LockState, _In_ PRX_CONNECTION_ID RxConnectionId)
 
VOID RxConjureOriginalName (_Inout_ PFCB Fcb, _Inout_ PFOBX Fobx, _Out_ PULONG ActualNameLength, _Out_writes_bytes_(*LengthRemaining) PWCHAR OriginalName, _Inout_ PLONG LengthRemaining, _In_ RX_NAME_CONJURING_METHODS NameConjuringMethod)
 
NTSTATUS NTAPI RxCompleteMdl (_In_ PRX_CONTEXT RxContext)
 
VOID RxLockUserBuffer (_In_ PRX_CONTEXT RxContext, _In_ LOCK_OPERATION Operation, _In_ ULONG BufferLength)
 
PVOID RxMapSystemBuffer (_In_ PRX_CONTEXT RxContext)
 
NTSTATUS __RxAcquireFcb (_Inout_ PFCB Fcb, _Inout_opt_ PRX_CONTEXT RxContext, _In_ ULONG Mode)
 
VOID __RxReleaseFcb (_Inout_opt_ PRX_CONTEXT RxContext, _Inout_ PMRX_FCB MrxFcb)
 
VOID __RxReleaseFcbForThread (_Inout_opt_ PRX_CONTEXT RxContext, _Inout_ PMRX_FCB MrxFcb, _In_ ERESOURCE_THREAD ResourceThreadId)
 
VOID RxTrackPagingIoResource (_Inout_ PVOID Instance, _In_ ULONG Type, _In_ ULONG Line, _In_ PCSTR File)
 
BOOLEAN NTAPI RxAcquireFcbForLazyWrite (_In_ PVOID Null, _In_ BOOLEAN Wait)
 
VOID NTAPI RxReleaseFcbFromLazyWrite (_In_ PVOID Null)
 
BOOLEAN NTAPI RxAcquireFcbForReadAhead (_In_ PVOID Null, _In_ BOOLEAN Wait)
 
VOID NTAPI RxReleaseFcbFromReadAhead (_In_ PVOID Null)
 
BOOLEAN NTAPI RxNoOpAcquire (_In_ PVOID Fcb, _In_ BOOLEAN Wait)
 
VOID NTAPI RxNoOpRelease (_In_ PVOID Fcb)
 
VOID RxVerifyOperationIsLegal (_In_ PRX_CONTEXT RxContext)
 
VOID RxPrePostIrp (_In_ PVOID Context, _In_ PIRP Irp)
 
VOID NTAPI RxAddToWorkque (_In_ PRX_CONTEXT RxContext, _In_ PIRP Irp)
 
NTSTATUS RxFsdPostRequest (_In_ PRX_CONTEXT RxContext)
 
VOID RxCompleteRequest_Real (_In_ PRX_CONTEXT RxContext, _In_ PIRP Irp, _In_ NTSTATUS Status)
 
NTSTATUS RxCompleteRequest (_In_ PRX_CONTEXT pContext, _In_ NTSTATUS Status)
 
NTSTATUS RxConstructSrvCall (_In_ PRX_CONTEXT RxContext, _In_ PSRV_CALL SrvCall, _Out_ PLOCK_HOLDING_STATE LockHoldingState)
 
NTSTATUS RxConstructNetRoot (_In_ PRX_CONTEXT RxContext, _In_ PSRV_CALL SrvCall, _In_ PNET_ROOT NetRoot, _In_ PV_NET_ROOT VirtualNetRoot, _Out_ PLOCK_HOLDING_STATE LockHoldingState)
 
NTSTATUS RxConstructVirtualNetRoot (_In_ PRX_CONTEXT RxContext, _In_ PUNICODE_STRING CanonicalName, _In_ NET_ROOT_TYPE NetRootType, _Out_ PV_NET_ROOT *VirtualNetRootPointer, _Out_ PLOCK_HOLDING_STATE LockHoldingState, _Out_ PRX_CONNECTION_ID RxConnectionId)
 
NTSTATUS RxFindOrConstructVirtualNetRoot (_In_ PRX_CONTEXT RxContext, _In_ PUNICODE_STRING CanonicalName, _In_ NET_ROOT_TYPE NetRootType, _In_ PUNICODE_STRING RemainingName)
 
NTSTATUS RxLowIoLockControlShell (_In_ PRX_CONTEXT RxContext)
 
NTSTATUS NTAPI RxChangeBufferingState (PSRV_OPEN SrvOpen, PVOID Context, BOOLEAN ComputeNewState)
 
VOID NTAPI RxIndicateChangeOfBufferingStateForSrvOpen (PMRX_SRV_CALL SrvCall, PMRX_SRV_OPEN SrvOpen, PVOID SrvOpenKey, PVOID Context)
 
NTSTATUS NTAPI RxPrepareToReparseSymbolicLink (PRX_CONTEXT RxContext, BOOLEAN SymbolicLinkEmbeddedInOldPath, PUNICODE_STRING NewPath, BOOLEAN NewPathIsAbsolute, PBOOLEAN ReparseRequired)
 
VOID RxReference (_Inout_ PVOID Instance)
 
VOID RxDereference (_Inout_ PVOID Instance, _In_ LOCK_HOLDING_STATE LockHoldingState)
 
VOID RxWaitForStableCondition (_In_ PRX_BLOCK_CONDITION Condition, _Inout_ PLIST_ENTRY TransitionWaitList, _Inout_ PRX_CONTEXT RxContext, _Out_opt_ NTSTATUS *AsyncStatus)
 
VOID RxUpdateCondition (_In_ RX_BLOCK_CONDITION NewConditionValue, _Out_ PRX_BLOCK_CONDITION Condition, _In_ OUT PLIST_ENTRY TransitionWaitList)
 
NTSTATUS RxCloseAssociatedSrvOpen (_In_ PFOBX Fobx, _In_opt_ PRX_CONTEXT RxContext)
 
NTSTATUS NTAPI RxFinalizeConnection (_Inout_ PNET_ROOT NetRoot, _Inout_opt_ PV_NET_ROOT VNetRoot, _In_ LOGICAL ForceFilesClosed)
 
NTSTATUS RxCheckShareAccessPerSrvOpens (_In_ PFCB Fcb, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess)
 
VOID RxUpdateShareAccessPerSrvOpens (_In_ PSRV_OPEN SrvOpen)
 
VOID RxRemoveShareAccessPerSrvOpens (_Inout_ PSRV_OPEN SrvOpen)
 
NTSTATUS NTAPI RxDriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
 
VOID NTAPI RxUnload (_In_ PDRIVER_OBJECT DriverObject)
 
VOID RxInitializeMinirdrDispatchTable (_In_ PDRIVER_OBJECT DriverObject)
 
ULONG RxGetNetworkProviderPriority (_In_ PUNICODE_STRING DeviceName)
 
VOID RxPrepareRequestForReuse (PCHANGE_BUFFERING_STATE_REQUEST Request)
 
VOID RxpDiscardChangeBufferingStateRequests (_Inout_ PLIST_ENTRY DiscardedRequests)
 
VOID RxGatherRequestsForSrvOpen (_Inout_ PSRV_CALL SrvCall, _In_ PSRV_OPEN SrvOpen, _Inout_ PLIST_ENTRY RequestsListHead)
 
NTSTATUS RxpLookupSrvOpenForRequestLite (_In_ PSRV_CALL SrvCall, _Inout_ PCHANGE_BUFFERING_STATE_REQUEST Request)
 
VOID RxProcessChangeBufferingStateRequestsForSrvOpen (PSRV_OPEN SrvOpen)
 
NTSTATUS RxPurgeFobxFromCache (PFOBX FobxToBePurged)
 
BOOLEAN RxPurgeFobx (PFOBX pFobx)
 
VOID RxUndoScavengerFinalizationMarking (PVOID Instance)
 
ULONG RxTableComputePathHashValue (_In_ PUNICODE_STRING Name)
 
VOID RxExtractServerName (_In_ PUNICODE_STRING FilePathName, _Out_ PUNICODE_STRING SrvCallName, _Out_ PUNICODE_STRING RestOfName)
 
VOID NTAPI RxCreateNetRootCallBack (_In_ PMRX_CREATENETROOT_CONTEXT CreateNetRootContext)
 
PVOID RxAllocateObject (_In_ NODE_TYPE_CODE NodeType, _In_opt_ PMINIRDR_DISPATCH MRxDispatch, _In_ ULONG NameLength)
 
VOID RxFreeObject (_In_ PVOID pObject)
 
NTSTATUS RxInitializeSrvCallParameters (_In_ PRX_CONTEXT RxContext, _Inout_ PSRV_CALL SrvCall)
 
VOID RxAddVirtualNetRootToNetRoot (_In_ PNET_ROOT NetRoot, _In_ PV_NET_ROOT VNetRoot)
 
VOID RxRemoveVirtualNetRootFromNetRoot (_In_ PNET_ROOT NetRoot, _In_ PV_NET_ROOT VNetRoot)
 
PVOID RxAllocateFcbObject (_In_ PRDBSS_DEVICE_OBJECT RxDeviceObject, _In_ NODE_TYPE_CODE NodeType, _In_ POOL_TYPE PoolType, _In_ ULONG NameSize, _In_opt_ PVOID AlreadyAllocatedObject)
 
VOID RxFreeFcbObject (_In_ PVOID Object)
 
VOID RxPurgeFcb (_In_ PFCB Fcb)
 
BOOLEAN RxFinalizeNetFcb (_Out_ PFCB ThisFcb, _In_ BOOLEAN RecursiveFinalize, _In_ BOOLEAN ForceFinalize, _In_ LONG ReferenceCount)
 
BOOLEAN RxIsThisACscAgentOpen (_In_ PRX_CONTEXT RxContext)
 
VOID NTAPI RxCheckFcbStructuresForAlignment (VOID)
 
NTSTATUS RxInitializeWorkQueueDispatcher (_In_ PRX_WORK_QUEUE_DISPATCHER Dispatcher)
 
VOID RxInitializeWorkQueue (_In_ PRX_WORK_QUEUE WorkQueue, _In_ WORK_QUEUE_TYPE WorkQueueType, _In_ ULONG MaximumNumberOfWorkerThreads, _In_ ULONG MinimumNumberOfWorkerThreads)
 
NTSTATUS RxSpinUpWorkerThread (_In_ PRX_WORK_QUEUE WorkQueue, _In_ PRX_WORKERTHREAD_ROUTINE Routine, _In_ PVOID Parameter)
 
VOID RxSpinUpWorkerThreads (_In_ PRX_WORK_QUEUE WorkQueue)
 
VOID NTAPI RxSpinUpRequestsDispatcher (_In_ PVOID Dispatcher)
 
VOID RxpWorkerThreadDispatcher (_In_ PRX_WORK_QUEUE WorkQueue, _In_ PLARGE_INTEGER WaitInterval)
 
VOID NTAPI RxBootstrapWorkerThreadDispatcher (_In_ PVOID WorkQueue)
 
PRX_PREFIX_ENTRY RxTableLookupName_ExactLengthMatch (_In_ PRX_PREFIX_TABLE ThisTable, _In_ PUNICODE_STRING Name, _In_ ULONG HashValue, _In_opt_ PRX_CONNECTION_ID RxConnectionId)
 
PVOID RxTableLookupName (_In_ PRX_PREFIX_TABLE ThisTable, _In_ PUNICODE_STRING Name, _Out_ PUNICODE_STRING RemainingName, _In_opt_ PRX_CONNECTION_ID RxConnectionId)
 
VOID RxOrphanSrvOpens (_In_ PV_NET_ROOT ThisVNetRoot)
 
VOID RxOrphanThisFcb (_In_ PFCB Fcb)
 
VOID RxOrphanSrvOpensForThisFcb (_In_ PFCB Fcb, _In_ PV_NET_ROOT ThisVNetRoot, _In_ BOOLEAN OrphanAll)
 
NTSTATUS NTAPI RxLockOperationCompletion (_In_ PVOID Context, _In_ PIRP Irp)
 
VOID NTAPI RxUnlockOperation (_In_ PVOID Context, _In_ PFILE_LOCK_INFO LockInfo)
 
NTSTATUS RxPostStackOverflowRead (_In_ PRX_CONTEXT RxContext)
 
VOID NTAPI RxCancelRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
 

Variables

PVOID RxNull
 

Macro Definition Documentation

◆ CHANGE_BUFFERING_STATE_CONTEXT

#define CHANGE_BUFFERING_STATE_CONTEXT   ((PRX_CONTEXT)IntToPtr(0xffffffff))

Definition at line 135 of file rxprocs.h.

◆ CHANGE_BUFFERING_STATE_CONTEXT_WAIT

#define CHANGE_BUFFERING_STATE_CONTEXT_WAIT   ((PRX_CONTEXT)IntToPtr(0xfffffffe))

Definition at line 136 of file rxprocs.h.

◆ FCB_MODE_EXCLUSIVE

#define FCB_MODE_EXCLUSIVE   1

Definition at line 130 of file rxprocs.h.

◆ FCB_MODE_SHARED

#define FCB_MODE_SHARED   2

Definition at line 131 of file rxprocs.h.

◆ FCB_MODE_SHARED_STARVE_EXCLUSIVE

#define FCB_MODE_SHARED_STARVE_EXCLUSIVE   4

Definition at line 133 of file rxprocs.h.

◆ FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE

#define FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE   3

Definition at line 132 of file rxprocs.h.

◆ QuadAlign

#define QuadAlign (   V)    (ALIGN_UP(V, ULONGLONG))

Definition at line 358 of file rxprocs.h.

◆ RX_GET_MRX_FCB

#define RX_GET_MRX_FCB (   F)    ((PMRX_FCB)((F)))

Definition at line 157 of file rxprocs.h.

◆ RxAcquireExclusiveFcb

#define RxAcquireExclusiveFcb (   R,
  F 
)    __RxAcquireFcb((F), (R), FCB_MODE_EXCLUSIVE)

Definition at line 154 of file rxprocs.h.

◆ RxAcquirePagingIoResource

#define RxAcquirePagingIoResource (   RxContext,
  Fcb 
)
Value:
if (RxContext != NULL) \
{ \
(RxContext)->FcbPagingIoResourceAcquired = TRUE; \
} \
RxTrackPagingIoResource(Fcb, 1, __LINE__, __FILE__)
#define TRUE
Definition: types.h:120
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
Definition: Header.h:8
smooth NULL
Definition: ftsmooth.c:416
_In_ PFCB Fcb
Definition: cdprocs.h:159

Definition at line 233 of file rxprocs.h.

◆ RxAcquirePagingIoResourceShared

#define RxAcquirePagingIoResourceShared (   RxContext,
  Fcb,
  Flag 
)
Value:
ExAcquireResourceSharedLite((Fcb)->Header.PagingIoResource, Flag); \
if (AcquiredFile) \
{ \
if (RxContext != NULL) \
{ \
((PRX_CONTEXT)RxContext)->FcbPagingIoResourceAcquired = TRUE; \
} \
RxTrackPagingIoResource(Fcb, 2, __LINE__, __FILE__); \
}
#define TRUE
Definition: types.h:120
Definition: Header.h:8
smooth NULL
Definition: ftsmooth.c:416
Definition: xml2sdb.h:79
struct _RX_CONTEXT * PRX_CONTEXT
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
_In_ PFCB Fcb
Definition: cdprocs.h:159

Definition at line 242 of file rxprocs.h.

◆ RxAcquireSharedFcb

#define RxAcquireSharedFcb (   R,
  F 
)    __RxAcquireFcb((F), (R), FCB_MODE_SHARED)

Definition at line 162 of file rxprocs.h.

◆ RxAcquireSharedFcbWaitForEx

#define RxAcquireSharedFcbWaitForEx (   R,
  F 
)    __RxAcquireFcb((F), (R), FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE)

Definition at line 168 of file rxprocs.h.

◆ RxCheckShareAccess

#define RxCheckShareAccess (   a1,
  a2,
  a3,
  a4,
  a5,
  a6,
  a7 
)    IoCheckShareAccess(a1, a2, a3, a4, a5)

Definition at line 578 of file rxprocs.h.

◆ RxCompleteAsynchronousRequest

#define RxCompleteAsynchronousRequest (   C,
  S 
)    RxCompleteRequest(C, S)

Definition at line 386 of file rxprocs.h.

◆ RxConvertToSharedFcb

#define RxConvertToSharedFcb (   R,
  F 
)    ExConvertExclusiveToSharedLite(RX_GET_MRX_FCB(F)->Header.Resource)

Definition at line 337 of file rxprocs.h.

◆ RxDumpCurrentAccess

#define RxDumpCurrentAccess (   w1,
  w2,
  wlt,
  SA 
)    {NOTHING;}

Definition at line 527 of file rxprocs.h.

◆ RxDumpWantedAccess

#define RxDumpWantedAccess (   w1,
  w2,
  wlt,
  DA,
  DSA 
)    {NOTHING;}

Definition at line 526 of file rxprocs.h.

◆ RxEqualConnectionId

#define RxEqualConnectionId (   C1,
  C2 
)    RtlEqualMemory(C1, C2, sizeof(RX_CONNECTION_ID))

Definition at line 774 of file rxprocs.h.

◆ RxIsFcbAcquired

#define RxIsFcbAcquired (   Fcb)
Value:
ExIsResourceAcquiredExclusiveLite((Fcb)->Header.Resource))
Definition: Header.h:8
ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)
Definition: resource.c:1658
_In_ PFCB Fcb
Definition: cdprocs.h:159

Definition at line 230 of file rxprocs.h.

◆ RxIsFcbAcquiredExclusive

#define RxIsFcbAcquiredExclusive (   Fcb)    ExIsResourceAcquiredExclusiveLite((Fcb)->Header.Resource)

Definition at line 229 of file rxprocs.h.

◆ RxIsFcbAcquiredShared

#define RxIsFcbAcquiredShared (   Fcb)    ExIsResourceAcquiredSharedLite((Fcb)->Header.Resource)

Definition at line 228 of file rxprocs.h.

◆ RxLogFailure

#define RxLogFailure (   DO,
  Originator,
  Event,
  Status 
)    RxLogEventDirect(DO, Originator, Event, Status, __LINE__)

Definition at line 11 of file rxprocs.h.

◆ RxReleaseFcb

#define RxReleaseFcb (   R,
  F 
)    __RxReleaseFcb((R), RX_GET_MRX_FCB(F))

Definition at line 186 of file rxprocs.h.

◆ RxReleaseFcbForThread

#define RxReleaseFcbForThread (   R,
  F,
  T 
)    __RxReleaseFcbForThread((R), RX_GET_MRX_FCB(F), (T))

Definition at line 205 of file rxprocs.h.

◆ RxReleasePagingIoResource

#define RxReleasePagingIoResource (   RxContext,
  Fcb 
)
Value:
RxTrackPagingIoResource(Fcb, 3, __LINE__, __FILE__); \
if (RxContext != NULL) \
{ \
(RxContext)->FcbPagingIoResourceAcquired = FALSE; \
} \
ExReleaseResourceLite((Fcb)->Header.PagingIoResource)
Definition: Header.h:8
smooth NULL
Definition: ftsmooth.c:416
VOID RxTrackPagingIoResource(_Inout_ PVOID Instance, _In_ ULONG Type, _In_ ULONG Line, _In_ PCSTR File)
Definition: rxce.c:8654
_In_ PFCB Fcb
Definition: cdprocs.h:159

Definition at line 268 of file rxprocs.h.

◆ RxReleasePagingIoResourceForThread

#define RxReleasePagingIoResourceForThread (   RxContext,
  Fcb,
  Thread 
)
Value:
RxTrackPagingIoResource(Fcb, 3, __LINE__, __FILE__); \
if (RxContext != NULL) \
{ \
(RxContext)->FcbPagingIoResourceAcquired = FALSE; \
} \
ExReleaseResourceForThreadLite((Fcb)->Header.PagingIoResource, (Thread))
Definition: Header.h:8
smooth NULL
Definition: ftsmooth.c:416
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
VOID RxTrackPagingIoResource(_Inout_ PVOID Instance, _In_ ULONG Type, _In_ ULONG Line, _In_ PCSTR File)
Definition: rxce.c:8654
_In_ PFCB Fcb
Definition: cdprocs.h:159

Definition at line 276 of file rxprocs.h.

◆ RxRemoveShareAccess

#define RxRemoveShareAccess (   a1,
  a2,
  a3,
  a4 
)    IoRemoveShareAccess(a1, a2)

Definition at line 579 of file rxprocs.h.

◆ RxSetShareAccess

#define RxSetShareAccess (   a1,
  a2,
  a3,
  a4,
  a5,
  a6 
)    IoSetShareAccess(a1, a2, a3, a4)

Definition at line 580 of file rxprocs.h.

◆ RxTrackerUpdateHistory

#define RxTrackerUpdateHistory (   R,
  F,
  O,
  L,
  F,
  S 
)    { NOTHING; }

Definition at line 218 of file rxprocs.h.

◆ RxUpdateShareAccess

#define RxUpdateShareAccess (   a1,
  a2,
  a3,
  a4 
)    IoUpdateShareAccess(a1, a2)

Definition at line 581 of file rxprocs.h.

Typedef Documentation

◆ RX_NAME_CONJURING_METHODS

Enumeration Type Documentation

◆ _RX_NAME_CONJURING_METHODS

Enumerator
VNetRoot_As_Prefix 
VNetRoot_As_UNC_Name 
VNetRoot_As_DriveLetter 

Definition at line 78 of file rxprocs.h.

Function Documentation

◆ __RxAcquireFcb()

NTSTATUS __RxAcquireFcb ( _Inout_ PFCB  Fcb,
_Inout_opt_ PRX_CONTEXT  RxContext,
_In_ ULONG  Mode 
)

Definition at line 8973 of file rxce.c.

8984 {
8985  NTSTATUS Status;
8986  BOOLEAN SpecialContext, CanWait, Acquired, ContextIsPresent;
8987 
8988  PAGED_CODE();
8989 
8990  DPRINT("__RxAcquireFcb(%p, %p, %d, %d, %s, %d)\n", Fcb, RxContext, Mode, LineNumber, FileName, SerialNumber);
8991 
8992  SpecialContext = FALSE;
8993  ContextIsPresent = FALSE;
8994  /* Check for special context */
8996  {
8997  SpecialContext = TRUE;
8998  }
8999 
9000  /* We don't handle buffering state change yet... */
9001  if (!RxIsFcbAcquired(Fcb) && !SpecialContext &&
9003  {
9004  UNIMPLEMENTED;
9005  }
9006 
9007  /* Nor special contexts */
9008  if (SpecialContext)
9009  {
9010  UNIMPLEMENTED;
9011  }
9012 
9013  /* If we don't have a context, assume we can wait! */
9014  if (RxContext == NULL)
9015  {
9016  CanWait = TRUE;
9017  }
9018  else
9019  {
9020  /* That said: we have a real context! */
9021  ContextIsPresent = TRUE;
9022 
9023  /* If we've been cancelled in between, give up */
9025  if (!NT_SUCCESS(Status))
9026  {
9027  return Status;
9028  }
9029 
9030  /* Can we wait? */
9031  CanWait = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
9032  }
9033 
9034  while (TRUE)
9035  {
9036  /* Assume we cannot lock */
9038 
9039  /* Lock according to what the caller asked */
9040  switch (Mode)
9041  {
9042  case FCB_MODE_EXCLUSIVE:
9043  Acquired = ExAcquireResourceExclusiveLite(Fcb->Header.Resource, CanWait);
9044  break;
9045 
9046  case FCB_MODE_SHARED:
9047  Acquired = ExAcquireResourceSharedLite(Fcb->Header.Resource, CanWait);
9048  break;
9049 
9051  Acquired = ExAcquireSharedWaitForExclusive(Fcb->Header.Resource, CanWait);
9052  break;
9053 
9054  default:
9056  Acquired = ExAcquireSharedStarveExclusive(Fcb->Header.Resource, CanWait);
9057  break;
9058  }
9059 
9060  /* Lock granted! */
9061  if (Acquired)
9062  {
9065 
9066  /* Handle paging write - not implemented */
9067  if (Fcb->NonPaged->OutstandingAsyncWrites != 0)
9068  {
9069  UNIMPLEMENTED;
9070  }
9071  }
9072 
9073  /* And break, that cool! */
9074  if (Acquired)
9075  {
9076  break;
9077  }
9078 
9079  /* If it failed, return immediately */
9080  if (!NT_SUCCESS(Status))
9081  {
9082  return Status;
9083  }
9084  }
9085 
9086  /* If we don't have to check for valid operation, job done, nothing more to do */
9087  if (!ContextIsPresent || BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_BYPASS_VALIDOP_CHECK))
9088  {
9089  if (NT_SUCCESS(Status))
9090  {
9091  RxTrackerUpdateHistory(RxContext, RX_GET_MRX_FCB(Fcb), TRACKER_ACQUIRE_FCB, LineNumber, FileName, SerialNumber);
9092  }
9093 
9094  return Status;
9095  }
9096 
9097  /* Verify operation */
9098  _SEH2_TRY
9099  {
9100  RxVerifyOperationIsLegal(RxContext);
9101  }
9103  {
9104  /* If it failed, release lock and fail */
9106  {
9107  ExReleaseResourceLite(Fcb->Header.Resource);
9109  }
9110  }
9111  _SEH2_END;
9112 
9113  if (NT_SUCCESS(Status))
9114  {
9115  RxTrackerUpdateHistory(RxContext, RX_GET_MRX_FCB(Fcb), TRACKER_ACQUIRE_FCB, LineNumber, FileName, SerialNumber);
9116  }
9117 
9118  DPRINT("Status: %x\n", Status);
9119  return Status;
9120 }
BOOLEAN NTAPI ExAcquireSharedWaitForExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1217
#define TRUE
Definition: types.h:120
_In_ ULONG Mode
Definition: hubbusif.h:303
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:931
#define CHANGE_BUFFERING_STATE_CONTEXT
Definition: rxprocs.h:135
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
VOID RxVerifyOperationIsLegal(IN PRX_CONTEXT RxContext)
Definition: rxce.c:8759
#define FCB_MODE_SHARED_STARVE_EXCLUSIVE
Definition: rxprocs.h:133
LONG NTSTATUS
Definition: precomp.h:26
#define CHANGE_BUFFERING_STATE_CONTEXT_WAIT
Definition: rxprocs.h:136
#define RxIsFcbAcquired(Fcb)
Definition: rxprocs.h:230
_SEH2_TRY
Definition: create.c:4226
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
#define RxTrackerUpdateHistory(R, F, O, L, F, S)
Definition: rxprocs.h:218
#define FCB_MODE_EXCLUSIVE
Definition: rxprocs.h:130
PNON_PAGED_FCB NonPaged
Definition: fatstruc.h:810
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define _SEH2_AbnormalTermination()
Definition: pseh2_64.h:13
void DPRINT(...)
Definition: polytest.cpp:61
#define RX_GET_MRX_FCB(F)
Definition: rxprocs.h:157
#define STATUS_LOCK_NOT_GRANTED
Definition: ntstatus.h:307
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define FCB_MODE_SHARED
Definition: rxprocs.h:131
ULONG SerialNumber
Definition: rxce.c:117
Status
Definition: gdiplustypes.h:24
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1063
_SEH2_END
Definition: create.c:4400
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 LineNumber
Definition: acpixf.h:1216
_SEH2_FINALLY
Definition: create.c:4371
#define FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE
Definition: rxprocs.h:132
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:885
#define UNIMPLEMENTED
Definition: debug.h:115
#define ASSERT_CORRECT_FCB_STRUCTURE(Fcb)
Definition: fcb.h:562
_In_ PFCB Fcb
Definition: cdprocs.h:159
return STATUS_SUCCESS
Definition: btrfs.c:3014
ULONG FcbState
Definition: cdstruc.h:977
#define FCB_STATE_BUFFERING_STATE_CHANGE_PENDING
Definition: fcb.h:207
#define PAGED_CODE()
ULONG OutstandingAsyncWrites
Definition: fatstruc.h:736

◆ __RxReleaseFcb()

VOID __RxReleaseFcb ( _Inout_opt_ PRX_CONTEXT  RxContext,
_Inout_ PMRX_FCB  MrxFcb 
)

Definition at line 9142 of file rxce.c.

9152 {
9153  BOOLEAN IsExclusive, BufferingPending;
9154 
9156 
9157  BufferingPending = BooleanFlagOn(MrxFcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING);
9158  IsExclusive = !!RxIsResourceOwnershipStateExclusive(MrxFcb->Header.Resource);
9159 
9160  /* If no buffering pending, or no exclusive lock (we can only handle with an exclusive lock),
9161  * then just release the FCB
9162  */
9163  if (!BufferingPending || !IsExclusive)
9164  {
9165  RxTrackerUpdateHistory(RxContext, MrxFcb, (!BufferingPending ? TRACKER_RELEASE_FCB_NO_BUFF_PENDING : TRACKER_RELEASE_NON_EXCL_FCB_BUFF_PENDING),
9167  ExReleaseResourceLite(MrxFcb->Header.Resource);
9168  }
9169 
9171 
9172  /* And finally leave */
9173  if (!BufferingPending || !IsExclusive)
9174  {
9175  return;
9176  }
9177 
9179 
9180  /* Otherwise, handle buffering state and release */
9182 
9183  RxTrackerUpdateHistory(RxContext, MrxFcb, TRACKER_RELEASE_EXCL_FCB_BUFF_PENDING, LineNumber, FileName, SerialNumber);
9184  ExReleaseResourceLite(MrxFcb->Header.Resource);
9185 }
#define RxIsResourceOwnershipStateExclusive(Resource)
Definition: ntrxdef.h:28
Definition: cdstruc.h:908
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define RxTrackerUpdateHistory(R, F, O, L, F, S)
Definition: rxprocs.h:218
unsigned char BOOLEAN
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define RxReleaseSerializationMutex()
Definition: rxdata.h:9
VOID RxProcessFcbChangeBufferingStateRequest(PFCB Fcb)
Definition: rxce.c:6685
ULONG SerialNumber
Definition: rxce.c:117
#define RxIsFcbAcquiredExclusive(Fcb)
Definition: rxprocs.h:229
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 LineNumber
Definition: acpixf.h:1216
#define RxAcquireSerializationMutex()
Definition: rxdata.h:8
#define FCB_STATE_BUFFERING_STATE_CHANGE_PENDING
Definition: fcb.h:207

◆ __RxReleaseFcbForThread()

VOID __RxReleaseFcbForThread ( _Inout_opt_ PRX_CONTEXT  RxContext,
_Inout_ PMRX_FCB  MrxFcb,
_In_ ERESOURCE_THREAD  ResourceThreadId 
)

Definition at line 9188 of file rxce.c.

9199 {
9200  BOOLEAN IsExclusive, BufferingPending;
9201 
9203 
9204  BufferingPending = BooleanFlagOn(MrxFcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING);
9205  IsExclusive = !!RxIsResourceOwnershipStateExclusive(MrxFcb->Header.Resource);
9206 
9207  /* If no buffering pending, or no exclusive lock (we can only handle with an exclusive lock),
9208  * then just release the FCB
9209  */
9210  if (!BufferingPending || !IsExclusive)
9211  {
9212  RxTrackerUpdateHistory(RxContext, MrxFcb,
9213  (!BufferingPending ? TRACKER_RELEASE_FCB_FOR_THRD_NO_BUFF_PENDING : TRACKER_RELEASE_NON_EXCL_FCB_FOR_THRD_BUFF_PENDING),
9215  ExReleaseResourceForThreadLite(MrxFcb->Header.Resource, ResourceThreadId);
9216  }
9217 
9219 
9220  /* And finally leave */
9221  if (!BufferingPending || !IsExclusive)
9222  {
9223  return;
9224  }
9225 
9226  /* Otherwise, handle buffering state and release */
9227  RxTrackerUpdateHistory(RxContext, MrxFcb, TRACKER_RELEASE_EXCL_FCB_FOR_THRD_BUFF_PENDING, LineNumber, FileName, SerialNumber);
9229  ExReleaseResourceForThreadLite(MrxFcb->Header.Resource, ResourceThreadId);
9230 }
#define RxIsResourceOwnershipStateExclusive(Resource)
Definition: ntrxdef.h:28
Definition: cdstruc.h:908
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define RxTrackerUpdateHistory(R, F, O, L, F, S)
Definition: rxprocs.h:218
unsigned char BOOLEAN
_In_ ERESOURCE_THREAD ResourceThreadId
Definition: exfuncs.h:1002
#define RxReleaseSerializationMutex()
Definition: rxdata.h:9
VOID RxProcessFcbChangeBufferingStateRequest(PFCB Fcb)
Definition: rxce.c:6685
ULONG SerialNumber
Definition: rxce.c:117
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 LineNumber
Definition: acpixf.h:1216
#define RxAcquireSerializationMutex()
Definition: rxdata.h:8
VOID NTAPI ExReleaseResourceForThreadLite(IN PERESOURCE Resource, IN ERESOURCE_THREAD Thread)
Definition: resource.c:1844
#define FCB_STATE_BUFFERING_STATE_CHANGE_PENDING
Definition: fcb.h:207

◆ RxAcquireFcbForLazyWrite()

BOOLEAN NTAPI RxAcquireFcbForLazyWrite ( _In_ PVOID  Null,
_In_ BOOLEAN  Wait 
)

◆ RxAcquireFcbForReadAhead()

BOOLEAN NTAPI RxAcquireFcbForReadAhead ( _In_ PVOID  Null,
_In_ BOOLEAN  Wait 
)

◆ RxAddToWorkque()

VOID NTAPI RxAddToWorkque ( _In_ PRX_CONTEXT  RxContext,
_In_ PIRP  Irp 
)

◆ RxAddVirtualNetRootToNetRoot()

VOID RxAddVirtualNetRootToNetRoot ( _In_ PNET_ROOT  NetRoot,
_In_ PV_NET_ROOT  VNetRoot 
)

◆ RxAllocateFcbObject()

PVOID RxAllocateFcbObject ( _In_ PRDBSS_DEVICE_OBJECT  RxDeviceObject,
_In_ NODE_TYPE_CODE  NodeType,
_In_ POOL_TYPE  PoolType,
_In_ ULONG  NameSize,
_In_opt_ PVOID  AlreadyAllocatedObject 
)

◆ RxAllocateObject()

PVOID RxAllocateObject ( _In_ NODE_TYPE_CODE  NodeType,
_In_opt_ PMINIRDR_DISPATCH  MRxDispatch,
_In_ ULONG  NameLength 
)

◆ RxBootstrapWorkerThreadDispatcher()

VOID NTAPI RxBootstrapWorkerThreadDispatcher ( _In_ PVOID  WorkQueue)

◆ RxCancelRoutine()

VOID NTAPI RxCancelRoutine ( _In_ PDEVICE_OBJECT  DeviceObject,
_In_ PIRP  Irp 
)

◆ RxChangeBufferingState()

NTSTATUS NTAPI RxChangeBufferingState ( PSRV_OPEN  SrvOpen,
PVOID  Context,
BOOLEAN  ComputeNewState 
)

Definition at line 783 of file rxce.c.

787 {
788  PFCB Fcb;
790  ULONG NewBufferingState, OldBufferingState;
791 
792  PAGED_CODE();
793 
794  DPRINT("RxChangeBufferingState(%p, %p, %d)\n", SrvOpen, Context, ComputeNewState);
795 
796  Fcb = (PFCB)SrvOpen->pFcb;
798  /* First of all, mark that buffering state is changing */
800 
801  /* Assume success */
803  _SEH2_TRY
804  {
805  /* If we're asked to compute a new state, ask the mini-rdr for it */
806  if (ComputeNewState)
807  {
808  MINIRDR_CALL_THROUGH(MiniStatus, Fcb->MRxDispatch, MRxComputeNewBufferingState,
809  ((PMRX_SRV_OPEN)SrvOpen, Context, &NewBufferingState));
810  if (MiniStatus != STATUS_SUCCESS)
811  {
812  NewBufferingState = 0;
813  }
814  }
815  else
816  {
817  /* If not, use SRV_OPEN state */
818  NewBufferingState = SrvOpen->BufferingFlags;
819  }
820 
821  /* If no shared access, and if we're not asked to compute a new state, use maximum flags set */
822  if ((Fcb->ShareAccess.SharedRead + Fcb->ShareAccess.SharedWrite + Fcb->ShareAccess.SharedDelete) == 0 && !ComputeNewState)
823  {
824  SetFlag(NewBufferingState, FCB_STATE_BUFFERING_STATE_WITH_NO_SHARES);
825  }
826 
827  /* If there's a lock operation to complete, clear that flag */
828  if (Fcb->OutstandingLockOperationsCount != 0)
829  {
830  ClearFlag(NewBufferingState, FCB_STATE_LOCK_BUFFERING_ENABLED);
831  }
832 
833  /* Get the old state */
834  OldBufferingState = Fcb->FcbState & FCB_STATE_BUFFERING_STATE_MASK;
835  DPRINT("ChangeBufferingState %x -> %x (%x)\n", OldBufferingState, NewBufferingState, SrvOpen->BufferingFlags);
836 
837  /* If we're dropping write cache, then flush the FCB */
838  if (BooleanFlagOn(OldBufferingState, FCB_STATE_WRITECACHING_ENABLED) &&
839  !BooleanFlagOn(NewBufferingState, FCB_STATE_WRITECACHING_ENABLED))
840  {
841  DPRINT("Flushing\n");
842 
844  }
845 
846  /* If we're dropping read cache, then purge */
847  if (Fcb->UncleanCount == 0 ||
848  (BooleanFlagOn(OldBufferingState, FCB_STATE_READCACHING_ENABLED) &&
849  !BooleanFlagOn(NewBufferingState, FCB_STATE_READCACHING_ENABLED)) ||
850  BooleanFlagOn(NewBufferingState, FCB_STATE_DELETE_ON_CLOSE))
851  {
852  DPRINT("Purging\n");
853 
854  if (!NT_SUCCESS(Status))
855  {
856  DPRINT("Previous flush failed with status: %lx\n", Status);
857  }
858 
860  }
861 
862  /* If there's already a change pending in SRV_OPEN */
863  if (ComputeNewState && BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING))
864  {
865  /* If there's a FOBX at least */
866  if (!IsListEmpty(&SrvOpen->FobxList))
867  {
868  PRX_CONTEXT RxContext;
869 
870  /* Create a fake context to pass to the mini-rdr */
872  if (RxContext != NULL)
873  {
874  PFOBX Fobx;
875 
876  RxContext->pFcb = RX_GET_MRX_FCB(Fcb);
877 
878  /* Give the first FOBX */
879  Fobx = CONTAINING_RECORD(SrvOpen->FobxList.Flink, FOBX, FobxQLinks);
880  RxContext->pFobx = (PMRX_FOBX)Fobx;
881  RxContext->pRelevantSrvOpen = Fobx->pSrvOpen;
882 
883  /* If there was a delayed close, perform it */
884  if (BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_CLOSE_DELAYED))
885  {
886  DPRINT("Oplock break close for %p\n", SrvOpen);
887 
888  RxCloseAssociatedSrvOpen(Fobx, RxContext);
889  }
890  /* Otherwise, inform the mini-rdr about completion */
891  else
892  {
893  MINIRDR_CALL_THROUGH(MiniStatus, Fcb->MRxDispatch, MRxCompleteBufferingStateChangeRequest,
894  (RxContext, (PMRX_SRV_OPEN)SrvOpen, Context));
895  (void)MiniStatus;
896  }
897 
899  }
900  }
901  }
902 
903  /* Set the new state */
904  Fcb->FcbState ^= (NewBufferingState ^ Fcb->FcbState) & FCB_STATE_BUFFERING_STATE_MASK;
905  }
907  {
908  /* Job done, clear the flag */
910 
911  if (!BooleanFlagOn(NewBufferingState, FCB_STATE_FILETIMECACHEING_ENABLED))
912  {
914  }
915  }
916  _SEH2_END;
917 
918  return Status;
919 }
BOOLEAN NTAPI CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
Definition: fssup.c:386
#define TRUE
Definition: types.h:120
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
Definition: cdstruc.h:908
PMRX_FCB pFcb
Definition: rxcontx.h:112
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define NodeTypeIsFcb(FCB)
Definition: nodetype.h:68
PRX_CONTEXT NTAPI RxCreateRxContext(IN PIRP Irp, IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN ULONG InitialContextFlags)
Definition: rxce.c:1797
LONG NTSTATUS
Definition: precomp.h:26
PMRX_FOBX pFobx
Definition: rxcontx.h:113
struct _MRX_FOBX_ * PMRX_FOBX
SECTION_OBJECT_POINTERS SectionObjectPointers
Definition: fatstruc.h:728
Definition: fcb.h:304
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
_SEH2_TRY
Definition: create.c:4226
#define FCB_STATE_BUFFERING_STATE_MASK
Definition: fcb.h:232
#define FCB_STATE_WRITECACHING_ENABLED
Definition: fcb.h:226
VOID NTAPI MiniStatus(IN NDIS_HANDLE MiniportHandle, IN NDIS_STATUS GeneralStatus, IN PVOID StatusBuffer, IN UINT StatusBufferSize)
Definition: miniport.c:1384
PNON_PAGED_FCB NonPaged
Definition: fatstruc.h:810
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
#define RX_GET_MRX_FCB(F)
Definition: rxprocs.h:157
ULONG SharedWrite
Definition: iotypes.h:500
#define FCB_STATE_READCACHING_ENABLED
Definition: fcb.h:224
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:120
#define FCB_STATE_FILETIMECACHEING_ENABLED
Definition: fcb.h:218
SHARE_ACCESS ShareAccess
Definition: cdstruc.h:1015
NTSTATUS RxCloseAssociatedSrvOpen(_In_ PFOBX Fobx, _In_opt_ PRX_CONTEXT RxContext)
#define SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING
Definition: mrxfcb.h:136
#define FCB_STATE_DELETE_ON_CLOSE
Definition: fatstruc.h:1192
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
FCB * PFCB
Definition: cdstruc.h:1046
NTSTATUS RxFlushFcbInSystemCache(IN PFCB Fcb, IN BOOLEAN SynchronizeWithLazyWriter)
Definition: rxce.c:4249
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
PMINIRDR_DISPATCH MRxDispatch
Definition: fcb.h:150
CLONG UncleanCount
Definition: fatstruc.h:872
ULONG SharedRead
Definition: iotypes.h:499
#define FCB_STATE_LOCK_BUFFERING_ENABLED
Definition: fcb.h:220
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
PRDBSS_DEVICE_OBJECT RxDeviceObject
Definition: fcb.h:149
Status
Definition: gdiplustypes.h:24
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
_SEH2_END
Definition: create.c:4400
#define FCB_STATE_TIME_AND_SIZE_ALREADY_SET
Definition: fcb.h:217
_SEH2_FINALLY
Definition: create.c:4371
LIST_ENTRY FobxList
Definition: fcb.h:279
unsigned int ULONG
Definition: retypes.h:1
#define MINIRDR_CALL_THROUGH(STATUS, DISPATCH, FUNC, ARGLIST)
Definition: rxcontx.h:375
ULONG SharedDelete
Definition: iotypes.h:501
_In_ PFCB Fcb
Definition: cdprocs.h:159
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define RxDereferenceAndDeleteRxContext(RXCONTEXT)
Definition: rxcontx.h:514
ULONG FcbState
Definition: cdstruc.h:977
#define FCB_STATE_BUFFERSTATE_CHANGING
Definition: fcb.h:215
#define SRVOPEN_FLAG_CLOSE_DELAYED
Definition: mrxfcb.h:133
PMRX_SRV_OPEN pRelevantSrvOpen
Definition: rxcontx.h:114
#define PAGED_CODE()

Referenced by enable_caching(), and RxCreateFromNetRoot().

◆ RxCheckFcbStructuresForAlignment()

VOID NTAPI RxCheckFcbStructuresForAlignment ( VOID  )

Definition at line 1447 of file rdbss.c.

1449 {
1450  PAGED_CODE();
1451 }
#define PAGED_CODE()

Referenced by RxDriverEntry().

◆ RxCheckShareAccessPerSrvOpens()

NTSTATUS RxCheckShareAccessPerSrvOpens ( _In_ PFCB  Fcb,
_In_ ACCESS_MASK  DesiredAccess,
_In_ ULONG  DesiredShareAccess 
)

◆ RxCloseAssociatedSrvOpen()

NTSTATUS RxCloseAssociatedSrvOpen ( _In_ PFOBX  Fobx,
_In_opt_ PRX_CONTEXT  RxContext 
)

◆ RxCompleteMdl()

NTSTATUS NTAPI RxCompleteMdl ( _In_ PRX_CONTEXT  RxContext)

◆ RxCompleteRequest()

NTSTATUS RxCompleteRequest ( _In_ PRX_CONTEXT  pContext,
_In_ NTSTATUS  Status 
)

◆ RxCompleteRequest_Real()

VOID RxCompleteRequest_Real ( _In_ PRX_CONTEXT  RxContext,
_In_ PIRP  Irp,
_In_ NTSTATUS  Status 
)

Referenced by RxFsdCommonDispatch().

◆ RxConjureOriginalName()

VOID RxConjureOriginalName ( _Inout_ PFCB  Fcb,
_Inout_ PFOBX  Fobx,
_Out_ PULONG  ActualNameLength,
_Out_writes_bytes_ *LengthRemaining PWCHAR  OriginalName,
_Inout_ PLONG  LengthRemaining,
_In_ RX_NAME_CONJURING_METHODS  NameConjuringMethod 
)

◆ RxConstructNetRoot()

NTSTATUS RxConstructNetRoot ( _In_ PRX_CONTEXT  RxContext,
_In_ PSRV_CALL  SrvCall,
_In_ PNET_ROOT  NetRoot,
_In_ PV_NET_ROOT  VirtualNetRoot,
_Out_ PLOCK_HOLDING_STATE  LockHoldingState 
)

◆ RxConstructSrvCall()

NTSTATUS RxConstructSrvCall ( _In_ PRX_CONTEXT  RxContext,
_In_ PSRV_CALL  SrvCall,
_Out_ PLOCK_HOLDING_STATE  LockHoldingState 
)

◆ RxConstructVirtualNetRoot()

NTSTATUS RxConstructVirtualNetRoot ( _In_ PRX_CONTEXT  RxContext,
_In_ PUNICODE_STRING  CanonicalName,
_In_ NET_ROOT_TYPE  NetRootType,
_Out_ PV_NET_ROOT VirtualNetRootPointer,
_Out_ PLOCK_HOLDING_STATE  LockHoldingState,
_Out_ PRX_CONNECTION_ID  RxConnectionId 
)

◆ RxCreateNetRootCallBack()

VOID NTAPI RxCreateNetRootCallBack ( _In_ PMRX_CREATENETROOT_CONTEXT  CreateNetRootContext)

◆ RxDereference()

VOID RxDereference ( _Inout_ PVOID  Instance,
_In_ LOCK_HOLDING_STATE  LockHoldingState 
)

◆ RxDriverEntry()

NTSTATUS NTAPI RxDriverEntry ( _In_ PDRIVER_OBJECT  DriverObject,
_In_ PUNICODE_STRING  RegistryPath 
)

Referenced by DriverEntry().

◆ RxExtractServerName()

VOID RxExtractServerName ( _In_ PUNICODE_STRING  FilePathName,
_Out_ PUNICODE_STRING  SrvCallName,
_Out_ PUNICODE_STRING  RestOfName 
)

◆ RxFinalizeConnection()

NTSTATUS NTAPI RxFinalizeConnection ( _Inout_ PNET_ROOT  NetRoot,
_Inout_opt_ PV_NET_ROOT  VNetRoot,
_In_ LOGICAL  ForceFilesClosed 
)

Referenced by nfs41_DeleteConnection().

◆ RxFinalizeNetFcb()

BOOLEAN RxFinalizeNetFcb ( _Out_ PFCB  ThisFcb,
_In_ BOOLEAN  RecursiveFinalize,
_In_ BOOLEAN  ForceFinalize,
_In_ LONG  ReferenceCount 
)

◆ RxFindOrConstructVirtualNetRoot()

NTSTATUS RxFindOrConstructVirtualNetRoot ( _In_ PRX_CONTEXT  RxContext,
_In_ PUNICODE_STRING  CanonicalName,
_In_ NET_ROOT_TYPE  NetRootType,
_In_ PUNICODE_STRING  RemainingName 
)

◆ RxFindOrCreateConnections()

NTSTATUS RxFindOrCreateConnections ( _In_ PRX_CONTEXT  RxContext,
_In_ PUNICODE_STRING  CanonicalName,
_In_ NET_ROOT_TYPE  NetRootType,
_Out_ PUNICODE_STRING  LocalNetRootName,
_Out_ PUNICODE_STRING  FilePathName,
_Inout_ PLOCK_HOLDING_STATE  LockState,
_In_ PRX_CONNECTION_ID  RxConnectionId 
)

Definition at line 3675 of file rxce.c.

3683 {
3684  PVOID Container;
3685  PSRV_CALL SrvCall;
3686  PNET_ROOT NetRoot;
3687  PV_NET_ROOT VNetRoot;
3689  PRX_PREFIX_TABLE PrefixTable;
3690  UNICODE_STRING RemainingName, NetRootName;
3691 
3692  PAGED_CODE();
3693 
3694  DPRINT("RxFindOrCreateConnections(%p, %wZ, %x, %p, %p, %p, %p)\n",
3695  RxContext, CanonicalName, NetRootType, LocalNetRootName,
3696  FilePathName, LockState, RxConnectionId);
3697 
3698  *FilePathName = *CanonicalName;
3699  LocalNetRootName->Length = 0;
3700  LocalNetRootName->MaximumLength = 0;
3701  LocalNetRootName->Buffer = CanonicalName->Buffer;
3702 
3703  /* UNC path, split it */
3704  if (FilePathName->Buffer[1] == ';')
3705  {
3706  BOOLEAN Slash;
3707  USHORT i, Length;
3708 
3709  Slash = FALSE;
3710  for (i = 2; i < FilePathName->Length / sizeof(WCHAR); ++i)
3711  {
3712  if (FilePathName->Buffer[i] == OBJ_NAME_PATH_SEPARATOR)
3713  {
3714  Slash = TRUE;
3715  break;
3716  }
3717  }
3718 
3719  if (!Slash)
3720  {
3722  }
3723 
3724  FilePathName->Buffer = &FilePathName->Buffer[i];
3725  Length = (USHORT)((ULONG_PTR)FilePathName->Buffer - (ULONG_PTR)LocalNetRootName->Buffer);
3726  LocalNetRootName->Length = Length;
3727  LocalNetRootName->MaximumLength = Length;
3728  FilePathName->Length -= Length;
3729 
3730  DPRINT("CanonicalName: %wZ\n", CanonicalName);
3731  DPRINT(" -> FilePathName: %wZ\n", FilePathName);
3732  DPRINT(" -> LocalNetRootName: %wZ\n", LocalNetRootName);
3733  }
3734 
3735  Container = NULL;
3736  PrefixTable = RxContext->RxDeviceObject->pRxNetNameTable;
3737 
3738  _SEH2_TRY
3739  {
3740 RetryLookup:
3742 
3743  /* If previous lookup left something, dereference it */
3744  if (Container != NULL)
3745  {
3746  switch (NodeType(Container))
3747  {
3748  case RDBSS_NTC_SRVCALL:
3749  RxDereferenceSrvCall(Container, *LockState);
3750  break;
3751 
3752  case RDBSS_NTC_NETROOT:
3753  RxDereferenceNetRoot(Container, *LockState);
3754  break;
3755 
3756  case RDBSS_NTC_V_NETROOT:
3757  RxDereferenceVNetRoot(Container, *LockState);
3758  break;
3759 
3760  default:
3761  /* Should never happen */
3762  ASSERT(FALSE);
3763  break;
3764  }
3765  }
3766 
3767  /* Look for our NetRoot in prefix table */
3768  Container = RxPrefixTableLookupName(PrefixTable, FilePathName, &RemainingName, RxConnectionId);
3769  DPRINT("Container %p for path %wZ\n", Container, FilePathName);
3770 
3771  while (TRUE)
3772  {
3773  UNICODE_STRING SrvCallName;
3774 
3775  SrvCall = NULL;
3776  NetRoot = NULL;
3777  VNetRoot = NULL;
3778 
3779  /* Assume we didn't succeed */
3780  RxContext->Create.pVNetRoot = NULL;
3781  RxContext->Create.pNetRoot = NULL;
3782  RxContext->Create.pSrvCall = NULL;
3783  RxContext->Create.Type = NetRootType;
3784 
3785  /* If we found something */
3786  if (Container != NULL)
3787  {
3788  /* A VNetRoot */
3789  if (NodeType(Container) == RDBSS_NTC_V_NETROOT)
3790  {
3791  VNetRoot = Container;
3792  /* Use its NetRoot */
3793  NetRoot = VNetRoot->NetRoot;
3794 
3795  /* If it's not stable, wait for it to be stable */
3796  if (NetRoot->Condition == Condition_InTransition)
3797  {
3798  RxReleasePrefixTableLock(PrefixTable);
3799  DPRINT("Waiting for stable condition for: %p\n", NetRoot);
3800  RxWaitForStableNetRoot(NetRoot, RxContext);
3803 
3804  /* Now that's it's ok, retry lookup to find what we want */
3805  if (NetRoot->Condition == Condition_Good)
3806  {
3807  goto RetryLookup;
3808  }
3809  }
3810 
3811  /* Is the associated netroot good? */
3812  if (NetRoot->Condition == Condition_Good)
3813  {
3814  SrvCall = (PSRV_CALL)NetRoot->pSrvCall;
3815 
3816  /* If it is, and SrvCall as well, then, we have our active connection */
3817  if (SrvCall->Condition == Condition_Good &&
3818  SrvCall->RxDeviceObject == RxContext->RxDeviceObject)
3819  {
3820  RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
3821  RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
3822  RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
3823 
3825  _SEH2_LEAVE;
3826  }
3827  }
3828 
3829  /* If VNetRoot was well constructed, it means the connection is active */
3830  if (VNetRoot->ConstructionStatus == STATUS_SUCCESS)
3831  {
3833  }
3834  else
3835  {
3836  Status = VNetRoot->ConstructionStatus;
3837  }
3838 
3839  RxDereferenceVNetRoot(VNetRoot, *LockState);
3840  _SEH2_LEAVE;
3841  }
3842  /* Can only be a SrvCall */
3843  else
3844  {
3845  ASSERT(NodeType(Container) == RDBSS_NTC_SRVCALL);
3846  SrvCall = Container;
3847 
3848  /* Wait for the SRV_CALL to be stable */
3849  if (SrvCall->Condition == Condition_InTransition)
3850  {
3851  RxReleasePrefixTableLock(PrefixTable);
3852  DPRINT("Waiting for stable condition for: %p\n", SrvCall);
3853  RxWaitForStableSrvCall(SrvCall, RxContext);
3856 
3857  /* It went good, loop again to find what we look for */
3858  if (SrvCall->Condition == Condition_Good)
3859  {
3860  goto RetryLookup;
3861  }
3862  }
3863 
3864  /* If it's not good... */
3865  if (SrvCall->Condition != Condition_Good)
3866  {
3867  /* But SRV_CALL was well constructed, assume a connection was active */
3868  if (SrvCall->Status == STATUS_SUCCESS)
3869  {
3871  }
3872  else
3873  {
3874  Status = SrvCall->Status;
3875  }
3876 
3877  RxDereferenceSrvCall(SrvCall, *LockState);
3878  _SEH2_LEAVE;
3879  }
3880  }
3881  }
3882 
3883  /* If we found a SRV_CALL not matching our DO, quit */
3884  if (SrvCall != NULL && SrvCall->Condition == Condition_Good &&
3885  SrvCall->RxDeviceObject != RxContext->RxDeviceObject)
3886  {
3887  RxDereferenceSrvCall(SrvCall, *LockState);
3889  _SEH2_LEAVE;
3890  }
3891 
3892  /* Now, we want exclusive lock */
3893  if (*LockState == LHS_SharedLockHeld)
3894  {
3895  if (!RxAcquirePrefixTableLockExclusive(PrefixTable, FALSE))
3896  {
3897  RxReleasePrefixTableLock(PrefixTable);
3900  goto RetryLookup;
3901  }
3902 
3903  RxReleasePrefixTableLock(PrefixTable);
3905  }
3906 
3908 
3909  /* If we reach that point, we found something, no need to create something */
3910  if (Container != NULL)
3911  {
3912  break;
3913  }
3914 
3915  /* Get the name for the SRV_CALL */
3916  RxExtractServerName(FilePathName, &SrvCallName, NULL);
3917  DPRINT(" -> SrvCallName: %wZ\n", &SrvCallName);
3918  /* And create the SRV_CALL */
3919  SrvCall = RxCreateSrvCall(RxContext, &SrvCallName, NULL, RxConnectionId);
3920  if (SrvCall == NULL)
3921  {
3923  _SEH2_LEAVE;
3924  }
3925 
3926  /* Reset RX_CONTEXT, so far, connection creation isn't a success */
3927  RxReferenceSrvCall(SrvCall);
3928  RxContext->Create.pVNetRoot = NULL;
3929  RxContext->Create.pNetRoot = NULL;
3930  RxContext->Create.pSrvCall = NULL;
3931  RxContext->Create.Type = NetRootType;
3932  Container = SrvCall;
3933 
3934  /* Construct SRV_CALL, ie, use mini-rdr */
3935  Status = RxConstructSrvCall(RxContext, SrvCall, LockState);
3937  if (Status != STATUS_SUCCESS)
3938  {
3939  DPRINT1("RxConstructSrvCall() = Status: %x\n", Status);
3941  RxDereferenceSrvCall(SrvCall, *LockState);
3942  RxReleasePrefixTableLock(PrefixTable);
3943  _SEH2_LEAVE;
3944  }
3945 
3946  /* Loop again to make use of SRV_CALL stable condition wait */
3947  }
3948 
3949  /* At that point, we have a stable SRV_CALL (either found or constructed) */
3950  ASSERT((NodeType(SrvCall) == RDBSS_NTC_SRVCALL) && (SrvCall->Condition == Condition_Good));
3951  ASSERT(NetRoot == NULL && VNetRoot == NULL);
3952  ASSERT(SrvCall->RxDeviceObject == RxContext->RxDeviceObject);
3953 
3954  /* Call mini-rdr to get NetRoot name */
3955  SrvCall->RxDeviceObject->Dispatch->MRxExtractNetRootName(FilePathName, (PMRX_SRV_CALL)SrvCall, &NetRootName, NULL);
3956  /* And create the NetRoot with that name */
3957  NetRoot = RxCreateNetRoot(SrvCall, &NetRootName, 0, RxConnectionId);
3958  if (NetRoot == NULL)
3959  {
3961  _SEH2_LEAVE;
3962  }
3963  NetRoot->Type = NetRootType;
3964 
3965  RxDereferenceSrvCall(SrvCall, *LockState);
3966 
3967  /* Finally, create the associated VNetRoot */
3968  VNetRoot = RxCreateVNetRoot(RxContext, NetRoot, CanonicalName, LocalNetRootName, FilePathName, RxConnectionId);
3969  if (VNetRoot == NULL)
3970  {
3971  RxFinalizeNetRoot(NetRoot, TRUE, TRUE);
3973  _SEH2_LEAVE;
3974  }
3975  RxReferenceVNetRoot(VNetRoot);
3976 
3977  /* We're get closer! */
3978  NetRoot->Condition = Condition_InTransition;
3979  RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
3980  RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
3981  RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
3982 
3983  /* Construct the NetRoot, involving the mini-rdr now that we have our three control structs */
3984  Status = RxConstructNetRoot(RxContext, SrvCall, NetRoot, VNetRoot, LockState);
3985  if (!NT_SUCCESS(Status))
3986  {
3988  DPRINT1("RxConstructNetRoot failed Ctxt: %p, VNet: %p, Status: %lx, Condition: %d\n", RxContext, VNetRoot, Status, VNetRoot->Condition);
3989  RxDereferenceVNetRoot(VNetRoot, *LockState);
3990 
3991  RxContext->Create.pNetRoot = NULL;
3992  RxContext->Create.pVNetRoot = NULL;
3993  }
3994  else
3995  {
3996  PIO_STACK_LOCATION Stack;
3997 
3999 
4000  Stack = RxContext->CurrentIrpSp;
4002  {
4005  }
4006  }
4007  }
4009  {
4011  {
4012  if (*LockState != LHS_LockNotHeld)
4013  {
4014  RxReleasePrefixTableLock(PrefixTable);
4016  }
4017  }
4018  }
4019  _SEH2_END;
4020 
4021  DPRINT("RxFindOrCreateConnections() = Status: %x\n", Status);
4022  return Status;
4023 }
struct _SRV_CALL * PSRV_CALL
#define TRUE
Definition: types.h:120
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
RX_BLOCK_CONDITION Condition
Definition: fcb.h:21
struct _MRX_NET_ROOT_ * PMRX_NET_ROOT
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define RxReferenceSrvCall(SrvCall)
Definition: fcb.h:391
LONG NTSTATUS
Definition: precomp.h:26
Definition: fcb.h:33
#define RxReleasePrefixTableLock(T)
Definition: prefix.h:84
struct _MRX_V_NET_ROOT_ * PMRX_V_NET_ROOT
#define RxWaitForStableNetRoot(N, R)
Definition: fcb.h:473
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:64
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
IN OUT PLONG IN OUT PLONG Addend IN OUT PLONG IN LONG IN OUT PLONG IN LONG Increment IN PNDIS_RW_LOCK Lock IN PNDIS_RW_LOCK IN PLOCK_STATE LockState
Definition: CrNtStubs.h:99
#define RxReferenceVNetRoot(VNetRoot)
Definition: fcb.h:407
unsigned char BOOLEAN
PVOID RxPrefixTableLookupName(IN PRX_PREFIX_TABLE ThisTable, IN PUNICODE_STRING CanonicalName, OUT PUNICODE_STRING RemainingName, IN PRX_CONNECTION_ID ConnectionId)
Definition: rxce.c:6487
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
#define RxIsPrefixTableLockAcquired(T)
Definition: prefix.h:113
NodeType
Definition: Node.h:5
NTSTATUS RxConstructNetRoot(IN PRX_CONTEXT RxContext, IN PSRV_CALL SrvCall, IN PNET_ROOT NetRoot, IN PV_NET_ROOT VirtualNetRoot, OUT PLOCK_HOLDING_STATE LockHoldingState)
Definition: rxce.c:1163
#define RxDereferenceVNetRoot(VNetRoot, LockHoldingState)
Definition: fcb.h:411
#define STATUS_BAD_NETWORK_NAME
Definition: ntstatus.h:426
Definition: fcb.h:9
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define RDBSS_NTC_V_NETROOT
Definition: nodetype.h:50
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
VOID RxExtractServerName(IN PUNICODE_STRING FilePathName, OUT PUNICODE_STRING SrvCallName, OUT PUNICODE_STRING RestOfName)
Definition: rxce.c:2452
#define RxDereferenceNetRoot(NetRoot, LockHoldingState)
Definition: fcb.h:403
RX_BLOCK_CONDITION Condition
Definition: fcb.h:45
PNET_ROOT NetRoot
Definition: fcb.h:65
PSRV_CALL RxCreateSrvCall(IN PRX_CONTEXT RxContext, IN PUNICODE_STRING Name, IN PUNICODE_STRING InnerNamePrefix OPTIONAL, IN PRX_CONNECTION_ID RxConnectionId)
Definition: rxce.c:1843
RX_BLOCK_CONDITION Condition
Definition: fcb.h:70
Status
Definition: gdiplustypes.h:24
#define RDBSS_NTC_SRVCALL
Definition: nodetype.h:48
_SEH2_END
Definition: create.c:4400
unsigned short USHORT
Definition: pedump.c:61
#define RDBSS_NTC_NETROOT
Definition: nodetype.h:49
PV_NET_ROOT RxCreateVNetRoot(IN PRX_CONTEXT RxContext, IN PNET_ROOT NetRoot, IN PUNICODE_STRING CanonicalName, IN PUNICODE_STRING LocalNetRootName, IN PUNICODE_STRING FilePath, IN PRX_CONNECTION_ID RxConnectionId)
Definition: rxce.c:2052
#define STATUS_OBJECT_NAME_INVALID
Definition: udferr_usr.h:148
#define RxAcquirePrefixTableLockExclusive(T, W)
Definition: prefix.h:83
_SEH2_FINALLY
Definition: create.c:4371
#define STATUS_CONNECTION_ACTIVE
Definition: ntstatus.h:689
NTSTATUS RxConstructSrvCall(IN PRX_CONTEXT RxContext, IN PSRV_CALL SrvCall, OUT PLOCK_HOLDING_STATE LockHoldingState)
Definition: rxce.c:1262
VOID RxExclusivePrefixTableLockToShared(PRX_PREFIX_TABLE Table)
Definition: rxce.c:2440
#define DPRINT1
Definition: precomp.h:8
#define RxTransitionVNetRoot(V, C)
Definition: fcb.h:515
struct _MRX_SRV_CALL_ * PMRX_SRV_CALL
BOOLEAN RxFinalizeNetRoot(OUT PNET_ROOT ThisNetRoot, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
Definition: rxce.c:3062
#define ULONG_PTR
Definition: config.h:101
#define FILE_CREATE_TREE_CONNECTION
Definition: from_kernel.h:33
#define _SEH2_LEAVE
Definition: filesup.c:20
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2774
#define RxWaitForStableSrvCall(S, R)
Definition: fcb.h:450
#define RxDereferenceSrvCall(SrvCall, LockHoldingState)
Definition: fcb.h:395
return STATUS_SUCCESS
Definition: btrfs.c:3014
PNET_ROOT RxCreateNetRoot(IN PSRV_CALL SrvCall, IN PUNICODE_STRING Name, IN ULONG NetRootFlags, IN PRX_CONNECTION_ID OPTIONAL RxConnectionId)
Definition: rxce.c:1705
HRESULT Create([out]ITransactionReceiver **ppReceiver)
#define PAGED_CODE()
_Inout_ PFCB _Inout_ PUNICODE_STRING RemainingName
Definition: cdprocs.h:801

Referenced by RxConstructVirtualNetRoot().

◆ RxFreeFcbObject()

VOID RxFreeFcbObject ( _In_ PVOID  Object)

◆ RxFreeObject()

VOID RxFreeObject ( _In_ PVOID  pObject)

◆ RxFsdPostRequest()

NTSTATUS RxFsdPostRequest ( _In_ PRX_CONTEXT  RxContext)

◆ RxGatherRequestsForSrvOpen()

VOID RxGatherRequestsForSrvOpen ( _Inout_ PSRV_CALL  SrvCall,
_In_ PSRV_OPEN  SrvOpen,
_Inout_ PLIST_ENTRY  RequestsListHead 
)

◆ RxGetNetworkProviderPriority()

ULONG RxGetNetworkProviderPriority ( _In_ PUNICODE_STRING  DeviceName)

◆ RxGetSessionId()

ULONG RxGetSessionId ( _In_ PIO_STACK_LOCATION  IrpSp)

◆ RxGetUid()

LUID RxGetUid ( _In_ PSECURITY_SUBJECT_CONTEXT  SubjectSecurityContext)

◆ RxIndicateChangeOfBufferingStateForSrvOpen()

VOID NTAPI RxIndicateChangeOfBufferingStateForSrvOpen ( PMRX_SRV_CALL  SrvCall,
PMRX_SRV_OPEN  SrvOpen,
PVOID  SrvOpenKey,
PVOID  Context 
)

Definition at line 6880 of file rdbss.c.

6885 {
6886  UNIMPLEMENTED;
6887 }
#define UNIMPLEMENTED
Definition: debug.h:115

Referenced by fcbopen_main(), and nfs41_invalidate_cache().

◆ RxInitializeMinirdrDispatchTable()

VOID RxInitializeMinirdrDispatchTable ( _In_ PDRIVER_OBJECT  DriverObject)

◆ RxInitializeSrvCallParameters()

NTSTATUS RxInitializeSrvCallParameters ( _In_ PRX_CONTEXT  RxContext,
_Inout_ PSRV_CALL  SrvCall 
)

◆ RxInitializeWorkQueue()

VOID RxInitializeWorkQueue ( _In_ PRX_WORK_QUEUE  WorkQueue,
_In_ WORK_QUEUE_TYPE  WorkQueueType,
_In_ ULONG  MaximumNumberOfWorkerThreads,
_In_ ULONG  MinimumNumberOfWorkerThreads 
)

◆ RxInitializeWorkQueueDispatcher()

NTSTATUS RxInitializeWorkQueueDispatcher ( _In_ PRX_WORK_QUEUE_DISPATCHER  Dispatcher)

◆ RxIsThisACscAgentOpen()

BOOLEAN RxIsThisACscAgentOpen ( _In_ PRX_CONTEXT  RxContext)

◆ RxLockOperationCompletion()

NTSTATUS NTAPI RxLockOperationCompletion ( _In_ PVOID  Context,
_In_ PIRP  Irp 
)

◆ RxLockUserBuffer()

VOID RxLockUserBuffer ( _In_ PRX_CONTEXT  RxContext,
_In_ LOCK_OPERATION  Operation,
_In_ ULONG  BufferLength 
)

◆ RxLogEventDirect()

VOID NTAPI RxLogEventDirect ( _In_ PRDBSS_DEVICE_OBJECT  DeviceObject,
_In_ PUNICODE_STRING  OriginatorId,
_In_ ULONG  EventId,
_In_ NTSTATUS  Status,
_In_ ULONG  Line 
)

◆ RxLogEventWithAnnotation()

VOID NTAPI RxLogEventWithAnnotation ( _In_ PRDBSS_DEVICE_OBJECT  DeviceObject,
_In_ ULONG  EventId,
_In_ NTSTATUS  Status,
_In_ PVOID  DataBuffer,
_In_ USHORT  DataBufferLength,
_In_ PUNICODE_STRING  Annotation,
_In_ ULONG  AnnotationCount 
)

◆ RxLowIoCompletionTail()

NTSTATUS RxLowIoCompletionTail ( _In_ PRX_CONTEXT  RxContext)

◆ RxLowIoLockControlShell()

NTSTATUS RxLowIoLockControlShell ( _In_ PRX_CONTEXT  RxContext)

◆ RxMapSystemBuffer()

PVOID RxMapSystemBuffer ( _In_ PRX_CONTEXT  RxContext)

◆ RxNoOpAcquire()

BOOLEAN NTAPI RxNoOpAcquire ( _In_ PVOID  Fcb,
_In_ BOOLEAN  Wait 
)

◆ RxNoOpRelease()

VOID NTAPI RxNoOpRelease ( _In_ PVOID  Fcb)

◆ RxOrphanSrvOpens()

VOID RxOrphanSrvOpens ( _In_ PV_NET_ROOT  ThisVNetRoot)

◆ RxOrphanSrvOpensForThisFcb()

VOID RxOrphanSrvOpensForThisFcb ( _In_ PFCB  Fcb,
_In_ PV_NET_ROOT  ThisVNetRoot,
_In_ BOOLEAN  OrphanAll 
)

◆ RxOrphanThisFcb()

VOID RxOrphanThisFcb ( _In_ PFCB  Fcb)

Referenced by RxCommonClose(), and RxFindOrCreateFcb().

◆ RxpDiscardChangeBufferingStateRequests()

VOID RxpDiscardChangeBufferingStateRequests ( _Inout_ PLIST_ENTRY  DiscardedRequests)

Definition at line 6065 of file rxce.c.

6067 {
6069 
6070  PAGED_CODE();
6071 
6072  /* No requests to discard */
6073  if (IsListEmpty(DiscardedRequests))
6074  {
6075  return;
6076  }
6077 
6078  /* Free all the discarded requests */
6079  Entry = DiscardedRequests->Flink;
6080  while (Entry != DiscardedRequests)
6081  {
6083 
6085  Entry = Entry->Flink;
6086 
6087  DPRINT("Req %p for %p (%p) discarded\n", Request, Request->SrvOpenKey, Request->SrvOpen);
6088 
6091  }
6092 }
struct _Entry Entry
Definition: kefuncs.h:627
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define RxFreePool
Definition: ntrxdef.h:26
_In_ NDIS_HANDLE _In_ PNDIS_REQUEST Request
Definition: ndis.h:5173
void DPRINT(...)
Definition: polytest.cpp:61
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
VOID RxPrepareRequestForReuse(PCHANGE_BUFFERING_STATE_REQUEST Request)
Definition: rxce.c:6607
Definition: typedefs.h:118
base of all file and directory entries
Definition: entries.h:82
#define PAGED_CODE()

Referenced by RxCompleteSrvOpenKeyAssociation(), RxGatherRequestsForSrvOpen(), and RxPurgeChangeBufferingStateRequestsForSrvOpen().

◆ RxpLookupSrvOpenForRequestLite()

NTSTATUS RxpLookupSrvOpenForRequestLite ( _In_ PSRV_CALL  SrvCall,
_Inout_ PCHANGE_BUFFERING_STATE_REQUEST  Request 
)

◆ RxPostStackOverflowRead()

NTSTATUS RxPostStackOverflowRead ( _In_ PRX_CONTEXT  RxContext)

◆ RxpPrepareCreateContextForReuse()

VOID RxpPrepareCreateContextForReuse ( _In_ PRX_CONTEXT  RxContext)

◆ RxPrefixClaim()

NTSTATUS RxPrefixClaim ( _In_ PRX_CONTEXT  RxContext)

◆ RxPrepareRequestForReuse()

VOID RxPrepareRequestForReuse ( PCHANGE_BUFFERING_STATE_REQUEST  Request)

Definition at line 6607 of file rxce.c.

6609 {
6610  PSRV_OPEN SrvOpen;
6611 
6612  PAGED_CODE();
6613 
6614  SrvOpen = Request->SrvOpen;
6615 
6616  /* If the request was already prepared for service */
6618  {
6619  /* We have to dereference the associated SRV_OPEN depending on the lock */
6620  if (RxIsFcbAcquiredExclusive(SrvOpen->pFcb))
6621  {
6623  }
6624  else
6625  {
6627  }
6628  }
6629  /* Otherwise, just dereference */
6630  else if (SrvOpen != NULL)
6631  {
6633  }
6634 
6635  Request->SrvOpen = NULL;
6636 }
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
_In_ NDIS_HANDLE _In_ PNDIS_REQUEST Request
Definition: ndis.h:5173
smooth NULL
Definition: ftsmooth.c:416
#define RX_REQUEST_PREPARED_FOR_HANDLING
Definition: buffring.h:4
#define RxDereferenceSrvOpen(SrvOpen, LockHoldingState)
Definition: fcb.h:427
Definition: fcb.h:260
#define RxIsFcbAcquiredExclusive(Fcb)
Definition: rxprocs.h:229
#define PAGED_CODE()

Referenced by RxpDiscardChangeBufferingStateRequests().

◆ RxPrepareToReparseSymbolicLink()

NTSTATUS NTAPI RxPrepareToReparseSymbolicLink ( PRX_CONTEXT  RxContext,
BOOLEAN  SymbolicLinkEmbeddedInOldPath,
PUNICODE_STRING  NewPath,
BOOLEAN  NewPathIsAbsolute,
PBOOLEAN  ReparseRequired 
)

Definition at line 7825 of file rdbss.c.

7831 {
7832  PWSTR NewBuffer;
7833  USHORT NewLength;
7835 
7836  /* Assume no reparse is required first */
7837  *ReparseRequired = FALSE;
7838 
7839  /* Only supported for IRP_MJ_CREATE */
7840  if (RxContext->MajorFunction != IRP_MJ_CREATE)
7841  {
7842  return STATUS_INVALID_PARAMETER;
7843  }
7844 
7845  /* If symbolic link is not embedded, and DELETE is specified, fail */
7846  if (!SymbolicLinkEmbeddedInOldPath)
7847  {
7848  /* Excepted if DELETE is the only flag specified, then, open has to succeed
7849  * See: https://msdn.microsoft.com/en-us/library/windows/hardware/ff554649(v=vs.85).aspx (remarks)
7850  */
7851  if (BooleanFlagOn(RxContext->Create.NtCreateParameters.DesiredAccess, DELETE) &&
7852  BooleanFlagOn(RxContext->Create.NtCreateParameters.DesiredAccess, ~DELETE))
7853  {
7854  return STATUS_ACCESS_DENIED;
7855  }
7856  }
7857 
7858  /* At that point, assume reparse will be required */
7859  *ReparseRequired = TRUE;
7860 
7861  /* If new path isn't absolute, it's up to us to make it absolute */
7862  if (!NewPathIsAbsolute)
7863  {
7864  /* The prefix will be \Device\Mup */
7865  NewLength = NewPath->Length + (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL));
7867  RX_MISC_POOLTAG);
7868  if (NewBuffer == NULL)
7869  {
7871  }
7872 
7873  /* Copy data for the new path */
7874  RtlMoveMemory(NewBuffer, L"\\Device\\Mup", (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL)));
7875  RtlMoveMemory(Add2Ptr(NewBuffer, (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL))),
7876  NewPath->Buffer, NewPath->Length);
7877  }
7878  /* Otherwise, use caller path as it */
7879  else
7880  {
7881  NewLength = NewPath->Length;
7882  NewBuffer = NewPath->Buffer;
7883  }
7884 
7885  /* Get the FILE_OBJECT we'll modify */
7886  FileObject = RxContext->CurrentIrpSp->FileObject;
7887 
7888  /* Free old path first */
7889  ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
7890  /* And setup new one */
7891  FileObject->FileName.Length = NewLength;
7892  FileObject->FileName.MaximumLength = NewLength;
7893  FileObject->FileName.Buffer = NewBuffer;
7894 
7895  /* And set reparse flag */
7896  SetFlag(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_REPARSE);
7897 
7898  /* Done! */
7899  return STATUS_SUCCESS;
7900 }
#define TRUE
Definition: types.h:120
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define Add2Ptr(PTR, INC)
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
uint16_t * PWSTR
Definition: typedefs.h:55
struct _RX_CONTEXT::@2109::@2121 Create
#define POOL_COLD_ALLOCATION
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
static USHORT USHORT * NewLength
#define UNICODE_NULL
smooth NULL
Definition: ftsmooth.c:416
UCHAR MajorFunction
Definition: rxcontx.h:105
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:588
#define RX_MISC_POOLTAG
Definition: rxpooltg.h:10
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
* PFILE_OBJECT
Definition: iotypes.h:1957
PIO_STACK_LOCATION CurrentIrpSp
Definition: rxcontx.h:111
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
static const WCHAR L[]
Definition: oid.c:1250
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
PFILE_OBJECT FileObject
Definition: iotypes.h:2815
unsigned short USHORT
Definition: pedump.c:61
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define DELETE
Definition: nt_native.h:57

◆ RxPrePostIrp()

VOID RxPrePostIrp ( _In_ PVOID  Context,
_In_ PIRP  Irp 
)

Referenced by RxConstructSrvCall().

◆ RxProcessChangeBufferingStateRequestsForSrvOpen()

VOID RxProcessChangeBufferingStateRequestsForSrvOpen ( PSRV_OPEN  SrvOpen)

Definition at line 6655 of file rxce.c.

6657 {
6658  LONG NumberOfBufferingChangeRequests, LockedOldBufferingToken, OldBufferingToken;
6659 
6660  /* Get the current number of change requests */
6661  NumberOfBufferingChangeRequests = ((PSRV_CALL)SrvOpen->pVNetRoot->pNetRoot->pSrvCall)->BufferingManager.CumulativeNumberOfBufferingChangeRequests;
6662  /* Get our old token */
6663  OldBufferingToken = SrvOpen->BufferingToken;
6664  LockedOldBufferingToken = InterlockedCompareExchange(&SrvOpen->BufferingToken,
6665  NumberOfBufferingChangeRequests,
6666  NumberOfBufferingChangeRequests);
6667  /* If buffering state changed in between, process changes */
6668  if (OldBufferingToken != LockedOldBufferingToken)
6669  {
6670  PFCB Fcb;
6671  NTSTATUS Status;
6672 
6673  /* Acquire the FCB and start processing */
6674  Fcb = (PFCB)SrvOpen->pFcb;
6676  if (Status == STATUS_SUCCESS)
6677  {
6679  RxReleaseFcb(NULL, Fcb);
6680  }
6681  }
6682 }
#define RxAcquireExclusiveFcb(R, F)
Definition: rxprocs.h:154
struct _SRV_CALL * PSRV_CALL
Definition: cdstruc.h:908
LONG NTSTATUS
Definition: precomp.h:26
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define RxReleaseFcb(R, F)
Definition: rxprocs.h:186
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
FCB * PFCB
Definition: cdstruc.h:1046
VOID RxProcessFcbChangeBufferingStateRequest(PFCB Fcb)
Definition: rxce.c:6685
volatile LONG BufferingToken
Definition: fcb.h:276
Status
Definition: gdiplustypes.h:24
_In_ PFCB Fcb
Definition: cdprocs.h:159
return STATUS_SUCCESS
Definition: btrfs.c:3014

Referenced by RxFastIoCheckIfPossible().

◆ RxPurgeFcb()

VOID RxPurgeFcb ( _In_ PFCB  Fcb)

◆ RxPurgeFobx()

BOOLEAN RxPurgeFobx ( PFOBX  pFobx)

Definition at line 7051 of file rxce.c.

7053 {
7054  NTSTATUS Status;
7055  PFCB FcbToBePurged;
7056 
7057  PAGED_CODE();
7058 
7059  /* Get the associated FCB */
7060  FcbToBePurged = (PFCB)pFobx->pSrvOpen->pFcb;
7061  Status = RxAcquireExclusiveFcb(NULL, FcbToBePurged);
7063 
7064  /* Purge it */
7065  Status = RxPurgeFcbInSystemCache(FcbToBePurged, NULL, 0, FALSE, TRUE);
7066  if (Status != STATUS_SUCCESS)
7067  {
7068  DPRINT1("Purge failed for %p (%p)\n", FcbToBePurged, pFobx);
7069  return FALSE;
7070  }
7071 
7072  /* And flush */
7073  if (!MmFlushImageSection(&FcbToBePurged->NonPaged->SectionObjectPointers, MmFlushForWrite))
7074  {
7075  DPRINT1("Image section flush failed for %p (%p)\n", FcbToBePurged, pFobx);
7076  return FALSE;
7077  }
7078 
7079  DPRINT("Purge OK for %p (%p)\n", FcbToBePurged, pFobx);
7080  return TRUE;
7081 }
#define RxAcquireExclusiveFcb(R, F)
Definition: rxprocs.h:154
#define TRUE
Definition: types.h:120
Definition: cdstruc.h:908
LONG NTSTATUS
Definition: precomp.h:26
SECTION_OBJECT_POINTERS SectionObjectPointers
Definition: fatstruc.h:728
PNON_PAGED_FCB NonPaged
Definition: fatstruc.h:810
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
BOOLEAN NTAPI MmFlushImageSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN MMFLUSH_TYPE FlushType)
Definition: section.c:4798
FCB * PFCB
Definition: cdstruc.h:1046
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Status
Definition: gdiplustypes.h:24
#define DPRINT1
Definition: precomp.h:8
return STATUS_SUCCESS
Definition: btrfs.c:3014
NTSTATUS RxPurgeFcbInSystemCache(IN PFCB Fcb, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps, IN BOOLEAN FlushFile)
Definition: rxce.c:6998
#define PAGED_CODE()

Referenced by RxPurgeRelatedFobxs().

◆ RxPurgeFobxFromCache()

NTSTATUS RxPurgeFobxFromCache ( PFOBX  FobxToBePurged)

Definition at line 7087 of file rxce.c.

7089 {
7090  NTSTATUS Status;
7091  PFCB FcbToBePurged;
7092 
7093  PAGED_CODE();
7094 
7095  FcbToBePurged = (PFCB)FobxToBePurged->pSrvOpen->pFcb;
7096  ASSERT(FcbToBePurged != NULL);
7097 
7098  /* If we cannot have our FCB exclusively, give up */
7099  Status = RxAcquireExclusiveFcb(NULL, FcbToBePurged);
7100  if (Status != STATUS_SUCCESS)
7101  {
7102  RxDereferenceNetFobx(FobxToBePurged, LHS_LockNotHeld);
7103  return Status;
7104  }
7105 
7106  /* Don't let the FCB disappear */
7107  RxReferenceNetFcb(FcbToBePurged);
7108 
7109  /* If the SRV_OPEN was already closed, or if there are unclean FOBX, give up */
7110  if (BooleanFlagOn(FobxToBePurged->Flags, FOBX_FLAG_SRVOPEN_CLOSED) || FobxToBePurged->pSrvOpen->UncleanFobxCount != 0)
7111  {
7112  DPRINT("FCB purge skipped\n");
7113  }
7114  else
7115  {
7116  Status = RxPurgeFcbInSystemCache(FcbToBePurged, NULL, 0, FALSE, TRUE);
7117  }
7118 
7120  /* Drop our extra reference */
7121  if (!RxDereferenceAndFinalizeNetFcb(FcbToBePurged, NULL, FALSE, FALSE))
7122  {
7123  RxReleaseFcb(NULL, FcbToBePurged);
7124  }
7125 
7126  return Status;
7127 }
#define RxReferenceNetFcb(Fcb)
Definition: fcb.h:431
#define RxAcquireExclusiveFcb(R, F)
Definition: rxprocs.h:154
#define TRUE
Definition: types.h:120
#define FOBX_FLAG_SRVOPEN_CLOSED
Definition: fcb.h:296
Definition: cdstruc.h:908
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
LONG NTSTATUS
Definition: precomp.h:26
#define RxDereferenceNetFobx(Fobx, LockHoldingState)
Definition: fcb.h:419
#define RxReleaseFcb(R, F)
Definition: rxprocs.h:186
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
FCB * PFCB
Definition: cdstruc.h:1046
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define RxDereferenceAndFinalizeNetFcb(Fcb, RxContext, RecursiveFinalize, ForceFinalize)
Definition: fcb.h:439
Status
Definition: gdiplustypes.h:24
return STATUS_SUCCESS
Definition: btrfs.c:3014
NTSTATUS RxPurgeFcbInSystemCache(IN PFCB Fcb, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps, IN BOOLEAN FlushFile)
Definition: rxce.c:6998
#define PAGED_CODE()

Referenced by RxMarkFobxOnCleanup().

◆ RxpWorkerThreadDispatcher()

VOID RxpWorkerThreadDispatcher ( _In_ PRX_WORK_QUEUE  WorkQueue,
_In_ PLARGE_INTEGER  WaitInterval 
)

◆ RxReference()

VOID RxReference ( _Inout_ PVOID  Instance)

◆ RxReleaseFcbFromLazyWrite()

VOID NTAPI RxReleaseFcbFromLazyWrite ( _In_ PVOID  Null)

◆ RxReleaseFcbFromReadAhead()

VOID NTAPI RxReleaseFcbFromReadAhead ( _In_ PVOID  Null)

◆ RxRemoveShareAccessPerSrvOpens()

VOID RxRemoveShareAccessPerSrvOpens ( _Inout_ PSRV_OPEN  SrvOpen)

◆ RxRemoveVirtualNetRootFromNetRoot()

VOID RxRemoveVirtualNetRootFromNetRoot ( _In_ PNET_ROOT  NetRoot,
_In_ PV_NET_ROOT  VNetRoot 
)

◆ RxSpinUpRequestsDispatcher()

VOID NTAPI RxSpinUpRequestsDispatcher ( _In_ PVOID  Dispatcher)

◆ RxSpinUpWorkerThread()

NTSTATUS RxSpinUpWorkerThread ( _In_ PRX_WORK_QUEUE  WorkQueue,
_In_ PRX_WORKERTHREAD_ROUTINE  Routine,
_In_ PVOID  Parameter 
)

◆ RxSpinUpWorkerThreads()

VOID RxSpinUpWorkerThreads ( _In_ PRX_WORK_QUEUE  WorkQueue)

◆ RxTableComputePathHashValue()

ULONG RxTableComputePathHashValue ( _In_ PUNICODE_STRING  Name)

◆ RxTableLookupName()

PVOID RxTableLookupName ( _In_ PRX_PREFIX_TABLE  ThisTable,
_In_ PUNICODE_STRING  Name,
_Out_ PUNICODE_STRING  RemainingName,
_In_opt_ PRX_CONNECTION_ID  RxConnectionId 
)

◆ RxTableLookupName_ExactLengthMatch()

PRX_PREFIX_ENTRY RxTableLookupName_ExactLengthMatch ( _In_ PRX_PREFIX_TABLE  ThisTable,
_In_ PUNICODE_STRING  Name,
_In_ ULONG  HashValue,
_In_opt_ PRX_CONNECTION_ID  RxConnectionId 
)

◆ RxTrackPagingIoResource()

VOID RxTrackPagingIoResource ( _Inout_ PVOID  Instance,
_In_ ULONG  Type,
_In_ ULONG  Line,
_In_ PCSTR  File 
)

Definition at line 8654 of file rxce.c.

8659 {
8660  UNIMPLEMENTED;
8661 }
#define UNIMPLEMENTED
Definition: debug.h:115

◆ RxUndoScavengerFinalizationMarking()

VOID RxUndoScavengerFinalizationMarking ( PVOID  Instance)

Definition at line 8667 of file rxce.c.

8669 {
8670  /* Just call internal routine with mutex held */
8674 }
#define RxAcquireScavengerMutex()
Definition: scavengr.h:26
VOID RxpUndoScavengerFinalizationMarking(PVOID Instance)
Definition: rxce.c:6862
#define RxReleaseScavengerMutex()
Definition: scavengr.h:27
IN PVOID Instance
Definition: pci.h:361

Referenced by RxProcessChangeBufferingStateRequests().

◆ RxUnload()

VOID NTAPI RxUnload ( _In_ PDRIVER_OBJECT  DriverObject)

Referenced by nfs41_driver_unload().

◆ RxUnlockOperation()

VOID NTAPI RxUnlockOperation ( _In_ PVOID  Context,
_In_ PFILE_LOCK_INFO  LockInfo 
)

◆ RxUpdateCondition()

VOID RxUpdateCondition ( _In_ RX_BLOCK_CONDITION  NewConditionValue,
_Out_ PRX_BLOCK_CONDITION  Condition,
_In_ OUT PLIST_ENTRY  TransitionWaitList 
)

◆ RxUpdateShareAccessPerSrvOpens()

VOID RxUpdateShareAccessPerSrvOpens ( _In_ PSRV_OPEN  SrvOpen)

◆ RxVerifyOperationIsLegal()

VOID RxVerifyOperationIsLegal ( _In_ PRX_CONTEXT  RxContext)

◆ RxWaitForStableCondition()

VOID RxWaitForStableCondition ( _In_ PRX_BLOCK_CONDITION  Condition,
_Inout_ PLIST_ENTRY  TransitionWaitList,
_Inout_ PRX_CONTEXT  RxContext,
_Out_opt_ NTSTATUS AsyncStatus 
)

Variable Documentation

◆ RxNull

PVOID RxNull

Definition at line 118 of file rxce.c.

Referenced by RxFsdCommonDispatch().