rxce.c File Reference

#include <rx.h>
#include <pseh/pseh2.h>
#include <dfs.h>
#include <debug.h>

Include dependency graph for rxce.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID	RxAssert (PVOID Assert, PVOID File, ULONG Line, PVOID Message)
VOID NTAPI	RxCreateSrvCallCallBack (IN OUT PMRX_SRVCALL_CALLBACK_CONTEXT Context)
NTSTATUS	RxFinishSrvCallConstruction (PMRX_SRVCALLDOWN_STRUCTURE Calldown)
VOID NTAPI	RxFinishSrvCallConstructionDispatcher (IN PVOID Context)
NTSTATUS	RxInsertWorkQueueItem (PRDBSS_DEVICE_OBJECT pMRxDeviceObject, WORK_QUEUE_TYPE WorkQueueType, PRX_WORK_QUEUE_ITEM WorkQueueItem)
PVOID	RxNewMapUserBuffer (PRX_CONTEXT RxContext)
VOID NTAPI	RxpDestroySrvCall (IN PVOID Context)
VOID	RxpDispatchChangeBufferingStateRequests (PSRV_CALL SrvCall, PSRV_OPEN SrvOpen, PLIST_ENTRY DiscardedRequests)
VOID NTAPI	RxScavengerTimerRoutine (PVOID Context)
VOID NTAPI	RxTimerDispatch (_In_ struct _KDPC *Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)
VOID NTAPI	RxWorkItemDispatcher (PVOID Context)
PVOID NTAPI	_RxAllocatePoolWithTag (_In_ POOL_TYPE PoolType, _In_ SIZE_T NumberOfBytes, _In_ ULONG Tag)
VOID NTAPI	_RxFreePool (_In_ PVOID Buffer)
VOID NTAPI	_RxFreePoolWithTag (_In_ PVOID Buffer, _In_ ULONG Tag)
NTSTATUS NTAPI	RxAcquireExclusiveFcbResourceInMRx (_Inout_ PMRX_FCB Fcb)
BOOLEAN NTAPI	RxAcquireFcbForLazyWrite (PVOID Context, BOOLEAN Wait)
BOOLEAN NTAPI	RxAcquireFcbForReadAhead (PVOID Context, BOOLEAN Wait)
VOID NTAPI	RxAcquireFileForNtCreateSection (PFILE_OBJECT FileObject)
NTSTATUS NTAPI	RxAcquireForCcFlush (PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject)
VOID	RxAddVirtualNetRootToNetRoot (PNET_ROOT NetRoot, PV_NET_ROOT VNetRoot)
PVOID	RxAllocateFcbObject (PRDBSS_DEVICE_OBJECT RxDeviceObject, NODE_TYPE_CODE NodeType, POOL_TYPE PoolType, ULONG NameSize, PVOID AlreadyAllocatedObject)
PVOID	RxAllocateObject (NODE_TYPE_CODE NodeType, PMINIRDR_DISPATCH MRxDispatch, ULONG NameLength)
VOID NTAPI	RxBootstrapWorkerThreadDispatcher (IN PVOID WorkQueue)
VOID	RxCancelBlockingOperation (IN OUT PRX_CONTEXT RxContext)
NTSTATUS NTAPI	RxChangeBufferingState (PSRV_OPEN SrvOpen, PVOID Context, BOOLEAN ComputeNewState)
NTSTATUS	RxCheckVNetRootCredentials (PRX_CONTEXT RxContext, PV_NET_ROOT VNetRoot, PLUID LogonId, PUNICODE_STRING UserName, PUNICODE_STRING UserDomain, PUNICODE_STRING Password, ULONG Flags)
NTSTATUS	RxCompleteRequest (PRX_CONTEXT Context, NTSTATUS Status)
VOID	RxCompleteRequest_Real (IN PRX_CONTEXT RxContext, IN PIRP Irp, IN NTSTATUS Status)
VOID	RxCompleteSrvOpenKeyAssociation (IN OUT PSRV_OPEN SrvOpen)
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	RxConstructSrvCall (IN PRX_CONTEXT RxContext, IN PSRV_CALL SrvCall, 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)
PFCB	RxCreateNetFcb (IN PRX_CONTEXT RxContext, IN PV_NET_ROOT VNetRoot, IN PUNICODE_STRING Name)
PMRX_FOBX NTAPI	RxCreateNetFobx (OUT PRX_CONTEXT RxContext, IN PMRX_SRV_OPEN MrxSrvOpen)
PNET_ROOT	RxCreateNetRoot (IN PSRV_CALL SrvCall, IN PUNICODE_STRING Name, IN ULONG NetRootFlags, IN PRX_CONNECTION_ID OPTIONAL RxConnectionId)
VOID NTAPI	RxCreateNetRootCallBack (IN PMRX_CREATENETROOT_CONTEXT CreateNetRootContext)
PRX_CONTEXT NTAPI	RxCreateRxContext (IN PIRP Irp, IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN ULONG InitialContextFlags)
PSRV_CALL	RxCreateSrvCall (IN PRX_CONTEXT RxContext, IN PUNICODE_STRING Name, IN PUNICODE_STRING InnerNamePrefix OPTIONAL, IN PRX_CONNECTION_ID RxConnectionId)
PSRV_OPEN	RxCreateSrvOpen (IN PV_NET_ROOT VNetRoot, IN OUT PFCB Fcb)
PV_NET_ROOT	RxCreateVNetRoot (IN PRX_CONTEXT RxContext, IN PNET_ROOT NetRoot, IN PUNICODE_STRING CanonicalName, IN PUNICODE_STRING LocalNetRootName, IN PUNICODE_STRING FilePath, IN PRX_CONNECTION_ID RxConnectionId)
VOID	RxDereference (IN OUT PVOID Instance, IN LOCK_HOLDING_STATE LockHoldingState)
VOID NTAPI	RxDereferenceAndDeleteRxContext_Real (IN PRX_CONTEXT RxContext)
VOID NTAPI	RxDispatchChangeBufferingStateRequests (PVOID Context)
NTSTATUS NTAPI	RxDispatchToWorkerThread (IN PRDBSS_DEVICE_OBJECT pMRxDeviceObject, IN WORK_QUEUE_TYPE WorkQueueType, IN PRX_WORKERTHREAD_ROUTINE Routine, IN PVOID pContext)
VOID	RxExclusivePrefixTableLockToShared (PRX_PREFIX_TABLE Table)
VOID	RxExtractServerName (IN PUNICODE_STRING FilePathName, OUT PUNICODE_STRING SrvCallName, OUT PUNICODE_STRING RestOfName)
NTSTATUS	RxFcbTableInsertFcb (IN OUT PRX_FCB_TABLE FcbTable, IN OUT PFCB Fcb)
PFCB	RxFcbTableLookupFcb (IN PRX_FCB_TABLE FcbTable, IN PUNICODE_STRING Path)
NTSTATUS	RxFcbTableRemoveFcb (IN OUT PRX_FCB_TABLE FcbTable, IN OUT PFCB Fcb)
NTSTATUS NTAPI	RxFinalizeConnection (IN OUT PNET_ROOT NetRoot, IN OUT PV_NET_ROOT VNetRoot OPTIONAL, IN LOGICAL ForceFilesClosed)
VOID	RxFinalizeFcbTable (IN OUT PRX_FCB_TABLE FcbTable)
BOOLEAN	RxFinalizeNetFcb (OUT PFCB ThisFcb, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize, IN LONG ReferenceCount)
BOOLEAN	RxFinalizeNetFobx (_Out_ PFOBX ThisFobx, _In_ BOOLEAN RecursiveFinalize, _In_ BOOLEAN ForceFinalize)
BOOLEAN	RxFinalizeNetRoot (OUT PNET_ROOT ThisNetRoot, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
BOOLEAN	RxFinalizeSrvCall (OUT PSRV_CALL ThisSrvCall, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
BOOLEAN	RxFinalizeSrvOpen (OUT PSRV_OPEN ThisSrvOpen, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
BOOLEAN	RxFinalizeVNetRoot (OUT PV_NET_ROOT ThisVNetRoot, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
NTSTATUS	RxFindOrConstructVirtualNetRoot (IN PRX_CONTEXT RxContext, IN PUNICODE_STRING CanonicalName, IN NET_ROOT_TYPE NetRootType, IN PUNICODE_STRING RemainingName)
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 NTAPI	RxFinishFcbInitialization (IN OUT PMRX_FCB Fcb, IN RX_FILE_TYPE FileType, IN PFCB_INIT_PACKET InitPacket OPTIONAL)
NTSTATUS	RxFlushFcbInSystemCache (IN PFCB Fcb, IN BOOLEAN SynchronizeWithLazyWriter)
VOID	RxFreeFcbObject (PVOID Object)
VOID	RxFreeObject (PVOID pObject)
VOID	RxGatherRequestsForSrvOpen (IN OUT PSRV_CALL SrvCall, IN PSRV_OPEN SrvOpen, IN OUT PLIST_ENTRY RequestsListHead)
PRDBSS_DEVICE_OBJECT	RxGetDeviceObjectOfInstance (PVOID Instance)
VOID	RxGetFileSizeWithLock (IN PFCB Fcb, OUT PLONGLONG FileSize)
PEPROCESS NTAPI	RxGetRDBSSProcess (VOID)
NTSTATUS	RxInitializeBufferingManager (PSRV_CALL SrvCall)
VOID NTAPI	RxInitializeContext (IN PIRP Irp, IN PRDBSS_DEVICE_OBJECT RxDeviceObject, IN ULONG InitialContextFlags, IN OUT PRX_CONTEXT RxContext)
VOID NTAPI	RxInitializeDebugSupport (VOID)
NTSTATUS NTAPI	RxInitializeDispatcher (VOID)
VOID	RxInitializeFcbTable (IN OUT PRX_FCB_TABLE FcbTable, IN BOOLEAN CaseInsensitiveMatch)
VOID NTAPI	RxInitializeLowIoContext (OUT PLOWIO_CONTEXT LowIoContext, IN ULONG Operation)
VOID	RxInitializeLowIoPerFcbInfo (PLOWIO_PER_FCB_INFO LowIoPerFcbInfo)
NTSTATUS	RxInitializeMRxDispatcher (IN OUT PRDBSS_DEVICE_OBJECT pMRxDeviceObject)
VOID	RxInitializePrefixTable (IN OUT PRX_PREFIX_TABLE ThisTable, IN ULONG TableSize OPTIONAL, IN BOOLEAN CaseInsensitiveMatch)
VOID	RxInitializePurgeSyncronizationContext (PPURGE_SYNCHRONIZATION_CONTEXT PurgeSyncronizationContext)
NTSTATUS	RxInitializeSrvCallParameters (IN PRX_CONTEXT RxContext, IN OUT PSRV_CALL SrvCall)
NTSTATUS NTAPI	RxInitializeRxTimer (VOID)
NTSTATUS	RxInitializeVNetRootParameters (PRX_CONTEXT RxContext, OUT LUID *LogonId, OUT PULONG SessionId, OUT PUNICODE_STRING *UserNamePtr, OUT PUNICODE_STRING *UserDomainNamePtr, OUT PUNICODE_STRING *PasswordPtr, OUT PULONG Flags)
VOID	RxInitializeWorkQueue (PRX_WORK_QUEUE WorkQueue, WORK_QUEUE_TYPE WorkQueueType, ULONG MaximumNumberOfWorkerThreads, ULONG MinimumNumberOfWorkerThreads)
NTSTATUS	RxInitializeWorkQueueDispatcher (PRX_WORK_QUEUE_DISPATCHER Dispatcher)
VOID	RxInitiateSrvOpenKeyAssociation (IN OUT PSRV_OPEN SrvOpen)
BOOLEAN	RxIsThisACscAgentOpen (IN PRX_CONTEXT RxContext)
VOID	RxLockUserBuffer (IN PRX_CONTEXT RxContext, IN LOCK_OPERATION Operation, IN ULONG BufferLength)
NTSTATUS	RxLowIoCompletionTail (IN PRX_CONTEXT RxContext)
NTSTATUS NTAPI	RxLowIoPopulateFsctlInfo (IN PRX_CONTEXT RxContext)
NTSTATUS NTAPI	RxLowIoSubmit (IN PRX_CONTEXT RxContext, IN PLOWIO_COMPLETION_ROUTINE CompletionRoutine)
PVOID	RxMapSystemBuffer (IN PRX_CONTEXT RxContext)
VOID	RxMarkFobxOnCleanup (PFOBX pFobx, PBOOLEAN NeedPurge)
VOID	RxMarkFobxOnClose (PFOBX Fobx)
BOOLEAN NTAPI	RxNoOpAcquire (IN PVOID Fcb, IN BOOLEAN Wait)
VOID NTAPI	RxNoOpRelease (IN PVOID Fcb)
VOID	RxOrphanThisFcb (PFCB Fcb)
VOID	RxOrphanSrvOpens (IN PV_NET_ROOT ThisVNetRoot)
VOID	RxOrphanSrvOpensForThisFcb (IN PFCB Fcb, IN PV_NET_ROOT ThisVNetRoot, IN BOOLEAN OrphanAll)
BOOLEAN	RxpAcquirePrefixTableLockShared (PRX_PREFIX_TABLE pTable, BOOLEAN Wait, BOOLEAN ProcessBufferingStateChangeRequests)
BOOLEAN	RxpAcquirePrefixTableLockExclusive (PRX_PREFIX_TABLE pTable, BOOLEAN Wait, BOOLEAN ProcessBufferingStateChangeRequests)
BOOLEAN	RxpDereferenceAndFinalizeNetFcb (OUT PFCB ThisFcb, IN PRX_CONTEXT RxContext, IN BOOLEAN RecursiveFinalize, IN BOOLEAN ForceFinalize)
LONG	RxpDereferenceNetFcb (PFCB Fcb)
VOID	RxpDiscardChangeBufferingStateRequests (_Inout_ PLIST_ENTRY DiscardedRequests)
NTSTATUS	RxpLookupSrvOpenForRequestLite (IN PSRV_CALL SrvCall, IN OUT PCHANGE_BUFFERING_STATE_REQUEST Request)
VOID	RxpMarkInstanceForScavengedFinalization (PVOID Instance)
NTSTATUS NTAPI	RxPostOneShotTimerRequest (IN PRDBSS_DEVICE_OBJECT pDeviceObject, IN PRX_WORK_ITEM pWorkItem, IN PRX_WORKERTHREAD_ROUTINE Routine, IN PVOID pContext, IN LARGE_INTEGER TimeInterval)
NTSTATUS NTAPI	RxPostToWorkerThread (_In_ PRDBSS_DEVICE_OBJECT pMRxDeviceObject, _In_ WORK_QUEUE_TYPE WorkQueueType, _In_ PRX_WORK_QUEUE_ITEM pWorkQueueItem, _In_ PRX_WORKERTHREAD_ROUTINE Routine, _In_ PVOID pContext)
VOID	RxpProcessChangeBufferingStateRequests (PSRV_CALL SrvCall, BOOLEAN UpdateHandlerState)
PRX_PREFIX_ENTRY	RxPrefixTableInsertName (IN OUT PRX_PREFIX_TABLE ThisTable, IN OUT PRX_PREFIX_ENTRY ThisEntry, IN PVOID Container, IN PULONG ContainerRefCount, IN USHORT CaseInsensitiveLength, IN PRX_CONNECTION_ID ConnectionId)
PVOID	RxPrefixTableLookupName (IN PRX_PREFIX_TABLE ThisTable, IN PUNICODE_STRING CanonicalName, OUT PUNICODE_STRING RemainingName, IN PRX_CONNECTION_ID ConnectionId)
LONG	RxpReferenceNetFcb (PFCB Fcb)
VOID	RxpReleasePrefixTableLock (PRX_PREFIX_TABLE pTable, BOOLEAN ProcessBufferingStateChangeRequests)
VOID NTAPI	RxPrepareContextForReuse (IN OUT PRX_CONTEXT RxContext)
VOID	RxPrepareRequestForReuse (PCHANGE_BUFFERING_STATE_REQUEST Request)
VOID NTAPI	RxProcessChangeBufferingStateRequests (_In_ PVOID SrvCall)
VOID	RxProcessChangeBufferingStateRequestsForSrvOpen (PSRV_OPEN SrvOpen)
VOID	RxProcessFcbChangeBufferingStateRequest (PFCB Fcb)
VOID	RxpScavengeFobxs (PRDBSS_SCAVENGER Scavenger, PLIST_ENTRY FobxToScavenge)
BOOLEAN	RxpTrackDereference (_In_ ULONG TraceType, _In_ PCSTR FileName, _In_ ULONG Line, _In_ PVOID Instance)
VOID	RxpTrackReference (_In_ ULONG TraceType, _In_ PCSTR FileName, _In_ ULONG Line, _In_ PVOID Instance)
VOID	RxpUndoScavengerFinalizationMarking (PVOID Instance)
VOID	RxPurgeChangeBufferingStateRequestsForSrvOpen (PSRV_OPEN SrvOpen)
VOID	RxPurgeFcb (IN PFCB Fcb)
NTSTATUS	RxPurgeFcbInSystemCache (IN PFCB Fcb, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps, IN BOOLEAN FlushFile)
BOOLEAN	RxPurgeFobx (PFOBX pFobx)
NTSTATUS	RxPurgeFobxFromCache (PFOBX FobxToBePurged)
NTSTATUS	RxPurgeRelatedFobxs (PNET_ROOT NetRoot, PRX_CONTEXT RxContext, BOOLEAN AttemptFinalization, PFCB PurgingFcb)
VOID	RxpWorkerThreadDispatcher (IN PRX_WORK_QUEUE WorkQueue, IN PLARGE_INTEGER WaitInterval)
VOID	RxReference (IN OUT PVOID Instance)
VOID NTAPI	RxReinitializeContext (IN OUT PRX_CONTEXT RxContext)
VOID NTAPI	RxReleaseFcbFromLazyWrite (PVOID Context)
VOID NTAPI	RxReleaseFcbFromReadAhead (PVOID Context)
VOID NTAPI	RxReleaseFileForNtCreateSection (PFILE_OBJECT FileObject)
NTSTATUS NTAPI	RxReleaseForCcFlush (PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject)
VOID	RxRemoveNameNetFcb (OUT PFCB ThisFcb)
VOID	RxRemoveOperationFromBlockingQueue (IN OUT PRX_CONTEXT RxContext)
VOID	RxRemovePrefixTableEntry (IN OUT PRX_PREFIX_TABLE ThisTable, IN OUT PRX_PREFIX_ENTRY Entry)
VOID	RxRemoveVirtualNetRootFromNetRoot (PNET_ROOT NetRoot, PV_NET_ROOT VNetRoot)
VOID	RxResumeBlockedOperations_ALL (IN OUT PRX_CONTEXT RxContext)
VOID NTAPI	RxResumeBlockedOperations_Serially (IN OUT PRX_CONTEXT RxContext, IN OUT PLIST_ENTRY BlockingIoQ)
VOID	RxSetFileSizeWithLock (IN OUT PFCB Fcb, IN PLONGLONG FileSize)
VOID	RxScavengeFobxsForNetRoot (PNET_ROOT NetRoot, PFCB PurgingFcb, BOOLEAN SynchronizeWithScavenger)
BOOLEAN	RxScavengeRelatedFobxs (PFCB Fcb)
VOID	RxScavengerFinalizeEntries (PRDBSS_DEVICE_OBJECT DeviceObject)
BOOLEAN	RxScavengeVNetRoots (PRDBSS_DEVICE_OBJECT RxDeviceObject)
VOID NTAPI	RxSpinUpRequestsDispatcher (PVOID Dispatcher)
NTSTATUS	RxSpinUpWorkerThread (PRX_WORK_QUEUE WorkQueue, PRX_WORKERTHREAD_ROUTINE Routine, PVOID Parameter)
VOID	RxSpinUpWorkerThreads (PRX_WORK_QUEUE WorkQueue)
VOID	RxSynchronizeWithScavenger (IN PRX_CONTEXT RxContext)
ULONG	RxTableComputeHashValue (IN PUNICODE_STRING Name)
ULONG	RxTableComputePathHashValue (IN PUNICODE_STRING Name)
PVOID	RxTableLookupName (IN PRX_PREFIX_TABLE ThisTable, IN PUNICODE_STRING Name, OUT PUNICODE_STRING RemainingName, IN PRX_CONNECTION_ID OPTIONAL RxConnectionId)
PRX_PREFIX_ENTRY	RxTableLookupName_ExactLengthMatch (IN PRX_PREFIX_TABLE ThisTable, IN PUNICODE_STRING Name, IN ULONG HashValue, IN PRX_CONNECTION_ID OPTIONAL RxConnectionId)
NTSTATUS	RxTearDownBufferingManager (PSRV_CALL SrvCall)
VOID	RxTrackPagingIoResource (_Inout_ PVOID Instance, _In_ ULONG Type, _In_ ULONG Line, _In_ PCSTR File)
VOID	RxUndoScavengerFinalizationMarking (PVOID Instance)
VOID	RxUninitializeVNetRootParameters (IN PUNICODE_STRING UserName, IN PUNICODE_STRING UserDomainName, IN PUNICODE_STRING Password, OUT PULONG Flags)
VOID	RxUpdateCondition (IN RX_BLOCK_CONDITION NewConditionValue, OUT PRX_BLOCK_CONDITION Condition, IN OUT PLIST_ENTRY TransitionWaitList)
VOID	RxVerifyOperationIsLegal (IN PRX_CONTEXT RxContext)
VOID	RxWaitForStableCondition (IN PRX_BLOCK_CONDITION Condition, IN OUT PLIST_ENTRY TransitionWaitList, IN OUT PRX_CONTEXT RxContext, OUT NTSTATUS *AsyncStatus OPTIONAL)
NTSTATUS	__RxAcquireFcb (_Inout_ PFCB Fcb, _Inout_opt_ PRX_CONTEXT RxContext OPTIONAL, _In_ ULONG Mode)
VOID	__RxItsTheSameContext (_In_ PRX_CONTEXT RxContext, _In_ ULONG CapturedRxContextSerialNumber, _In_ ULONG Line, _In_ PCSTR File)
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)

Variables
ULONG	ReadAheadGranularity
volatile LONG	RxNumberOfActiveFcbs = 0
ULONG	SerialNumber = 1
PVOID	RxNull = NULL
volatile ULONG	RxContextSerialNumberCounter
BOOLEAN	RxStopOnLoudCompletion = TRUE
BOOLEAN	RxSrvCallConstructionDispatcherActive = FALSE
LIST_ENTRY	RxSrvCalldownList
RX_SPIN_LOCK	RxStrucSupSpinLock
ULONG	RdbssReferenceTracingValue = 0
LARGE_INTEGER	RxWorkQueueWaitInterval [RxMaximumWorkQueue]
LARGE_INTEGER	RxSpinUpDispatcherWaitInterval
RX_DISPATCHER	RxDispatcher
RX_WORK_QUEUE_DISPATCHER	RxDispatcherWorkQueues
FAST_MUTEX	RxLowIoPagingIoSyncMutex
BOOLEAN	RxContinueFromAssert = TRUE
ULONG	RxExplodePoolTags = 1
LARGE_INTEGER	RxTimerInterval
RX_SPIN_LOCK	RxTimerLock
LIST_ENTRY	RxTimerQueueHead
LIST_ENTRY	RxRecurrentWorkItemsList
KDPC	RxTimerDpc
KTIMER	RxTimer
ULONG	RxTimerTickCount
FAST_MUTEX	RxContextPerFileSerializationMutex
BOOLEAN	DumpDispatchRoutine = FALSE

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 33 of file rxce.c.

Function Documentation

__RxAcquireFcb()

NTSTATUS __RxAcquireFcb	(	_Inout_ PFCB	Fcb,
		_Inout_opt_ PRX_CONTEXT RxContext	OPTIONAL,
		_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;
}

__RxItsTheSameContext()

VOID __RxItsTheSameContext	(	_In_ PRX_CONTEXT	RxContext,
		_In_ ULONG	CapturedRxContextSerialNumber,
		_In_ ULONG	Line,
		_In_ PCSTR	File
	)

Definition at line 9126 of file rxce.c.

{
    /* Check we have a context with the same serial number */
    if (NodeType(RxContext) != RDBSS_NTC_RX_CONTEXT ||
        RxContext->SerialNumber != CapturedRxContextSerialNumber)
    {
        /* Just be noisy */
        DPRINT1("Context %p has changed at line %d in file %s\n", RxContext, Line, File);
    }
}

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

_RxAllocatePoolWithTag()

PVOID NTAPI _RxAllocatePoolWithTag	(	_In_ POOL_TYPE	PoolType,
		_In_ SIZE_T	NumberOfBytes,
		_In_ ULONG	Tag
	)

Definition at line 8941 of file rxce.c.

{
    return ExAllocatePoolWithTagPriority(PoolType, NumberOfBytes, Tag, LowPoolPriority);
}

_RxFreePool()

VOID NTAPI _RxFreePool

(

_In_ PVOID

Buffer

)

Definition at line 8954 of file rxce.c.

{
    ExFreePoolWithTag(Buffer, 0);
}

_RxFreePoolWithTag()

VOID NTAPI _RxFreePoolWithTag	(	_In_ PVOID	Buffer,
		_In_ ULONG	Tag
	)

Definition at line 8965 of file rxce.c.

{
    ExFreePoolWithTag(Buffer, Tag);
}

RxAcquireExclusiveFcbResourceInMRx()

NTSTATUS NTAPI RxAcquireExclusiveFcbResourceInMRx

(

_Inout_ PMRX_FCB

Fcb

)

Definition at line 183 of file rxce.c.

{
    return RxAcquireExclusiveFcb(NULL, (PFCB)Fcb);
}

RxAcquireFcbForLazyWrite()

BOOLEAN NTAPI RxAcquireFcbForLazyWrite	(	PVOID	Context,
		BOOLEAN	Wait
	)

Definition at line 194 of file rxce.c.

{
    PFCB Fcb;
    BOOLEAN Ret;
 
    PAGED_CODE();
 
    Fcb = Context;
    /* The received context is a FCB */
    ASSERT(NodeType(Fcb) == RDBSS_NTC_FCB);
    ASSERT_CORRECT_FCB_STRUCTURE(Fcb);
    ASSERT(Fcb->Specific.Fcb.LazyWriteThread == NULL);
 
    /* Acquire the paging resource (shared) */
    Ret = ExAcquireResourceSharedLite(Fcb->Header.PagingIoResource, Wait);
    if (Ret)
    {
        /* Update tracker information */
        Fcb->PagingIoResourceFile = __FILE__;
        Fcb->PagingIoResourceLine = __LINE__;
        /* Lazy writer thread is the current one */
        Fcb->Specific.Fcb.LazyWriteThread = PsGetCurrentThread();
 
        /* There is no top level IRP */
        ASSERT(RxIsThisTheTopLevelIrp(NULL));
        /* Now, there will be! */
        Ret = RxTryToBecomeTheTopLevelIrp(NULL, (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP,
                                          Fcb->RxDeviceObject, TRUE);
        /* In case of failure, release the lock and reset everything */
        if (!Ret)
        {
            Fcb->PagingIoResourceFile = NULL;
            Fcb->PagingIoResourceLine = 0;
            ExReleaseResourceLite(Fcb->Header.PagingIoResource);
            Fcb->Specific.Fcb.LazyWriteThread = NULL;
        }
    }
 
    return Ret;
}

RxAcquireFcbForReadAhead()

BOOLEAN NTAPI RxAcquireFcbForReadAhead	(	PVOID	Context,
		BOOLEAN	Wait
	)

Definition at line 242 of file rxce.c.

{
    PFCB Fcb;
    BOOLEAN Ret;
 
    PAGED_CODE();
 
    Fcb = Context;
    /* The received context is a FCB */
    ASSERT(NodeType(Fcb) == RDBSS_NTC_FCB);
    ASSERT_CORRECT_FCB_STRUCTURE(Fcb);
 
    Ret = ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait);
    if (Ret)
    {
        /* There is no top level IRP */
        ASSERT(RxIsThisTheTopLevelIrp(NULL));
        /* Now, there will be! */
        Ret = RxTryToBecomeTheTopLevelIrp(NULL, (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP,
                                          Fcb->RxDeviceObject, TRUE);
        /* In case of failure, release the lock and reset everything */
        if (!Ret)
        {
            ExReleaseResourceLite(Fcb->Header.Resource);
        }
    }
 
    return Ret;
}

RxAcquireFileForNtCreateSection()

VOID NTAPI RxAcquireFileForNtCreateSection

(

PFILE_OBJECT

FileObject

)

Definition at line 276 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxInitializeDispatchVectors().

RxAcquireForCcFlush()

NTSTATUS NTAPI RxAcquireForCcFlush	(	PFILE_OBJECT	FileObject,
		PDEVICE_OBJECT	DeviceObject
	)

Definition at line 284 of file rxce.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RxInitializeDispatchVectors().

RxAddVirtualNetRootToNetRoot()

VOID RxAddVirtualNetRootToNetRoot	(	PNET_ROOT	NetRoot,
		PV_NET_ROOT	VNetRoot
	)

Definition at line 296 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("RxAddVirtualNetRootToNetRoot(%p, %p)\n", NetRoot, VNetRoot);
 
    /* Insert in the VNetRoot list - make sure lock is held */
    ASSERT(RxIsPrefixTableLockExclusive(NetRoot->SrvCall->RxDeviceObject->pRxNetNameTable));
 
    VNetRoot->pNetRoot = (PMRX_NET_ROOT)NetRoot;
    ++NetRoot->NumberOfVirtualNetRoots;
    InsertTailList(&NetRoot->VirtualNetRoots, &VNetRoot->NetRootListEntry);
}

Referenced by RxCreateVNetRoot().

RxAllocateFcbObject()

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

Definition at line 316 of file rxce.c.

{
    PFCB Fcb;
    PFOBX Fobx;
    PSRV_OPEN SrvOpen;
    PVOID Buffer, PAPNBuffer;
    PNON_PAGED_FCB NonPagedFcb;
    PMINIRDR_DISPATCH Dispatch;
    ULONG NonPagedSize, FobxSize, SrvOpenSize, FcbSize;
 
    PAGED_CODE();
 
    Dispatch = RxDeviceObject->Dispatch;
 
    NonPagedSize = 0;
    FobxSize = 0;
    SrvOpenSize = 0;
    FcbSize = 0;
 
    Fcb = NULL;
    Fobx = NULL;
    SrvOpen = NULL;
    NonPagedFcb = NULL;
    PAPNBuffer = NULL;
 
    /* If we ask for FOBX, just allocate FOBX and its extension if asked */
    if (NodeType == RDBSS_NTC_FOBX)
    {
        FobxSize = sizeof(FOBX);
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FOBX_EXTENSION))
        {
            FobxSize += QuadAlign(Dispatch->MRxFobxSize);
        }
    }
    /* If we ask for SRV_OPEN, also allocate the "internal" FOBX and the extensions if asked */
    else if (NodeType == RDBSS_NTC_SRVOPEN || NodeType == RDBSS_NTC_INTERNAL_SRVOPEN)
    {
        SrvOpenSize = sizeof(SRV_OPEN);
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_SRV_OPEN_EXTENSION))
        {
            SrvOpenSize += QuadAlign(Dispatch->MRxSrvOpenSize);
        }
 
        FobxSize = sizeof(FOBX);
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FOBX_EXTENSION))
        {
            FobxSize += QuadAlign(Dispatch->MRxFobxSize);
        }
    }
    /* Otherwise, we're asked to allocate a FCB */
    else
    {
        /* So, allocate the FCB and its extension if asked */
        FcbSize = sizeof(FCB);
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FCB_EXTENSION))
        {
            FcbSize += QuadAlign(Dispatch->MRxFcbSize);
        }
 
        /* If we're asked to allocate from nonpaged, also allocate the NON_PAGED_FCB
         * Otherwise, it will be allocated later on, specifically
         */
        if (PoolType == NonPagedPool)
        {
            NonPagedSize = sizeof(NON_PAGED_FCB);
        }
 
        /* And if it's not for a rename operation also allcoate the internal SRV_OPEN and FOBX and their extensions */
        if (NodeType != RDBSS_NTC_OPENTARGETDIR_FCB)
        {
            SrvOpenSize = sizeof(SRV_OPEN);
            if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_SRV_OPEN_EXTENSION))
            {
                SrvOpenSize += QuadAlign(Dispatch->MRxSrvOpenSize);
            }
 
            FobxSize = sizeof(FOBX);
            if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FOBX_EXTENSION))
            {
                FobxSize += QuadAlign(Dispatch->MRxFobxSize);
            }
        }
    }
 
    /* If we already have a buffer, go ahead */
    if (AlreadyAllocatedObject != NULL)
    {
        Buffer = AlreadyAllocatedObject;
    }
    /* Otherwise, allocate it */
    else
    {
        Buffer = RxAllocatePoolWithTag(PoolType, NameSize + FcbSize + SrvOpenSize + FobxSize + NonPagedSize, RX_FCB_POOLTAG);
        if (Buffer == NULL)
        {
            return NULL;
        }
    }
 
    /* Now, get the pointers - FOBX is easy */
    if (NodeType == RDBSS_NTC_FOBX)
    {
        Fobx = Buffer;
    }
    /* SRV_OPEN first, FOBX next */
    else if (NodeType == RDBSS_NTC_SRVOPEN)
    {
        SrvOpen = Buffer;
        Fobx = Add2Ptr(Buffer, SrvOpenSize);
    }
    else if (NodeType == RDBSS_NTC_INTERNAL_SRVOPEN)
    {
        SrvOpen = Buffer;
    }
    else
    {
        /* FCB first, and if needed, SRV_OPEN next, FOBX last */
        Fcb = Buffer;
        if (NodeType != RDBSS_NTC_OPENTARGETDIR_FCB)
        {
            SrvOpen = Add2Ptr(Buffer, FcbSize);
            Fobx = Add2Ptr(Buffer, FcbSize + SrvOpenSize);
        }
 
        /* If we were not allocated from non paged, allocate the NON_PAGED_FCB now */
        if (PoolType != NonPagedPool)
        {
            NonPagedFcb = RxAllocatePoolWithTag(NonPagedPool, sizeof(NON_PAGED_FCB), RX_NONPAGEDFCB_POOLTAG);
            if (NonPagedFcb == NULL)
            {
                RxFreePoolWithTag(Buffer, RX_FCB_POOLTAG);
                return NULL;
            }
 
            PAPNBuffer = Add2Ptr(Buffer, FcbSize + SrvOpenSize + FobxSize);
        }
        /* Otherwise, just point at the right place in what has been allocated previously */
        else
        {
            NonPagedFcb = Add2Ptr(Fobx, FobxSize);
            PAPNBuffer = Add2Ptr(Fobx, FobxSize + NonPagedSize);
        }
    }
 
    /* If we have allocated a SRV_OPEN, initialize it */
    if (SrvOpen != NULL)
    {
        ZeroAndInitializeNodeType(SrvOpen, RDBSS_NTC_SRVOPEN, SrvOpenSize);
 
        if (NodeType == RDBSS_NTC_SRVOPEN)
        {
            SrvOpen->InternalFobx = Fobx;
        }
        else
        {
            SrvOpen->InternalFobx = NULL;
            SrvOpen->Flags |= SRVOPEN_FLAG_FOBX_USED;
        }
 
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_SRV_OPEN_EXTENSION))
        {
            SrvOpen->Context = Add2Ptr(SrvOpen, sizeof(SRV_OPEN));
        }
 
        InitializeListHead(&SrvOpen->SrvOpenQLinks);
    }
 
    /* If we have allocated a FOBX, initialize it */
    if (Fobx != NULL)
    {
        ZeroAndInitializeNodeType(Fobx, RDBSS_NTC_FOBX, FobxSize);
 
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FOBX_EXTENSION))
        {
            Fobx->Context = Add2Ptr(Fobx, sizeof(FOBX));
        }
    }
 
    /* If we have allocated a FCB, initialize it */
    if (Fcb != NULL)
    {
        ZeroAndInitializeNodeType(Fcb, RDBSS_STORAGE_NTC(FileTypeNotYetKnown), FcbSize);
 
        Fcb->NonPaged = NonPagedFcb;
        ZeroAndInitializeNodeType(Fcb->NonPaged, RDBSS_NTC_NONPAGED_FCB, sizeof(NON_PAGED_FCB));
#if DBG
        Fcb->CopyOfNonPaged = NonPagedFcb;
        NonPagedFcb->FcbBackPointer = Fcb;
#endif
 
        Fcb->InternalSrvOpen = SrvOpen;
        Fcb->InternalFobx = Fobx;
 
        Fcb->PrivateAlreadyPrefixedName.Length = NameSize;
        Fcb->PrivateAlreadyPrefixedName.MaximumLength = NameSize;
        Fcb->PrivateAlreadyPrefixedName.Buffer = PAPNBuffer;
 
        if (BooleanFlagOn(Dispatch->MRxFlags, RDBSS_MANAGE_FCB_EXTENSION))
        {
            Fcb->Context = Add2Ptr(Fcb, sizeof(FCB));
        }
 
        ZeroAndInitializeNodeType(&Fcb->FcbTableEntry, RDBSS_NTC_FCB_TABLE_ENTRY, sizeof(RX_FCB_TABLE_ENTRY));
 
        InterlockedIncrement(&RxNumberOfActiveFcbs);
        InterlockedIncrement((volatile long *)&RxDeviceObject->NumberOfActiveFcbs);
 
        ExInitializeFastMutex(&NonPagedFcb->AdvancedFcbHeaderMutex);
        FsRtlSetupAdvancedHeader(Fcb, &NonPagedFcb->AdvancedFcbHeaderMutex);
    }
 
    DPRINT("Allocated %p\n", Buffer);
 
    return Buffer;
}

Referenced by RxCreateNetFcb(), RxCreateNetFobx(), and RxCreateSrvOpen().

RxAllocateObject()

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

Definition at line 541 of file rxce.c.

