rdbss.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/rdbsslib/rdbss.c
 * PURPOSE:          RDBSS library
 * PROGRAMMER:       Pierre Schweitzer (pierre@reactos.org)
 */
 
/* INCLUDES *****************************************************************/
 
#include <rx.h>
#include <pseh/pseh2.h>
#include <limits.h>
#include <dfs.h>
#include <copysup.h>
 
#define NDEBUG
#include <debug.h>
 
#define RX_TOPLEVELCTX_FLAG_FROM_POOL 1
 
typedef
NTSTATUS
(NTAPI *PRX_FSD_DISPATCH) (
    PRX_CONTEXT Context);
 
typedef struct _RX_FSD_DISPATCH_VECTOR
{
    PRX_FSD_DISPATCH CommonRoutine;
} RX_FSD_DISPATCH_VECTOR, *PRX_FSD_DISPATCH_VECTOR;
 
VOID
NTAPI
RxAcquireFileForNtCreateSection(
    PFILE_OBJECT FileObject);
 
NTSTATUS
NTAPI
RxAcquireForCcFlush(
    PFILE_OBJECT FileObject,
    PDEVICE_OBJECT DeviceObject);
 
VOID
RxAddToTopLevelIrpAllocatedContextsList(
    PRX_TOPLEVELIRP_CONTEXT TopLevelContext);
 
VOID
RxAssert(
    PVOID Assert,
    PVOID File,
    ULONG Line,
    PVOID Message);
 
