#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:

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:

ExAcquireResourceExclusiveLite((Fcb)->Header.PagingIoResource, TRUE); \
    if (RxContext != NULL)                                                \
    {                                                                     \
        (RxContext)->FcbPagingIoResourceAcquired = TRUE;                  \
    }                                                                     \
    RxTrackPagingIoResource(Fcb, 1, __LINE__, __FILE__)

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__);              \
    }

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:

(ExIsResourceAcquiredSharedLite((Fcb)->Header.Resource) || \

ExIsResourceAcquiredExclusiveLite((Fcb)->Header.Resource))

Header

Definition: Header.h:8

ExIsResourceAcquiredSharedLite

ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)

Definition: resource.c:1658

Fcb

_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 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 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

typedef enum _RX_NAME_CONJURING_METHODS RX_NAME_CONJURING_METHODS

Enumeration Type Documentation

◆ _RX_NAME_CONJURING_METHODS

enum _RX_NAME_CONJURING_METHODS

Enumerator
VNetRoot_As_Prefix
VNetRoot_As_UNC_Name
VNetRoot_As_DriveLetter

Definition at line 78 of file rxprocs.h.

 {
     VNetRoot_As_Prefix,
     VNetRoot_As_UNC_Name,
     VNetRoot_As_DriveLetter
 } RX_NAME_CONJURING_METHODS;

Function Documentation

◆ __RxAcquireFcb()

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

Definition at line 8973 of file rxce.c.

 {
     NTSTATUS Status;
     BOOLEAN SpecialContext, CanWait, Acquired, ContextIsPresent;
 
     PAGED_CODE();
 
     DPRINT("__RxAcquireFcb(%p, %p, %d, %d, %s, %d)\n", Fcb, RxContext, Mode, LineNumber, FileName, SerialNumber);
 
     SpecialContext = FALSE;
     ContextIsPresent = FALSE;
     /* Check for special context */
     if (RxContext == CHANGE_BUFFERING_STATE_CONTEXT || RxContext == CHANGE_BUFFERING_STATE_CONTEXT_WAIT)
     {
         SpecialContext = TRUE;
     }
 
     /* We don't handle buffering state change yet... */
     if (!RxIsFcbAcquired(Fcb) && !SpecialContext &&
         BooleanFlagOn(Fcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING))
     {
         UNIMPLEMENTED;
     }
 
     /* Nor special contexts */
     if (SpecialContext)
     {
         UNIMPLEMENTED;
     }
 
     /* If we don't have a context, assume we can wait! */
     if (RxContext == NULL)
     {
         CanWait = TRUE;
     }
     else
     {
         /* That said: we have a real context! */
         ContextIsPresent = TRUE;
 
         /* If we've been cancelled in between, give up */
         Status = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_CANCELLED) ? STATUS_CANCELLED : STATUS_SUCCESS;
         if (!NT_SUCCESS(Status))
         {
             return Status;
         }
 
         /* Can we wait? */
         CanWait = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
     }
 
     while (TRUE)
     {
         /* Assume we cannot lock */
         Status = STATUS_LOCK_NOT_GRANTED;
 
         /* Lock according to what the caller asked */
         switch (Mode)
         {
             case FCB_MODE_EXCLUSIVE:
                 Acquired = ExAcquireResourceExclusiveLite(Fcb->Header.Resource, CanWait);
                 break;
 
             case FCB_MODE_SHARED:
                 Acquired = ExAcquireResourceSharedLite(Fcb->Header.Resource, CanWait);
                 break;
 
             case FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE:
                 Acquired = ExAcquireSharedWaitForExclusive(Fcb->Header.Resource, CanWait);
                 break;
 
             default:
                 ASSERT(Mode == FCB_MODE_SHARED_STARVE_EXCLUSIVE);
                 Acquired = ExAcquireSharedStarveExclusive(Fcb->Header.Resource, CanWait);
                 break;
         }
 
         /* Lock granted! */
         if (Acquired)
         {
             Status = STATUS_SUCCESS;
             ASSERT_CORRECT_FCB_STRUCTURE(Fcb);
 
             /* Handle paging write - not implemented */
             if (Fcb->NonPaged->OutstandingAsyncWrites != 0)
             {
                 UNIMPLEMENTED;
             }
         }
 
         /* And break, that cool! */
         if (Acquired)
         {
             break;
         }
 
         /* If it failed, return immediately */
         if (!NT_SUCCESS(Status))
         {
             return Status;
         }
     }
 
     /* If we don't have to check for valid operation, job done, nothing more to do */
     if (!ContextIsPresent || BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_BYPASS_VALIDOP_CHECK))
     {
         if (NT_SUCCESS(Status))
         {
             RxTrackerUpdateHistory(RxContext, RX_GET_MRX_FCB(Fcb), TRACKER_ACQUIRE_FCB, LineNumber, FileName, SerialNumber);
         }
 
         return Status;
     }
 
     /* Verify operation */
     _SEH2_TRY
     {
         RxVerifyOperationIsLegal(RxContext);
     }
     _SEH2_FINALLY
     {
         /* If it failed, release lock and fail */
         if (_SEH2_AbnormalTermination())
         {
             ExReleaseResourceLite(Fcb->Header.Resource);
             Status = STATUS_LOCK_NOT_GRANTED;
         }
     }
     _SEH2_END;
 
     if (NT_SUCCESS(Status))
     {
         RxTrackerUpdateHistory(RxContext, RX_GET_MRX_FCB(Fcb), TRACKER_ACQUIRE_FCB, LineNumber, FileName, SerialNumber);
     }
 
     DPRINT("Status: %x\n", Status);
     return Status;
 }