{
    ULONG Tag, ObjectSize;
    PVOID Object, *Extension;
    PRX_PREFIX_ENTRY PrefixEntry;
    USHORT StructSize, ExtensionSize;
 
    PAGED_CODE();
 
    /* Select the node to allocate and always deal with the fact we may have to manage its extension */
    ExtensionSize = 0;
    switch (NodeType)
    {
        case RDBSS_NTC_SRVCALL:
            Tag = RX_SRVCALL_POOLTAG;
            StructSize = sizeof(SRV_CALL);
            if (MRxDispatch != NULL && BooleanFlagOn(MRxDispatch->MRxFlags, RDBSS_MANAGE_SRV_CALL_EXTENSION))
            {
                ExtensionSize = QuadAlign(MRxDispatch->MRxSrvCallSize);
            }
            break;
 
        case RDBSS_NTC_NETROOT:
            Tag = RX_NETROOT_POOLTAG;
            StructSize = sizeof(NET_ROOT);
            if (BooleanFlagOn(MRxDispatch->MRxFlags, RDBSS_MANAGE_NET_ROOT_EXTENSION))
            {
                ExtensionSize = QuadAlign(MRxDispatch->MRxNetRootSize);
            }
            break;
 
        case RDBSS_NTC_V_NETROOT:
            Tag = RX_V_NETROOT_POOLTAG;
            StructSize = sizeof(V_NET_ROOT);
            if (BooleanFlagOn(MRxDispatch->MRxFlags, RDBSS_MANAGE_V_NET_ROOT_EXTENSION))
            {
                ExtensionSize = QuadAlign(MRxDispatch->MRxVNetRootSize);
            }
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
 
    /* Now, allocate the object */
    ObjectSize = ExtensionSize + StructSize + NameLength;
    Object = RxAllocatePoolWithTag(NonPagedPool, ObjectSize, Tag);
    if (Object == NULL)
    {
        return NULL;
    }
    /* Initialize it */
    ZeroAndInitializeNodeType(Object, NodeType, ObjectSize);
 
    /* For SRV_CALL and NETROOT, the name points to the prefix table name */
    switch (NodeType)
    {
        case RDBSS_NTC_SRVCALL:
            PrefixEntry = &((PSRV_CALL)Object)->PrefixEntry;
            Extension = &((PSRV_CALL)Object)->Context;
            ((PSRV_CALL)Object)->pSrvCallName = &PrefixEntry->Prefix;
            break;
 
        case RDBSS_NTC_NETROOT:
            PrefixEntry = &((PNET_ROOT)Object)->PrefixEntry;
            Extension = &((PNET_ROOT)Object)->Context;
            ((PNET_ROOT)Object)->pNetRootName = &PrefixEntry->Prefix;
            break;
 
        case RDBSS_NTC_V_NETROOT:
            PrefixEntry = &((PV_NET_ROOT)Object)->PrefixEntry;
            Extension = &((PV_NET_ROOT)Object)->Context;
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
 
    /* Set the prefix table unicode string */
    RtlZeroMemory(PrefixEntry, sizeof(RX_PREFIX_ENTRY));
    PrefixEntry->NodeTypeCode = RDBSS_NTC_PREFIX_ENTRY;
    PrefixEntry->NodeByteSize = sizeof(RX_PREFIX_ENTRY);
    PrefixEntry->Prefix.Length = NameLength;
    PrefixEntry->Prefix.MaximumLength = NameLength;
    PrefixEntry->Prefix.Buffer = Add2Ptr(Object, ExtensionSize + StructSize);
 
    /* Return the extension if we are asked to manage it */
    if (ExtensionSize != 0)
    {
        *Extension = Add2Ptr(Object, StructSize);
    }
 
    return Object;
}

Referenced by RxCreateNetRoot(), RxCreateSrvCall(), and RxCreateVNetRoot().

RxAssert()

VOID RxAssert	(	PVOID	Assert,
		PVOID	File,
		ULONG	Line,
		PVOID	Message
	)

Definition at line 645 of file rxce.c.

{
    CHAR Response[2];
    CONTEXT Context;
 
    /* If we're not asked to continue, just stop the system */
    if (!RxContinueFromAssert)
    {
        KeBugCheckEx(RDBSS_FILE_SYSTEM, RDBSS_BUG_CHECK_ASSERT | Line, 0, 0, 0);
    }
 
    /* Otherwise, capture context to offer the user to dump it */
    RtlCaptureContext(&Context);
 
    /* Loop until the user hits 'i' */
    while (TRUE)
    {
        /* If no file provided, use empty name */
        if (File == NULL)
        {
            File = "";
        }
 
        /* If no message provided, use empty one */
        if (Message == NULL)
        {
            Message = "";
        }
 
        /* Display the message */
        DbgPrint("\n*** Assertion failed: %s%s\n***   Source File: %s, line %ld\n\n", Message, Assert, File, Line);
        /* And ask the user */
        DbgPrompt("Break, Ignore (bi)? ", Response, sizeof(Response));
        /* If he asks for ignore, quit
         * In case of invalid input, ask again
         */
        if (Response[0] != 'B' && Response[0] != 'b')
        {
            if (Response[0] == 'I' || Response[0] == 'i')
            {
                return;
            }
 
            continue;
        }
 
        /* Break: offer the user to dump the context and break */
        DbgPrint("Execute '!cxr %lx' to dump context\n", &Context);
        DbgBreakPoint();
 
        /* Continue looping, so that after dump, execution can continue (with ignore) */
    }
}

RxBootstrapWorkerThreadDispatcher()

VOID NTAPI RxBootstrapWorkerThreadDispatcher

(

IN PVOID

WorkQueue

)

Definition at line 708 of file rxce.c.

{
    PRX_WORK_QUEUE RxWorkQueue;
 
    PAGED_CODE();
 
    RxWorkQueue = WorkQueue;
    RxpWorkerThreadDispatcher(RxWorkQueue, NULL);
}

Referenced by RxInitializeWorkQueueDispatcher().

RxCancelBlockingOperation()

VOID RxCancelBlockingOperation

(

IN OUT PRX_CONTEXT

RxContext

)

Definition at line 723 of file rxce.c.

{
    PFOBX Fobx;
    BOOLEAN PostRequest;
 
    PAGED_CODE();
 
    Fobx = (PFOBX)RxContext->pFobx;
    PostRequest = FALSE;
 
    /* Acquire the pipe mutex */
    ExAcquireFastMutex(&RxContextPerFileSerializationMutex);
 
    /* If that's a blocking pipe operation which is not the CCB one, then handle it */
    if (BooleanFlagOn(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION) &&
        RxContext->RxContextSerializationQLinks.Flink != NULL &&
        RxContext != CONTAINING_RECORD(&Fobx->Specific.NamedPipe.ReadSerializationQueue, RX_CONTEXT, RxContextSerializationQLinks) &&
        RxContext != CONTAINING_RECORD(&Fobx->Specific.NamedPipe.WriteSerializationQueue, RX_CONTEXT, RxContextSerializationQLinks))
    {
        /* Clear it! */
        ClearFlag(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION);
 
        /* Drop it off the list */
        RemoveEntryList(&RxContext->RxContextSerializationQLinks);
        RxContext->RxContextSerializationQLinks.Flink = NULL;
        RxContext->RxContextSerializationQLinks.Blink = NULL;
 
        /* Set we've been cancelled */
        RxContext->IoStatusBlock.Status = STATUS_CANCELLED;
 
        /*
         * If it's async, we'll post completion, otherwise, we signal to waiters
         * it's being cancelled
         */
        if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
        {
            PostRequest = TRUE;
        }
        else
        {
            RxSignalSynchronousWaiter(RxContext);
        }
    }
 
    /* Done */
    ExReleaseFastMutex(&RxContextPerFileSerializationMutex);
 
    /* Post if async */
    if (PostRequest)
    {
        RxFsdPostRequest(RxContext);
    }
}

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

RxCheckVNetRootCredentials()

NTSTATUS RxCheckVNetRootCredentials	(	PRX_CONTEXT	RxContext,
		PV_NET_ROOT	VNetRoot,
		PLUID	LogonId,
		PUNICODE_STRING	UserName,
		PUNICODE_STRING	UserDomain,
		PUNICODE_STRING	Password,
		ULONG	Flags
	)

Definition at line 922 of file rxce.c.

{
    PAGED_CODE();
 
    /* If that's a UNC name, there's nothing to process */
    if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_CREATE_FLAG_UNC_NAME) &&
        (BooleanFlagOn(VNetRoot->Flags, VNETROOT_FLAG_CSCAGENT_INSTANCE) ||
         Flags != 0))
    {
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    /* Compare the logon ID in the VNetRoot with the one provided */
    if (RtlCompareMemory(&VNetRoot->LogonId, LogonId, sizeof(LUID)) != sizeof(LUID))
    {
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    /* No credential provided? That's OK */
    if (UserName == NULL && UserDomain == NULL && Password == NULL)
    {
        return STATUS_SUCCESS;
    }
 
    /* Left to do! */
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RxFindOrConstructVirtualNetRoot().

RxCompleteRequest()

NTSTATUS RxCompleteRequest	(	PRX_CONTEXT	Context,
		NTSTATUS	Status
	)

Definition at line 959 of file rxce.c.

{
    PIRP Irp;
 
    PAGED_CODE();
 
    DPRINT("RxCompleteRequest(%p, %lx)\n", Context, Status);
 
    ASSERT(Context != NULL);
    ASSERT(Context->CurrentIrp != NULL);
    Irp = Context->CurrentIrp;
 
    /* Debug what the caller asks for */
    if (Context->LoudCompletionString != NULL)
    {
        DPRINT("LoudCompletion: %lx/%lx with %wZ\n", Status, Irp->IoStatus.Information, Context->LoudCompletionString);
        /* Does the user asks to stop on failed completion */
        if (!NT_SUCCESS(Status) && RxStopOnLoudCompletion)
        {
            DPRINT1("LoudFailure: %lx/%lx with %wZ\n", Status, Irp->IoStatus.Information, Context->LoudCompletionString);
        }
    }
 
    /* Complete for real */
    Context->CurrentIrp = NULL;
    RxCompleteRequest_Real(Context, Irp, Status);
 
    DPRINT("Status: %lx\n", Status);
    return Status;
}

Referenced by RxFinishSrvCallConstruction(), and RxLowIoCompletionTail().

RxCompleteRequest_Real()

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

Definition at line 996 of file rxce.c.

{
    CCHAR Boost;
    KIRQL OldIrql;
    PIO_STACK_LOCATION Stack;
 
    DPRINT("RxCompleteRequest_Real(%p, %p, %lx)\n", RxContext, Irp, Status);
 
    /* Nothing to complete, just free context */
    if (Irp == NULL)
    {
        DPRINT("NULL IRP for %p\n", RxContext);
        if (RxContext != NULL)
        {
            RxDereferenceAndDeleteRxContext_Real(RxContext);
        }
 
        return;
    }
 
    /* Remove cancel routine */
    IoAcquireCancelSpinLock(&OldIrql);
    IoSetCancelRoutine(Irp, NULL);
    IoReleaseCancelSpinLock(OldIrql);
 
    /* Select the boost, given the success/paging operation */
    if (NT_SUCCESS(Status) || !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO))
    {
        Boost = IO_DISK_INCREMENT;
    }
    else
    {
        Irp->IoStatus.Information = 0;
        Boost = IO_NO_INCREMENT;
    }
    Irp->IoStatus.Status = Status;
 
    if (RxContext != NULL)
    {
        ASSERT(RxContext->MajorFunction <= IRP_MJ_MAXIMUM_FUNCTION);
        if (RxContext->MajorFunction != IRP_MJ_DEVICE_CONTROL)
        {
            DPRINT("Completing: MN: %d, Context: %p, IRP: %p, Status: %lx, Info: %lx, #%lx\n",
                   RxContext->MinorFunction, RxContext, Irp,
                   Status, Irp->IoStatus.Information, RxContext->SerialNumber);
        }
    }
 
    /* If that's an opening, there might be a canonical name allocated,
     * if completion isn't pending, release it
     */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (Stack->MajorFunction == IRP_MJ_CREATE && Status != STATUS_PENDING &&
        RxContext != NULL)
    {
        if (BooleanFlagOn(RxContext->Create.Flags, 2))
        {
            Stack->FileObject->FileName.Length += sizeof(WCHAR);
        }
 
        RxpPrepareCreateContextForReuse(RxContext);
        ASSERT(RxContext->Create.CanonicalNameBuffer == NULL);
    }
 
    /* If it's a write, validate the correct behavior of the operation */
    if (Stack->MajorFunction == IRP_MJ_WRITE)
    {
        if (NT_SUCCESS(Irp->IoStatus.Status))
        {
            ASSERT(Irp->IoStatus.Information <= Stack->Parameters.Write.Length);
        }
    }
 
    /* If it's pending, make sure IRP is marked as such */
    if (RxContext != NULL)
    {
        if (RxContext->PendingReturned)
        {
            ASSERT(BooleanFlagOn(Stack->Control, SL_PENDING_RETURNED));
        }
    }
 
    /* Complete now */
    DPRINT("Completing IRP with %x/%x\n", Irp->IoStatus.Status, Irp->IoStatus.Information);
    IoCompleteRequest(Irp, Boost);
 
    /* If there's a context, dereference it */
    if (RxContext != NULL)
    {
        RxDereferenceAndDeleteRxContext_Real(RxContext);
    }
}

Referenced by RxCompleteRequest().

RxCompleteSrvOpenKeyAssociation()

VOID RxCompleteSrvOpenKeyAssociation

(

IN OUT PSRV_OPEN

SrvOpen

)

Definition at line 1096 of file rxce.c.

{
    PSRV_CALL SrvCall;
 
    SrvCall = (PSRV_CALL)((PFCB)SrvOpen->pFcb)->VNetRoot->pNetRoot->pSrvCall;
    /* Only handle requests if opening was a success */
    if (SrvOpen->Condition == Condition_Good)
    {
        KIRQL OldIrql;
        BOOLEAN ProcessChange;
        LIST_ENTRY DiscardedRequests;
 
        /* Initialize our discarded requests list */
        InitializeListHead(&DiscardedRequests);
 
        RxAcquireBufferingManagerMutex(&SrvCall->BufferingManager);
 
        /* Transfer our requests in the SRV_CALL */
        RxTransferList(&SrvCall->BufferingManager.SrvOpenLists[0], &SrvOpen->SrvOpenKeyList);
 
        /* Was increased in RxInitiateSrvOpenKeyAssociation(), opening is done */
        InterlockedDecrement(&SrvCall->BufferingManager.NumberOfOutstandingOpens);
 
        /* Dispatch requests and get the discarded ones */
        RxpDispatchChangeBufferingStateRequests(SrvCall, SrvOpen, &DiscardedRequests);
 
        RxReleaseBufferingManagerMutex(&SrvCall->BufferingManager);
 
        /* Is there still anything to process? */
        KeAcquireSpinLock(&SrvCall->BufferingManager.SpinLock, &OldIrql);
        if (IsListEmpty(&SrvCall->BufferingManager.HandlerList))
        {
            ProcessChange = FALSE;
        }
        else
        {
            ProcessChange = (SrvCall->BufferingManager.HandlerInactive == FALSE);
            if (ProcessChange)
            {
                SrvCall->BufferingManager.HandlerInactive = TRUE;
            }
        }
        KeReleaseSpinLock(&SrvCall->BufferingManager.SpinLock, OldIrql);
 
        /* Yes? Go ahead! */
        if (ProcessChange)
        {
            RxReferenceSrvCall(SrvCall);
            RxPostToWorkerThread(RxFileSystemDeviceObject, HyperCriticalWorkQueue,
                                 &SrvCall->BufferingManager.HandlerWorkItem,
                                 RxProcessChangeBufferingStateRequests, SrvCall);
        }
 
        /* And discard left requests */
        RxpDiscardChangeBufferingStateRequests(&DiscardedRequests);
    }
    else
    {
        InterlockedDecrement(&SrvCall->BufferingManager.NumberOfOutstandingOpens);
    }
}

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
	)

Definition at line 1163 of file rxce.c.

{
    NTSTATUS Status;
    PRX_PREFIX_TABLE PrefixTable;
    PMRX_CREATENETROOT_CONTEXT Context;
    RX_BLOCK_CONDITION RootCondition, VRootCondition;
 
    PAGED_CODE();
 
    DPRINT("RxConstructNetRoot(%p, %p, %p, %p, %p)\n", RxContext, SrvCall, NetRoot,
           VirtualNetRoot, LockHoldingState);
 
    /* Validate the lock is exclusively held */
    PrefixTable = RxContext->RxDeviceObject->pRxNetNameTable;
    ASSERT(*LockHoldingState == LHS_ExclusiveLockHeld);
 
    /* Allocate the context */
    Context = RxAllocatePoolWithTag(PagedPool, sizeof(MRX_CREATENETROOT_CONTEXT), RX_SRVCALL_POOLTAG);
    if (Context == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* We can release lock now */
    RxReleasePrefixTableLock(PrefixTable);
    *LockHoldingState = LHS_LockNotHeld;
 
    RootCondition = Condition_Bad;
    VRootCondition = Condition_Bad;
 
    /* Initialize the context */
    RtlZeroMemory(Context, sizeof(MRX_CREATENETROOT_CONTEXT));
    KeInitializeEvent(&Context->FinishEvent, SynchronizationEvent, FALSE);
    Context->RxContext = RxContext;
    Context->pVNetRoot = VirtualNetRoot;
    Context->Callback = RxCreateNetRootCallBack;
 
    /* And call the mini-rdr */
    MINIRDR_CALL_THROUGH(Status, SrvCall->RxDeviceObject->Dispatch, MRxCreateVNetRoot, (Context));
    if (Status == STATUS_PENDING)
    {
        /* Wait for the mini-rdr to be done */
        KeWaitForSingleObject(&Context->FinishEvent, Executive, KernelMode, FALSE, NULL);
        /* Update the structures condition according to mini-rdr return */
        if (NT_SUCCESS(Context->NetRootStatus))
        {
            if (NT_SUCCESS(Context->VirtualNetRootStatus))
            {
                RootCondition = Condition_Good;
                VRootCondition = Condition_Good;
                Status = STATUS_SUCCESS;
            }
            else
            {
                RootCondition = Condition_Good;
                Status = Context->VirtualNetRootStatus;
            }
        }
        else
        {
            Status = Context->VirtualNetRootStatus;
            if (NT_SUCCESS(Status))
            {
                Status = Context->NetRootStatus;
            }
        }
    }
    else
    {
        /* It has to return STATUS_PENDING! */
        ASSERT(FALSE);
    }
 
    /* Acquire lock again - for caller lock status will remain unchanged */
    ASSERT(*LockHoldingState == LHS_LockNotHeld);
    RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
    *LockHoldingState = LHS_ExclusiveLockHeld;
 
    /* Do the transition to the condition got from mini-rdr */
    RxTransitionNetRoot(NetRoot, RootCondition);
    RxTransitionVNetRoot(VirtualNetRoot, VRootCondition);
 
    /* Context is not longer needed */
    RxFreePoolWithTag(Context, RX_SRVCALL_POOLTAG);
 
    DPRINT("Status: %x\n", Status);
 
    return Status;
}

Referenced by RxConstructVirtualNetRoot(), and RxFindOrCreateConnections().

RxConstructSrvCall()

NTSTATUS RxConstructSrvCall	(	IN PRX_CONTEXT	RxContext,
		IN PSRV_CALL	SrvCall,
		OUT PLOCK_HOLDING_STATE	LockHoldingState
	)

Definition at line 1262 of file rxce.c.

{
    NTSTATUS Status;
    PRX_PREFIX_TABLE PrefixTable;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    PMRX_SRVCALLDOWN_STRUCTURE Calldown;
    PMRX_SRVCALL_CALLBACK_CONTEXT CallbackContext;
 
    PAGED_CODE();
 
    DPRINT("RxConstructSrvCall(%p, %p, %p)\n", RxContext, SrvCall, LockHoldingState);
 
    /* Validate the lock is exclusively held */
    RxDeviceObject = RxContext->RxDeviceObject;
    PrefixTable = RxDeviceObject->pRxNetNameTable;
    ASSERT(*LockHoldingState == LHS_ExclusiveLockHeld);
 
    /* Allocate the context for mini-rdr */
    Calldown = RxAllocatePoolWithTag(NonPagedPool, sizeof(MRX_SRVCALLDOWN_STRUCTURE), RX_SRVCALL_POOLTAG);
    if (Calldown == NULL)
    {
        SrvCall->Context = NULL;
        SrvCall->Condition = Condition_Bad;
        RxReleasePrefixTableLock(PrefixTable);
        *LockHoldingState = LHS_LockNotHeld;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Initialize it */
    RtlZeroMemory(Calldown, sizeof(MRX_SRVCALLDOWN_STRUCTURE));
 
    SrvCall->Context = NULL;
    SrvCall->Condition = Condition_InTransition;
 
    RxReleasePrefixTableLock(PrefixTable);
    *LockHoldingState = LHS_LockNotHeld;
 
    CallbackContext = &Calldown->CallbackContexts[0];
    DPRINT("CalldownContext %p for %wZ\n", CallbackContext, &RxDeviceObject->DeviceName);
    DPRINT("With calldown %p and SrvCall %p\n", Calldown, SrvCall);
    CallbackContext->SrvCalldownStructure = Calldown;
    CallbackContext->CallbackContextOrdinal = 0;
    CallbackContext->RxDeviceObject = RxDeviceObject;
 
    RxReferenceSrvCall(SrvCall);
 
    /* If we're async, we'll post, otherwise, we'll have to wait for completion */
    if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
    {
        RxPrePostIrp(RxContext, RxContext->CurrentIrp);
    }
    else
    {
        KeInitializeEvent(&Calldown->FinishEvent, SynchronizationEvent, FALSE);
    }
 
    Calldown->NumberToWait = 1;
    Calldown->NumberRemaining = 1;
    Calldown->RxContext = RxContext;
    Calldown->SrvCall = (PMRX_SRV_CALL)SrvCall;
    Calldown->CallBack = RxCreateSrvCallCallBack;
    Calldown->BestFinisher = NULL;
    CallbackContext->Status = STATUS_BAD_NETWORK_PATH;
    InitializeListHead(&Calldown->SrvCalldownList);
 
    /* Call the mini-rdr */
    ASSERT(RxDeviceObject->Dispatch != NULL);
    ASSERT(NodeType(RxDeviceObject->Dispatch) == RDBSS_NTC_MINIRDR_DISPATCH);
    ASSERT(RxDeviceObject->Dispatch->MRxCreateSrvCall != NULL);
    Status = RxDeviceObject->Dispatch->MRxCreateSrvCall((PMRX_SRV_CALL)SrvCall, CallbackContext);
    /* It has to return STATUS_PENDING! */
    ASSERT(Status == STATUS_PENDING);
 
    /* No async, start completion */
    if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
    {
        KeWaitForSingleObject(&Calldown->FinishEvent, Executive, KernelMode, FALSE, NULL);
 
        /* Finish construction - we'll notify mini-rdr it's the winner */
        Status = RxFinishSrvCallConstruction(Calldown);
        if (!NT_SUCCESS(Status))
        {
            RxReleasePrefixTableLock(PrefixTable);
            *LockHoldingState = LHS_LockNotHeld;
        }
        else
        {
            ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
            *LockHoldingState = LHS_ExclusiveLockHeld;
        }
    }
 
    DPRINT("RxConstructSrvCall() = Status: %x\n", Status);
    return Status;
}

Referenced by RxFindOrCreateConnections().

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
	)

Definition at line 1365 of file rxce.c.

{
    NTSTATUS Status;
    PV_NET_ROOT VNetRoot;
    RX_BLOCK_CONDITION Condition;
    UNICODE_STRING LocalNetRootName, FilePathName;
 
    PAGED_CODE();
 
    ASSERT(*LockHoldingState != LHS_LockNotHeld);
 
    VNetRoot = NULL;
    Condition = Condition_Bad;
    /* Before creating the VNetRoot, try to find the appropriate connection */
    Status = RxFindOrCreateConnections(RxContext, CanonicalName, NetRootType,
                                       &LocalNetRootName, &FilePathName,
                                       LockHoldingState, RxConnectionId);
    /* Found and active */
    if (Status == STATUS_CONNECTION_ACTIVE)
    {
        /* We need a new VNetRoot */
        VNetRoot = RxCreateVNetRoot(RxContext, (PNET_ROOT)RxContext->Create.pVNetRoot->pNetRoot,
                                    CanonicalName, &LocalNetRootName, &FilePathName, RxConnectionId);
        if (VNetRoot != NULL)
        {
            RxReferenceVNetRoot(VNetRoot);
        }
 
        /* Dereference previous VNetRoot */
        RxDereferenceVNetRoot(RxContext->Create.pVNetRoot->pNetRoot, *LockHoldingState);
        /* Reset and start construct (new structures will replace old ones) */
        RxContext->Create.pSrvCall = NULL;
        RxContext->Create.pNetRoot = NULL;
        RxContext->Create.pVNetRoot = NULL;
 
        /* Construct new NetRoot */
        if (VNetRoot != NULL)
        {
            Status = RxConstructNetRoot(RxContext, (PSRV_CALL)VNetRoot->pNetRoot->pSrvCall,
                                        (PNET_ROOT)VNetRoot->pNetRoot, VNetRoot, LockHoldingState);
            if (NT_SUCCESS(Status))
            {
                Condition = Condition_Good;
            }
        }
        else
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    else
    {
        /* If it failed creating the connection, leave */
        if (Status != STATUS_SUCCESS)
        {
            if (*LockHoldingState != LHS_LockNotHeld)
            {
                RxReleasePrefixTableLock(RxContext->RxDeviceObject->pRxNetNameTable);
                *LockHoldingState = LHS_LockNotHeld;
            }
 
            *VirtualNetRootPointer = VNetRoot;
            DPRINT("RxConstructVirtualNetRoot() = Status: %x\n", Status);
            return Status;
        }
 
        *LockHoldingState = LHS_ExclusiveLockHeld;
 
        VNetRoot = (PV_NET_ROOT)RxContext->Create.pVNetRoot;
        Condition = Condition_Good;
    }
 
    /* We have a non stable VNetRoot - transition it */
    if (VNetRoot != NULL && !StableCondition(VNetRoot->Condition))
    {
        RxTransitionVNetRoot(VNetRoot, Condition);
    }
 
    /* If recreation failed */
    if (Status != STATUS_SUCCESS)
    {
        /* Dereference potential VNetRoot */
        if (VNetRoot != NULL)
        {
            ASSERT(*LockHoldingState != LHS_LockNotHeld);
            RxDereferenceVNetRoot(VNetRoot, *LockHoldingState);
            VNetRoot = NULL;
        }
 
        /* Release lock */
        if (*LockHoldingState != LHS_LockNotHeld)
        {
            RxReleasePrefixTableLock(RxContext->RxDeviceObject->pRxNetNameTable);
            *LockHoldingState = LHS_LockNotHeld;
        }
 
        /* Set NULL ptr */
        *VirtualNetRootPointer = VNetRoot;
        return Status;
    }
 
    /* Return the allocated VNetRoot */
    *VirtualNetRootPointer = VNetRoot;
    return Status;
}

Referenced by RxFindOrConstructVirtualNetRoot().

RxCreateNetFcb()

PFCB RxCreateNetFcb	(	IN PRX_CONTEXT	RxContext,
		IN PV_NET_ROOT	VNetRoot,
		IN PUNICODE_STRING	Name
	)

Definition at line 1481 of file rxce.c.

{
    PFCB Fcb;
    BOOLEAN FakeFcb;
    PNET_ROOT NetRoot;
    POOL_TYPE PoolType;
    NODE_TYPE_CODE NodeType;
    PIO_STACK_LOCATION Stack;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
 
    PAGED_CODE();
 
    /* We need a decent VNetRoot */
    ASSERT(VNetRoot != NULL && NodeType(VNetRoot) == RDBSS_NTC_V_NETROOT);
 
    NetRoot = (PNET_ROOT)VNetRoot->pNetRoot;
    ASSERT(NodeType(NetRoot) == RDBSS_NTC_NETROOT);
    ASSERT((PMRX_NET_ROOT)NetRoot == RxContext->Create.pNetRoot);
 
    RxDeviceObject = NetRoot->pSrvCall->RxDeviceObject;
    ASSERT(RxDeviceObject == RxContext->RxDeviceObject);
 
    Stack = RxContext->CurrentIrpSp;
 
    /* Do we need to create a fake FCB? Like for renaming */
    FakeFcb = BooleanFlagOn(Stack->Flags, SL_OPEN_TARGET_DIRECTORY) &&
              !BooleanFlagOn(NetRoot->Flags, NETROOT_FLAG_SUPPORTS_SYMBOLIC_LINKS);
    ASSERT(FakeFcb || RxIsFcbTableLockExclusive(&NetRoot->FcbTable));
 
    PoolType = (BooleanFlagOn(Stack->Flags, SL_OPEN_PAGING_FILE) ? NonPagedPool : PagedPool);
    NodeType = (FakeFcb) ? RDBSS_NTC_OPENTARGETDIR_FCB : RDBSS_STORAGE_NTC(FileTypeNotYetKnown);
 
    /* Allocate the FCB */
    Fcb = RxAllocateFcbObject(RxDeviceObject, NodeType, PoolType,
                              NetRoot->InnerNamePrefix.Length + Name->Length, NULL);
    if (Fcb == NULL)
    {
        return NULL;
    }
 
    /* Initialize the FCB */
    Fcb->CachedNetRootType = NetRoot->Type;
    Fcb->RxDeviceObject = RxDeviceObject;
    Fcb->MRxDispatch = RxDeviceObject->Dispatch;
    Fcb->VNetRoot = VNetRoot;
    Fcb->pNetRoot = VNetRoot->pNetRoot;
 
    InitializeListHead(&Fcb->SrvOpenList);
    Fcb->SrvOpenListVersion = 0;
 
    Fcb->FcbTableEntry.Path.Length = Name->Length;
    Fcb->FcbTableEntry.Path.MaximumLength = Name->Length;
    Fcb->FcbTableEntry.Path.Buffer = Add2Ptr(Fcb->PrivateAlreadyPrefixedName.Buffer, NetRoot->InnerNamePrefix.Length);
    RtlMoveMemory(Fcb->PrivateAlreadyPrefixedName.Buffer, NetRoot->InnerNamePrefix.Buffer,
                  NetRoot->InnerNamePrefix.Length);
    RtlMoveMemory(Fcb->FcbTableEntry.Path.Buffer, Name->Buffer, Name->Length);
 
    /* Copy back parameters from RxContext */
    if (BooleanFlagOn(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_ADDEDBACKSLASH))
    {
        Fcb->FcbState |= FCB_STATE_ADDEDBACKSLASH;
    }
 
    InitializeListHead(&Fcb->NonPaged->TransitionWaitList);
 
    if (BooleanFlagOn(Stack->Flags, SL_OPEN_PAGING_FILE))
    {
        Fcb->FcbState |= FCB_STATE_PAGING_FILE;
    }
 
    if (RxContext->MajorFunction == IRP_MJ_CREATE && BooleanFlagOn(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_SPECIAL_PATH))
    {
        Fcb->FcbState |= FCB_STATE_SPECIAL_PATH;
    }
 
    Fcb->Header.Resource = &Fcb->NonPaged->HeaderResource;
    ExInitializeResourceLite(Fcb->Header.Resource);
 
    Fcb->Header.PagingIoResource = &Fcb->NonPaged->PagingIoResource;
    ExInitializeResourceLite(Fcb->Header.PagingIoResource);
 
    Fcb->BufferedLocks.Resource = &Fcb->NonPaged->BufferedLocksResource;
    ExInitializeResourceLite(Fcb->BufferedLocks.Resource);
 
    /* Fake FCB doesn't go in prefix table */
    if (FakeFcb)
    {
        Fcb->FcbState |= (FCB_STATE_FAKEFCB | FCB_STATE_NAME_ALREADY_REMOVED);
        InitializeListHead(&Fcb->FcbTableEntry.HashLinks);
        DPRINT("Fake FCB: %p\n", Fcb);
    }
    else
    {
        RxFcbTableInsertFcb(&NetRoot->FcbTable, Fcb);
    }
 
    RxReferenceVNetRoot(VNetRoot);
    InterlockedIncrement((volatile long *)&Fcb->pNetRoot->NumberOfFcbs);
 
    Fcb->ulFileSizeVersion = 0;
 
    DPRINT("FCB %p for %wZ\n", Fcb, &Fcb->FcbTableEntry.Path);
    RxReferenceNetFcb(Fcb);
 
    return Fcb;
}

RxCreateNetFobx()

PMRX_FOBX NTAPI RxCreateNetFobx	(	OUT PRX_CONTEXT	RxContext,
		IN PMRX_SRV_OPEN	MrxSrvOpen
	)

Definition at line 1596 of file rxce.c.

{
    PFCB Fcb;
    PFOBX Fobx;
    ULONG Flags;
    PNET_ROOT NetRoot;
    PSRV_OPEN SrvOpen;
    POOL_TYPE PoolType;
 
    PAGED_CODE();
 
    SrvOpen = (PSRV_OPEN)MrxSrvOpen;
    ASSERT(NodeType(SrvOpen) == RDBSS_NTC_SRVOPEN);
    ASSERT(NodeTypeIsFcb(SrvOpen->Fcb));
    ASSERT(RxIsFcbAcquiredExclusive(SrvOpen->Fcb));
 
    Fcb = SrvOpen->Fcb;
    PoolType = (BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE) ? NonPagedPool : PagedPool);
    /* Can we use pre-allocated FOBX? */
    if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_FOBX_USED) && Fcb->InternalSrvOpen == (PSRV_OPEN)MrxSrvOpen)
    {
        Fobx = Fcb->InternalFobx;
        /* Call allocate to initialize the FOBX */
        RxAllocateFcbObject(Fcb->RxDeviceObject, RDBSS_NTC_FOBX, PoolType, 0, Fobx);
        /* Mark it used now */
        Fcb->FcbState |= FCB_STATE_FOBX_USED;
        Flags = FOBX_FLAG_ENCLOSED_ALLOCATED;
    }
    else if (!BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_FOBX_USED))
    {
        Fobx = SrvOpen->InternalFobx;
        /* Call allocate to initialize the FOBX */
        RxAllocateFcbObject(Fcb->RxDeviceObject, RDBSS_NTC_FOBX, PoolType, 0, Fobx);
        /* Mark it used now */
        SrvOpen->Flags |= SRVOPEN_FLAG_FOBX_USED;
        Flags = FOBX_FLAG_ENCLOSED_ALLOCATED;
    }
    else
    {
        /* Last case, we cannot, allocate a FOBX */
        Fobx = RxAllocateFcbObject(Fcb->RxDeviceObject, RDBSS_NTC_FOBX, PoolType, 0, NULL);
        Flags = 0;
    }
 
    /* Allocation failed! */
    if (Fobx == NULL)
    {
        return NULL;
    }
 
    /* Set flags */
    Fobx->Flags = Flags;
 
    /* Initialize throttling */
    NetRoot = (PNET_ROOT)RxContext->Create.pNetRoot;
    if (NetRoot != NULL)
    {
        if (NetRoot->DeviceType == FILE_DEVICE_DISK)
        {
            RxInitializeThrottlingState(&Fobx->Specific.DiskFile.LockThrottlingState,
                                        NetRoot->DiskParameters.LockThrottlingParameters.Increment,
                                        NetRoot->DiskParameters.LockThrottlingParameters.MaximumDelay);
        }
        else if (NetRoot->DeviceType == FILE_DEVICE_NAMED_PIPE)
        {
            RxInitializeThrottlingState(&Fobx->Specific.NamedPipe.ThrottlingState,
                                        NetRoot->NamedPipeParameters.PipeReadThrottlingParameters.Increment,
                                        NetRoot->NamedPipeParameters.PipeReadThrottlingParameters.MaximumDelay);
        }
    }
 
    /* Propagate flags fron RxContext */
    if (BooleanFlagOn(RxContext->Create.Flags, RX_CONTEXT_CREATE_FLAG_UNC_NAME))
    {
        Fobx->Flags |= FOBX_FLAG_UNC_NAME;
    }
 
    if (BooleanFlagOn(RxContext->Create.NtCreateParameters.CreateOptions, FILE_OPEN_FOR_BACKUP_INTENT))
    {
        Fobx->Flags |= FOBX_FLAG_BACKUP_INTENT;
    }
 
    /* Continue init */
    Fobx->FobxSerialNumber = 0;
    Fobx->SrvOpen = (PSRV_OPEN)MrxSrvOpen;
    Fobx->NodeReferenceCount = 1;
    Fobx->RxDeviceObject = Fcb->RxDeviceObject;
 
    RxReferenceSrvOpen(SrvOpen);
    InterlockedIncrement((volatile long *)&SrvOpen->pVNetRoot->NumberOfFobxs);
 
    InsertTailList(&SrvOpen->FobxList, &Fobx->FobxQLinks);
    InitializeListHead(&Fobx->ScavengerFinalizationList);
    InitializeListHead(&Fobx->ClosePendingList);
 
    Fobx->CloseTime.QuadPart = 0;
    Fobx->fOpenCountDecremented = FALSE;
 
    DPRINT("FOBX %p for SRV_OPEN %p FCB %p\n", Fobx, Fobx->SrvOpen, Fobx->SrvOpen->pFcb);
 
    return (PMRX_FOBX)Fobx;
}

RxCreateNetRoot()

PNET_ROOT RxCreateNetRoot	(	IN PSRV_CALL	SrvCall,
		IN PUNICODE_STRING	Name,
		IN ULONG	NetRootFlags,
		IN PRX_CONNECTION_ID OPTIONAL	RxConnectionId
	)

Definition at line 1705 of file rxce.c.

{
    PNET_ROOT NetRoot;
    USHORT CaseInsensitiveLength;
    PRX_PREFIX_TABLE PrefixTable;
 
    DPRINT("RxCreateNetRoot(%p, %wZ, %x, %p)\n", SrvCall, Name, NetRootFlags, RxConnectionId);
 
    PAGED_CODE();
 
    /* We need a SRV_CALL */
    ASSERT(SrvCall != NULL);
 
    PrefixTable = SrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockExclusive(PrefixTable));
 
    /* Get name length */
    CaseInsensitiveLength = SrvCall->PrefixEntry.Prefix.Length + Name->Length;
    if (CaseInsensitiveLength > MAXUSHORT)
    {
        return NULL;
    }
 
    /* Allocate the NetRoot */
    NetRoot = RxAllocateObject(RDBSS_NTC_NETROOT, SrvCall->RxDeviceObject->Dispatch,
                               CaseInsensitiveLength);
    if (NetRoot == NULL)
    {
        return NULL;
    }
 
    /* Construct name */
    RtlMoveMemory(Add2Ptr(NetRoot->PrefixEntry.Prefix.Buffer, SrvCall->PrefixEntry.Prefix.Length),
                  Name->Buffer, Name->Length);
    if (SrvCall->PrefixEntry.Prefix.Length != 0)
    {
        RtlMoveMemory(NetRoot->PrefixEntry.Prefix.Buffer, SrvCall->PrefixEntry.Prefix.Buffer,
                      SrvCall->PrefixEntry.Prefix.Length);
    }
 
    if (!BooleanFlagOn(SrvCall->Flags, SRVCALL_FLAG_CASE_INSENSITIVE_NETROOTS))
    {
        CaseInsensitiveLength = SrvCall->PrefixEntry.CaseInsensitiveLength;
    }
    /* Inisert in prefix table */
    RxPrefixTableInsertName(PrefixTable, &NetRoot->PrefixEntry, NetRoot,
                            (PULONG)&NetRoot->NodeReferenceCount, CaseInsensitiveLength,
                            RxConnectionId);
 
    /* Prepare the FCB table */
    RxInitializeFcbTable(&NetRoot->FcbTable, TRUE);
 
    InitializeListHead(&NetRoot->TransitionWaitList);
    InitializeListHead(&NetRoot->ScavengerFinalizationList);
    InitializeListHead(&NetRoot->VirtualNetRoots);
 
    RxInitializePurgeSyncronizationContext(&NetRoot->PurgeSyncronizationContext);
 
    NetRoot->SerialNumberForEnum = SerialNumber++;
    NetRoot->Flags |= NetRootFlags;
    NetRoot->DiskParameters.ClusterSize = 1;
    NetRoot->DiskParameters.ReadAheadGranularity = ReadAheadGranularity;
    NetRoot->SrvCall = SrvCall;
 
    RxReferenceSrvCall(SrvCall);
 
    DPRINT("NetRootName: %wZ (%p)\n", NetRoot->pNetRootName, NetRoot);
    return NetRoot;
}

