rxce.c

Go to the documentation of this file.

/*
 *  ReactOS kernel
 *  Copyright (C) 2017 ReactOS Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
/*
 * COPYRIGHT:        See COPYING in the top level directory
 * PROJECT:          ReactOS kernel
 * FILE:             sdk/lib/drivers/rxce/rxce.c
 * PURPOSE:          RXCE library
 * PROGRAMMER:       Pierre Schweitzer (pierre@reactos.org)
 */
 
/* INCLUDES *****************************************************************/
 
#include <rx.h>
#include <pseh/pseh2.h>
#include <dfs.h>
 
#define NDEBUG
#include <debug.h>
 
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);
 
extern 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;
#if 0
ULONG RdbssReferenceTracingValue = (RDBSS_REF_TRACK_SRVCALL | RDBSS_REF_TRACK_NETROOT |
                                    RDBSS_REF_TRACK_VNETROOT | RDBSS_REF_TRACK_NETFOBX |
                                    RDBSS_REF_TRACK_NETFCB | RDBSS_REF_TRACK_SRVOPEN |
                                    RX_PRINT_REF_TRACKING);
#else
ULONG RdbssReferenceTracingValue = 0;
#endif
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;
#if DBG
BOOLEAN DumpDispatchRoutine = TRUE;
#else
BOOLEAN DumpDispatchRoutine = FALSE;
#endif
 
#if RDBSS_ASSERTS
#ifdef ASSERT
#undef ASSERT
#endif
 
#define ASSERT(exp)                               \
    if (!(exp))                                   \
    {                                             \
        RxAssert(#exp, __FILE__, __LINE__, NULL); \
    }
#endif
 
#if RX_POOL_WRAPPER
#undef RxAllocatePool
#undef RxAllocatePoolWithTag
#undef RxFreePool
 
#define RxAllocatePool(P, S) _RxAllocatePoolWithTag(P, S, 0)
#define RxAllocatePoolWithTag _RxAllocatePoolWithTag
#define RxFreePool _RxFreePool
#define RxFreePoolWithTag _RxFreePoolWithTag
#endif
 
/* FUNCTIONS ****************************************************************/
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxAcquireExclusiveFcbResourceInMRx(
    _Inout_ PMRX_FCB Fcb)
{
    return RxAcquireExclusiveFcb(NULL, (PFCB)Fcb);
}
 
/*
 * @implemented
 */
BOOLEAN
NTAPI
RxAcquireFcbForLazyWrite(
    PVOID Context,
    BOOLEAN Wait)
{
    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;
}
 
/*
 * @implemented
 */
BOOLEAN
NTAPI
RxAcquireFcbForReadAhead(
    PVOID Context,
    BOOLEAN Wait)
{
    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;
}
 
VOID
NTAPI
RxAcquireFileForNtCreateSection(
    PFILE_OBJECT FileObject)
{
    UNIMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxAcquireForCcFlush(
    PFILE_OBJECT FileObject,
    PDEVICE_OBJECT DeviceObject)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
VOID
RxAddVirtualNetRootToNetRoot(
    PNET_ROOT NetRoot,
    PV_NET_ROOT VNetRoot)
{
    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);
}
 
/*
 * @implemented
 */
PVOID
RxAllocateFcbObject(
    PRDBSS_DEVICE_OBJECT RxDeviceObject,
    NODE_TYPE_CODE NodeType,
    POOL_TYPE PoolType,
    ULONG NameSize,
    PVOID AlreadyAllocatedObject)
{
    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;
}
 
/*
 * @implemented
 */
PVOID
RxAllocateObject(
    NODE_TYPE_CODE NodeType,
    PMINIRDR_DISPATCH MRxDispatch,
    ULONG NameLength)
{
    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;
}
 
/*
 * @implemented
 */
VOID
RxAssert(
    PVOID Assert,
    PVOID File,
    ULONG Line,
    PVOID Message)
{
    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) */
    }
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxBootstrapWorkerThreadDispatcher(
   IN PVOID WorkQueue)
{
    PRX_WORK_QUEUE RxWorkQueue;
 
    PAGED_CODE();
 
    RxWorkQueue = WorkQueue;
    RxpWorkerThreadDispatcher(RxWorkQueue, NULL);
}
 
/*
 * @implemented
 */
VOID
RxCancelBlockingOperation(
    IN OUT PRX_CONTEXT RxContext)
{
    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);
    }
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxChangeBufferingState(
    PSRV_OPEN SrvOpen,
    PVOID Context,
    BOOLEAN ComputeNewState)
{
    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;
}
 
NTSTATUS
RxCheckVNetRootCredentials(
    PRX_CONTEXT RxContext,
    PV_NET_ROOT VNetRoot,
    PLUID LogonId,
    PUNICODE_STRING UserName,
    PUNICODE_STRING UserDomain,
    PUNICODE_STRING Password,
    ULONG Flags)
{
    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;
}
 
NTSTATUS
RxCompleteRequest(
      PRX_CONTEXT Context,
      NTSTATUS Status)
{
    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;
}
 
/*
 * @implemented
 */
VOID
RxCompleteRequest_Real(
    IN PRX_CONTEXT RxContext,
    IN PIRP Irp,
    IN NTSTATUS Status)
{
    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);
    }
}
 
/*
 * @implemented
 */
VOID
RxCompleteSrvOpenKeyAssociation(
    IN OUT PSRV_OPEN SrvOpen)
{
    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);
    }
}
 
/*
 * @implemented
 */
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 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;
}
 
/*
 * @implemented
 */
NTSTATUS
RxConstructSrvCall(
    IN PRX_CONTEXT RxContext,
    IN PSRV_CALL SrvCall,
    OUT PLOCK_HOLDING_STATE LockHoldingState)
{
    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;
}
 
/*
 * @implemented
 */
NTSTATUS
RxConstructVirtualNetRoot(
    IN PRX_CONTEXT RxContext,
    IN PUNICODE_STRING CanonicalName,
    IN NET_ROOT_TYPE NetRootType,
    OUT PV_NET_ROOT *VirtualNetRootPointer,
    OUT PLOCK_HOLDING_STATE LockHoldingState,
    OUT PRX_CONNECTION_ID RxConnectionId)
{
    NTSTATUS 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;
}
 
/*
 * @implemented
 */
PFCB
RxCreateNetFcb(
    IN PRX_CONTEXT RxContext,
    IN PV_NET_ROOT VNetRoot,
    IN PUNICODE_STRING Name)
{
    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;
}
 
/*
 * @implemented
 */
PMRX_FOBX
NTAPI
RxCreateNetFobx(
    OUT PRX_CONTEXT RxContext,
    IN PMRX_SRV_OPEN MrxSrvOpen)
{
    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;
}
 
/*
 * @implemented
 */
PNET_ROOT
RxCreateNetRoot(
    IN PSRV_CALL SrvCall,
    IN PUNICODE_STRING Name,
    IN ULONG NetRootFlags,
    IN PRX_CONNECTION_ID OPTIONAL RxConnectionId)
{
    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;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxCreateNetRootCallBack(
    IN PMRX_CREATENETROOT_CONTEXT CreateNetRootContext)
{
    PAGED_CODE();
 
    KeSetEvent(&CreateNetRootContext->FinishEvent, IO_NETWORK_INCREMENT, FALSE);
}
 
/*
 * @implemented
 */
PRX_CONTEXT
NTAPI
RxCreateRxContext(
    IN PIRP Irp,
    IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
    IN ULONG InitialContextFlags)
{
    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;
}
 
/*
 * @implemented
 */
PSRV_CALL
RxCreateSrvCall(
    IN PRX_CONTEXT RxContext,
    IN PUNICODE_STRING Name,
    IN PUNICODE_STRING InnerNamePrefix OPTIONAL,
    IN PRX_CONNECTION_ID RxConnectionId)
{
    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;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxCreateSrvCallCallBack(
    IN OUT PMRX_SRVCALL_CALLBACK_CONTEXT Context)
{
    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);
        }
    }
}
 