◆ __RxReleaseFcb()

VOID __RxReleaseFcb	(	_Inout_opt_ PRX_CONTEXT	RxContext,
		_Inout_ PMRX_FCB	MrxFcb
	)

Definition at line 9142 of file rxce.c.

 {
     BOOLEAN IsExclusive, BufferingPending;
 
     RxAcquireSerializationMutex();
 
     BufferingPending = BooleanFlagOn(MrxFcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING);
     IsExclusive = !!RxIsResourceOwnershipStateExclusive(MrxFcb->Header.Resource);
 
     /* If no buffering pending, or no exclusive lock (we can only handle with an exclusive lock),
      * then just release the FCB
      */
     if (!BufferingPending || !IsExclusive)
     {
         RxTrackerUpdateHistory(RxContext, MrxFcb, (!BufferingPending ? TRACKER_RELEASE_FCB_NO_BUFF_PENDING : TRACKER_RELEASE_NON_EXCL_FCB_BUFF_PENDING),
                                LineNumber, FileName, SerialNumber);
         ExReleaseResourceLite(MrxFcb->Header.Resource);
     }
 
     RxReleaseSerializationMutex();
 
     /* And finally leave */
     if (!BufferingPending || !IsExclusive)
     {
         return;
     }
 
     ASSERT(RxIsFcbAcquiredExclusive(MrxFcb));
 
     /* Otherwise, handle buffering state and release */
     RxProcessFcbChangeBufferingStateRequest((PFCB)MrxFcb);
 
     RxTrackerUpdateHistory(RxContext, MrxFcb, TRACKER_RELEASE_EXCL_FCB_BUFF_PENDING, LineNumber, FileName, SerialNumber);
     ExReleaseResourceLite(MrxFcb->Header.Resource);
 }

◆ __RxReleaseFcbForThread()

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

Definition at line 9188 of file rxce.c.

 {
     BOOLEAN IsExclusive, BufferingPending;
 
     RxAcquireSerializationMutex();
 
     BufferingPending = BooleanFlagOn(MrxFcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING);
     IsExclusive = !!RxIsResourceOwnershipStateExclusive(MrxFcb->Header.Resource);
 
     /* If no buffering pending, or no exclusive lock (we can only handle with an exclusive lock),
      * then just release the FCB
      */
     if (!BufferingPending || !IsExclusive)
     {
         RxTrackerUpdateHistory(RxContext, MrxFcb,
                                (!BufferingPending ? TRACKER_RELEASE_FCB_FOR_THRD_NO_BUFF_PENDING : TRACKER_RELEASE_NON_EXCL_FCB_FOR_THRD_BUFF_PENDING),
                                LineNumber, FileName, SerialNumber);
         ExReleaseResourceForThreadLite(MrxFcb->Header.Resource, ResourceThreadId);
     }
 
     RxReleaseSerializationMutex();
 
     /* And finally leave */
     if (!BufferingPending || !IsExclusive)
     {
         return;
     }
 
     /* Otherwise, handle buffering state and release */
     RxTrackerUpdateHistory(RxContext, MrxFcb, TRACKER_RELEASE_EXCL_FCB_FOR_THRD_BUFF_PENDING, LineNumber, FileName, SerialNumber);
     RxProcessFcbChangeBufferingStateRequest((PFCB)MrxFcb);
     ExReleaseResourceForThreadLite(MrxFcb->Header.Resource, ResourceThreadId);
 }

◆ RxAcquireFcbForLazyWrite()

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

Referenced by RxInitializeDispatchVectors().

◆ RxAcquireFcbForReadAhead()

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

Referenced by RxInitializeDispatchVectors().