Referenced by RxFindOrCreateConnections().

RxCreateNetRootCallBack()

VOID NTAPI RxCreateNetRootCallBack

(

IN PMRX_CREATENETROOT_CONTEXT

CreateNetRootContext

)

Definition at line 1784 of file rxce.c.

{
    PAGED_CODE();
 
    KeSetEvent(&CreateNetRootContext->FinishEvent, IO_NETWORK_INCREMENT, FALSE);
}

Referenced by RxConstructNetRoot().

RxCreateRxContext()

PRX_CONTEXT NTAPI RxCreateRxContext	(	IN PIRP	Irp,
		IN PRDBSS_DEVICE_OBJECT	RxDeviceObject,
		IN ULONG	InitialContextFlags
	)

Definition at line 1797 of file rxce.c.

{
    KIRQL OldIrql;
    PRX_CONTEXT Context;
 
    ASSERT(RxDeviceObject != NULL);
 
    DPRINT("RxCreateRxContext(%p, %p, %u)\n", Irp, RxDeviceObject, InitialContextFlags);
 
#if DBG
    InterlockedIncrement((volatile LONG *)&RxFsdEntryCount);
#endif
    InterlockedIncrement((volatile LONG *)&RxDeviceObject->NumberOfActiveContexts);
 
    /* Allocate the context from our lookaside list */
    Context = ExAllocateFromNPagedLookasideList(&RxContextLookasideList);
    if (Context == NULL)
    {
        return NULL;
    }
 
    /* Zero it */
    RtlZeroMemory(Context, sizeof(RX_CONTEXT));
 
    /* It was allocated on NP pool, keep track of it! */
    SetFlag(Context->Flags, RX_CONTEXT_FLAG_FROM_POOL);
    /* And initialize it */
    RxInitializeContext(Irp, RxDeviceObject, InitialContextFlags, Context);
    ASSERT((Context->MajorFunction != IRP_MJ_CREATE) || !BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_MUST_SUCCEED_ALLOCATED));
 
    /* Add it to our global list */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
    InsertTailList(&RxActiveContexts, &Context->ContextListEntry);
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    DPRINT("Context: %p\n", Context);
    return Context;
}

Referenced by RxChangeBufferingState().

RxCreateSrvCall()

PSRV_CALL RxCreateSrvCall	(	IN PRX_CONTEXT	RxContext,
		IN PUNICODE_STRING	Name,
		IN PUNICODE_STRING InnerNamePrefix	OPTIONAL,
		IN PRX_CONNECTION_ID	RxConnectionId
	)

Definition at line 1843 of file rxce.c.

{
    ULONG NameLength;
    PSRV_CALL SrvCall;
 
    PAGED_CODE();
 
    DPRINT("RxCreateSrvCall(%p, %wZ, %wZ, %p)\n", RxContext, Name, InnerNamePrefix, RxConnectionId);
 
    ASSERT(RxIsPrefixTableLockExclusive(RxContext->RxDeviceObject->pRxNetNameTable));
 
    /* Get the name length */
    NameLength = Name->Length + 2 * sizeof(WCHAR);
    if (InnerNamePrefix != NULL)
    {
        NameLength += InnerNamePrefix->Length;
    }
 
    /* Allocate the object */
    SrvCall = RxAllocateObject(RDBSS_NTC_SRVCALL, NULL, NameLength);
    if (SrvCall == NULL)
    {
        return NULL;
    }
 
    /* Initialize it */
    SrvCall->SerialNumberForEnum = SerialNumber++;
    SrvCall->RxDeviceObject = RxContext->RxDeviceObject;
    RxInitializeBufferingManager(SrvCall);
    InitializeListHead(&SrvCall->TransitionWaitList);
    InitializeListHead(&SrvCall->ScavengerFinalizationList);
    RxInitializePurgeSyncronizationContext(&SrvCall->PurgeSyncronizationContext);
    RxInitializeSrvCallParameters(RxContext, SrvCall);
    RtlMoveMemory(SrvCall->PrefixEntry.Prefix.Buffer, Name->Buffer, Name->Length);
    SrvCall->PrefixEntry.Prefix.MaximumLength = Name->Length + 2 * sizeof(WCHAR);
    SrvCall->PrefixEntry.Prefix.Length = Name->Length;
    RxPrefixTableInsertName(RxContext->RxDeviceObject->pRxNetNameTable, &SrvCall->PrefixEntry,
                            SrvCall, (PULONG)&SrvCall->NodeReferenceCount, Name->Length, RxConnectionId);
 
    DPRINT("SrvCallName: %wZ (%p)\n", SrvCall->pSrvCallName, SrvCall);
    return SrvCall;
}

Referenced by RxFindOrCreateConnections().

RxCreateSrvCallCallBack()

VOID NTAPI RxCreateSrvCallCallBack

(

IN OUT PMRX_SRVCALL_CALLBACK_CONTEXT

Context

)

Definition at line 1895 of file rxce.c.

{
    KIRQL OldIrql;
    PSRV_CALL SrvCall;
    PRX_CONTEXT RxContext;
    ULONG NumberRemaining;
    BOOLEAN StartDispatcher;
    PMRX_SRVCALLDOWN_STRUCTURE Calldown;
 
    DPRINT("RxCreateSrvCallCallBack(%p)\n", Context);
 
    /* Get our context structures */
    Calldown = Context->SrvCalldownStructure;
    SrvCall = (PSRV_CALL)Calldown->SrvCall;
 
    /* If it is a success, that's the winner */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
    if (Context->Status == STATUS_SUCCESS)
    {
        Calldown->BestFinisherOrdinal = Context->CallbackContextOrdinal;
        Calldown->BestFinisher = Context->RxDeviceObject;
    }
    NumberRemaining = --Calldown->NumberRemaining;
    SrvCall->Status = Context->Status;
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    /* Still some to ask, keep going */
    if (NumberRemaining != 0)
    {
        return;
    }
 
    /* If that's not async, signal we're done */
    RxContext = Calldown->RxContext;
    if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
    {
        KeSetEvent(&Calldown->FinishEvent, IO_NETWORK_INCREMENT, FALSE);
        return;
    }
    /* If that's a mailslot, finish construction, no more to do */
    else if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_CREATE_MAILSLOT))
    {
        RxFinishSrvCallConstruction(Calldown);
        return;
    }
 
    /* Queue our finish call for delayed completion */
    DPRINT("Queuing RxFinishSrvCallConstruction() call\n");
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
    InsertTailList(&RxSrvCalldownList, &Calldown->SrvCalldownList);
    StartDispatcher = !RxSrvCallConstructionDispatcherActive;
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    /* If we have to start dispatcher, go ahead */
    if (StartDispatcher)
    {
        NTSTATUS Status;
 
        Status = RxDispatchToWorkerThread(RxFileSystemDeviceObject, CriticalWorkQueue,
                                          RxFinishSrvCallConstructionDispatcher, &RxSrvCalldownList);
        if (!NT_SUCCESS(Status))
        {
            /* It failed - run it manually.... */
            RxFinishSrvCallConstructionDispatcher(NULL);
        }
    }
}

Referenced by RxConstructSrvCall().

RxCreateSrvOpen()

PSRV_OPEN RxCreateSrvOpen	(	IN PV_NET_ROOT	VNetRoot,
		IN OUT PFCB	Fcb
	)

Definition at line 1968 of file rxce.c.

{
    ULONG Flags;
    PSRV_OPEN SrvOpen;
    POOL_TYPE PoolType;
 
    PAGED_CODE();
 
    ASSERT(NodeTypeIsFcb(Fcb));
    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
    PoolType = (BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE) ? NonPagedPool : PagedPool);
 
    _SEH2_TRY
    {
        SrvOpen = Fcb->InternalSrvOpen;
        /* Check whethet we have to allocate a new SRV_OPEN */
        if (Fcb->InternalSrvOpen == NULL || BooleanFlagOn(Fcb->FcbState, FCB_STATE_SRVOPEN_USED) ||
            BooleanFlagOn(Fcb->InternalSrvOpen->Flags, SRVOPEN_FLAG_ENCLOSED_ALLOCATED) ||
            !IsListEmpty(&Fcb->InternalSrvOpen->SrvOpenQLinks))
        {
            /* Proceed */
            SrvOpen = RxAllocateFcbObject(Fcb->VNetRoot->NetRoot->pSrvCall->RxDeviceObject,
                                          RDBSS_NTC_SRVOPEN, PoolType, 0, NULL);
            Flags = 0;
        }
        else
        {
            /* Otherwise, just use internal one and initialize it */
            RxAllocateFcbObject(Fcb->VNetRoot->NetRoot->pSrvCall->RxDeviceObject,
                                RDBSS_NTC_INTERNAL_SRVOPEN, PoolType, 0,
                                Fcb->InternalSrvOpen);
            Fcb->FcbState |= FCB_STATE_SRVOPEN_USED;
            Flags = SRVOPEN_FLAG_ENCLOSED_ALLOCATED | SRVOPEN_FLAG_FOBX_USED;
        }
 
        /* If SrvOpen was properly allocated, initialize it */
        if (SrvOpen != NULL)
        {
            SrvOpen->Flags = Flags;
            SrvOpen->pFcb = RX_GET_MRX_FCB(Fcb);
            SrvOpen->pAlreadyPrefixedName = &Fcb->PrivateAlreadyPrefixedName;
            SrvOpen->pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
            SrvOpen->ulFileSizeVersion = Fcb->ulFileSizeVersion;
            SrvOpen->NodeReferenceCount = 1;
 
            RxReferenceVNetRoot(VNetRoot);
            RxReferenceNetFcb(Fcb);
 
            InsertTailList(&Fcb->SrvOpenList, &SrvOpen->SrvOpenQLinks);
            ++Fcb->SrvOpenListVersion;
 
            InitializeListHead(&SrvOpen->ScavengerFinalizationList);
            InitializeListHead(&SrvOpen->TransitionWaitList);
            InitializeListHead(&SrvOpen->FobxList);
            InitializeListHead(&SrvOpen->SrvOpenKeyList);
        }
    }
    _SEH2_FINALLY
    {
        if (_SEH2_AbnormalTermination())
        {
            if (SrvOpen != NULL)
            {
                RxFinalizeSrvOpen(SrvOpen, TRUE, TRUE);
                SrvOpen = NULL;
            }
        }
        else
        {
            DPRINT("SrvOpen %p for FCB %p\n", SrvOpen, SrvOpen->pFcb);
        }
    }
    _SEH2_END;
 
    return SrvOpen;
}

RxCreateVNetRoot()

PV_NET_ROOT RxCreateVNetRoot	(	IN PRX_CONTEXT	RxContext,
		IN PNET_ROOT	NetRoot,
		IN PUNICODE_STRING	CanonicalName,
		IN PUNICODE_STRING	LocalNetRootName,
		IN PUNICODE_STRING	FilePath,
		IN PRX_CONNECTION_ID	RxConnectionId
	)

Definition at line 2052 of file rxce.c.

{
    NTSTATUS Status;
    PV_NET_ROOT VNetRoot;
    USHORT CaseInsensitiveLength;
 
    PAGED_CODE();
 
    DPRINT("RxCreateVNetRoot(%p, %p, %wZ, %wZ, %wZ, %p)\n", RxContext, NetRoot, CanonicalName,
           LocalNetRootName, FilePath, RxConnectionId);
 
    /* Lock must be held exclusively */
    ASSERT(RxIsPrefixTableLockExclusive(RxContext->RxDeviceObject->pRxNetNameTable));
 
    /* Check for overflow */
    if (LocalNetRootName->Length + NetRoot->PrefixEntry.Prefix.Length > MAXUSHORT)
    {
        return NULL;
    }
 
    /* Get name length and allocate VNetRoot */
    CaseInsensitiveLength = LocalNetRootName->Length + NetRoot->PrefixEntry.Prefix.Length;
    VNetRoot = RxAllocateObject(RDBSS_NTC_V_NETROOT, NetRoot->SrvCall->RxDeviceObject->Dispatch,
                                CaseInsensitiveLength);
    if (VNetRoot == NULL)
    {
        return NULL;
    }
 
    /* Initialize its connection parameters */
    Status = RxInitializeVNetRootParameters(RxContext, &VNetRoot->LogonId, &VNetRoot->SessionId,
                                            &VNetRoot->pUserName, &VNetRoot->pUserDomainName,
                                            &VNetRoot->pPassword, &VNetRoot->Flags);
    if (!NT_SUCCESS(Status))
    {
        RxUninitializeVNetRootParameters(VNetRoot->pUserName, VNetRoot->pUserDomainName,
                                         VNetRoot->pPassword, &VNetRoot->Flags);
        RxFreeObject(VNetRoot);
 
        return NULL;
    }
 
    /* Set name */
    RtlMoveMemory(VNetRoot->PrefixEntry.Prefix.Buffer, CanonicalName->Buffer, VNetRoot->PrefixEntry.Prefix.Length);
 
    VNetRoot->PrefixOffsetInBytes = LocalNetRootName->Length + NetRoot->PrefixEntry.Prefix.Length;
    VNetRoot->NamePrefix.Buffer = Add2Ptr(VNetRoot->PrefixEntry.Prefix.Buffer, VNetRoot->PrefixOffsetInBytes);
    VNetRoot->NamePrefix.Length = VNetRoot->PrefixEntry.Prefix.Length - VNetRoot->PrefixOffsetInBytes;
    VNetRoot->NamePrefix.MaximumLength = VNetRoot->PrefixEntry.Prefix.Length - VNetRoot->PrefixOffsetInBytes;
 
    InitializeListHead(&VNetRoot->TransitionWaitList);
    InitializeListHead(&VNetRoot->ScavengerFinalizationList);
 
    if (!BooleanFlagOn(NetRoot->SrvCall->Flags, SRVCALL_FLAG_CASE_INSENSITIVE_FILENAMES))
    {
        USHORT i;
 
        if (BooleanFlagOn(NetRoot->SrvCall->Flags, SRVCALL_FLAG_CASE_INSENSITIVE_NETROOTS))
        {
            CaseInsensitiveLength = NetRoot->PrefixEntry.CaseInsensitiveLength;
        }
        else
        {
            CaseInsensitiveLength = NetRoot->SrvCall->PrefixEntry.CaseInsensitiveLength;
        }
 
        for (i = 1; i < CanonicalName->Length / sizeof(WCHAR); ++i)
        {
            if (CanonicalName->Buffer[i] != OBJ_NAME_PATH_SEPARATOR)
            {
                break;
            }
        }
 
        CaseInsensitiveLength += (i * sizeof(WCHAR));
    }
 
    /* Insert in prefix table */
    RxPrefixTableInsertName(RxContext->RxDeviceObject->pRxNetNameTable, &VNetRoot->PrefixEntry,
                            VNetRoot, (PULONG)&VNetRoot->NodeReferenceCount, CaseInsensitiveLength,
                            RxConnectionId);
 
    RxReferenceNetRoot(NetRoot);
    RxAddVirtualNetRootToNetRoot(NetRoot, VNetRoot);
 
    /* Finish init */
    VNetRoot->SerialNumberForEnum = SerialNumber++;
    VNetRoot->UpperFinalizationDone = FALSE;
    VNetRoot->ConnectionFinalizationDone = FALSE;
    VNetRoot->AdditionalReferenceForDeleteFsctlTaken = 0;
 
    DPRINT("NamePrefix: %wZ\n", &VNetRoot->NamePrefix);
    DPRINT("PrefixEntry: %wZ\n", &VNetRoot->PrefixEntry.Prefix);
 
    return VNetRoot;
}

Referenced by RxConstructVirtualNetRoot(), and RxFindOrCreateConnections().

RxDereference()

VOID RxDereference	(	IN OUT PVOID	Instance,
		IN LOCK_HOLDING_STATE	LockHoldingState
	)

Definition at line 2159 of file rxce.c.

