sys: wq: FspWq* routiens

sys: write: initial implementation

build/VStudio/winfsp_sys.vcxproj

@@ -170,6 +170,7 @@
     <ClCompile Include="..\..\src\sys\util.c" />
     <ClCompile Include="..\..\src\sys\volinfo.c" />
     <ClCompile Include="..\..\src\sys\volume.c" />
+    <ClCompile Include="..\..\src\sys\wq.c" />
     <ClCompile Include="..\..\src\sys\write.c" />
   </ItemGroup>
   <ItemGroup>

build/VStudio/winfsp_sys.vcxproj.filters

@@ -89,6 +89,9 @@
     <ClCompile Include="..\..\src\sys\meta.c">
       <Filter>Source</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\sys\wq.c">
+      <Filter>Source</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\src\sys\driver.h">

src/sys/driver.h

@@ -322,10 +322,15 @@ PVOID FspAllocateIrpMustSucceed(CCHAR StackSize);
 BOOLEAN FspUnicodePathIsValid(PUNICODE_STRING Path, BOOLEAN AllowStreams);
 VOID FspUnicodePathSuffix(PUNICODE_STRING Path, PUNICODE_STRING Remain, PUNICODE_STRING Suffix);
 NTSTATUS FspCreateGuid(GUID *Guid);
+NTSTATUS FspLockUserBuffer(PVOID UserBuffer, ULONG Length,
+    KPROCESSOR_MODE RequestorMode, LOCK_OPERATION Operation, PMDL *PMdl);
 NTSTATUS FspCcSetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes);
+NTSTATUS FspCcMdlWriteComplete(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PMDL MdlChain);
 NTSTATUS FspQuerySecurityDescriptorInfo(SECURITY_INFORMATION SecurityInformation,
     PSECURITY_DESCRIPTOR SecurityDescriptor, PULONG PLength,
     PSECURITY_DESCRIPTOR ObjectsSecurityDescriptor);
+#define FspSetTopLevelIrp(Irp)          (IoGetTopLevelIrp() ? FALSE : (IoSetTopLevelIrp(Irp), TRUE))
+#define FspResetTopLevelIrp(TopLevel)   ((TopLevel) ? IoSetTopLevelIrp(0) : (void)0)
 
 /* utility: synchronous work queue */
 typedef struct
@@ -431,6 +436,8 @@ enum
     FspIopCreateRequestFunnel(I, F, E, 0, FspIopRequestMustSucceed, P)
 #define FspIopCreateRequestEx(I, F, E, RF, P)\
     FspIopCreateRequestFunnel(I, F, E, RF, 0, P)
+#define FspIopCreateRequestWorkItem(I, E, RF, P)\
+    FspIopCreateRequestFunnel(I, 0, E, RF, FspIopRequestNonPaged, P)
 #define FspIopRequestContext(Request, I)\
     (*FspIopRequestContextAddress(Request, I))
 #define FspIopPostWorkRequest(D, R)     FspIopPostWorkRequestFunnel(D, R, FALSE)
@@ -454,6 +461,24 @@ FSP_FSCTL_TRANSACT_RSP *FspIopIrpResponse(PIRP Irp);
 NTSTATUS FspIopDispatchPrepare(PIRP Irp, FSP_FSCTL_TRANSACT_REQ *Request);
 NTSTATUS FspIopDispatchComplete(PIRP Irp, const FSP_FSCTL_TRANSACT_RSP *Response);
 
+/* work queue processing */
+enum
+{
+    FspWqRequestIrpAndFlags             = 0,
+    FspWqRequestWorkRoutine             = 1,
+};
+typedef NTSTATUS FSP_WQ_REQUEST_WORK(
+    PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp,
+    BOOLEAN CanWait);
+NTSTATUS FspWqCreateAndPostIrpWorkItem(PIRP Irp,
+    FSP_WQ_REQUEST_WORK *WorkRoutine, FSP_IOP_REQUEST_FINI *RequestFini,
+    BOOLEAN CreateAndPost);
+VOID FspWqPostIrpWorkItem(PIRP Irp);
+#define FspWqCreateIrpWorkItem(I, RW, RF)\
+    FspWqCreateAndPostIrpWorkItem(I, RW, RF, FALSE)
+#define FspWqRepostIrpWorkItem(I, RW, RF)\
+    FspWqCreateAndPostIrpWorkItem(I, RW, RF, TRUE)
+
 /* device management */
 #define FSP_DEVICE_VOLUME_NAME_LENMAX   (FSP_FSCTL_VOLUME_NAME_SIZEMAX - sizeof(WCHAR))
 enum