◆ 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.

 {
     PFCB Fcb;
     NTSTATUS Status, MiniStatus;
     ULONG NewBufferingState, OldBufferingState;
 
     PAGED_CODE();
 
     DPRINT("RxChangeBufferingState(%p, %p, %d)\n", SrvOpen, Context, ComputeNewState);
 
     Fcb = (PFCB)SrvOpen->pFcb;
     ASSERT(NodeTypeIsFcb(Fcb));
     /* First of all, mark that buffering state is changing */
     SetFlag(Fcb->FcbState, FCB_STATE_BUFFERSTATE_CHANGING);
 
     /* Assume success */
     Status = STATUS_SUCCESS;
     _SEH2_TRY
     {
         /* If we're asked to compute a new state, ask the mini-rdr for it */
         if (ComputeNewState)
         {
             MINIRDR_CALL_THROUGH(MiniStatus, Fcb->MRxDispatch, MRxComputeNewBufferingState,
                                  ((PMRX_SRV_OPEN)SrvOpen, Context, &NewBufferingState));
             if (MiniStatus != STATUS_SUCCESS)
             {
                 NewBufferingState = 0;
             }
         }
         else
         {
             /* If not, use SRV_OPEN state */
             NewBufferingState = SrvOpen->BufferingFlags;
         }
 
         /* If no shared access, and if we're not asked to compute a new state, use maximum flags set */
         if ((Fcb->ShareAccess.SharedRead + Fcb->ShareAccess.SharedWrite + Fcb->ShareAccess.SharedDelete) == 0 && !ComputeNewState)
         {
             SetFlag(NewBufferingState, FCB_STATE_BUFFERING_STATE_WITH_NO_SHARES);
         }
 
         /* If there's a lock operation to complete, clear that flag */
         if (Fcb->OutstandingLockOperationsCount != 0)
         {
             ClearFlag(NewBufferingState, FCB_STATE_LOCK_BUFFERING_ENABLED);
         }
 
         /* Get the old state */
         OldBufferingState = Fcb->FcbState & FCB_STATE_BUFFERING_STATE_MASK;
         DPRINT("ChangeBufferingState %x -> %x (%x)\n", OldBufferingState, NewBufferingState, SrvOpen->BufferingFlags);
 
         /* If we're dropping write cache, then flush the FCB */
         if (BooleanFlagOn(OldBufferingState, FCB_STATE_WRITECACHING_ENABLED) &&
             !BooleanFlagOn(NewBufferingState, FCB_STATE_WRITECACHING_ENABLED))
         {
             DPRINT("Flushing\n");
 
             Status = RxFlushFcbInSystemCache(Fcb, TRUE);
         }
 
         /* If we're dropping read cache, then purge */
         if (Fcb->UncleanCount == 0 ||
             (BooleanFlagOn(OldBufferingState, FCB_STATE_READCACHING_ENABLED) &&
              !BooleanFlagOn(NewBufferingState, FCB_STATE_READCACHING_ENABLED)) ||
             BooleanFlagOn(NewBufferingState, FCB_STATE_DELETE_ON_CLOSE))
         {
             DPRINT("Purging\n");
 
             if (!NT_SUCCESS(Status))
             {
                  DPRINT("Previous flush failed with status: %lx\n", Status);
             }
 
             CcPurgeCacheSection(&Fcb->NonPaged->SectionObjectPointers, NULL, 0, TRUE);
         }
 
         /* If there's already a change pending in SRV_OPEN */
         if (ComputeNewState && BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING))
         {
             /* If there's a FOBX at least */
             if (!IsListEmpty(&SrvOpen->FobxList))
             {
                 PRX_CONTEXT RxContext;
 
                 /* Create a fake context to pass to the mini-rdr */
                 RxContext = RxCreateRxContext(NULL, Fcb->RxDeviceObject, RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING | RX_CONTEXT_FLAG_WAIT);
                 if (RxContext != NULL)
                 {
                     PFOBX Fobx;
 
                     RxContext->pFcb = RX_GET_MRX_FCB(Fcb);
 
                     /* Give the first FOBX */
                     Fobx = CONTAINING_RECORD(SrvOpen->FobxList.Flink, FOBX, FobxQLinks);
                     RxContext->pFobx = (PMRX_FOBX)Fobx;
                     RxContext->pRelevantSrvOpen = Fobx->pSrvOpen;
 
                     /* If there was a delayed close, perform it */
                     if (BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_CLOSE_DELAYED))
                     {
                         DPRINT("Oplock break close for %p\n", SrvOpen);
 
                         RxCloseAssociatedSrvOpen(Fobx, RxContext);
                     }
                     /* Otherwise, inform the mini-rdr about completion */
                     else
                     {
                         MINIRDR_CALL_THROUGH(MiniStatus, Fcb->MRxDispatch, MRxCompleteBufferingStateChangeRequest,
                                              (RxContext, (PMRX_SRV_OPEN)SrvOpen, Context));
                         (void)MiniStatus;
                     }
 
                     RxDereferenceAndDeleteRxContext(RxContext);
                 }
             }
         }
 
         /* Set the new state */
         Fcb->FcbState ^= (NewBufferingState ^ Fcb->FcbState) & FCB_STATE_BUFFERING_STATE_MASK;
     }
     _SEH2_FINALLY
     {
         /* Job done, clear the flag */
         ClearFlag(Fcb->FcbState, FCB_STATE_BUFFERSTATE_CHANGING);
 
         if (!BooleanFlagOn(NewBufferingState, FCB_STATE_FILETIMECACHEING_ENABLED))
         {
             ClearFlag(Fcb->FcbState, FCB_STATE_TIME_AND_SIZE_ALREADY_SET);
         }
     }
     _SEH2_END;
 
     return Status;
 }

Referenced by enable_caching(), and RxCreateFromNetRoot().

◆ RxCheckFcbStructuresForAlignment()

VOID NTAPI RxCheckFcbStructuresForAlignment ( VOID )

Definition at line 1447 of file rdbss.c.

 {
     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
	)

Referenced by RxChangeBufferingState(), and RxFinalizeNetFobx().

◆ RxCompleteMdl()

NTSTATUS NTAPI RxCompleteMdl ( _In_ PRX_CONTEXT RxContext )

◆ RxCompleteRequest()

NTSTATUS RxCompleteRequest	(	_In_ PRX_CONTEXT	pContext,
		_In_ NTSTATUS	Status
	)

Referenced by RxCancelOperationInOverflowQueue(), RxCompleteMdl(), and RxFspDispatch().

◆ 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
	)

Referenced by RxCanonicalizeNameAndObtainNetRoot(), RxCreateTreeConnect(), and RxPrefixClaim().

