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

ExIsResourceAcquiredSharedLite

ULONG NTAPI ExIsResourceAcquiredSharedLite(IN PERESOURCE Resource)

Definition: resource.c:1663

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://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/rxprocs/nf-rxprocs-rxpreparetoreparsesymboliclink (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

extern

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