src/sys/util.c

@@ -9,7 +9,10 @@
 BOOLEAN FspUnicodePathIsValid(PUNICODE_STRING Path, BOOLEAN AllowStreams);
 VOID FspUnicodePathSuffix(PUNICODE_STRING Path, PUNICODE_STRING Remain, PUNICODE_STRING Suffix);
 NTSTATUS FspCreateGuid(GUID *Guid);
+NTSTATUS FspLockUserBuffer(PVOID UserBuffer, ULONG Length,
+    KPROCESSOR_MODE RequestorMode, LOCK_OPERATION Operation, PMDL *PMdl);
 NTSTATUS FspCcSetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes);
+NTSTATUS FspCcMdlWriteComplete(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PMDL MdlChain);
 NTSTATUS FspQuerySecurityDescriptorInfo(SECURITY_INFORMATION SecurityInformation,
     PSECURITY_DESCRIPTOR SecurityDescriptor, PULONG PLength,
     PSECURITY_DESCRIPTOR ObjectsSecurityDescriptor);
@@ -26,7 +29,9 @@ static KDEFERRED_ROUTINE FspQueueDelayedWorkItemDPC;
 #pragma alloc_text(PAGE, FspUnicodePathIsValid)
 #pragma alloc_text(PAGE, FspUnicodePathSuffix)
 #pragma alloc_text(PAGE, FspCreateGuid)
+#pragma alloc_text(PAGE, FspLockUserBuffer)
 #pragma alloc_text(PAGE, FspCcSetFileSizes)
+#pragma alloc_text(PAGE, FspCcMdlWriteComplete)
 #pragma alloc_text(PAGE, FspQuerySecurityDescriptorInfo)
 #pragma alloc_text(PAGE, FspInitializeSynchronousWorkItem)
 #pragma alloc_text(PAGE, FspExecuteSynchronousWorkItem)
@@ -153,6 +158,31 @@ NTSTATUS FspCreateGuid(GUID *Guid)
     return Result;
 }
 
+NTSTATUS FspLockUserBuffer(PVOID UserBuffer, ULONG Length,
+    KPROCESSOR_MODE RequestorMode, LOCK_OPERATION Operation, PMDL *PMdl)
+{
+    PAGED_CODE();
+
+    *PMdl = 0;
+
+    PMDL Mdl = IoAllocateMdl(UserBuffer, Length, FALSE, FALSE, 0);
+    if (0 == Mdl)
+        return STATUS_INSUFFICIENT_RESOURCES;
+
+    try
+    {
+        MmProbeAndLockPages(Mdl, RequestorMode, Operation);
+    }
+    except (EXCEPTION_EXECUTE_HANDLER)
+    {
+        IoFreeMdl(Mdl);
+        return GetExceptionCode();
+    }
+
+    *PMdl = Mdl;
+    return STATUS_SUCCESS;
+}
+
 NTSTATUS FspCcSetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes)
 {
     PAGED_CODE();
@@ -162,12 +192,28 @@ NTSTATUS FspCcSetFileSizes(PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes)
         CcSetFileSizes(FileObject, FileSizes);
         return STATUS_SUCCESS;
     }
-    except(EXCEPTION_EXECUTE_HANDLER)
+    except (EXCEPTION_EXECUTE_HANDLER)
     {
         return GetExceptionCode();
     }
 }
 
