- Update to r53061

[reactos.git] / drivers / filesystems / npfs / rw.c

diff --git a/drivers/filesystems/npfs/rw.c b/drivers/filesystems/npfs/rw.c
index e5ef963..e8547f5 100644 (file)
--- a/drivers/filesystems/npfs/rw.c
+++ b/drivers/filesystems/npfs/rw.c
@@ -21,7 +21,7 @@ VOID HexDump(PUCHAR Buffer, ULONG Length)
     CHAR Line[65];
     UCHAR ch;
     const char Hex[] = "0123456789ABCDEF";
-    int i, j;
+    ULONG i, j;
 
     DbgPrint("---------------\n");
 
@@ -48,8 +48,8 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
                            IN PIRP Irp)
 {
     PNPFS_CONTEXT Context;
-    PNPFS_DEVICE_EXTENSION DeviceExt;
     PIO_STACK_LOCATION IoStack;
+    PNPFS_VCB Vcb;
     PNPFS_CCB Ccb;
     PLIST_ENTRY ListEntry;
     PNPFS_THREAD_CONTEXT ThreadContext;
@@ -60,17 +60,17 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
     IoReleaseCancelSpinLock(Irp->CancelIrql);
 
     Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
-    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+    Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
     IoStack = IoGetCurrentIrpStackLocation(Irp);
     Ccb = IoStack->FileObject->FsContext2;
 
-    KeLockMutex(&DeviceExt->PipeListLock);
+    KeLockMutex(&Vcb->PipeListLock);
     ExAcquireFastMutex(&Ccb->DataListLock);
     switch(IoStack->MajorFunction)
     {
     case IRP_MJ_READ:
-        ListEntry = DeviceExt->ThreadListHead.Flink;
-        while (ListEntry != &DeviceExt->ThreadListHead)
+        ListEntry = Vcb->ThreadListHead.Flink;
+        while (ListEntry != &Vcb->ThreadListHead)
         {
             ThreadContext = CONTAINING_RECORD(ListEntry, NPFS_THREAD_CONTEXT, ListEntry);
             /* Real events start at index 1 */
@@ -92,7 +92,7 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
                     KeSetEvent(&ThreadContext->Event, IO_NO_INCREMENT, FALSE);
 
                     ExReleaseFastMutex(&Ccb->DataListLock);
-                    KeUnlockMutex(&DeviceExt->PipeListLock);
+                    KeUnlockMutex(&Vcb->PipeListLock);
 
                     return;
                 }
@@ -103,7 +103,7 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
         RemoveEntryList(&Context->ListEntry);
 
         ExReleaseFastMutex(&Ccb->DataListLock);
-        KeUnlockMutex(&DeviceExt->PipeListLock);
+        KeUnlockMutex(&Vcb->PipeListLock);
 
         Irp->IoStatus.Status = STATUS_CANCELLED;
         Irp->IoStatus.Information = 0;
@@ -126,12 +126,12 @@ NpfsWaiterThread(PVOID InitContext)
     PIO_STACK_LOCATION IoStack = NULL;
     KIRQL OldIrql;
 
-    KeLockMutex(&ThreadContext->DeviceExt->PipeListLock);
+    KeLockMutex(&ThreadContext->Vcb->PipeListLock);
 
     while (1)
     {
         CurrentCount = ThreadContext->Count;
-        KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock);
+        KeUnlockMutex(&ThreadContext->Vcb->PipeListLock);
         IoAcquireCancelSpinLock(&OldIrql);
         if (Irp && IoSetCancelRoutine(Irp, NULL) != NULL)
         {
@@ -162,14 +162,14 @@ NpfsWaiterThread(PVOID InitContext)
         {
             ASSERT(FALSE);
         }
-        KeLockMutex(&ThreadContext->DeviceExt->PipeListLock);
+        KeLockMutex(&ThreadContext->Vcb->PipeListLock);
         Count = Status - STATUS_WAIT_0;
         ASSERT (Count < CurrentCount);
         if (Count > 0)
         {
             Irp = ThreadContext->WaitIrpArray[Count];
             ThreadContext->Count--;
-            ThreadContext->DeviceExt->EmptyWaiterCount++;
+            ThreadContext->Vcb->EmptyWaiterCount++;
             ThreadContext->WaitObjectArray[Count] = ThreadContext->WaitObjectArray[ThreadContext->Count];
             ThreadContext->WaitIrpArray[Count] = ThreadContext->WaitIrpArray[ThreadContext->Count];
         }
@@ -184,22 +184,21 @@ NpfsWaiterThread(PVOID InitContext)
                 if (ThreadContext->WaitIrpArray[i] == NULL)
                 {
                    ThreadContext->Count--;
-                   ThreadContext->DeviceExt->EmptyWaiterCount++;
+                   ThreadContext->Vcb->EmptyWaiterCount++;
                    ThreadContext->WaitObjectArray[i] = ThreadContext->WaitObjectArray[ThreadContext->Count];
                    ThreadContext->WaitIrpArray[i] = ThreadContext->WaitIrpArray[ThreadContext->Count];
                 }
             }
         }
-        if (ThreadContext->Count == 1 && ThreadContext->DeviceExt->EmptyWaiterCount >= MAXIMUM_WAIT_OBJECTS)
+        if (ThreadContext->Count == 1 && ThreadContext->Vcb->EmptyWaiterCount >= MAXIMUM_WAIT_OBJECTS)
         {
             /* it exist an other thread with empty wait slots, we can remove our thread from the list */
             RemoveEntryList(&ThreadContext->ListEntry);
-            ThreadContext->DeviceExt->EmptyWaiterCount -= MAXIMUM_WAIT_OBJECTS - 1;
-            KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock);
+            ExFreePoolWithTag(ThreadContext, TAG_NPFS_THREAD_CONTEXT);
+            KeUnlockMutex(&ThreadContext->Vcb->PipeListLock);
             break;
         }
     }
