Patch by Elrond:

[reactos.git] / reactos / drivers / fs / np / rw.c

diff --git a/reactos/drivers/fs/np/rw.c b/reactos/drivers/fs/np/rw.c
index d07796b..e4f8cb2 100644 (file)
--- a/reactos/drivers/fs/np/rw.c
+++ b/reactos/drivers/fs/np/rw.c
@@ -1,5 +1,4 @@
-/* $Id$
- *
+/*
  * COPYRIGHT:  See COPYING in the top level directory
  * PROJECT:    ReactOS kernel
  * FILE:       drivers/fs/np/rw.c
@@ -9,13 +8,11 @@
 
 /* INCLUDES ******************************************************************/
 
-#include <ddk/ntddk.h>
-#include <rosrtl/minmax.h>
-#include "npfs.h"
-
 #define NDEBUG
 #include <debug.h>
 
+#include "npfs.h"
+
 /* FUNCTIONS *****************************************************************/
 
 #ifndef NDEBUG
@@ -28,7 +25,7 @@ VOID HexDump(PUCHAR Buffer, ULONG Length)
 
   DbgPrint("---------------\n");
 
-  for (i = 0; i < ROUND_UP(Length, 16); i+= 16)
+  for (i = 0; i < Length; i+= 16)
     {
       memset(Line, ' ', 64);
       Line[64] = 0;
@@ -46,7 +43,7 @@ VOID HexDump(PUCHAR Buffer, ULONG Length)
 }
 #endif
 
-static VOID STDCALL 
+static VOID STDCALL
 NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
                            IN PIRP Irp)
 {
@@ -67,7 +64,7 @@ NpfsReadWriteCancelRoutine(IN PDEVICE_OBJECT DeviceObject,
 
    KeLockMutex(&DeviceExt->PipeListLock);
    ExAcquireFastMutex(&Fcb->DataListLock);
-   switch(IoStack->MajorFunction)   
+   switch(IoStack->MajorFunction)
    {
       case IRP_MJ_READ:
          if (Fcb->ReadRequestListHead.Flink != &Context->ListEntry)
@@ -183,17 +180,18 @@ NpfsWaiterThread(PVOID InitContext)
                      NextIrp = CONTAINING_RECORD(NextContext, IRP, Tail.Overlay.DriverContext);
                      ThreadContext->WaitIrpArray[ThreadContext->Count] = NextIrp;
                      ThreadContext->Count++;
-                      ThreadContext->DeviceExt->EmptyWaiterCount--;               
+                      ThreadContext->DeviceExt->EmptyWaiterCount--;
                   }
+                  KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock);
                   break;
                default:
                   KEBUGCHECK(0);
             }
             ExReleaseFastMutex(&Fcb->DataListLock);
-         }         
+         }
        }
        else
-       {  
+       {
          /* someone has add a new wait request */
           Irp = NULL;
        }
@@ -205,7 +203,6 @@ NpfsWaiterThread(PVOID InitContext)
          Terminate = TRUE;
         }
      }
-   KeUnlockMutex(&ThreadContext->DeviceExt->PipeListLock);
    ExFreePool(ThreadContext);
 }
 
@@ -220,7 +217,7 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
    KIRQL oldIrql;
 
    PNPFS_CONTEXT Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