+NTSTATUS FspCcMdlWriteComplete(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PMDL MdlChain)
+{
+    PAGED_CODE();
+
+    try
+    {
+        CcMdlWriteComplete(FileObject, FileOffset, MdlChain);
+        return STATUS_SUCCESS;
+    }
+    except (EXCEPTION_EXECUTE_HANDLER)
+    {
+        CcMdlWriteAbort(FileObject, MdlChain);
+        return GetExceptionCode();
+    }
+}
+
 NTSTATUS FspQuerySecurityDescriptorInfo(SECURITY_INFORMATION SecurityInformation,
     PSECURITY_DESCRIPTOR SecurityDescriptor, PULONG PLength,
     PSECURITY_DESCRIPTOR ObjectsSecurityDescriptor)
@@ -200,16 +246,18 @@ VOID FspInitializeSynchronousWorkItem(FSP_SYNCHRONOUS_WORK_ITEM *SynchronousWork
     ExInitializeWorkItem(&SynchronousWorkItem->WorkQueueItem,
         FspExecuteSynchronousWorkItemRoutine, SynchronousWorkItem);
 }
+
 VOID FspExecuteSynchronousWorkItem(FSP_SYNCHRONOUS_WORK_ITEM *SynchronousWorkItem)
 {
     PAGED_CODE();
 
-    ExQueueWorkItem(&SynchronousWorkItem->WorkQueueItem, DelayedWorkQueue);
+    ExQueueWorkItem(&SynchronousWorkItem->WorkQueueItem, CriticalWorkQueue);
 
     NTSTATUS Result;
     Result = KeWaitForSingleObject(&SynchronousWorkItem->Event, Executive, KernelMode, FALSE, 0);
     ASSERT(STATUS_SUCCESS == Result);
 }