NTSTATUS
NTAPI
RxCommonCleanup(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonClose(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonCreate(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDevFCBCleanup(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDevFCBClose(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDevFCBFsCtl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDevFCBIoCtl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDevFCBQueryVolInfo(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDeviceControl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDirectoryControl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonDispatchProblem(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonFileSystemControl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonFlushBuffers(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonLockControl(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonQueryEa(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonQueryInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonQueryQuotaInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonQuerySecurity(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonQueryVolumeInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonRead(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonSetEa(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonSetInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonSetQuotaInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonSetSecurity(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonSetVolumeInformation(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonUnimplemented(
    PRX_CONTEXT Context);
 
NTSTATUS
NTAPI
RxCommonWrite(
    PRX_CONTEXT Context);
 
VOID
RxCopyCreateParameters(
    IN PRX_CONTEXT RxContext);
 
NTSTATUS
RxCreateFromNetRoot(
    PRX_CONTEXT Context,
    PUNICODE_STRING NetRootName);
 
NTSTATUS
RxCreateTreeConnect(
    IN PRX_CONTEXT RxContext);
 
BOOLEAN
NTAPI
RxFastIoCheckIfPossible(
    PFILE_OBJECT FileObject,
    PLARGE_INTEGER FileOffset,
    ULONG Length, BOOLEAN Wait,
    ULONG LockKey, BOOLEAN CheckForReadOperation,
    PIO_STATUS_BLOCK IoStatus,
    PDEVICE_OBJECT DeviceObject);
 
BOOLEAN
NTAPI
RxFastIoDeviceControl(
    PFILE_OBJECT FileObject,
    BOOLEAN Wait,
    PVOID InputBuffer OPTIONAL,
    ULONG InputBufferLength,
    PVOID OutputBuffer OPTIONAL,
    ULONG OutputBufferLength,
    ULONG IoControlCode,
    PIO_STATUS_BLOCK IoStatus,
    PDEVICE_OBJECT DeviceObject);
 
BOOLEAN
NTAPI
RxFastIoRead(
    PFILE_OBJECT FileObject,
    PLARGE_INTEGER FileOffset,
    ULONG Length,
    BOOLEAN Wait,
    ULONG LockKey,
    PVOID Buffer,
    PIO_STATUS_BLOCK IoStatus,
    PDEVICE_OBJECT DeviceObject);
 
BOOLEAN
NTAPI
RxFastIoWrite(
    PFILE_OBJECT FileObject,
    PLARGE_INTEGER FileOffset,
    ULONG Length,
    BOOLEAN Wait,
    ULONG LockKey,
    PVOID Buffer,
    PIO_STATUS_BLOCK IoStatus,
    PDEVICE_OBJECT DeviceObject);
 
NTSTATUS
RxFindOrCreateFcb(
    PRX_CONTEXT RxContext,
    PUNICODE_STRING NetRootName);
 
NTSTATUS
RxFirstCanonicalize(
    PRX_CONTEXT RxContext,
    PUNICODE_STRING FileName,
    PUNICODE_STRING CanonicalName,
    PNET_ROOT_TYPE NetRootType);
 
VOID
RxFreeCanonicalNameBuffer(
    PRX_CONTEXT Context);
 
VOID
NTAPI
RxFspDispatch(
    IN PVOID Context);
 
VOID
NTAPI
RxGetRegistryParameters(
    IN PUNICODE_STRING RegistryPath);
 
NTSTATUS
NTAPI
RxGetStringRegistryParameter(
    IN HANDLE KeyHandle,
    IN PCWSTR KeyName,
    OUT PUNICODE_STRING OutString,
    IN PUCHAR Buffer,
    IN ULONG BufferLength,
    IN BOOLEAN LogFailure);
 
VOID
NTAPI
RxInitializeDebugSupport(
    VOID);
 
VOID
NTAPI
RxInitializeDispatchVectors(
    PDRIVER_OBJECT DriverObject);
 
NTSTATUS
NTAPI
RxInitializeRegistrationStructures(
    VOID);
 
VOID
NTAPI
RxInitializeTopLevelIrpPackage(
    VOID);
 
VOID
NTAPI
RxInitUnwind(
    PDRIVER_OBJECT DriverObject,
    USHORT State);
 
BOOLEAN
RxIsThisAnRdbssTopLevelContext(
    PRX_TOPLEVELIRP_CONTEXT TopLevelContext);
 
NTSTATUS
NTAPI
RxLowIoIoCtlShellCompletion(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxLowIoReadShell(
    PRX_CONTEXT RxContext);
 
NTSTATUS
NTAPI
RxLowIoReadShellCompletion(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxLowIoWriteShell(
    IN PRX_CONTEXT RxContext);
 
NTSTATUS
NTAPI
RxLowIoWriteShellCompletion(
    PRX_CONTEXT RxContext);
 
PVOID
RxNewMapUserBuffer(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxNotifyChangeDirectory(
    PRX_CONTEXT RxContext);
 
VOID
NTAPI
RxpCancelRoutine(
    PVOID Context);
 
NTSTATUS
RxpQueryInfoMiniRdr(
    PRX_CONTEXT RxContext,
    FILE_INFORMATION_CLASS FileInfoClass,
    PVOID Buffer);
 
VOID
RxPurgeNetFcb(
    PFCB Fcb,
    PRX_CONTEXT LocalContext);
 
NTSTATUS
RxQueryAlternateNameInfo(
    PRX_CONTEXT RxContext,
    PFILE_NAME_INFORMATION AltNameInfo);
 
NTSTATUS
RxQueryBasicInfo(
    PRX_CONTEXT RxContext,
    PFILE_BASIC_INFORMATION BasicInfo);
 
NTSTATUS
RxQueryCompressedInfo(
    PRX_CONTEXT RxContext,
    PFILE_COMPRESSION_INFORMATION CompressionInfo);
 
NTSTATUS
RxQueryDirectory(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxQueryEaInfo(
    PRX_CONTEXT RxContext,
    PFILE_EA_INFORMATION EaInfo);
 
NTSTATUS
RxQueryInternalInfo(
    PRX_CONTEXT RxContext,
    PFILE_INTERNAL_INFORMATION InternalInfo);
 
NTSTATUS
RxQueryNameInfo(
    PRX_CONTEXT RxContext,
    PFILE_NAME_INFORMATION NameInfo);
 
NTSTATUS
RxQueryPipeInfo(
    PRX_CONTEXT RxContext,
    PFILE_PIPE_INFORMATION PipeInfo);
 
NTSTATUS
RxQueryPositionInfo(
    PRX_CONTEXT RxContext,
    PFILE_POSITION_INFORMATION PositionInfo);
 
NTSTATUS
RxQueryStandardInfo(
    PRX_CONTEXT RxContext,
    PFILE_STANDARD_INFORMATION StandardInfo);
 
VOID
NTAPI
RxReadRegistryParameters(
    VOID);
 
VOID
NTAPI
RxReleaseFileForNtCreateSection(
    PFILE_OBJECT FileObject);
 
NTSTATUS
NTAPI
RxReleaseForCcFlush(
    PFILE_OBJECT FileObject,
    PDEVICE_OBJECT DeviceObject);
 
PRX_CONTEXT
RxRemoveOverflowEntry(
    PRDBSS_DEVICE_OBJECT DeviceObject,
    WORK_QUEUE_TYPE Queue);
 
NTSTATUS
RxSearchForCollapsibleOpen(
    PRX_CONTEXT RxContext,
    ACCESS_MASK DesiredAccess,
    ULONG ShareAccess);
 
NTSTATUS
RxSetAllocationInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetBasicInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetDispositionInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetEndOfFileInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetPipeInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetPositionInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetRenameInfo(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSetSimpleInfo(
    PRX_CONTEXT RxContext);
 
VOID
RxSetupNetFileObject(
    PRX_CONTEXT RxContext);
 
NTSTATUS
RxSystemControl(
    IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
    IN PIRP Irp);
 
VOID
RxUninitializeCacheMap(
    PRX_CONTEXT RxContext,
    PFILE_OBJECT FileObject,
    PLARGE_INTEGER TruncateSize);
 
VOID
RxUnstart(
    PRX_CONTEXT Context,
    PRDBSS_DEVICE_OBJECT DeviceObject);
 
NTSTATUS
RxXXXControlFileCallthru(
    PRX_CONTEXT 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);
 
WCHAR RxStarForTemplate = '*';
WCHAR Rx8QMdot3QM[] = L">>>>>>>>.>>>*";
BOOLEAN DisableByteRangeLockingOnReadOnlyFiles = FALSE;
BOOLEAN DisableFlushOnCleanup = FALSE;
ULONG ReadAheadGranularity = 1 << PAGE_SHIFT;
LIST_ENTRY RxActiveContexts;
NPAGED_LOOKASIDE_LIST RxContextLookasideList;
RDBSS_DATA RxData;
FCB RxDeviceFCB;
BOOLEAN RxLoudLowIoOpsEnabled = FALSE;
RX_FSD_DISPATCH_VECTOR RxDeviceFCBVector[IRP_MJ_MAXIMUM_FUNCTION + 1] =
{
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDevFCBClose },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDevFCBQueryVolInfo },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDevFCBFsCtl },
    { RxCommonDevFCBIoCtl },
    { RxCommonDevFCBIoCtl },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDevFCBCleanup },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonDispatchProblem },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
};
RDBSS_EXPORTS RxExports;
FAST_IO_DISPATCH RxFastIoDispatch;
PRDBSS_DEVICE_OBJECT RxFileSystemDeviceObject;
RX_FSD_DISPATCH_VECTOR RxFsdDispatchVector[IRP_MJ_MAXIMUM_FUNCTION + 1] =
{
    { RxCommonCreate },
    { RxCommonUnimplemented },
    { RxCommonClose },
    { RxCommonRead },
    { RxCommonWrite },
    { RxCommonQueryInformation },
    { RxCommonSetInformation },
    { RxCommonQueryEa },
    { RxCommonSetEa },
    { RxCommonFlushBuffers },
    { RxCommonQueryVolumeInformation },
    { RxCommonSetVolumeInformation },
    { RxCommonDirectoryControl },
    { RxCommonFileSystemControl },
    { RxCommonDeviceControl },
    { RxCommonDeviceControl },
    { RxCommonUnimplemented },
    { RxCommonLockControl },
    { RxCommonCleanup },
    { RxCommonUnimplemented },
    { RxCommonQuerySecurity },
    { RxCommonSetSecurity },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonUnimplemented },
    { RxCommonQueryQuotaInformation },
    { RxCommonSetQuotaInformation },
    { RxCommonUnimplemented },
};
ULONG RxFsdEntryCount;
LIST_ENTRY RxIrpsList;
KSPIN_LOCK RxIrpsListSpinLock;
KMUTEX RxScavengerMutex;
KMUTEX RxSerializationMutex;
UCHAR RxSpaceForTheWrappersDeviceObject[sizeof(*RxFileSystemDeviceObject)];
KSPIN_LOCK TopLevelIrpSpinLock;
LIST_ENTRY TopLevelIrpAllocatedContextsList;
BOOLEAN RxForceQFIPassThrough = FALSE;
BOOLEAN RxNoAsync = FALSE;
 
DECLARE_CONST_UNICODE_STRING(unknownId, L"???");
 
#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
 */
VOID
CheckForLoudOperations(
    PRX_CONTEXT RxContext)
{
    RxCaptureFcb;
 
    PAGED_CODE();
 
#define ALLSCR_LENGTH (sizeof(L"all.scr") - sizeof(UNICODE_NULL))
 
    /* Are loud operations enabled? */
    if (RxLoudLowIoOpsEnabled)
    {
        /* If so, the operation will be loud only if filename ends with all.scr */
        if (RtlCompareMemory(Add2Ptr(capFcb->PrivateAlreadyPrefixedName.Buffer,
                             (capFcb->PrivateAlreadyPrefixedName.Length - ALLSCR_LENGTH)),
                             L"all.scr", ALLSCR_LENGTH) == ALLSCR_LENGTH)
        {
            SetFlag(RxContext->LowIoContext.Flags, LOWIO_CONTEXT_FLAG_LOUDOPS);
        }
    }
#undef ALLSCR_LENGTH
}
 
/*
 * @implemented
 */
VOID
__RxInitializeTopLevelIrpContext(
    IN OUT PRX_TOPLEVELIRP_CONTEXT TopLevelContext,
    IN PIRP Irp,
    IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
    IN ULONG Flags)
{
    DPRINT("__RxInitializeTopLevelIrpContext(%p, %p, %p, %u)\n", TopLevelContext, Irp, RxDeviceObject, Flags);
 
    RtlZeroMemory(TopLevelContext, sizeof(RX_TOPLEVELIRP_CONTEXT));
    TopLevelContext->Irp = Irp;
    TopLevelContext->Flags = (Flags ? RX_TOPLEVELCTX_FLAG_FROM_POOL : 0);
    TopLevelContext->Signature = RX_TOPLEVELIRP_CONTEXT_SIGNATURE;
    TopLevelContext->RxDeviceObject = RxDeviceObject;
    TopLevelContext->Previous = IoGetTopLevelIrp();
    TopLevelContext->Thread = PsGetCurrentThread();
 
    /* We cannot add to list something that'd come from stack */
    if (BooleanFlagOn(TopLevelContext->Flags, RX_TOPLEVELCTX_FLAG_FROM_POOL))
    {
        RxAddToTopLevelIrpAllocatedContextsList(TopLevelContext);
    }
}
 
/*
 * @implemented
 */
VOID
__RxWriteReleaseResources(
    PRX_CONTEXT RxContext,
    BOOLEAN ResourceOwnerSet,
    ULONG LineNumber,
    PCSTR FileName,
    ULONG SerialNumber)
{
    RxCaptureFcb;
 
    PAGED_CODE();
 
    ASSERT(RxContext != NULL);
    ASSERT(capFcb != NULL);
 
    /* If FCB resource was acquired, release it */
    if (RxContext->FcbResourceAcquired)
    {
        /* Taking care of owner */
        if (ResourceOwnerSet)
        {
            RxReleaseFcbForThread(RxContext, capFcb, RxContext->LowIoContext.ResourceThreadId);
        }
        else
        {
            RxReleaseFcb(RxContext, capFcb);
        }
 
        RxContext->FcbResourceAcquired = FALSE;
    }
 
    /* If FCB paging resource was acquired, release it */
    if (RxContext->FcbPagingIoResourceAcquired)
    {
        /* Taking care of owner */
        if (ResourceOwnerSet)
        {
            RxReleasePagingIoResourceForThread(RxContext, capFcb, RxContext->LowIoContext.ResourceThreadId);
        }
        else
        {
            RxReleasePagingIoResource(RxContext, capFcb);
        }
 
        /* No need to release boolean here, RxReleasePagingIoResource() takes care of it */
    }
}
 
/*
 * @implemented
 */
VOID
RxAddToTopLevelIrpAllocatedContextsList(
    PRX_TOPLEVELIRP_CONTEXT TopLevelContext)
{
    KIRQL OldIrql;
 
    DPRINT("RxAddToTopLevelIrpAllocatedContextsList(%p)\n", TopLevelContext);
 
    ASSERT(TopLevelContext->Signature == RX_TOPLEVELIRP_CONTEXT_SIGNATURE);
    ASSERT(BooleanFlagOn(TopLevelContext->Flags, RX_TOPLEVELCTX_FLAG_FROM_POOL));
 
    KeAcquireSpinLock(&TopLevelIrpSpinLock, &OldIrql);
    InsertTailList(&TopLevelIrpAllocatedContextsList, &TopLevelContext->ListEntry);
    KeReleaseSpinLock(&TopLevelIrpSpinLock, OldIrql);
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxAddToWorkque(
    IN PRX_CONTEXT RxContext,
    IN PIRP Irp)
{
    ULONG Queued;
    KIRQL OldIrql;
    WORK_QUEUE_TYPE Queue;
 
    RxCaptureParamBlock;
 
    RxContext->PostRequest = FALSE;
 
    /* First of all, select the appropriate queue - delayed for prefix claim, critical for the rest */
    if (RxContext->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
        capPARAMS->Parameters.DeviceIoControl.IoControlCode == IOCTL_REDIR_QUERY_PATH)
    {
        Queue = DelayedWorkQueue;
        SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE);
    }
    else
    {
        Queue = CriticalWorkQueue;
        SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE);
    }
 
    /* Check for overflow */
    if (capPARAMS->FileObject != NULL)
    {
        KeAcquireSpinLock(&RxFileSystemDeviceObject->OverflowQueueSpinLock, &OldIrql);
 
        Queued = InterlockedIncrement(&RxFileSystemDeviceObject->PostedRequestCount[Queue]);
        /* In case of an overflow, add the new queued call to the overflow list */
        if (Queued > 1)
        {
            InterlockedDecrement(&RxFileSystemDeviceObject->PostedRequestCount[Queue]);
            InsertTailList(&RxFileSystemDeviceObject->OverflowQueue[Queue], &RxContext->OverflowListEntry);
            ++RxFileSystemDeviceObject->OverflowQueueCount[Queue];
 
            KeReleaseSpinLock(&RxFileSystemDeviceObject->OverflowQueueSpinLock, OldIrql);
            return;
        }
 
        KeReleaseSpinLock(&RxFileSystemDeviceObject->OverflowQueueSpinLock, OldIrql);
    }
 
    ExInitializeWorkItem(&RxContext->WorkQueueItem, RxFspDispatch, RxContext);
    ExQueueWorkItem((PWORK_QUEUE_ITEM)&RxContext->WorkQueueItem, Queue);
}
 
/*
 * @implemented
 */
VOID
RxAdjustFileTimesAndSize(
    PRX_CONTEXT RxContext)
{
    NTSTATUS Status;
    LARGE_INTEGER CurrentTime;
    FILE_BASIC_INFORMATION FileBasicInfo;
    FILE_END_OF_FILE_INFORMATION FileEOFInfo;
    BOOLEAN FileModified, SetLastChange, SetLastAccess, SetLastWrite, NeedUpdate;
 
    RxCaptureFcb;
    RxCaptureFobx;
    RxCaptureParamBlock;
    RxCaptureFileObject;
 
    PAGED_CODE();
 
    /* If Cc isn't initialized, the file was not read nor written, nothing to do */
    if (capFileObject->PrivateCacheMap == NULL)
    {
        return;
    }
 
    /* Get now */
    KeQuerySystemTime(&CurrentTime);
 
    /* Was the file modified? */
    FileModified = BooleanFlagOn(capFileObject->Flags, FO_FILE_MODIFIED);
    /* We'll set last write if it was modified and user didn't update yet */
    SetLastWrite = FileModified && !BooleanFlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_WRITE);
    /* File was accessed if: written or read (fastio), we'll update last access if user didn't */
    SetLastAccess = SetLastWrite ||
                    (BooleanFlagOn(capFileObject->Flags, FO_FILE_FAST_IO_READ) &&
                     !BooleanFlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_ACCESS));
    /* We'll set last change if it was modified and user didn't update yet */
    SetLastChange = FileModified && !BooleanFlagOn(capFobx->Flags, FOBX_FLAG_USER_SET_LAST_CHANGE);
 
    /* Nothing to update? Job done */
    if (!FileModified && !SetLastWrite && !SetLastAccess && !SetLastChange)
    {
        return;
    }
 
    /* By default, we won't issue any MRxSetFileInfoAtCleanup call */
    NeedUpdate = FALSE;
    RtlZeroMemory(&FileBasicInfo, sizeof(FileBasicInfo));
 
    /* Update lastwrite time if required */
    if (SetLastWrite)
    {
        NeedUpdate = TRUE;
        capFcb->LastWriteTime.QuadPart = CurrentTime.QuadPart;
        FileBasicInfo.LastWriteTime.QuadPart = CurrentTime.QuadPart;
    }
 
    /* Update lastaccess time if required */
    if (SetLastAccess)
    {
        NeedUpdate = TRUE;
        capFcb->LastAccessTime.QuadPart = CurrentTime.QuadPart;
        FileBasicInfo.LastAccessTime.QuadPart = CurrentTime.QuadPart;
    }
 
    /* Update lastchange time if required */
    if (SetLastChange)
    {
        NeedUpdate = TRUE;
        capFcb->LastChangeTime.QuadPart = CurrentTime.QuadPart;
        FileBasicInfo.ChangeTime.QuadPart = CurrentTime.QuadPart;
    }
 
    /* If one of the date was modified, issue a call to mini-rdr */
    if (NeedUpdate)
    {
        RxContext->Info.FileInformationClass = FileBasicInformation;
        RxContext->Info.Buffer = &FileBasicInfo;
        RxContext->Info.Length = sizeof(FileBasicInfo);
 
        MINIRDR_CALL(Status, RxContext, capFcb->MRxDispatch, MRxSetFileInfoAtCleanup, (RxContext));
        (void)Status;
    }
 
    /* If the file was modified, update its EOF */
    if (FileModified)
    {
        FileEOFInfo.EndOfFile.QuadPart = capFcb->Header.FileSize.QuadPart;
 
        RxContext->Info.FileInformationClass = FileEndOfFileInformation;
        RxContext->Info.Buffer = &FileEOFInfo;
        RxContext->Info.Length = sizeof(FileEOFInfo);
 
        MINIRDR_CALL(Status, RxContext, capFcb->MRxDispatch, MRxSetFileInfoAtCleanup, (RxContext));
        (void)Status;
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxAllocateCanonicalNameBuffer(
    PRX_CONTEXT RxContext,
    PUNICODE_STRING CanonicalName,
    USHORT CanonicalLength)
{
    PAGED_CODE();
 
    DPRINT("RxContext: %p - CanonicalNameBuffer: %p\n", RxContext, RxContext->Create.CanonicalNameBuffer);
 
    /* Context must be free of any already allocated name */
    ASSERT(RxContext->Create.CanonicalNameBuffer == NULL);
 
    /* Validate string length */
    if (CanonicalLength > USHRT_MAX - 1)
    {
        CanonicalName->Buffer = NULL;
        return STATUS_OBJECT_PATH_INVALID;
    }
 
    CanonicalName->Buffer = RxAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION, CanonicalLength, RX_MISC_POOLTAG);
    if (CanonicalName->Buffer == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    CanonicalName->Length = 0;
    CanonicalName->MaximumLength = CanonicalLength;
 
    /* Set the two places - they must always be identical */
    RxContext->Create.CanonicalNameBuffer = CanonicalName->Buffer;
    RxContext->AlsoCanonicalNameBuffer = CanonicalName->Buffer;
 
    return STATUS_SUCCESS;
}
 
/*
 * @implemented
 */
VOID
RxCancelNotifyChangeDirectoryRequestsForFobx(
   PFOBX Fobx)
{
    KIRQL OldIrql;
    PLIST_ENTRY Entry;
    PRX_CONTEXT Context;
    LIST_ENTRY ContextsToCancel;
 
    /* Init a list for the contexts to cancel */
    InitializeListHead(&ContextsToCancel);
 
    /* Lock our list lock */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
 
    /* Now, browse all the active contexts, to find the associated ones */
    Entry = RxActiveContexts.Flink;
    while (Entry != &RxActiveContexts)
    {
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, ContextListEntry);
        Entry = Entry->Flink;
 
        /* Not the IRP we're looking for, ignore */
        if (Context->MajorFunction != IRP_MJ_DIRECTORY_CONTROL ||
            Context->MinorFunction != IRP_MN_NOTIFY_CHANGE_DIRECTORY)
        {
            continue;
        }
 
        /* Not the FOBX we're looking for, ignore */
        if ((PFOBX)Context->pFobx != Fobx)
        {
            continue;
        }
 
        /* No cancel routine (can't be cancel, then), ignore */
        if (Context->MRxCancelRoutine == NULL)
        {
            continue;
        }
 
        /* Mark our context as cancelled */
        SetFlag(Context->Flags, RX_CONTEXT_FLAG_CANCELLED);
 
        /* Move it to our list */
        RemoveEntryList(&Context->ContextListEntry);
        InsertTailList(&ContextsToCancel, &Context->ContextListEntry);
 
        InterlockedIncrement((volatile long *)&Context->ReferenceCount);
    }
 
    /* Done with the contexts */
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    /* Now, handle all our "extracted" contexts */
    while (!IsListEmpty(&ContextsToCancel))
    {
        Entry = RemoveHeadList(&ContextsToCancel);
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, ContextListEntry);
 
        /* If they had an associated IRP (should be always true) */
        if (Context->CurrentIrp != NULL)
        {
            /* Then, call cancel routine */
            ASSERT(Context->MRxCancelRoutine != NULL);
            DPRINT1("Canceling %p with %p\n", Context, Context->MRxCancelRoutine);
            Context->MRxCancelRoutine(Context);
        }
 
        /* And delete the context */
        RxDereferenceAndDeleteRxContext(Context);
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxCancelNotifyChangeDirectoryRequestsForVNetRoot(
   PV_NET_ROOT VNetRoot,
   BOOLEAN ForceFilesClosed)
{
    KIRQL OldIrql;
    NTSTATUS Status;
    PLIST_ENTRY Entry;
    PRX_CONTEXT Context;
    LIST_ENTRY ContextsToCancel;
 
    /* Init a list for the contexts to cancel */
    InitializeListHead(&ContextsToCancel);
 
    /* Lock our list lock */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Now, browse all the active contexts, to find the associated ones */
    Entry = RxActiveContexts.Flink;
    while (Entry != &RxActiveContexts)
    {
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, ContextListEntry);
        Entry = Entry->Flink;
 
        /* Not the IRP we're looking for, ignore */
        if (Context->MajorFunction != IRP_MJ_DIRECTORY_CONTROL ||
            Context->MinorFunction != IRP_MN_NOTIFY_CHANGE_DIRECTORY)
        {
            continue;
        }
 
        /* Not the VNetRoot we're looking for, ignore */
        if (Context->pFcb == NULL ||
            (PV_NET_ROOT)Context->NotifyChangeDirectory.pVNetRoot != VNetRoot)
        {
            continue;
        }
 
        /* No cancel routine (can't be cancel, then), ignore */
        if (Context->MRxCancelRoutine == NULL)
        {
            continue;
        }
 
        /* At that point, we found a matching context
         * If we're not asked to force close, then fail - it's still open
         */
        if (!ForceFilesClosed)
        {
            Status = STATUS_FILES_OPEN;
            break;
        }
 
        /* Mark our context as cancelled */
        SetFlag(Context->Flags, RX_CONTEXT_FLAG_CANCELLED);
 
        /* Move it to our list */
        RemoveEntryList(&Context->ContextListEntry);
        InsertTailList(&ContextsToCancel, &Context->ContextListEntry);
 
        InterlockedIncrement((volatile long *)&Context->ReferenceCount);
    }
 
    /* Done with the contexts */
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    if (Status != STATUS_SUCCESS)
    {
        return Status;
    }
 
    /* Now, handle all our "extracted" contexts */
    while (!IsListEmpty(&ContextsToCancel))
    {
        Entry = RemoveHeadList(&ContextsToCancel);
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, ContextListEntry);
 
        /* If they had an associated IRP (should be always true) */
        if (Context->CurrentIrp != NULL)
        {
            /* Then, call cancel routine */
            ASSERT(Context->MRxCancelRoutine != NULL);
            DPRINT1("Canceling %p with %p\n", Context, Context->MRxCancelRoutine);
            Context->MRxCancelRoutine(Context);
        }
 
        /* And delete the context */
        RxDereferenceAndDeleteRxContext(Context);
    }
 
    return Status;
}
 
/*
 * @implemented
 */
BOOLEAN
RxCancelOperationInOverflowQueue(
    PRX_CONTEXT RxContext)
{
    KIRQL OldIrql;
    BOOLEAN OperationToCancel;
 
    /* By default, nothing cancelled */
    OperationToCancel = FALSE;
 
    /* Acquire the overflow spinlock */
    KeAcquireSpinLock(&RxFileSystemDeviceObject->OverflowQueueSpinLock, &OldIrql);
 
    /* Is our context in any queue? */
    if (BooleanFlagOn(RxContext->Flags, (RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE | RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE)))
    {
        /* Make sure flag is consistent with facts... */
        if (RxContext->OverflowListEntry.Flink != NULL)
        {
            /* Remove it from the list */
            RemoveEntryList(&RxContext->OverflowListEntry);
            RxContext->OverflowListEntry.Flink = NULL;
 
            /* Decrement appropriate count */
            if (BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE))
            {
                --RxFileSystemDeviceObject->OverflowQueueCount[CriticalWorkQueue];
            }
            else
            {
                --RxFileSystemDeviceObject->OverflowQueueCount[DelayedWorkQueue];
            }
 
            /* Clear the flag */
            ClearFlag(RxContext->Flags, ~(RX_CONTEXT_FLAG_FSP_DELAYED_OVERFLOW_QUEUE | RX_CONTEXT_FLAG_FSP_CRITICAL_OVERFLOW_QUEUE));
 
            /* Time to cancel! */
            OperationToCancel = TRUE;
        }
    }
 
    KeReleaseSpinLock(&RxFileSystemDeviceObject->OverflowQueueSpinLock, OldIrql);
 
    /* We have something to cancel & complete */
    if (OperationToCancel)
    {
        RxRemoveOperationFromBlockingQueue(RxContext);
        RxCompleteRequest(RxContext, STATUS_CANCELLED);
    }
 
    return OperationToCancel;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxCancelRoutine(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp)
{
    KIRQL OldIrql;
    PLIST_ENTRY Entry;
    PRX_CONTEXT RxContext;
 
    /* Lock our contexts list */
    KeAcquireSpinLock(&RxStrucSupSpinLock, &OldIrql);
 
    /* Now, find a context that matches the cancelled IRP */
    Entry = RxActiveContexts.Flink;
    while (Entry != &RxActiveContexts)
    {
        RxContext = CONTAINING_RECORD(Entry, RX_CONTEXT, ContextListEntry);
        Entry = Entry->Flink;
 
        /* Found! */
        if (RxContext->CurrentIrp == Irp)
        {
            break;
        }
    }
 
    /* If we reached the end of the list, we didn't find any context, so zero the buffer
     * If the context is already under cancellation, forget about it too
     */
    if (Entry == &RxActiveContexts || BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_CANCELLED))
    {
        RxContext = NULL;
    }
    else
    {
        /* Otherwise, reference it and mark it cancelled */
        SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_CANCELLED);
        InterlockedIncrement((volatile long *)&RxContext->ReferenceCount);
    }
 
    /* Done with the contexts list */
    KeReleaseSpinLock(&RxStrucSupSpinLock, OldIrql);
 
    /* And done with the cancellation, we'll do it now */
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* If we have a context to cancel */
    if (RxContext != NULL)
    {
        /* We cannot executed at dispatch, so queue a deferred cancel */
        if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
        {
            RxDispatchToWorkerThread(RxFileSystemDeviceObject, CriticalWorkQueue, RxpCancelRoutine, RxContext);
        }
        /* Cancel now! */
        else
        {
            RxpCancelRoutine(RxContext);
        }
    }
}
 
/*
 * @implemented
 */
NTSTATUS
RxCanonicalizeFileNameByServerSpecs(
    PRX_CONTEXT RxContext,
    PUNICODE_STRING NetRootName)
{
    USHORT NextChar, CurChar;
    USHORT MaxChars;
 
    PAGED_CODE();
 
    /* Validate file name is not empty */
    MaxChars = NetRootName->Length / sizeof(WCHAR);
    if (MaxChars == 0)
    {
        return STATUS_MORE_PROCESSING_REQUIRED;
    }
 
    /* Validate name is correct */
    for (NextChar = 0, CurChar = 0; CurChar + 1 < MaxChars; NextChar = CurChar + 1)
    {
        USHORT i;
 
        for (i = NextChar + 1; i < MaxChars; ++i)
        {
            if (NetRootName->Buffer[i] == '\\' || NetRootName->Buffer[i] == ':')
            {
                break;
            }
        }
 
        CurChar = i - 1;
        if (CurChar == NextChar)
        {
            if (((NetRootName->Buffer[NextChar] != '\\' && NetRootName->Buffer[NextChar] != ':') || NextChar == (MaxChars - 1)) && NetRootName->Buffer[NextChar] != '.')
            {
                continue;
            }
 
            if (CurChar != 0)
            {
                if (CurChar >= MaxChars - 1)
                {
                    continue;
                }
 
                if (NetRootName->Buffer[CurChar + 1] != ':')
                {
                    return STATUS_OBJECT_PATH_SYNTAX_BAD;
                }
            }
            else
            {
                if (NetRootName->Buffer[1] != ':')
                {
                    return STATUS_OBJECT_PATH_SYNTAX_BAD;
                }
            }
        }
        else
        {
            if ((CurChar - NextChar) == 1)
            {
                if (NetRootName->Buffer[NextChar + 2] != '.')
                {
                    continue;
                }
 
                if (NetRootName->Buffer[NextChar] == '\\' || NetRootName->Buffer[NextChar] == ':' || NetRootName->Buffer[NextChar] == '.')
                {
                    return STATUS_OBJECT_PATH_SYNTAX_BAD;
                }
            }
            else
            {
                if ((CurChar - NextChar) != 2 || (NetRootName->Buffer[NextChar] != '\\' && NetRootName->Buffer[NextChar] != ':')
                    || NetRootName->Buffer[NextChar + 1] != '.')
                {
                    continue;
                }
 
                if (NetRootName->Buffer[NextChar + 2] == '.')
                {
                    return STATUS_OBJECT_PATH_SYNTAX_BAD;
                }
            }
        }
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}
 
NTSTATUS
RxCanonicalizeNameAndObtainNetRoot(
    PRX_CONTEXT RxContext,
    PUNICODE_STRING FileName,
    PUNICODE_STRING NetRootName)
{
    NTSTATUS Status;
    NET_ROOT_TYPE NetRootType;
    UNICODE_STRING CanonicalName;
 
    RxCaptureParamBlock;
    RxCaptureFileObject;
 
    PAGED_CODE();
 
    NetRootType = NET_ROOT_WILD;
 
    RtlInitEmptyUnicodeString(NetRootName, NULL, 0);
    RtlInitEmptyUnicodeString(&CanonicalName, NULL, 0);
 
    /* if not relative opening, just handle the passed name */
    if (capFileObject->RelatedFileObject == NULL)
    {
        Status = RxFirstCanonicalize(RxContext, FileName, &CanonicalName, &NetRootType);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
    else
    {
        PFCB Fcb;
 
        /* Make sure we have a valid FCB and a FOBX */
        Fcb = capFileObject->RelatedFileObject->FsContext;
        if (Fcb == NULL || capFileObject->RelatedFileObject->FsContext2 == NULL)
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        if (!NodeTypeIsFcb(Fcb))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        UNIMPLEMENTED;
    }
 
    /* Get/Create the associated VNetRoot for opening */
    Status = RxFindOrConstructVirtualNetRoot(RxContext, &CanonicalName, NetRootType, NetRootName);
    if (!NT_SUCCESS(Status) && Status != STATUS_PENDING &&
        BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_MAILSLOT_REPARSE))
    {
        ASSERT(CanonicalName.Buffer == RxContext->Create.CanonicalNameBuffer);
 
        RxFreeCanonicalNameBuffer(RxContext);
        Status = RxFirstCanonicalize(RxContext, FileName, &CanonicalName, &NetRootType);
        if (NT_SUCCESS(Status))
        {
            Status = RxFindOrConstructVirtualNetRoot(RxContext, &CanonicalName, NetRootType, NetRootName);
        }
    }
 
    /* Filename cannot contain wildcards */
    if (FsRtlDoesNameContainWildCards(NetRootName))
    {
        Status = STATUS_OBJECT_NAME_INVALID;
    }
 
    /* Make sure file name is correct */
    if (NT_SUCCESS(Status))
    {
        Status = RxCanonicalizeFileNameByServerSpecs(RxContext, NetRootName);
    }
 
    /* Give the mini-redirector a chance to prepare the name */
    if (NT_SUCCESS(Status) || Status == STATUS_MORE_PROCESSING_REQUIRED)
    {
        if (RxContext->Create.pNetRoot != NULL)
        {
            NTSTATUS IgnoredStatus;
 
            MINIRDR_CALL(IgnoredStatus, RxContext, RxContext->Create.pNetRoot->pSrvCall->RxDeviceObject->Dispatch,
                         MRxPreparseName, (RxContext, NetRootName));
            (void)IgnoredStatus;
        }
    }
 
    return Status;
}
 
/*
 * @implemented
 */
VOID
NTAPI
RxCheckFcbStructuresForAlignment(
    VOID)
{
    PAGED_CODE();
}
 
#if DBG
NTSTATUS
RxCheckShareAccess(
    _In_ ACCESS_MASK DesiredAccess,
    _In_ ULONG DesiredShareAccess,
    _Inout_ PFILE_OBJECT FileObject,
    _Inout_ PSHARE_ACCESS ShareAccess,
    _In_ BOOLEAN Update,
    _In_ PSZ where,
    _In_ PSZ wherelogtag)
{
    PAGED_CODE();
 
    RxDumpWantedAccess(where, "", wherelogtag, DesiredAccess, DesiredShareAccess);
    RxDumpCurrentAccess(where, "", wherelogtag, ShareAccess);
 
    return IoCheckShareAccess(DesiredAccess, DesiredShareAccess, FileObject, ShareAccess, Update);
}
#endif
 
/*
 * @implemented
 */
NTSTATUS
RxCheckShareAccessPerSrvOpens(
    IN PFCB Fcb,
    IN ACCESS_MASK DesiredAccess,
    IN ULONG DesiredShareAccess)
{
    BOOLEAN ReadAccess;
    BOOLEAN WriteAccess;
    BOOLEAN DeleteAccess;
    PSHARE_ACCESS ShareAccess;
 
    PAGED_CODE();
 
    ShareAccess = &Fcb->ShareAccessPerSrvOpens;
 
    RxDumpWantedAccess("RxCheckShareAccessPerSrvOpens", "", "RxCheckShareAccessPerSrvOpens", DesiredAccess, DesiredShareAccess);
    RxDumpCurrentAccess("RxCheckShareAccessPerSrvOpens", "", "RxCheckShareAccessPerSrvOpens", ShareAccess);
 
    /* Check if any access wanted */
    ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE)) != 0;
    WriteAccess = (DesiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0;
    DeleteAccess = (DesiredAccess & DELETE) != 0;
 
    if (ReadAccess || WriteAccess || DeleteAccess)
    {
        BOOLEAN SharedRead = (DesiredShareAccess & FILE_SHARE_READ) != 0;
        BOOLEAN SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE) != 0;
        BOOLEAN SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE) != 0;
 
        /* Check whether there's a violation */
        if ((ReadAccess &&
             (ShareAccess->SharedRead < ShareAccess->OpenCount)) ||
            (WriteAccess &&
             (ShareAccess->SharedWrite < ShareAccess->OpenCount)) ||
            (DeleteAccess &&
             (ShareAccess->SharedDelete < ShareAccess->OpenCount)) ||
            ((ShareAccess->Readers != 0) && !SharedRead) ||
            ((ShareAccess->Writers != 0) && !SharedWrite) ||
            ((ShareAccess->Deleters != 0) && !SharedDelete))
        {
            return STATUS_SHARING_VIOLATION;
        }
    }
 
    return STATUS_SUCCESS;
}
 
VOID
RxCleanupPipeQueues(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
RxCloseAssociatedSrvOpen(
    IN PFOBX Fobx,
    IN PRX_CONTEXT RxContext OPTIONAL)
{
    PFCB Fcb;
    NTSTATUS Status;
    PSRV_OPEN SrvOpen;
    BOOLEAN CloseSrvOpen;
    PRX_CONTEXT LocalContext;
 
    PAGED_CODE();
 
    /* Assume SRV_OPEN is already closed */
    CloseSrvOpen = FALSE;
    /* If we have a FOBX, we'll have to close it */
    if (Fobx != NULL)
    {
        /* If the FOBX isn't closed yet */
        if (!BooleanFlagOn(Fobx->Flags, FOBX_FLAG_SRVOPEN_CLOSED))
        {
            SrvOpen = Fobx->SrvOpen;
            Fcb = (PFCB)SrvOpen->pFcb;
            /* Check whether we've to close SRV_OPEN first */
            if (!BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_CLOSED))
            {
                CloseSrvOpen = TRUE;
            }
            else
            {
                ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
                /* Not much to do */
                SetFlag(Fobx->Flags, FOBX_FLAG_SRVOPEN_CLOSED);
 
                if (SrvOpen->OpenCount > 0)
                {
                    --SrvOpen->OpenCount;
                }
            }
        }
 
        /* No need to close SRV_OPEN, so close FOBX */
        if (!CloseSrvOpen)
        {
            RxMarkFobxOnClose(Fobx);
 
            return STATUS_SUCCESS;
        }
    }
    else
    {
        /* No FOBX? No RX_CONTEXT, ok, job done! */
        if (RxContext == NULL)
        {
            return STATUS_SUCCESS;
        }
 
        /* Get the FCB from RX_CONTEXT */
        Fcb = (PFCB)RxContext->pFcb;
        SrvOpen = NULL;
    }
 
    /* If we don't have RX_CONTEXT, allocte one, we'll need it */
    if (RxContext == NULL)
    {
        ASSERT(Fobx != NULL);
 
        LocalContext = RxCreateRxContext(NULL, Fcb->RxDeviceObject, RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING | RX_CONTEXT_FLAG_WAIT);
        if (LocalContext == NULL)
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        LocalContext->MajorFunction = 2;
        LocalContext->pFcb = RX_GET_MRX_FCB(Fcb);
        LocalContext->pFobx = (PMRX_FOBX)Fobx;
        LocalContext->pRelevantSrvOpen = (PMRX_SRV_OPEN)Fobx->SrvOpen;
    }
    else
    {
        LocalContext = RxContext;
    }
 
    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
    /* Now, close the FOBX */
    if (Fobx != NULL)
    {
        RxMarkFobxOnClose(Fobx);
    }
    else
    {
        InterlockedDecrement((volatile long *)&Fcb->OpenCount);
    }
 
    /* If not a "standard" file, SRV_OPEN can be null */
    if (SrvOpen == NULL)
    {
        ASSERT((NodeType(Fcb) == RDBSS_NTC_OPENTARGETDIR_FCB) || (NodeType(Fcb) == RDBSS_NTC_IPC_SHARE) || (NodeType(Fcb) == RDBSS_NTC_MAILSLOT));
        RxDereferenceNetFcb(Fcb);
 
        if (LocalContext != RxContext)
        {
            RxDereferenceAndDeleteRxContext(LocalContext);
        }
 
        return STATUS_SUCCESS;
    }
 
    /* If SRV_OPEN isn't in a good condition, nothing to close */
    if (SrvOpen->Condition != Condition_Good)
    {
        if (LocalContext != RxContext)
        {
            RxDereferenceAndDeleteRxContext(LocalContext);
        }
 
        return STATUS_SUCCESS;
    }
 
    /* Decrease open count */
    if (SrvOpen->OpenCount > 0)
    {
        --SrvOpen->OpenCount;
    }
 
    /* If we're the only one left, is there a FOBX handled by Scavenger? */
    if (SrvOpen->OpenCount == 1)
    {
        if (!IsListEmpty(&SrvOpen->FobxList))
        {
            if (!IsListEmpty(&CONTAINING_RECORD(SrvOpen->FobxList.Flink, FOBX, FobxQLinks)->ScavengerFinalizationList))
            {
                SetFlag(SrvOpen->Flags, SRVOPEN_FLAG_CLOSE_DELAYED);
            }
        }
    }
 
    /* Nothing left, purge FCB */
    if (SrvOpen->OpenCount == 0 && RxContext == NULL)
    {
        RxPurgeNetFcb(Fcb, LocalContext);
    }
 
    /* Already closed? Job done! */
    SrvOpen = Fobx->SrvOpen;
    if (SrvOpen == NULL ||
        (SrvOpen->OpenCount != 0 && !BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_BUFFERING_STATE_CHANGE_PENDING)) ||
        BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_CLOSED))
    {
        SetFlag(Fobx->Flags, FOBX_FLAG_SRVOPEN_CLOSED);
        if (LocalContext != RxContext)
        {
            RxDereferenceAndDeleteRxContext(LocalContext);
        }
 
        return STATUS_SUCCESS;
    }
 
    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
    /* Inform mini-rdr about closing */
    MINIRDR_CALL(Status, LocalContext, Fcb->MRxDispatch, MRxCloseSrvOpen, (LocalContext));
    DPRINT("MRxCloseSrvOpen returned: %lx, called with RX_CONTEXT %p for FOBX %p (FCB %p, SRV_OPEN %p)\n ",
           Status, RxContext, Fobx, Fcb, SrvOpen);
 
    /* And mark as such */
    SetFlag(SrvOpen->Flags, SRVOPEN_FLAG_CLOSED);
    SrvOpen->Key = (PVOID)-1;
 
    /* If we were delayed, we're not! */
    if (BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_CLOSE_DELAYED))
    {
        InterlockedDecrement(&((PSRV_CALL)Fcb->pNetRoot->pSrvCall)->NumberOfCloseDelayedFiles);
    }
 
    /* Clear access */
    RxRemoveShareAccessPerSrvOpens(SrvOpen);
    RxPurgeChangeBufferingStateRequestsForSrvOpen(SrvOpen);
 
    /* Dereference */
    RxDereferenceSrvOpen(SrvOpen, LHS_ExclusiveLockHeld);
 
    /* Mark the FOBX closed as well */
    SetFlag(Fobx->Flags, FOBX_FLAG_SRVOPEN_CLOSED);
 
    if (LocalContext != RxContext)
    {
        RxDereferenceAndDeleteRxContext(LocalContext);
    }
 
    return Status;
}
 
/*
 * @implemented
 */
NTSTATUS
RxCollapseOrCreateSrvOpen(
    PRX_CONTEXT RxContext)
{
    NTSTATUS Status;
    ULONG Disposition;
    PSRV_OPEN SrvOpen;
    USHORT ShareAccess;
    ACCESS_MASK DesiredAccess;
    RX_BLOCK_CONDITION FcbCondition;
 
    RxCaptureFcb;
    RxCaptureParamBlock;
 
    PAGED_CODE();
 
    DPRINT("RxCollapseOrCreateSrvOpen(%p)\n", RxContext);
 
    ASSERT(RxIsFcbAcquiredExclusive(capFcb));
    ++capFcb->UncleanCount;
 
    DesiredAccess = capPARAMS->Parameters.Create.SecurityContext->DesiredAccess & FILE_ALL_ACCESS;
    ShareAccess = capPARAMS->Parameters.Create.ShareAccess & FILE_SHARE_VALID_FLAGS;
 
    Disposition = RxContext->Create.NtCreateParameters.Disposition;
 
    /* Try to find a reusable SRV_OPEN */
    Status = RxSearchForCollapsibleOpen(RxContext, DesiredAccess, ShareAccess);
    if (Status == STATUS_NOT_FOUND)
    {
        /* If none found, create one */
        SrvOpen = RxCreateSrvOpen((PV_NET_ROOT)RxContext->Create.pVNetRoot, capFcb);
        if (SrvOpen == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
        else
        {
            SrvOpen->DesiredAccess = DesiredAccess;
            SrvOpen->ShareAccess = ShareAccess;
            Status = STATUS_SUCCESS;
        }
 
        RxContext->pRelevantSrvOpen = (PMRX_SRV_OPEN)SrvOpen;
 
        if (Status != STATUS_SUCCESS)
        {
            FcbCondition = Condition_Bad;
        }
        else
        {
            RxInitiateSrvOpenKeyAssociation(SrvOpen);
 
            /* Cookie to check the mini-rdr doesn't mess with RX_CONTEXT */
            RxContext->CurrentIrp->IoStatus.Information = 0xABCDEF;
            /* Inform the mini-rdr we're handling a create */
            MINIRDR_CALL(Status, RxContext, capFcb->MRxDispatch, MRxCreate, (RxContext));
            ASSERT(RxContext->CurrentIrp->IoStatus.Information == 0xABCDEF);
 
            DPRINT("MRxCreate returned: %x\n", Status);
            if (Status == STATUS_SUCCESS)
            {
                /* In case of overwrite, reset file size */
                if (Disposition == FILE_OVERWRITE || Disposition == FILE_OVERWRITE_IF)
                {
                    RxAcquirePagingIoResource(RxContext, capFcb);
                    capFcb->Header.AllocationSize.QuadPart = 0LL;
                    capFcb->Header.FileSize.QuadPart = 0LL;
                    capFcb->Header.ValidDataLength.QuadPart = 0LL;
                    RxContext->CurrentIrpSp->FileObject->SectionObjectPointer = &capFcb->NonPaged->SectionObjectPointers;
                    CcSetFileSizes(RxContext->CurrentIrpSp->FileObject, (PCC_FILE_SIZES)&capFcb->Header.AllocationSize);
                    RxReleasePagingIoResource(RxContext, capFcb);
                }
                else
                {
                    /* Otherwise, adjust sizes */
                    RxContext->CurrentIrpSp->FileObject->SectionObjectPointer = &capFcb->NonPaged->SectionObjectPointers;
                    if (CcIsFileCached(RxContext->CurrentIrpSp->FileObject))
                    {
                        RxAdjustAllocationSizeforCC(capFcb);
                    }
                    CcSetFileSizes(RxContext->CurrentIrpSp->FileObject, (PCC_FILE_SIZES)&capFcb->Header.AllocationSize);
                }
            }
 
            /* Set the IoStatus with information returned by mini-rdr */
            RxContext->CurrentIrp->IoStatus.Information = RxContext->Create.ReturnedCreateInformation;
 
            SrvOpen->OpenStatus = Status;
            /* Set SRV_OPEN state - good or bad - depending on whether create succeed */
            RxTransitionSrvOpen(SrvOpen, (Status == STATUS_SUCCESS ? Condition_Good : Condition_Bad));
 
            ASSERT(RxIsFcbAcquiredExclusive(capFcb));
 
            RxCompleteSrvOpenKeyAssociation(SrvOpen);
 
            if (Status == STATUS_SUCCESS)
            {
                if (BooleanFlagOn(capPARAMS->Parameters.Create.Options, FILE_DELETE_ON_CLOSE))
                {
                    ClearFlag(capFcb->FcbState, FCB_STATE_COLLAPSING_ENABLED);
                }
                SrvOpen->CreateOptions = RxContext->Create.NtCreateParameters.CreateOptions;
                FcbCondition = Condition_Good;
            }
            else
            {
                FcbCondition = Condition_Bad;
                RxDereferenceSrvOpen(SrvOpen, LHS_ExclusiveLockHeld);
                RxContext->pRelevantSrvOpen = NULL;
 
                if (RxContext->pFobx != NULL)
                {
                    RxDereferenceNetFobx(RxContext->pFobx, LHS_ExclusiveLockHeld);
                    RxContext->pFobx = NULL;
                }
            }
        }
 
        /* Set FCB state -  good or bad - depending on whether create succeed */
        DPRINT("Transitioning FCB %p to condition %lx\n", capFcb, capFcb->Condition);
        RxTransitionNetFcb(capFcb, FcbCondition);
    }
    else if (Status == STATUS_SUCCESS)
    {
        BOOLEAN IsGood, ExtraOpen;
 
        /* A reusable SRV_OPEN was found */
        RxContext->CurrentIrp->IoStatus.Information = FILE_OPENED;
        ExtraOpen = FALSE;
 
        SrvOpen = (PSRV_OPEN)RxContext->pRelevantSrvOpen;
 
        IsGood = (SrvOpen->Condition == Condition_Good);
        /* If the SRV_OPEN isn't in a stable situation, wait for it to become stable */
        if (!StableCondition(SrvOpen->Condition))
        {
            RxReferenceSrvOpen(SrvOpen);
            ++SrvOpen->OpenCount;
            ExtraOpen = TRUE;
 
            RxReleaseFcb(RxContext, capFcb);
            RxContext->Create.FcbAcquired = FALSE;
 
            RxWaitForStableSrvOpen(SrvOpen, RxContext);
 
            if (NT_SUCCESS(RxAcquireExclusiveFcb(RxContext, capFcb)))
            {
                RxContext->Create.FcbAcquired = TRUE;
            }
 
            IsGood = (SrvOpen->Condition == Condition_Good);
        }
 
        /* Inform the mini-rdr we do an opening with a reused SRV_OPEN */
        if (IsGood)
        {
            MINIRDR_CALL(Status, RxContext, capFcb->MRxDispatch, MRxCollapseOpen, (RxContext));
 
            ASSERT(RxIsFcbAcquiredExclusive(capFcb));
        }
        else
        {
            Status = SrvOpen->OpenStatus;
        }
 
        if (ExtraOpen)
        {
            --SrvOpen->OpenCount;
            RxDereferenceSrvOpen(SrvOpen, LHS_ExclusiveLockHeld);
        }
    }
 
    --capFcb->UncleanCount;
 
    DPRINT("Status: %x\n", Status);
    return Status;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonCleanup(
    PRX_CONTEXT Context)
{
#define BugCheckFileId RDBSS_BUG_CHECK_CLEANUP
    PFCB Fcb;
    PFOBX Fobx;
    ULONG OpenCount;
    NTSTATUS Status;
    PNET_ROOT NetRoot;
    PFILE_OBJECT FileObject;
    LARGE_INTEGER TruncateSize;
    PLARGE_INTEGER TruncateSizePtr;
    BOOLEAN NeedPurge, FcbTableAcquired, OneLeft, IsFile, FcbAcquired, LeftForDelete;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
    DPRINT("RxCommonCleanup(%p); FOBX: %p, FCB: %p\n", Context, Fobx, Fcb);
 
    /* File system closing, it's OK */
    if (Fobx == NULL)
    {
        if (Fcb->UncleanCount > 0)
        {
            InterlockedDecrement((volatile long *)&Fcb->UncleanCount);
        }
 
        return STATUS_SUCCESS;
    }
 
    /* Check we have a correct FCB type */
    if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_FILE &&
        NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY &&
        NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_UNKNOWN &&
        NodeType(Fcb) != RDBSS_NTC_SPOOLFILE)
    {
        DPRINT1("Invalid Fcb type for %p\n", Fcb);
        RxBugCheck(Fcb->Header.NodeTypeCode, 0, 0);
    }
 
    FileObject = Context->CurrentIrpSp->FileObject;
    ASSERT(!BooleanFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE));
 
    RxMarkFobxOnCleanup(Fobx, &NeedPurge);
 
    Status = RxAcquireExclusiveFcb(Context, Fcb);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    FcbAcquired = TRUE;
 
    Fobx->AssociatedFileObject = NULL;
 
    /* In case it was already orphaned */
    if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_ORPHANED))
    {
        ASSERT(Fcb->UncleanCount != 0);
        InterlockedDecrement((volatile long *)&Fcb->UncleanCount);
 
        if (BooleanFlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING))
        {
            --Fcb->UncachedUncleanCount;
        }
 
        /* Inform mini-rdr */
        MINIRDR_CALL(Status, Context, Fcb->MRxDispatch, MRxCleanupFobx, (Context));
 
        ASSERT(Fobx->SrvOpen->UncleanFobxCount != 0);
        --Fobx->SrvOpen->UncleanFobxCount;
 
        RxUninitializeCacheMap(Context, FileObject, NULL);
 
        RxReleaseFcb(Context, Fcb);
 
        return STATUS_SUCCESS;
    }
 
    /* Report the fact that file could be set as delete on close */
    if (BooleanFlagOn(Fobx->Flags, FOBX_FLAG_DELETE_ON_CLOSE))
    {
        SetFlag(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE);
    }
 
    /* Cancel any pending notification */
    RxCancelNotifyChangeDirectoryRequestsForFobx(Fobx);
 
    /* Backup open count before we start playing with it */
    OpenCount = Fcb->ShareAccess.OpenCount;
 
    NetRoot = (PNET_ROOT)Fcb->pNetRoot;
    FcbTableAcquired = FALSE;
    LeftForDelete = FALSE;
    OneLeft = (Fcb->UncleanCount == 1);
 
    _SEH2_TRY
    {
        /* Unclean count and delete on close? Verify whether we're the one */
        if (OneLeft && BooleanFlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE))
        {
            if (RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, FALSE))
            {
                FcbTableAcquired = TRUE;
            }
            else
            {
                RxReleaseFcb(Context, Fcb);
 
                RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, TRUE);
 
                Status = RxAcquireExclusiveFcb(Context, Fcb);
                if (Status != STATUS_SUCCESS)
                {
                    RxReleaseFcbTableLock(&NetRoot->FcbTable);
                    return Status;
                }
 
                FcbTableAcquired = TRUE;
            }
 
            /* That means we'll perform the delete on close! */
            if (Fcb->UncleanCount == 1)
            {
                LeftForDelete = TRUE;
            }
            else
            {
                RxReleaseFcbTableLock(&NetRoot->FcbTable);
                FcbTableAcquired = FALSE;
            }
        }
 
        IsFile = FALSE;
        TruncateSizePtr = NULL;
        /* Handle cleanup for pipes and printers */
        if (NetRoot->Type == NET_ROOT_PIPE || NetRoot->Type == NET_ROOT_PRINT)
        {
            RxCleanupPipeQueues(Context);
        }
        /* Handle cleanup for files */
        else if (NetRoot->Type == NET_ROOT_DISK || NetRoot->Type == NET_ROOT_WILD)
        {
            Context->LowIoContext.Flags |= LOWIO_CONTEXT_FLAG_SAVEUNLOCKS;
            if (NodeType(Fcb) == RDBSS_NTC_STORAGE_TYPE_FILE)
            {
                /* First, unlock */
                FsRtlFastUnlockAll(&Fcb->Specific.Fcb.FileLock, FileObject, RxGetRequestorProcess(Context), Context);
 
                /* If there are still locks to release, proceed */
                if (Context->LowIoContext.ParamsFor.Locks.LockList != NULL)
                {
                    RxInitializeLowIoContext(&Context->LowIoContext, LOWIO_OP_UNLOCK_MULTIPLE);
                    Context->LowIoContext.ParamsFor.Locks.Flags = 0;
                    Status = RxLowIoLockControlShell(Context);
                }
 
                /* Fix times and size */
                RxAdjustFileTimesAndSize(Context);
 
                /* If we're the only one left... */
                if (OneLeft)
                {
                    /* And if we're supposed to delete on close */
                    if (LeftForDelete)
                    {
                        /* Update the sizes */
                        RxAcquirePagingIoResource(Context, Fcb);
                        Fcb->Header.FileSize.QuadPart = 0;
                        Fcb->Header.ValidDataLength.QuadPart = 0;
                        RxReleasePagingIoResource(Context, Fcb);
                    }
                    /* Otherwise, call the mini-rdr to adjust sizes */
                    else
                    {
                        /* File got grown up, fill with zeroes */
                        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE) &&
                            (Fcb->Header.ValidDataLength.QuadPart < Fcb->Header.FileSize.QuadPart))
                        {
                            MINIRDR_CALL(Status, Context, Fcb->MRxDispatch, MRxZeroExtend, (Context));
                            Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
                        }
 
                        /* File was truncated, let mini-rdr proceed */
                        if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_TRUNCATE_ON_CLOSE))
                        {
                            MINIRDR_CALL(Status, Context, Fcb->MRxDispatch, MRxTruncate, (Context));
                            ClearFlag(Fcb->FcbState, FCB_STATE_TRUNCATE_ON_CLOSE);
 
                            /* Keep track of file change for Cc uninit */
                            TruncateSize.QuadPart = Fcb->Header.FileSize.QuadPart;
                            TruncateSizePtr = &TruncateSize;
                        }
                    }
                }
 
                /* If RxMarkFobxOnCleanup() asked for purge, make sure we're the only one left first */
                if (NeedPurge)
                {
                    if (!OneLeft)
                    {
                        NeedPurge = FALSE;
                    }
                }
                /* Otherwise, try to see whether we can purge */
                else
                {
                    NeedPurge = (OneLeft && (LeftForDelete || !BooleanFlagOn(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED)));
                }
 
                IsFile = TRUE;
            }
        }
 
        /* We have to still be there! */
        ASSERT(Fcb->UncleanCount != 0);
        InterlockedDecrement((volatile long *)&Fcb->UncleanCount);
 
        if (BooleanFlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING))
        {
            --Fcb->UncachedUncleanCount;
        }
 
        /* Inform mini-rdr about ongoing cleanup */
        MINIRDR_CALL(Status, Context, Fcb->MRxDispatch, MRxCleanupFobx, (Context));
 
        ASSERT(Fobx->SrvOpen->UncleanFobxCount != 0);
        --Fobx->SrvOpen->UncleanFobxCount;
 
        /* Flush cache */
        if (DisableFlushOnCleanup)
        {
            /* Only if we're the last standing */
            if (Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL &&
                Fcb->UncleanCount == Fcb->UncachedUncleanCount)
            {
                DPRINT("Flushing %p due to last cached handle cleanup\n", Context);
                RxFlushFcbInSystemCache(Fcb, TRUE);
            }
        }
        else
        {
            /* Always */
            if (Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL)
            {
                DPRINT("Flushing %p on cleanup\n", Context);
                RxFlushFcbInSystemCache(Fcb, TRUE);
            }
        }
 
        /* If only remaining uncached & unclean, then flush and purge */
        if (!BooleanFlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING))
        {
            if (Fcb->UncachedUncleanCount != 0)
            {
                if (Fcb->UncachedUncleanCount == Fcb->UncleanCount &&
                    Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL)
                {
                    DPRINT("Flushing FCB in system cache for %p\n", Context);
                    RxPurgeFcbInSystemCache(Fcb, NULL, 0, FALSE, TRUE);
                }
            }
        }
 
        /* If purge required, and not about to delete, flush */
        if (!LeftForDelete && NeedPurge)
        {
            DPRINT("Flushing FCB in system cache for %p\n", Context);
            RxFlushFcbInSystemCache(Fcb, TRUE);
        }
 
        /* If it was a file, drop cache */
        if (IsFile)
        {
            DPRINT("Uninit cache map for file\n");
            RxUninitializeCacheMap(Context, FileObject, TruncateSizePtr);
        }
 
        /* If that's the one left for deletion, or if it needs purge, flush */
        if (LeftForDelete || NeedPurge)
        {
            RxPurgeFcbInSystemCache(Fcb, NULL, 0, FALSE, !LeftForDelete);
            /* If that's for deletion, also remove from FCB table */
            if (LeftForDelete)
            {
                RxRemoveNameNetFcb(Fcb);
                RxReleaseFcbTableLock(&NetRoot->FcbTable);
                FcbTableAcquired = FALSE;
            }
        }
 
        /* Remove any share access */
        if (OpenCount != 0 && NetRoot->Type == NET_ROOT_DISK)
        {
            RxRemoveShareAccess(FileObject, &Fcb->ShareAccess, "Cleanup the share access", "ClnUpShr");
        }
 
        /* In case there's caching, on a file, and we were asked to drop collapsing, handle it */
        if (NodeType(Fcb) == RDBSS_NTC_STORAGE_TYPE_FILE && BooleanFlagOn(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING) &&
            RxWriteCacheingAllowed(Fcb, Fobx->pSrvOpen))
        {
            NTSTATUS InternalStatus;
            PRX_CONTEXT InternalContext;
 
            /* If we can properly set EOF, there's no need to drop collapsing, try to do it */
            InternalStatus = STATUS_UNSUCCESSFUL;
            InternalContext = RxCreateRxContext(Context->CurrentIrp,
                                                Fcb->RxDeviceObject,
                                                RX_CONTEXT_FLAG_WAIT | RX_CONTEXT_FLAG_MUST_SUCCEED_NONBLOCKING);
            if (InternalContext != NULL)
            {
                FILE_END_OF_FILE_INFORMATION FileEOF;
 
                InternalStatus = STATUS_SUCCESS;
 
                /* Initialize the context for file information set */
                InternalContext->pFcb = RX_GET_MRX_FCB(Fcb);
                InternalContext->pFobx = (PMRX_FOBX)Fobx;
                InternalContext->pRelevantSrvOpen = Fobx->pSrvOpen;
 
                /* Get EOF from the FCB */
                FileEOF.EndOfFile.QuadPart = Fcb->Header.FileSize.QuadPart;
                InternalContext->Info.FileInformationClass = FileEndOfFileInformation;
                InternalContext->Info.Buffer = &FileEOF;
                InternalContext->Info.Length = sizeof(FileEOF);
 
                /* Call the mini-rdr */
                MINIRDR_CALL_THROUGH(InternalStatus, Fcb->MRxDispatch, MRxSetFileInfo, (InternalContext));
 
                /* We're done */
                RxDereferenceAndDeleteRxContext(InternalContext);
            }
 
            /* We tried, so, clean the FOBX flag */
            ClearFlag(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING);
            /* If it failed, then, disable collapsing on the FCB */
            if (!NT_SUCCESS(InternalStatus))
            {
                ClearFlag(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED);
            }
        }
 
        /* We're clean! */
        SetFlag(FileObject->Flags, FO_CLEANUP_COMPLETE);
 
        FcbAcquired = FALSE;
        RxReleaseFcb(Context, Fcb);
    }
    _SEH2_FINALLY
    {
        if (FcbAcquired)
        {
            RxReleaseFcb(Context, Fcb);
        }
 
        if (FcbTableAcquired)
        {
            RxReleaseFcbTableLock(&NetRoot->FcbTable);
        }
    }
    _SEH2_END;
 
    return Status;