{
    LONG RefCount;
    NODE_TYPE_CODE NodeType;
    PNODE_TYPE_AND_SIZE Node;
 
    PAGED_CODE();
 
    RxAcquireScavengerMutex();
 
    /* Check we have a node we can handle */
    NodeType = NodeType(Instance);
    ASSERT((NodeType == RDBSS_NTC_SRVCALL) || (NodeType == RDBSS_NTC_NETROOT) ||
           (NodeType == RDBSS_NTC_V_NETROOT) || (NodeType == RDBSS_NTC_SRVOPEN) ||
           (NodeType == RDBSS_NTC_FOBX));
 
    Node = (PNODE_TYPE_AND_SIZE)Instance;
    RefCount = InterlockedDecrement((volatile long *)&Node->NodeReferenceCount);
    ASSERT(RefCount >= 0);
 
    /* Trace refcount */
    switch (NodeType)
    {
        case RDBSS_NTC_SRVCALL:
            PRINT_REF_COUNT(SRVCALL, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_NETROOT:
            PRINT_REF_COUNT(NETROOT, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_V_NETROOT:
            PRINT_REF_COUNT(VNETROOT, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_SRVOPEN:
            PRINT_REF_COUNT(SRVOPEN, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_FOBX:
            PRINT_REF_COUNT(NETFOBX, Node->NodeReferenceCount);
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
 
    /* No need to free - still in use */
    if (RefCount > 1)
    {
        RxReleaseScavengerMutex();
        return;
    }
 
    /* We have to be locked exclusively */
    if (LockHoldingState != LHS_ExclusiveLockHeld)
    {
        if ((NodeType == RDBSS_NTC_FOBX && RefCount == 0) ||
             (NodeType >= RDBSS_NTC_SRVCALL && NodeType <= RDBSS_NTC_V_NETROOT))
        {
            RxpMarkInstanceForScavengedFinalization(Instance);
        }
 
        RxReleaseScavengerMutex();
        return;
    }
    else
    {
        if (BooleanFlagOn(NodeType, RX_SCAVENGER_MASK))
        {
            RxpUndoScavengerFinalizationMarking(Instance);
        }
    }
 
    RxReleaseScavengerMutex();
 
    /* Now, deallocate the memory */
    switch (NodeType)
    {
        case RDBSS_NTC_SRVCALL:
        {
            PSRV_CALL SrvCall;
 
            SrvCall = (PSRV_CALL)Instance;
 
            ASSERT(SrvCall->RxDeviceObject != NULL);
            ASSERT(RxIsPrefixTableLockAcquired(SrvCall->RxDeviceObject->pRxNetNameTable));
            RxFinalizeSrvCall(SrvCall, TRUE, TRUE);
            break;
        }
 
        case RDBSS_NTC_NETROOT:
        {
            PNET_ROOT NetRoot;
 
            NetRoot = (PNET_ROOT)Instance;
 
            ASSERT(NetRoot->pSrvCall->RxDeviceObject != NULL);
            ASSERT(RxIsPrefixTableLockAcquired(NetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable));
            RxFinalizeNetRoot(NetRoot, TRUE, TRUE);
            break;
        }
 
        case RDBSS_NTC_V_NETROOT:
        {
            PV_NET_ROOT VNetRoot;
 
            VNetRoot = (PV_NET_ROOT)Instance;
 
            ASSERT(VNetRoot->pNetRoot->pSrvCall->RxDeviceObject != NULL);
            ASSERT(RxIsPrefixTableLockAcquired(VNetRoot->pNetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable));
            RxFinalizeVNetRoot(VNetRoot, TRUE, TRUE);
            break;
        }
 
        case RDBSS_NTC_SRVOPEN:
        {
            PSRV_OPEN SrvOpen;
 
            SrvOpen = (PSRV_OPEN)Instance;
 
            ASSERT(RxIsFcbAcquired(SrvOpen->Fcb));
            if (SrvOpen->OpenCount == 0)
            {
                RxFinalizeSrvOpen(SrvOpen, FALSE, FALSE);
            }
            break;
        }
 
        case RDBSS_NTC_FOBX:
        {
            PFOBX Fobx;
 
            Fobx = (PFOBX)Instance;
 
            ASSERT(RxIsFcbAcquired(Fobx->SrvOpen->Fcb));
            RxFinalizeNetFobx(Fobx, TRUE, FALSE);
            break;
        }
    }
}

RxDereferenceAndDeleteRxContext_Real()

VOID NTAPI RxDereferenceAndDeleteRxContext_Real

(

IN PRX_CONTEXT

RxContext

)

Definition at line 2309 of file rxce.c.

{
    KIRQL OldIrql;
    ULONG RefCount;
    BOOLEAN Allocated;
    PRX_CONTEXT StopContext = NULL;
 
    /* Make sure we really have a context */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
    ASSERT(RxContext->NodeTypeCode == RDBSS_NTC_RX_CONTEXT);
    RefCount = InterlockedDecrement((volatile LONG *)&RxContext->ReferenceCount);
    /* If refcount is 0, start releasing stuff that needs spinlock held */
    if (RefCount == 0)
    {
        PRDBSS_DEVICE_OBJECT RxDeviceObject;
 
        Allocated = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_FROM_POOL);
 
        /* If that's stop context from DO, remove it */
        RxDeviceObject = RxContext->RxDeviceObject;
        if (RxDeviceObject->StartStopContext.pStopContext == RxContext)
        {
            RxDeviceObject->StartStopContext.pStopContext = NULL;
        }
        else
        {
           /* Remove it from the list */
            ASSERT((RxContext->ContextListEntry.Flink->Blink == &RxContext->ContextListEntry) &&
                   (RxContext->ContextListEntry.Blink->Flink == &RxContext->ContextListEntry));
            RemoveEntryList(&RxContext->ContextListEntry);
 
            /* If that was the last active context, save the stop context */
            if (InterlockedExchangeAdd((volatile LONG *)&RxDeviceObject->NumberOfActiveContexts, -1) == 0)
            {
                if (RxDeviceObject->StartStopContext.pStopContext != NULL)
                {
                    StopContext = RxDeviceObject->StartStopContext.pStopContext;
                }
            }
        }
    }
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    /* Now, deal with what can be done without spinlock held */
    if (RefCount == 0)
    {
        /* Refcount shouldn't have changed */
        ASSERT(RxContext->ReferenceCount == 0);
        /* Reset everything that can be */
        RxPrepareContextForReuse(RxContext);
 
#ifdef RDBSS_TRACKER
        ASSERT(RxContext->AcquireReleaseFcbTrackerX == 0);
#endif
        /* If that was the last active, set the event */
        if (StopContext != NULL)
        {
            StopContext->Flags &= ~RX_CONTEXT_FLAG_RECURSIVE_CALL;
            KeSetEvent(&StopContext->SyncEvent, IO_NO_INCREMENT, FALSE);
        }
 
#if DBG
        /* Is ShadowCrit still owned? Shouldn't happen! */
        if (RxContext->ShadowCritOwner != 0)
        {
            DPRINT1("ShadowCritOwner not null! %lx\n", RxContext->ShadowCritOwner);
            ASSERT(FALSE);
        }
#endif
 
        /* If it was allocated, free it */
        if (Allocated)
        {
            ExFreeToNPagedLookasideList(&RxContextLookasideList, RxContext);
        }
    }
}

Referenced by RxCompleteRequest_Real().

RxDispatchChangeBufferingStateRequests()

VOID NTAPI RxDispatchChangeBufferingStateRequests

(

PVOID

Context

)

Definition at line 2390 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxpDispatchChangeBufferingStateRequests().

RxDispatchToWorkerThread()

NTSTATUS NTAPI RxDispatchToWorkerThread	(	IN PRDBSS_DEVICE_OBJECT	pMRxDeviceObject,
		IN WORK_QUEUE_TYPE	WorkQueueType,
		IN PRX_WORKERTHREAD_ROUTINE	Routine,
		IN PVOID	pContext
	)

Definition at line 2401 of file rxce.c.

{
    NTSTATUS Status;
    PRX_WORK_DISPATCH_ITEM DispatchItem;
 
    /* Allocate a bit of context */
    DispatchItem = RxAllocatePoolWithTag(PagedPool, sizeof(RX_WORK_DISPATCH_ITEM), RX_WORKQ_POOLTAG);
    if (DispatchItem == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Set all the routines, the one our dispatcher will call, the one ntoskrnl will call */
    DispatchItem->DispatchRoutine = Routine;
    DispatchItem->DispatchRoutineParameter = pContext;
    DispatchItem->WorkQueueItem.WorkerRoutine = RxWorkItemDispatcher;
    DispatchItem->WorkQueueItem.Parameter = DispatchItem;
 
    /* Insert item */
    Status = RxInsertWorkQueueItem(pMRxDeviceObject, WorkQueueType, &DispatchItem->WorkQueueItem);
    if (!NT_SUCCESS(Status))
    {
        RxFreePoolWithTag(DispatchItem, RX_WORKQ_POOLTAG);
        DPRINT1("RxInsertWorkQueueItem failed! Queue: %ld, Routine: %p, Context: %p, Status: %lx\n", WorkQueueType, Routine, pContext, Status);
    }
 
    DPRINT("Dispatching: %p, %p\n", Routine, pContext);
 
    return Status;
}

Referenced by RxCreateSrvCallCallBack(), and RxFinalizeSrvCall().

RxExclusivePrefixTableLockToShared()

VOID RxExclusivePrefixTableLockToShared

(

PRX_PREFIX_TABLE

Table

)

Definition at line 2440 of file rxce.c.

{
    PAGED_CODE();
 
    ExConvertExclusiveToSharedLite(&Table->TableLock);
}

Referenced by RxFindOrCreateConnections().

RxExtractServerName()

VOID RxExtractServerName	(	IN PUNICODE_STRING	FilePathName,
		OUT PUNICODE_STRING	SrvCallName,
		OUT PUNICODE_STRING	RestOfName
	)

Definition at line 2452 of file rxce.c.

{
    USHORT i, Length;
 
    PAGED_CODE();
 
    ASSERT(SrvCallName != NULL);
 
    /* SrvCall name will start from the begin up to the first separator */
    SrvCallName->Buffer = FilePathName->Buffer;
    for (i = 1; i < FilePathName->Length / sizeof(WCHAR); ++i)
    {
        if (FilePathName->Buffer[i] == OBJ_NAME_PATH_SEPARATOR)
        {
            break;
        }
    }
 
    /* Compute length */
    Length = (USHORT)((ULONG_PTR)&FilePathName->Buffer[i] - (ULONG_PTR)FilePathName->Buffer);
    SrvCallName->MaximumLength = Length;
    SrvCallName->Length = Length;
 
    /* Return the rest if asked */
    if (RestOfName != NULL)
    {
        Length = (USHORT)((ULONG_PTR)&FilePathName->Buffer[FilePathName->Length / sizeof(WCHAR)] - (ULONG_PTR)FilePathName->Buffer[i]);
        RestOfName->Buffer = &FilePathName->Buffer[i];
        RestOfName->MaximumLength = Length;
        RestOfName->Length = Length;
    }
}

Referenced by RxFindOrCreateConnections().

RxFcbTableInsertFcb()

NTSTATUS RxFcbTableInsertFcb	(	IN OUT PRX_FCB_TABLE	FcbTable,
		IN OUT PFCB	Fcb
	)

Definition at line 2492 of file rxce.c.

{
    PAGED_CODE();
 
    /* We deal with the table, make sure it's locked */
    ASSERT(RxIsFcbTableLockExclusive(FcbTable));
 
    /* Compute the hash */
    Fcb->FcbTableEntry.HashValue = RxTableComputePathHashValue(&Fcb->FcbTableEntry.Path);
 
    RxReferenceNetFcb(Fcb);
 
    /* If no length, it will be our null entry */
    if (Fcb->FcbTableEntry.Path.Length == 0)
    {
        FcbTable->TableEntryForNull = &Fcb->FcbTableEntry;
    }
    /* Otherwise, insert in the appropriate bucket */
    else
    {
        InsertTailList(FCB_HASH_BUCKET(FcbTable, Fcb->FcbTableEntry.HashValue),
                       &Fcb->FcbTableEntry.HashLinks);
    }
 
    /* Propagate the change by incrementing the version number */
    InterlockedIncrement((volatile long *)&FcbTable->Version);
 
    return STATUS_SUCCESS;
}

Referenced by RxCreateNetFcb().

RxFcbTableLookupFcb()

PFCB RxFcbTableLookupFcb	(	IN PRX_FCB_TABLE	FcbTable,
		IN PUNICODE_STRING	Path
	)

Definition at line 2528 of file rxce.c.

{
    PFCB Fcb;
    PRX_FCB_TABLE_ENTRY TableEntry;
 
    PAGED_CODE();
 
    /* No path - easy, that's null entry */
    if (Path == NULL)
    {
        TableEntry = FcbTable->TableEntryForNull;
    }
    else
    {
        ULONG Hash;
        PLIST_ENTRY HashBucket, ListEntry;
 
        /* Otherwise, compute the hash value and find the associated bucket */
        Hash = RxTableComputePathHashValue(Path);
        HashBucket = FCB_HASH_BUCKET(FcbTable, Hash);
        /* If the bucket is empty, it means there's no entry yet */
        if (IsListEmpty(HashBucket))
        {
            TableEntry = NULL;
        }
        else
        {
            /* Otherwise, browse all the entry */
            for (ListEntry = HashBucket->Flink;
                 ListEntry != HashBucket;
                 ListEntry = ListEntry->Flink)
            {
                TableEntry = CONTAINING_RECORD(ListEntry, RX_FCB_TABLE_ENTRY, HashLinks);
                InterlockedIncrement(&FcbTable->Compares);
 
                /* If entry hash and string are equal, thatt's the one! */
                if (TableEntry->HashValue == Hash &&
                    TableEntry->Path.Length == Path->Length &&
                    RtlEqualUnicodeString(Path, &TableEntry->Path, FcbTable->CaseInsensitiveMatch))
                {
                    break;
                }
            }
 
            /* We reached the end? Not found */
            if (ListEntry == HashBucket)
            {
                TableEntry = NULL;
            }
        }
    }
 
    InterlockedIncrement(&FcbTable->Lookups);
 
    /* If table entry isn't null, return the FCB */
    if (TableEntry != NULL)
    {
        Fcb = CONTAINING_RECORD(TableEntry, FCB, FcbTableEntry);
        RxReferenceNetFcb(Fcb);
    }
    else
    {
        Fcb = NULL;
        InterlockedIncrement(&FcbTable->FailedLookups);
    }
 
    return Fcb;
}

RxFcbTableRemoveFcb()

NTSTATUS RxFcbTableRemoveFcb	(	IN OUT PRX_FCB_TABLE	FcbTable,
		IN OUT PFCB	Fcb
	)

Definition at line 2603 of file rxce.c.

{
    PAGED_CODE();
 
    ASSERT(RxIsPrefixTableLockExclusive(FcbTable));
 
    /* If no path, then remove entry for null */
    if (Fcb->FcbTableEntry.Path.Length == 0)
    {
        FcbTable->TableEntryForNull = NULL;
    }
    /* Otherwise, remove from the bucket */
    else
    {
        RemoveEntryList(&Fcb->FcbTableEntry.HashLinks);
    }
 
    /* Reset its list entry */
    InitializeListHead(&Fcb->FcbTableEntry.HashLinks);
 
    /* Propagate the change by incrementing the version number */
    InterlockedIncrement((volatile long *)&FcbTable->Version);
 
    return STATUS_SUCCESS;
}

Referenced by RxFinalizeNetFcb(), and RxRemoveNameNetFcb().

RxFinalizeConnection()

NTSTATUS NTAPI RxFinalizeConnection	(	IN OUT PNET_ROOT	NetRoot,
		IN OUT PV_NET_ROOT VNetRoot	OPTIONAL,
		IN LOGICAL	ForceFilesClosed
	)

Definition at line 2636 of file rxce.c.

{
    NTSTATUS Status;
    PRX_PREFIX_TABLE PrefixTable;
    ULONG UncleanAny, UncleanDir;
    LONG FilesOpen, AdditionalRef;
    BOOLEAN PrefixLocked, FcbTableLocked, ForceClose;
 
    PAGED_CODE();
 
    ASSERT(NodeType(NetRoot) == RDBSS_NTC_NETROOT);
 
    /* Get a BOOLEAN out of LOGICAL
     * -1 is like FALSE but also drops extra V_NET_ROOT reference in case of failure
     */
    ForceClose = (ForceFilesClosed == TRUE ? TRUE : FALSE);
 
    /* First, delete any notification change */
    Status = RxCancelNotifyChangeDirectoryRequestsForVNetRoot(VNetRoot, ForceClose);
    /* If it failed, continue if forced */
    if (Status != STATUS_SUCCESS && !ForceFilesClosed)
    {
        return Status;
    }
    /* Reset status, in case notification deletion failed */
    Status = STATUS_SUCCESS;
 
    PrefixTable = NetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
 
    PrefixLocked = FALSE;
    FcbTableLocked = FALSE;
    FilesOpen = 0;
    AdditionalRef = 0;
    UncleanAny = 0;
    UncleanDir = 0;
    _SEH2_TRY
    {
        RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
        PrefixLocked = TRUE;
 
        RxReferenceNetRoot(NetRoot);
 
        RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, TRUE);
        FcbTableLocked = TRUE;
 
        /* If our V_NET_ROOT wasn't finalized yet, proceed! */
        if (!VNetRoot->ConnectionFinalizationDone)
        {
            USHORT Bucket;
            PRX_FCB_TABLE FcbTable;
 
            DPRINT("Finalizing connection %p: %wZ\n", NetRoot, &NetRoot->PrefixEntry.Prefix);
 
            /* We'll browse all its associated FCB to check whether they're open/orphaned */
            FcbTable = &NetRoot->FcbTable;
            for (Bucket = 0; Bucket < FcbTable->NumberOfBuckets; ++Bucket)
            {
                PLIST_ENTRY BucketList, Entry;
 
                BucketList = &FcbTable->HashBuckets[Bucket];
                Entry = BucketList->Flink;
                while (Entry != BucketList)
                {
                    PFCB Fcb;
 
                    Fcb = CONTAINING_RECORD(Entry, FCB, FcbTableEntry.HashLinks);
                    Entry = Entry->Flink;
 
                    /* FCB for this connection, go ahead */
                    if (Fcb->VNetRoot == VNetRoot)
                    {
                        /* It's still open, and no force? Fail and keep track */
                        if (Fcb->UncleanCount > 0 && !ForceClose)
                        {
                            Status = STATUS_CONNECTION_IN_USE;
                            if (NodeType(Fcb) == RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
                            {
                                ++UncleanDir;
                            }
                            else
                            {
                                ++UncleanAny;
                            }
                        }
                        else
                        {
                            /* Else, force purge */
                            ASSERT(NodeTypeIsFcb(Fcb));
 
                            Status = RxAcquireExclusiveFcb(NULL, Fcb);
                            ASSERT(Status == STATUS_SUCCESS);
 
                            ClearFlag(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED);
 
                            RxScavengeRelatedFobxs(Fcb);
                            RxPurgeFcb(Fcb);
 
                            /* We don't need to release FCB lock, FCB finalize will take care of it */
                        }
                    }
                }
            }
 
            /* No files left, our V_NET_ROOT is finalized */
            if (VNetRoot->NumberOfFobxs == 0)
            {
                VNetRoot->ConnectionFinalizationDone = TRUE;
            }
        }
 
        /* Keep Number of open files and track of the extra reference */
        FilesOpen = VNetRoot->NumberOfFobxs;
        AdditionalRef = VNetRoot->AdditionalReferenceForDeleteFsctlTaken;
        /* If force close, caller doesn't want to keep connection alive
         * and wants it totally close, so drop the V_NET_ROOT too
         */
        if (ForceClose)
        {
            RxFinalizeVNetRoot(VNetRoot, FALSE, TRUE);
        }
    }
    _SEH2_FINALLY
    {
        /* Release what was acquired */
        if (FcbTableLocked)
        {
            RxReleaseFcbTableLock(&NetRoot->FcbTable);
        }
 
        /* If close is forced, only fix status if there are open files */
        if (ForceClose)
        {
            if (Status != STATUS_SUCCESS && UncleanAny != 0)
            {
                Status = STATUS_FILES_OPEN;
            }
        }
        /* Else, fix status and fail closing if there are open files */
        else
        {
            if ((Status != STATUS_SUCCESS && UncleanAny != 0) || FilesOpen > 0)
            {
                Status = STATUS_FILES_OPEN;
            }
        }
 
        DPRINT("UncleanAny: %ld, UncleanDir: %ld, FilesOpen: %ld\n", UncleanAny, UncleanDir, FilesOpen);
 
        /* If we're are asked to remove the extra ref, or if closing was a success, do it;
         * only if it was still referenced!
         */
        if ((ForceFilesClosed == 0xFF || Status == STATUS_SUCCESS) && AdditionalRef != 0)
        {
            VNetRoot->AdditionalReferenceForDeleteFsctlTaken = 0;
            RxDereferenceVNetRoot(VNetRoot, LHS_ExclusiveLockHeld);
        }
 
        if (PrefixLocked)
        {
            RxDereferenceNetRoot(NetRoot, LHS_ExclusiveLockHeld);
            RxReleasePrefixTableLock(PrefixTable);
        }
    }
    _SEH2_END;
 
    return Status;
}

RxFinalizeFcbTable()

VOID RxFinalizeFcbTable

(

IN OUT PRX_FCB_TABLE

FcbTable

)

Definition at line 2811 of file rxce.c.

{
    USHORT Bucket;
 
    PAGED_CODE();
 
    /* Just delete the lock */
    ExDeleteResourceLite(&FcbTable->TableLock);
 
    /* And make sure (checked) that the table is really empty... */
    for (Bucket = 0; Bucket < FcbTable->NumberOfBuckets; ++Bucket)
    {
        ASSERT(IsListEmpty(&FcbTable->HashBuckets[Bucket]));
    }
}

Referenced by RxFinalizeNetRoot().

RxFinalizeNetFcb()

BOOLEAN RxFinalizeNetFcb	(	OUT PFCB	ThisFcb,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize,
		IN LONG	ReferenceCount
	)

Definition at line 2832 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("RxFinalizeNetFcb(%p, %d, %d, %d)\n", ThisFcb, RecursiveFinalize, ForceFinalize, ReferenceCount);
    DPRINT("Finalize: %wZ\n", &ThisFcb->FcbTableEntry.Path);
 
    /* Make sure we have an exclusively acquired FCB */
    ASSERT_CORRECT_FCB_STRUCTURE(ThisFcb);
    ASSERT(RxIsFcbAcquiredExclusive(ThisFcb));
 
    /* We shouldn't force finalization... */
    ASSERT(!ForceFinalize);
 
    /* If recurisve, finalize all the associated SRV_OPEN */
    if (RecursiveFinalize)
    {
        PLIST_ENTRY ListEntry;
 
        for (ListEntry = ThisFcb->SrvOpenList.Flink;
             ListEntry != &ThisFcb->SrvOpenList;
             ListEntry = ListEntry->Flink)
        {
            PSRV_OPEN SrvOpen;
 
            SrvOpen = CONTAINING_RECORD(ListEntry, SRV_OPEN, SrvOpenQLinks);
            RxFinalizeSrvOpen(SrvOpen, TRUE, ForceFinalize);
        }
    }
    /* If FCB is still in use, that's over */
    else
    {
        if (ThisFcb->OpenCount != 0 || ThisFcb->UncleanCount != 0)
        {
            ASSERT(ReferenceCount > 0);
 
            return FALSE;
        }
    }
 
    ASSERT(ReferenceCount >= 1);
 
    /* If FCB is still referenced, that's over - unless you force it and want to BSOD somewhere */
    if (ReferenceCount != 1 && !ForceFinalize)
    {
        return FALSE;
    }
 
    ASSERT(ForceFinalize || ((ThisFcb->OpenCount == 0) && (ThisFcb->UncleanCount == 0)));
 
    DPRINT("Finalizing FCB open: %d (%d)\n", ThisFcb->OpenCount, ForceFinalize);
 
    /* If finalization was not already initiated, go ahead */
    if (!ThisFcb->UpperFinalizationDone)
    {
        /* Free any FCB_LOCK */
        if (NodeType(ThisFcb) == RDBSS_NTC_STORAGE_TYPE_FILE)
        {
            FsRtlUninitializeFileLock(&ThisFcb->Specific.Fcb.FileLock);
 
            while (ThisFcb->BufferedLocks.List != NULL)
            {
                PFCB_LOCK Entry;
 
                Entry = ThisFcb->BufferedLocks.List;
                ThisFcb->BufferedLocks.List = Entry->Next;
 
                RxFreePool(Entry);
            }
        }
 
        /* If not orphaned, it still has a NET_ROOT and potentially is still in a table */
        if (!BooleanFlagOn(ThisFcb->FcbState, FCB_STATE_ORPHANED))
        {
            PNET_ROOT NetRoot;
 
            NetRoot = (PNET_ROOT)ThisFcb->pNetRoot;
 
            ASSERT(RxIsFcbTableLockExclusive(&NetRoot->FcbTable));
            /* So, remove it */
            if (!BooleanFlagOn(ThisFcb->FcbState, FCB_STATE_NAME_ALREADY_REMOVED))
            {
                RxFcbTableRemoveFcb(&NetRoot->FcbTable, ThisFcb);
            }
        }
 
        ThisFcb->UpperFinalizationDone = TRUE;
    }
 
    ASSERT(ReferenceCount >= 1);
 
    /* Even if forced, don't allow broken free */
    if (ReferenceCount != 1)
    {
        return FALSE;
    }
 
    /* Now, release everything */
    if (ThisFcb->pBufferingStateChangeCompletedEvent != NULL)
    {
        RxFreePool(ThisFcb->pBufferingStateChangeCompletedEvent);
    }
 
    if (ThisFcb->MRxDispatch != NULL)
    {
        ThisFcb->MRxDispatch->MRxDeallocateForFcb(RX_GET_MRX_FCB(ThisFcb));
    }
 
    ExDeleteResourceLite(ThisFcb->BufferedLocks.Resource);
    ExDeleteResourceLite(ThisFcb->Header.Resource);
    ExDeleteResourceLite(ThisFcb->Header.PagingIoResource);
 
    InterlockedDecrement((volatile long *)&ThisFcb->pNetRoot->NumberOfFcbs);
    RxDereferenceVNetRoot(ThisFcb->VNetRoot, LHS_LockNotHeld);
 
    ASSERT(IsListEmpty(&ThisFcb->FcbTableEntry.HashLinks));
    ASSERT(!ThisFcb->fMiniInited);
 
    /* And free the object */
    RxFreeFcbObject(ThisFcb);
 
    return TRUE;
}

Referenced by RxpDereferenceAndFinalizeNetFcb().

RxFinalizeNetFobx()

BOOLEAN RxFinalizeNetFobx	(	_Out_ PFOBX	ThisFobx,
		_In_ BOOLEAN	RecursiveFinalize,
		_In_ BOOLEAN	ForceFinalize
	)

Definition at line 2964 of file rxce.c.

{
    PFCB Fcb;
    PSRV_OPEN SrvOpen;
 
    PAGED_CODE();
 
    ASSERT(NodeType(ThisFobx) == RDBSS_NTC_FOBX);
 
    /* Only finalize if forced or if there's no ref left */
    if (ThisFobx->NodeReferenceCount != 0 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalize Fobx: %p (with %d ref), forced: %d\n", ThisFobx, ThisFobx->NodeReferenceCount, ForceFinalize);
 
    SrvOpen = ThisFobx->SrvOpen;
    Fcb = SrvOpen->Fcb;
    /* If it wasn't finalized yet, do it */
    if (!ThisFobx->UpperFinalizationDone)
    {
        ASSERT(NodeType(SrvOpen->Fcb) != RDBSS_NTC_OPENTARGETDIR_FCB);
        ASSERT(RxIsFcbAcquiredExclusive(SrvOpen->Fcb));
 
        /* Remove it from the SRV_OPEN */
        RemoveEntryList(&ThisFobx->FobxQLinks);
 
        /* If we were used to browse a directory, free the query buffer */
        if (BooleanFlagOn(ThisFobx->Flags, FOBX_FLAG_FREE_UNICODE))
        {
            RxFreePoolWithTag(ThisFobx->UnicodeQueryTemplate.Buffer, RX_DIRCTL_POOLTAG);
        }
 
        /* Notify the mini-rdr */
        if (Fcb->MRxDispatch != NULL && Fcb->MRxDispatch->MRxDeallocateForFobx != NULL)
        {
            Fcb->MRxDispatch->MRxDeallocateForFobx((PMRX_FOBX)ThisFobx);
        }
 
        /* If the SRV_OPEN wasn't closed yet, do it */
        if (!BooleanFlagOn(ThisFobx->Flags, FOBX_FLAG_SRVOPEN_CLOSED))
        {
            NTSTATUS Status;
 
            Status = RxCloseAssociatedSrvOpen(ThisFobx, FALSE);
            DPRINT("Closing SRV_OPEN %p for %p: %x\n", SrvOpen, ThisFobx, Status);
        }
 
        /* Finalization done */
        ThisFobx->UpperFinalizationDone = TRUE;
    }
 
    /* If we're still referenced, don't go any further! */
    if (ThisFobx->NodeReferenceCount != 0)
    {
        return FALSE;
    }
 
    /* At that point, everything should be closed */
    ASSERT(IsListEmpty(&ThisFobx->ClosePendingList));
 
    /* Was the FOBX allocated with another object?
     * If so, mark the buffer free in said object
     */
    if (ThisFobx == Fcb->InternalFobx)
    {
        ClearFlag(Fcb->FcbState, FCB_STATE_FOBX_USED);
    }
    else if (ThisFobx == SrvOpen->InternalFobx)
    {
        ClearFlag(SrvOpen->Flags, SRVOPEN_FLAG_FOBX_USED);
    }
 
    ThisFobx->pSrvOpen = NULL;
 
    /* A FOBX less */
    InterlockedDecrement((volatile long *)&SrvOpen->pVNetRoot->NumberOfFobxs);
 
    RxDereferenceSrvOpen(SrvOpen, LHS_ExclusiveLockHeld);
 
    /* If it wasn't allocated with another object, free the FOBX */
    if (!BooleanFlagOn(ThisFobx->Flags, FOBX_FLAG_ENCLOSED_ALLOCATED))
    {
        RxFreeFcbObject(ThisFobx);
    }
 
    return TRUE;
}

Referenced by RxDereference(), RxFinalizeSrvOpen(), and RxScavengeRelatedFobxs().

RxFinalizeNetRoot()

BOOLEAN RxFinalizeNetRoot	(	OUT PNET_ROOT	ThisNetRoot,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize
	)

Definition at line 3062 of file rxce.c.

{
    PSRV_CALL SrvCall;
    PRX_FCB_TABLE FcbTable;
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    ASSERT(NodeType(ThisNetRoot) == RDBSS_NTC_NETROOT);
 
    PrefixTable = ThisNetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
 
    /* If sme finalization is already ongoing, leave */
    if (BooleanFlagOn(ThisNetRoot->Flags, NETROOT_FLAG_FINALIZATION_IN_PROGRESS))
    {
        return FALSE;
    }
 
    /* Mark we're finalizing */
    SetFlag(ThisNetRoot->Flags, NETROOT_FLAG_FINALIZATION_IN_PROGRESS);
 
    FcbTable = &ThisNetRoot->FcbTable;
    /* Did caller asked us to finalize any associated FCB? */
    if (RecursiveFinalize)
    {
        USHORT Bucket;
 
        /* Browse all the FCBs in our FCB table */
        RxAcquireFcbTableLockExclusive(FcbTable, TRUE);
        for (Bucket = 0; Bucket < FcbTable->NumberOfBuckets; ++Bucket)
        {
            PLIST_ENTRY HashBucket, ListEntry;
 
            HashBucket = &FcbTable->HashBuckets[Bucket];
            ListEntry = HashBucket->Flink;
            while (ListEntry != HashBucket)
            {
                PFCB Fcb;
 
                Fcb = CONTAINING_RECORD(ListEntry, FCB, FcbTableEntry.HashLinks);
                ASSERT(NodeTypeIsFcb(Fcb));
 
                ListEntry = ListEntry->Flink;
 
                /* If the FCB isn't orphaned, then, it's time to purge it */
                if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_ORPHANED))
                {
                    NTSTATUS Status;
 
                    Status = RxAcquireExclusiveFcb(NULL, Fcb);
                    ASSERT(Status == STATUS_SUCCESS);
                    RxPurgeFcb(Fcb);
                }
            }
        }
        RxReleaseFcbTableLock(FcbTable);
    }
 
    /* Only finalize if forced or if there's a single ref left */
    if (ThisNetRoot->NodeReferenceCount != 1 && !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalizing NetRoot %p for %wZ\n", ThisNetRoot, &ThisNetRoot->PrefixEntry.Prefix);
 
    /* If we're still referenced, don't go any further! */
    if (ThisNetRoot->NodeReferenceCount != 1)
    {
        return FALSE;
    }
 
    /* Finalize the FCB table (and make sure it's empty!) */
    RxFinalizeFcbTable(FcbTable);
 
    /* If name wasn't remove already, do it now */
    if (!BooleanFlagOn(ThisNetRoot->Flags, NETROOT_FLAG_NAME_ALREADY_REMOVED))
    {
        RxRemovePrefixTableEntry(PrefixTable, &ThisNetRoot->PrefixEntry);
    }
 
    /* Delete the object */
    SrvCall = (PSRV_CALL)ThisNetRoot->pSrvCall;
    RxFreeObject(ThisNetRoot);
 
    /* And dereference the associated SRV_CALL */
    if (SrvCall != NULL)
    {
        RxDereferenceSrvCall(SrvCall, LHS_ExclusiveLockHeld);
    }
 
    return TRUE;
}

Referenced by RxDereference(), and RxFindOrCreateConnections().

RxFinalizeSrvCall()

BOOLEAN RxFinalizeSrvCall	(	OUT PSRV_CALL	ThisSrvCall,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize
	)

Definition at line 3164 of file rxce.c.

{
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    ASSERT(NodeType(ThisSrvCall) == RDBSS_NTC_SRVCALL);
 
    PrefixTable = ThisSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
 
    /* Only finalize if forced or if there's a single ref left */
    if (ThisSrvCall->NodeReferenceCount != 1 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalizing SrvCall %p for %wZ\n", ThisSrvCall, &ThisSrvCall->PrefixEntry.Prefix);
 
    /* If it wasn't finalized yet, do it */
    if (!ThisSrvCall->UpperFinalizationDone)
    {
        BOOLEAN WillFree;
 
        /* Remove ourselves from prefix table */
        RxRemovePrefixTableEntry(PrefixTable, &ThisSrvCall->PrefixEntry);
 
        /* Remember our third arg, in case we get queued for later execution */
        if (ForceFinalize)
        {
            SetFlag(ThisSrvCall->Flags, SRVCALL_FLAG_FORCE_FINALIZED);
        }
 
        /* And done */
        ThisSrvCall->UpperFinalizationDone = TRUE;
 
        /* Would defered execution free the object? */
        WillFree = (ThisSrvCall->NodeReferenceCount == 1);
 
        /* If we have a device object */
        if (ThisSrvCall->RxDeviceObject != NULL)
        {
            NTSTATUS Status;
 
            /* If we're not executing in the RDBSS thread, queue for execution within the thread */
            if (RxGetRDBSSProcess() != IoGetCurrentProcess())
            {
                /* Extra ref, as usual */
                InterlockedIncrement((volatile long *)&ThisSrvCall->NodeReferenceCount);
                /* And dispatch */
                RxDispatchToWorkerThread(ThisSrvCall->RxDeviceObject, DelayedWorkQueue, RxpDestroySrvCall, ThisSrvCall);
 
                /* Return to the caller, in advance, whether we're freeing the object or not */
                return WillFree;
            }
 
            /* If in the right thread already, call the mini-rdr */
            MINIRDR_CALL_THROUGH(Status, ThisSrvCall->RxDeviceObject->Dispatch,
                                 MRxFinalizeSrvCall, ((PMRX_SRV_CALL)ThisSrvCall, ForceFinalize));
            (void)Status;
        }
    }
 
    /* If we're still referenced, don't go any further! */
    if (ThisSrvCall->NodeReferenceCount != 1)
    {
        return FALSE;
    }
 
    /* Don't leak */
    if (ThisSrvCall->pDomainName != NULL)
    {
        RxFreePool(ThisSrvCall->pDomainName);
    }
 
    /* And free! */
    RxTearDownBufferingManager(ThisSrvCall);
    RxFreeObject(ThisSrvCall);
 
    return TRUE;
}

Referenced by RxDereference(), and RxpDestroySrvCall().

RxFinalizeSrvOpen()

BOOLEAN RxFinalizeSrvOpen	(	OUT PSRV_OPEN	ThisSrvOpen,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize
	)

Definition at line 3254 of file rxce.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    /* We have to have a SRV_OPEN */
    ASSERT(NodeType(ThisSrvOpen) == RDBSS_NTC_SRVOPEN);
 
    /* If that's a recursive finalization, finalize any related FOBX */
    if (RecursiveFinalize)
    {
        PLIST_ENTRY ListEntry;
 
        ListEntry = ThisSrvOpen->FobxList.Flink;
        while (ListEntry != &ThisSrvOpen->FobxList)
        {
            PFOBX Fobx;
 
            Fobx = CONTAINING_RECORD(ListEntry, FOBX, FobxQLinks);
            ListEntry = ListEntry->Flink;
            RxFinalizeNetFobx(Fobx, TRUE, ForceFinalize);
        }
    }
 
    /* If we have still references, don't finalize unless forced */
    if (ThisSrvOpen->NodeReferenceCount != 0 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalize SRV_OPEN: %p (with %d ref), forced: %d\n", ThisSrvOpen, ThisSrvOpen->NodeReferenceCount, ForceFinalize);
 
    /* Only finalize if closed, or if it wasn't already done and SRV_OPEN is in a bad shape */
    Fcb = (PFCB)ThisSrvOpen->pFcb;
    if ((!ThisSrvOpen->UpperFinalizationDone && ThisSrvOpen->Condition != Condition_Good) ||
        BooleanFlagOn(ThisSrvOpen->Flags, SRVOPEN_FLAG_CLOSED))
    {
        PV_NET_ROOT VNetRoot;
 
        /* Associated FCB can't be fake one */
        ASSERT(NodeType(Fcb) != RDBSS_NTC_OPENTARGETDIR_FCB);
        ASSERT(RxIsFcbAcquiredExclusive (Fcb));
 
        /* Purge any pending operation */
        RxPurgeChangeBufferingStateRequestsForSrvOpen(ThisSrvOpen);
 
        /* If the FCB wasn't orphaned, inform the mini-rdr about close */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_ORPHANED))
        {
            NTSTATUS Status;
 
            MINIRDR_CALL_THROUGH(Status, Fcb->MRxDispatch, MRxForceClosed, ((PMRX_SRV_OPEN)ThisSrvOpen));
            (void)Status;
        }
 
        /* Remove ourselves from the FCB */
        RemoveEntryList(&ThisSrvOpen->SrvOpenQLinks);
        InitializeListHead(&ThisSrvOpen->SrvOpenQLinks);
        ++Fcb->SrvOpenListVersion;
 
        /* If we have a V_NET_ROOT, dereference it */
        VNetRoot = (PV_NET_ROOT)ThisSrvOpen->pVNetRoot;
        if (VNetRoot != NULL)
        {
            InterlockedDecrement((volatile long *)&VNetRoot->pNetRoot->NumberOfSrvOpens);
            RxDereferenceVNetRoot(VNetRoot, LHS_LockNotHeld);
            ThisSrvOpen->pVNetRoot = NULL;
        }
 
        /* Finalization done */
        ThisSrvOpen->UpperFinalizationDone = TRUE;
    }
 
    /* Don't free memory if still referenced */
    if (ThisSrvOpen->NodeReferenceCount != 0)
    {
        return FALSE;
    }
 
    /* No key association left */
    ASSERT(IsListEmpty(&ThisSrvOpen->SrvOpenKeyList));
 
    /* If we're still in some FCB, remove us */
    if (!IsListEmpty(&ThisSrvOpen->SrvOpenQLinks))
    {
        RemoveEntryList(&ThisSrvOpen->SrvOpenQLinks);
    }
 
    /* If enclosed allocation, mark the memory zone free */
    if (BooleanFlagOn(ThisSrvOpen->Flags, SRVOPEN_FLAG_ENCLOSED_ALLOCATED))
    {
        ClearFlag(Fcb->FcbState, FCB_STATE_SRVOPEN_USED);
    }
    /* Otherwise, free the memory */
    else
    {
        RxFreeFcbObject(ThisSrvOpen);
    }
 
    RxDereferenceNetFcb(Fcb);
 
    return TRUE;
}

Referenced by RxCreateSrvOpen(), RxDereference(), and RxFinalizeNetFcb().

RxFinalizeVNetRoot()

BOOLEAN RxFinalizeVNetRoot	(	OUT PV_NET_ROOT	ThisVNetRoot,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize
	)

Definition at line 3367 of file rxce.c.

{
    PNET_ROOT NetRoot;
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    ASSERT(NodeType(ThisVNetRoot) == RDBSS_NTC_V_NETROOT);
 
    PrefixTable = ThisVNetRoot->pNetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
 
    /* Only finalize if forced or if there's a single ref left */
    if (ThisVNetRoot->NodeReferenceCount != 1 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalizing VNetRoot %p for %wZ\n", ThisVNetRoot, &ThisVNetRoot->PrefixEntry.Prefix);
 
    NetRoot = (PNET_ROOT)ThisVNetRoot->pNetRoot;
    /* If it wasn't finalized yet, do it */
    if (!ThisVNetRoot->UpperFinalizationDone)
    {
        ASSERT(NodeType(NetRoot) == RDBSS_NTC_NETROOT);
 
        /* Reference the NetRoot so that it doesn't disappear */
        RxReferenceNetRoot(NetRoot);
        RxOrphanSrvOpens(ThisVNetRoot);
        /* Remove us from the available VNetRoot for NetRoot */
        RxRemoveVirtualNetRootFromNetRoot(NetRoot, ThisVNetRoot);
        /* Remove extra ref */
        RxDereferenceNetRoot(NetRoot, LHS_ExclusiveLockHeld);
 
        /* Remove ourselves from prefix table */
        RxRemovePrefixTableEntry(PrefixTable, &ThisVNetRoot->PrefixEntry);
 
        /* Finalization done */
        ThisVNetRoot->UpperFinalizationDone = TRUE;
    }
 
    /* If we're still referenced, don't go any further! */
    if (ThisVNetRoot->NodeReferenceCount != 1)
    {
        return FALSE;
    }
 
    /* If there's an associated device, notify mini-rdr */
    if (NetRoot->pSrvCall->RxDeviceObject != NULL)
    {
        NTSTATUS Status;
 
        MINIRDR_CALL_THROUGH(Status, NetRoot->pSrvCall->RxDeviceObject->Dispatch,
                             MRxFinalizeVNetRoot, ((PMRX_V_NET_ROOT)ThisVNetRoot, FALSE));
        (void)Status;
    }
 
    /* Free parameters */
    RxUninitializeVNetRootParameters(ThisVNetRoot->pUserName, ThisVNetRoot->pUserDomainName,
                                     ThisVNetRoot->pPassword, &ThisVNetRoot->Flags);
    /* Dereference our NetRoot, we won't reference it anymore */
    RxDereferenceNetRoot(NetRoot, LHS_ExclusiveLockHeld);
 
    /* And free the object! */
    RxFreePoolWithTag(ThisVNetRoot, RX_V_NETROOT_POOLTAG);
 
    return TRUE;
}

Referenced by RxDereference(), and RxFinalizeConnection().

RxFindOrConstructVirtualNetRoot()

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

Definition at line 3441 of file rxce.c.

{
    ULONG Flags;
    NTSTATUS Status;
    PVOID Container;
    BOOLEAN Construct;
    PV_NET_ROOT VNetRoot;
    RX_CONNECTION_ID ConnectionID;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    LOCK_HOLDING_STATE LockHoldingState;
 
    PAGED_CODE();
 
    RxDeviceObject = RxContext->RxDeviceObject;
    ASSERT(RxDeviceObject->Dispatch != NULL);
    ASSERT(NodeType(RxDeviceObject->Dispatch) == RDBSS_NTC_MINIRDR_DISPATCH);
 
    /* Ask the mini-rdr for connection ID */
    ConnectionID.SessionID = 0;
    if (RxDeviceObject->Dispatch->MRxGetConnectionId != NULL)
    {
        Status = RxDeviceObject->Dispatch->MRxGetConnectionId(RxContext, &ConnectionID);
        if (!NT_SUCCESS(Status) && Status != STATUS_NOT_IMPLEMENTED)
        {
            /* mini-rdr is expected not to fail - unless it's not implemented */
            DPRINT1("Failed to initialize connection ID\n");
            ASSERT(FALSE);
        }
    }
 
    RxContext->Create.NetNamePrefixEntry = NULL;
 
    Status = STATUS_MORE_PROCESSING_REQUIRED;
    RxAcquirePrefixTableLockShared(RxDeviceObject->pRxNetNameTable, TRUE);
    LockHoldingState = LHS_SharedLockHeld;
    Construct = TRUE;
    Flags = 0;
 
    /* We will try twice to find a matching VNetRoot: shared locked and then exlusively locked */
    while (TRUE)
    {
        PNET_ROOT NetRoot;
        PV_NET_ROOT SavedVNetRoot;
 
        /* Look in prefix table */
        Container = RxPrefixTableLookupName(RxDeviceObject->pRxNetNameTable, CanonicalName, RemainingName, &ConnectionID);
        if (Container != NULL)
        {
            /* If that's not a VNetRoot, that's a SrvCall, not interesting, loop again */
            if (NodeType(Container) != RDBSS_NTC_V_NETROOT)
            {
                ASSERT(NodeType(Container) == RDBSS_NTC_SRVCALL);
                RxDereferenceSrvCall(Container, LockHoldingState);
            }
            else
            {
                VNetRoot = Container;
                NetRoot = VNetRoot->NetRoot;
 
                /* If the matching VNetRoot isn't in a good shape, there's something wrong - fail */
                if ((NetRoot->Condition != Condition_InTransition && NetRoot->Condition != Condition_Good) ||
                    NetRoot->SrvCall->RxDeviceObject != RxContext->RxDeviceObject)
                {
                    Status = STATUS_BAD_NETWORK_PATH;
                    SavedVNetRoot = NULL;
                }
                else
                {
                    LUID LogonId;
                    ULONG SessionId;
                    PUNICODE_STRING UserName, UserDomain, Password;
 
                    /* We can reuse if we use same credentials */
                    Status = RxInitializeVNetRootParameters(RxContext, &LogonId,
                                                            &SessionId, &UserName,
                                                            &UserDomain, &Password,
                                                            &Flags);
                    if (NT_SUCCESS(Status))
                    {
                        SavedVNetRoot = VNetRoot;
                        Status = RxCheckVNetRootCredentials(RxContext, VNetRoot,
                                                            &LogonId, UserName,
                                                            UserDomain, Password,
                                                            Flags);
                        if (Status == STATUS_MORE_PROCESSING_REQUIRED)
                        {
                            PLIST_ENTRY ListEntry;
 
                            for (ListEntry = NetRoot->VirtualNetRoots.Flink;
                                 ListEntry != &NetRoot->VirtualNetRoots;
                                 ListEntry = ListEntry->Flink)
                            {
                                SavedVNetRoot = CONTAINING_RECORD(ListEntry, V_NET_ROOT, NetRootListEntry);
                                Status = RxCheckVNetRootCredentials(RxContext, SavedVNetRoot,
                                                                    &LogonId, UserName,
                                                                    UserDomain, Password,
                                                                    Flags);
                                if (Status != STATUS_MORE_PROCESSING_REQUIRED)
                                {
                                    break;
                                }
                            }
 
                            if (ListEntry == &NetRoot->VirtualNetRoots)
                            {
                                SavedVNetRoot = NULL;
                            }
                        }
 
                        if (!NT_SUCCESS(Status))
                        {
                            SavedVNetRoot = NULL;
                        }
 
                        RxUninitializeVNetRootParameters(UserName, UserDomain, Password, &Flags);
                    }
                }
 
                /* We'll fail, if we had referenced a VNetRoot, dereference it */
                if (Status != STATUS_MORE_PROCESSING_REQUIRED && !NT_SUCCESS(Status))
                {
                    if (SavedVNetRoot == NULL)
                    {
                        RxDereferenceVNetRoot(VNetRoot, LockHoldingState);
                    }
                }
                /* Reference VNetRoot we'll keep, and dereference current */
                else if (SavedVNetRoot != VNetRoot)
                {
                    RxDereferenceVNetRoot(VNetRoot, LockHoldingState);
                    if (SavedVNetRoot != NULL)
                    {
                        RxReferenceVNetRoot(SavedVNetRoot);
                    }
                }
            }
 
            /* We may have found something, or we fail hard, so don't attempt to create a VNetRoot */
            if (Status != STATUS_MORE_PROCESSING_REQUIRED)
            {
                Construct = FALSE;
                break;
            }
        }
 
        /* If we're locked exclusive, we won't loop again, it was the second pass */
        if (LockHoldingState != LHS_SharedLockHeld)
        {
            break;
        }
 
        /* Otherwise, prepare for second pass, exclusive, making sure we can acquire without delay */
        if (RxAcquirePrefixTableLockExclusive(RxDeviceObject->pRxNetNameTable, FALSE))
        {
            RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
            LockHoldingState = LHS_ExclusiveLockHeld;
            break;
        }
 
        RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
        RxAcquirePrefixTableLockExclusive(RxDeviceObject->pRxNetNameTable, TRUE);
        LockHoldingState = LHS_ExclusiveLockHeld;
    }
 
    /* We didn't fail, and didn't find any VNetRoot, construct one */
    if (Construct)
    {
        ASSERT(LockHoldingState == LHS_ExclusiveLockHeld);
 
        Status = RxConstructVirtualNetRoot(RxContext, CanonicalName, NetRootType, &VNetRoot, &LockHoldingState, &ConnectionID);
        ASSERT(Status != STATUS_SUCCESS || LockHoldingState != LHS_LockNotHeld);
 
        if (Status == STATUS_SUCCESS)
        {
            DPRINT("CanonicalName: %wZ (%d)\n", CanonicalName, CanonicalName->Length);
            DPRINT("VNetRoot: %wZ (%d)\n", &VNetRoot->PrefixEntry.Prefix, VNetRoot->PrefixEntry.Prefix.Length);
            ASSERT(CanonicalName->Length >= VNetRoot->PrefixEntry.Prefix.Length);
 
            RemainingName->Buffer = Add2Ptr(CanonicalName->Buffer, VNetRoot->PrefixEntry.Prefix.Length);
            RemainingName->Length = CanonicalName->Length - VNetRoot->PrefixEntry.Prefix.Length;
            RemainingName->MaximumLength = RemainingName->Length;
 
            if (BooleanFlagOn(Flags, VNETROOT_FLAG_CSCAGENT_INSTANCE))
            {
                DPRINT("CSC instance, VNetRoot: %p\n", VNetRoot);
            }
            VNetRoot->Flags |= Flags;
        }
    }
 
    /* Release the prefix table - caller expects it to be released */
    if (LockHoldingState != LHS_LockNotHeld)
    {
        RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
    }
 
    /* If we failed creating, quit */
    if (Status != STATUS_SUCCESS)
    {
        DPRINT1("RxFindOrConstructVirtualNetRoot() = Status: %x\n", Status);
        return Status;
    }
 
    /* Otherwise, wait until the VNetRoot is stable */
    DPRINT("Waiting for stable condition for: %p\n", VNetRoot);
    RxWaitForStableVNetRoot(VNetRoot, RxContext);
    /* It's all good, update the RX_CONTEXT with all our structs */
    if (VNetRoot->Condition == Condition_Good)
    {
        PNET_ROOT NetRoot;
 
        NetRoot = VNetRoot->NetRoot;
        RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
        RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
        RxContext->Create.pSrvCall = (PMRX_SRV_CALL)NetRoot->SrvCall;
    }
    else
    {
        RxDereferenceVNetRoot(VNetRoot, LHS_LockNotHeld);
        RxContext->Create.pVNetRoot = NULL;
        Status = STATUS_BAD_NETWORK_PATH;
    }
 
    return Status;
}

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

RxFinishFcbInitialization()

VOID NTAPI RxFinishFcbInitialization	(	IN OUT PMRX_FCB	Fcb,
		IN RX_FILE_TYPE	FileType,
		IN PFCB_INIT_PACKET InitPacket	OPTIONAL
	)

Definition at line 4030 of file rxce.c.

{
    RX_FILE_TYPE OldType;
 
    PAGED_CODE();
 
    DPRINT("RxFinishFcbInitialization(%p, %x, %p)\n", Fcb, FileType, InitPacket);
 
    OldType = NodeType(Fcb);
    NodeType(Fcb) = FileType;
    /* If mini-rdr already did the job for mailslot attributes, 0 the rest */
    if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_TIME_AND_SIZE_ALREADY_SET) && FileType == RDBSS_NTC_MAILSLOT)
    {
        FILL_IN_FCB((PFCB)Fcb, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    }
    /* Otherwise, if mini-rdr provided us with an init packet, copy its data */
    else if (InitPacket != NULL)
    {
        FILL_IN_FCB((PFCB)Fcb, *InitPacket->pAttributes, *InitPacket->pNumLinks,
                    InitPacket->pCreationTime->QuadPart, InitPacket->pLastAccessTime->QuadPart,
                    InitPacket->pLastWriteTime->QuadPart, InitPacket->pLastChangeTime->QuadPart,
                    InitPacket->pAllocationSize->QuadPart, InitPacket->pFileSize->QuadPart,
                    InitPacket->pValidDataLength->QuadPart);
    }
 
    if (FileType != RDBSS_NTC_STORAGE_TYPE_UNKNOWN &&
        FileType != RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
    {
        /* If our FCB newly points to a file, initiliaze everything related */
        if (FileType == RDBSS_NTC_STORAGE_TYPE_FILE)
 
        {
            if (OldType != RDBSS_NTC_STORAGE_TYPE_FILE)
            {
                RxInitializeLowIoPerFcbInfo(&((PFCB)Fcb)->Specific.Fcb.LowIoPerFcbInfo);
                FsRtlInitializeFileLock(&((PFCB)Fcb)->Specific.Fcb.FileLock, RxLockOperationCompletion,
                                        RxUnlockOperation);
 
                ((PFCB)Fcb)->BufferedLocks.List = NULL;
                ((PFCB)Fcb)->BufferedLocks.PendingLockOps = 0;
 
                Fcb->Header.IsFastIoPossible = FastIoIsQuestionable;
            }
        }
        /* If not a file, validate type */
        else
        {
            ASSERT(FileType >= RDBSS_NTC_SPOOLFILE && FileType <= RDBSS_NTC_MAILSLOT);
        }
    }
}

RxFinishSrvCallConstruction()

NTSTATUS RxFinishSrvCallConstruction

(

PMRX_SRVCALLDOWN_STRUCTURE

Calldown

)

Definition at line 4089 of file rxce.c.

{
    NTSTATUS Status;
    PSRV_CALL SrvCall;
    PRX_CONTEXT Context;
    RX_BLOCK_CONDITION Condition;
    PRX_PREFIX_TABLE PrefixTable;
 
    DPRINT("RxFinishSrvCallConstruction(%p)\n", Calldown);
 
    SrvCall = (PSRV_CALL)Calldown->SrvCall;
    Context = Calldown->RxContext;
    PrefixTable = Context->RxDeviceObject->pRxNetNameTable;
 
    /* We have a winner, notify him */
    if (Calldown->BestFinisher != NULL)
    {
        DPRINT("Notify the winner: %p (%wZ)\n", Calldown->BestFinisher, &Calldown->BestFinisher->DeviceName);
 
        ASSERT(SrvCall->RxDeviceObject == Calldown->BestFinisher);
 
        MINIRDR_CALL_THROUGH(Status, Calldown->BestFinisher->Dispatch,
                             MRxSrvCallWinnerNotify,
                             ((PMRX_SRV_CALL)SrvCall, TRUE,
                              Calldown->CallbackContexts[Calldown->BestFinisherOrdinal].RecommunicateContext));
        if (Status != STATUS_SUCCESS)
        {
            Condition = Condition_Bad;
        }
        else
        {
            Condition = Condition_Good;
        }
    }
    /* Otherwise, just fail our SRV_CALL */
    else
    {
        Status = Calldown->CallbackContexts[0].Status;
        Condition = Condition_Bad;
    }
 
    RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
    RxTransitionSrvCall(SrvCall, Condition);
    RxFreePoolWithTag(Calldown, RX_SRVCALL_POOLTAG);
 
    /* If async, finish it here, otherwise, caller has already finished the stuff */
    if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
    {
        DPRINT("Finishing async call\n");
 
        RxReleasePrefixTableLock(PrefixTable);
 
        /* Make sure we weren't cancelled in-between */
        if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_CANCELLED))
        {
            Status = STATUS_CANCELLED;
        }
 
        /* In case that was a create, context can be reused */
        if (Context->MajorFunction == IRP_MJ_CREATE)
        {
            RxpPrepareCreateContextForReuse(Context);
        }
 
        /* If that's a failure, reset everything and return failure */
        if (Status != STATUS_SUCCESS)
        {
            Context->MajorFunction = Context->CurrentIrpSp->MajorFunction;
            if (Context->MajorFunction == IRP_MJ_DEVICE_CONTROL)
            {
                if (Context->Info.Buffer != NULL)
                {
                    RxFreePool(Context->Info.Buffer);
                    Context->Info.Buffer = NULL;
                }
            }
            Context->CurrentIrp->IoStatus.Information = 0;
            Context->CurrentIrp->IoStatus.Status = Status;
            RxCompleteRequest(Context, Status);
        }
        /* Otherwise, call resume routine and done! */
        else
        {
            Status = Context->ResumeRoutine(Context);
            if (Status != STATUS_PENDING)
            {
                RxCompleteRequest(Context, Status);
            }
 
            DPRINT("Not completing, pending\n");
        }
    }
 
    RxDereferenceSrvCall(SrvCall, LHS_LockNotHeld);
    return Status;
}

Referenced by RxConstructSrvCall(), RxCreateSrvCallCallBack(), and RxFinishSrvCallConstructionDispatcher().

RxFinishSrvCallConstructionDispatcher()

VOID NTAPI RxFinishSrvCallConstructionDispatcher

(

IN PVOID

Context

)

Definition at line 4192 of file rxce.c.

{
    KIRQL OldIrql;
    BOOLEAN Direct, KeepLoop;
 
    DPRINT("RxFinishSrvCallConstructionDispatcher(%p)\n", Context);
 
    /* In case of failure of starting dispatcher, context is not set
     * We keep track of it to fail associated SRV_CALL
     */
    Direct = (Context == NULL);
 
    /* Separated thread, loop forever */
    while (TRUE)
    {
        PLIST_ENTRY ListEntry;
        PMRX_SRVCALLDOWN_STRUCTURE Calldown;
 
        /* If there are no SRV_CALL to finalize left, just finish thread */
        KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
        if (IsListEmpty(&RxSrvCalldownList))
        {
            KeepLoop =  FALSE;
            RxSrvCallConstructionDispatcherActive = FALSE;
        }
        /* Otherwise, get the SRV_CALL to finish construction */
        else
        {
            ListEntry = RemoveHeadList(&RxSrvCalldownList);
            KeepLoop =  TRUE;
        }
        KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
        /* Nothing to do */
        if (!KeepLoop)
        {
            break;
        }
 
        /* If direct is set, reset the finisher to avoid electing a winner
         * and fail SRV_CALL (see upper comment)
         */
        Calldown = CONTAINING_RECORD(ListEntry, MRX_SRVCALLDOWN_STRUCTURE, SrvCalldownList);
        if (Direct)
        {
            Calldown->BestFinisher = NULL;
        }
        /* Finish SRV_CALL construction */
        RxFinishSrvCallConstruction(Calldown);
    }
}

Referenced by RxCreateSrvCallCallBack().

RxFlushFcbInSystemCache()

NTSTATUS RxFlushFcbInSystemCache	(	IN PFCB	Fcb,
		IN BOOLEAN	SynchronizeWithLazyWriter
	)

Definition at line 4249 of file rxce.c.

{
    IO_STATUS_BLOCK IoStatus;
 
    PAGED_CODE();
 
    /* Deal with Cc */
    CcFlushCache(&Fcb->NonPaged->SectionObjectPointers, NULL, 0, &IoStatus);
    /* If we're asked to sync with LW, do it in case of success */
    if (SynchronizeWithLazyWriter && NT_SUCCESS(IoStatus.Status))
    {
        RxAcquirePagingIoResource((PRX_CONTEXT)NULL, Fcb);
        RxReleasePagingIoResource((PRX_CONTEXT)NULL, Fcb);
    }
 
    DPRINT("Flushing for FCB %p returns %lx\n", Fcb, IoStatus.Status);
    return IoStatus.Status;
}

Referenced by RxChangeBufferingState(), and RxPurgeFcbInSystemCache().

RxFreeFcbObject()

VOID RxFreeFcbObject

(

PVOID

Object

)

Definition at line 4274 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("Freeing %p\n", Object);
 
    /* If that's a FOBX/SRV_OPEN, nothing to do, just free it */
    if (NodeType(Object) == RDBSS_NTC_FOBX || NodeType(Object) == RDBSS_NTC_SRVOPEN)
    {
        RxFreePoolWithTag(Object, RX_FCB_POOLTAG);
    }
    /* If that's a FCB... */
    else if (NodeTypeIsFcb(Object))
    {
        PFCB Fcb;
        PRDBSS_DEVICE_OBJECT DeviceObject;
 
        Fcb = (PFCB)Object;
        DeviceObject = Fcb->RxDeviceObject;
 
        /* Delete per stream contexts */
        FsRtlTeardownPerStreamContexts(&Fcb->Header);
 
        SetFlag(Fcb->Header.Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH);
 
        /* If there was a non-paged FCB allocated, free it */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE))
        {
            RxFreePoolWithTag(Fcb->NonPaged, RX_NONPAGEDFCB_POOLTAG);
        }
 
        /* Free the FCB */
        RxFreePool(Fcb);
 
        /* Update statistics */
        InterlockedDecrement(&RxNumberOfActiveFcbs);
        InterlockedDecrement((volatile long *)&DeviceObject->NumberOfActiveFcbs);
    }
}