+
 static VOID FspExecuteSynchronousWorkItemRoutine(PVOID Context)
 {
     PAGED_CODE();

src/sys/wq.c

@@ -0,0 +1,74 @@
+/**
+ * @file sys/wq.c
+ *
+ * @copyright 2015 Bill Zissimopoulos
+ */
+
+#include <sys/driver.h>
+
+static VOID FspWqWorkRoutine(PVOID Context);
+
+NTSTATUS FspWqCreateAndPostIrpWorkItem(PIRP Irp,
+    FSP_WQ_REQUEST_WORK *WorkRoutine, FSP_IOP_REQUEST_FINI *RequestFini,
+    BOOLEAN CreateAndPost)
+{
+    FSP_FSCTL_TRANSACT_REQ *RequestWorkItem = FspIrpRequest(Irp);
+
+    if (0 == RequestWorkItem)
+    {
+        NTSTATUS Result = FspIopCreateRequestWorkItem(Irp, sizeof(WORK_QUEUE_ITEM),
+            RequestFini, &RequestWorkItem);
+        if (!NT_SUCCESS(Result))
+            return Result;
+
+        ASSERT(sizeof(FSP_WQ_REQUEST_WORK *) == sizeof(PVOID));
+
+        PIRP TopLevelIrp = IoGetTopLevelIrp();
+        FspIopRequestContext(RequestWorkItem, FspWqRequestIrpAndFlags) =
+            (PVOID)((UINT_PTR)Irp | (0 == TopLevelIrp || Irp == TopLevelIrp));
+        FspIopRequestContext(RequestWorkItem, FspWqRequestWorkRoutine) =
+            (PVOID)(UINT_PTR)WorkRoutine;
+        ExInitializeWorkItem((PWORK_QUEUE_ITEM)&RequestWorkItem->Buffer, FspWqWorkRoutine, Irp);
+    }
+
+    if (!CreateAndPost)
+        return STATUS_SUCCESS;
+
+    FspWqPostIrpWorkItem(Irp);
+    return STATUS_PENDING;
+}
+
+VOID FspWqPostIrpWorkItem(PIRP Irp)
+{
+    FSP_FSCTL_TRANSACT_REQ *RequestWorkItem = FspIrpRequest(Irp);
+
+    ASSERT(RequestWorkItem->Kind == FspFsctlTransactReservedKind);
+    ASSERT(RequestWorkItem->Size == sizeof *RequestWorkItem + sizeof(WORK_QUEUE_ITEM));
+    ASSERT(RequestWorkItem->Hint == (UINT_PTR)Irp);
+
+    IoMarkIrpPending(Irp);
+    ExQueueWorkItem((PWORK_QUEUE_ITEM)&RequestWorkItem->Buffer, CriticalWorkQueue);
+}
+
+static VOID FspWqWorkRoutine(PVOID Context)
+{
+    PIRP Irp = Context;
+    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
+    FSP_FSCTL_TRANSACT_REQ *RequestWorkItem = FspIrpRequest(Irp);
+    BOOLEAN TopLevel = (BOOLEAN)
+        ((UINT_PTR)FspIopRequestContext(RequestWorkItem, FspWqRequestIrpAndFlags) & 1);
+    FSP_WQ_REQUEST_WORK *WorkRoutine = (FSP_WQ_REQUEST_WORK *)(UINT_PTR)
+        FspIopRequestContext(RequestWorkItem, FspWqRequestWorkRoutine);
+    NTSTATUS Result;
+
+    IoSetTopLevelIrp(TopLevel ? Irp : (PIRP)FSRTL_FSP_TOP_LEVEL_IRP);
+
+    Result = WorkRoutine(IrpSp->DeviceObject, Irp, IrpSp, FALSE);
+    if (STATUS_PENDING != Result)
+    {
+        DEBUGLOGIRP(Irp, Result);
+        FspIopCompleteIrp(Irp, Result);
+    }
+
+    IoSetTopLevelIrp(0);
+}

src/sys/write.c

@@ -7,18 +7,124 @@
 #include <sys/driver.h>
 
 static NTSTATUS FspFsvolWrite(
-    PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
+static NTSTATUS FspFsvolWriteCached(
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp,
+    BOOLEAN CanWait);
+static VOID FspFsvolWriteCachedDeferred(PVOID Context1, PVOID Context2);
+static NTSTATUS FspFsvolWriteNonCached(
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp);
 FSP_IOCMPL_DISPATCH FspFsvolWriteComplete;
 FSP_DRIVER_DISPATCH FspWrite;
 
 #ifdef ALLOC_PRAGMA
 #pragma alloc_text(PAGE, FspFsvolWrite)
+#pragma alloc_text(PAGE, FspFsvolWriteCached)
+#pragma alloc_text(PAGE, FspFsvolWriteCachedDeferred)
+#pragma alloc_text(PAGE, FspFsvolWriteNonCached)
 #pragma alloc_text(PAGE, FspFsvolWriteComplete)
 #pragma alloc_text(PAGE, FspWrite)
 #endif
 
 static NTSTATUS FspFsvolWrite(
-    PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
+    PAGED_CODE();
+
+    /* is this a valid FileObject? */
+    if (!FspFileNodeIsValid(IrpSp->FileObject->FsContext))
+        return STATUS_INVALID_DEVICE_REQUEST;
+
+    NTSTATUS Result;
+    BOOLEAN TopLevel = FspSetTopLevelIrp(Irp);
+
+    /* is this an MDL complete request? */
+    if (FlagOn(IrpSp->MinorFunction, IRP_MN_COMPLETE))
+    {
+        Result = FspCcMdlWriteComplete(IrpSp->FileObject,
+            &IrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress);
+        Irp->MdlAddress = 0;
+        goto exit;
+    }
+
+    /* do we have anything to write? */
+    if (0 == IrpSp->Parameters.Write.Length)
+    {
+        Irp->IoStatus.Information = 0;
+        Result = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    /* probe and lock the user buffer */
+    if (0 == Irp->MdlAddress)
+    {
+        Result = FspLockUserBuffer(Irp->UserBuffer, IrpSp->Parameters.Write.Length,
+            Irp->RequestorMode, IoReadAccess, &Irp->MdlAddress);
+        if (!NT_SUCCESS(Result))
+            goto exit;
+    }
+
+    if (!FlagOn(Irp->Flags, IRP_NOCACHE))
+        Result = FspFsvolWriteCached(FsvolDeviceObject, Irp, IrpSp, IoIsOperationSynchronous(Irp));
+    else
+        Result = FspFsvolWriteNonCached(FsvolDeviceObject, Irp, IrpSp);
+
+exit:
+    FspResetTopLevelIrp(TopLevel);
+
+    return Result;
+}
+
+static NTSTATUS FspFsvolWriteCached(
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp,
+    BOOLEAN CanWait)
+{
+    PAGED_CODE();
+
+    NTSTATUS Result;
+    FSP_FSCTL_TRANSACT_REQ *RequestWorkItem = FspIrpRequest(Irp);
+    PFILE_OBJECT FileObject = IrpSp->FileObject;
+    FSP_FILE_NODE *FileNode = FileObject->FsContext;
+    FSP_FILE_DESC *FileDesc = FileObject->FsContext2;
+#if 0
+    ULONG WriteKey = IrpSp->Parameters.Write.Key;
+    LARGE_INTEGER WriteOffset = IrpSp->Parameters.Write.ByteOffset;
+#endif
+    ULONG WriteLength = IrpSp->Parameters.Write.Length;
+#if 0
+    BOOLEAN WriteToEof =
+        FILE_WRITE_TO_END_OF_FILE == WriteOffset.LowPart && -1L == WriteOffset.HighPart;
+#endif
+
+    ASSERT(FileNode == FileDesc->FileNode);
+
+    /* should we defer the write? */
+    if (DEBUGRANDTEST(10, TRUE) ||
+        !CcCanIWrite(FileObject, WriteLength, CanWait, 0 != RequestWorkItem))
+    {
+        Result = FspWqCreateIrpWorkItem(Irp, FspFsvolWriteCached, 0);
+        if (NT_SUCCESS(Result))
+        {
+            IoMarkIrpPending(Irp);
+            CcDeferWrite(FileObject, FspFsvolWriteCachedDeferred, Irp, 0, WriteLength,
+                0 != RequestWorkItem);
+
+            return STATUS_PENDING;
+        }
+
+        /* if we are unable to defer we will go ahead and (try to) service the IRP now! */
+    }
+
+    return STATUS_INVALID_DEVICE_REQUEST;
+}
+
+static VOID FspFsvolWriteCachedDeferred(PVOID Context1, PVOID Context2)
+{
+    FspWqPostIrpWorkItem(Context1);
+}
+
+static NTSTATUS FspFsvolWriteNonCached(
+    PDEVICE_OBJECT FsvolDeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 {
     PAGED_CODE();
 
@@ -30,7 +136,13 @@ NTSTATUS FspFsvolWriteComplete(
 {
     FSP_ENTER_IOC(PAGED_CODE());
 
-    FSP_LEAVE_IOC("%s", "");
+    FSP_LEAVE_IOC(
+        "FileObject=%p, UserBuffer=%p, MdlAddress=%p, "
+        "Key=%#lx, ByteOffset=%#lx:%#lx, Length=%ld",
+        IrpSp->FileObject, Irp->UserBuffer, Irp->MdlAddress,
+        IrpSp->Parameters.Write.Key,
+        IrpSp->Parameters.Write.ByteOffset.HighPart, IrpSp->Parameters.Write.ByteOffset.LowPart,
+        IrpSp->Parameters.Write.Length);
 }
 
 NTSTATUS FspWrite(
@@ -46,5 +158,11 @@ NTSTATUS FspWrite(
         FSP_RETURN(Result = STATUS_INVALID_DEVICE_REQUEST);
     }
 
-    FSP_LEAVE_MJ("%s", "");
+    FSP_LEAVE_MJ(
+        "FileObject=%p, UserBuffer=%p, MdlAddress=%p, "
+        "Key=%#lx, ByteOffset=%#lx:%#lx, Length=%ld",
+        IrpSp->FileObject, Irp->UserBuffer, Irp->MdlAddress,
+        IrpSp->Parameters.Write.Key,
+        IrpSp->Parameters.Write.ByteOffset.HighPart, IrpSp->Parameters.Write.ByteOffset.LowPart,
+        IrpSp->Parameters.Write.Length);
 }