◆ 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.

 {
     PVOID Container;
     PSRV_CALL SrvCall;
     PNET_ROOT NetRoot;
     PV_NET_ROOT VNetRoot;
     NTSTATUS Status = STATUS_UNSUCCESSFUL;
     PRX_PREFIX_TABLE PrefixTable;
     UNICODE_STRING RemainingName, NetRootName;
 
     PAGED_CODE();
 
     DPRINT("RxFindOrCreateConnections(%p, %wZ, %x, %p, %p, %p, %p)\n",
            RxContext, CanonicalName, NetRootType, LocalNetRootName,
            FilePathName, LockState, RxConnectionId);
 
     *FilePathName = *CanonicalName;
     LocalNetRootName->Length = 0;
     LocalNetRootName->MaximumLength = 0;
     LocalNetRootName->Buffer = CanonicalName->Buffer;
 
     /* UNC path, split it */
     if (FilePathName->Buffer[1] == ';')
     {
         BOOLEAN Slash;
         USHORT i, Length;
 
         Slash = FALSE;
         for (i = 2; i < FilePathName->Length / sizeof(WCHAR); ++i)
         {
             if (FilePathName->Buffer[i] == OBJ_NAME_PATH_SEPARATOR)
             {
                 Slash = TRUE;
                 break;
             }
         }
 
         if (!Slash)
         {
             return STATUS_OBJECT_NAME_INVALID;
         }
 
         FilePathName->Buffer = &FilePathName->Buffer[i];
         Length = (USHORT)((ULONG_PTR)FilePathName->Buffer - (ULONG_PTR)LocalNetRootName->Buffer);
         LocalNetRootName->Length = Length;
         LocalNetRootName->MaximumLength = Length;
         FilePathName->Length -= Length;
 
         DPRINT("CanonicalName: %wZ\n", CanonicalName);
         DPRINT(" -> FilePathName: %wZ\n", FilePathName);
         DPRINT(" -> LocalNetRootName: %wZ\n", LocalNetRootName);
     }
 
     Container = NULL;
     PrefixTable = RxContext->RxDeviceObject->pRxNetNameTable;
 
     _SEH2_TRY
     {
 RetryLookup:
         ASSERT(*LockState != LHS_LockNotHeld);
 
         /* If previous lookup left something, dereference it */
         if (Container != NULL)
         {
             switch (NodeType(Container))
             {
                 case RDBSS_NTC_SRVCALL:
                     RxDereferenceSrvCall(Container, *LockState);
                     break;
 
                 case RDBSS_NTC_NETROOT:
                     RxDereferenceNetRoot(Container, *LockState);
                     break;
 
                 case RDBSS_NTC_V_NETROOT:
                     RxDereferenceVNetRoot(Container, *LockState);
                     break;
 
                 default:
                     /* Should never happen */
                     ASSERT(FALSE);
                     break;
             }
         }
 
         /* Look for our NetRoot in prefix table */
         Container = RxPrefixTableLookupName(PrefixTable, FilePathName, &RemainingName, RxConnectionId);
         DPRINT("Container %p for path %wZ\n", Container, FilePathName);
 
         while (TRUE)
         {
             UNICODE_STRING SrvCallName;
 
             SrvCall = NULL;
             NetRoot = NULL;
             VNetRoot = NULL;
 
             /* Assume we didn't succeed */
             RxContext->Create.pVNetRoot = NULL;
             RxContext->Create.pNetRoot = NULL;
             RxContext->Create.pSrvCall = NULL;
             RxContext->Create.Type = NetRootType;
 
             /* If we found something */
             if (Container != NULL)
             {
                 /* A VNetRoot */
                 if (NodeType(Container) == RDBSS_NTC_V_NETROOT)
                 {
                     VNetRoot = Container;
                     /* Use its NetRoot */
                     NetRoot = VNetRoot->NetRoot;
 
                     /* If it's not stable, wait for it to be stable */
                     if (NetRoot->Condition == Condition_InTransition)
                     {
                         RxReleasePrefixTableLock(PrefixTable);
                         DPRINT("Waiting for stable condition for: %p\n", NetRoot);
                         RxWaitForStableNetRoot(NetRoot, RxContext);
                         RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                         *LockState = LHS_ExclusiveLockHeld;
 
                         /* Now that's it's ok, retry lookup to find what we want */
                         if (NetRoot->Condition == Condition_Good)
                         {
                             goto RetryLookup;
                         }
                     }
 
                     /* Is the associated netroot good? */
                     if (NetRoot->Condition == Condition_Good)
                     {
                         SrvCall = (PSRV_CALL)NetRoot->pSrvCall;
 
                         /* If it is, and SrvCall as well, then, we have our active connection */
                         if (SrvCall->Condition == Condition_Good &&
                             SrvCall->RxDeviceObject == RxContext->RxDeviceObject)
                         {
                             RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
                             RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
                             RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
 
                             Status = STATUS_CONNECTION_ACTIVE;
                             _SEH2_LEAVE;
                         }
                     }
 
                     /* If VNetRoot was well constructed, it means the connection is active */
                     if (VNetRoot->ConstructionStatus == STATUS_SUCCESS)
                     {
                         Status = STATUS_CONNECTION_ACTIVE;
                     }
                     else
                     {
                         Status = VNetRoot->ConstructionStatus;
                     }
 
                     RxDereferenceVNetRoot(VNetRoot, *LockState);
                     _SEH2_LEAVE;
                 }
                 /* Can only be a SrvCall */
                 else
                 {
                     ASSERT(NodeType(Container) == RDBSS_NTC_SRVCALL);
                     SrvCall = Container;
 
                     /* Wait for the SRV_CALL to be stable */
                     if (SrvCall->Condition == Condition_InTransition)
                     {
                         RxReleasePrefixTableLock(PrefixTable);
                         DPRINT("Waiting for stable condition for: %p\n", SrvCall);
                         RxWaitForStableSrvCall(SrvCall, RxContext);
                         RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                         *LockState = LHS_ExclusiveLockHeld;
 
                         /* It went good, loop again to find what we look for */
                         if (SrvCall->Condition == Condition_Good)
                         {
                             goto RetryLookup;
                         }
                     }
 
                     /* If it's not good... */
                     if (SrvCall->Condition != Condition_Good)
                     {
                         /* But SRV_CALL was well constructed, assume a connection was active */
                         if (SrvCall->Status == STATUS_SUCCESS)
                         {
                             Status = STATUS_CONNECTION_ACTIVE;
                         }
                         else
                         {
                             Status = SrvCall->Status;
                         }
 
                         RxDereferenceSrvCall(SrvCall, *LockState);
                         _SEH2_LEAVE;
                     }
                 }
             }
 
             /* If we found a SRV_CALL not matching our DO, quit */
             if (SrvCall != NULL && SrvCall->Condition == Condition_Good &&
                 SrvCall->RxDeviceObject != RxContext->RxDeviceObject)
             {
                 RxDereferenceSrvCall(SrvCall, *LockState);
                 Status = STATUS_BAD_NETWORK_NAME;
                 _SEH2_LEAVE;
             }
 
             /* Now, we want exclusive lock */
             if (*LockState == LHS_SharedLockHeld)
             {
                 if (!RxAcquirePrefixTableLockExclusive(PrefixTable, FALSE))
                 {
                     RxReleasePrefixTableLock(PrefixTable);
                     RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                     *LockState = LHS_ExclusiveLockHeld;
                     goto RetryLookup;
                 }
 
                 RxReleasePrefixTableLock(PrefixTable);
                 *LockState = LHS_ExclusiveLockHeld;
             }
 
             ASSERT(*LockState == LHS_ExclusiveLockHeld);
 
             /* If we reach that point, we found something, no need to create something */
             if (Container != NULL)
             {
                 break;
             }
 
             /* Get the name for the SRV_CALL */
             RxExtractServerName(FilePathName, &SrvCallName, NULL);
             DPRINT(" -> SrvCallName: %wZ\n", &SrvCallName);
             /* And create the SRV_CALL */
             SrvCall = RxCreateSrvCall(RxContext, &SrvCallName, NULL, RxConnectionId);
             if (SrvCall == NULL)
             {
                 Status = STATUS_INSUFFICIENT_RESOURCES;
                 _SEH2_LEAVE;
             }
 
             /* Reset RX_CONTEXT, so far, connection creation isn't a success */
             RxReferenceSrvCall(SrvCall);
             RxContext->Create.pVNetRoot = NULL;
             RxContext->Create.pNetRoot = NULL;
             RxContext->Create.pSrvCall = NULL;
             RxContext->Create.Type = NetRootType;
             Container = SrvCall;
 
             /* Construct SRV_CALL, ie, use mini-rdr */
             Status = RxConstructSrvCall(RxContext, SrvCall, LockState);
             ASSERT(Status != STATUS_SUCCESS || RxIsPrefixTableLockAcquired(PrefixTable));
             if (Status != STATUS_SUCCESS)
             {
                 DPRINT1("RxConstructSrvCall() = Status: %x\n", Status);
                 RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                 RxDereferenceSrvCall(SrvCall, *LockState);
                 RxReleasePrefixTableLock(PrefixTable);
                 _SEH2_LEAVE;
             }
 
             /* Loop again to make use of SRV_CALL stable condition wait */
         }
 
         /* At that point, we have a stable SRV_CALL (either found or constructed) */
         ASSERT((NodeType(SrvCall) == RDBSS_NTC_SRVCALL) && (SrvCall->Condition == Condition_Good));
         ASSERT(NetRoot == NULL && VNetRoot == NULL);
         ASSERT(SrvCall->RxDeviceObject == RxContext->RxDeviceObject);
 
         /* Call mini-rdr to get NetRoot name */
         SrvCall->RxDeviceObject->Dispatch->MRxExtractNetRootName(FilePathName, (PMRX_SRV_CALL)SrvCall, &NetRootName, NULL);
         /* And create the NetRoot with that name */
         NetRoot = RxCreateNetRoot(SrvCall, &NetRootName, 0, RxConnectionId);
         if (NetRoot == NULL)
         {
             Status = STATUS_INSUFFICIENT_RESOURCES;
             _SEH2_LEAVE;
         }
         NetRoot->Type = NetRootType;
 
         RxDereferenceSrvCall(SrvCall, *LockState);
 
         /* Finally, create the associated VNetRoot */
         VNetRoot = RxCreateVNetRoot(RxContext, NetRoot, CanonicalName, LocalNetRootName, FilePathName, RxConnectionId);
         if (VNetRoot == NULL)
         {
             RxFinalizeNetRoot(NetRoot, TRUE, TRUE);
             Status = STATUS_INSUFFICIENT_RESOURCES;
             _SEH2_LEAVE;
         }
         RxReferenceVNetRoot(VNetRoot);
 
         /* We're get closer! */
         NetRoot->Condition = Condition_InTransition;
         RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
         RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
         RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
 
         /* Construct the NetRoot, involving the mini-rdr now that we have our three control structs */
         Status = RxConstructNetRoot(RxContext, SrvCall, NetRoot, VNetRoot, LockState);
         if (!NT_SUCCESS(Status))
         {
             RxTransitionVNetRoot(VNetRoot, Condition_Bad);
             DPRINT1("RxConstructNetRoot failed Ctxt: %p, VNet: %p, Status: %lx, Condition: %d\n", RxContext, VNetRoot, Status, VNetRoot->Condition);
             RxDereferenceVNetRoot(VNetRoot, *LockState);
 
             RxContext->Create.pNetRoot = NULL;
             RxContext->Create.pVNetRoot = NULL;
         }
         else
         {
             PIO_STACK_LOCATION Stack;
 
             ASSERT(*LockState == LHS_ExclusiveLockHeld);
 
             Stack = RxContext->CurrentIrpSp;
             if (BooleanFlagOn(Stack->Parameters.Create.Options, FILE_CREATE_TREE_CONNECTION))
             {
                 RxExclusivePrefixTableLockToShared(PrefixTable);
                 *LockState = LHS_SharedLockHeld;
             }
         }
     }
     _SEH2_FINALLY
     {
         if (Status != STATUS_SUCCESS && Status != STATUS_CONNECTION_ACTIVE)
         {
             if (*LockState != LHS_LockNotHeld)
             {
                 RxReleasePrefixTableLock(PrefixTable);
                 *LockState = LHS_LockNotHeld;
             }
         }
     }
     _SEH2_END;
 
     DPRINT("RxFindOrCreateConnections() = Status: %x\n", Status);
     return Status;
 }