Referenced by RxFinalizeNetFcb(), RxFinalizeNetFobx(), and RxFinalizeSrvOpen().

RxFreeObject()

VOID RxFreeObject

(

PVOID

pObject

)

Definition at line 4319 of file rxce.c.

{
    PAGED_CODE();
 
    /* First, perform a few sanity checks if we're dealing with a SRV_CALL or a NET_ROOT */
    if (NodeType(pObject) == RDBSS_NTC_SRVCALL)
    {
        PSRV_CALL SrvCall;
        PRDBSS_DEVICE_OBJECT DeviceObject;
 
        SrvCall = (PSRV_CALL)pObject;
        DeviceObject = SrvCall->RxDeviceObject;
        if (DeviceObject != NULL)
        {
            if (!BooleanFlagOn(DeviceObject->Dispatch->MRxFlags, RDBSS_MANAGE_SRV_CALL_EXTENSION))
            {
                ASSERT(SrvCall->Context == NULL);
            }
 
            ASSERT(SrvCall->Context2 == NULL);
 
            SrvCall->RxDeviceObject = NULL;
        }
    }
    else if (NodeType(pObject) == RDBSS_NTC_NETROOT)
    {
        PNET_ROOT NetRoot;
 
        NetRoot = (PNET_ROOT)pObject;
        NetRoot->pSrvCall = NULL;
        NetRoot->NodeTypeCode = NodeType(pObject) | 0xF000;
    }
 
    /* And just free the object */
    RxFreePool(pObject);
}

Referenced by RxCreateVNetRoot(), RxFinalizeNetRoot(), and RxFinalizeSrvCall().

RxGatherRequestsForSrvOpen()

VOID RxGatherRequestsForSrvOpen	(	IN OUT PSRV_CALL	SrvCall,
		IN PSRV_OPEN	SrvOpen,
		IN OUT PLIST_ENTRY	RequestsListHead
	)

Definition at line 4361 of file rxce.c.

{
    KIRQL OldIrql;
    LIST_ENTRY Discarded, *Entry;
    PCHANGE_BUFFERING_STATE_REQUEST Request;
 
    /* Dispatch any pending operation first */
    RxpDispatchChangeBufferingStateRequests(SrvCall, SrvOpen, &Discarded);
 
    /* Then, get any entry related to our key and SRV_OPEN */
    KeAcquireSpinLock(&SrvCall->BufferingManager.SpinLock, &OldIrql);
    Entry = SrvCall->BufferingManager.HandlerList.Flink;
    while (Entry != &SrvCall->BufferingManager.HandlerList)
    {
        Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
        Entry = Entry->Flink;
        if (Request->SrvOpenKey == SrvOpen->Key && Request->SrvOpen == SrvOpen)
        {
            RemoveEntryList(&Request->ListEntry);
            InsertTailList(RequestsListHead, &Request->ListEntry);
        }
    }
    KeReleaseSpinLock(&SrvCall->BufferingManager.SpinLock, OldIrql);
 
    /* Perform the same search in the last change list */
    Entry = SrvCall->BufferingManager.LastChanceHandlerList.Flink;
    while (Entry != &SrvCall->BufferingManager.LastChanceHandlerList)
    {
        Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
        Entry = Entry->Flink;
        if (Request->SrvOpenKey == SrvOpen->Key && Request->SrvOpen == SrvOpen)
        {
            RemoveEntryList(&Request->ListEntry);
            InsertTailList(RequestsListHead, &Request->ListEntry);
        }
    }
 
    /* Discard the discarded requests */
    RxpDiscardChangeBufferingStateRequests(&Discarded);
}

Referenced by RxPurgeChangeBufferingStateRequestsForSrvOpen().

RxGetDeviceObjectOfInstance()

PRDBSS_DEVICE_OBJECT RxGetDeviceObjectOfInstance

(

PVOID

Instance

)

Definition at line 4409 of file rxce.c.