-   PNPFS_DEVICE_EXTENSION DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;;
+   PNPFS_DEVICE_EXTENSION DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    DPRINT("NpfsAddWaitingReadWriteRequest(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 
@@ -249,9 +246,9 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
        ThreadContext->Count = 1;
        ThreadContext->WaitObjectArray[0] = &ThreadContext->Event;
 
-   
+
        DPRINT("Creating a new system thread for waiting read/write requests\n");
-      
+
        Status = PsCreateSystemThread(&hThread,
                                     THREAD_ALL_ACCESS,
                                     NULL,
@@ -266,7 +263,7 @@ NpfsAddWaitingReadWriteRequest(IN PDEVICE_OBJECT DeviceObject,
            return Status;
         }
        InsertHeadList(&DeviceExt->ThreadListHead, &ThreadContext->ListEntry);
-       DeviceExt->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1;       
+       DeviceExt->EmptyWaiterCount += MAXIMUM_WAIT_OBJECTS - 1;
      }
    IoMarkIrpPending(Irp);
 
@@ -391,7 +388,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
      Information = Irp->IoStatus.Information;
      Length = IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length;
      ASSERT (Information <= Length);
-     Buffer += Information;
+     Buffer = (PVOID)((ULONG_PTR)Buffer + Information);
      Length -= Information;
      Status = STATUS_SUCCESS;
 
@@ -401,6 +398,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
         {
           if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE)
           {
+             ASSERT(Fcb->OtherSide != NULL);
              KeSetEvent(&Fcb->OtherSide->WriteEvent, IO_NO_INCREMENT, FALSE);
           }
           if (Information > 0 &&
@@ -431,11 +429,11 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
           }
           else
           {
-              PNPFS_CONTEXT Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
-           
+              Context = (PNPFS_CONTEXT)&Irp->Tail.Overlay.DriverContext;
+
               Context->WaitEvent = &Fcb->ReadEvent;
              Status = NpfsAddWaitingReadWriteRequest(DeviceObject, Irp);
-                
+
              if (NT_SUCCESS(Status))
              {
                 Status = STATUS_PENDING;
@@ -443,32 +441,33 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
              ExAcquireFastMutex(&Fcb->DataListLock);
              break;
           }
-        } 
+        }
+        ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
         if (Fcb->Pipe->ReadMode == FILE_PIPE_BYTE_STREAM_MODE)
         {
           DPRINT("Byte stream mode\n");
           /* Byte stream mode */
           while (Length > 0 && Fcb->ReadDataAvailable > 0)
           {
-             CopyLength = RtlRosMin(Fcb->ReadDataAvailable, Length);
-             if (Fcb->ReadPtr + CopyLength <= Fcb->Data + Fcb->MaxDataLength)
+             CopyLength = min(Fcb->ReadDataAvailable, Length);
+             if ((ULONG_PTR)Fcb->ReadPtr + CopyLength <= (ULONG_PTR)Fcb->Data + Fcb->MaxDataLength)
              {
                 memcpy(Buffer, Fcb->ReadPtr, CopyLength);
-                Fcb->ReadPtr += CopyLength;
-                if (Fcb->ReadPtr == Fcb->Data + Fcb->MaxDataLength)
+                Fcb->ReadPtr = (PVOID)((ULONG_PTR)Fcb->ReadPtr + CopyLength);
+                if (Fcb->ReadPtr == (PVOID)((ULONG_PTR)Fcb->Data + Fcb->MaxDataLength))
                 {
                    Fcb->ReadPtr = Fcb->Data;
                 }
              }
               else
              {
-                TempLength = Fcb->Data + Fcb->MaxDataLength - Fcb->ReadPtr;
+                TempLength = (ULONG)((ULONG_PTR)Fcb->Data + Fcb->MaxDataLength - (ULONG_PTR)Fcb->ReadPtr);
                 memcpy(Buffer, Fcb->ReadPtr, TempLength);
-                memcpy(Buffer + TempLength, Fcb->Data, CopyLength - TempLength);
-                Fcb->ReadPtr = Fcb->Data + CopyLength - TempLength;
+                memcpy((PVOID)((ULONG_PTR)Buffer + TempLength), Fcb->Data, CopyLength - TempLength);
+                Fcb->ReadPtr = (PVOID)((ULONG_PTR)Fcb->Data + CopyLength - TempLength);
              }
 
-             Buffer += CopyLength;
+             Buffer = (PVOID)((ULONG_PTR)Buffer + CopyLength);
              Length -= CopyLength;
              Information += CopyLength;
 
@@ -494,7 +493,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
           if (Fcb->ReadDataAvailable)
           {
              /* Truncate the message if the receive buffer is too small */
-             CopyLength = RtlRosMin(Fcb->ReadDataAvailable, Length);
+             CopyLength = min(Fcb->ReadDataAvailable, Length);
              memcpy(Buffer, Fcb->Data, CopyLength);
 
 #ifndef NDEBUG
@@ -506,7 +505,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
 
              if (Fcb->ReadDataAvailable > Length)
              {
-                memmove(Fcb->Data, Fcb->Data + Length,
+                memmove(Fcb->Data, (PVOID)((ULONG_PTR)Fcb->Data + Length),
                         Fcb->ReadDataAvailable - Length);
                 Fcb->ReadDataAvailable -= Length;
                 Status = STATUS_MORE_ENTRIES;
@@ -528,9 +527,11 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
               break;
           }
         }
-     }   
+     }
      Irp->IoStatus.Information = Information;
      Irp->IoStatus.Status = Status;
+     
+     ASSERT(IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL);
 
      if (IoIsOperationSynchronous(Irp))
      {
@@ -570,7 +571,7 @@ NpfsRead(IN PDEVICE_OBJECT DeviceObject,
         Context = CONTAINING_RECORD(Fcb->ReadRequestListHead.Flink, NPFS_CONTEXT, ListEntry);
        Irp = CONTAINING_RECORD(Context, IRP, Tail.Overlay.DriverContext);
      }
-  }    
+  }
 
 done:
   Irp->IoStatus.Status = Status;