Referenced by RxConstructVirtualNetRoot().

◆ RxFreeFcbObject()

VOID RxFreeFcbObject ( _In_ PVOID Object )

◆ RxFreeObject()

VOID RxFreeObject ( _In_ PVOID pObject )

◆ RxFsdPostRequest()

NTSTATUS RxFsdPostRequest ( _In_ PRX_CONTEXT RxContext )

Referenced by RxCancelBlockingOperation(), and RxUpdateCondition().

◆ 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.

 {
     UNIMPLEMENTED;
 }

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
	)

Referenced by RxFinishFcbInitialization().

◆ RxLockUserBuffer()

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

Referenced by RxNotifyChangeDirectory(), RxPrePostIrp(), and RxQueryDirectory().

◆ 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 )

Referenced by RxCommonQueryInformation().

◆ RxNoOpAcquire()

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

Referenced by RxInitializeDispatchVectors().

◆ RxNoOpRelease()

VOID NTAPI RxNoOpRelease ( _In_ PVOID Fcb )

Referenced by RxInitializeDispatchVectors().

◆ 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.

 {
     PLIST_ENTRY Entry;
 
     PAGED_CODE();
 
     /* No requests to discard */
     if (IsListEmpty(DiscardedRequests))
     {
         return;
     }
 
     /* Free all the discarded requests */
     Entry = DiscardedRequests->Flink;
     while (Entry != DiscardedRequests)
     {
         PCHANGE_BUFFERING_STATE_REQUEST Request;
 
         Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
         Entry = Entry->Flink;
 
         DPRINT("Req %p for %p (%p) discarded\n", Request, Request->SrvOpenKey, Request->SrvOpen);
 
         RxPrepareRequestForReuse(Request);
         RxFreePool(Request);
     }
 }

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 )