-    ExFreePool(ThreadContext);
 }
 
 static NTSTATUS
@@ -208,19 +207,21 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
 {
     PLIST_ENTRY ListEntry;
     PNPFS_THREAD_CONTEXT ThreadContext = NULL;
-    NTSTATUS Status;
+    PNPFS_CONTEXT Context;
     HANDLE hThread;
+    PNPFS_VCB Vcb;
     KIRQL oldIrql;
+    NTSTATUS Status;
 
-    PNPFS_CONTEXT Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
-    PNPFS_DEVICE_EXTENSION DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+    Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
+    Vcb = (PNPFS_VCB)DeviceObject->DeviceExtension;
 
     DPRINT("NpfsAddWaitingReadWriteRequest(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 
-    KeLockMutex(&DeviceExt->PipeListLock);
+    KeLockMutex(&Vcb->PipeListLock);
 
-    ListEntry = DeviceExt->ThreadListHead.Flink;
-    while (ListEntry != &DeviceExt->ThreadListHead)
+    ListEntry = Vcb->ThreadListHead.Flink;
+    while (ListEntry != &Vcb->ThreadListHead)
     {
         ThreadContext = CONTAINING_RECORD(ListEntry, NPFS_THREAD_CONTEXT, ListEntry);
         if (ThreadContext->Count < MAXIMUM_WAIT_OBJECTS)
@@ -229,20 +230,23 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
         }
         ListEntry = ListEntry->Flink;
     }
-    if (ListEntry == &DeviceExt->ThreadListHead)
+
+    if (ListEntry == &Vcb->ThreadListHead)
     {
-        ThreadContext = ExAllocatePool(NonPagedPool, sizeof(NPFS_THREAD_CONTEXT));
+        ThreadContext = ExAllocatePoolWithTag(NonPagedPool,
+                                              sizeof(NPFS_THREAD_CONTEXT),
+                                              TAG_NPFS_THREAD_CONTEXT);
         if (ThreadContext == NULL)
         {
-            KeUnlockMutex(&DeviceExt->PipeListLock);
+            KeUnlockMutex(&Vcb->PipeListLock);
             return STATUS_NO_MEMORY;
         }
-        ThreadContext->DeviceExt = DeviceExt;
+
+        ThreadContext->Vcb = Vcb;
         KeInitializeEvent(&ThreadContext->Event, SynchronizationEvent, FALSE);
         ThreadContext->Count = 1;
         ThreadContext->WaitObjectArray[0] = &ThreadContext->Event;
 
-
         DPRINT("Creating a new system thread for waiting read/write requests\n");
 
         Status = PsCreateSystemThread(&hThread,
@@ -254,12 +258,13 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
             (PVOID)ThreadContext);
         if (!NT_SUCCESS(Status))
         {
-            ExFreePool(ThreadContext);
-            KeUnlockMutex(&DeviceExt->PipeListLock);
+            ExFreePoolWithTag(ThreadContext, TAG_NPFS_THREAD_CONTEXT);
+            KeUnlockMutex(&Vcb->PipeListLock);
             return Status;
         }
-        InsertHeadList(&DeviceExt->ThreadListHead, &ThreadContext->ListEntry);
-        DeviceExt->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1;
+
+        InsertHeadList(&Vcb->ThreadListHead, &ThreadContext->ListEntry);
+        Vcb->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1;
     }
     IoMarkIrpPending(Irp);
 
@@ -276,11 +281,11 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
         ThreadContext->WaitObjectArray[ThreadContext->Count] = Context->WaitEvent;
         ThreadContext->WaitIrpArray[ThreadContext->Count] = Irp;
         ThreadContext->Count++;
-        DeviceExt->EmptyWaiterCount--;
+        Vcb->EmptyWaiterCount--;
         KeSetEvent(&ThreadContext->Event, IO_NO_INCREMENT, FALSE);
         Status = STATUS_SUCCESS;
     }