@@ -668,7 +669,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
          ExReleaseFastMutex(&ReaderFcb->DataListLock);
 
          DPRINT("Waiting for buffer space (%S)\n", Pipe->PipeName.Buffer);
-         Status = KeWaitForSingleObject(&Fcb->WriteEvent, 
+         Status = KeWaitForSingleObject(&Fcb->WriteEvent,
                                         UserRequest,
                                         KernelMode,
                                         FALSE,
@@ -694,22 +695,22 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
          DPRINT("Byte stream mode\n");
          while (Length > 0 && ReaderFcb->WriteQuotaAvailable > 0)
            {
-             CopyLength = RtlRosMin(Length, ReaderFcb->WriteQuotaAvailable);
-             if (ReaderFcb->WritePtr + CopyLength <= ReaderFcb->Data + ReaderFcb->MaxDataLength)
+             CopyLength = min(Length, ReaderFcb->WriteQuotaAvailable);
+             if ((ULONG_PTR)ReaderFcb->WritePtr + CopyLength <= (ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength)
                {
                  memcpy(ReaderFcb->WritePtr, Buffer, CopyLength);
-                 ReaderFcb->WritePtr += CopyLength;
-                 if (ReaderFcb->WritePtr == ReaderFcb->Data + ReaderFcb->MaxDataLength)
+                 ReaderFcb->WritePtr = (PVOID)((ULONG_PTR)ReaderFcb->WritePtr + CopyLength);
+                 if ((ULONG_PTR)ReaderFcb->WritePtr == (ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength)
                    {
                      ReaderFcb->WritePtr = ReaderFcb->Data;
                    }
                }
              else
                {
-                 TempLength = ReaderFcb->Data + ReaderFcb->MaxDataLength - ReaderFcb->WritePtr;
+                 TempLength = (ULONG)((ULONG_PTR)ReaderFcb->Data + ReaderFcb->MaxDataLength - (ULONG_PTR)ReaderFcb->WritePtr);
                  memcpy(ReaderFcb->WritePtr, Buffer, TempLength);
                  memcpy(ReaderFcb->Data, Buffer + TempLength, CopyLength - TempLength);
-                 ReaderFcb->WritePtr = ReaderFcb->Data + CopyLength - TempLength;
+                 ReaderFcb->WritePtr = (PVOID)((ULONG_PTR)ReaderFcb->Data + CopyLength - TempLength);
                }
 
              Buffer += CopyLength;
@@ -732,7 +733,7 @@ NpfsWrite(PDEVICE_OBJECT DeviceObject,
          DPRINT("Message mode\n");
          if (Length > 0)
            {
-             CopyLength = RtlRosMin(Length, ReaderFcb->WriteQuotaAvailable);
+             CopyLength = min(Length, ReaderFcb->WriteQuotaAvailable);
              memcpy(ReaderFcb->Data, Buffer, CopyLength);
 
              Information = CopyLength;