#undef BugCheckFileId
}
 
NTSTATUS
NTAPI
RxCommonClose(
    PRX_CONTEXT Context)
{
#define BugCheckFileId RDBSS_BUG_CHECK_CLOSE
    PFCB Fcb;
    PFOBX Fobx;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    BOOLEAN DereferenceFobx, AcquiredFcb;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
    FileObject = Context->CurrentIrpSp->FileObject;
    DPRINT("RxCommonClose(%p); FOBX: %p, FCB: %p, FO: %p\n", Context, Fobx, Fcb, FileObject);
 
    Status = RxAcquireExclusiveFcb(Context, Fcb);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    AcquiredFcb = TRUE;
    _SEH2_TRY
    {
        BOOLEAN Freed;
 
        /* Check our FCB type is expected */
        if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_UNKNOWN &&
            (NodeType(Fcb) < RDBSS_NTC_STORAGE_TYPE_DIRECTORY || (NodeType(Fcb) > RDBSS_NTC_STORAGE_TYPE_FILE &&
            (NodeType(Fcb) < RDBSS_NTC_SPOOLFILE || NodeType(Fcb) > RDBSS_NTC_OPENTARGETDIR_FCB))))
        {
            RxBugCheck(NodeType(Fcb), 0, 0);
        }
 
        RxReferenceNetFcb(Fcb);
 
        DereferenceFobx = FALSE;
        /* If we're not closing FS */
        if (Fobx != NULL)
        {
            PSRV_OPEN SrvOpen;
            PSRV_CALL SrvCall;
 
            SrvOpen = (PSRV_OPEN)Fobx->pSrvOpen;
            SrvCall = (PSRV_CALL)Fcb->pNetRoot->pSrvCall;
            /* Handle delayed close */
            if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
            {
                if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE | FCB_STATE_ORPHANED))
                {
                    if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED))
                    {
                        DPRINT("Delay close for FOBX: %p, SrvOpen %p\n", Fobx, SrvOpen);
 
                        if (SrvOpen->OpenCount == 1 && !BooleanFlagOn(SrvOpen->Flags, SRVOPEN_FLAG_COLLAPSING_DISABLED))
                        {
                            if (InterlockedIncrement(&SrvCall->NumberOfCloseDelayedFiles) >= SrvCall->MaximumNumberOfCloseDelayedFiles)
                            {
                                InterlockedDecrement(&SrvCall->NumberOfCloseDelayedFiles);
                            }
                            else
                            {
                                DereferenceFobx = TRUE;
                                SetFlag(SrvOpen->Flags, SRVOPEN_FLAG_CLOSE_DELAYED);
                            }
                        }
                    }
                }
            }
 
            /* If we reach maximum of delayed close/or if there are no delayed close */
            if (!DereferenceFobx)
            {
                PNET_ROOT NetRoot;
 
                NetRoot = (PNET_ROOT)Fcb->pNetRoot;
                if (NetRoot->Type != NET_ROOT_PRINT)
                {
                    /* Delete if asked */
                    if (BooleanFlagOn(Fobx->Flags, FOBX_FLAG_DELETE_ON_CLOSE))
                    {
                        RxScavengeRelatedFobxs(Fcb);
                        RxSynchronizeWithScavenger(Context);
 
                        RxReleaseFcb(Context, Fcb);
 
                        RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, TRUE);
                        RxOrphanThisFcb(Fcb);
                        RxReleaseFcbTableLock(&NetRoot->FcbTable);
 
                        Status = RxAcquireExclusiveFcb(Context, Fcb);
                        ASSERT(NT_SUCCESS(Status));
                    }
                }
            }
 
            RxMarkFobxOnClose(Fobx);
        }
 
        if (DereferenceFobx)
        {
            ASSERT(Fobx != NULL);
            RxDereferenceNetFobx(Fobx, LHS_SharedLockHeld);
        }
        else
        {
            RxCloseAssociatedSrvOpen(Fobx, Context);
            if (Fobx != NULL)
            {
                RxDereferenceNetFobx(Fobx, LHS_ExclusiveLockHeld);
            }
        }
 
        Freed = RxDereferenceAndFinalizeNetFcb(Fcb, Context, FALSE, FALSE);
        AcquiredFcb = !Freed;
 
        FileObject->FsContext = (PVOID)-1;
 
        if (Freed)
        {
            RxTrackerUpdateHistory(Context, NULL, TRACKER_FCB_FREE, __LINE__, __FILE__, 0);
        }
        else
        {
            RxReleaseFcb(Context, Fcb);
            AcquiredFcb = FALSE;
        }
    }
    _SEH2_FINALLY
    {
        if (_SEH2_AbnormalTermination())
        {
            if (AcquiredFcb)
            {
                RxReleaseFcb(Context, Fcb);
            }
        }
        else
        {
            ASSERT(!AcquiredFcb);
        }
    }
    _SEH2_END;
 
    DPRINT("Status: %x\n", Status);
    return Status;