Referenced by RxCompleteRequest_Real(), and RxFinishSrvCallConstruction().

◆ RxPrefixClaim()

NTSTATUS RxPrefixClaim ( _In_ PRX_CONTEXT RxContext )

◆ RxPrepareRequestForReuse()

VOID RxPrepareRequestForReuse ( PCHANGE_BUFFERING_STATE_REQUEST Request )

Definition at line 6607 of file rxce.c.

 {
     PSRV_OPEN SrvOpen;
 
     PAGED_CODE();
 
     SrvOpen = Request->SrvOpen;
 
     /* If the request was already prepared for service */
     if (BooleanFlagOn(Request->Flags, RX_REQUEST_PREPARED_FOR_HANDLING))
     {
         /* We have to dereference the associated SRV_OPEN depending on the lock */
         if (RxIsFcbAcquiredExclusive(SrvOpen->pFcb))
         {
             RxDereferenceSrvOpen(SrvOpen, LHS_ExclusiveLockHeld);
         }
         else
         {
             RxDereferenceSrvOpen(SrvOpen, LHS_LockNotHeld);
         }
     }
     /* Otherwise, just dereference */
     else if (SrvOpen != NULL)
     {
         RxDereferenceSrvOpen(SrvOpen, LHS_LockNotHeld);
     }
 
     Request->SrvOpen = NULL;
 }

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.

 {
     PWSTR NewBuffer;
     USHORT NewLength;
     PFILE_OBJECT FileObject;
 
     /* Assume no reparse is required first */
     *ReparseRequired = FALSE;
 
     /* Only supported for IRP_MJ_CREATE */
     if (RxContext->MajorFunction != IRP_MJ_CREATE)
     {
         return STATUS_INVALID_PARAMETER;
     }
 
     /* If symbolic link is not embedded, and DELETE is specified, fail */
     if (!SymbolicLinkEmbeddedInOldPath)
     {
         /* Excepted if DELETE is the only flag specified, then, open has to succeed
          * See: https://msdn.microsoft.com/en-us/library/windows/hardware/ff554649(v=vs.85).aspx (remarks)
          */
         if (BooleanFlagOn(RxContext->Create.NtCreateParameters.DesiredAccess, DELETE) &&
             BooleanFlagOn(RxContext->Create.NtCreateParameters.DesiredAccess, ~DELETE))
         {
             return STATUS_ACCESS_DENIED;
         }
     }
 
     /* At that point, assume reparse will be required */
     *ReparseRequired = TRUE;
 
     /* If new path isn't absolute, it's up to us to make it absolute */
     if (!NewPathIsAbsolute)
     {
         /* The prefix will be \Device\Mup */
         NewLength = NewPath->Length + (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL));
         NewBuffer = ExAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION, NewLength,
                                           RX_MISC_POOLTAG);
         if (NewBuffer == NULL)
         {
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
         /* Copy data for the new path */
         RtlMoveMemory(NewBuffer, L"\\Device\\Mup", (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL)));
         RtlMoveMemory(Add2Ptr(NewBuffer, (sizeof(L"\\Device\\Mup") - sizeof(UNICODE_NULL))),
                       NewPath->Buffer, NewPath->Length);
     }
     /* Otherwise, use caller path as it */
     else
     {
         NewLength = NewPath->Length;
         NewBuffer = NewPath->Buffer;
     }
 
     /* Get the FILE_OBJECT we'll modify */
     FileObject = RxContext->CurrentIrpSp->FileObject;
 
     /* Free old path first */
     ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
     /* And setup new one */
     FileObject->FileName.Length = NewLength;
     FileObject->FileName.MaximumLength = NewLength;
     FileObject->FileName.Buffer = NewBuffer;
 
     /* And set reparse flag */
     SetFlag(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_REPARSE);
 
     /* Done! */
     return STATUS_SUCCESS;
 }