/*
 * @implemented
 */
PSRV_OPEN
RxCreateSrvOpen(
    IN PV_NET_ROOT VNetRoot,
    IN OUT PFCB Fcb)
{
    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;
}
 
/*
 * @implemented
 */
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)
{
    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;
}
 
/*
 * @implemented
 */
VOID
RxDereference(
    IN OUT PVOID Instance,
    IN LOCK_HOLDING_STATE LockHoldingState)
{
    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;
        }
    }
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxDereferenceAndDeleteRxContext_Real(
    IN PRX_CONTEXT RxContext)
{
    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);
        }
    }
}
 
VOID
NTAPI
RxDispatchChangeBufferingStateRequests(
    PVOID Context)
{
    UNIMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxDispatchToWorkerThread(
    IN  PRDBSS_DEVICE_OBJECT pMRxDeviceObject,
    IN  WORK_QUEUE_TYPE WorkQueueType,
    IN  PRX_WORKERTHREAD_ROUTINE Routine,
    IN PVOID pContext)
{
    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;
}
 
/*
 * @implemented
 */
VOID
RxExclusivePrefixTableLockToShared(
    PRX_PREFIX_TABLE Table)
{
    PAGED_CODE();
 
    ExConvertExclusiveToSharedLite(&Table->TableLock);
}
 
/*
 * @implemented
 */
VOID
RxExtractServerName(
    IN PUNICODE_STRING FilePathName,
    OUT PUNICODE_STRING SrvCallName,
    OUT PUNICODE_STRING RestOfName)
{
    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;
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxFcbTableInsertFcb(
    IN OUT PRX_FCB_TABLE FcbTable,
    IN OUT PFCB Fcb)
{
    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;
}
 
/*
 * @implemented
 */
PFCB
RxFcbTableLookupFcb(
    IN  PRX_FCB_TABLE FcbTable,
    IN  PUNICODE_STRING Path)
{
    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;
}
 
/*
 * @implemented
 */
NTSTATUS
RxFcbTableRemoveFcb(
    IN OUT PRX_FCB_TABLE FcbTable,
    IN OUT PFCB Fcb)
{
    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;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxFinalizeConnection(
    IN OUT PNET_ROOT NetRoot,
    IN OUT PV_NET_ROOT VNetRoot OPTIONAL,
    IN LOGICAL ForceFilesClosed)
{
    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;
}
 
/*
 * @implemented
 */
VOID
RxFinalizeFcbTable(
    IN OUT PRX_FCB_TABLE FcbTable)
{
    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]));
    }
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeNetFcb(
    OUT PFCB ThisFcb,
    IN BOOLEAN RecursiveFinalize,
    IN BOOLEAN ForceFinalize,
    IN LONG ReferenceCount)
{
    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;
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeNetFobx(
    _Out_ PFOBX ThisFobx,
    _In_ BOOLEAN RecursiveFinalize,
    _In_ BOOLEAN ForceFinalize)
{
    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;
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeNetRoot(
    OUT PNET_ROOT ThisNetRoot,
    IN BOOLEAN RecursiveFinalize,
    IN BOOLEAN ForceFinalize)
{
    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;
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeSrvCall(
    OUT PSRV_CALL ThisSrvCall,
    IN BOOLEAN RecursiveFinalize,
    IN BOOLEAN ForceFinalize)
{
    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;
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeSrvOpen(
    OUT PSRV_OPEN ThisSrvOpen,
    IN BOOLEAN RecursiveFinalize,
    IN BOOLEAN ForceFinalize)
{
    PFCB Fcb;
 
    PAGED_CODE();
 
    /* We have to have a SRV_OPEN */
    ASSERT(NodeType(ThisSrvOpen) == RDBSS_NTC_SRVOPEN);
 
    /* If that's a recursive finalization, finalize any related FOBX */
    if (RecursiveFinalize)
    {
        PLIST_ENTRY ListEntry;
 
        ListEntry = ThisSrvOpen->FobxList.Flink;
        while (ListEntry != &ThisSrvOpen->FobxList)
        {
            PFOBX Fobx;
 
            Fobx = CONTAINING_RECORD(ListEntry, FOBX, FobxQLinks);
            ListEntry = ListEntry->Flink;
            RxFinalizeNetFobx(Fobx, TRUE, ForceFinalize);
        }
    }
 
    /* If we have still references, don't finalize unless forced */
    if (ThisSrvOpen->NodeReferenceCount != 0 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalize SRV_OPEN: %p (with %d ref), forced: %d\n", ThisSrvOpen, ThisSrvOpen->NodeReferenceCount, ForceFinalize);
 
    /* Only finalize if closed, or if it wasn't already done and SRV_OPEN is in a bad shape */
    Fcb = (PFCB)ThisSrvOpen->pFcb;
    if ((!ThisSrvOpen->UpperFinalizationDone && ThisSrvOpen->Condition != Condition_Good) ||
        BooleanFlagOn(ThisSrvOpen->Flags, SRVOPEN_FLAG_CLOSED))
    {
        PV_NET_ROOT VNetRoot;
 
        /* Associated FCB can't be fake one */
        ASSERT(NodeType(Fcb) != RDBSS_NTC_OPENTARGETDIR_FCB);
        ASSERT(RxIsFcbAcquiredExclusive (Fcb));
 
        /* Purge any pending operation */
        RxPurgeChangeBufferingStateRequestsForSrvOpen(ThisSrvOpen);
 
        /* If the FCB wasn't orphaned, inform the mini-rdr about close */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_ORPHANED))
        {
            NTSTATUS Status;
 
            MINIRDR_CALL_THROUGH(Status, Fcb->MRxDispatch, MRxForceClosed, ((PMRX_SRV_OPEN)ThisSrvOpen));
            (void)Status;
        }
 
        /* Remove ourselves from the FCB */
        RemoveEntryList(&ThisSrvOpen->SrvOpenQLinks);
        InitializeListHead(&ThisSrvOpen->SrvOpenQLinks);
        ++Fcb->SrvOpenListVersion;
 
        /* If we have a V_NET_ROOT, dereference it */
        VNetRoot = (PV_NET_ROOT)ThisSrvOpen->pVNetRoot;
        if (VNetRoot != NULL)
        {
            InterlockedDecrement((volatile long *)&VNetRoot->pNetRoot->NumberOfSrvOpens);
            RxDereferenceVNetRoot(VNetRoot, LHS_LockNotHeld);
            ThisSrvOpen->pVNetRoot = NULL;
        }
 
        /* Finalization done */
        ThisSrvOpen->UpperFinalizationDone = TRUE;
    }
 
    /* Don't free memory if still referenced */
    if (ThisSrvOpen->NodeReferenceCount != 0)
    {
        return FALSE;
    }
 
    /* No key association left */
    ASSERT(IsListEmpty(&ThisSrvOpen->SrvOpenKeyList));
 
    /* If we're still in some FCB, remove us */
    if (!IsListEmpty(&ThisSrvOpen->SrvOpenQLinks))
    {
        RemoveEntryList(&ThisSrvOpen->SrvOpenQLinks);
    }
 
    /* If enclosed allocation, mark the memory zone free */
    if (BooleanFlagOn(ThisSrvOpen->Flags, SRVOPEN_FLAG_ENCLOSED_ALLOCATED))
    {
        ClearFlag(Fcb->FcbState, FCB_STATE_SRVOPEN_USED);
    }
    /* Otherwise, free the memory */
    else
    {
        RxFreeFcbObject(ThisSrvOpen);
    }
 
    RxDereferenceNetFcb(Fcb);
 
    return TRUE;
}
 
/*
 * @implemented
 */
BOOLEAN
RxFinalizeVNetRoot(
    OUT PV_NET_ROOT ThisVNetRoot,
    IN BOOLEAN RecursiveFinalize,
    IN BOOLEAN ForceFinalize)
{
    PNET_ROOT NetRoot;
    PRX_PREFIX_TABLE PrefixTable;
 
    PAGED_CODE();
 
    ASSERT(NodeType(ThisVNetRoot) == RDBSS_NTC_V_NETROOT);
 
    PrefixTable = ThisVNetRoot->pNetRoot->pSrvCall->RxDeviceObject->pRxNetNameTable;
    ASSERT(RxIsPrefixTableLockAcquired(PrefixTable));
 
    /* Only finalize if forced or if there's a single ref left */
    if (ThisVNetRoot->NodeReferenceCount != 1 &&
        !ForceFinalize)
    {
        return FALSE;
    }
 
    DPRINT("Finalizing VNetRoot %p for %wZ\n", ThisVNetRoot, &ThisVNetRoot->PrefixEntry.Prefix);
 
    NetRoot = (PNET_ROOT)ThisVNetRoot->pNetRoot;
    /* If it wasn't finalized yet, do it */
    if (!ThisVNetRoot->UpperFinalizationDone)
    {
        ASSERT(NodeType(NetRoot) == RDBSS_NTC_NETROOT);
 
        /* Reference the NetRoot so that it doesn't disappear */
        RxReferenceNetRoot(NetRoot);
        RxOrphanSrvOpens(ThisVNetRoot);
        /* Remove us from the available VNetRoot for NetRoot */
        RxRemoveVirtualNetRootFromNetRoot(NetRoot, ThisVNetRoot);
        /* Remove extra ref */
        RxDereferenceNetRoot(NetRoot, LHS_ExclusiveLockHeld);
 
        /* Remove ourselves from prefix table */
        RxRemovePrefixTableEntry(PrefixTable, &ThisVNetRoot->PrefixEntry);
 
        /* Finalization done */
        ThisVNetRoot->UpperFinalizationDone = TRUE;
    }
 
    /* If we're still referenced, don't go any further! */
    if (ThisVNetRoot->NodeReferenceCount != 1)
    {
        return FALSE;
    }
 
    /* If there's an associated device, notify mini-rdr */
    if (NetRoot->pSrvCall->RxDeviceObject != NULL)
    {
        NTSTATUS Status;
 
        MINIRDR_CALL_THROUGH(Status, NetRoot->pSrvCall->RxDeviceObject->Dispatch,
                             MRxFinalizeVNetRoot, ((PMRX_V_NET_ROOT)ThisVNetRoot, FALSE));
        (void)Status;
    }
 
    /* Free parameters */
    RxUninitializeVNetRootParameters(ThisVNetRoot->pUserName, ThisVNetRoot->pUserDomainName,
                                     ThisVNetRoot->pPassword, &ThisVNetRoot->Flags);
    /* Dereference our NetRoot, we won't reference it anymore */
    RxDereferenceNetRoot(NetRoot, LHS_ExclusiveLockHeld);
 
    /* And free the object! */
    RxFreePoolWithTag(ThisVNetRoot, RX_V_NETROOT_POOLTAG);
 
    return TRUE;
}
 
NTSTATUS
RxFindOrConstructVirtualNetRoot(
    IN PRX_CONTEXT RxContext,
    IN PUNICODE_STRING CanonicalName,
    IN NET_ROOT_TYPE NetRootType,
    IN PUNICODE_STRING RemainingName)
{
    ULONG Flags;
    NTSTATUS Status;
    PVOID Container;
    BOOLEAN Construct;
    PV_NET_ROOT VNetRoot;
    RX_CONNECTION_ID ConnectionID;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    LOCK_HOLDING_STATE LockHoldingState;
 
    PAGED_CODE();
 
    RxDeviceObject = RxContext->RxDeviceObject;
    ASSERT(RxDeviceObject->Dispatch != NULL);
    ASSERT(NodeType(RxDeviceObject->Dispatch) == RDBSS_NTC_MINIRDR_DISPATCH);
 
    /* Ask the mini-rdr for connection ID */
    ConnectionID.SessionID = 0;
    if (RxDeviceObject->Dispatch->MRxGetConnectionId != NULL)
    {
        Status = RxDeviceObject->Dispatch->MRxGetConnectionId(RxContext, &ConnectionID);
        if (!NT_SUCCESS(Status) && Status != STATUS_NOT_IMPLEMENTED)
        {
            /* mini-rdr is expected not to fail - unless it's not implemented */
            DPRINT1("Failed to initialize connection ID\n");
            ASSERT(FALSE);
        }
    }
 
    RxContext->Create.NetNamePrefixEntry = NULL;
 
    Status = STATUS_MORE_PROCESSING_REQUIRED;
    RxAcquirePrefixTableLockShared(RxDeviceObject->pRxNetNameTable, TRUE);
    LockHoldingState = LHS_SharedLockHeld;
    Construct = TRUE;
    Flags = 0;
 
    /* We will try twice to find a matching VNetRoot: shared locked and then exlusively locked */
    while (TRUE)
    {
        PNET_ROOT NetRoot;
        PV_NET_ROOT SavedVNetRoot;
 
        /* Look in prefix table */
        Container = RxPrefixTableLookupName(RxDeviceObject->pRxNetNameTable, CanonicalName, RemainingName, &ConnectionID);
        if (Container != NULL)
        {
            /* If that's not a VNetRoot, that's a SrvCall, not interesting, loop again */
            if (NodeType(Container) != RDBSS_NTC_V_NETROOT)
            {
                ASSERT(NodeType(Container) == RDBSS_NTC_SRVCALL);
                RxDereferenceSrvCall(Container, LockHoldingState);
            }
            else
            {
                VNetRoot = Container;
                NetRoot = VNetRoot->NetRoot;
 
                /* If the matching VNetRoot isn't in a good shape, there's something wrong - fail */
                if ((NetRoot->Condition != Condition_InTransition && NetRoot->Condition != Condition_Good) ||
                    NetRoot->SrvCall->RxDeviceObject != RxContext->RxDeviceObject)
                {
                    Status = STATUS_BAD_NETWORK_PATH;
                    SavedVNetRoot = NULL;
                }
                else
                {
                    LUID LogonId;
                    ULONG SessionId;
                    PUNICODE_STRING UserName, UserDomain, Password;
 
                    /* We can reuse if we use same credentials */
                    Status = RxInitializeVNetRootParameters(RxContext, &LogonId,
                                                            &SessionId, &UserName,
                                                            &UserDomain, &Password,
                                                            &Flags);
                    if (NT_SUCCESS(Status))
                    {
                        SavedVNetRoot = VNetRoot;
                        Status = RxCheckVNetRootCredentials(RxContext, VNetRoot,
                                                            &LogonId, UserName,
                                                            UserDomain, Password,
                                                            Flags);
                        if (Status == STATUS_MORE_PROCESSING_REQUIRED)
                        {
                            PLIST_ENTRY ListEntry;
 
                            for (ListEntry = NetRoot->VirtualNetRoots.Flink;
                                 ListEntry != &NetRoot->VirtualNetRoots;
                                 ListEntry = ListEntry->Flink)
                            {
                                SavedVNetRoot = CONTAINING_RECORD(ListEntry, V_NET_ROOT, NetRootListEntry);
                                Status = RxCheckVNetRootCredentials(RxContext, SavedVNetRoot,
                                                                    &LogonId, UserName,
                                                                    UserDomain, Password,
                                                                    Flags);
                                if (Status != STATUS_MORE_PROCESSING_REQUIRED)
                                {
                                    break;
                                }
                            }
 
                            if (ListEntry == &NetRoot->VirtualNetRoots)
                            {
                                SavedVNetRoot = NULL;
                            }
                        }
 
                        if (!NT_SUCCESS(Status))
                        {
                            SavedVNetRoot = NULL;
                        }
 
                        RxUninitializeVNetRootParameters(UserName, UserDomain, Password, &Flags);
                    }
                }
 
                /* We'll fail, if we had referenced a VNetRoot, dereference it */
                if (Status != STATUS_MORE_PROCESSING_REQUIRED && !NT_SUCCESS(Status))
                {
                    if (SavedVNetRoot == NULL)
                    {
                        RxDereferenceVNetRoot(VNetRoot, LockHoldingState);
                    }
                }
                /* Reference VNetRoot we'll keep, and dereference current */
                else if (SavedVNetRoot != VNetRoot)
                {
                    RxDereferenceVNetRoot(VNetRoot, LockHoldingState);
                    if (SavedVNetRoot != NULL)
                    {
                        RxReferenceVNetRoot(SavedVNetRoot);
                    }
                }
            }
 
            /* We may have found something, or we fail hard, so don't attempt to create a VNetRoot */
            if (Status != STATUS_MORE_PROCESSING_REQUIRED)
            {
                Construct = FALSE;
                break;
            }
        }
 
        /* If we're locked exclusive, we won't loop again, it was the second pass */
        if (LockHoldingState != LHS_SharedLockHeld)
        {
            break;
        }
 
        /* Otherwise, prepare for second pass, exclusive, making sure we can acquire without delay */
        if (RxAcquirePrefixTableLockExclusive(RxDeviceObject->pRxNetNameTable, FALSE))
        {
            RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
            LockHoldingState = LHS_ExclusiveLockHeld;
            break;
        }
 
        RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
        RxAcquirePrefixTableLockExclusive(RxDeviceObject->pRxNetNameTable, TRUE);
        LockHoldingState = LHS_ExclusiveLockHeld;
    }
 
    /* We didn't fail, and didn't find any VNetRoot, construct one */
    if (Construct)
    {
        ASSERT(LockHoldingState == LHS_ExclusiveLockHeld);
 
        Status = RxConstructVirtualNetRoot(RxContext, CanonicalName, NetRootType, &VNetRoot, &LockHoldingState, &ConnectionID);
        ASSERT(Status != STATUS_SUCCESS || LockHoldingState != LHS_LockNotHeld);
 
        if (Status == STATUS_SUCCESS)
        {
            DPRINT("CanonicalName: %wZ (%d)\n", CanonicalName, CanonicalName->Length);
            DPRINT("VNetRoot: %wZ (%d)\n", &VNetRoot->PrefixEntry.Prefix, VNetRoot->PrefixEntry.Prefix.Length);
            ASSERT(CanonicalName->Length >= VNetRoot->PrefixEntry.Prefix.Length);
 
            RemainingName->Buffer = Add2Ptr(CanonicalName->Buffer, VNetRoot->PrefixEntry.Prefix.Length);
            RemainingName->Length = CanonicalName->Length - VNetRoot->PrefixEntry.Prefix.Length;
            RemainingName->MaximumLength = RemainingName->Length;
 
            if (BooleanFlagOn(Flags, VNETROOT_FLAG_CSCAGENT_INSTANCE))
            {
                DPRINT("CSC instance, VNetRoot: %p\n", VNetRoot);
            }
            VNetRoot->Flags |= Flags;
        }
    }
 
    /* Release the prefix table - caller expects it to be released */
    if (LockHoldingState != LHS_LockNotHeld)
    {
        RxReleasePrefixTableLock(RxDeviceObject->pRxNetNameTable);
    }
 
    /* If we failed creating, quit */
    if (Status != STATUS_SUCCESS)
    {
        DPRINT1("RxFindOrConstructVirtualNetRoot() = Status: %x\n", Status);
        return Status;
    }
 
    /* Otherwise, wait until the VNetRoot is stable */
    DPRINT("Waiting for stable condition for: %p\n", VNetRoot);
    RxWaitForStableVNetRoot(VNetRoot, RxContext);
    /* It's all good, update the RX_CONTEXT with all our structs */
    if (VNetRoot->Condition == Condition_Good)
    {
        PNET_ROOT NetRoot;
 
        NetRoot = VNetRoot->NetRoot;
        RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
        RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
        RxContext->Create.pSrvCall = (PMRX_SRV_CALL)NetRoot->SrvCall;
    }
    else
    {
        RxDereferenceVNetRoot(VNetRoot, LHS_LockNotHeld);
        RxContext->Create.pVNetRoot = NULL;
        Status = STATUS_BAD_NETWORK_PATH;
    }
 
    return Status;
}
 
/*
 * @implemented
 */
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)
{
    PVOID Container;
    PSRV_CALL SrvCall;
    PNET_ROOT NetRoot;
    PV_NET_ROOT VNetRoot;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    PRX_PREFIX_TABLE PrefixTable;
    UNICODE_STRING RemainingName, NetRootName;
 
    PAGED_CODE();
 
    DPRINT("RxFindOrCreateConnections(%p, %wZ, %x, %p, %p, %p, %p)\n",
           RxContext, CanonicalName, NetRootType, LocalNetRootName,
           FilePathName, LockState, RxConnectionId);
 
    *FilePathName = *CanonicalName;
    LocalNetRootName->Length = 0;
    LocalNetRootName->MaximumLength = 0;
    LocalNetRootName->Buffer = CanonicalName->Buffer;
 
    /* UNC path, split it */
    if (FilePathName->Buffer[1] == ';')
    {
        BOOLEAN Slash;
        USHORT i, Length;
 
        Slash = FALSE;
        for (i = 2; i < FilePathName->Length / sizeof(WCHAR); ++i)
        {
            if (FilePathName->Buffer[i] == OBJ_NAME_PATH_SEPARATOR)
            {
                Slash = TRUE;
                break;
            }
        }
 
        if (!Slash)
        {
            return STATUS_OBJECT_NAME_INVALID;
        }
 
        FilePathName->Buffer = &FilePathName->Buffer[i];
        Length = (USHORT)((ULONG_PTR)FilePathName->Buffer - (ULONG_PTR)LocalNetRootName->Buffer);
        LocalNetRootName->Length = Length;
        LocalNetRootName->MaximumLength = Length;
        FilePathName->Length -= Length;
 
        DPRINT("CanonicalName: %wZ\n", CanonicalName);
        DPRINT(" -> FilePathName: %wZ\n", FilePathName);
        DPRINT(" -> LocalNetRootName: %wZ\n", LocalNetRootName);
    }
 
    Container = NULL;
    PrefixTable = RxContext->RxDeviceObject->pRxNetNameTable;
 
    _SEH2_TRY
    {
RetryLookup:
        ASSERT(*LockState != LHS_LockNotHeld);
 
        /* If previous lookup left something, dereference it */
        if (Container != NULL)
        {
            switch (NodeType(Container))
            {
                case RDBSS_NTC_SRVCALL:
                    RxDereferenceSrvCall(Container, *LockState);
                    break;
 
                case RDBSS_NTC_NETROOT:
                    RxDereferenceNetRoot(Container, *LockState);
                    break;
 
                case RDBSS_NTC_V_NETROOT:
                    RxDereferenceVNetRoot(Container, *LockState);
                    break;
 
                default:
                    /* Should never happen */
                    ASSERT(FALSE);
                    break;
            }
        }
 
        /* Look for our NetRoot in prefix table */
        Container = RxPrefixTableLookupName(PrefixTable, FilePathName, &RemainingName, RxConnectionId);
        DPRINT("Container %p for path %wZ\n", Container, FilePathName);
 
        while (TRUE)
        {
            UNICODE_STRING SrvCallName;
 
            SrvCall = NULL;
            NetRoot = NULL;
            VNetRoot = NULL;
 
            /* Assume we didn't succeed */
            RxContext->Create.pVNetRoot = NULL;
            RxContext->Create.pNetRoot = NULL;
            RxContext->Create.pSrvCall = NULL;
            RxContext->Create.Type = NetRootType;
 
            /* If we found something */
            if (Container != NULL)
            {
                /* A VNetRoot */
                if (NodeType(Container) == RDBSS_NTC_V_NETROOT)
                {
                    VNetRoot = Container;
                    /* Use its NetRoot */
                    NetRoot = VNetRoot->NetRoot;
 
                    /* If it's not stable, wait for it to be stable */
                    if (NetRoot->Condition == Condition_InTransition)
                    {
                        RxReleasePrefixTableLock(PrefixTable);
                        DPRINT("Waiting for stable condition for: %p\n", NetRoot);
                        RxWaitForStableNetRoot(NetRoot, RxContext);
                        RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                        *LockState = LHS_ExclusiveLockHeld;
 
                        /* Now that's it's ok, retry lookup to find what we want */
                        if (NetRoot->Condition == Condition_Good)
                        {
                            goto RetryLookup;
                        }
                    }
 
                    /* Is the associated netroot good? */
                    if (NetRoot->Condition == Condition_Good)
                    {
                        SrvCall = (PSRV_CALL)NetRoot->pSrvCall;
 
                        /* If it is, and SrvCall as well, then, we have our active connection */
                        if (SrvCall->Condition == Condition_Good &&
                            SrvCall->RxDeviceObject == RxContext->RxDeviceObject)
                        {
                            RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
                            RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
                            RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
 
                            Status = STATUS_CONNECTION_ACTIVE;
                            _SEH2_LEAVE;
                        }
                    }
 
                    /* If VNetRoot was well constructed, it means the connection is active */
                    if (VNetRoot->ConstructionStatus == STATUS_SUCCESS)
                    {
                        Status = STATUS_CONNECTION_ACTIVE;
                    }
                    else
                    {
                        Status = VNetRoot->ConstructionStatus;
                    }
 
                    RxDereferenceVNetRoot(VNetRoot, *LockState);
                    _SEH2_LEAVE;
                }
                /* Can only be a SrvCall */
                else
                {
                    ASSERT(NodeType(Container) == RDBSS_NTC_SRVCALL);
                    SrvCall = Container;
 
                    /* Wait for the SRV_CALL to be stable */
                    if (SrvCall->Condition == Condition_InTransition)
                    {
                        RxReleasePrefixTableLock(PrefixTable);
                        DPRINT("Waiting for stable condition for: %p\n", SrvCall);
                        RxWaitForStableSrvCall(SrvCall, RxContext);
                        RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                        *LockState = LHS_ExclusiveLockHeld;
 
                        /* It went good, loop again to find what we look for */
                        if (SrvCall->Condition == Condition_Good)
                        {
                            goto RetryLookup;
                        }
                    }
 
                    /* If it's not good... */
                    if (SrvCall->Condition != Condition_Good)
                    {
                        /* But SRV_CALL was well constructed, assume a connection was active */
                        if (SrvCall->Status == STATUS_SUCCESS)
                        {
                            Status = STATUS_CONNECTION_ACTIVE;
                        }
                        else
                        {
                            Status = SrvCall->Status;
                        }
 
                        RxDereferenceSrvCall(SrvCall, *LockState);
                        _SEH2_LEAVE;
                    }
                }
            }
 
            /* If we found a SRV_CALL not matching our DO, quit */
            if (SrvCall != NULL && SrvCall->Condition == Condition_Good &&
                SrvCall->RxDeviceObject != RxContext->RxDeviceObject)
            {
                RxDereferenceSrvCall(SrvCall, *LockState);
                Status = STATUS_BAD_NETWORK_NAME;
                _SEH2_LEAVE;
            }
 
            /* Now, we want exclusive lock */
            if (*LockState == LHS_SharedLockHeld)
            {
                if (!RxAcquirePrefixTableLockExclusive(PrefixTable, FALSE))
                {
                    RxReleasePrefixTableLock(PrefixTable);
                    RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                    *LockState = LHS_ExclusiveLockHeld;
                    goto RetryLookup;
                }
 
                RxReleasePrefixTableLock(PrefixTable);
                *LockState = LHS_ExclusiveLockHeld;
            }
 
            ASSERT(*LockState == LHS_ExclusiveLockHeld);
 
            /* If we reach that point, we found something, no need to create something */
            if (Container != NULL)
            {
                break;
            }
 
            /* Get the name for the SRV_CALL */
            RxExtractServerName(FilePathName, &SrvCallName, NULL);
            DPRINT(" -> SrvCallName: %wZ\n", &SrvCallName);
            /* And create the SRV_CALL */
            SrvCall = RxCreateSrvCall(RxContext, &SrvCallName, NULL, RxConnectionId);
            if (SrvCall == NULL)
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            /* Reset RX_CONTEXT, so far, connection creation isn't a success */
            RxReferenceSrvCall(SrvCall);
            RxContext->Create.pVNetRoot = NULL;
            RxContext->Create.pNetRoot = NULL;
            RxContext->Create.pSrvCall = NULL;
            RxContext->Create.Type = NetRootType;
            Container = SrvCall;
 
            /* Construct SRV_CALL, ie, use mini-rdr */
            Status = RxConstructSrvCall(RxContext, SrvCall, LockState);
            ASSERT(Status != STATUS_SUCCESS || RxIsPrefixTableLockAcquired(PrefixTable));
            if (Status != STATUS_SUCCESS)
            {
                DPRINT1("RxConstructSrvCall() = Status: %x\n", Status);
                RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
                RxDereferenceSrvCall(SrvCall, *LockState);
                RxReleasePrefixTableLock(PrefixTable);
                _SEH2_LEAVE;
            }
 
            /* Loop again to make use of SRV_CALL stable condition wait */
        }
 
        /* At that point, we have a stable SRV_CALL (either found or constructed) */
        ASSERT((NodeType(SrvCall) == RDBSS_NTC_SRVCALL) && (SrvCall->Condition == Condition_Good));
        ASSERT(NetRoot == NULL && VNetRoot == NULL);
        ASSERT(SrvCall->RxDeviceObject == RxContext->RxDeviceObject);
 
        /* Call mini-rdr to get NetRoot name */
        SrvCall->RxDeviceObject->Dispatch->MRxExtractNetRootName(FilePathName, (PMRX_SRV_CALL)SrvCall, &NetRootName, NULL);
        /* And create the NetRoot with that name */
        NetRoot = RxCreateNetRoot(SrvCall, &NetRootName, 0, RxConnectionId);
        if (NetRoot == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        NetRoot->Type = NetRootType;
 
        RxDereferenceSrvCall(SrvCall, *LockState);
 
        /* Finally, create the associated VNetRoot */
        VNetRoot = RxCreateVNetRoot(RxContext, NetRoot, CanonicalName, LocalNetRootName, FilePathName, RxConnectionId);
        if (VNetRoot == NULL)
        {
            RxFinalizeNetRoot(NetRoot, TRUE, TRUE);
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        RxReferenceVNetRoot(VNetRoot);
 
        /* We're get closer! */
        NetRoot->Condition = Condition_InTransition;
        RxContext->Create.pSrvCall = (PMRX_SRV_CALL)SrvCall;
        RxContext->Create.pNetRoot = (PMRX_NET_ROOT)NetRoot;
        RxContext->Create.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
 
        /* Construct the NetRoot, involving the mini-rdr now that we have our three control structs */
        Status = RxConstructNetRoot(RxContext, SrvCall, NetRoot, VNetRoot, LockState);
        if (!NT_SUCCESS(Status))
        {
            RxTransitionVNetRoot(VNetRoot, Condition_Bad);
            DPRINT1("RxConstructNetRoot failed Ctxt: %p, VNet: %p, Status: %lx, Condition: %d\n", RxContext, VNetRoot, Status, VNetRoot->Condition);
            RxDereferenceVNetRoot(VNetRoot, *LockState);
 
            RxContext->Create.pNetRoot = NULL;
            RxContext->Create.pVNetRoot = NULL;
        }
        else
        {
            PIO_STACK_LOCATION Stack;
 
            ASSERT(*LockState == LHS_ExclusiveLockHeld);
 
            Stack = RxContext->CurrentIrpSp;
            if (BooleanFlagOn(Stack->Parameters.Create.Options, FILE_CREATE_TREE_CONNECTION))
            {
                RxExclusivePrefixTableLockToShared(PrefixTable);
                *LockState = LHS_SharedLockHeld;
            }
        }
    }
    _SEH2_FINALLY
    {
        if (Status != STATUS_SUCCESS && Status != STATUS_CONNECTION_ACTIVE)
        {
            if (*LockState != LHS_LockNotHeld)
            {
                RxReleasePrefixTableLock(PrefixTable);
                *LockState = LHS_LockNotHeld;
            }
        }
    }
    _SEH2_END;
 
    DPRINT("RxFindOrCreateConnections() = Status: %x\n", Status);
    return Status;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxFinishFcbInitialization(
    IN OUT PMRX_FCB Fcb,
    IN RX_FILE_TYPE FileType,
    IN PFCB_INIT_PACKET InitPacket OPTIONAL)
{
    RX_FILE_TYPE OldType;
 
    PAGED_CODE();
 
    DPRINT("RxFinishFcbInitialization(%p, %x, %p)\n", Fcb, FileType, InitPacket);
 
    OldType = NodeType(Fcb);
    NodeType(Fcb) = FileType;
    /* If mini-rdr already did the job for mailslot attributes, 0 the rest */
    if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_TIME_AND_SIZE_ALREADY_SET) && FileType == RDBSS_NTC_MAILSLOT)
    {
        FILL_IN_FCB((PFCB)Fcb, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    }
    /* Otherwise, if mini-rdr provided us with an init packet, copy its data */
    else if (InitPacket != NULL)
    {
        FILL_IN_FCB((PFCB)Fcb, *InitPacket->pAttributes, *InitPacket->pNumLinks,
                    InitPacket->pCreationTime->QuadPart, InitPacket->pLastAccessTime->QuadPart,
                    InitPacket->pLastWriteTime->QuadPart, InitPacket->pLastChangeTime->QuadPart,
                    InitPacket->pAllocationSize->QuadPart, InitPacket->pFileSize->QuadPart,
                    InitPacket->pValidDataLength->QuadPart);
    }
 
    if (FileType != RDBSS_NTC_STORAGE_TYPE_UNKNOWN &&
        FileType != RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
    {
        /* If our FCB newly points to a file, initiliaze everything related */
        if (FileType == RDBSS_NTC_STORAGE_TYPE_FILE)
 
        {
            if (OldType != RDBSS_NTC_STORAGE_TYPE_FILE)
            {
                RxInitializeLowIoPerFcbInfo(&((PFCB)Fcb)->Specific.Fcb.LowIoPerFcbInfo);
                FsRtlInitializeFileLock(&((PFCB)Fcb)->Specific.Fcb.FileLock, RxLockOperationCompletion,
                                        RxUnlockOperation);
 
                ((PFCB)Fcb)->BufferedLocks.List = NULL;
                ((PFCB)Fcb)->BufferedLocks.PendingLockOps = 0;
 
                Fcb->Header.IsFastIoPossible = FastIoIsQuestionable;
            }
        }
        /* If not a file, validate type */
        else
        {
            ASSERT(FileType >= RDBSS_NTC_SPOOLFILE && FileType <= RDBSS_NTC_MAILSLOT);
        }
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxFinishSrvCallConstruction(
    PMRX_SRVCALLDOWN_STRUCTURE Calldown)
{
    NTSTATUS Status;
    PSRV_CALL SrvCall;
    PRX_CONTEXT Context;
    RX_BLOCK_CONDITION Condition;
    PRX_PREFIX_TABLE PrefixTable;
 
    DPRINT("RxFinishSrvCallConstruction(%p)\n", Calldown);
 
    SrvCall = (PSRV_CALL)Calldown->SrvCall;
    Context = Calldown->RxContext;
    PrefixTable = Context->RxDeviceObject->pRxNetNameTable;
 
    /* We have a winner, notify him */
    if (Calldown->BestFinisher != NULL)
    {
        DPRINT("Notify the winner: %p (%wZ)\n", Calldown->BestFinisher, &Calldown->BestFinisher->DeviceName);
 
        ASSERT(SrvCall->RxDeviceObject == Calldown->BestFinisher);
 
        MINIRDR_CALL_THROUGH(Status, Calldown->BestFinisher->Dispatch,
                             MRxSrvCallWinnerNotify,
                             ((PMRX_SRV_CALL)SrvCall, TRUE,
                              Calldown->CallbackContexts[Calldown->BestFinisherOrdinal].RecommunicateContext));
        if (Status != STATUS_SUCCESS)
        {
            Condition = Condition_Bad;
        }
        else
        {
            Condition = Condition_Good;
        }
    }
    /* Otherwise, just fail our SRV_CALL */
    else
    {
        Status = Calldown->CallbackContexts[0].Status;
        Condition = Condition_Bad;
    }
 
    RxAcquirePrefixTableLockExclusive(PrefixTable, TRUE);
    RxTransitionSrvCall(SrvCall, Condition);
    RxFreePoolWithTag(Calldown, RX_SRVCALL_POOLTAG);
 
    /* If async, finish it here, otherwise, caller has already finished the stuff */
    if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION))
    {
        DPRINT("Finishing async call\n");
 
        RxReleasePrefixTableLock(PrefixTable);
 
        /* Make sure we weren't cancelled in-between */
        if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_CANCELLED))
        {
            Status = STATUS_CANCELLED;
        }
 
        /* In case that was a create, context can be reused */
        if (Context->MajorFunction == IRP_MJ_CREATE)
        {
            RxpPrepareCreateContextForReuse(Context);
        }
 
        /* If that's a failure, reset everything and return failure */
        if (Status != STATUS_SUCCESS)
        {
            Context->MajorFunction = Context->CurrentIrpSp->MajorFunction;
            if (Context->MajorFunction == IRP_MJ_DEVICE_CONTROL)
            {
                if (Context->Info.Buffer != NULL)
                {
                    RxFreePool(Context->Info.Buffer);
                    Context->Info.Buffer = NULL;
                }
            }
            Context->CurrentIrp->IoStatus.Information = 0;
            Context->CurrentIrp->IoStatus.Status = Status;
            RxCompleteRequest(Context, Status);
        }
        /* Otherwise, call resume routine and done! */
        else
        {
            Status = Context->ResumeRoutine(Context);
            if (Status != STATUS_PENDING)
            {
                RxCompleteRequest(Context, Status);
            }
 
            DPRINT("Not completing, pending\n");
        }
    }
 
    RxDereferenceSrvCall(SrvCall, LHS_LockNotHeld);
    return Status;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxFinishSrvCallConstructionDispatcher(
    IN PVOID Context)
{
    KIRQL OldIrql;
    BOOLEAN Direct, KeepLoop;
 
    DPRINT("RxFinishSrvCallConstructionDispatcher(%p)\n", Context);
 
    /* In case of failure of starting dispatcher, context is not set
     * We keep track of it to fail associated SRV_CALL
     */
    Direct = (Context == NULL);
 
    /* Separated thread, loop forever */
    while (TRUE)
    {
        PLIST_ENTRY ListEntry;
        PMRX_SRVCALLDOWN_STRUCTURE Calldown;
 
        /* If there are no SRV_CALL to finalize left, just finish thread */
        KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
        if (IsListEmpty(&RxSrvCalldownList))
        {
            KeepLoop =  FALSE;
            RxSrvCallConstructionDispatcherActive = FALSE;
        }
        /* Otherwise, get the SRV_CALL to finish construction */
        else
        {
            ListEntry = RemoveHeadList(&RxSrvCalldownList);
            KeepLoop =  TRUE;
        }
        KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
        /* Nothing to do */
        if (!KeepLoop)
        {
            break;
        }
 
        /* If direct is set, reset the finisher to avoid electing a winner
         * and fail SRV_CALL (see upper comment)
         */
        Calldown = CONTAINING_RECORD(ListEntry, MRX_SRVCALLDOWN_STRUCTURE, SrvCalldownList);
        if (Direct)
        {
            Calldown->BestFinisher = NULL;
        }
        /* Finish SRV_CALL construction */
        RxFinishSrvCallConstruction(Calldown);
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxFlushFcbInSystemCache(
    IN PFCB Fcb,
    IN BOOLEAN SynchronizeWithLazyWriter)
{
    IO_STATUS_BLOCK IoStatus;
 
    PAGED_CODE();
 
    /* Deal with Cc */
    CcFlushCache(&Fcb->NonPaged->SectionObjectPointers, NULL, 0, &IoStatus);
    /* If we're asked to sync with LW, do it in case of success */
    if (SynchronizeWithLazyWriter && NT_SUCCESS(IoStatus.Status))
    {
        RxAcquirePagingIoResource((PRX_CONTEXT)NULL, Fcb);
        RxReleasePagingIoResource((PRX_CONTEXT)NULL, Fcb);
    }
 
    DPRINT("Flushing for FCB %p returns %lx\n", Fcb, IoStatus.Status);
    return IoStatus.Status;
}
 
/*
 * @implemented
 */
VOID
RxFreeFcbObject(
    PVOID Object)
{
    PAGED_CODE();
 
    DPRINT("Freeing %p\n", Object);
 
    /* If that's a FOBX/SRV_OPEN, nothing to do, just free it */
    if (NodeType(Object) == RDBSS_NTC_FOBX || NodeType(Object) == RDBSS_NTC_SRVOPEN)
    {
        RxFreePoolWithTag(Object, RX_FCB_POOLTAG);
    }
    /* If that's a FCB... */
    else if (NodeTypeIsFcb(Object))
    {
        PFCB Fcb;
        PRDBSS_DEVICE_OBJECT DeviceObject;
 
        Fcb = (PFCB)Object;
        DeviceObject = Fcb->RxDeviceObject;
 
        /* Delete per stream contexts */
        FsRtlTeardownPerStreamContexts(&Fcb->Header);
 
        SetFlag(Fcb->Header.Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH);
 
        /* If there was a non-paged FCB allocated, free it */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE))
        {
            RxFreePoolWithTag(Fcb->NonPaged, RX_NONPAGEDFCB_POOLTAG);
        }
 
        /* Free the FCB */
        RxFreePool(Fcb);
 
        /* Update statistics */
        InterlockedDecrement(&RxNumberOfActiveFcbs);
        InterlockedDecrement((volatile long *)&DeviceObject->NumberOfActiveFcbs);
    }
}
 
/*
 * @implemented
 */
VOID
RxFreeObject(
    PVOID pObject)
{
    PAGED_CODE();
 
    /* First, perform a few sanity checks if we're dealing with a SRV_CALL or a NET_ROOT */
    if (NodeType(pObject) == RDBSS_NTC_SRVCALL)
    {
        PSRV_CALL SrvCall;
        PRDBSS_DEVICE_OBJECT DeviceObject;
 
        SrvCall = (PSRV_CALL)pObject;
        DeviceObject = SrvCall->RxDeviceObject;
        if (DeviceObject != NULL)
        {
            if (!BooleanFlagOn(DeviceObject->Dispatch->MRxFlags, RDBSS_MANAGE_SRV_CALL_EXTENSION))
            {
                ASSERT(SrvCall->Context == NULL);
            }
 
            ASSERT(SrvCall->Context2 == NULL);
 
            SrvCall->RxDeviceObject = NULL;
        }
    }
    else if (NodeType(pObject) == RDBSS_NTC_NETROOT)
    {
        PNET_ROOT NetRoot;
 
        NetRoot = (PNET_ROOT)pObject;
        NetRoot->pSrvCall = NULL;
        NetRoot->NodeTypeCode = NodeType(pObject) | 0xF000;
    }
 
    /* And just free the object */
    RxFreePool(pObject);
}
 
/*
 * @implemented
 */
VOID
RxGatherRequestsForSrvOpen(
    IN OUT PSRV_CALL SrvCall,
    IN PSRV_OPEN SrvOpen,
    IN OUT PLIST_ENTRY RequestsListHead)
{
    KIRQL OldIrql;
    LIST_ENTRY Discarded, *Entry;
    PCHANGE_BUFFERING_STATE_REQUEST Request;
 
    /* Dispatch any pending operation first */
    RxpDispatchChangeBufferingStateRequests(SrvCall, SrvOpen, &Discarded);
 
    /* Then, get any entry related to our key and SRV_OPEN */
    KeAcquireSpinLock(&SrvCall->BufferingManager.SpinLock, &OldIrql);
    Entry = SrvCall->BufferingManager.HandlerList.Flink;
    while (Entry != &SrvCall->BufferingManager.HandlerList)
    {
        Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
        Entry = Entry->Flink;
        if (Request->SrvOpenKey == SrvOpen->Key && Request->SrvOpen == SrvOpen)
        {
            RemoveEntryList(&Request->ListEntry);
            InsertTailList(RequestsListHead, &Request->ListEntry);
        }
    }
    KeReleaseSpinLock(&SrvCall->BufferingManager.SpinLock, OldIrql);
 
    /* Perform the same search in the last change list */
    Entry = SrvCall->BufferingManager.LastChanceHandlerList.Flink;
    while (Entry != &SrvCall->BufferingManager.LastChanceHandlerList)
    {
        Request = CONTAINING_RECORD(Entry, CHANGE_BUFFERING_STATE_REQUEST, ListEntry);
        Entry = Entry->Flink;
        if (Request->SrvOpenKey == SrvOpen->Key && Request->SrvOpen == SrvOpen)
        {
            RemoveEntryList(&Request->ListEntry);
            InsertTailList(RequestsListHead, &Request->ListEntry);
        }
    }
 
    /* Discard the discarded requests */
    RxpDiscardChangeBufferingStateRequests(&Discarded);
}
 
/*
 * @implemented
 */
PRDBSS_DEVICE_OBJECT
RxGetDeviceObjectOfInstance(
    PVOID Instance)
{
    NODE_TYPE_CODE NodeType;
    PRDBSS_DEVICE_OBJECT DeviceObject;
 
    PAGED_CODE();
 
    /* We only handle a few object types */
    NodeType = NodeType(Instance);
    ASSERT((NodeType == RDBSS_NTC_SRVCALL) || (NodeType == RDBSS_NTC_NETROOT) ||
           (NodeType == RDBSS_NTC_V_NETROOT) || (NodeType == RDBSS_NTC_SRVOPEN) || (NodeType == RDBSS_NTC_FOBX));
 
    /* Get the device object depending on the object */
    switch (NodeType)
    {
        case RDBSS_NTC_FOBX:
        {
            PFOBX Fobx;
 
            Fobx = (PFOBX)Instance;
            DeviceObject = Fobx->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_SRVCALL:
        {
            PSRV_CALL SrvCall;
 
            SrvCall = (PSRV_CALL)Instance;
            DeviceObject = SrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_NETROOT:
        {
            PNET_ROOT NetRoot;
 
            NetRoot = (PNET_ROOT)Instance;
            DeviceObject = NetRoot->pSrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_V_NETROOT:
        {
            PV_NET_ROOT VNetRoot;
 
            VNetRoot = (PV_NET_ROOT)Instance;
            DeviceObject = VNetRoot->pNetRoot->pSrvCall->RxDeviceObject;
            break;
        }
 
        case RDBSS_NTC_SRVOPEN:
        {
            PSRV_OPEN SrvOpen;
 
            SrvOpen = (PSRV_OPEN)Instance;
            DeviceObject = ((PFCB)SrvOpen->pFcb)->RxDeviceObject;
            break;
        }
 
        default:
            DeviceObject = NULL;
            break;
    }
 
    /* Job done */
    return DeviceObject;
}
 
/*
 * @implemented
 */
VOID
RxGetFileSizeWithLock(
    IN PFCB Fcb,
    OUT PLONGLONG FileSize)
{
    PAGED_CODE();
 
    *FileSize = Fcb->Header.FileSize.QuadPart;
}
 
/*
 * @implemented
 */
PEPROCESS
NTAPI
RxGetRDBSSProcess(
    VOID)
{
    return RxData.OurProcess;
}
 
/*
 * @implemented
 */
NTSTATUS
RxInitializeBufferingManager(
   PSRV_CALL SrvCall)
{
    KeInitializeSpinLock(&SrvCall->BufferingManager.SpinLock);
    InitializeListHead(&SrvCall->BufferingManager.DispatcherList);
    InitializeListHead(&SrvCall->BufferingManager.HandlerList);
    InitializeListHead(&SrvCall->BufferingManager.LastChanceHandlerList);
    SrvCall->BufferingManager.DispatcherActive = FALSE;
    SrvCall->BufferingManager.HandlerInactive = FALSE;
    SrvCall->BufferingManager.LastChanceHandlerActive = FALSE;
    SrvCall->BufferingManager.NumberOfOutstandingOpens = 0;
    InitializeListHead(&SrvCall->BufferingManager.SrvOpenLists[0]);
    ExInitializeFastMutex(&SrvCall->BufferingManager.Mutex);
 
    return STATUS_SUCCESS;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxInitializeContext(
    IN PIRP Irp,
    IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
    IN ULONG InitialContextFlags,
    IN OUT PRX_CONTEXT RxContext)
{
    PIO_STACK_LOCATION Stack;
 
    /* Initialize our various fields */
    RxContext->NodeTypeCode = RDBSS_NTC_RX_CONTEXT;
    RxContext->NodeByteSize = sizeof(RX_CONTEXT);
    RxContext->ReferenceCount = 1;
    RxContext->SerialNumber = InterlockedExchangeAdd((volatile LONG *)&RxContextSerialNumberCounter, 1);
    RxContext->RxDeviceObject = RxDeviceObject;
    KeInitializeEvent(&RxContext->SyncEvent, SynchronizationEvent, FALSE);
    RxInitializeScavengerEntry(&RxContext->ScavengerEntry);
    InitializeListHead(&RxContext->BlockedOperations);
    RxContext->MRxCancelRoutine = NULL;
    RxContext->ResumeRoutine = NULL;
    RxContext->Flags |= InitialContextFlags;
    RxContext->CurrentIrp = Irp;
    RxContext->LastExecutionThread = PsGetCurrentThread();
    RxContext->OriginalThread = RxContext->LastExecutionThread;
 
    /* If've got no IRP, mark RX_CONTEXT */
    if (Irp == NULL)
    {
        RxContext->CurrentIrpSp = NULL;
        RxContext->MajorFunction = IRP_MJ_MAXIMUM_FUNCTION + 1;
        RxContext->MinorFunction = 0;
    }
    else
    {
        /* Otherwise, first determine whether we are performing async operation */
        Stack = IoGetCurrentIrpStackLocation(Irp);
        if (Stack->FileObject != NULL)
        {
            PFCB Fcb;
 
            Fcb = Stack->FileObject->FsContext;
            if (!IoIsOperationSynchronous(Irp) ||
                ((Fcb != NULL && NodeTypeIsFcb(Fcb)) &&
                 (Stack->MajorFunction == IRP_MJ_READ || Stack->MajorFunction == IRP_MJ_WRITE || Stack->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
                 (Fcb->pNetRoot != NULL && (Fcb->pNetRoot->Type == NET_ROOT_PIPE))))
            {
                RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
            }
        }
 
        if (Stack->MajorFunction == IRP_MJ_DIRECTORY_CONTROL && Stack->MinorFunction == IRP_MN_NOTIFY_CHANGE_DIRECTORY)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
        }
        if (Stack->MajorFunction == IRP_MJ_DEVICE_CONTROL)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_ASYNC_OPERATION;
        }
 
        /* Set proper flags if TopLevl IRP/Device */
        if (!RxIsThisTheTopLevelIrp(Irp))
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_RECURSIVE_CALL;
        }
        if (RxGetTopDeviceObjectIfRdbssIrp() == RxDeviceObject)
        {
            RxContext->Flags |= RX_CONTEXT_FLAG_THIS_DEVICE_TOP_LEVEL;
        }
 
        /* Copy stack information */
        RxContext->MajorFunction = Stack->MajorFunction;
        RxContext->MinorFunction = Stack->MinorFunction;
        ASSERT(RxContext->MajorFunction <= IRP_MJ_MAXIMUM_FUNCTION);
        RxContext->CurrentIrpSp = Stack;
 
        /* If we have a FO associated, learn for more */
        if (Stack->FileObject != NULL)
        {
            PFCB Fcb;
            PFOBX Fobx;
 
            /* Get the FCB and CCB (FOBX) */
            Fcb = Stack->FileObject->FsContext;
            Fobx = Stack->FileObject->FsContext2;
            RxContext->pFcb = (PMRX_FCB)Fcb;
            if (Fcb != NULL && NodeTypeIsFcb(Fcb))
            {
                RxContext->NonPagedFcb = Fcb->NonPaged;
            }
 
            /* We have a FOBX, this not a DFS opening, keep track of it */
            if (Fobx != NULL && Fobx != UIntToPtr(DFS_OPEN_CONTEXT) && Fobx != UIntToPtr(DFS_DOWNLEVEL_OPEN_CONTEXT))
            {
                RxContext->pFobx = (PMRX_FOBX)Fobx;
                RxContext->pRelevantSrvOpen = Fobx->pSrvOpen;
                if (Fobx->NodeTypeCode == RDBSS_NTC_FOBX)
                {
                    RxContext->FobxSerialNumber = InterlockedIncrement((volatile LONG *)&Fobx->FobxSerialNumber);
                }
            }
            else
            {
                RxContext->pFobx = NULL;
            }
 
            /* In case of directory change notification, Fobx may be a VNetRoot, take note of that */
            if (RxContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL && RxContext->MinorFunction == IRP_MN_NOTIFY_CHANGE_DIRECTORY &&
                Fobx != NULL)
            {
                PV_NET_ROOT VNetRoot = NULL;
 
                if (Fobx->NodeTypeCode == RDBSS_NTC_FOBX)
                {
                    VNetRoot = Fcb->VNetRoot;
                }
                else if (Fobx->NodeTypeCode == RDBSS_NTC_V_NETROOT)
                {
                    VNetRoot = (PV_NET_ROOT)Fobx;
                }
 
                if (VNetRoot != NULL)
                {
                    RxContext->NotifyChangeDirectory.pVNetRoot = (PMRX_V_NET_ROOT)VNetRoot;
                }
            }
 
            /* Remember if that's a write through file */
            RxContext->RealDevice = Stack->FileObject->DeviceObject;
            if (BooleanFlagOn(Stack->FileObject->Flags, FO_WRITE_THROUGH))
            {
                RxContext->Flags |= RX_CONTEXT_FLAG_WRITE_THROUGH;
            }
        }
    }
 
    if (RxContext->MajorFunction != IRP_MJ_DEVICE_CONTROL)
    {
        DPRINT("New Ctxt: %p for MN: %d, IRP: %p, THRD: %p, FCB: %p, FOBX:%p #%lx\n",
               RxContext, RxContext->MinorFunction, Irp,
               PsGetCurrentThread(), RxContext->pFcb, RxContext->pFobx,
               RxContext->SerialNumber);
    }
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxInitializeDebugSupport(
    VOID)
{
    /* Nothing to do */
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxInitializeDispatcher(
    VOID)
{
    NTSTATUS Status;
    HANDLE ThreadHandle;
 
    PAGED_CODE();
 
    RxFileSystemDeviceObject->DispatcherContext.NumberOfWorkerThreads = 0;
    RxFileSystemDeviceObject->DispatcherContext.pTearDownEvent = NULL;
 
    /* Set appropriate timeouts: 10s & 60s */
    RxWorkQueueWaitInterval[CriticalWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxWorkQueueWaitInterval[DelayedWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxWorkQueueWaitInterval[HyperCriticalWorkQueue].QuadPart = -10 * 1000 * 1000 * 10;
    RxSpinUpDispatcherWaitInterval.QuadPart = -60 * 1000 * 1000 * 10;
 
    RxDispatcher.NumberOfProcessors = 1;
    RxDispatcher.OwnerProcess = IoGetCurrentProcess();
    RxDispatcher.pWorkQueueDispatcher = &RxDispatcherWorkQueues;
 
    /* Initialize our dispatchers */
    Status = RxInitializeWorkQu