{
    NODE_TYPE_CODE NodeType;
    PRDBSS_DEVICE_OBJECT DeviceObject;
 
    PAGED_CODE();
 
    /* We only handle a few object types */
    NodeType = NodeType(Instance);
    ASSERT((NodeType == RDBSS_NTC_SRVCALL) || (NodeType == RDBSS_NTC_NETROOT) ||
           (NodeType == RDBSS_NTC_V_NETROOT) || (NodeType == RDBSS_NTC_SRVOPEN) || (NodeType == RDBSS_NTC_FOBX));
 
    /* Get the device object depending on the object */
    switch (NodeType)
    {
        case RDBSS_NTC_FOBX:
        {
            PFOBX Fobx;
 
            Fobx = (PFOBX)Instance;
            DeviceObject = Fobx->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_SRVCALL:
        {
            PSRV_CALL SrvCall;
 
            SrvCall = (PSRV_CALL)Instance;
            DeviceObject = SrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_NETROOT:
        {
            PNET_ROOT NetRoot;
 
            NetRoot = (PNET_ROOT)Instance;
            DeviceObject = NetRoot->pSrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_V_NETROOT:
        {
            PV_NET_ROOT VNetRoot;
 
            VNetRoot = (PV_NET_ROOT)Instance;
            DeviceObject = VNetRoot->pNetRoot->pSrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_SRVOPEN:
        {
            PSRV_OPEN SrvOpen;
 
            SrvOpen = (PSRV_OPEN)Instance;
            DeviceObject = ((PFCB)SrvOpen->pFcb)->RxDeviceObject;
            break;
        }
 
        default:
            DeviceObject = NULL;
            break;
    }
 
    /* Job done */
    return DeviceObject;
}

Referenced by RxpMarkInstanceForScavengedFinalization(), and RxpUndoScavengerFinalizationMarking().

RxGetFileSizeWithLock()

VOID RxGetFileSizeWithLock	(	IN PFCB	Fcb,
		OUT PLONGLONG	FileSize
	)

Definition at line 4483 of file rxce.c.

{
    PAGED_CODE();
 
    *FileSize = Fcb->Header.FileSize.QuadPart;
}

RxGetRDBSSProcess()

PEPROCESS NTAPI RxGetRDBSSProcess

(

VOID

)

Definition at line 4497 of file rxce.c.

{
    return RxData.OurProcess;
}

Referenced by nfs41_CreateSrvCall(), and RxFinalizeSrvCall().

RxInitializeBufferingManager()

NTSTATUS RxInitializeBufferingManager

(

PSRV_CALL

SrvCall

)

Definition at line 4507 of file rxce.c.

{
    KeInitializeSpinLock(&SrvCall->BufferingManager.SpinLock);
    InitializeListHead(&SrvCall->BufferingManager.DispatcherList);
    InitializeListHead(&SrvCall->BufferingManager.HandlerList);
    InitializeListHead(&SrvCall->BufferingManager.LastChanceHandlerList);
    SrvCall->BufferingManager.DispatcherActive = FALSE;
    SrvCall->BufferingManager.HandlerInactive = FALSE;
    SrvCall->BufferingManager.LastChanceHandlerActive = FALSE;
    SrvCall->BufferingManager.NumberOfOutstandingOpens = 0;
    InitializeListHead(&SrvCall->BufferingManager.SrvOpenLists[0]);
    ExInitializeFastMutex(&SrvCall->BufferingManager.Mutex);
 
    return STATUS_SUCCESS;
}

Referenced by RxCreateSrvCall().

RxInitializeContext()

VOID NTAPI RxInitializeContext	(	IN PIRP	Irp,
		IN PRDBSS_DEVICE_OBJECT	RxDeviceObject,
		IN ULONG	InitialContextFlags,
		IN OUT PRX_CONTEXT	RxContext
	)

Definition at line 4529 of file rxce.c.

{
    PIO_STACK_LOCATION Stack;
 
    /* Initialize our various fields */
    RxContext->NodeTypeCode = RDBSS_NTC_RX_CONTEXT;
    RxContext->NodeByteSize = sizeof(RX_CONTEXT);
    RxContext->ReferenceCount = 1;
    RxContext->SerialNumber = InterlockedExchangeAdd((volatile LONG *)&RxContextSerialNumberCounter, 1);
    RxContext->RxDeviceObject = RxDeviceObject;
    KeInitializeEvent(&RxContext->SyncEvent, SynchronizationEvent, FALSE);
    RxInitializeScavengerEntry(&RxContext->ScavengerEntry);
    InitializeListHead(&RxContext->BlockedOperations);
    RxContext->MRxCancelRoutine = NULL;
    RxContext->ResumeRoutine = NULL;
    RxContext->Flags |= InitialContextFlags;
    RxContext->CurrentIrp = Irp;
    RxContext->LastExecutionThread = PsGetCurrentThread();
    RxContext->OriginalThread = RxContext->LastExecutionThread;
 
    /* If've got no IRP, mark RX_CONTEXT */
    if (Irp == NULL)
    {
        RxContext->CurrentIrpSp = NULL;
        RxContext->MajorFunction = IRP_MJ_MAXIMUM_FUNCTION + 1;
        RxContext->MinorFunction = 0;
    }
    else
    {
        /* Otherwise, first determine whether we are performing async operation */
        Stack = IoGetCurrentIrpStackLocation(Irp);
        if (Stack->FileObject != NULL)
        {
            PFCB Fcb;
 
            Fcb = Stack->FileObject->FsContext;
            if (!IoIsOperationSynchronous(Irp) ||
                ((Fcb != NULL && NodeTypeIsFcb(Fcb)) &&
                 (Stack->MajorFunction == IRP_MJ_READ || Stack->MajorFunction == IRP_MJ_WRITE || Stack->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
                 (Fcb->pNetRoot != NULL && (Fcb->pNetRoot->Type == NET_ROOT_PIPE))))
            {
                RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
            }
        }
 
        if (Stack->MajorFunction == IRP_MJ_DIRECTORY_CONTROL && Stack->MinorFunction == IRP_MN_NOTIFY_CHANGE_DIRECTORY)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
        }
        if (Stack->MajorFunction == IRP_MJ_DEVICE_CONTROL)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
        }
 
        /* Set proper flags if TopLevl IRP/Device */
        if (!RxIsThisTheTopLevelIrp(Irp))
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_RECURSIVE_CALL;
        }
        if (RxGetTopDeviceObjectIfRdbssIrp() == RxDeviceObject)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_THIS_DEVICE_TOP_LEVEL;
        }
 
        /* Copy stack information */
        RxContext->MajorFunction = Stack->MajorFunction;
        RxContext->MinorFunction = Stack->MinorFunction;
        ASSERT(RxContext->MajorFunction <= IRP_MJ_MAXIMUM_FUNCTION);
        RxContext->CurrentIrpSp = Stack;
 
        /* If we have a FO associated, learn for more */
        if (Stack->FileObject != NULL)
        {
            PFCB Fcb;
            PFOBX Fobx;
 
            /* Get the FCB and CCB (FOBX) */
            Fcb = Stack->FileObject->FsContext;
            Fobx = Stack->FileObject->FsContext2;
            RxContext->pFcb = (PMRX_FCB)Fcb;
            if (Fcb != NULL && NodeTypeIsFcb(Fcb))
            {
                RxContext->NonPagedFcb = Fcb->NonPaged;
            }
 
            /* We have a FOBX, this not a DFS opening, keep track of it */
            if (Fobx != NULL && Fobx != UIntToPtr(DFS_OPEN_CONTEXT) && Fobx != UIntToPtr(DFS_DOWNLEVEL_OPEN_CONTEXT))
            {
                RxContext->pFobx = (PMRX_FOBX)Fobx;
                RxContext->pRelevantSrvOpen = Fobx->pSrvOpen;
                if (Fobx->NodeTypeCode == RDBSS_NTC_FOBX)
                {
                    RxContext->FobxSerialNumber = InterlockedIncrement((volatile LONG *)&Fobx->FobxSerialNumber);
                }
            }
            else
            {
                RxContext->pFobx = NULL;
            }
 
            /* In case of directory change notification, Fobx may be a VNetRoot, take note of that */
            if (RxContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL && RxContext->MinorFunction == IRP_MN_NOTIFY_CHANGE_DIRECTORY &&
                Fobx != NULL)
            {
                PV_NET_ROOT VNetRoot = NULL;
 
                if (Fobx->NodeTypeCode == RDBSS_NTC_FOBX)
                {
                    VNetRoot = Fcb->VNetRoot;
                }
                else if (Fobx->NodeTypeCode == RDBSS_NTC_V_NETROOT)
                {
                    VNetRoot = (PV_NET_ROOT)Fobx;
                }
 
                if (VNetRoot != NULL)
                {
                    RxContext->NotifyChangeDirectory.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
                }
            }
 
            /* Remember if that's a write through file */
            RxContext->RealDevice = Stack->FileObject->DeviceObject;
            if (BooleanFlagOn(Stack->FileObject->Flags, FO_WRITE_THROUGH))
            {
                RxContext->Flags |= RX_CONTEXT_FLAG_WRITE_THROUGH;
            }
        }
    }
 
    if (RxContext->MajorFunction != IRP_MJ_DEVICE_CONTROL)
    {
        DPRINT("New Ctxt: %p for MN: %d, IRP: %p, THRD: %p, FCB: %p, FOBX:%p #%lx\n",
               RxContext, RxContext->MinorFunction, Irp,
               PsGetCurrentThread(), RxContext->pFcb, RxContext->pFobx,
               RxContext->SerialNumber);
    }
}

Referenced by RxCreateRxContext(), and RxReinitializeContext().

RxInitializeDebugSupport()

VOID NTAPI RxInitializeDebugSupport

(

VOID

)

Definition at line 4677 of file rxce.c.

{
    /* Nothing to do */
}

Referenced by RxDriverEntry().

RxInitializeDispatcher()

NTSTATUS NTAPI RxInitializeDispatcher

(

VOID

)

Definition at line 4688 of file rxce.c.

{
    NTSTATUS Status;
    HANDLE ThreadHandle;
 
    PAGED_CODE();
 
    RxFileSystemDeviceObject->DispatcherContext.NumberOfWorkerThreads = 0;
    RxFileSystemDeviceObject->DispatcherContext.pTearDownEvent = NULL;
 
    /* Set appropriate timeouts: 10s & 60s */
    RxWorkQueueWaitInterval[CriticalWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxWorkQueueWaitInterval[DelayedWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxWorkQueueWaitInterval[HyperCriticalWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxSpinUpDispatcherWaitInterval.QuadPart = -60 * 1000 * 1000 * 10;
 
    RxDispatcher.NumberOfProcessors = 1;
    RxDispatcher.OwnerProcess = IoGetCurrentProcess();
    RxDispatcher.pWorkQueueDispatcher = &RxDispatcherWorkQueues;
 
    /* Initialize our dispatchers */
    Status = RxInitializeWorkQueueDispatcher(RxDispatcher.pWorkQueueDispatcher);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    Status = RxInitializeMRxDispatcher(RxFileSystemDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* And start them */
    RxDispatcher.State = RxDispatcherActive;
    InitializeListHead(&RxDispatcher.SpinUpRequests);
    KeInitializeSpinLock(&RxDispatcher.SpinUpRequestsLock);
    KeInitializeEvent(&RxDispatcher.SpinUpRequestsEvent, 0, 0);
    KeInitializeEvent(&RxDispatcher.SpinUpRequestsTearDownEvent, 0, 0);
    Status = PsCreateSystemThread(&ThreadHandle, PROCESS_ALL_ACCESS, NULL,
                                  NULL, NULL, RxSpinUpRequestsDispatcher, &RxDispatcher);
    if (NT_SUCCESS(Status))
    {
        ZwClose(ThreadHandle);
    }
 
    return Status;
}

Referenced by RxDriverEntry().

RxInitializeFcbTable()

VOID RxInitializeFcbTable	(	IN OUT PRX_FCB_TABLE	FcbTable,
		IN BOOLEAN	CaseInsensitiveMatch
	)

Definition at line 4742 of file rxce.c.

{
    USHORT i;
 
    PAGED_CODE();
 
    FcbTable->NodeTypeCode = RDBSS_NTC_FCB_TABLE;
    FcbTable->NodeByteSize = sizeof(RX_FCB_TABLE);
 
    ExInitializeResourceLite(&FcbTable->TableLock);
    FcbTable->CaseInsensitiveMatch = CaseInsensitiveMatch;
    FcbTable->Version = 0;
    FcbTable->TableEntryForNull = NULL;
 
    FcbTable->NumberOfBuckets = RX_FCB_TABLE_NUMBER_OF_HASH_BUCKETS;
    for (i = 0; i < FcbTable->NumberOfBuckets; ++i)
    {
        InitializeListHead(&FcbTable->HashBuckets[i]);
    }
 
    FcbTable->Lookups = 0;
    FcbTable->FailedLookups = 0;
    FcbTable->Compares = 0;
}

Referenced by RxCreateNetRoot().

RxInitializeLowIoContext()

VOID NTAPI RxInitializeLowIoContext	(	OUT PLOWIO_CONTEXT	LowIoContext,
		IN ULONG	Operation
	)

Definition at line 4774 of file rxce.c.

{
    PRX_CONTEXT RxContext;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    RxContext = CONTAINING_RECORD(LowIoContext, RX_CONTEXT, LowIoContext);
    ASSERT(LowIoContext == &RxContext->LowIoContext);
 
    Stack = RxContext->CurrentIrpSp;
 
    KeInitializeEvent(&RxContext->SyncEvent, NotificationEvent, FALSE);
    RxContext->LowIoContext.ResourceThreadId = (ERESOURCE_THREAD)PsGetCurrentThread();
    RxContext->LowIoContext.Operation = Operation;
 
    switch (Operation)
    {
        case LOWIO_OP_READ:
        case LOWIO_OP_WRITE:
            /* In case of RW, set a canary, to make sure these fields are properly set
             * they will be asserted when lowio request will be submit to mini-rdr
             * See LowIoSubmit()
             */
            RxContext->LowIoContext.ParamsFor.ReadWrite.ByteOffset = 0xFFFFFFEE;
            RxContext->LowIoContext.ParamsFor.ReadWrite.ByteCount = 0xEEEEEEEE;
            RxContext->LowIoContext.ParamsFor.ReadWrite.Key = Stack->Parameters.Read.Key;
 
            /* Keep track of paging IOs */
            if (BooleanFlagOn(RxContext->CurrentIrp->Flags, IRP_PAGING_IO))
            {
                RxContext->LowIoContext.ParamsFor.ReadWrite.Flags = LOWIO_READWRITEFLAG_PAGING_IO;
            }
            else
            {
                RxContext->LowIoContext.ParamsFor.ReadWrite.Flags = 0;
            }
 
            break;
 
        case LOWIO_OP_FSCTL:
        case LOWIO_OP_IOCTL:
            /* This will be initialized later on with a call to RxLowIoPopulateFsctlInfo() */
            RxContext->LowIoContext.ParamsFor.FsCtl.Flags = 0;
            RxContext->LowIoContext.ParamsFor.FsCtl.InputBufferLength = 0;
            RxContext->LowIoContext.ParamsFor.FsCtl.pInputBuffer = NULL;
            RxContext->LowIoContext.ParamsFor.FsCtl.OutputBufferLength = 0;
            RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer = NULL;
            RxContext->LowIoContext.ParamsFor.FsCtl.MinorFunction = 0;
            break;
 
        /* Nothing to do for these */
        case LOWIO_OP_SHAREDLOCK:
        case LOWIO_OP_EXCLUSIVELOCK:
        case LOWIO_OP_UNLOCK:
        case LOWIO_OP_UNLOCK_MULTIPLE:
        case LOWIO_OP_NOTIFY_CHANGE_DIRECTORY:
        case LOWIO_OP_CLEAROUT:
            break;
 
        default:
            /* Should never happen */
            ASSERT(FALSE);
            break;
    }
}

RxInitializeLowIoPerFcbInfo()

VOID RxInitializeLowIoPerFcbInfo

(

PLOWIO_PER_FCB_INFO

LowIoPerFcbInfo

)

Definition at line 4847 of file rxce.c.

{
    PAGED_CODE();
 
    InitializeListHead(&LowIoPerFcbInfo->PagingIoReadsOutstanding);
    InitializeListHead(&LowIoPerFcbInfo->PagingIoWritesOutstanding);
}

Referenced by RxFinishFcbInitialization().

RxInitializeMRxDispatcher()

NTSTATUS RxInitializeMRxDispatcher

(

IN OUT PRDBSS_DEVICE_OBJECT

pMRxDeviceObject

)

Definition at line 4860 of file rxce.c.

{
    PAGED_CODE();
 
    pMRxDeviceObject->DispatcherContext.NumberOfWorkerThreads = 0;
    pMRxDeviceObject->DispatcherContext.pTearDownEvent = NULL;
 
    return STATUS_SUCCESS;
}

Referenced by RxInitializeDispatcher().

RxInitializePrefixTable()

VOID RxInitializePrefixTable	(	IN OUT PRX_PREFIX_TABLE	ThisTable,
		IN ULONG TableSize	OPTIONAL,
		IN BOOLEAN	CaseInsensitiveMatch
	)

Definition at line 4875 of file rxce.c.

{
    PAGED_CODE();
 
    if (TableSize == 0)
    {
        TableSize = RX_PREFIX_TABLE_DEFAULT_LENGTH;
    }
 
    ThisTable->NodeTypeCode = RDBSS_NTC_PREFIX_TABLE;
    ThisTable->NodeByteSize = sizeof(RX_PREFIX_TABLE);
    InitializeListHead(&ThisTable->MemberQueue);
    ThisTable->Version = 0;
    ThisTable->TableEntryForNull = NULL;
    ThisTable->IsNetNameTable = FALSE;
    ThisTable->CaseInsensitiveMatch = CaseInsensitiveMatch;
    ThisTable->TableSize = TableSize;
 
    if (TableSize > 0)
    {
        USHORT i;
 
        for (i = 0; i < RX_PREFIX_TABLE_DEFAULT_LENGTH; ++i)
        {
            InitializeListHead(&ThisTable->HashBuckets[i]);
        }
    }
}

RxInitializePurgeSyncronizationContext()

VOID RxInitializePurgeSyncronizationContext

(

PPURGE_SYNCHRONIZATION_CONTEXT

PurgeSyncronizationContext

)

Definition at line 4911 of file rxce.c.

{
    PAGED_CODE();
 
    InitializeListHead(&PurgeSyncronizationContext->ContextsAwaitingPurgeCompletion);
    PurgeSyncronizationContext->PurgeInProgress = FALSE;
}

Referenced by RxCreateNetRoot(), and RxCreateSrvCall().

RxInitializeRxTimer()

NTSTATUS NTAPI RxInitializeRxTimer

(

VOID

)

Definition at line 4946 of file rxce.c.

{
    PAGED_CODE();
 
    RxTimerInterval.QuadPart = -550000;
    KeInitializeSpinLock(&RxTimerLock);
    InitializeListHead(&RxTimerQueueHead);
    InitializeListHead(&RxRecurrentWorkItemsList);
    KeInitializeDpc(&RxTimerDpc, RxTimerDispatch, NULL);
    KeInitializeTimer(&RxTimer);
    RxTimerTickCount = 0;
 
    return STATUS_SUCCESS;
}

Referenced by RxDriverEntry().

RxInitializeSrvCallParameters()

NTSTATUS RxInitializeSrvCallParameters	(	IN PRX_CONTEXT	RxContext,
		IN OUT PSRV_CALL	SrvCall
	)

Definition at line 4921 of file rxce.c.

{
    PAGED_CODE();
 
    SrvCall->pPrincipalName = NULL;
 
    /* We only have stuff to initialize for file opening from DFS */
    if (RxContext->MajorFunction != IRP_MJ_CREATE || RxContext->Create.EaLength == 0)
    {
        return STATUS_SUCCESS;
    }
 
    ASSERT(RxContext->Create.EaBuffer != NULL);
 
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RxCreateSrvCall().

RxInitializeVNetRootParameters()

NTSTATUS RxInitializeVNetRootParameters	(	PRX_CONTEXT	RxContext,
		OUT LUID *	LogonId,
		OUT PULONG	SessionId,
		OUT PUNICODE_STRING *	UserNamePtr,
		OUT PUNICODE_STRING *	UserDomainNamePtr,
		OUT PUNICODE_STRING *	PasswordPtr,
		OUT PULONG	Flags
	)

Definition at line 4963 of file rxce.c.

{
    NTSTATUS Status;
    PACCESS_TOKEN Token;
 
    PAGED_CODE();
 
    DPRINT("RxInitializeVNetRootParameters(%p, %p, %p, %p, %p, %p, %p)\n", RxContext,
           LogonId, SessionId, UserNamePtr, UserDomainNamePtr, PasswordPtr, Flags);
 
    *UserNamePtr = NULL;
    *UserDomainNamePtr = NULL;
    *PasswordPtr = NULL;
    /* By default, that's not CSC instance */
    *Flags &= ~VNETROOT_FLAG_CSCAGENT_INSTANCE;
 
    Token = SeQuerySubjectContextToken(&RxContext->Create.NtCreateParameters.SecurityContext->AccessState->SubjectSecurityContext);
    if (SeTokenIsRestricted(Token))
    {
        return STATUS_ACCESS_DENIED;
    }
 
    /* Get LogonId */
    Status = SeQueryAuthenticationIdToken(Token, LogonId);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* And SessionId */
    Status = SeQuerySessionIdToken(Token, SessionId);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (RxContext->Create.UserName.Buffer != NULL)
    {
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
        goto Leave;
    }
 
    /* Deal with connection credentials */
    if (RxContext->Create.UserDomainName.Buffer != NULL)
    {
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
        goto Leave;
    }
 
    if (RxContext->Create.Password.Buffer != NULL)
    {
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
        goto Leave;
    }
 
Leave:
    if (NT_SUCCESS(Status))
    {
        /* If that's a CSC instance, mark it as such */
        if (RxIsThisACscAgentOpen(RxContext))
        {
            *Flags |= VNETROOT_FLAG_CSCAGENT_INSTANCE;
        }
        return Status;
    }
 
    return Status;
}

Referenced by RxCreateVNetRoot(), and RxFindOrConstructVirtualNetRoot().

RxInitializeWorkQueue()

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

Definition at line 5046 of file rxce.c.

{
    PAGED_CODE();
 
    WorkQueue->Type = WorkQueueType;
    WorkQueue->MaximumNumberOfWorkerThreads = MaximumNumberOfWorkerThreads;
    WorkQueue->MinimumNumberOfWorkerThreads = MinimumNumberOfWorkerThreads;
 
    WorkQueue->State = RxWorkQueueActive;
    WorkQueue->SpinUpRequestPending = FALSE;
    WorkQueue->pRundownContext = NULL;
    WorkQueue->NumberOfWorkItemsDispatched = 0;
    WorkQueue->NumberOfWorkItemsToBeDispatched = 0;
    WorkQueue->CumulativeQueueLength = 0;
    WorkQueue->NumberOfSpinUpRequests = 0;
    WorkQueue->NumberOfActiveWorkerThreads = 0;
    WorkQueue->NumberOfIdleWorkerThreads = 0;
    WorkQueue->NumberOfFailedSpinUpRequests = 0;
    WorkQueue->WorkQueueItemForSpinUpWorkerThreadInUse = 0;
    WorkQueue->WorkQueueItemForTearDownWorkQueue.List.Flink = NULL;
    WorkQueue->WorkQueueItemForTearDownWorkQueue.WorkerRoutine = NULL;
    WorkQueue->WorkQueueItemForTearDownWorkQueue.Parameter = NULL;
    WorkQueue->WorkQueueItemForTearDownWorkQueue.pDeviceObject = NULL;
    WorkQueue->WorkQueueItemForSpinUpWorkerThread.List.Flink = NULL;
    WorkQueue->WorkQueueItemForSpinUpWorkerThread.WorkerRoutine = NULL;
    WorkQueue->WorkQueueItemForSpinUpWorkerThread.Parameter = NULL;
    WorkQueue->WorkQueueItemForSpinUpWorkerThread.pDeviceObject = NULL;
    WorkQueue->WorkQueueItemForSpinDownWorkerThread.List.Flink = NULL;
    WorkQueue->WorkQueueItemForSpinDownWorkerThread.WorkerRoutine = NULL;
    WorkQueue->WorkQueueItemForSpinDownWorkerThread.Parameter = NULL;
    WorkQueue->WorkQueueItemForSpinDownWorkerThread.pDeviceObject = NULL;
 
    KeInitializeQueue(&WorkQueue->Queue, MaximumNumberOfWorkerThreads);
    KeInitializeSpinLock(&WorkQueue->SpinLock);
}

Referenced by RxInitializeWorkQueueDispatcher().

RxInitializeWorkQueueDispatcher()

NTSTATUS RxInitializeWorkQueueDispatcher

(

PRX_WORK_QUEUE_DISPATCHER

Dispatcher

)

Definition at line 5090 of file rxce.c.

{
    NTSTATUS Status;
    ULONG MaximumNumberOfWorkerThreads;
 
    PAGED_CODE();
 
    /* Number of threads will depend on system capacity */
    if (MmQuerySystemSize() != MmLargeSystem)
    {
        MaximumNumberOfWorkerThreads = 5;
    }
    else
    {
        MaximumNumberOfWorkerThreads = 10;
    }
 
    /* Initialize the work queues */
    RxInitializeWorkQueue(&Dispatcher->WorkQueue[CriticalWorkQueue], CriticalWorkQueue,
                          MaximumNumberOfWorkerThreads, 1);
    RxInitializeWorkQueue(&Dispatcher->WorkQueue[DelayedWorkQueue], DelayedWorkQueue, 2, 1);
    RxInitializeWorkQueue(&Dispatcher->WorkQueue[HyperCriticalWorkQueue], HyperCriticalWorkQueue, 5, 1);
 
    /* And start the worker threads */
    Status = RxSpinUpWorkerThread(&Dispatcher->WorkQueue[HyperCriticalWorkQueue],
                                  RxBootstrapWorkerThreadDispatcher,
                                  &Dispatcher->WorkQueue[HyperCriticalWorkQueue]);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    Status = RxSpinUpWorkerThread(&Dispatcher->WorkQueue[CriticalWorkQueue],
                                  RxBootstrapWorkerThreadDispatcher,
                                  &Dispatcher->WorkQueue[CriticalWorkQueue]);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    Status = RxSpinUpWorkerThread(&Dispatcher->WorkQueue[DelayedWorkQueue],
                                  RxBootstrapWorkerThreadDispatcher,
                                  &Dispatcher->WorkQueue[DelayedWorkQueue]);
    return Status;
}

Referenced by RxInitializeDispatcher().

RxInitiateSrvOpenKeyAssociation()

VOID RxInitiateSrvOpenKeyAssociation

(

IN OUT PSRV_OPEN

SrvOpen

)

Definition at line 5141 of file rxce.c.

{
    PRX_BUFFERING_MANAGER BufferingManager;
 
    PAGED_CODE();
 
    SrvOpen->Key = NULL;
 
    /* Just keep track of the opening request */
    BufferingManager = &((PSRV_CALL)((PFCB)SrvOpen->pFcb)->VNetRoot->pNetRoot->pSrvCall)->BufferingManager;
    InterlockedIncrement(&BufferingManager->NumberOfOutstandingOpens);
 
    InitializeListHead(&SrvOpen->SrvOpenKeyList);
}

RxInsertWorkQueueItem()

NTSTATUS RxInsertWorkQueueItem	(	PRDBSS_DEVICE_OBJECT	pMRxDeviceObject,
		WORK_QUEUE_TYPE	WorkQueueType,
		PRX_WORK_QUEUE_ITEM	WorkQueueItem
	)

Definition at line 5161 of file rxce.c.

{
    KIRQL OldIrql;
    NTSTATUS Status;
    BOOLEAN SpinUpThreads;
    PRX_WORK_QUEUE WorkQueue;
 
    /* No dispatcher, nothing to insert */
    if (RxDispatcher.State != RxDispatcherActive)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Get the work queue */
    WorkQueue = &RxDispatcher.pWorkQueueDispatcher->WorkQueue[WorkQueueType];
 
    KeAcquireSpinLock(&WorkQueue->SpinLock, &OldIrql);
    /* Only insert if the work queue is in decent state */
    if (WorkQueue->State != RxWorkQueueActive || pMRxDeviceObject->DispatcherContext.pTearDownEvent != NULL)
    {
        Status = STATUS_UNSUCCESSFUL;
    }
    else
    {
        SpinUpThreads = FALSE;
        WorkQueueItem->pDeviceObject = pMRxDeviceObject;
        InterlockedIncrement(&pMRxDeviceObject->DispatcherContext.NumberOfWorkerThreads);
        WorkQueue->CumulativeQueueLength += WorkQueue->NumberOfWorkItemsToBeDispatched;
        InterlockedIncrement(&WorkQueue->NumberOfWorkItemsToBeDispatched);
 
        /* If required (and possible!), spin up a new worker thread */
        if (WorkQueue->NumberOfIdleWorkerThreads < WorkQueue->NumberOfWorkItemsToBeDispatched &&
            WorkQueue->NumberOfActiveWorkerThreads < WorkQueue->MaximumNumberOfWorkerThreads &&
            !WorkQueue->SpinUpRequestPending)
        {
            WorkQueue->SpinUpRequestPending = TRUE;
            SpinUpThreads = TRUE;
        }
 
        Status = STATUS_SUCCESS;
    }
    KeReleaseSpinLock(&WorkQueue->SpinLock, OldIrql);
 
    /* If we failed, return and still not insert item */
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* All fine, insert the item */
    KeInsertQueue(&WorkQueue->Queue, &WorkQueueItem->List);
 
    /* And start a new worker thread if needed */
    if (SpinUpThreads)
    {
        RxSpinUpWorkerThreads(WorkQueue);
    }
 
    return Status;
}

Referenced by RxDispatchToWorkerThread(), and RxPostToWorkerThread().

RxIsThisACscAgentOpen()

BOOLEAN RxIsThisACscAgentOpen

(

IN PRX_CONTEXT

RxContext

)

Definition at line 5226 of file rxce.c.

{
    BOOLEAN CscAgent;
 
    CscAgent = FALSE;
 
    /* Client Side Caching is DFS stuff - we don't support it */
    if (RxContext->Create.EaLength != 0)
    {
        UNIMPLEMENTED;
    }
 
    if (RxContext->Create.NtCreateParameters.DfsNameContext != NULL &&
        ((PDFS_NAME_CONTEXT)RxContext->Create.NtCreateParameters.DfsNameContext)->NameContextType == 0xAAAAAAAA)
    {
        CscAgent = TRUE;
    }
 
    return CscAgent;
}

Referenced by RxInitializeVNetRootParameters().

RxLockUserBuffer()

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

Definition at line 5249 of file rxce.c.

{
    PIRP Irp;
    PMDL Mdl = NULL;
 
    PAGED_CODE();
 
    _SEH2_TRY
    {
        Irp = RxContext->CurrentIrp;
        /* If we already have a MDL, make sure it's locked */
        if (Irp->MdlAddress != NULL)
        {
            ASSERT(RxLowIoIsMdlLocked(Irp->MdlAddress));
        }
        else
        {
            /* That likely means the driver asks for buffered IOs - we don't support it! */
            ASSERT(!BooleanFlagOn(Irp->Flags, IRP_INPUT_OPERATION));
 
            /* If we have a real length */
            if (BufferLength > 0)
            {
                /* Allocate a MDL and lock it */
                Mdl = IoAllocateMdl(Irp->UserBuffer, BufferLength, FALSE, FALSE, Irp);
                if (Mdl == NULL)
                {
                    RxContext->StoredStatus = STATUS_INSUFFICIENT_RESOURCES;
                    ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
                }
 
                MmProbeAndLockPages(Mdl, Irp->RequestorMode, Operation);
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        NTSTATUS Status;
 
        Status = _SEH2_GetExceptionCode();
 
        /* Free the possible MDL we have allocated */
        IoFreeMdl(Mdl);
        Irp->MdlAddress = NULL;
 
        RxContext->Flags |= RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT;
 
        /* Fix status */
        if (!FsRtlIsNtstatusExpected(Status))
        {
            Status = STATUS_INVALID_USER_BUFFER;
        }
 
        RxContext->IoStatusBlock.Status = Status;
        ExRaiseStatus(Status);
    }
    _SEH2_END;
}

Referenced by RxLowIoSubmit().

RxLowIoCompletionTail()

NTSTATUS RxLowIoCompletionTail

(

IN PRX_CONTEXT

RxContext

)

Definition at line 5315 of file rxce.c.

{
    NTSTATUS Status;
    USHORT Operation;
 
    PAGED_CODE();
 
    DPRINT("RxLowIoCompletionTail(%p)\n", RxContext);
 
    /* Only continue if we're at APC_LEVEL or lower */
    if (RxShouldPostCompletion() &&
        !BooleanFlagOn(RxContext->LowIoContext.Flags, LOWIO_CONTEXT_FLAG_CAN_COMPLETE_AT_DPC_LEVEL))
    {
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    /* Call the completion routine */
    DPRINT("Calling completion routine: %p\n", RxContext->LowIoContext.CompletionRoutine);
    Status = RxContext->LowIoContext.CompletionRoutine(RxContext);
    if (Status == STATUS_MORE_PROCESSING_REQUIRED || Status == STATUS_RETRY)
    {
        return Status;
    }
 
    /* If it was a RW operation, for a paging file ... */
    Operation = RxContext->LowIoContext.Operation;
    if (Operation == LOWIO_OP_READ || Operation == LOWIO_OP_WRITE)
    {
        /* Remove ourselves from the list and resume operations */
        if (BooleanFlagOn(RxContext->LowIoContext.ParamsFor.ReadWrite.Flags, LOWIO_READWRITEFLAG_PAGING_IO))
        {
            ExAcquireFastMutexUnsafe(&RxLowIoPagingIoSyncMutex);
            RemoveEntryList(&RxContext->RxContextSerializationQLinks);
            RxContext->RxContextSerializationQLinks.Flink = NULL;
            RxContext->RxContextSerializationQLinks.Blink = NULL;
            ExReleaseFastMutexUnsafe(&RxLowIoPagingIoSyncMutex);
            RxResumeBlockedOperations_ALL(RxContext);
        }
    }
    else
    {
        /* Sanity check: we had known operation */
        ASSERT(Operation < LOWIO_OP_MAXIMUM);
    }
 
    /* If not sync operation, complete now. Otherwise, caller has already completed */
    if (!BooleanFlagOn(RxContext->LowIoContext.Flags, LOWIO_CONTEXT_FLAG_SYNCCALL))
    {
        RxCompleteRequest(RxContext, Status);
    }
 
    DPRINT("Status: %x\n", Status);
    return Status;
}

Referenced by RxLowIoSubmit().

RxLowIoPopulateFsctlInfo()

NTSTATUS NTAPI RxLowIoPopulateFsctlInfo

(

IN PRX_CONTEXT

RxContext

)

Definition at line 5376 of file rxce.c.

{
    PMDL Mdl;
    PIRP Irp;
    UCHAR Method;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    DPRINT("RxLowIoPopulateFsctlInfo(%p)\n", RxContext);
 
    Irp = RxContext->CurrentIrp;
    Stack = RxContext->CurrentIrpSp;
 
    /* Copy stack parameters */
    RxContext->LowIoContext.ParamsFor.FsCtl.FsControlCode = Stack->Parameters.FileSystemControl.FsControlCode;
    RxContext->LowIoContext.ParamsFor.FsCtl.InputBufferLength = Stack->Parameters.FileSystemControl.InputBufferLength;
    RxContext->LowIoContext.ParamsFor.FsCtl.OutputBufferLength = Stack->Parameters.FileSystemControl.OutputBufferLength;
    RxContext->LowIoContext.ParamsFor.FsCtl.MinorFunction = Stack->MinorFunction;
    Method = METHOD_FROM_CTL_CODE(RxContext->LowIoContext.ParamsFor.FsCtl.FsControlCode);
 
    /* Same buffer in case of buffered */
    if (Method == METHOD_BUFFERED)
    {
        RxContext->LowIoContext.ParamsFor.FsCtl.pInputBuffer = Irp->AssociatedIrp.SystemBuffer;
        RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer = Irp->AssociatedIrp.SystemBuffer;
 
        return STATUS_SUCCESS;
    }
 
    /* Two buffers for neither */
    if (Method == METHOD_NEITHER)
    {
        RxContext->LowIoContext.ParamsFor.FsCtl.pInputBuffer = Stack->Parameters.FileSystemControl.Type3InputBuffer;
        RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer = Irp->UserBuffer;
 
        return STATUS_SUCCESS;
    }
 
    /* Only IN/OUT remain */
    ASSERT(Method == METHOD_IN_DIRECT || Method == METHOD_OUT_DIRECT);
 
    /* Use system buffer for input */
    RxContext->LowIoContext.ParamsFor.FsCtl.pInputBuffer = Irp->AssociatedIrp.SystemBuffer;
    /* And MDL for output */
    Mdl = Irp->MdlAddress;
    if (Mdl != NULL)
    {
        RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
        if (RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer == NULL)
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    else
    {
        RxContext->LowIoContext.ParamsFor.FsCtl.pOutputBuffer = NULL;
    }
 
    return STATUS_SUCCESS;
}

Referenced by RxLowIoSubmit().

RxLowIoSubmit()

NTSTATUS NTAPI RxLowIoSubmit	(	IN PRX_CONTEXT	RxContext,
		IN PLOWIO_COMPLETION_ROUTINE	CompletionRoutine
	)

Definition at line 5441 of file rxce.c.

{
    NTSTATUS Status;
    USHORT Operation;
    BOOLEAN Synchronous;
    PLOWIO_CONTEXT LowIoContext;
 
    DPRINT("RxLowIoSubmit(%p, %p)\n", RxContext, CompletionRoutine);
 
    PAGED_CODE();
 
    LowIoContext = &RxContext->LowIoContext;
    Synchronous = !BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION);
 
    LowIoContext->CompletionRoutine = CompletionRoutine;
 
    Status = STATUS_SUCCESS;
    Operation = LowIoContext->Operation;
    switch (Operation)
    {
        case LOWIO_OP_READ:
        case LOWIO_OP_WRITE:
            /* Check that the parameters were properly set by caller
             * See comment in RxInitializeLowIoContext()
             */
            ASSERT(LowIoContext->ParamsFor.ReadWrite.ByteOffset != 0xFFFFFFEE);
            ASSERT(LowIoContext->ParamsFor.ReadWrite.ByteCount != 0xEEEEEEEE);
 
            /* Lock the buffer */
            RxLockUserBuffer(RxContext,
                             (Operation == LOWIO_OP_READ ? IoWriteAccess : IoReadAccess),
                             LowIoContext->ParamsFor.ReadWrite.ByteCount);
            if (RxNewMapUserBuffer(RxContext) == NULL)
            {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            LowIoContext->ParamsFor.ReadWrite.Buffer = RxContext->CurrentIrp->MdlAddress;
 
            /* If that's a paging IO, initialize serial operation */
            if (BooleanFlagOn(LowIoContext->ParamsFor.ReadWrite.Flags, LOWIO_READWRITEFLAG_PAGING_IO))
            {
                PFCB Fcb;
 
                Fcb = (PFCB)RxContext->pFcb;
 
                ExAcquireFastMutexUnsafe(&RxLowIoPagingIoSyncMutex);
                RxContext->BlockedOpsMutex = &RxLowIoPagingIoSyncMutex;
                if (Operation == LOWIO_OP_READ)
                {
                    InsertTailList(&Fcb->Specific.Fcb.PagingIoReadsOutstanding, &RxContext->RxContextSerializationQLinks);
                }
                else
                {
                    InsertTailList(&Fcb->Specific.Fcb.PagingIoWritesOutstanding, &RxContext->RxContextSerializationQLinks);
                }
 
                ExReleaseFastMutexUnsafe(&RxLowIoPagingIoSyncMutex);
            }
 
            break;
 
        case LOWIO_OP_FSCTL:
        case LOWIO_OP_IOCTL:
            /* Set FSCTL/IOCTL parameters */
            Status = RxLowIoPopulateFsctlInfo(RxContext);
            /* Check whether we're consistent: a length means a buffer */
            if (NT_SUCCESS(Status))
            {
                if ((LowIoContext->ParamsFor.FsCtl.InputBufferLength > 0 &&
                     LowIoContext->ParamsFor.FsCtl.pInputBuffer == NULL) ||
                    (LowIoContext->ParamsFor.FsCtl.OutputBufferLength > 0 &&
                     LowIoContext->ParamsFor.FsCtl.pOutputBuffer == NULL))
                {
                    Status = STATUS_INVALID_PARAMETER;
                }
            }
            break;
 
        /* Nothing to do */
        case LOWIO_OP_SHAREDLOCK:
        case LOWIO_OP_EXCLUSIVELOCK:
        case LOWIO_OP_UNLOCK:
        case LOWIO_OP_UNLOCK_MULTIPLE:
        case LOWIO_OP_NOTIFY_CHANGE_DIRECTORY:
        case LOWIO_OP_CLEAROUT:
            break;
 
        default:
            ASSERT(FALSE);
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    /* No need to perform extra init in case of posting */
    RxContext->Flags |= RX_CONTEXT_FLAG_NO_PREPOSTING_NEEDED;
 
    /* Preflight checks were OK, time to submit */
    if (NT_SUCCESS(Status))
    {
        PMINIRDR_DISPATCH Dispatch;
 
        if (!Synchronous)
        {
            InterlockedIncrement((volatile long *)&RxContext->ReferenceCount);
            /* If not synchronous, we're likely to return before the operation is finished */
            if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP))
            {
                IoMarkIrpPending(RxContext->CurrentIrp);
            }
        }
 
        Dispatch = RxContext->RxDeviceObject->Dispatch;
        if (Dispatch != NULL)
        {
            /* We'll try to execute until the mini-rdr doesn't return pending */
            do
            {
                RxContext->IoStatusBlock.Information = 0;
 
                MINIRDR_CALL(Status, RxContext, Dispatch, MRxLowIOSubmit[Operation], (RxContext));
                if (Status == STATUS_PENDING)
                {
                    /* Unless it's not synchronous, caller will be happy with pending op */
                    if (!Synchronous)
                    {
                        return Status;
                    }
 
                    RxWaitSync(RxContext);
                    Status = RxContext->IoStatusBlock.Status;
                }
                else
                {
                    if (!Synchronous)
                    {
                        /* We had marked the IRP pending, whereas the operation finished, drop that */
                        if (Status != STATUS_RETRY)
                        {
                            if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP))
                            {
                                RxContext->CurrentIrpSp->Flags &= ~SL_PENDING_RETURNED;
                            }
 
                            InterlockedDecrement((volatile long *)&RxContext->ReferenceCount);
                        }
                    }
                }
            } while (Status == STATUS_PENDING);
        }
        else
        {
            Status = STATUS_INVALID_PARAMETER;
        }
    }
 
    /* Call completion and return */
    RxContext->IoStatusBlock.Status = Status;
    LowIoContext->Flags |= LOWIO_CONTEXT_FLAG_SYNCCALL;
    return RxLowIoCompletionTail(RxContext);
}

RxMapSystemBuffer()

PVOID RxMapSystemBuffer

(

IN PRX_CONTEXT

RxContext

)

Definition at line 5608 of file rxce.c.

{
    PIRP Irp;
 
    PAGED_CODE();
 
    Irp = RxContext->CurrentIrp;
    /* We should have a MDL (buffered IOs are not supported!) */
    if (Irp->MdlAddress != NULL)
    {
        ASSERT(FALSE);
        return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    }
 
    /* Just return system buffer */
    return Irp->AssociatedIrp.SystemBuffer;
}

RxMarkFobxOnCleanup()

VOID RxMarkFobxOnCleanup	(	PFOBX	pFobx,
		PBOOLEAN	NeedPurge
	)

Definition at line 5631 of file rxce.c.

{
    PFCB Fcb;
    PFOBX ScavengerFobx;
    LARGE_INTEGER TickCount;
    PRDBSS_SCAVENGER Scavenger;
 
    PAGED_CODE();
 
    /* No FOBX, nothing to mark */
    if (pFobx == NULL)
    {
        return;
    }
 
    /* Query time for close */
    KeQueryTickCount(&TickCount);
 
    Fcb = (PFCB)pFobx->pSrvOpen->pFcb;
    ASSERT(NodeTypeIsFcb(Fcb));
 
    Scavenger = Fcb->RxDeviceObject->pRdbssScavenger;
    RxAcquireScavengerMutex();
 
    ScavengerFobx = NULL;
    /* If that's not a file, or even not a disk resource, just mark as dormant */
    if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_FILE || Fcb->VNetRoot->pNetRoot->DeviceType != FILE_DEVICE_DISK)
    {
        SetFlag(pFobx->Flags, FOBX_FLAG_MARKED_AS_DORMANT);
        InitializeListHead(&pFobx->ClosePendingList);
        ++Scavenger->NumberOfDormantFiles;
    }
    else
    {
        ASSERT(Scavenger->NumberOfDormantFiles >= 0);
        /* If we're about to reach the maximum dormant of FOBX */
        if (Scavenger->NumberOfDormantFiles >= Scavenger->MaximumNumberOfDormantFiles)
        {
            /* This should never be wrong... */
            if (!IsListEmpty(&Scavenger->ClosePendingFobxsList))
            {
                /* Then, take the first from the list (oldest) and save it for later purge */
                ScavengerFobx = CONTAINING_RECORD(Scavenger->ClosePendingFobxsList.Flink, FOBX, ClosePendingList);
                if (ScavengerFobx->pSrvOpen != NULL && ScavengerFobx->pSrvOpen->pFcb == RX_GET_MRX_FCB(Fcb))
                {
                    *NeedPurge = TRUE;
                    ScavengerFobx = NULL;
                }
                else
                {
                    RxReferenceNetFobx(ScavengerFobx);
                }
            }
        }
 
        /* Mark ourselves as dormant */
        SetFlag(pFobx->Flags, FOBX_FLAG_MARKED_AS_DORMANT);
        pFobx->CloseTime.QuadPart = TickCount.QuadPart;
 
        /* And insert us in the list of dormant files */
        InsertTailList(&Scavenger->ClosePendingFobxsList, &pFobx->ClosePendingList);
        /* If scavenger was inactive, start it */
        if (Scavenger->NumberOfDormantFiles++ == 0 && Scavenger->State == RDBSS_SCAVENGER_INACTIVE)
        {
            Scavenger->State = RDBSS_SCAVENGER_DORMANT;
            RxPostOneShotTimerRequest(RxFileSystemDeviceObject, &Scavenger->WorkItem, RxScavengerTimerRoutine,
                                      Fcb->RxDeviceObject, Scavenger->TimeLimit);
        }
    }
 
    RxReleaseScavengerMutex();
 
    /* If we had reached max */
    if (ScavengerFobx != NULL)
    {
        NTSTATUS Status;
 
        /* Purge the oldest FOBX */
        Status = RxPurgeFobxFromCache(ScavengerFobx);
        if (Status != STATUS_SUCCESS)
        {
            *NeedPurge = TRUE;
        }
    }
}

RxMarkFobxOnClose()

VOID RxMarkFobxOnClose

(

PFOBX

Fobx

)

Definition at line 5723 of file rxce.c.

{
    PFCB Fcb;
    PRDBSS_SCAVENGER Scavenger;
 
    PAGED_CODE();
 
    /* No FOBX, nothing to mark */
    if (Fobx == NULL)
    {
        return;
    }
 
    Fcb = (PFCB)Fobx->pSrvOpen->pFcb;
    ASSERT(NodeTypeIsFcb(Fcb));
 
    Scavenger = Fcb->RxDeviceObject->pRdbssScavenger;
 
    RxAcquireScavengerMutex();
    /* Only mark it if it was already marked as dormant */
    if (BooleanFlagOn(Fobx->Flags, FOBX_FLAG_MARKED_AS_DORMANT))
    {
        /* If FCB wasn't already decrement, do it now */
        if (!Fobx->fOpenCountDecremented)
        {
            Fcb = (PFCB)Fobx->pSrvOpen->pFcb;
            ASSERT(NodeTypeIsFcb(Fcb));
            InterlockedDecrement((volatile long *)&Fcb->OpenCount);
 
            Fobx->fOpenCountDecremented = TRUE;
        }
 
        /* We're no longer dormant */
        InterlockedDecrement(&Scavenger->NumberOfDormantFiles);
        ClearFlag(Fobx->Flags, FOBX_FLAG_MARKED_AS_DORMANT);
    }
 
    /* If we were inserted in the scavenger, drop ourselves out */
    if (!IsListEmpty(&Fobx->ClosePendingList))
    {
        RemoveEntryList(&Fobx->ClosePendingList);
        InitializeListHead(&Fobx->ClosePendingList);
    }
 
    RxReleaseScavengerMutex();
}

RxNewMapUserBuffer()

PVOID RxNewMapUserBuffer

(

PRX_CONTEXT

RxContext

)

Definition at line 5775 of file rxce.c.

{
    PIRP Irp;
 
    PAGED_CODE();
 
    Irp = RxContext->CurrentIrp;
    if (Irp->MdlAddress != NULL)
    {
        return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
    }
 
    return Irp->UserBuffer;
}

Referenced by RxCommonRead(), RxCommonWrite(), RxLowIoSubmit(), and RxQueryDirectory().

RxNoOpAcquire()

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

Definition at line 5793 of file rxce.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

RxNoOpRelease()

VOID NTAPI RxNoOpRelease

(

IN PVOID

Fcb

)

Definition at line 5803 of file rxce.c.

{
    UNIMPLEMENTED;
}

RxOrphanSrvOpens()

VOID RxOrphanSrvOpens

(

IN PV_NET_ROOT

ThisVNetRoot

)

Definition at line 5817 of file rxce.c.

{
    PFCB Fcb;
    USHORT Bucket;
    PNET_ROOT NetRoot;
    PRX_FCB_TABLE FcbTable;
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    /* Mailslot won't have any SRV_OPEN (to orphan) */
    NetRoot = (PNET_ROOT)ThisVNetRoot->pNetRoot;
    if (NetRoot->Type == NET_ROOT_MAILSLOT)
    {
        return;
    }
 
    PrefixTable = NetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockExclusive(PrefixTable));
 
    FcbTable = &NetRoot->FcbTable;
    RxAcquireFcbTableLockExclusive(FcbTable, TRUE);
 
    _SEH2_TRY
    {
        /* Now, we'll browse all the FCBs attached, and orphan related SRV_OPENs */
        for (Bucket = 0; Bucket < FcbTable->NumberOfBuckets; ++Bucket)
        {
            PLIST_ENTRY BucketList, Entry;
 
            BucketList = &FcbTable->HashBuckets[Bucket];
            Entry = BucketList->Flink;
            while (Entry != BucketList)
            {
                Fcb = CONTAINING_RECORD(Entry, FCB, FcbTableEntry.HashLinks);
                Entry = Entry->Flink;
 
                ASSERT(NodeTypeIsFcb(Fcb));
                RxOrphanSrvOpensForThisFcb(Fcb, ThisVNetRoot, FALSE);
            }
        }
 
        /* Of course, don't forget about NULL-entry */
        if (FcbTable->TableEntryForNull != NULL)
        {
            Fcb = CONTAINING_RECORD(FcbTable->TableEntryForNull, FCB, FcbTableEntry.HashLinks);
            ASSERT(NodeTypeIsFcb(Fcb));
            RxOrphanSrvOpensForThisFcb(Fcb, ThisVNetRoot, FALSE);
        }
    }
    _SEH2_FINALLY
    {
        RxReleaseFcbTableLock(FcbTable);
    }
    _SEH2_END;
}

Referenced by RxFinalizeVNetRoot().

RxOrphanSrvOpensForThisFcb()

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

Definition at line 5876 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxOrphanSrvOpens().

RxOrphanThisFcb()

VOID RxOrphanThisFcb

(

PFCB

Fcb

)

Definition at line 5810 of file rxce.c.

{
    UNIMPLEMENTED;
}

RxpAcquirePrefixTableLockExclusive()

BOOLEAN RxpAcquirePrefixTableLockExclusive	(	PRX_PREFIX_TABLE	pTable,
		BOOLEAN	Wait,
		BOOLEAN	ProcessBufferingStateChangeRequests
	)

Definition at line 5905 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("RxpAcquirePrefixTableLockExclusive(%p, %d, %d) -> %d\n", pTable, Wait, ProcessBufferingStateChangeRequests,
           pTable->TableLock.ActiveEntries);
 
    return ExAcquireResourceExclusiveLite(&pTable->TableLock, Wait);
}

RxpAcquirePrefixTableLockShared()

BOOLEAN RxpAcquirePrefixTableLockShared	(	PRX_PREFIX_TABLE	pTable,
		BOOLEAN	Wait,
		BOOLEAN	ProcessBufferingStateChangeRequests
	)

Definition at line 5888 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("RxpAcquirePrefixTableLockShared(%p, %d, %d) -> %d\n", pTable, Wait, ProcessBufferingStateChangeRequests,
           pTable->TableLock.ActiveEntries);
 
    return ExAcquireResourceSharedLite(&pTable->TableLock, Wait);
}

RxpDereferenceAndFinalizeNetFcb()

BOOLEAN RxpDereferenceAndFinalizeNetFcb	(	OUT PFCB	ThisFcb,
		IN PRX_CONTEXT	RxContext,
		IN BOOLEAN	RecursiveFinalize,
		IN BOOLEAN	ForceFinalize
	)

Definition at line 5922 of file rxce.c.

{
    NTSTATUS Status;
    ULONG References;
    PNET_ROOT NetRoot;
    BOOLEAN ResourceAcquired, NetRootReferenced, Freed;
 
    PAGED_CODE();
 
    ASSERT(!ForceFinalize);
    ASSERT(NodeTypeIsFcb(ThisFcb));
    ASSERT(RxIsFcbAcquiredExclusive(ThisFcb));
 
    /* Unless we're recursively finalizing, or forcing, if FCB is still in use, quit */
    References = InterlockedDecrement((volatile long *)&ThisFcb->NodeReferenceCount);
    if (!ForceFinalize && !RecursiveFinalize && (ThisFcb->OpenCount != 0 || ThisFcb->UncleanCount != 0 || References > 1))
    {
        return FALSE;
    }
 
    Freed = FALSE;
    Status = STATUS_SUCCESS;
    NetRoot = (PNET_ROOT)ThisFcb->VNetRoot->pNetRoot;
    ResourceAcquired = FALSE;
    NetRootReferenced = FALSE;
    /* If FCB isn't orphaned, it still have context attached */
    if (!BooleanFlagOn(ThisFcb->FcbState, FCB_STATE_ORPHANED))
    {
        /* Don't let NetRoot go away before we're done */
        RxReferenceNetRoot(NetRoot);
        NetRootReferenced = TRUE;
 
        /* Try to acquire the table lock exclusively */
        if (!RxIsFcbTableLockExclusive(&NetRoot->FcbTable))
        {
            RxReferenceNetFcb(ThisFcb);
 
            if (!RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, FALSE))
            {
                if (RxContext != NULL && RxContext != CHANGE_BUFFERING_STATE_CONTEXT &&
                    RxContext != CHANGE_BUFFERING_STATE_CONTEXT_WAIT)
                {
                    RxContext->Flags |= RX_CONTEXT_FLAG_BYPASS_VALIDOP_CHECK;
                }
 
                RxReleaseFcb(RxContext, ThisFcb);
 
                RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, TRUE);
 
                Status = RxAcquireExclusiveFcb(RxContext, ThisFcb);
            }
 
            References = RxDereferenceNetFcb(ThisFcb);
 
            ResourceAcquired = TRUE;
        }
    }
 
    /* If locking was OK (or not needed!), attempt finalization */
    if (Status == STATUS_SUCCESS)
    {
        Freed = RxFinalizeNetFcb(ThisFcb, RecursiveFinalize, ForceFinalize, References);
    }
 
    /* Release table lock if acquired */
    if (ResourceAcquired)
    {
        RxReleaseFcbTableLock(&NetRoot->FcbTable);
    }
 
    /* We don't need the NetRoot anylonger */
    if (NetRootReferenced)
    {
        RxDereferenceNetRoot(NetRoot, LHS_LockNotHeld);
    }
 
    return Freed;
}

RxpDereferenceNetFcb()

LONG RxpDereferenceNetFcb

(

PFCB

Fcb

)

Definition at line 6009 of file rxce.c.

{
    LONG NewCount;
 
    PAGED_CODE();
 
    ASSERT(NodeTypeIsFcb(Fcb));
 
    NewCount = InterlockedDecrement((volatile long *)&Fcb->NodeReferenceCount);
    ASSERT(NewCount >= 0);
 
    PRINT_REF_COUNT(NETFCB, NewCount);
 
    return NewCount;
}

RxpDestroySrvCall()

VOID NTAPI RxpDestroySrvCall

(

IN PVOID

Context

)

Definition at line 6031 of file rxce.c.

{
    NTSTATUS Status;
    PSRV_CALL SrvCall;
    BOOLEAN ForceFinalize;
    PRX_PREFIX_TABLE PrefixTable;
 
    SrvCall = (PSRV_CALL)Context;
    /* At this step, RxFinalizeSrvCall already cleaned some fields */
    ASSERT(SrvCall->UpperFinalizationDone);
 
    PrefixTable = SrvCall->RxDeviceObject->pRxNetNameTable;
    /* Were we called with ForceFinalize? */
    ForceFinalize = BooleanFlagOn(SrvCall->Flags, SRVCALL_FLAG_FORCE_FINALIZED);
 
    /* Notify mini-rdr */
    MINIRDR_CALL_THROUGH(Status, SrvCall->RxDeviceObject->Dispatch,
                         MRxFinalizeSrvCall, ((PMRX_SRV_CALL)SrvCall,
                         ForceFinalize));
    (void)Status;
 
    /* Dereference our extra reference (set before queueing) */
    RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
    InterlockedDecrement((volatile long *)&SrvCall->NodeReferenceCount);
    /* And finalize for real, with the right context */
    RxFinalizeSrvCall(SrvCall, FALSE, ForceFinalize);
    RxReleasePrefixTableLock(PrefixTable);
}

Referenced by RxFinalizeSrvCall().

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

RxpDispatchChangeBufferingStateRequests()

VOID RxpDispatchChangeBufferingStateRequests	(	PSRV_CALL	SrvCall,
		PSRV_OPEN	SrvOpen,
		PLIST_ENTRY	DiscardedRequests
	)

Definition at line 6098 of file rxce.c.

{
    KIRQL OldIrql;
    NTSTATUS Status;
    BOOLEAN StartDispatcher;
    LIST_ENTRY AcceptedReqs;
    LIST_ENTRY DispatcherList;
    PRX_BUFFERING_MANAGER BufferingManager;
 
    /* Initialize our lists */
    InitializeListHead(&AcceptedReqs);
    InitializeListHead(DiscardedRequests);
 
    /* Transfer the requests to dispatch locally */
    BufferingManager = &SrvCall->BufferingManager;
    KeAcquireSpinLock(&BufferingManager->SpinLock, &OldIrql);
    RxTransferList(&DispatcherList, &BufferingManager->DispatcherList);
    KeReleaseSpinLock(&BufferingManager->SpinLock, OldIrql);
 
    /* If there were requests */
    if (!IsListEmpty(&DispatcherList))
    {
        PLIST_ENTRY Entry;
 
        /* For each of the entries... */
        Entry = DispatcherList.Flink;
        while (Entry != &DispatcherList)
        {
            PCHANGE_BUFFERING_STATE_REQUEST Request;
 
            Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
            Entry = Entry->Flink;
 
            /* If we have been provided a SRV_OPEN, see whether it matches */
            if (SrvOpen != NULL)
            {
                /* Match, the request is accepted */
                if (Request->SrvOpenKey == SrvOpen->Key)
                {
                    Request->SrvOpen = SrvOpen;
                    RxReferenceSrvOpen(SrvOpen);
 
                    RemoveEntryList(&Request->ListEntry);
                    InsertTailList(&AcceptedReqs, &Request->ListEntry);
 
                    /* Move to the next entry */
                    continue;
                }
                else
                {
                    Status = STATUS_PENDING;
                }
            }
            else
            {
                /* No SRV_OPEN provided, try to find one */
                Status = RxpLookupSrvOpenForRequestLite(SrvCall, Request);
            }
 
            /* We found a matching SRV_OPEN, accept the request */
            if (Status == STATUS_SUCCESS)
            {
                RemoveEntryList(&Request->ListEntry);
                InsertTailList(&AcceptedReqs, &Request->ListEntry);
            }
            /* Another run might help handling it, don't discard it */
            else if (Status == STATUS_PENDING)
            {
                continue;
            }
            /* Otherwise, discard the request */
            else
            {
                ASSERT(Status == STATUS_NOT_FOUND);
 
                RemoveEntryList(&Request->ListEntry);
                InsertTailList(DiscardedRequests, &Request->ListEntry);
            }
        }
    }
 
    KeAcquireSpinLock(&BufferingManager->SpinLock, &OldIrql);
    /* Nothing to dispatch, no need to start dispatcher */
    if (IsListEmpty(&DispatcherList))
    {
        StartDispatcher = FALSE;
    }
    else
    {
        /* Transfer back the list of the not treated entries to the buffering manager */
        RxTransferList(&BufferingManager->DispatcherList, &DispatcherList);
        StartDispatcher = (BufferingManager->DispatcherActive == FALSE);
        /* If the dispatcher isn't active, start it */
        if (StartDispatcher)
        {
            BufferingManager->DispatcherActive = TRUE;
        }
    }
 
    /* If there were accepted requests, move them to the buffering manager */
    if (!IsListEmpty(&AcceptedReqs))
    {
        RxTransferList(&BufferingManager->HandlerList, &AcceptedReqs);
    }
    KeReleaseSpinLock(&BufferingManager->SpinLock, OldIrql);
 
    /* If we're to start the dispatcher, do it */
    if (StartDispatcher)
    {
        RxReferenceSrvCall(SrvCall);
        DPRINT("Starting dispatcher\n");
        RxPostToWorkerThread(RxFileSystemDeviceObject, HyperCriticalWorkQueue,
                             &BufferingManager->DispatcherWorkItem,
                             RxDispatchChangeBufferingStateRequests, SrvCall);
    }
}

Referenced by RxCompleteSrvOpenKeyAssociation(), and RxGatherRequestsForSrvOpen().

RxpLookupSrvOpenForRequestLite()

NTSTATUS RxpLookupSrvOpenForRequestLite	(	IN PSRV_CALL	SrvCall,
		IN OUT PCHANGE_BUFFERING_STATE_REQUEST	Request
	)

Definition at line 6222 of file rxce.c.

{
    NTSTATUS Status;
    PLIST_ENTRY Entry;
    PSRV_OPEN SrvOpen;
 
    PAGED_CODE();
 
    Status = STATUS_SUCCESS;
    /* Browse all our associated SRV_OPENs to find the one! */
    for (Entry = SrvCall->BufferingManager.SrvOpenLists[0].Flink;
         Entry != &SrvCall->BufferingManager.SrvOpenLists[0];
         Entry = Entry->Flink)
    {
        /* Same key, not orphaned, this is ours */
        SrvOpen = CONTAINING_RECORD(Entry, SRV_OPEN, SrvOpenKeyList);
        if (SrvOpen->Key == Request->SrvOpenKey)
        {
            if (!BooleanFlagOn(SrvOpen->pFcb->FcbState, FCB_STATE_ORPHANED))
            {
                RxReferenceSrvOpen(SrvOpen);
                break;
            }
        }
    }
 
    /* We didn't manage to find a SRV_OPEN */
    if (Entry == &SrvCall->BufferingManager.SrvOpenLists[0])
    {
        SrvOpen = NULL;
 
        /* The coming open might help, mark as pending for later retry */
        if (SrvCall->BufferingManager.NumberOfOutstandingOpens != 0)
        {
            Status = STATUS_PENDING;
        }
        /* Else, it's a complete failure */
        else
        {
            Status = STATUS_NOT_FOUND;
        }
    }
 
    /* Return the (not) found SRV_OPEN */
    Request->SrvOpen = SrvOpen;
 
    return Status;
}

Referenced by RxpDispatchChangeBufferingStateRequests().

RxpMarkInstanceForScavengedFinalization()

VOID RxpMarkInstanceForScavengedFinalization

(

PVOID

Instance

)

Definition at line 6277 of file rxce.c.

{
    NODE_TYPE_CODE NodeType;
    PNODE_TYPE_AND_SIZE Node;
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT DeviceObject;
    PLIST_ENTRY ScavengerHead, InstEntry;
 
    PAGED_CODE();
 
    /* If still referenced, don't mark it (broken caller) */
    Node = (PNODE_TYPE_AND_SIZE)Instance;
    if (Node->NodeReferenceCount > 1)
    {
        return;
    }
 
    DeviceObject = RxGetDeviceObjectOfInstance(Instance);
    Scavenger = DeviceObject->pRdbssScavenger;
 
    /* Mark the node */
    NodeType = NodeType(Instance);
    SetFlag(NodeType(Node), RX_SCAVENGER_MASK);
    DPRINT("Node %p has now the scavenger mark!\n", Instance);
 
    /* Increase the count in the scavenger, and queue it */
    ScavengerHead = NULL;
    switch (NodeType)
    {
        case RDBSS_NTC_FOBX:
            ++Scavenger->FobxsToBeFinalized;
            ScavengerHead = &Scavenger->FobxFinalizationList;
            InstEntry = &((PFOBX)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVCALL:
            ++Scavenger->SrvCallsToBeFinalized;
            ScavengerHead = &Scavenger->SrvCallFinalizationList;
            InstEntry = &((PSRV_CALL)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_NETROOT:
            ++Scavenger->NetRootsToBeFinalized;
            ScavengerHead = &Scavenger->NetRootFinalizationList;
            InstEntry = &((PNET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_V_NETROOT:
            ++Scavenger->VNetRootsToBeFinalized;
            ScavengerHead = &Scavenger->VNetRootFinalizationList;
            InstEntry = &((PV_NET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVOPEN:
            ++Scavenger->SrvOpensToBeFinalized;
            ScavengerHead = &Scavenger->SrvOpenFinalizationList;
            InstEntry = &((PSRV_OPEN)Instance)->ScavengerFinalizationList;
            break;
    }
 
    /* Extra ref for scavenger */
    InterlockedIncrement((volatile long *)&Node->NodeReferenceCount);
 
    /* If matching type */
    if (ScavengerHead != NULL)
    {
        /* Insert in the scavenger list */
        InsertTailList(ScavengerHead, InstEntry);
 
        /* And if it wasn't started, start it */
        if (Scavenger->State == RDBSS_SCAVENGER_INACTIVE)
        {
            Scavenger->State = RDBSS_SCAVENGER_DORMANT;
            RxPostOneShotTimerRequest(RxFileSystemDeviceObject, &Scavenger->WorkItem,
                                      RxScavengerTimerRoutine, DeviceObject, Scavenger->TimeLimit);
        }
    }
}

Referenced by RxDereference().

RxPostOneShotTimerRequest()

NTSTATUS NTAPI RxPostOneShotTimerRequest	(	IN PRDBSS_DEVICE_OBJECT	pDeviceObject,
		IN PRX_WORK_ITEM	pWorkItem,
		IN PRX_WORKERTHREAD_ROUTINE	Routine,
		IN PVOID	pContext,
		IN LARGE_INTEGER	TimeInterval
	)

Definition at line 6362 of file rxce.c.

{
    KIRQL OldIrql;
 
    ASSERT(pWorkItem != NULL);
 
    /* Prepare the work item */
    ExInitializeWorkItem(&pWorkItem->WorkQueueItem, Routine, pContext);
    pWorkItem->WorkQueueItem.pDeviceObject = pDeviceObject;
 
    /* Last tick can be computed with the number of times it was caller (timertickcount)
     * and the interval between calls
     */
    KeAcquireSpinLock(&RxTimerLock, &OldIrql);
    pWorkItem->LastTick = (TimeInterval.QuadPart / 550000) + RxTimerTickCount + 1;
    /* Insert in work queue */
    InsertTailList(&RxTimerQueueHead, &pWorkItem->WorkQueueItem.List);
    KeReleaseSpinLock(&RxTimerLock, OldIrql);
 
    /* If there are queued events, queue an execution */
    if (IsListEmpty(&RxTimerQueueHead))
    {
        KeSetTimer(&RxTimer, RxTimerInterval, &RxTimerDpc);
    }
 
    return STATUS_SUCCESS;
}

Referenced by RxMarkFobxOnCleanup(), RxpMarkInstanceForScavengedFinalization(), and RxScavengerTimerRoutine().

RxPostToWorkerThread()

NTSTATUS NTAPI RxPostToWorkerThread	(	_In_ PRDBSS_DEVICE_OBJECT	pMRxDeviceObject,
		_In_ WORK_QUEUE_TYPE	WorkQueueType,
		_In_ PRX_WORK_QUEUE_ITEM	pWorkQueueItem,
		_In_ PRX_WORKERTHREAD_ROUTINE	Routine,
		_In_ PVOID	pContext
	)

Definition at line 6400 of file rxce.c.

{
    /* Initialize work queue item */
    pWorkQueueItem->List.Flink = NULL;
    pWorkQueueItem->WorkerRoutine = Routine;
    pWorkQueueItem->Parameter = pContext;
 
    /* And insert it in the work queue */
    return RxInsertWorkQueueItem(pMRxDeviceObject, WorkQueueType, pWorkQueueItem);
}

Referenced by RxCompleteSrvOpenKeyAssociation(), RxpDispatchChangeBufferingStateRequests(), and RxTimerDispatch().

RxpProcessChangeBufferingStateRequests()

VOID RxpProcessChangeBufferingStateRequests	(	PSRV_CALL	SrvCall,
		BOOLEAN	UpdateHandlerState
	)

Definition at line 6417 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxCommonCreate(), and RxProcessChangeBufferingStateRequests().

RxpReferenceNetFcb()

LONG RxpReferenceNetFcb

(

PFCB

Fcb

)

Definition at line 6546 of file rxce.c.

{
    LONG NewCount;
 
    PAGED_CODE();
 
    ASSERT(NodeTypeIsFcb(Fcb));
 
    NewCount = InterlockedIncrement((volatile long *)&Fcb->NodeReferenceCount);
 
    PRINT_REF_COUNT(NETFCB, Fcb->NodeReferenceCount);
 
    return NewCount;
}

RxPrefixTableInsertName()

PRX_PREFIX_ENTRY RxPrefixTableInsertName	(	IN OUT PRX_PREFIX_TABLE	ThisTable,
		IN OUT PRX_PREFIX_ENTRY	ThisEntry,
		IN PVOID	Container,
		IN PULONG	ContainerRefCount,
		IN USHORT	CaseInsensitiveLength,
		IN PRX_CONNECTION_ID	ConnectionId
	)

Definition at line 6428 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("Insert: %wZ\n", &ThisEntry->Prefix);
 
    ASSERT(RxIsPrefixTableLockExclusive(ThisTable));
    ASSERT(CaseInsensitiveLength <= ThisEntry->Prefix.Length);
 
    /* Copy parameters and compute hash */
    ThisEntry->CaseInsensitiveLength = CaseInsensitiveLength;
    ThisEntry->ContainingRecord = Container;
    ThisEntry->ContainerRefCount = ContainerRefCount;
    InterlockedIncrement((volatile long *)ContainerRefCount);
    ThisEntry->SavedHashValue = RxTableComputeHashValue(&ThisEntry->Prefix);
    DPRINT("Associated hash: %x\n", ThisEntry->SavedHashValue);
 
    /* If no path length: this is entry for null path */
    if (ThisEntry->Prefix.Length == 0)
    {
        ThisTable->TableEntryForNull = ThisEntry;
    }
    /* Otherwise, insert in the appropriate bucket */
    else
    {
        InsertTailList(HASH_BUCKET(ThisTable, ThisEntry->SavedHashValue), &ThisEntry->HashLinks);
    }
 
    /* If we had a connection ID, keep track of it */
    if (ConnectionId != NULL)
    {
        ThisEntry->ConnectionId.Luid = ConnectionId->Luid;
    }
    else
    {
        ThisEntry->ConnectionId.Luid.LowPart = 0;
        ThisEntry->ConnectionId.Luid.HighPart = 0;
    }
 
    InsertTailList(&ThisTable->MemberQueue, &ThisEntry->MemberQLinks);
    /* Reflect the changes */
    ++ThisTable->Version;
 
    DPRINT("Inserted in bucket: %p\n", HASH_BUCKET(ThisTable, ThisEntry->SavedHashValue));
 
    return ThisEntry;
}

Referenced by RxCreateNetRoot(), RxCreateSrvCall(), and RxCreateVNetRoot().

RxPrefixTableLookupName()

PVOID RxPrefixTableLookupName	(	IN PRX_PREFIX_TABLE	ThisTable,
		IN PUNICODE_STRING	CanonicalName,
		OUT PUNICODE_STRING	RemainingName,
		IN PRX_CONNECTION_ID	ConnectionId
	)

Definition at line 6487 of file rxce.c.

{
    PVOID Container;
 
    PAGED_CODE();
 
    ASSERT(RxIsPrefixTableLockAcquired(ThisTable));
    ASSERT(CanonicalName->Length > 0);
 
    /* Call the internal helper */
    Container = RxTableLookupName(ThisTable, CanonicalName, RemainingName, ConnectionId);
    if (Container == NULL)
    {
        return NULL;
    }
 
    /* Reference our container before returning it */
    if (RdbssReferenceTracingValue != 0)
    {
        NODE_TYPE_CODE Type;
 
        Type = (NodeType(Container) & ~RX_SCAVENGER_MASK);
        switch (Type)
        {
            case RDBSS_NTC_SRVCALL:
                RxReferenceSrvCall(Container);
                break;
 
            case RDBSS_NTC_NETROOT:
                RxReferenceNetRoot(Container);
                break;
 
            case RDBSS_NTC_V_NETROOT:
                RxReferenceVNetRoot(Container);
                break;
 
            default:
                DPRINT1("Invalid node type: %x\n", Type);
                ASSERT(FALSE);
                RxReference(Container);
                break;
        }
    }
    else
    {
        RxReference(Container);
    }
 
    return Container;
}

Referenced by RxFindOrConstructVirtualNetRoot(), and RxFindOrCreateConnections().

RxpReleasePrefixTableLock()

VOID RxpReleasePrefixTableLock	(	PRX_PREFIX_TABLE	pTable,
		BOOLEAN	ProcessBufferingStateChangeRequests
	)

Definition at line 6566 of file rxce.c.

{
    PAGED_CODE();
 
    DPRINT("RxpReleasePrefixTableLock(%p, %d) -> %d\n", pTable, ProcessBufferingStateChangeRequests,
           pTable->TableLock.ActiveEntries);
 
    ExReleaseResourceLite(&pTable->TableLock);
}

RxPrepareContextForReuse()

VOID NTAPI RxPrepareContextForReuse

(

IN OUT PRX_CONTEXT

RxContext

)

Definition at line 6583 of file rxce.c.

{
    PAGED_CODE();
 
    /* When we reach that point, make sure mandatory parts are null-ed */
    if (RxContext->MajorFunction == IRP_MJ_CREATE)
    {
        ASSERT(RxContext->Create.CanonicalNameBuffer == NULL);
        RxContext->Create.RdrFlags = 0;
    }
    else if (RxContext->MajorFunction == IRP_MJ_READ || RxContext->MajorFunction == IRP_MJ_WRITE)
    {
        ASSERT(RxContext->RxContextSerializationQLinks.Flink == NULL);
        ASSERT(RxContext->RxContextSerializationQLinks.Blink == NULL);
    }
 
    RxContext->ReferenceCount = 0;
}

Referenced by RxDereferenceAndDeleteRxContext_Real(), and RxReinitializeContext().

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

RxProcessChangeBufferingStateRequests()

VOID NTAPI RxProcessChangeBufferingStateRequests

(

_In_ PVOID

SrvCall

)

Definition at line 6643 of file rxce.c.

{
    /* Call internal routine */
    RxUndoScavengerFinalizationMarking(SrvCall);
    RxpProcessChangeBufferingStateRequests(SrvCall, TRUE);
}

Referenced by RxCompleteSrvOpenKeyAssociation().

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

RxProcessFcbChangeBufferingStateRequest()

VOID RxProcessFcbChangeBufferingStateRequest

(

PFCB

Fcb

)

Definition at line 6685 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by __RxReleaseFcb(), __RxReleaseFcbForThread(), and RxProcessChangeBufferingStateRequestsForSrvOpen().

RxpScavengeFobxs()

VOID RxpScavengeFobxs	(	PRDBSS_SCAVENGER	Scavenger,
		PLIST_ENTRY	FobxToScavenge
	)

Definition at line 6695 of file rxce.c.

{
    /* Explore the whole list of FOBX to scavenge */
    while (!IsListEmpty(FobxToScavenge))
    {
        PFCB Fcb;
        PFOBX Fobx;
        PLIST_ENTRY Entry;
 
        Entry = RemoveHeadList(FobxToScavenge);
        Fobx = CONTAINING_RECORD(Entry, FOBX, ScavengerFinalizationList);
        Fcb = (PFCB)Fobx->SrvOpen->pFcb;
 
        /* Try to acquire the lock exclusively to perform finalization */
        if (RxAcquireExclusiveFcb(NULL, Fcb) != STATUS_SUCCESS)
        {
            RxDereferenceNetRoot(Fobx, LHS_LockNotHeld);
        }
        else
        {
            RxReferenceNetFcb(Fcb);
            RxDereferenceNetRoot(Fobx, LHS_ExclusiveLockHeld);
 
            if (!RxDereferenceAndFinalizeNetFcb(Fcb, NULL, FALSE, FALSE))
            {
                RxReleaseFcb(NULL, Fcb);
            }
        }
    }
}

Referenced by RxScavengeFobxsForNetRoot().

RxpTrackDereference()

BOOLEAN RxpTrackDereference	(	_In_ ULONG	TraceType,
		_In_ PCSTR	FileName,
		_In_ ULONG	Line,
		_In_ PVOID	Instance
	)

Definition at line 6729 of file rxce.c.

{
    PCSTR InstanceType;
    ULONG ReferenceCount;
 
    PAGED_CODE();
 
    if (!BooleanFlagOn(RdbssReferenceTracingValue, TraceType))
    {
        return TRUE;
    }
 
    switch (TraceType)
    {
        case RDBSS_REF_TRACK_SRVCALL:
            InstanceType = "SrvCall";
            ReferenceCount = ((PSRV_CALL)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETROOT:
            InstanceType = "NetRoot";
            ReferenceCount = ((PNET_ROOT)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_VNETROOT:
            InstanceType = "VNetRoot";
            ReferenceCount = ((PV_NET_ROOT)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETFOBX:
            InstanceType = "NetFobx";
            ReferenceCount = ((PFOBX)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETFCB:
            InstanceType = "NetFcb";
            ReferenceCount = ((PFCB)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_SRVOPEN:
            InstanceType = "SrvOpen";
            ReferenceCount = ((PSRV_OPEN)Instance)->NodeReferenceCount;
            break;
 
        default:
            DPRINT1("Invalid node type!\n");
            return TRUE;
    }
 
    if (BooleanFlagOn(RdbssReferenceTracingValue, RX_LOG_REF_TRACKING))
    {
        UNIMPLEMENTED;
    }
 
    if (BooleanFlagOn(RdbssReferenceTracingValue, RX_PRINT_REF_TRACKING))
    {
        DbgPrint("(%s:%d) %p (%s) dereferenced from %d\n", FileName, Line, Instance, InstanceType, ReferenceCount);
    }
 
    return TRUE;
}

RxpTrackReference()

VOID RxpTrackReference	(	_In_ ULONG	TraceType,
		_In_ PCSTR	FileName,
		_In_ ULONG	Line,
		_In_ PVOID	Instance
	)

Definition at line 6796 of file rxce.c.

{
    PCSTR InstanceType;
    ULONG ReferenceCount;
 
    if (!BooleanFlagOn(RdbssReferenceTracingValue, TraceType))
    {
        return;
    }
 
    switch (TraceType)
    {
        case RDBSS_REF_TRACK_SRVCALL:
            InstanceType = "SrvCall";
            ReferenceCount = ((PSRV_CALL)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETROOT:
            InstanceType = "NetRoot";
            ReferenceCount = ((PNET_ROOT)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_VNETROOT:
            InstanceType = "VNetRoot";
            ReferenceCount = ((PV_NET_ROOT)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETFOBX:
            InstanceType = "NetFobx";
            ReferenceCount = ((PFOBX)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_NETFCB:
            InstanceType = "NetFcb";
            ReferenceCount = ((PFCB)Instance)->NodeReferenceCount;
            break;
 
        case RDBSS_REF_TRACK_SRVOPEN:
            InstanceType = "SrvOpen";
            ReferenceCount = ((PSRV_OPEN)Instance)->NodeReferenceCount;
            break;
 
        default:
            DPRINT1("Invalid node type!\n");
            return;
    }
 
    if (BooleanFlagOn(RdbssReferenceTracingValue, RX_LOG_REF_TRACKING))
    {
        UNIMPLEMENTED;
    }
 
    if (BooleanFlagOn(RdbssReferenceTracingValue, RX_PRINT_REF_TRACKING))
    {
        DbgPrint("(%s:%d) %p (%s) referenced from %d\n", FileName, Line, Instance, InstanceType, ReferenceCount);
    }
}

RxpUndoScavengerFinalizationMarking()

VOID RxpUndoScavengerFinalizationMarking

(

PVOID

Instance

)

Definition at line 6862 of file rxce.c.

{
    PLIST_ENTRY ListEntry;
    PNODE_TYPE_AND_SIZE Node;
    PRDBSS_SCAVENGER Scavenger;
 
    PAGED_CODE();
 
    Node = (PNODE_TYPE_AND_SIZE)Instance;
    /* There's no marking - nothing to do */
    if (!BooleanFlagOn(NodeType(Node), RX_SCAVENGER_MASK))
    {
        return;
    }
 
    /* First of all, remove the mark */
    ClearFlag(NodeType(Node), RX_SCAVENGER_MASK);
    DPRINT("Node %p no longer has the scavenger mark\n");
 
    /* And now, remove from the scavenger */
    Scavenger = RxGetDeviceObjectOfInstance(Instance)->pRdbssScavenger;
    switch (NodeType(Node))
    {
        case RDBSS_NTC_FOBX:
            --Scavenger->FobxsToBeFinalized;
            ListEntry = &((PFOBX)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVCALL:
            --Scavenger->SrvCallsToBeFinalized;
            ListEntry = &((PSRV_CALL)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_NETROOT:
            --Scavenger->NetRootsToBeFinalized;
            ListEntry = &((PNET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_V_NETROOT:
            --Scavenger->VNetRootsToBeFinalized;
            ListEntry = &((PV_NET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVOPEN:
            --Scavenger->SrvOpensToBeFinalized;
            ListEntry = &((PSRV_OPEN)Instance)->ScavengerFinalizationList;
            break;
 
        default:
            return;
    }
 
    /* Also, remove the extra ref from the scavenger */
    RemoveEntryList(ListEntry);
    InterlockedDecrement((volatile long *)&Node->NodeReferenceCount);
}

Referenced by RxDereference(), RxReference(), RxScavengeRelatedFobxs(), and RxUndoScavengerFinalizationMarking().

RxPurgeChangeBufferingStateRequestsForSrvOpen()

VOID RxPurgeChangeBufferingStateRequestsForSrvOpen

(

PSRV_OPEN

SrvOpen

)

Definition at line 6924 of file rxce.c.

{
    PSRV_CALL SrvCall;
    LIST_ENTRY Discarded;
 
    PAGED_CODE();
 
    ASSERT(RxIsFcbAcquiredExclusive(SrvOpen->Fcb));
 
    /* Initialize our discarded list */
    InitializeListHead(&Discarded);
 
    SrvCall = (PSRV_CALL)SrvOpen->Fcb->VNetRoot->pNetRoot->pSrvCall;
    RxAcquireBufferingManagerMutex(&SrvCall->BufferingManager);
 
    /* Set the flag, and get the requests */
    InitializeListHead(&SrvOpen->SrvOpenKeyList);
    SetFlag(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_REQUESTS_PURGED);
    RxGatherRequestsForSrvOpen(SrvCall, SrvOpen, &Discarded);
 
    RxReleaseBufferingManagerMutex(&SrvCall->BufferingManager);
 
    /* If there were discarded requests */
    if (!IsListEmpty(&Discarded))
    {
        /* And a pending buffering state change */
        if (BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING))
        {
            /* Clear the flag, and set the associated event - job done */
            RxAcquireSerializationMutex();
            ClearFlag(SrvOpen->Fcb->FcbState, FCB_STATE_BUFFERING_STATE_CHANGE_PENDING);
            if (SrvOpen->Fcb->pBufferingStateChangeCompletedEvent != NULL)
            {
                KeSetEvent(SrvOpen->Fcb->pBufferingStateChangeCompletedEvent, IO_NETWORK_INCREMENT, FALSE);
            }
            RxReleaseSerializationMutex();
        }
 
        /* Drop the discarded requests */
        RxpDiscardChangeBufferingStateRequests(&Discarded);
    }
}

Referenced by RxFinalizeSrvOpen().

RxPurgeFcb()

VOID RxPurgeFcb

(

IN PFCB

Fcb

)

Definition at line 6972 of file rxce.c.

{
    PAGED_CODE();
 
    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
    /* Reference our FCB so that it doesn't disappear */
    RxReferenceNetFcb(Fcb);
    /* Purge Cc if required */
    if (Fcb->OpenCount != 0)
    {
        RxPurgeFcbInSystemCache(Fcb, NULL, 0, TRUE, TRUE);
    }
 
    /* If it wasn't freed, release the lock */
    if (!RxDereferenceAndFinalizeNetFcb(Fcb, NULL, FALSE, FALSE))
    {
        RxReleaseFcb(NULL, Fcb);
    }
}

Referenced by RxFinalizeConnection(), and RxFinalizeNetRoot().

RxPurgeFcbInSystemCache()

NTSTATUS RxPurgeFcbInSystemCache	(	IN PFCB	Fcb,
		IN PLARGE_INTEGER FileOffset	OPTIONAL,
		IN ULONG	Length,
		IN BOOLEAN	UninitializeCacheMaps,
		IN BOOLEAN	FlushFile
	)

Definition at line 6998 of file rxce.c.

{
    BOOLEAN Purged;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
    /* Try to flush first, if asked */
    if (FlushFile)
    {
        /* If flushing failed, just make some noise */
        Status = RxFlushFcbInSystemCache(Fcb, TRUE);
        if (!NT_SUCCESS(Status))
        {
            PVOID CallersAddress, CallersCaller;
 
            RtlGetCallersAddress(&CallersAddress, &CallersCaller);
            DPRINT1("Flush failed with status %lx for FCB %p\n", Status, Fcb);
            DPRINT1("Caller was %p %p\n", CallersAddress, CallersCaller);
        }
    }
 
    /* Deal with Cc for purge */
    Purged = CcPurgeCacheSection(&Fcb->NonPaged->SectionObjectPointers, FileOffset,
                                 Length, UninitializeCacheMaps);
    /* If purge failed, force section closing */
    if (!Purged)
    {
        MmFlushImageSection(&Fcb->NonPaged->SectionObjectPointers, MmFlushForWrite);
 
        RxReleaseFcb(NULL, Fcb);
        Purged = MmForceSectionClosed(&Fcb->NonPaged->SectionObjectPointers, TRUE);
        RxAcquireExclusiveFcb(NULL, Fcb);
    }
 
    /* Return appropriate status */
    Status = (Purged ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
    DPRINT("Purge for FCB %p returns %lx\n", Fcb, Status);
 
    return Status;
}

Referenced by RxPurgeFcb(), RxPurgeFobx(), and RxPurgeFobxFromCache().

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

RxPurgeRelatedFobxs()

NTSTATUS RxPurgeRelatedFobxs	(	PNET_ROOT	NetRoot,
		PRX_CONTEXT	RxContext,
		BOOLEAN	AttemptFinalization,
		PFCB	PurgingFcb
	)

Definition at line 7133 of file rxce.c.

{
    PLIST_ENTRY Entry;
    ULONG SuccessfullPurge;
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    PPURGE_SYNCHRONIZATION_CONTEXT PurgeSyncCtx;
 
    PAGED_CODE();
 
    RxDeviceObject = RxContext->RxDeviceObject;
    Scavenger = RxDeviceObject->pRdbssScavenger;
    PurgeSyncCtx = &NetRoot->PurgeSyncronizationContext;
 
    RxAcquireScavengerMutex();
 
    /* If there's already a purge in progress */
    if (PurgeSyncCtx->PurgeInProgress)
    {
        /* Add our RX_CONTEXT to the current run */
        InsertTailList(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion,
                       &RxContext->RxContextSerializationQLinks);
 
        /* And wait until it's done */
        RxReleaseScavengerMutex();
        RxWaitSync(RxContext);
        RxAcquireScavengerMutex();
    }
 
    /* Start the purge */
    PurgeSyncCtx->PurgeInProgress = TRUE;
 
    /* While the purge is still handling our NET_ROOT, do nothing but wait */
    while (Scavenger->CurrentNetRootForClosePendingProcessing == NetRoot)
    {
        RxReleaseScavengerMutex();
        KeWaitForSingleObject(&Scavenger->ClosePendingProcessingSyncEvent, Executive,
                              KernelMode, TRUE, NULL);
        RxAcquireScavengerMutex();
    }
 
    /* Now, for all the entries */
    SuccessfullPurge = 0;
    Entry = Scavenger->ClosePendingFobxsList.Flink;
    while (Entry != &Scavenger->ClosePendingFobxsList)
    {
        PFCB Fcb;
        PFOBX Fobx;
        BOOLEAN Success;
 
        Fobx = CONTAINING_RECORD(Entry, FOBX, ClosePendingList);
        DPRINT("Dealing with FOBX: %p\n", Fobx);
 
        Entry = Entry->Flink;
 
        /* If it's not matching our NET_ROOT, ignore */
        if (Fobx->pSrvOpen == NULL ||
            Fobx->pSrvOpen->pFcb == NULL ||
            ((PFCB)Fobx->pSrvOpen->pFcb)->VNetRoot == NULL ||
            (PNET_ROOT)((PFCB)Fobx->pSrvOpen->pFcb)->VNetRoot->pNetRoot != NetRoot)
        {
            continue;
        }
 
        /* Determine if it matches our FCB */
        Fcb = (PFCB)Fobx->pSrvOpen->pFcb;
        if (PurgingFcb != NULL && NodeType(PurgingFcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY &&
            PurgingFcb != Fcb)
        {
            NTSTATUS Status;
 
            MINIRDR_CALL_THROUGH(Status, RxDeviceObject->Dispatch, MRxAreFilesAliased, (Fcb, PurgingFcb));
            if (Status == STATUS_SUCCESS)
            {
                continue;
            }
        }
 
        /* Matching, we'll purge it */
        RemoveEntryList(&Fobx->ClosePendingList);
 
        /* Reference it so that it doesn't disappear */
        RxReferenceNetFobx(Fobx);
 
        RxReleaseScavengerMutex();
 
        /* And purge */
        Success = RxPurgeFobx(Fobx);
        if (Success)
        {
            ++SuccessfullPurge;
        }
 
        /* If we don't have to finalize it (or if we cannot acquire lock exclusively
         * Just normally dereference
         */
        if ((AttemptFinalization == DONT_ATTEMPT_FINALIZE_ON_PURGE) ||
            RxAcquireExclusiveFcb(NULL, Fcb) != STATUS_SUCCESS)
        {
            RxDereferenceNetFobx(Fobx, LHS_LockNotHeld);
        }
        /* Otherwise, finalize */
        else
        {
            RxReferenceNetFcb(Fcb);
            RxDereferenceNetFobx(Fobx, LHS_ExclusiveLockHeld);
            if (!RxDereferenceAndFinalizeNetFcb(Fcb, NULL, FALSE, FALSE))
            {
                RxReleaseFcb(NULL, Fcb);
            }
        }
 
        if (!Success)
        {
            DPRINT1("Failed purging %p (%p)\n", Fcb, Fobx);
        }
 
        RxAcquireScavengerMutex();
    }
 
    /* If no contexts left, purge is not running */
    if (IsListEmpty(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion))
    {
        PurgeSyncCtx->PurgeInProgress = FALSE;
    }
    /* Otherwise, notify a waiter it can start */
    else
    {
        PRX_CONTEXT Context;
 
        Entry = RemoveHeadList(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion);
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, RxContextSerializationQLinks);
 
        RxSignalSynchronousWaiter(Context);
    }
 
    RxReleaseScavengerMutex();
 
    return (SuccessfullPurge > 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

Referenced by RxCommonCreate(), RxCommonSetInformation(), and RxCreateFromNetRoot().

RxpWorkerThreadDispatcher()

VOID RxpWorkerThreadDispatcher	(	IN PRX_WORK_QUEUE	WorkQueue,
		IN PLARGE_INTEGER	WaitInterval
	)

Definition at line 7282 of file rxce.c.

{
    NTSTATUS Status;
    PVOID Parameter;
    PETHREAD CurrentThread;
    BOOLEAN KillThread, Dereference;
    PRX_WORK_QUEUE_ITEM WorkQueueItem;
    PWORKER_THREAD_ROUTINE WorkerRoutine;
 
    InterlockedIncrement(&WorkQueue->NumberOfIdleWorkerThreads);
 
    /* Reference ourselves */
    CurrentThread = PsGetCurrentThread();
    Status = ObReferenceObjectByPointer(CurrentThread, THREAD_ALL_ACCESS, *PsThreadType, KernelMode);
    ASSERT(NT_SUCCESS(Status));
 
    /* Infinite loop for worker */
    KillThread = FALSE;
    Dereference = FALSE;
    do
    {
        KIRQL OldIrql;
        PLIST_ENTRY ListEntry;
 
        /* Remove an entry from the work queue */
        ListEntry = KeRemoveQueue(&WorkQueue->Queue, KernelMode, WaitInterval);
        if ((ULONG_PTR)ListEntry != STATUS_TIMEOUT)
        {
            PRDBSS_DEVICE_OBJECT DeviceObject;
 
            WorkQueueItem = CONTAINING_RECORD(ListEntry, RX_WORK_QUEUE_ITEM, List);
 
            InterlockedIncrement(&WorkQueue->NumberOfWorkItemsDispatched);
            InterlockedDecrement(&WorkQueue->NumberOfWorkItemsToBeDispatched);
            InterlockedDecrement(&WorkQueue->NumberOfIdleWorkerThreads);
 
            /* Get the parameters, and null-them in the struct */
            WorkerRoutine = WorkQueueItem->WorkerRoutine;
            Parameter = WorkQueueItem->Parameter;
            DeviceObject = WorkQueueItem->pDeviceObject;
 
            WorkQueueItem->List.Flink = NULL;
            WorkQueueItem->WorkerRoutine = NULL;
            WorkQueueItem->Parameter = NULL;
            WorkQueueItem->pDeviceObject = NULL;
 
            /* Call the routine */
            DPRINT("Calling: %p(%p)\n", WorkerRoutine, Parameter);
            WorkerRoutine(Parameter);
 
            /* Are we going down now? */
            if (InterlockedDecrement(&DeviceObject->DispatcherContext.NumberOfWorkerThreads) == 0)
            {
                PKEVENT TearDownEvent;
 
                TearDownEvent = InterlockedExchangePointer((void * volatile*)&DeviceObject->DispatcherContext.pTearDownEvent, NULL);
                if (TearDownEvent != NULL)
                {
                    KeSetEvent(TearDownEvent, IO_NO_INCREMENT, FALSE);
                }
            }
 
            InterlockedIncrement(&WorkQueue->NumberOfIdleWorkerThreads);
        }
 
        /* Shall we shutdown... */
        KeAcquireSpinLock(&WorkQueue->SpinLock, &OldIrql);
        switch (WorkQueue->State)
        {
            /* Our queue is active, kill it if we have no more items to dispatch
             * and more threads than the required minimum
             */
            case RxWorkQueueActive:
                if (WorkQueue->NumberOfWorkItemsToBeDispatched <= 0)
                {
                    ASSERT(WorkQueue->NumberOfActiveWorkerThreads > 0);
                    if (WorkQueue->NumberOfActiveWorkerThreads > WorkQueue->MinimumNumberOfWorkerThreads)
                    {
                        KillThread = TRUE;
                        Dereference = TRUE;
                        InterlockedDecrement(&WorkQueue->NumberOfActiveWorkerThreads);
                    }
 
                    if (KillThread)
                    {
                        InterlockedDecrement(&WorkQueue->NumberOfIdleWorkerThreads);
                    }
                }
                break;
 
            /* The queue is inactive: kill it we have more threads than the required minimum */
            case RxWorkQueueInactive:
                ASSERT(WorkQueue->NumberOfActiveWorkerThreads > 0);
                if (WorkQueue->NumberOfActiveWorkerThreads > WorkQueue->MinimumNumberOfWorkerThreads)
                {
                    KillThread = TRUE;
                    Dereference = TRUE;
                    InterlockedDecrement(&WorkQueue->NumberOfActiveWorkerThreads);
                }
 
                if (KillThread)
                {
                    InterlockedDecrement(&WorkQueue->NumberOfIdleWorkerThreads);
                }
                break;
 
            /* Rundown in progress..., kill it for sure! */
            case RxWorkQueueRundownInProgress:
                {
                    PRX_WORK_QUEUE_RUNDOWN_CONTEXT RundownContext;
 
                    ASSERT(WorkQueue->pRundownContext != NULL);
 
                    RundownContext = WorkQueue->pRundownContext;
                    RundownContext->ThreadPointers[RundownContext->NumberOfThreadsSpunDown++] = CurrentThread;
 
                    InterlockedDecrement(&WorkQueue->NumberOfActiveWorkerThreads);
                    KillThread = TRUE;
                    Dereference = FALSE;
 
                    if (WorkQueue->NumberOfActiveWorkerThreads == 0)
                    {
                        KeSetEvent(&RundownContext->RundownCompletionEvent, IO_NO_INCREMENT, FALSE);
                    }
 
                    InterlockedDecrement(&WorkQueue->NumberOfIdleWorkerThreads);
                }
                break;
 
            default:
                break;
        }
        KeReleaseSpinLock(&WorkQueue->SpinLock, OldIrql);
    } while (!KillThread);
 
    DPRINT("Killed worker thread\n");
 
    /* Do we have to dereference ourselves? */
    if (Dereference)
    {
        ObDereferenceObject(CurrentThread);
    }
 
    /* Dump last executed routine */
    if (DumpDispatchRoutine)
    {
        DPRINT("Dispatch routine %p(%p) taken from %p\n", WorkerRoutine, Parameter, WorkQueueItem);
    }
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by RxBootstrapWorkerThreadDispatcher().

RxReference()

VOID RxReference

(

IN OUT PVOID

Instance

)

Definition at line 7437 of file rxce.c.

{
    NODE_TYPE_CODE NodeType;
    PNODE_TYPE_AND_SIZE Node;
 
    PAGED_CODE();
 
    RxAcquireScavengerMutex();
 
    /* We can only reference a few structs */
    NodeType = NodeType(Instance) & ~RX_SCAVENGER_MASK;
    ASSERT((NodeType == RDBSS_NTC_SRVCALL) || (NodeType == RDBSS_NTC_NETROOT) ||
           (NodeType == RDBSS_NTC_V_NETROOT) || (NodeType == RDBSS_NTC_SRVOPEN) ||
           (NodeType == RDBSS_NTC_FOBX));
 
    Node = (PNODE_TYPE_AND_SIZE)Instance;
    InterlockedIncrement((volatile long *)&Node->NodeReferenceCount);
 
    /* Trace refcount if asked */
    switch (NodeType)
    {
        case RDBSS_NTC_SRVCALL:
            PRINT_REF_COUNT(SRVCALL, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_NETROOT:
            PRINT_REF_COUNT(NETROOT, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_V_NETROOT:
            PRINT_REF_COUNT(VNETROOT, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_SRVOPEN:
            PRINT_REF_COUNT(SRVOPEN, Node->NodeReferenceCount);
            break;
 
        case RDBSS_NTC_FOBX:
            PRINT_REF_COUNT(NETFOBX, Node->NodeReferenceCount);
            break;
 
        default:
            ASSERT(FALSE);
            break;
    }
 
    RxpUndoScavengerFinalizationMarking(Instance);
    RxReleaseScavengerMutex();
}

Referenced by RxPrefixTableLookupName().

RxReinitializeContext()

VOID NTAPI RxReinitializeContext

(

IN OUT PRX_CONTEXT

RxContext

)

Definition at line 7493 of file rxce.c.

{
    PIRP Irp;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    ULONG InitialContextFlags, SavedFlags;
 
    PAGED_CODE();
 
    /* Backup a few flags */
    Irp = RxContext->CurrentIrp;
    RxDeviceObject = RxContext->RxDeviceObject;
    SavedFlags = RxContext->Flags & RX_CONTEXT_PRESERVED_FLAGS;
    InitialContextFlags = RxContext->Flags & RX_CONTEXT_INITIALIZATION_FLAGS;
 
    /* Reset our context */
    RxPrepareContextForReuse(RxContext);
 
    /* Zero everything */
    RtlZeroMemory(&RxContext->MajorFunction, sizeof(RX_CONTEXT) - FIELD_OFFSET(RX_CONTEXT, MajorFunction));
 
    /* Restore saved flags */
    RxContext->Flags = SavedFlags;
    /* And reinit the context */
    RxInitializeContext(Irp, RxDeviceObject, InitialContextFlags, RxContext);
}

RxReleaseFcbFromLazyWrite()

VOID NTAPI RxReleaseFcbFromLazyWrite

(

PVOID

Context

)

Definition at line 7525 of file rxce.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    Fcb = Context;
    /* The received context is a FCB */
    ASSERT(NodeType(Fcb) == RDBSS_NTC_FCB);
    ASSERT_CORRECT_FCB_STRUCTURE(Fcb);
 
    /* Lazy writer is releasing lock, so forget about it */
    Fcb->Specific.Fcb.LazyWriteThread = NULL;
 
    /* If we were top level IRP, unwind */
    if (RxGetTopIrpIfRdbssIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
    {
        RxUnwindTopLevelIrp(NULL);
    }
 
    /* And finally, release the lock */
    Fcb->PagingIoResourceFile = NULL;
    Fcb->PagingIoResourceLine = 0;
    ExReleaseResourceLite(Fcb->Header.PagingIoResource);
}

RxReleaseFcbFromReadAhead()

VOID NTAPI RxReleaseFcbFromReadAhead

(

PVOID

Context

)

Definition at line 7557 of file rxce.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    Fcb = Context;
    /* The received context is a FCB */
    ASSERT(NodeType(Fcb) == RDBSS_NTC_FCB);
    ASSERT_CORRECT_FCB_STRUCTURE(Fcb);
 
    /* Top Level IRP is CC */
    ASSERT(RxGetTopIrpIfRdbssIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
    RxUnwindTopLevelIrp(NULL);
 
    ExReleaseResourceLite(Fcb->Header.Resource);
}

RxReleaseFileForNtCreateSection()

VOID NTAPI RxReleaseFileForNtCreateSection

(

PFILE_OBJECT

FileObject

)

Definition at line 7578 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxInitializeDispatchVectors().

RxReleaseForCcFlush()

NTSTATUS NTAPI RxReleaseForCcFlush	(	PFILE_OBJECT	FileObject,
		PDEVICE_OBJECT	DeviceObject
	)

Definition at line 7586 of file rxce.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by RxInitializeDispatchVectors().

RxRemoveNameNetFcb()

VOID RxRemoveNameNetFcb

(

OUT PFCB

ThisFcb

)

Definition at line 7598 of file rxce.c.

{
    PNET_ROOT NetRoot;
 
    PAGED_CODE();
 
    ASSERT(NodeTypeIsFcb(ThisFcb));
 
    /* Just remove the entry from the FCB_TABLE */
    NetRoot = (PNET_ROOT)ThisFcb->VNetRoot->pNetRoot;
    ASSERT(RxIsFcbTableLockExclusive(&NetRoot->FcbTable));
    ASSERT(RxIsFcbAcquiredExclusive(ThisFcb));
 
#ifdef __REACTOS__
    if (!BooleanFlagOn(ThisFcb->FcbState, FCB_STATE_NAME_ALREADY_REMOVED))
    {
#endif
        RxFcbTableRemoveFcb(&NetRoot->FcbTable, ThisFcb);
        DPRINT("FCB (%p) %wZ removed\n", ThisFcb, &ThisFcb->FcbTableEntry.Path);
        /* Mark, so that we don't try to do it twice */
        SetFlag(ThisFcb->FcbState, FCB_STATE_NAME_ALREADY_REMOVED);
#ifdef __REACTOS__
    }
#endif
}

RxRemoveOperationFromBlockingQueue()

VOID RxRemoveOperationFromBlockingQueue

(

IN OUT PRX_CONTEXT

RxContext

)

Definition at line 7629 of file rxce.c.

{
    /* Acquire the pipe mutex */
    ExAcquireFastMutex(&RxContextPerFileSerializationMutex);
 
    /* Is that a blocking serial operation? */
    if (BooleanFlagOn(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION))
    {
        /* Clear it! */
        ClearFlag(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION);
 
        /* Drop it off the list */
        RemoveEntryList(&RxContext->RxContextSerializationQLinks);
        RxContext->RxContextSerializationQLinks.Flink = NULL;
        RxContext->RxContextSerializationQLinks.Blink = NULL;
    }
 
    /* Done */
    ExReleaseFastMutex(&RxContextPerFileSerializationMutex);
}

RxRemovePrefixTableEntry()

VOID RxRemovePrefixTableEntry	(	IN OUT PRX_PREFIX_TABLE	ThisTable,
		IN OUT PRX_PREFIX_ENTRY	Entry
	)

Definition at line 7655 of file rxce.c.

{
    PAGED_CODE();
 
    ASSERT(NodeType(Entry) == RDBSS_NTC_PREFIX_ENTRY);
    ASSERT(RxIsPrefixTableLockExclusive(ThisTable));
 
    /* Check whether we're asked to remove null entry */
    if (Entry->Prefix.Length == 0)
    {
        ThisTable->TableEntryForNull = NULL;
    }
    else
    {
        RemoveEntryList(&Entry->HashLinks);
    }
 
    Entry->ContainingRecord = NULL;
 
    /* Also remove it from global list */
    RemoveEntryList(&Entry->MemberQLinks);
 
    ++ThisTable->Version;
}

Referenced by RxFinalizeNetRoot(), RxFinalizeSrvCall(), RxFinalizeVNetRoot(), and RxRemoveVirtualNetRootFromNetRoot().

RxRemoveVirtualNetRootFromNetRoot()

VOID RxRemoveVirtualNetRootFromNetRoot	(	PNET_ROOT	NetRoot,
		PV_NET_ROOT	VNetRoot
	)

Definition at line 7686 of file rxce.c.

{
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    PrefixTable = NetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
 
    /* Remove the VNetRoot from the list in the NetRoot */
    --NetRoot->NumberOfVirtualNetRoots;
    RemoveEntryList(&VNetRoot->NetRootListEntry);
 
    /* Fix the NetRoot if we were the default VNetRoot */
    if (NetRoot->DefaultVNetRoot == VNetRoot)
    {
        /* Put the first one available */
        if (!IsListEmpty(&NetRoot->VirtualNetRoots))
        {
            NetRoot->DefaultVNetRoot = CONTAINING_RECORD(NetRoot->VirtualNetRoots.Flink, V_NET_ROOT, NetRootListEntry);
        }
        /* Otherwise, none */
        else
        {
            NetRoot->DefaultVNetRoot = NULL;
        }
    }
 
    /* If there are still other VNetRoot available, we're done */
    if (!IsListEmpty(&NetRoot->VirtualNetRoots))
    {
        return;
    }
 
    /* Otherwise, initiate NetRoot finalization */
    if (!BooleanFlagOn(NetRoot->Flags, NETROOT_FLAG_NAME_ALREADY_REMOVED))
    {
        RxRemovePrefixTableEntry(PrefixTable, &NetRoot->PrefixEntry);
        SetFlag(NetRoot->Flags, NETROOT_FLAG_NAME_ALREADY_REMOVED);
    }
 
    /* Notify mini-rdr */
    if (NetRoot->pSrvCall != NULL && NetRoot->pSrvCall->RxDeviceObject != NULL)
    {
        NTSTATUS Status;
 
        MINIRDR_CALL_THROUGH(Status, NetRoot->pSrvCall->RxDeviceObject->Dispatch,
                             MRxFinalizeNetRoot, ((PMRX_NET_ROOT)NetRoot, FALSE));
        (void)Status;
    }
}

Referenced by RxFinalizeVNetRoot().

RxResumeBlockedOperations_ALL()

VOID RxResumeBlockedOperations_ALL

(

IN OUT PRX_CONTEXT

RxContext

)

Definition at line 7741 of file rxce.c.

{
    LIST_ENTRY BlockedOps;
 
    PAGED_CODE();
 
    /* Get the blocked operations */
    RxTransferListWithMutex(&BlockedOps, &RxContext->BlockedOperations, RxContext->BlockedOpsMutex);
 
    if (!IsListEmpty(&BlockedOps))
    {
        UNIMPLEMENTED;
    }
}

Referenced by RxLowIoCompletionTail().

RxResumeBlockedOperations_Serially()

VOID NTAPI RxResumeBlockedOperations_Serially	(	IN OUT PRX_CONTEXT	RxContext,
		IN OUT PLIST_ENTRY	BlockingIoQ
	)

Definition at line 7759 of file rxce.c.

{
    PAGED_CODE();
 
    RxAcquireSerializationMutex();
 
    /* This can only happen on pipes */
    if (!BooleanFlagOn(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION))
    {
        RxReleaseSerializationMutex();
        return;
    }
 
    UNIMPLEMENTED;
 
    RxReleaseSerializationMutex();
}

RxScavengeFobxsForNetRoot()

VOID RxScavengeFobxsForNetRoot	(	PNET_ROOT	NetRoot,
		PFCB	PurgingFcb,
		BOOLEAN	SynchronizeWithScavenger
	)

Definition at line 7798 of file rxce.c.

{
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
 
    PAGED_CODE();
 
    RxDeviceObject = NetRoot->pSrvCall->RxDeviceObject;
    Scavenger = RxDeviceObject->pRdbssScavenger;
 
    /* Wait for the scavenger, if asked to */
    if (SynchronizeWithScavenger)
    {
        KeWaitForSingleObject(&Scavenger->ScavengeEvent, Executive, KernelMode, FALSE, NULL);
    }
 
    RxAcquireScavengerMutex();
 
    /* If there's nothing left to do... */
    if (Scavenger->FobxsToBeFinalized <= 0)
    {
        RxReleaseScavengerMutex();
    }
    else
    {
        PLIST_ENTRY Entry;
        LIST_ENTRY FobxToScavenge;
 
        InitializeListHead(&FobxToScavenge);
 
        /* Browse all the FOBXs to finalize */
        Entry = Scavenger->FobxFinalizationList.Flink;
        while (Entry != &Scavenger->FobxFinalizationList)
        {
            PFOBX Fobx;
 
            Fobx = CONTAINING_RECORD(Entry, FOBX, ScavengerFinalizationList);
            Entry = Entry->Flink;
 
            if (Fobx->SrvOpen != NULL)
            {
                PFCB Fcb;
 
                Fcb = (PFCB)Fobx->SrvOpen->pFcb;
 
                /* If it matches our NET_ROOT */
                if ((PNET_ROOT)Fcb->pNetRoot == NetRoot)
                {
                    NTSTATUS Status;
 
                    /* Check whether it matches our FCB */
                    Status = STATUS_MORE_PROCESSING_REQUIRED;
                    if (PurgingFcb != NULL && PurgingFcb != Fcb)
                    {
                        MINIRDR_CALL_THROUGH(Status, RxDeviceObject->Dispatch, MRxAreFilesAliased, (Fcb, PurgingFcb));
                    }
 
                    /* If so, add it to the list of the FOBXs to scavenge */
                    if (Status != STATUS_SUCCESS)
                    {
                        RxReferenceNetFobx(Fobx);
                        ASSERT(NodeType(Fobx) == RDBSS_NTC_FOBX);
 
                        RemoveEntryList(&Fobx->ScavengerFinalizationList);
                        InsertTailList(&FobxToScavenge, &Fobx->ScavengerFinalizationList);
                    }
                }
            }
        }
 
        RxReleaseScavengerMutex();
 
        /* Now, scavenge all the extracted FOBX */
        RxpScavengeFobxs(Scavenger, &FobxToScavenge);
    }
 
    if (SynchronizeWithScavenger)
    {
        KeSetEvent(&Scavenger->ScavengeEvent, IO_NO_INCREMENT, FALSE);
    }
}

Referenced by RxCommonCreate(), and RxCommonSetInformation().

RxScavengeRelatedFobxs()

BOOLEAN RxScavengeRelatedFobxs

(

PFCB

Fcb

)

Definition at line 7887 of file rxce.c.

{
    PFOBX Fobx;
    LIST_ENTRY LocalList;
    PLIST_ENTRY NextEntry;
    PRDBSS_SCAVENGER Scavenger;
 
    PAGED_CODE();
 
    /* First of all, check whether there are FOBX to scavenge */
    Scavenger = Fcb->RxDeviceObject->pRdbssScavenger;
    RxAcquireScavengerMutex();
    if (Scavenger->FobxsToBeFinalized <= 0)
    {
        RxReleaseScavengerMutex();
        return FALSE;
    }
 
    /* Initialize our local list which will hold all the FOBX to scavenge so
     * that we don't acquire the scavenger mutex too long
     */
    InitializeListHead(&LocalList);
 
    /* Technically, that condition should all be true... */
    if (!IsListEmpty(&Scavenger->FobxFinalizationList))
    {
        PLIST_ENTRY NextEntry, LastEntry;
 
        /* Browse all the FCBs to find the matching ones */
        NextEntry = Scavenger->FobxFinalizationList.Flink;
        LastEntry = &Scavenger->FobxFinalizationList;
        while (NextEntry != LastEntry)
        {
            Fobx = CONTAINING_RECORD(NextEntry, FOBX, ScavengerFinalizationList);
            NextEntry = NextEntry->Flink;
            /* Matching our FCB? Let's finalize it */
            if (Fobx->pSrvOpen != NULL && Fobx->pSrvOpen->pFcb == RX_GET_MRX_FCB(Fcb))
            {
                RxpUndoScavengerFinalizationMarking(Fobx);
                ASSERT(NodeType(Fobx) == RDBSS_NTC_FOBX);
                InsertTailList(&LocalList, &Fobx->ScavengerFinalizationList);
            }
        }
    }
 
    RxReleaseScavengerMutex();
 
    /* Nothing to scavenge? Quit */
    if (IsListEmpty(&LocalList))
    {
        return FALSE;
    }
 
    /* Now, finalize all the extracted FOBX */
    while (!IsListEmpty(&LocalList))
    {
        NextEntry = RemoveHeadList(&LocalList);
        Fobx = CONTAINING_RECORD(NextEntry, FOBX, ScavengerFinalizationList);
        RxFinalizeNetFobx(Fobx, TRUE, TRUE);
    }
 
    return TRUE;
}

Referenced by RxFinalizeConnection().

RxScavengerFinalizeEntries()

VOID RxScavengerFinalizeEntries

(

PRDBSS_DEVICE_OBJECT

DeviceObject

)

Definition at line 7953 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxScavengerTimerRoutine().

RxScavengerTimerRoutine()

VOID NTAPI RxScavengerTimerRoutine

(

PVOID

Context

)

Definition at line 7964 of file rxce.c.

{
    BOOLEAN Requeue;
    PRDBSS_DEVICE_OBJECT DeviceObject;
    PRDBSS_SCAVENGER Scavenger;
 
    PAGED_CODE();
 
    DeviceObject = Context;
    Scavenger = DeviceObject->pRdbssScavenger;
 
    Requeue = FALSE;
    RxAcquireScavengerMutex();
    /* If the scavenger was dormant, wake it up! */
    if (Scavenger->State == RDBSS_SCAVENGER_DORMANT)
    {
        /* Done */
        Scavenger->State = RDBSS_SCAVENGER_ACTIVE;
        KeClearEvent(&Scavenger->ScavengeEvent);
 
        /* Scavenger the entries */
        RxReleaseScavengerMutex();
        RxScavengerFinalizeEntries(DeviceObject);
        RxAcquireScavengerMutex();
 
        /* If we're still active (race) */
        if (Scavenger->State == RDBSS_SCAVENGER_ACTIVE)
        {
            /* If there are new entries to scavenge, stay dormant and requeue a run */
            if (Scavenger->NumberOfDormantFiles + Scavenger->SrvCallsToBeFinalized +
                Scavenger->NetRootsToBeFinalized + Scavenger->VNetRootsToBeFinalized +
                Scavenger->FcbsToBeFinalized + Scavenger->SrvOpensToBeFinalized +
                Scavenger->FobxsToBeFinalized != 0)
            {
                Requeue = TRUE;
                Scavenger->State = RDBSS_SCAVENGER_DORMANT;
            }
            /* Otherwise, we're inactive again */
            else
            {
                Scavenger->State = RDBSS_SCAVENGER_INACTIVE;
            }
        }
 
        RxReleaseScavengerMutex();
 
        /* Requeue an execution */
        if (Requeue)
        {
            RxPostOneShotTimerRequest(RxFileSystemDeviceObject, &Scavenger->WorkItem,
                                      RxScavengerTimerRoutine, DeviceObject, Scavenger->TimeLimit);
        }
    }
    else
    {
        RxReleaseScavengerMutex();
    }
 
    KeSetEvent(&Scavenger->ScavengeEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by RxMarkFobxOnCleanup(), RxpMarkInstanceForScavengedFinalization(), and RxScavengerTimerRoutine().

RxScavengeVNetRoots()

BOOLEAN RxScavengeVNetRoots

(

PRDBSS_DEVICE_OBJECT

RxDeviceObject

)

Definition at line 8027 of file rxce.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

RxSetFileSizeWithLock()

VOID RxSetFileSizeWithLock	(	IN OUT PFCB	Fcb,
		IN PLONGLONG	FileSize
	)

Definition at line 7783 of file rxce.c.

{
    PAGED_CODE();
 
    /* Set attribute and increase version */
    Fcb->Header.FileSize.QuadPart = *FileSize;
    ++Fcb->ulFileSizeVersion;
}

RxSpinUpRequestsDispatcher()

VOID NTAPI RxSpinUpRequestsDispatcher

(

PVOID

Dispatcher

)

Definition at line 8039 of file rxce.c.

{
    NTSTATUS Status;
    PRX_DISPATCHER RxDispatcher;
 
    Status = ObReferenceObjectByPointer(PsGetCurrentThread(), THREAD_ALL_ACCESS, *PsThreadType, KernelMode);
    if (!NT_SUCCESS(Status))
    {
        PsTerminateSystemThread(STATUS_SUCCESS);
    }
 
    RxDispatcher = Dispatcher;
 
    do
    {
        KIRQL OldIrql;
        PLIST_ENTRY ListEntry;
 
        Status = KeWaitForSingleObject(&RxDispatcher->SpinUpRequestsEvent, Executive,
                                       KernelMode, FALSE, &RxSpinUpDispatcherWaitInterval);
        ASSERT((Status == STATUS_SUCCESS) || (Status == STATUS_TIMEOUT));
 
        KeAcquireSpinLock(&RxDispatcher->SpinUpRequestsLock, &OldIrql);
        if (!IsListEmpty(&RxDispatcher->SpinUpRequests))
        {
            ListEntry = RemoveHeadList(&RxDispatcher->SpinUpRequests);
        }
        else
        {
            ListEntry = &RxDispatcher->SpinUpRequests;
        }
        KeClearEvent(&RxDispatcher->SpinUpRequestsEvent);
        KeReleaseSpinLock(&RxDispatcher->SpinUpRequestsLock, OldIrql);
 
        while (ListEntry != &RxDispatcher->SpinUpRequests)
        {
            PWORK_QUEUE_ITEM WorkItem;
            PRX_WORK_QUEUE WorkQueue;
 
            WorkItem = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ITEM, List);
            WorkQueue = WorkItem->Parameter;
 
            InterlockedDecrement(&WorkQueue->WorkQueueItemForSpinUpWorkerThreadInUse);
 
            DPRINT("Workqueue: calling %p(%p)\n", WorkItem->WorkerRoutine, WorkItem->Parameter);
            WorkItem->WorkerRoutine(WorkItem->Parameter);
        }
    } while (RxDispatcher->State == RxDispatcherActive);
 
    KeSetEvent(&RxDispatcher->SpinUpRequestsTearDownEvent, IO_NO_INCREMENT, FALSE);
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by RxInitializeDispatcher().

RxSpinUpWorkerThread()

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

Definition at line 8097 of file rxce.c.

{
    KIRQL OldIrql;
    NTSTATUS Status;
    HANDLE ThreadHandle;
 
    PAGED_CODE();
 
    /* If work queue is inactive, that cannot work */
    KeAcquireSpinLock(&WorkQueue->SpinLock, &OldIrql);
    if (WorkQueue->State != RxWorkQueueActive)
    {
        Status = STATUS_UNSUCCESSFUL;
        DPRINT("Workqueue not active! WorkQ: %p, State: %d, Active: %d\n", WorkQueue, WorkQueue->State, WorkQueue->NumberOfActiveWorkerThreads);
    }
    else
    {
        ++WorkQueue->NumberOfActiveWorkerThreads;
        Status = STATUS_SUCCESS;
    }
    KeReleaseSpinLock(&WorkQueue->SpinLock, OldIrql);
 
    /* Quit on failure */
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Spin up the worker thread */
    Status = PsCreateSystemThread(&ThreadHandle, PROCESS_ALL_ACCESS, NULL, NULL, NULL, Routine, Parameter);
    if (NT_SUCCESS(Status))
    {
        ZwClose(ThreadHandle);
        return Status;
    }
    /* Read well: we reached that point because it failed! */
    DPRINT("WorkQ: %p, Status: %lx\n", WorkQueue, Status);
 
    KeAcquireSpinLock(&WorkQueue->SpinLock, &OldIrql);
    --WorkQueue->NumberOfActiveWorkerThreads;
    ++WorkQueue->NumberOfFailedSpinUpRequests;
 
    /* Rundown, no more active threads, set the event! */
    if (WorkQueue->NumberOfActiveWorkerThreads == 0 &&
        WorkQueue->State == RxWorkQueueRundownInProgress)
    {
        KeSetEvent(&WorkQueue->pRundownContext->RundownCompletionEvent, IO_NO_INCREMENT, FALSE);
    }
 
    DPRINT("Workqueue not active! WorkQ: %p, State: %d, Active: %d\n", WorkQueue, WorkQueue->State, WorkQueue->NumberOfActiveWorkerThreads);
 
    KeReleaseSpinLock(&WorkQueue->SpinLock, OldIrql);
 
    return Status;
}

Referenced by RxInitializeWorkQueueDispatcher().

RxSpinUpWorkerThreads()

VOID RxSpinUpWorkerThreads

(

PRX_WORK_QUEUE

WorkQueue

)

Definition at line 8157 of file rxce.c.

{
    UNIMPLEMENTED;
}

Referenced by RxInsertWorkQueueItem().

RxSynchronizeWithScavenger()

VOID RxSynchronizeWithScavenger

(

IN PRX_CONTEXT

RxContext

)

Definition at line 8164 of file rxce.c.

{
    UNIMPLEMENTED;
}

RxTableComputeHashValue()

ULONG RxTableComputeHashValue

(

IN PUNICODE_STRING

Name

)

Definition at line 8174 of file rxce.c.

{
    ULONG Hash;
    SHORT Loops[8];
    USHORT MaxChar, i;
 
    PAGED_CODE();
 
    MaxChar = Name->Length / sizeof(WCHAR);
 
    Loops[0] = 1;
    Loops[1] = MaxChar - 1;
    Loops[2] = MaxChar - 2;
    Loops[3] = MaxChar - 3;
    Loops[4] = MaxChar - 4;
    Loops[5] = MaxChar / 4;
    Loops[6] = 2 * MaxChar / 4;
    Loops[7] = 3 * MaxChar / 4;
 
    Hash = 0;
    for (i = 0; i < 8; ++i)
    {
        SHORT Idx;
 
        Idx = Loops[i];
        if (Idx >= 0 && Idx < MaxChar)
        {
            Hash = RtlUpcaseUnicodeChar(Name->Buffer[Idx]) + 8 * Hash;
        }
    }
 
    return Hash;
}

Referenced by RxPrefixTableInsertName(), and RxTableLookupName().

RxTableComputePathHashValue()

ULONG RxTableComputePathHashValue

(

IN PUNICODE_STRING

Name

)

Definition at line 8213 of file rxce.c.

{
    ULONG Hash;
    SHORT Loops[8];
    USHORT MaxChar, i;
 
    PAGED_CODE();
 
    MaxChar = Name->Length / sizeof(WCHAR);
 
    Loops[0] = 1;
    Loops[1] = MaxChar - 1;
    Loops[2] = MaxChar - 2;
    Loops[3] = MaxChar - 3;
    Loops[4] = MaxChar - 4;
    Loops[5] = MaxChar / 4;
    Loops[6] = 2 * MaxChar / 4;
    Loops[7] = 3 * MaxChar / 4;
 
    Hash = 0;
    for (i = 0; i < 8; ++i)
    {
        SHORT Idx;
 
        Idx = Loops[i];
        if (Idx >= 0 && Idx < MaxChar)
        {
            Hash = RtlUpcaseUnicodeChar(Name->Buffer[Idx]) + 8 * Hash;
        }
    }
 
    return Hash;
}

Referenced by RxFcbTableInsertFcb(), and RxFcbTableLookupFcb().

RxTableLookupName()

PVOID RxTableLookupName	(	IN PRX_PREFIX_TABLE	ThisTable,
		IN PUNICODE_STRING	Name,
		OUT PUNICODE_STRING	RemainingName,
		IN PRX_CONNECTION_ID OPTIONAL	RxConnectionId
	)

Definition at line 8252 of file rxce.c.

{
    PVOID Container;
    USHORT i, MaxChar;
    PRX_PREFIX_ENTRY Entry;
    RX_CONNECTION_ID NullId;
    UNICODE_STRING LookupString;
 
    PAGED_CODE();
 
    /* If caller didn't provide a connection ID, setup one */
    if (ThisTable->IsNetNameTable && RxConnectionId == NULL)
    {
        NullId.Luid.LowPart = 0;
        NullId.Luid.HighPart = 0;
        RxConnectionId = &NullId;
    }
 
    /* Validate name */
    ASSERT(Name->Buffer[0] == OBJ_NAME_PATH_SEPARATOR);
 
    Entry = NULL;
    Container = NULL;
    LookupString.Buffer = Name->Buffer;
    MaxChar = Name->Length / sizeof(WCHAR);
    /* We'll perform the lookup, path component after another */
    for (i = 1; i < MaxChar; ++i)
    {
        ULONG Hash;
        PRX_PREFIX_ENTRY CurEntry;
 
        /* Don't cut in the middle of a path element */
        if (Name->Buffer[i] != OBJ_NAME_PATH_SEPARATOR && Name->Buffer[i] != ':')
        {
            continue;
        }
 
        /* Perform lookup in the table */
        LookupString.Length = i * sizeof(WCHAR);
        Hash = RxTableComputeHashValue(&LookupString);
        CurEntry = RxTableLookupName_ExactLengthMatch(ThisTable, &LookupString, Hash, RxConnectionId);
#if DBG
        ++ThisTable->Lookups;
#endif
        /* Entry not found, move to the next component */
        if (CurEntry == NULL)
        {
#if DBG
            ++ThisTable->FailedLookups;
#endif
            continue;
        }
 
        Entry = CurEntry;
        ASSERT(Entry->ContainingRecord != NULL);
        Container = Entry->ContainingRecord;
 
        /* If we have a NET_ROOT, let's return a V_NET_ROOT */
        if ((NodeType(Entry->ContainingRecord) & ~RX_SCAVENGER_MASK) == RDBSS_NTC_NETROOT)
        {
            PNET_ROOT NetRoot;
 
            NetRoot = (PNET_ROOT)Entry->ContainingRecord;
            /* If there's a default one, perfect, that's a match */
            if (NetRoot->DefaultVNetRoot != NULL)
            {
                Container = NetRoot->DefaultVNetRoot;
            }
            /* If none (that shouldn't happen!), try to find one */
            else
            {
                /* Use the first one in the list */
                if (!IsListEmpty(&NetRoot->VirtualNetRoots))
                {
                    Container = CONTAINING_RECORD(NetRoot->VirtualNetRoots.Flink, V_NET_ROOT, NetRootListEntry);
                }
                /* Really, really, shouldn't happen */
                else
                {
                    ASSERT(FALSE);
                    Entry = NULL;
                    Container = NULL;
                }
            }
 
            break;
        }
        else if ((NodeType(Entry->ContainingRecord) & ~RX_SCAVENGER_MASK) == RDBSS_NTC_V_NETROOT)
        {
            break;
        }
        else
        {
            ASSERT((NodeType(Entry->ContainingRecord) & ~RX_SCAVENGER_MASK) == RDBSS_NTC_SRVCALL);
        }
    }
 
    /* Entry was found */
    if (Entry != NULL)
    {
        DPRINT("Found\n");
 
        ASSERT(Name->Length >= Entry->Prefix.Length);
 
        /* Setup remaining name */
        RemainingName->Buffer = Add2Ptr(Name->Buffer, Entry->Prefix.Length);
        RemainingName->Length = Name->Length - Entry->Prefix.Length;
        RemainingName->MaximumLength = Name->Length - Entry->Prefix.Length;
    }
    else
    {
        /* Otherwise, that's the whole name */
        RemainingName = Name;
    }
 
    return Container;
}

Referenced by RxPrefixTableLookupName().

RxTableLookupName_ExactLengthMatch()

PRX_PREFIX_ENTRY RxTableLookupName_ExactLengthMatch	(	IN PRX_PREFIX_TABLE	ThisTable,
		IN PUNICODE_STRING	Name,
		IN ULONG	HashValue,
		IN PRX_CONNECTION_ID OPTIONAL	RxConnectionId
	)

Definition at line 8378 of file rxce.c.

{
    PLIST_ENTRY ListEntry, HashBucket;
 
    PAGED_CODE();
 
    ASSERT(RxConnectionId != NULL);
 
    /* Select the right bucket */
    HashBucket = HASH_BUCKET(ThisTable, HashValue);
    DPRINT("Looking in bucket: %p for %x\n", HashBucket, HashValue);
    /* If bucket is empty, no match */
    if (IsListEmpty(HashBucket))
    {
        return NULL;
    }
 
    /* Browse all the entries in the bucket */
    for (ListEntry = HashBucket->Flink;
         ListEntry != HashBucket;
         ListEntry = ListEntry->Flink)
    {
        PVOID Container;
        PRX_PREFIX_ENTRY Entry;
        BOOLEAN CaseInsensitive;
        PUNICODE_STRING CmpName, CmpPrefix;
        UNICODE_STRING InsensitiveName, InsensitivePrefix;
 
        Entry = CONTAINING_RECORD(ListEntry, RX_PREFIX_ENTRY, HashLinks);
#if DBG
        ++ThisTable->Considers;
#endif
        ASSERT(HashBucket == HASH_BUCKET(ThisTable, Entry->SavedHashValue));
 
        Container = Entry->ContainingRecord;
        ASSERT(Container != NULL);
 
        /* Not the same hash, not the same length, move on */
        if (Entry->SavedHashValue != HashValue || Entry->Prefix.Length != Name->Length)
        {
            continue;
        }
 
#if DBG
        ++ThisTable->Compares;
#endif
        /* If we have to perform a case insensitive compare on a portion... */
        if (Entry->CaseInsensitiveLength != 0)
        {
            ASSERT(Entry->CaseInsensitiveLength <= Name->Length);
 
            /* Perform the case insensitive check on the asked length */
            InsensitiveName.Buffer = Name->Buffer;
            InsensitivePrefix.Buffer = Entry->Prefix.Buffer;
            InsensitiveName.Length = Entry->CaseInsensitiveLength;
            InsensitivePrefix.Length = Entry->CaseInsensitiveLength;
            /* No match, move to the next entry */
            if (!RtlEqualUnicodeString(&InsensitiveName, &InsensitivePrefix, TRUE))
            {
                continue;
            }
 
            /* Was the case insensitive covering the whole name? */
            if (Name->Length == Entry->CaseInsensitiveLength)
            {
                /* If connection ID also matches, that a complete match! */
                if (!ThisTable->IsNetNameTable || RxEqualConnectionId(RxConnectionId, &Entry->ConnectionId))
                {
                    return Entry;
                }
            }
 
            /* Otherwise, we have to continue with the sensitive match.... */
            InsensitiveName.Buffer = Add2Ptr(InsensitiveName.Buffer, Entry->CaseInsensitiveLength);
            InsensitivePrefix.Buffer = Add2Ptr(InsensitivePrefix.Buffer, Entry->CaseInsensitiveLength);
            InsensitiveName.Length = Name->Length - Entry->CaseInsensitiveLength;
            InsensitivePrefix.Length = Entry->Prefix.Length - Entry->CaseInsensitiveLength;
 
            CmpName = &InsensitiveName;
            CmpPrefix = &InsensitivePrefix;
            CaseInsensitive = FALSE;
        }
        else
        {
            CmpName = Name;
            CmpPrefix = &Entry->Prefix;
            CaseInsensitive = ThisTable->CaseInsensitiveMatch;
        }
 
        /* Perform the compare, if there's a match, also check for connection ID */
        if (RtlEqualUnicodeString(CmpName, CmpPrefix, CaseInsensitive))
        {
            if (!ThisTable->IsNetNameTable || RxEqualConnectionId(RxConnectionId, &Entry->ConnectionId))
            {
                return Entry;
            }
        }
    }
 
    return NULL;
}

Referenced by RxTableLookupName().

RxTearDownBufferingManager()

NTSTATUS RxTearDownBufferingManager

(

PSRV_CALL

SrvCall

)

Definition at line 8488 of file rxce.c.

{
    PAGED_CODE();
 
    /* Nothing to do */
    return STATUS_SUCCESS;
}

Referenced by RxFinalizeSrvCall().

RxTimerDispatch()

VOID NTAPI RxTimerDispatch	(	_In_ struct _KDPC *	Dpc,
		_In_opt_ PVOID	DeferredContext,
		_In_opt_ PVOID	SystemArgument1,
		_In_opt_ PVOID	SystemArgument2
	)

Definition at line 8502 of file rxce.c.

{
    BOOLEAN Set;
    LIST_ENTRY LocalList;
    PLIST_ENTRY ListEntry;
    PRX_WORK_ITEM WorkItem;
 
    InitializeListHead(&LocalList);
 
    KeAcquireSpinLockAtDpcLevel(&RxTimerLock);
    ++RxTimerTickCount;
 
    /* Find any entry matching */
    if (!IsListEmpty(&RxTimerQueueHead))
    {
        ListEntry = RxTimerQueueHead.Flink;
        do
        {
            WorkItem = CONTAINING_RECORD(ListEntry, RX_WORK_ITEM, WorkQueueItem.List);
            if (WorkItem->LastTick == RxTimerTickCount)
            {
                ListEntry = ListEntry->Flink;
 
                RemoveEntryList(&WorkItem->WorkQueueItem.List);
                InsertTailList(&LocalList, &WorkItem->WorkQueueItem.List);
            }
            else
            {
                ListEntry = ListEntry->Flink;
            }
        } while (ListEntry != &RxTimerQueueHead);
    }
    /* Do we have to requeue a later execution? */
    Set = !IsListEmpty(&RxTimerQueueHead);
 
    KeReleaseSpinLockFromDpcLevel(&RxTimerLock);
 
    /* Requeue if list wasn't empty */
    if (Set)
    {
        KeSetTimer(&RxTimer, RxTimerInterval, &RxTimerDpc);
    }
 
    /* If we had matching entries */
    if (!IsListEmpty(&LocalList))
    {
        /* Post them, one after another */
        ListEntry = LocalList.Flink;
        do
        {
            WorkItem = CONTAINING_RECORD(ListEntry, RX_WORK_ITEM, WorkQueueItem.List);
            ListEntry = ListEntry->Flink;
 
            WorkItem->WorkQueueItem.List.Flink = NULL;
            WorkItem->WorkQueueItem.List.Blink = NULL;
            RxPostToWorkerThread(WorkItem->WorkQueueItem.pDeviceObject, CriticalWorkQueue,
                                 &WorkItem->WorkQueueItem, WorkItem->WorkQueueItem.WorkerRoutine,
                                 WorkItem->WorkQueueItem.Parameter);
        }
        while (ListEntry != &LocalList);
    }
}

Referenced by RxInitializeRxTimer().

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

RxUninitializeVNetRootParameters()

VOID RxUninitializeVNetRootParameters	(	IN PUNICODE_STRING	UserName,
		IN PUNICODE_STRING	UserDomainName,
		IN PUNICODE_STRING	Password,
		OUT PULONG	Flags
	)

Definition at line 8680 of file rxce.c.

{
    PAGED_CODE();
 
    /* Only free what could have been allocated */
    if (UserName != NULL)
    {
        RxFreePool(UserName);
    }
 
    if (UserDomainName != NULL)
    {
        RxFreePool(UserDomainName);
    }
 
    if (Password != NULL)
    {
        RxFreePool(Password);
    }
 
    /* And remove the possibly set CSC agent flag */
    if (Flags != NULL)
    {
        (*Flags) &= ~VNETROOT_FLAG_CSCAGENT_INSTANCE;
    }
}

Referenced by RxCreateVNetRoot(), RxFinalizeVNetRoot(), and RxFindOrConstructVirtualNetRoot().

RxUpdateCondition()

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

Definition at line 8715 of file rxce.c.

{
    PRX_CONTEXT Context;
    LIST_ENTRY SerializationQueue;
 
    PAGED_CODE();
 
    DPRINT("RxUpdateCondition(%d, %p, %p)\n", NewConditionValue, Condition, TransitionWaitList);
 
    /* Set the new condition */
    RxAcquireSerializationMutex();
    ASSERT(NewConditionValue != Condition_InTransition);
    *Condition = NewConditionValue;
    /* And get the serialization queue for treatment */
    RxTransferList(&SerializationQueue, TransitionWaitList);
    RxReleaseSerializationMutex();
 
    /* Handle the serialization queue */
    Context = RxRemoveFirstContextFromSerializationQueue(&SerializationQueue);
    while (Context != NULL)
    {
        /* If the caller asked for post, post the request */
        if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION))
        {
            Context->Flags &= ~RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION;
            RxFsdPostRequest(Context);
        }
        /* Otherwise, wake up sleeping waiters */
        else
        {
            RxSignalSynchronousWaiter(Context);
        }
 
        Context = RxRemoveFirstContextFromSerializationQueue(&SerializationQueue);
    }
}

RxVerifyOperationIsLegal()

VOID RxVerifyOperationIsLegal

(

IN PRX_CONTEXT

RxContext

)

Definition at line 8759 of file rxce.c.

{
    PIRP Irp;
    PMRX_FOBX Fobx;
    BOOLEAN FlagSet;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    Irp = RxContext->CurrentIrp;
    Stack = RxContext->CurrentIrpSp;
    FileObject = Stack->FileObject;
 
    /* We'll only check stuff on opened files, this requires an IRP and a FO */
    if (Irp == NULL || FileObject == NULL)
    {
        return;
    }
 
    /* Set no exception for breakpoint - remember whether is was already set */
    FlagSet = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT);
    SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT);
 
    /* If we have a CCB, perform a few checks on opened file */
    Fobx = RxContext->pFobx;
    if (Fobx != NULL)
    {
        PMRX_SRV_OPEN SrvOpen;
 
        SrvOpen = Fobx->pSrvOpen;
        if (SrvOpen != NULL)
        {
            UCHAR MajorFunction;
 
            MajorFunction = RxContext->MajorFunction;
            /* Only allow closing/cleanup operations on renamed files */
            if (MajorFunction != IRP_MJ_CLEANUP && MajorFunction != IRP_MJ_CLOSE &&
                BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_FILE_RENAMED))
            {
                RxContext->IoStatusBlock.Status = STATUS_FILE_RENAMED;
                ExRaiseStatus(STATUS_FILE_RENAMED);
            }
 
            /* Only allow closing/cleanup operations on deleted files */
            if (MajorFunction != IRP_MJ_CLEANUP && MajorFunction != IRP_MJ_CLOSE &&
                BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_FILE_DELETED))
            {
                RxContext->IoStatusBlock.Status = STATUS_FILE_DELETED;
                ExRaiseStatus(STATUS_FILE_DELETED);
            }
        }
    }
 
    /* If that's an open operation */
    if (RxContext->MajorFunction == IRP_MJ_CREATE)
    {
        PFILE_OBJECT RelatedFileObject;
 
        /* We won't allow an open operation relative to a file to be deleted */
        RelatedFileObject = FileObject->RelatedFileObject;
        if (RelatedFileObject != NULL)
        {
            PMRX_FCB Fcb;
 
            Fcb = RelatedFileObject->FsContext;
            if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE))
            {
                RxContext->IoStatusBlock.Status = STATUS_DELETE_PENDING;
                ExRaiseStatus(STATUS_DELETE_PENDING);
            }
        }
    }
 
    /* If cleanup was completed */
    if (BooleanFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE))
    {
        if (!BooleanFlagOn(Irp->Flags, IRP_PAGING_IO))
        {
            UCHAR MajorFunction;
 
            /* We only allow a subset of operations (see FatVerifyOperationIsLegal for instance) */
            MajorFunction = Stack->MajorFunction;
            if (MajorFunction != IRP_MJ_CLOSE && MajorFunction != IRP_MJ_QUERY_INFORMATION &&
                MajorFunction != IRP_MJ_SET_INFORMATION)
            {
                if ((MajorFunction != IRP_MJ_READ && MajorFunction != IRP_MJ_WRITE) ||
                    !BooleanFlagOn(Stack->MinorFunction, IRP_MN_COMPLETE))
                {
                    RxContext->IoStatusBlock.Status = STATUS_FILE_CLOSED;
                    ExRaiseStatus(STATUS_FILE_CLOSED);
                }
            }
        }
    }
 
    /* If flag was already set, don't clear it */
    if (!FlagSet)
    {
        ClearFlag(RxContext->Flags, RX_CONTEXT_FLAG_NO_EXCEPTION_BREAKPOINT);
    }
}

Referenced by __RxAcquireFcb().

RxWaitForStableCondition()

VOID RxWaitForStableCondition	(	IN PRX_BLOCK_CONDITION	Condition,
		IN OUT PLIST_ENTRY	TransitionWaitList,
		IN OUT PRX_CONTEXT	RxContext,
		OUT NTSTATUS *AsyncStatus	OPTIONAL
	)

Definition at line 8867 of file rxce.c.

{
    BOOLEAN Wait;
    NTSTATUS LocalStatus;
 
    PAGED_CODE();
 
    /* Make sure to always get status */
    if (AsyncStatus == NULL)
    {
        AsyncStatus = &LocalStatus;
    }
 
    /* By default, it's a success */
    *AsyncStatus = STATUS_SUCCESS;
 
    Wait = FALSE;
    /* If it's not stable, we've to wait */
    if (!StableCondition(*Condition))
    {
        /* Lock the mutex */
        RxAcquireSerializationMutex();
        /* Still not stable? */
        if (!StableCondition(*Condition))
        {
            /* Insert us in the wait list for processing on stable condition */
            RxInsertContextInSerializationQueue(TransitionWaitList, RxContext);
 
            /* If we're asked to post on stable, don't wait, and just return pending */
            if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_POST_ON_STABLE_CONDITION))
            {
                *AsyncStatus = STATUS_PENDING;
            }
            else
            {
                Wait = TRUE;
            }
        }
        RxReleaseSerializationMutex();
 
        /* We don't post on stable, so, just wait... */
        if (Wait)
        {
            RxWaitSync(RxContext);
        }
    }
}

RxWorkItemDispatcher()

VOID NTAPI RxWorkItemDispatcher

(

PVOID

Context

)

Definition at line 8924 of file rxce.c.

{
    PRX_WORK_DISPATCH_ITEM DispatchItem = Context;
 
    DPRINT("Calling: %p, %p\n", DispatchItem->DispatchRoutine, DispatchItem->DispatchRoutineParameter);
 
    DispatchItem->DispatchRoutine(DispatchItem->DispatchRoutineParameter);
 
    RxFreePoolWithTag(DispatchItem, RX_WORKQ_POOLTAG);
}

Referenced by RxDispatchToWorkerThread().

Variable Documentation

DumpDispatchRoutine

BOOLEAN DumpDispatchRoutine = FALSE

Definition at line 150 of file rxce.c.

Referenced by RxpWorkerThreadDispatcher().

RdbssReferenceTracingValue

ULONG RdbssReferenceTracingValue = 0

Definition at line 130 of file rxce.c.

Referenced by RxPrefixTableLookupName(), RxpTrackDereference(), and RxpTrackReference().

ReadAheadGranularity

ULONG ReadAheadGranularity

extern

Definition at line 534 of file rdbss.c.

Referenced by RxCreateNetRoot(), and RxReadRegistryParameters().

RxContextPerFileSerializationMutex

FAST_MUTEX RxContextPerFileSerializationMutex

Definition at line 146 of file rxce.c.

Referenced by RxCancelBlockingOperation(), RxDriverEntry(), and RxRemoveOperationFromBlockingQueue().

RxContextSerialNumberCounter

volatile ULONG RxContextSerialNumberCounter

Definition at line 119 of file rxce.c.

Referenced by RxInitializeContext().

RxContinueFromAssert

BOOLEAN RxContinueFromAssert = TRUE

Definition at line 137 of file rxce.c.

Referenced by RxAssert().

RxDispatcher

RX_DISPATCHER RxDispatcher

Definition at line 134 of file rxce.c.

Referenced by RxInitializeDispatcher(), RxInsertWorkQueueItem(), and RxSpinUpRequestsDispatcher().

RxDispatcherWorkQueues

RX_WORK_QUEUE_DISPATCHER RxDispatcherWorkQueues

Definition at line 135 of file rxce.c.

Referenced by RxInitializeDispatcher().

RxExplodePoolTags

ULONG RxExplodePoolTags = 1

Definition at line 138 of file rxce.c.

RxLowIoPagingIoSyncMutex

FAST_MUTEX RxLowIoPagingIoSyncMutex

Definition at line 136 of file rxce.c.

Referenced by RxDriverEntry(), RxLowIoCompletionTail(), and RxLowIoSubmit().

RxNull

PVOID RxNull = NULL

Definition at line 118 of file rxce.c.

Referenced by RxFsdCommonDispatch().

RxNumberOfActiveFcbs

volatile LONG RxNumberOfActiveFcbs = 0

Definition at line 116 of file rxce.c.

Referenced by RxAllocateFcbObject(), and RxFreeFcbObject().

RxRecurrentWorkItemsList

LIST_ENTRY RxRecurrentWorkItemsList

Definition at line 142 of file rxce.c.

Referenced by RxInitializeRxTimer().

RxSpinUpDispatcherWaitInterval

LARGE_INTEGER RxSpinUpDispatcherWaitInterval

Definition at line 133 of file rxce.c.

Referenced by RxInitializeDispatcher(), and RxSpinUpRequestsDispatcher().

RxSrvCallConstructionDispatcherActive

BOOLEAN RxSrvCallConstructionDispatcherActive = FALSE

Definition at line 121 of file rxce.c.

Referenced by RxCreateSrvCallCallBack(), and RxFinishSrvCallConstructionDispatcher().

RxSrvCalldownList

LIST_ENTRY RxSrvCalldownList

Definition at line 122 of file rxce.c.

Referenced by RxCreateSrvCallCallBack(), RxDriverEntry(), and RxFinishSrvCallConstructionDispatcher().

RxStopOnLoudCompletion

BOOLEAN RxStopOnLoudCompletion = TRUE

Definition at line 120 of file rxce.c.

Referenced by RxCompleteRequest().

RxStrucSupSpinLock

RX_SPIN_LOCK RxStrucSupSpinLock

Definition at line 123 of file rxce.c.

Referenced by RxCancelNotifyChangeDirectoryRequestsForFobx(), RxCancelNotifyChangeDirectoryRequestsForVNetRoot(), RxCancelRoutine(), RxCommonWrite(), RxCreateRxContext(), RxCreateSrvCallCallBack(), RxDereferenceAndDeleteRxContext_Real(), RxDriverEntry(), RxFinishSrvCallConstructionDispatcher(), RxFsdCommonDispatch(), and RxLowIoWriteShellCompletion().

RxTimer

KTIMER RxTimer

Definition at line 144 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxTimerDpc

KDPC RxTimerDpc

Definition at line 143 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxTimerInterval

LARGE_INTEGER RxTimerInterval

Definition at line 139 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxTimerLock

RX_SPIN_LOCK RxTimerLock

Definition at line 140 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxTimerQueueHead

LIST_ENTRY RxTimerQueueHead

Definition at line 141 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxTimerTickCount

ULONG RxTimerTickCount

Definition at line 145 of file rxce.c.

Referenced by RxInitializeRxTimer(), RxPostOneShotTimerRequest(), and RxTimerDispatch().

RxWorkQueueWaitInterval

LARGE_INTEGER RxWorkQueueWaitInterval[RxMaximumWorkQueue]

Definition at line 132 of file rxce.c.

Referenced by RxInitializeDispatcher().

SerialNumber

ULONG SerialNumber = 1

Definition at line 117 of file rxce.c.

Referenced by __RxAcquireFcb(), __RxReleaseFcb(), __RxReleaseFcbForThread(), CdTocSerial(), CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCRLEntries(), CRYPT_AsnDecodeCRLEntry(), CRYPT_AsnDecodeIssuerSerialNumber(), RxCreateNetRoot(), RxCreateSrvCall(), RxCreateVNetRoot(), USBH_CheckDeviceIDUnique(), USBH_FdoQueryBusRelations(), USBH_PdoRemoveDevice(), USBH_ProcessPortStateChange(), and USBSTOR_HandleQueryProperty().