◆ 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.

 {
     LONG NumberOfBufferingChangeRequests, LockedOldBufferingToken, OldBufferingToken;
 
     /* Get the current number of change requests */
     NumberOfBufferingChangeRequests = ((PSRV_CALL)SrvOpen->pVNetRoot->pNetRoot->pSrvCall)->BufferingManager.CumulativeNumberOfBufferingChangeRequests;
     /* Get our old token */
     OldBufferingToken = SrvOpen->BufferingToken;
     LockedOldBufferingToken = InterlockedCompareExchange(&SrvOpen->BufferingToken,
                                                          NumberOfBufferingChangeRequests,
                                                          NumberOfBufferingChangeRequests);
     /* If buffering state changed in between, process changes */
     if (OldBufferingToken != LockedOldBufferingToken)
     {
         PFCB Fcb;
         NTSTATUS Status;
 
         /* Acquire the FCB and start processing */
         Fcb = (PFCB)SrvOpen->pFcb;
         Status = RxAcquireExclusiveFcb(NULL, Fcb);
         if (Status == STATUS_SUCCESS)
         {
             RxProcessFcbChangeBufferingStateRequest(Fcb);
             RxReleaseFcb(NULL, Fcb);
         }
     }
 }

Referenced by RxFastIoCheckIfPossible().

◆ RxPurgeFcb()

VOID RxPurgeFcb ( _In_ PFCB Fcb )

◆ RxPurgeFobx()

BOOLEAN RxPurgeFobx ( PFOBX pFobx )

Definition at line 7051 of file rxce.c.

 {
     NTSTATUS Status;
     PFCB FcbToBePurged;
 
     PAGED_CODE();
 
     /* Get the associated FCB */
     FcbToBePurged = (PFCB)pFobx->pSrvOpen->pFcb;
     Status = RxAcquireExclusiveFcb(NULL, FcbToBePurged);
     ASSERT(Status == STATUS_SUCCESS);
 
     /* Purge it */
     Status = RxPurgeFcbInSystemCache(FcbToBePurged, NULL, 0, FALSE, TRUE);
     if (Status != STATUS_SUCCESS)
     {
         DPRINT1("Purge failed for %p (%p)\n", FcbToBePurged, pFobx);
         return FALSE;
     }
 
     /* And flush */
     if (!MmFlushImageSection(&FcbToBePurged->NonPaged->SectionObjectPointers, MmFlushForWrite))
     {
         DPRINT1("Image section flush failed for %p (%p)\n", FcbToBePurged, pFobx);
         return FALSE;
     }
 
     DPRINT("Purge OK for %p (%p)\n", FcbToBePurged, pFobx);
     return TRUE;
 }

Referenced by RxPurgeRelatedFobxs().

◆ RxPurgeFobxFromCache()

NTSTATUS RxPurgeFobxFromCache ( PFOBX FobxToBePurged )