-    KeUnlockMutex(&DeviceExt->PipeListLock);
+    KeUnlockMutex(&Vcb->PipeListLock);
     return Status;
 }
 
@@ -303,6 +308,20 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
 
     DPRINT("NpfsRead(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 
+    FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
+    DPRINT("FileObject %p\n", FileObject);
+    DPRINT("Pipe name %wZ\n", &FileObject->FileName);
+    Ccb = FileObject->FsContext2;
+
+    /* Fail, if the CCB is not a pipe CCB */
+    if (Ccb->Type != CCB_PIPE)
+    {
+        DPRINT("Not a pipe!\n");
+        Status = STATUS_INVALID_PARAMETER;
+        Irp->IoStatus.Information = 0;
+        goto done;
+    }
+
     if (Irp->MdlAddress == NULL)
     {
         DPRINT("Irp->MdlAddress == NULL\n");
@@ -311,10 +330,6 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
         goto done;
     }
 
-    FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
-    DPRINT("FileObject %p\n", FileObject);
-    DPRINT("Pipe name %wZ\n", &FileObject->FileName);
-    Ccb = FileObject->FsContext2;
     Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
 
     if ((Ccb->OtherSide) && (Ccb->OtherSide->PipeState == FILE_PIPE_DISCONNECTED_STATE) && (Ccb->PipeState == FILE_PIPE_DISCONNECTED_STATE))
@@ -624,7 +639,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
                         Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
                         Length -= CopyLength;
                     }
-                    else 
+                    else
                     {
                         KeResetEvent(&Ccb->ReadEvent);
 
@@ -732,7 +747,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
     NTSTATUS Status = STATUS_SUCCESS;
     ULONG Length;
     ULONG Offset;
-    ULONG Information;
+    ULONG Information = 0;
     ULONG CopyLength;
     ULONG TempLength;
 
@@ -744,12 +759,21 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
     DPRINT("Pipe name %wZ\n", &FileObject->FileName);
 
     Ccb = FileObject->FsContext2;
+
+    /* Fail, if the CCB is not a pipe CCB */
+    if (Ccb->Type != CCB_PIPE)
+    {
+        DPRINT("Not a pipe!\n");
+        Status = STATUS_INVALID_PARAMETER;
+        Length = 0;
+        goto done;
+    }
+
     ReaderCcb = Ccb->OtherSide;
     Fcb = Ccb->Fcb;
 
     Length = IoStack->Parameters.Write.Length;
     Offset = IoStack->Parameters.Write.ByteOffset.u.LowPart;
-    Information = 0;
 
     if (Irp->MdlAddress == NULL)
     {