#undef BugCheckFileId
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonCreate(
    PRX_CONTEXT Context)
{
    PIRP Irp;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    DPRINT("RxCommonCreate(%p)\n", Context);
 
    Irp = Context->CurrentIrp;
    Stack = Context->CurrentIrpSp;
    FileObject = Stack->FileObject;
 
    /* Check whether that's a device opening */
    if (FileObject->FileName.Length == 0 && FileObject->RelatedFileObject == NULL)
    {
        FileObject->FsContext = &RxDeviceFCB;
        FileObject->FsContext2 = NULL;
 
        ++RxDeviceFCB.NodeReferenceCount;
        ++RxDeviceFCB.OpenCount;
 
        Irp->IoStatus.Information = FILE_OPENED;
        DPRINT("Device opening FO: %p, DO: %p, Name: %wZ\n", FileObject, Context->RxDeviceObject, &Context->RxDeviceObject->DeviceName);
 
        Status = STATUS_SUCCESS;
    }
    else
    {
        PFCB RelatedFcb = NULL;
 
        /* Make sure caller is consistent */
        if (FlagOn(Stack->Parameters.Create.Options, FILE_DIRECTORY_FILE | FILE_NON_DIRECTORY_FILE | FILE_OPEN_REMOTE_INSTANCE) ==
            (FILE_DIRECTORY_FILE | FILE_NON_DIRECTORY_FILE | FILE_OPEN_REMOTE_INSTANCE))
        {
            DPRINT1("Create.Options: %x\n", Stack->Parameters.Create.Options);
            return STATUS_INVALID_PARAMETER;
        }
 
        DPRINT("Ctxt: %p, FO: %p, Options: %lx, Flags: %lx, Attr: %lx, ShareAccess: %lx, DesiredAccess: %lx\n",
                 Context, FileObject, Stack->Parameters.Create.Options, Stack->Flags, Stack->Parameters.Create.FileAttributes,
                 Stack->Parameters.Create.ShareAccess, Stack->Parameters.Create.SecurityContext->DesiredAccess);
        DPRINT("FileName: %wZ\n", &FileObject->FileName);
 
        if (FileObject->RelatedFileObject != NULL)
        {
            RelatedFcb = FileObject->RelatedFileObject->FsContext;
            DPRINT("Rel FO: %p, path: %wZ\n", FileObject->RelatedFileObject, RelatedFcb->FcbTableEntry.Path);
        }
 
        /* Going to rename? */
        if (BooleanFlagOn(Stack->Flags, SL_OPEN_TARGET_DIRECTORY))
        {
            DPRINT("TargetDir!\n");
        }
 
        /* Copy create parameters to the context */
        RxCopyCreateParameters(Context);
 
        /* If the caller wants to establish a connection, go ahead */
        if (BooleanFlagOn(Stack->Parameters.Create.Options, FILE_CREATE_TREE_CONNECTION))
        {
            Status = RxCreateTreeConnect(Context);
        }
        else
        {
            /* Validate file name */
            if (FileObject->FileName.Length > sizeof(WCHAR) &&
                FileObject->FileName.Buffer[1] == OBJ_NAME_PATH_SEPARATOR &&
                FileObject->FileName.Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
            {
                FileObject->FileName.Length -= sizeof(WCHAR);
                RtlMoveMemory(&FileObject->FileName.Buffer[0], &FileObject->FileName.Buffer[1],
                              FileObject->FileName.Length);
 
                if (FileObject->FileName.Length > sizeof(WCHAR) &&
                    FileObject->FileName.Buffer[1] == OBJ_NAME_PATH_SEPARATOR &&
                    FileObject->FileName.Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
                {
                    return STATUS_OBJECT_NAME_INVALID;
                }
            }
 
            /* Attempt to open the file */
            do
            {
                UNICODE_STRING NetRootName;
 
                /* Strip last \ if required */
                if (FileObject->FileName.Length != 0 &&
                    FileObject->FileName.Buffer[FileObject->FileName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
                {
                    if (BooleanFlagOn(Stack->Parameters.Create.Options, FILE_NON_DIRECTORY_FILE))
                    {
                        return STATUS_OBJECT_NAME_INVALID;
                    }
 
                    FileObject->FileName.Length -= sizeof(WCHAR);
                    Context->Create.Flags |= RX_CONTEXT_CREATE_FLAG_STRIPPED_TRAILING_BACKSLASH;
                }
 
                if (BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_WRITE_THROUGH))
                {
                    FileObject->Flags |= FO_WRITE_THROUGH;
                }
 
                /* Get the associated net root to opening */
                Status = RxCanonicalizeNameAndObtainNetRoot(Context, &FileObject->FileName, &NetRootName);
                if (Status != STATUS_MORE_PROCESSING_REQUIRED)
                {
                    break;
                }
 
                /* And attempt to open */
                Status = RxCreateFromNetRoot(Context, &NetRootName);
                if (Status == STATUS_SHARING_VIOLATION)
                {
                    ASSERT(!BooleanFlagOn(Context->Create.Flags, RX_CONTEXT_CREATE_FLAG_REPARSE));
 
                    /* If that happens for file creation, fail for real */
                    if (Context->Create.NtCreateParameters.Disposition == FILE_CREATE)
                    {
                        Status = STATUS_OBJECT_NAME_COLLISION;
                    }
                    else
                    {
                        /* Otherwise, if possible, attempt to scavenger current FOBX
                         * to check whether a dormant FOBX is the reason for sharing violation
                         */
                        if (Context->Create.TryForScavengingOnSharingViolation &&
                            !Context->Create.ScavengingAlreadyTried)
                        {
                            /* Only doable with a VNetRoot */
                            if (Context->Create.pVNetRoot != NULL)
                            {
                                PV_NET_ROOT VNetRoot;
                                NT_CREATE_PARAMETERS SavedParameters;
 
                                /* Save create parameters */
                                RtlCopyMemory(&SavedParameters, &Context->Create.NtCreateParameters, sizeof(NT_CREATE_PARAMETERS));
 
                                /* Reference the VNetRoot for the scavenging time */
                                VNetRoot = (PV_NET_ROOT)Context->Create.pVNetRoot;
                                RxReferenceVNetRoot(VNetRoot);
 
                                /* Prepare the RX_CONTEXT for reuse */
                                RxpPrepareCreateContextForReuse(Context);
                                RxReinitializeContext(Context);
 
                                /* Copy what we saved */
                                RtlCopyMemory(&Context->Create.NtCreateParameters, &SavedParameters, sizeof(NT_CREATE_PARAMETERS));
 
                                /* And recopy what can be */
                                RxCopyCreateParameters(Context);
 
                                /* And start purging, then scavenging FOBX */
                                RxPurgeRelatedFobxs((PNET_ROOT)VNetRoot->pNetRoot, Context,
                                                    DONT_ATTEMPT_FINALIZE_ON_PURGE, NULL);
                                RxScavengeFobxsForNetRoot((PNET_ROOT)VNetRoot->pNetRoot,
                                                          NULL, TRUE);
 
                                /* Ask for a second round */
                                Status = STATUS_MORE_PROCESSING_REQUIRED;
 
                                /* Keep track we already scavenged */
                                Context->Create.ScavengingAlreadyTried = TRUE;
 
                                /* Reference our SRV_CALL for CBS handling */
                                RxReferenceSrvCall(VNetRoot->pNetRoot->pSrvCall);
                                RxpProcessChangeBufferingStateRequests((PSRV_CALL)VNetRoot->pNetRoot->pSrvCall, FALSE);
 
                                /* Drop our extra reference */
                                RxDereferenceVNetRoot(VNetRoot, LHS_LockNotHeld);
                            }
                        }
                    }
                }
                else if (Status == STATUS_REPARSE)
                {
                    Context->CurrentIrp->IoStatus.Information = 0;
                }
                else
                {
                    ASSERT(!BooleanFlagOn(Context->Create.Flags, RX_CONTEXT_CREATE_FLAG_REPARSE));
                }
            }
            while (Status == STATUS_MORE_PROCESSING_REQUIRED);
        }
 
        if (Status == STATUS_RETRY)
        {
            RxpPrepareCreateContextForReuse(Context);
        }
        ASSERT(Status != STATUS_PENDING);
    }
 
    DPRINT("Status: %lx\n", Status);
    return Status;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonDevFCBCleanup(
    PRX_CONTEXT Context)
{
    PMRX_FCB Fcb;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("RxCommonDevFCBCleanup(%p)\n", Context);
 
    Fcb = Context->pFcb;
    Status = STATUS_SUCCESS;
    ASSERT(NodeType(Fcb) == RDBSS_NTC_DEVICE_FCB);
 
    /* Our FOBX if set, has to be a VNetRoot */
    if (Context->pFobx != NULL)
    {
        RxAcquirePrefixTableLockShared(Context->RxDeviceObject->pRxNetNameTable, TRUE);
        if (Context->pFobx->NodeTypeCode != RDBSS_NTC_V_NETROOT)
        {
            Status = STATUS_INVALID_DEVICE_REQUEST;
        }
        RxReleasePrefixTableLock(Context->RxDeviceObject->pRxNetNameTable);
    }
    else
    {
        --Fcb->UncleanCount;
    }
 
    return Status;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonDevFCBClose(
    PRX_CONTEXT Context)
{
    PMRX_FCB Fcb;
    NTSTATUS Status;
    PMRX_V_NET_ROOT NetRoot;
 
    PAGED_CODE();
 
    DPRINT("RxCommonDevFCBClose(%p)\n", Context);
 
    Fcb = Context->pFcb;
    NetRoot = (PMRX_V_NET_ROOT)Context->pFobx;
    Status = STATUS_SUCCESS;
    ASSERT(NodeType(Fcb) == RDBSS_NTC_DEVICE_FCB);
 
    /* Our FOBX if set, has to be a VNetRoot */
    if (NetRoot != NULL)
    {
        RxAcquirePrefixTableLockExclusive(Context->RxDeviceObject->pRxNetNameTable, TRUE);
        if (NetRoot->NodeTypeCode == RDBSS_NTC_V_NETROOT)
        {
            --NetRoot->NumberOfOpens;
            RxDereferenceVNetRoot(NetRoot, LHS_ExclusiveLockHeld);
        }
        else
        {
            Status = STATUS_NOT_IMPLEMENTED;
        }
        RxReleasePrefixTableLock(Context->RxDeviceObject->pRxNetNameTable);
    }
    else
    {
        --Fcb->OpenCount;
    }
 
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonDevFCBFsCtl(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonDevFCBIoCtl(
    PRX_CONTEXT Context)
{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("RxCommonDevFCBIoCtl(%p)\n", Context);
 
    if (Context->pFobx != NULL)
    {
        return STATUS_INVALID_HANDLE;
    }
 
    /* Is that a prefix claim from MUP? */
    if (Context->CurrentIrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_REDIR_QUERY_PATH)
    {
        return RxPrefixClaim(Context);
    }
 
    /* Otherwise, pass through the mini-rdr */
    Status = RxXXXControlFileCallthru(Context);
    if (Status != STATUS_PENDING)
    {
        if (Context->PostRequest)
        {
            Context->ResumeRoutine = RxCommonDevFCBIoCtl;
            Status = RxFsdPostRequest(Context);
        }
    }
 
    DPRINT("Status: %lx\n", Status);
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonDevFCBQueryVolInfo(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonDeviceControl(
    PRX_CONTEXT Context)
{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    /* Prefix claim is only allowed for device, not files */
    if (Context->CurrentIrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_REDIR_QUERY_PATH)
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* Submit to mini-rdr */
    RxInitializeLowIoContext(&Context->LowIoContext, LOWIO_OP_IOCTL);
    Status = RxLowIoSubmit(Context, RxLowIoIoCtlShellCompletion);
    if (Status == STATUS_PENDING)
    {
        RxDereferenceAndDeleteRxContext_Real(Context);
    }
 
    return Status;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonDirectoryControl(
    PRX_CONTEXT Context)
{
    PFCB Fcb;
    PFOBX Fobx;
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
    Stack = Context->CurrentIrpSp;
    DPRINT("RxCommonDirectoryControl(%p) FOBX: %p, FCB: %p, Minor: %d\n", Context, Fobx, Fcb, Stack->MinorFunction);
 
    /* Call the appropriate helper */
    if (Stack->MinorFunction == IRP_MN_QUERY_DIRECTORY)
    {
        Status = RxQueryDirectory(Context);
    }
    else if (Stack->MinorFunction == IRP_MN_NOTIFY_CHANGE_DIRECTORY)
    {
        Status = RxNotifyChangeDirectory(Context);
        if (Status == STATUS_PENDING)
        {
            RxDereferenceAndDeleteRxContext_Real(Context);
        }
    }
    else
    {
        Status = STATUS_INVALID_DEVICE_REQUEST;
    }
 
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonDispatchProblem(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonFileSystemControl(
    PRX_CONTEXT Context)
{
    PIRP Irp;
    ULONG ControlCode;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    Irp = Context->CurrentIrp;
    Stack = Context->CurrentIrpSp;
    ControlCode = Stack->Parameters.FileSystemControl.FsControlCode;
 
    DPRINT1("RxCommonFileSystemControl: %p, %p, %d, %lx\n", Context, Irp, Stack->MinorFunction, ControlCode);
 
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonFlushBuffers(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonLockControl(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonQueryEa(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonQueryInformation(
    PRX_CONTEXT Context)
{
#define SET_SIZE_AND_QUERY(AlreadyConsummed, Function)                              \
    Context->Info.Length = Stack->Parameters.QueryFile.Length - (AlreadyConsummed); \
    Status = Function(Context, Add2Ptr(Buffer, AlreadyConsummed))
 
    PFCB Fcb;
    PIRP Irp;
    PFOBX Fobx;
    BOOLEAN Locked;
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    FILE_INFORMATION_CLASS FileInfoClass;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
    DPRINT("RxCommonQueryInformation(%p) FCB: %p, FOBX: %p\n", Context, Fcb, Fobx);
 
    Irp = Context->CurrentIrp;
    Stack = Context->CurrentIrpSp;
    DPRINT("Buffer: %p, Length: %lx, Class: %ld\n", Irp->AssociatedIrp.SystemBuffer,
            Stack->Parameters.QueryFile.Length, Stack->Parameters.QueryFile.FileInformationClass);
 
    Context->Info.Length = Stack->Parameters.QueryFile.Length;
    FileInfoClass = Stack->Parameters.QueryFile.FileInformationClass;
 
    Locked  = FALSE;
    _SEH2_TRY
    {
        PVOID Buffer;
 
        /* Get a writable buffer */
        Buffer = RxMapSystemBuffer(Context);
        if (Buffer == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        /* Zero it */
        RtlZeroMemory(Buffer, Context->Info.Length);
 
        /* Validate file type */
        if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_UNKNOWN)
        {
            if (NodeType(Fcb) < RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
            {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
            else if (NodeType(Fcb) > RDBSS_NTC_STORAGE_TYPE_FILE)
            {
                if (NodeType(Fcb) == RDBSS_NTC_MAILSLOT)
                {
                    Status = STATUS_NOT_IMPLEMENTED;
                }
                else
                {
                    Status = STATUS_INVALID_PARAMETER;
                }
 
                _SEH2_LEAVE;
            }
        }
 
        /* Acquire the right lock */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE) &&
            FileInfoClass != FileNameInformation)
        {
            if (FileInfoClass == FileCompressionInformation)
            {
                Status = RxAcquireExclusiveFcb(Context, Fcb);
            }
            else
            {
                Status = RxAcquireSharedFcb(Context, Fcb);
            }
 
            if (Status == STATUS_LOCK_NOT_GRANTED)
            {
                Status = STATUS_PENDING;
                _SEH2_LEAVE;
            }
            else if (!NT_SUCCESS(Status))
            {
                _SEH2_LEAVE;
            }
 
            Locked = TRUE;
        }
 
        /* Dispatch to the right helper */
        switch (FileInfoClass)
        {
            case FileBasicInformation:
                Status = RxQueryBasicInfo(Context, Buffer);
                break;
 
            case FileStandardInformation:
                Status = RxQueryStandardInfo(Context, Buffer);
                break;
 
            case FileInternalInformation:
                Status = RxQueryInternalInfo(Context, Buffer);
                break;
 
            case FileEaInformation:
                Status = RxQueryEaInfo(Context, Buffer);
                break;
 
            case FileNameInformation:
                Status = RxQueryNameInfo(Context, Buffer);
                break;
 
            case FileAllInformation:
                SET_SIZE_AND_QUERY(0, RxQueryBasicInfo);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                SET_SIZE_AND_QUERY(sizeof(FILE_BASIC_INFORMATION), RxQueryStandardInfo);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                SET_SIZE_AND_QUERY(sizeof(FILE_BASIC_INFORMATION) +
                                   sizeof(FILE_STANDARD_INFORMATION), RxQueryInternalInfo);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                SET_SIZE_AND_QUERY(sizeof(FILE_BASIC_INFORMATION) +
                                   sizeof(FILE_STANDARD_INFORMATION) +
                                   sizeof(FILE_INTERNAL_INFORMATION), RxQueryEaInfo);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                SET_SIZE_AND_QUERY(sizeof(FILE_BASIC_INFORMATION) +
                                   sizeof(FILE_STANDARD_INFORMATION) +
                                   sizeof(FILE_INTERNAL_INFORMATION) +
                                   sizeof(FILE_EA_INFORMATION), RxQueryPositionInfo);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                SET_SIZE_AND_QUERY(sizeof(FILE_BASIC_INFORMATION) +
                                   sizeof(FILE_STANDARD_INFORMATION) +
                                   sizeof(FILE_INTERNAL_INFORMATION) +
                                   sizeof(FILE_EA_INFORMATION) +
                                   sizeof(FILE_POSITION_INFORMATION), RxQueryNameInfo);
                break;
 
            case FileAlternateNameInformation:
                Status = RxQueryAlternateNameInfo(Context, Buffer);
                break;
 
            case FilePipeInformation:
            case FilePipeLocalInformation:
            case FilePipeRemoteInformation:
                Status = RxQueryPipeInfo(Context, Buffer);
                break;
 
            case FileCompressionInformation:
                Status = RxQueryCompressedInfo(Context, Buffer);
                break;
 
            default:
                Context->IoStatusBlock.Status = RxpQueryInfoMiniRdr(Context, FileInfoClass, Buffer);
                Status = Context->IoStatusBlock.Status;
                break;
        }
 
        if (Context->Info.Length < 0)
        {
            Status = STATUS_BUFFER_OVERFLOW;
            Context->Info.Length = Stack->Parameters.QueryFile.Length;
        }
 
        Irp->IoStatus.Information = Stack->Parameters.QueryFile.Length - Context->Info.Length;
    }
    _SEH2_FINALLY
    {
        if (Locked)
        {
            RxReleaseFcb(Context, Fcb);
        }
    }
    _SEH2_END;
 
    DPRINT("Status: %x\n", Status);
    return Status;
 
#undef SET_SIZE_AND_QUERY
}
 
NTSTATUS
NTAPI
RxCommonQueryQuotaInformation(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonQuerySecurity(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonQueryVolumeInformation(
    PRX_CONTEXT Context)
{
    PIRP Irp;
    PFCB Fcb;
    PFOBX Fobx;
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
 
    DPRINT("RxCommonQueryVolumeInformation(%p) FCB: %p, FOBX: %p\n", Context, Fcb, Fobx);
 
    Irp = Context->CurrentIrp;
    Stack = Context->CurrentIrpSp;
    DPRINT("Length: %lx, Class: %lx, Buffer %p\n", Stack->Parameters.QueryVolume.Length,
           Stack->Parameters.QueryVolume.FsInformationClass, Irp->AssociatedIrp.SystemBuffer);
 
    Context->Info.FsInformationClass = Stack->Parameters.QueryVolume.FsInformationClass;
    Context->Info.Buffer = Irp->AssociatedIrp.SystemBuffer;
    Context->Info.Length = Stack->Parameters.QueryVolume.Length;
 
    /* Forward to mini-rdr */
    MINIRDR_CALL(Status, Context, Fcb->MRxDispatch, MRxQueryVolumeInfo, (Context));
 
    /* Post request if mini-rdr asked to */
    if (Context->PostRequest)
    {
        Status = RxFsdPostRequest(Context);
    }
    else
    {
        Irp->IoStatus.Information = Stack->Parameters.QueryVolume.Length - Context->Info.Length;
    }
 
    DPRINT("Status: %x\n", Status);
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonRead(
    PRX_CONTEXT RxContext)
{
    PFCB Fcb;
    PIRP Irp;
    PFOBX Fobx;
    NTSTATUS Status;
    PNET_ROOT NetRoot;
    PVOID SystemBuffer;
    PFILE_OBJECT FileObject;
    LARGE_INTEGER ByteOffset;
    PIO_STACK_LOCATION Stack;
    PLOWIO_CONTEXT LowIoContext;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    ULONG ReadLength, CapturedRxContextSerialNumber = RxContext->SerialNumber;
    BOOLEAN CanWait, PagingIo, NoCache, Sync, PostRequest, IsPipe, ReadCachingEnabled, ReadCachingDisabled, InFsp, OwnerSet;
 
    PAGED_CODE();
 
    Fcb = (PFCB)RxContext->pFcb;
    Fobx = (PFOBX)RxContext->pFobx;
    DPRINT("RxCommonRead(%p) FOBX: %p, FCB: %p\n", RxContext, Fobx, Fcb);
 
    /* Get some parameters */
    Irp = RxContext->CurrentIrp;
    Stack = RxContext->CurrentIrpSp;
    CanWait = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
    PagingIo = BooleanFlagOn(Irp->Flags, IRP_PAGING_IO);
    NoCache = BooleanFlagOn(Irp->Flags, IRP_NOCACHE);
    Sync = !BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION);
    InFsp = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP);
    ReadLength = Stack->Parameters.Read.Length;
    ByteOffset.QuadPart = Stack->Parameters.Read.ByteOffset.QuadPart;
    DPRINT("Reading: %lx@%I64x %s %s %s %s\n", ReadLength, ByteOffset.QuadPart,
           (CanWait ? "CW" : "!CW"), (PagingIo ? "PI" : "!PI"), (NoCache ? "NC" : "!NC"), (Sync ? "S" : "!S"));
 
    RxItsTheSameContext();
 
    Irp->IoStatus.Information = 0;
 
    /* Should the read be loud - so far, it's just ignored on ReactOS:
     * s/DPRINT/DPRINT1/g will make it loud
     */
    LowIoContext = &RxContext->LowIoContext;
    CheckForLoudOperations(RxContext);
    if (BooleanFlagOn(LowIoContext->Flags, LOWIO_CONTEXT_FLAG_LOUDOPS))
    {
        DPRINT("LoudRead %I64x/%lx on %lx vdl/size/alloc %I64x/%I64x/%I64x\n",
                ByteOffset, ReadLength,
                Fcb, Fcb->Header.ValidDataLength, Fcb->Header.FileSize, Fcb->Header.AllocationSize);
    }
 
    RxDeviceObject = RxContext->RxDeviceObject;
    /* Update stats */
    if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP) && Fcb->CachedNetRootType == NET_ROOT_DISK)
    {
        InterlockedIncrement((volatile long *)&RxDeviceObject->ReadOperations);
 
        if (ByteOffset.QuadPart != Fobx->Specific.DiskFile.PredictedReadOffset)
        {
            InterlockedIncrement((volatile long *)&RxDeviceObject->RandomReadOperations);
        }
        Fobx->Specific.DiskFile.PredictedReadOffset = ByteOffset.QuadPart + ReadLength;
 
        if (PagingIo)
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->PagingReadBytesRequested, ReadLength);
        }
        else if (NoCache)
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->NonPagingReadBytesRequested, ReadLength);
        }
        else
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->CacheReadBytesRequested, ReadLength);
        }
    }
 
    /* A pagefile cannot be a pipe */
    IsPipe = Fcb->NetRoot->Type == NET_ROOT_PIPE;
    if (IsPipe && PagingIo)
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* Null-length read is no-op */
    if (ReadLength == 0)
    {
        return STATUS_SUCCESS;
    }
 
    /* Validate FCB type */
    if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_FILE && NodeType(Fcb) != RDBSS_NTC_VOLUME_FCB)
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* Init the lowio context for possible forward */
    RxInitializeLowIoContext(LowIoContext, LOWIO_OP_READ);
 
    PostRequest = FALSE;
    ReadCachingDisabled = FALSE;
    OwnerSet = FALSE;
    ReadCachingEnabled = BooleanFlagOn(Fcb->FcbState, FCB_STATE_READCACHING_ENABLED);
    FileObject = Stack->FileObject;
    NetRoot = (PNET_ROOT)Fcb->pNetRoot;
    _SEH2_TRY
    {
        LONGLONG FileSize;
 
        /* If no caching, make sure current Cc data have been flushed */
        if (!PagingIo && NoCache && !ReadCachingEnabled && FileObject->SectionObjectPointer != NULL)
        {
            Status = RxAcquireExclusiveFcb(RxContext, Fcb);
            if (Status == STATUS_LOCK_NOT_GRANTED)
            {
                PostRequest = TRUE;
                _SEH2_LEAVE;
            }
            else if (Status != STATUS_SUCCESS)
            {
                _SEH2_LEAVE;
            }
 
            ExAcquireResourceSharedLite(Fcb->Header.PagingIoResource, TRUE);
            CcFlushCache(FileObject->SectionObjectPointer, &ByteOffset, ReadLength, &Irp->IoStatus);
            RxReleasePagingIoResource(RxContext, Fcb);
 
            if (!NT_SUCCESS(Irp->IoStatus.Status))
            {
                Status = Irp->IoStatus.Status;
                _SEH2_LEAVE;
            }
 
            RxAcquirePagingIoResource(RxContext, Fcb);
            RxReleasePagingIoResource(RxContext, Fcb);
        }
 
        /* Acquire the appropriate lock */
        if (PagingIo && !ReadCachingEnabled)
        {
            ASSERT(!IsPipe);
 
            if (!ExAcquireResourceSharedLite(Fcb->Header.PagingIoResource, CanWait))
            {
                PostRequest = TRUE;
                _SEH2_LEAVE;
            }
 
            if (!CanWait)
            {
                LowIoContext->Resource = Fcb->Header.PagingIoResource;
            }
        }
        else
        {
            if (!ReadCachingEnabled)
            {
                if (!CanWait && NoCache)
                {
                    Status = RxAcquireSharedFcbWaitForEx(RxContext, Fcb);
                    if (Status == STATUS_LOCK_NOT_GRANTED)
                    {
                        DPRINT1("RdAsyLNG %x\n", RxContext);
                        PostRequest = TRUE;
                        _SEH2_LEAVE;
                    }
                    if (Status != STATUS_SUCCESS)
                    {
                        DPRINT1("RdAsyOthr %x\n", RxContext);
                        _SEH2_LEAVE;
                    }
 
                    if (RxIsFcbAcquiredShared(Fcb) <= 0xF000)
                    {
                        LowIoContext->Resource = Fcb->Header.Resource;
                    }
                    else
                    {
                        PostRequest = TRUE;
                        _SEH2_LEAVE;
                    }
                }
                else
                {
                    Status = RxAcquireSharedFcb(RxContext, Fcb);
                    if (Status == STATUS_LOCK_NOT_GRANTED)
                    {
                        PostRequest = TRUE;
                        _SEH2_LEAVE;
                    }
                    else if (Status != STATUS_SUCCESS)
                    {
                        _SEH2_LEAVE;
                    }
                }
            }
        }
 
        RxItsTheSameContext();
 
        ReadCachingDisabled = (ReadCachingEnabled == FALSE);
        if (IsPipe)
        {
            UNIMPLEMENTED;
        }
 
        RxGetFileSizeWithLock(Fcb, &FileSize);
 
        /* Make sure FLOCK doesn't conflict */
        if (!PagingIo)
        {
            if (!FsRtlCheckLockForReadAccess(&Fcb->Specific.Fcb.FileLock, Irp))
            {
                Status = STATUS_FILE_LOCK_CONFLICT;
                _SEH2_LEAVE;
            }
        }
 
        /* Validate byteoffset vs length */
        if (BooleanFlagOn(Fcb->FcbState, FCB_STATE_READCACHING_ENABLED))
        {
            if (ByteOffset.QuadPart >= FileSize)
            {
                Status = STATUS_END_OF_FILE;
                _SEH2_LEAVE;
            }
 
            if (ReadLength > FileSize - ByteOffset.QuadPart)
            {
                ReadLength = FileSize - ByteOffset.QuadPart;
            }
        }
 
        /* Read with Cc! */
        if (!PagingIo && !NoCache && ReadCachingEnabled &&
            !BooleanFlagOn(Fobx->pSrvOpen->Flags, SRVOPEN_FLAG_DONTUSE_READ_CACHING))
        {
            /* File was not cached yet, do it */
            if (FileObject->PrivateCacheMap == NULL)
            {
                if (BooleanFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    Status = STATUS_FILE_CLOSED;
                    _SEH2_LEAVE;
                }
 
                RxAdjustAllocationSizeforCC(Fcb);
 
                CcInitializeCacheMap(FileObject, (PCC_FILE_SIZES)&Fcb->Header.AllocationSize,
                                     FALSE, &RxData.CacheManagerCallbacks, Fcb);
 
                if (BooleanFlagOn(Fcb->MRxDispatch->MRxFlags, RDBSS_NO_DEFERRED_CACHE_READAHEAD))
                {
                    CcSetAdditionalCacheAttributes(FileObject, FALSE, FALSE);
                }
                else
                {
                    CcSetAdditionalCacheAttributes(FileObject, TRUE, FALSE);
                    SetFlag(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED);
                }
 
                CcSetReadAheadGranularity(FileObject, NetRoot->DiskParameters.ReadAheadGranularity);
            }
 
            /* This should never happen - fix your RDR */
            if (BooleanFlagOn(RxContext->MinorFunction, IRP_MN_MDL))
            {
                ASSERT(FALSE);
                ASSERT(CanWait);
 
                CcMdlRead(FileObject, &ByteOffset, ReadLength, &Irp->MdlAddress, &Irp->IoStatus);
                Status = Irp->IoStatus.Status;
                ASSERT(NT_SUCCESS(Status));
            }
            else
            {
                /* Map buffer */
                SystemBuffer = RxNewMapUserBuffer(RxContext);
                if (SystemBuffer == NULL)
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    _SEH2_LEAVE;
                }
 
                SetFlag(Fcb->FcbState, FCB_STATE_READCACHING_ENABLED);
 
                RxItsTheSameContext();
 
                /* Perform the read */
                if (!CcCopyRead(FileObject, &ByteOffset, ReadLength, CanWait, SystemBuffer, &Irp->IoStatus))
                {
                    if (!ReadCachingEnabled)
                    {
                        ClearFlag(Fcb->FcbState, FCB_STATE_READCACHING_ENABLED);
                    }
 
                    RxItsTheSameContext();
 
                    PostRequest = TRUE;
                    _SEH2_LEAVE;
                }
 
                if (!ReadCachingEnabled)
                {
                    ClearFlag(Fcb->FcbState, FCB_STATE_READCACHING_ENABLED);
                }
 
                Status = Irp->IoStatus.Status;
                ASSERT(NT_SUCCESS(Status));
            }
        }
        else
        {
            /* Validate the reading */
            if (FileObject->PrivateCacheMap != NULL && BooleanFlagOn(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED) &&
                ByteOffset.QuadPart >= 4096)
            {
                CcSetAdditionalCacheAttributes(FileObject, FALSE, FALSE);
                ClearFlag(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED);
            }
 
            /* If it's consistent, forward to mini-rdr */
            if (Fcb->CachedNetRootType != NET_ROOT_DISK || BooleanFlagOn(Fcb->FcbState, FCB_STATE_READAHEAD_DEFERRED) ||
                ByteOffset.QuadPart < Fcb->Header.ValidDataLength.QuadPart)
            {
                LowIoContext->ParamsFor.ReadWrite.ByteCount = ReadLength;
                LowIoContext->ParamsFor.ReadWrite.ByteOffset = ByteOffset.QuadPart;
 
                RxItsTheSameContext();
 
                if (InFsp && ReadCachingDisabled)
                {
                    ExSetResourceOwnerPointer((PagingIo ? Fcb->Header.PagingIoResource : Fcb->Header.Resource),
                                              (PVOID)((ULONG_PTR)RxContext | 3));
                    OwnerSet = TRUE;
                }
 
                Status = RxLowIoReadShell(RxContext);
 
                RxItsTheSameContext();
            }
            else
            {
                if (ByteOffset.QuadPart > FileSize)
                {
                    ReadLength = 0;
                    Irp->IoStatus.Information = ReadLength;
                    _SEH2_LEAVE;
                }
 
                if (ByteOffset.QuadPart + ReadLength > FileSize)
                {
                    ReadLength = FileSize - ByteOffset.QuadPart;
                }
 
                SystemBuffer = RxNewMapUserBuffer(RxContext);
                RtlZeroMemory(SystemBuffer, ReadLength);
                Irp->IoStatus.Information = ReadLength;
            }
        }
    }
    _SEH2_FINALLY
    {
        RxItsTheSameContext();
 
        /* Post if required */
        if (PostRequest)
        {
            InterlockedIncrement((volatile long *)&RxContext->ReferenceCount);
            Status = RxFsdPostRequest(RxContext);
        }
        else
        {
            /* Update FO in case of sync IO */
            if (!IsPipe && !PagingIo)
            {
                if (BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
                {
                    FileObject->CurrentByteOffset.QuadPart = ByteOffset.QuadPart + Irp->IoStatus.Information;
                }
            }
        }
 
        /* Set FastIo if read was a success */
        if (NT_SUCCESS(Status) && Status != STATUS_PENDING)
        {
            if (!IsPipe && !PagingIo)
            {
                SetFlag(FileObject->Flags, FO_FILE_FAST_IO_READ);
            }
        }
 
        /* In case we're done (not expected any further processing */
        if (_SEH2_AbnormalTermination() || Status != STATUS_PENDING || PostRequest)
        {
            /* Release everything that can be */
            if (ReadCachingDisabled)
            {
                if (PagingIo)
                {
                    if (OwnerSet)
                    {
                        RxReleasePagingIoResourceForThread(RxContext, Fcb, LowIoContext->ResourceThreadId);
                    }
                    else
                    {
                        RxReleasePagingIoResource(RxContext, Fcb);
                    }
                }
                else
                {
                    if (OwnerSet)
                    {
                        RxReleaseFcbForThread(RxContext, Fcb, LowIoContext->ResourceThreadId);
                    }
                    else
                    {
                        RxReleaseFcb(RxContext, Fcb);
                    }
                }
            }
 
            /* Dereference/Delete context */
            if (PostRequest)
            {
                RxDereferenceAndDeleteRxContext(RxContext);
            }
            else
            {
                if (BooleanFlagOn(RxContext->FlagsForLowIo, RXCONTEXT_FLAG4LOWIO_PIPE_SYNC_OPERATION))
                {
                    RxResumeBlockedOperations_Serially(RxContext, &Fobx->Specific.NamedPipe.ReadSerializationQueue);
                }
            }
 
            /* We cannot return more than asked */
            if (Status == STATUS_SUCCESS)
            {
                ASSERT(Irp->IoStatus.Information <= Stack->Parameters.Read.Length);
            }
        }
        else
        {
            ASSERT(!Sync);
 
            RxDereferenceAndDeleteRxContext(RxContext);
        }
    }
    _SEH2_END;
 
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonSetEa(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
RxCommonSetInformation(
    PRX_CONTEXT Context)
{
    PIRP Irp;
    PFCB Fcb;
    PFOBX Fobx;
    NTSTATUS Status;
    PNET_ROOT NetRoot;
    PIO_STACK_LOCATION Stack;
    FILE_INFORMATION_CLASS Class;
    BOOLEAN CanWait, FcbTableAcquired, FcbAcquired;
 
    PAGED_CODE();
 
    Fcb = (PFCB)Context->pFcb;
    Fobx = (PFOBX)Context->pFobx;
    DPRINT("RxCommonSetInformation(%p), FCB: %p, FOBX: %p\n", Context, Fcb, Fobx);
 
    Irp = Context->CurrentIrp;
    Stack = Context->CurrentIrpSp;
    Class = Stack->Parameters.SetFile.FileInformationClass;
    DPRINT("Buffer: %p, Length: %lx, Class: %ld, ReplaceIfExists: %d\n",
           Irp->AssociatedIrp.SystemBuffer, Stack->Parameters.SetFile.Length,
           Class, Stack->Parameters.SetFile.ReplaceIfExists);
 
    Status = STATUS_SUCCESS;
    CanWait = BooleanFlagOn(Context->Flags, RX_CONTEXT_FLAG_WAIT);
    FcbTableAcquired = FALSE;
    FcbAcquired = FALSE;
    NetRoot = (PNET_ROOT)Fcb->pNetRoot;
 
#define _SEH2_TRY_RETURN(S) S; goto try_exit
 
    _SEH2_TRY
    {
        /* Valide the node type first */
        if (NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_UNKNOWN &&
            NodeType(Fcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY)
        {
            if (NodeType(Fcb) == RDBSS_NTC_STORAGE_TYPE_FILE)
            {
                if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE))
                {
                    Status = STATUS_SUCCESS;
                }
            }
            else if (NodeType(Fcb) != RDBSS_NTC_SPOOLFILE)
            {
                if (NodeType(Fcb) == RDBSS_NTC_MAILSLOT)
                {
                    _SEH2_TRY_RETURN(Status = STATUS_NOT_IMPLEMENTED);
                }
                else
                {
                    DPRINT1("Illegal type of file provided: %x\n", NodeType(Fcb));
                    _SEH2_TRY_RETURN(Status = STATUS_INVALID_PARAMETER);
                }
            }
        }
 
        /* We don't autorize advance operation */
        if (Class == FileEndOfFileInformation && Stack->Parameters.SetFile.AdvanceOnly)
        {
            DPRINT1("Not allowed\n");
 
            _SEH2_TRY_RETURN(Status = STATUS_SUCCESS);
        }
 
        /* For these to classes, we'll have to deal with the FCB table (removal)
         * We thus need the exclusive FCB table lock
         */
        if (Class == FileDispositionInformation || Class == FileRenameInformation)
        {
            RxPurgeRelatedFobxs(NetRoot, Context, TRUE, Fcb);
            RxScavengeFobxsForNetRoot(NetRoot, Fcb, TRUE);
 
            if (!RxAcquireFcbTableLockExclusive(&NetRoot->FcbTable, CanWait))
            {
                Context->PostRequest = TRUE;
                _SEH2_TRY_RETURN(Status = STATUS_PENDING);
            }
 
            FcbTableAcquired = TRUE;
        }
 
        /* Finally, if not paging file, we need exclusive FCB lock */
        if (!BooleanFlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE))
        {
            Status = RxAcquireExclusiveFcb(Context, Fcb);
            if (Status == STATUS_LOCK_NOT_GRANTED)
            {
                Context->PostRequest = TRUE;
                _SEH2_TRY_RETURN(Status = STATUS_SUCCESS);
            }
            else if (Status != STATUS_SUCCESS)
            {
                _SEH2_LEAVE;
            }
 
            FcbAcquired = TRUE;
        }
 
        Status = STATUS_SUCCESS;
 
        /* And now, perform the job! */
        switch (Class)
        {
            case FileBasicInformation:
                Status = RxSetBasicInfo(Context);
                break;
 
            case FileDispositionInformation:
            {
                PFILE_DISPOSITION_INFORMATION FDI;
 
                /* Check whether user wants deletion */
                FDI = Irp->AssociatedIrp.SystemBuffer;
                if (FDI->DeleteFile)
                {
                    /* If so, check whether it's doable */
                    if (!MmFlushImageSection(&Fcb->NonPaged->SectionObjectPointers, MmFlushForDelete))
                    {
                        Status = STATUS_CANNOT_DELETE;
                    }
 
                    /* And if doable, already remove from FCB table */
                    if (Status == STATUS_SUCCESS)
                    {
                        ASSERT(FcbAcquired && FcbTableAcquired);
                        RxRemoveNameNetFcb(Fcb);
 
                        RxReleaseFcbTableLock(&NetRoot->FcbTable);
                        FcbTableAcquired = FALSE;
                    }
                }
 
                /* If it succeed, perform the operation */
                if (Status == STATUS_SUCCESS)
                {
                    Status = RxSetDispositionInfo(Context);
                }
 
                break;
            }
 
            case FilePositionInformation:
                Status = RxSetPositionInfo(Context);
                break;
 
            case FileAllocationInformation:
                Status = RxSetAllocationInfo(Context);
                break;
 
            case FileEndOfFileInformation:
                Status = RxSetEndOfFileInfo(Context);
                break;
 
            case FilePipeInformation:
            case FilePipeLocalInformation:
            case FilePipeRemoteInformation:
                Status = RxSetPipeInfo(Context);
                break;
 
            case FileRenameInformation:
            case FileLinkInformation:
            case FileMoveClusterInformation:
                /* If we can wait, try to perform the operation right now */
                if (CanWait)
                {
                    /* Of course, collapsing is not doable anymore, file is
                     * in an inbetween state
                     */
                    ClearFlag(Fcb->FcbState, FCB_STATE_COLLAPSING_ENABLED);
 
                    /* Set the information */
                    Status = RxSetRenameInfo(Context);
                    /* If it succeed, drop the current entry from FCB table */
                    if (Status == STATUS_SUCCESS && Class == FileRenameInformation)
                    {
                        ASSERT(FcbAcquired && FcbTableAcquired);
                        RxRemoveNameNetFcb(Fcb);
                    }
                    _SEH2_TRY_RETURN(Status);
                }
                /* Can't wait? Post for async retry */
                else
                {
                    Status = RxFsdPostRequest(Context);
                    _SEH2_TRY_RETURN(Status);
                }
                break;
 
            case FileValidDataLengthInformation:
                if (!MmCanFileBeTruncated(&Fcb->NonPaged->SectionObjectPointers, NULL))
                {
                    Status = STATUS_USER_MAPPED_FILE;
                }
                break;
 
            case FileShortNameInformation:
                Status = RxSetSimpleInfo(Context);
                break;
 
            default:
                DPRINT1("Insupported class: %x\n", Class);
                Status = STATUS_INVALID_PARAMETER;
 
                break;
        }
 
try_exit: NOTHING;
        /* If mini-rdr was OK and wants a re-post on this, do it */
        if (Status == STATUS_SUCCESS)
        {
            if (Context->PostRequest)
            {
                Status = RxFsdPostRequest(Context);
            }
        }
    }
    _SEH2_FINALLY
    {
        /* Release any acquired lock */
        if (FcbAcquired)
        {
            RxReleaseFcb(Context, Fcb);
        }
 
        if (FcbTableAcquired)
        {
            RxReleaseFcbTableLock(&NetRoot->FcbTable);
        }
    }
    _SEH2_END;
 
#undef _SEH2_TRY_RETURN
 
    return Status;
}
 
NTSTATUS
NTAPI
RxCommonSetQuotaInformation(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonSetSecurity(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonSetVolumeInformation(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonUnimplemented(
    PRX_CONTEXT Context)
{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}
 
NTSTATUS
NTAPI
RxCommonWrite(
    PRX_CONTEXT RxContext)
{
    PIRP Irp;
    PFCB Fcb;
    PFOBX Fobx;
    NTSTATUS Status;
    PNET_ROOT NetRoot;
    PSRV_OPEN SrvOpen;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION Stack;
    LARGE_INTEGER ByteOffset;
    NODE_TYPE_CODE NodeTypeCode;
    PLOWIO_CONTEXT LowIoContext;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    ULONG WriteLength, CapturedRxContextSerialNumber = RxContext->SerialNumber;
    LONGLONG FileSize, ValidDataLength, InitialFileSize, InitialValidDataLength;
    BOOLEAN CanWait, PagingIo, NoCache, Sync, NormalFile, WriteToEof, IsPipe, NoPreposting, InFsp, RecursiveWriteThrough, CalledByLazyWriter, SwitchBackToAsync, ExtendingFile, ExtendingValidData, UnwindOutstandingAsync, ResourceOwnerSet, PostIrp, ContextReferenced;
 
    PAGED_CODE();
 
    Fcb = (PFCB)RxContext->pFcb;
    NodeTypeCode = NodeType(Fcb);
    /* Validate FCB type */
    if (NodeTypeCode != RDBSS_NTC_STORAGE_TYPE_FILE && NodeTypeCode != RDBSS_NTC_VOLUME_FCB &&
        NodeTypeCode != RDBSS_NTC_SPOOLFILE && NodeTypeCode != RDBSS_NTC_MAILSLOT)
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* We'll write to file, keep track of it */
    Fcb->IsFileWritten = TRUE;
 
    Stack = RxContext->CurrentIrpSp;
    /* Set write through if asked */
    if (BooleanFlagOn(Stack->Flags, SL_WRITE_THROUGH))
    {
        SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_WRITE_THROUGH);
    }
 
    Fobx = (PFOBX)RxContext->pFobx;
    DPRINT("RxCommonWrite(%p) FOBX: %p, FCB: %p\n", RxContext, Fobx, Fcb);
 
    /* Get some parameters */
    Irp = RxContext->CurrentIrp;
    NoPreposting = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_NO_PREPOSTING_NEEDED);
    InFsp = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP);
    CanWait = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
    PagingIo = BooleanFlagOn(Irp->Flags, IRP_PAGING_IO);
    NoCache = BooleanFlagOn(Irp->Flags, IRP_NOCACHE);
    Sync = !BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION);
    WriteLength = Stack->Parameters.Write.Length;
    ByteOffset.QuadPart = Stack->Parameters.Write.ByteOffset.QuadPart;
    DPRINT("Writing: %lx@%I64x %s %s %s %s\n", WriteLength, ByteOffset.QuadPart,
           (CanWait ? "CW" : "!CW"), (PagingIo ? "PI" : "!PI"), (NoCache ? "NC" : "!NC"), (Sync ? "S" : "!S"));
 
    RxItsTheSameContext();
 
    RxContext->FcbResourceAcquired = FALSE;
    RxContext->FcbPagingIoResourceAcquired = FALSE;
 
    LowIoContext = &RxContext->LowIoContext;
    CheckForLoudOperations(RxContext);
    if (BooleanFlagOn(LowIoContext->Flags, LOWIO_CONTEXT_FLAG_LOUDOPS))
    {
        DPRINT("LoudWrite %I64x/%lx on %lx vdl/size/alloc %I64x/%I64x/%I64x\n",
                ByteOffset, WriteLength,
                Fcb, Fcb->Header.ValidDataLength, Fcb->Header.FileSize, Fcb->Header.AllocationSize);
    }
 
    RxDeviceObject = RxContext->RxDeviceObject;
    /* Update stats */
    if (!BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP) && Fcb->CachedNetRootType == NET_ROOT_DISK)
    {
        InterlockedIncrement((volatile long *)&RxDeviceObject->WriteOperations);
 
        if (ByteOffset.QuadPart != Fobx->Specific.DiskFile.PredictedWriteOffset)
        {
            InterlockedIncrement((volatile long *)&RxDeviceObject->RandomWriteOperations);
        }
        Fobx->Specific.DiskFile.PredictedWriteOffset = ByteOffset.QuadPart + WriteLength;
 
        if (PagingIo)
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->PagingWriteBytesRequested, WriteLength);
        }
        else if (NoCache)
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->NonPagingWriteBytesRequested, WriteLength);
        }
        else
        {
            ExInterlockedAddLargeStatistic(&RxDeviceObject->CacheWriteBytesRequested, WriteLength);
        }
    }
 
    NetRoot = (PNET_ROOT)Fcb->NetRoot;
    IsPipe = (NetRoot->Type == NET_ROOT_PIPE);
    /* Keep track for normal writes */
    if (NetRoot->Type == NET_ROOT_DISK || NetRoot->Type == NET_ROOT_WILD)
    {
        NormalFile = TRUE;
    }
    else
    {
        NormalFile = FALSE;
    }
 
    /* Zero-length write is immediate success */
    if (NormalFile && WriteLength == 0)
    {
        return STATUS_SUCCESS;
    }
 
    /* Check whether we have input data */
    if (Irp->UserBuffer == NULL && Irp->MdlAddress == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Are we writting to EOF? */
    WriteToEof = ((ByteOffset.LowPart == FILE_WRITE_TO_END_OF_FILE) && (ByteOffset.HighPart == -1));
    /* FIXME: validate length/offset */
 
    /* Get our SRV_OPEN in case of normal write */
    if (Fobx != NULL)
    {
        SrvOpen = (PSRV_OPEN)Fobx->pSrvOpen;
    }
    else
    {
        SrvOpen = NULL;
    }
 
    FileObject = Stack->FileObject;
 
    /* If we have caching enabled, check whether we have to defer write */
    if (!NoCache)
    {
        if (RxWriteCacheingAllowed(Fcb, SrvOpen))
        {
            if (!CcCanIWrite(FileObject, WriteLength,
                             (CanWait && !BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_IN_FSP)),
                             BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_DEFERRED_WRITE)))
            {
                BOOLEAN Retrying;
 
                Retrying = BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_DEFERRED_WRITE);
 
                RxPrePostIrp(RxContext, Irp);
 
                SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_DEFERRED_WRITE);
 
                CcDeferWrite(FileObject, (PCC_POST_DEFERRED_WRITE)RxAddToWorkque, RxContext, Irp, WriteLength, Retrying);
 
                return STATUS_PENDING;
            }
        }
    }
 
    /* Initialize the low IO context for write */
    RxInitializeLowIoContext(LowIoContext, LOWIO_OP_WRITE);
 
    /* Initialize our (many) booleans */
    RecursiveWriteThrough = FALSE;
    CalledByLazyWriter = FALSE;
    SwitchBackToAsync = FALSE;
    ExtendingFile = FALSE;
    ExtendingValidData = FALSE;
    UnwindOutstandingAsync = FALSE;
    ResourceOwnerSet = FALSE;
    PostIrp = FALSE;
    ContextReferenced = FALSE;
 