Definition at line 7087 of file rxce.c.

 {
     NTSTATUS Status;
     PFCB FcbToBePurged;
 
     PAGED_CODE();
 
     FcbToBePurged = (PFCB)FobxToBePurged->pSrvOpen->pFcb;
     ASSERT(FcbToBePurged != NULL);
 
     /* If we cannot have our FCB exclusively, give up */
     Status = RxAcquireExclusiveFcb(NULL, FcbToBePurged);
     if (Status != STATUS_SUCCESS)
     {
         RxDereferenceNetFobx(FobxToBePurged, LHS_LockNotHeld);
         return Status;
     }
 
     /* Don't let the FCB disappear */
     RxReferenceNetFcb(FcbToBePurged);
 
     /* If the SRV_OPEN was already closed, or if there are unclean FOBX, give up */
     if (BooleanFlagOn(FobxToBePurged->Flags, FOBX_FLAG_SRVOPEN_CLOSED) || FobxToBePurged->pSrvOpen->UncleanFobxCount != 0)
     {
         DPRINT("FCB purge skipped\n");
     }
     else
     {
         Status = RxPurgeFcbInSystemCache(FcbToBePurged, NULL, 0, FALSE, TRUE);
     }
 
     RxDereferenceNetFobx(FobxToBePurged, LHS_ExclusiveLockHeld);
     /* Drop our extra reference */
     if (!RxDereferenceAndFinalizeNetFcb(FcbToBePurged, NULL, FALSE, FALSE))
     {
         RxReleaseFcb(NULL, FcbToBePurged);
     }
 
     return Status;
 }

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 )

Referenced by RxInitializeDispatchVectors().

◆ RxReleaseFcbFromReadAhead()

VOID NTAPI RxReleaseFcbFromReadAhead ( _In_ PVOID Null )

Referenced by RxInitializeDispatchVectors().

◆ 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.

 {
     UNIMPLEMENTED;
 }

◆ RxUndoScavengerFinalizationMarking()

VOID RxUndoScavengerFinalizationMarking ( PVOID Instance )

Definition at line 8667 of file rxce.c.

 {
     /* Just call internal routine with mutex held */
     RxAcquireScavengerMutex();
     RxpUndoScavengerFinalizationMarking(Instance);
     RxReleaseScavengerMutex();
 }

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
	)

Referenced by RxFinishFcbInitialization().

◆ 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().

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CHANGE_BUFFERING_STATE_CONTEXT

◆ CHANGE_BUFFERING_STATE_CONTEXT_WAIT

◆ FCB_MODE_EXCLUSIVE

◆ FCB_MODE_SHARED

◆ FCB_MODE_SHARED_STARVE_EXCLUSIVE

◆ FCB_MODE_SHARED_WAIT_FOR_EXCLUSIVE

◆ QuadAlign

◆ RX_GET_MRX_FCB

◆ RxAcquireExclusiveFcb

◆ RxAcquirePagingIoResource

◆ RxAcquirePagingIoResourceShared

◆ RxAcquireSharedFcb

◆ RxAcquireSharedFcbWaitForEx

◆ RxCheckShareAccess

◆ RxCompleteAsynchronousRequest

◆ RxConvertToSharedFcb

◆ RxDumpCurrentAccess

◆ RxDumpWantedAccess

◆ RxEqualConnectionId

◆ RxIsFcbAcquired

◆ RxIsFcbAcquiredExclusive

◆ RxIsFcbAcquiredShared

◆ RxLogFailure

◆ RxReleaseFcb

◆ RxReleaseFcbForThread

◆ RxReleasePagingIoResource

◆ RxReleasePagingIoResourceForThread

◆ RxRemoveShareAccess

◆ RxSetShareAccess

◆ RxTrackerUpdateHistory

◆ RxUpdateShareAccess

Typedef Documentation

◆ RX_NAME_CONJURING_METHODS

Enumeration Type Documentation

◆ _RX_NAME_CONJURING_METHODS

Function Documentation

◆ __RxAcquireFcb()

◆ __RxReleaseFcb()

◆ __RxReleaseFcbForThread()

◆ RxAcquireFcbForLazyWrite()

◆ RxAcquireFcbForReadAhead()

◆ RxAddToWorkque()

◆ RxAddVirtualNetRootToNetRoot()

◆ RxAllocateFcbObject()

◆ RxAllocateObject()

◆ RxBootstrapWorkerThreadDispatcher()

◆ RxCancelRoutine()

◆ RxChangeBufferingState()

◆ RxCheckFcbStructuresForAlignment()

◆ RxCheckShareAccessPerSrvOpens()

◆ RxCloseAssociatedSrvOpen()

◆ RxCompleteMdl()

◆ RxCompleteRequest()

◆ RxCompleteRequest_Real()

◆ RxConjureOriginalName()

◆ RxConstructNetRoot()

◆ RxConstructSrvCall()

◆ RxConstructVirtualNetRoot()

◆ RxCreateNetRootCallBack()

◆ RxDereference()

◆ RxDriverEntry()

◆ RxExtractServerName()

◆ RxFinalizeConnection()

◆ RxFinalizeNetFcb()

◆ RxFindOrConstructVirtualNetRoot()

◆ RxFindOrCreateConnections()

◆ RxFreeFcbObject()

◆ RxFreeObject()

◆ RxFsdPostRequest()

◆ RxGatherRequestsForSrvOpen()

◆ RxGetNetworkProviderPriority()

◆ RxGetSessionId()

◆ RxGetUid()

◆ RxIndicateChangeOfBufferingStateForSrvOpen()