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