#define _SEH2_TRY_RETURN(S) S; goto try_exit
 
    _SEH2_TRY
    {
        /* No volume FCB here! */
        ASSERT((NodeTypeCode == RDBSS_NTC_STORAGE_TYPE_FILE) ||
               (NodeTypeCode == RDBSS_NTC_SPOOLFILE) ||
               (NodeTypeCode == RDBSS_NTC_MAILSLOT));
 
        /* Writing to EOF on a paging file is non sense */
        ASSERT(!(WriteToEof && PagingIo));
 
        RxItsTheSameContext();
 
        /* Start locking stuff */
        if (!PagingIo && !NoPreposting)
        {
            /* If it's already acquired, all fine */
            if (RxContext->FcbResourceAcquired)
            {
                ASSERT(!IsPipe);
            }
            else
            {
                /* Otherwise, try to acquire shared (excepted for pipes) */
                if (IsPipe)
                {
                    Status = RxAcquireExclusiveFcb(RxContext, Fcb);
                }
                else if (CanWait ||
                         (!NoCache && RxWriteCacheingAllowed(Fcb, SrvOpen)))
                {
                    Status = RxAcquireSharedFcb(RxContext, Fcb);
                }
                else
                {
                    Status = RxAcquireSharedFcbWaitForEx(RxContext, Fcb);
                }
 
                /* We'll post IRP to retry */
                if (Status == STATUS_LOCK_NOT_GRANTED)
                {
                    PostIrp = TRUE;
                    DPRINT1("Failed to acquire lock!\n");
                    _SEH2_TRY_RETURN(Status);
                }
 
                /* We'll just fail */
                if (Status != STATUS_SUCCESS)
                {
                    _SEH2_TRY_RETURN(Status);
                }
 
                /* Resource acquired */
                RxContext->FcbResourceAcquired = TRUE;
            }
 
            /* At that point, resource is acquired */
            if (IsPipe)
            {
                ASSERT(RxContext->FcbResourceAcquired);
            }
            else
            {
                BOOLEAN IsDormant;
 
                /* Now, check whether we have to promote shared lock */
                if (NodeTypeCode == RDBSS_NTC_STORAGE_TYPE_FILE && Fobx != NULL)
                {
                    IsDormant = BooleanFlagOn(Fobx->Flags, FOBX_FLAG_MARKED_AS_DORMANT);
                }
                else
                {
                    IsDormant = FALSE;
                }
 
                /* We're writing beyond VDL, we'll need an exclusive lock if not dormant */
                if (RxIsFcbAcquiredShared(Fcb) &&
                    ByteOffset.QuadPart + WriteLength > Fcb->Header.ValidDataLength.QuadPart)
                {
                    if (!IsDormant)
                    {
                        RxReleaseFcb(RxContext, Fcb);
                        RxContext->FcbResourceAcquired = FALSE;
 
                        Status = RxAcquireExclusiveFcb(RxContext, Fcb);
                        if (Status == STATUS_LOCK_NOT_GRANTED)
                        {
                            PostIrp = TRUE;
                            DPRINT1("Failed to acquire lock!\n");
                            _SEH2_TRY_RETURN(Status);
                        }
 
                        if (Status != STATUS_SUCCESS)
                        {
                            _SEH2_TRY_RETURN(Status);
                        }
 
                        RxContext->FcbResourceAcquired = TRUE;
                    }
                }
 
                /* If we're writing in VDL, or if we're dormant, shared lock is enough */
                if (ByteOffset.QuadPart + WriteLength <= Fcb->Header.ValidDataLength.QuadPart ||
                    IsDormant)
                {
                    if (RxIsFcbAcquiredExclusive(Fcb))
                    {
                        RxConvertToSharedFcb(RxContext, Fcb);
                    }
                }
                else
                {
                    /* We're extending file, disable collapsing */
                    ASSERT(RxIsFcbAcquiredExclusive(Fcb));
 
                    DPRINT("Disabling collapsing\n");
 
                    if (NodeTypeCode == RDBSS_NTC_STORAGE_TYPE_FILE && Fobx != NULL)
                    {
                        SetFlag(Fobx->Flags, FOBX_FLAG_DISABLE_COLLAPSING);
                    }
                }
 
                ASSERT(RxContext->FcbResourceAcquired);
            }
 
            /* Keep track of the acquired resource */
            LowIoContext->Resource = Fcb->Header.Resource;
        }
        else
        {
            /* Paging IO */
            ASSERT(!IsPipe);
 
            /* Lock the paging resource */
            RxAcquirePagingIoResourceShared(RxContext, Fcb, TRUE);
 
            /* Keep track of the acquired resource */
            LowIoContext->Resource = Fcb->Header.PagingIoResource;
        }
 
        if (IsPipe)
        {
            UNIMPLEMENTED;
            _SEH2_TRY_RETURN(Status = STATUS_NOT_IMPLEMENTED);
        }
 
        /* If it's a non cached write, or if caching is disallowed */
        if (NoCache || !RxWriteCacheingAllowed(Fcb, SrvOpen))
        {
            /* If cache was previously enabled, we'll have to flush before writing */
            if (!PagingIo && Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL)
            {
                LARGE_INTEGER FlushOffset;
 
                /* FCB is lock */
                ASSERT(RxIsFcbAcquiredExclusive(Fcb) || RxIsFcbAcquiredShared(Fcb));
 
                /* If shared, we'll have to relock exclusive */
                if (!RxIsFcbAcquiredExclusive(Fcb))
                {
                    /* Release and retry exclusive */
                    RxReleaseFcb(RxContext, Fcb);
                    RxContext->FcbResourceAcquired = FALSE;
 
                    Status = RxAcquireExclusiveFcb(RxContext, Fcb);
                    if (Status == STATUS_LOCK_NOT_GRANTED)
                    {
                        PostIrp = TRUE;
                        DPRINT1("Failed to acquire lock for flush!\n");
                        _SEH2_TRY_RETURN(Status);
                    }
 
                    if (Status != STATUS_SUCCESS)
                    {
                        _SEH2_TRY_RETURN(Status);
                    }
 
                    RxContext->FcbResourceAcquired = TRUE;
                }
 
                /* Get the length to flush */
                if (WriteToEof)
                {
                    RxGetFileSizeWithLock(Fcb, &FlushOffset.QuadPart);
                }
                else
                {
                    FlushOffset.QuadPart = ByteOffset.QuadPart;
                }
 
                /* Perform the flushing */
                RxAcquirePagingIoResource(RxContext, Fcb);
                CcFlushCache(&Fcb->NonPaged->SectionObjectPointers, &FlushOffset,
                             WriteLength, &Irp->IoStatus);
                RxReleasePagingIoResource(RxContext, Fcb);
 
                /* Cannot continue if flushing failed */
                if (!NT_SUCCESS(Irp->IoStatus.Status))
                {
                    _SEH2_TRY_RETURN(Status = Irp->IoStatus.Status);
                }
 
                /* Synchronize */
                RxAcquirePagingIoResource(RxContext, Fcb);
                RxReleasePagingIoResource(RxContext, Fcb);
 
                /* And purge */
                CcPurgeCacheSection(&Fcb->NonPaged->SectionObjectPointers,
                                    &FlushOffset, WriteLength, FALSE);
            }
        }
 
        /* If not paging IO, check if write is allowed */
        if (!PagingIo)
        {
            if (!FsRtlCheckLockForWriteAccess(&Fcb->Specific.Fcb.FileLock, Irp))
            {
                _SEH2_TRY_RETURN(Status = STATUS_FILE_LOCK_CONFLICT);
            }
        }
 
        /* Get file sizes */
        ValidDataLength = Fcb->Header.ValidDataLength.QuadPart;
        RxGetFileSizeWithLock(Fcb, &FileSize);
        ASSERT(ValidDataLength <= FileSize);
 
        /* If paging IO, we cannot write past file size
         * so fix write length if needed
         */
        if (PagingIo)
        {
            if (ByteOffset.QuadPart >= FileSize)
            {
                _SEH2_TRY_RETURN(Status = STATUS_SUCCESS);
            }
 
            if (WriteLength > FileSize - ByteOffset.QuadPart)
            {
                WriteLength = FileSize - ByteOffset.QuadPart;
            }
        }
 
        /* If we're being called by the lazywrite */
        if (Fcb->Specific.Fcb.LazyWriteThread == PsGetCurrentThread())
        {
            CalledByLazyWriter = TRUE;
 
            /* Fail if we're beyong VDL */
            if (BooleanFlagOn(Fcb->Header.Flags, FSRTL_FLAG_USER_MAPPED_FILE))
            {
                if ((ByteOffset.QuadPart + WriteLength > ValidDataLength) &&
                    (ByteOffset.QuadPart < FileSize))
                {
                    if (ByteOffset.QuadPart + WriteLength > ((ValidDataLength + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
                    {
                        _SEH2_TRY_RETURN(Status = STATUS_FILE_LOCK_CONFLICT);
                    }
                }
            }
        }
 
        /* If that's a recursive synchronous page write */
        if (BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) &&
            BooleanFlagOn(RxContext->Flags, RX_CONTEXT_FLAG_RECURSIVE_CALL))
        {
            PIRP TopIrp;
 
            /* Check the top level IRP on the FastIO path */
            TopIrp = RxGetTopIrpIfRdbssIrp();
            if (TopIrp != NULL && (ULONG_PTR)TopIrp > FSRTL_FAST_IO_TOP_LEVEL_IRP)
            {
                PIO_STACK_LOCATION IrpStack;
 
                ASSERT(NodeType(TopIrp) == IO_TYPE_IRP);
 
                /* If the top level IRP was a cached write for this file, keep track */
                IrpStack = IoGetCurrentIrpStackLocation(TopIrp);
                if (IrpStack->MajorFunction == IRP_MJ_WRITE &&
                    IrpStack->FileObject->FsContext == FileObject->FsContext)
                {
                    RecursiveWriteThrough = TRUE;
                    SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_WRITE_THROUGH);
                }
            }
        }
 
        /* Now, deal with file size and VDL */
        if (!CalledByLazyWriter && !RecursiveWriteThrough &&
            (WriteToEof || ByteOffset.QuadPart + WriteLength > ValidDataLength))
        {
            /* Not sync? Let's make it sync, just the time we extended */
            if (!Sync)
            {
                CanWait = TRUE;
                SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
                ClearFlag(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION);
                Sync = TRUE;
 
                /* Keep track we'll have to switch back to async */
                if (NoCache)
                {
                    SwitchBackToAsync = TRUE;
                }
            }
 
            /* Release all the locks */
            RxWriteReleaseResources(RxContext, 0);
 
            /* Acquire exclusive */
            Status = RxAcquireExclusiveFcb(RxContext, Fcb);
            if (Status == STATUS_LOCK_NOT_GRANTED)
            {
                PostIrp = TRUE;
                DPRINT1("Failed to acquire lock for extension!\n");
                _SEH2_TRY_RETURN(Status);
            }
 
            if (Status != STATUS_SUCCESS)
            {
                _SEH2_TRY_RETURN(Status);
            }
 
            RxContext->FcbResourceAcquired = TRUE;
 
            RxItsTheSameContext();
 
            /* Get the sizes again, to be sure they didn't change in the meantime */
            ValidDataLength = Fcb->Header.ValidDataLength.QuadPart;
            RxGetFileSizeWithLock(Fcb, &FileSize);
            ASSERT(ValidDataLength <= FileSize);
 
            /* Check we can switch back to async? */
            if ((SwitchBackToAsync && Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL) ||
                (ByteOffset.QuadPart + WriteLength > FileSize) || RxNoAsync)
            {
                SwitchBackToAsync = FALSE;
            }
 
            /* If paging IO, check we don't try to extend the file */
            if (PagingIo)
            {
                if (ByteOffset.QuadPart >= FileSize)
                {
                    _SEH2_TRY_RETURN(Status = STATUS_SUCCESS);
                }
 
                if (WriteLength > FileSize - ByteOffset.QuadPart)
                {
                    WriteLength = FileSize - ByteOffset.QuadPart;
                }
            }
        }
 
        /* Save our initial sizes for potential rollback */
        InitialFileSize = FileSize;
        InitialValidDataLength = ValidDataLength;
        /* If writing to EOF, update byte offset with file size */
        if (WriteToEof)
        {
            ByteOffset.QuadPart = FileSize;
        }
 
        /* Check again whether we're allowed to write */
        if (!PagingIo)
        {
            if (!FsRtlCheckLockForWriteAccess(&Fcb->Specific.Fcb.FileLock, Irp ))
            {
                _SEH2_TRY_RETURN(Status = STATUS_FILE_LOCK_CONFLICT);
            }
 
            /* Do we have to extend? */
            if (NormalFile && (ByteOffset.QuadPart + WriteLength > FileSize))
            {
                DPRINT("Need to extend file\n");
                ExtendingFile = TRUE;
                SetFlag(LowIoContext->ParamsFor.ReadWrite.Flags, LOWIO_READWRITEFLAG_EXTENDING_FILESIZE);
            }
        }
 
        /* Let's start to extend */
        if (ExtendingFile)
        {
            /* If we're past allocating, inform mini-rdr */
            FileSize = ByteOffset.QuadPart + WriteLength;
            if (FileSize > Fcb->Header.AllocationSize.QuadPart)
            {
                LARGE_INTEGER NewAllocationSize;
 
                DPRINT("Extending %p\n", RxContext);
 
                if (NoCache)
                {
                    C_ASSERT(sizeof(LONGLONG) == sizeof(LARGE_INTEGER));
                    MINIRDR_CALL(Status, RxContext, Fcb->MRxDispatch, MRxExtendForNonCache,
                                 (RxContext, (PLARGE_INTEGER)&FileSize, &NewAllocationSize));
                }
                else
                {
                    C_ASSERT(sizeof(LONGLONG) == sizeof(LARGE_INTEGER));
                    MINIRDR_CALL(Status, RxContext, Fcb->MRxDispatch, MRxExtendForCache,
                                 (RxContext, (PLARGE_INTEGER)&FileSize, &NewAllocationSize));
                }
 
                if (!NT_SUCCESS(Status))
                {
                    _SEH2_TRY_RETURN(Status);
                }
 
                if (FileSize > NewAllocationSize.QuadPart)
                {
                    NewAllocationSize.QuadPart = FileSize;
                }
 
                /* And update FCB */
                Fcb->Header.AllocationSize.QuadPart = NewAllocationSize.QuadPart;
            }
 
            /* Set the new sizes */
            RxSetFileSizeWithLock(Fcb, &FileSize);
            RxAdjustAllocationSizeforCC(Fcb);
 
            /* And inform Cc */
            if (CcIsFileCached(FileObject))
            {
                CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->Header.AllocationSize);
            }
        }
 
        /* Do we have to extend VDL? */
        if (!CalledByLazyWriter && !RecursiveWriteThrough)
        {
            if (WriteToEof || ByteOffset.QuadPart + WriteLength > ValidDataLength)
            {
                ExtendingValidData = TRUE;
                SetFlag(LowIoContext->ParamsFor.ReadWrite.Flags, LOWIO_READWRITEFLAG_EXTENDING_VDL);
            }
        }
 
        /* If none cached write */
        if (PagingIo || NoCache || !RxWriteCacheingAllowed(Fcb, SrvOpen))
        {
            /* Switch back to async, if asked to */
            if (SwitchBackToAsync)
            {
                CanWait = FALSE;
                Sync = FALSE;
 
                ClearFlag(RxContext->Flags, RX_CONTEXT_FLAG_WAIT);
                SetFlag(RxContext->Flags, RX_CONTEXT_FLAG_ASYNC_OPERATION);
            }
 
            /* If not synchronous, keep track of writes to be finished */
            if (!Sync)
            {
                if (Fcb->NonPaged->OutstandingAsyncEvent == NULL)
                {
                    Fcb->NonPaged->OutstandingAsyncEvent = &Fcb->NonPaged->TheActualEvent;
                    KeInitializeEvent(Fcb->NonPaged->OutstandingAsyncEvent,
                                      NotificationEvent, FALSE);
                }
 
                if (ExInterlockedAddUlong(&Fcb->NonPaged->OutstandingAsyncWrites,
                                          1,
                                          &RxStrucSupSpinLock) == 0)
                {
                    KeClearEvent(Fcb->NonPaged->OutstandingAsyncEvent);
                }
 
                UnwindOutstandingAsync = TRUE;
                LowIoContext->ParamsFor.ReadWrite.NonPagedFcb = Fcb->NonPaged;
            }
 
            /* Set our LOWIO_CONTEXT information */
            LowIoContext->ParamsFor.ReadWrite.ByteOffset = ByteOffset.QuadPart;
            LowIoContext->ParamsFor.ReadWrite.ByteCount = WriteLength;
 
            RxItsTheSameContext();
 
            /* We have to be locked */
            ASSERT(RxContext->FcbResourceAcquired || RxContext->FcbPagingIoResourceAcquired);
 
            /* Update thread ID if we're in FSP */
            if (InFsp)
            {
                LowIoContext->ResourceThreadId = (ULONG_PTR)RxContext | 3;
 
                if (RxContext->FcbResourceAcquired)
                {
                    ExSetResourceOwnerPointer(Fcb->Header.Resource, (PVOID)((ULONG_PTR)RxContext | 3));
                }
 
                if (RxContext->FcbPagingIoResourceAcquired)
                {
                    ExSetResourceOwnerPointer(Fcb->Header.PagingIoResource, (PVOID)((ULONG_PTR)RxContext | 3));
                }
 
                ResourceOwnerSet = TRUE;
            }
 
            /* And perform the write */
            Status = RxLowIoWriteShell(RxContext);
 
            RxItsTheSameContext();
 
            /* Not outstanding write anymore */
            if (UnwindOutstandingAsync && Status == STATUS_PENDING)
            {
                UnwindOutstandingAsync = FALSE;
            }
        }
        /* Cached write */
        else
        {
            /* If cache wasn't enabled yet, do it */
            if (FileObject->PrivateCacheMap == NULL)
            {
                if (BooleanFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    _SEH2_TRY_RETURN(Status = STATUS_FILE_CLOSED);
                }
 
                RxAdjustAllocationSizeforCC(Fcb);
 
                CcInitializeCacheMap(FileObject, (PCC_FILE_SIZES)&Fcb->Header.AllocationSize,
                                     FALSE, &RxData.CacheManagerCallbacks, Fcb);
 
                CcSetReadAheadGranularity(FileObject, NetRoot->DiskParameters.ReadAheadGranularity);
            }
 
            /* If that's a MDL backed write */
            if (BooleanFlagOn(RxContext->MinorFunction, IRP_MN_MDL))
            {
                /* Shouldn't happen */
                ASSERT(FALSE);
                ASSERT(CanWait);
 
                /* Perform it, though */
                CcPrepareMdlWrite(FileObject, &ByteOffset, WriteLength,
                                  &Irp->MdlAddress, &Irp->IoStatus);
 
                Status = Irp->IoStatus.Status;
            }
            else
            {
                PVOID SystemBuffer;
                ULONG BreakpointsSave;
 
                /* Map the user buffer */
                SystemBuffer = RxNewMapUserBuffer(RxContext);
                if (SystemBuffer == NULL)
                {
                    _SEH2_TRY_RETURN(Status = STATUS_INSUFFICIENT_RESOURCES);
                }
 
                RxSaveAndSetExceptionNoBreakpointFlag(RxContext, BreakpointsSave);