ntoskrnl/io/page.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/io/page.c
   6  * PURPOSE:
   7  * PROGRAMMER:
   8  * UPDATE HISTORY:
   9  *
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15 #include <internal/io.h>
  16
  17 #define NDEBUG
  18 #include <internal/debug.h>
  19
  20 /* FUNCTIONS *****************************************************************/
  21
  22 #ifndef LIBCAPTIVE
  23
  24 NTSTATUS STDCALL
  25 IoPageWrite(PFILE_OBJECT FileObject,
  26             PMDL Mdl,
  27             PLARGE_INTEGER Offset,
  28             PKEVENT Event,
  29             PIO_STATUS_BLOCK StatusBlock)
  30 {
  31    PIRP Irp;
  32    PIO_STACK_LOCATION StackPtr;
  33    NTSTATUS Status;
  34
  35    DPRINT("IoPageWrite(FileObject %x, Mdl %x)\n",
  36           FileObject, Mdl);
  37
  38    Irp = IoBuildSynchronousFsdRequestWithMdl(IRP_MJ_WRITE,
  39                                              FileObject->DeviceObject,
  40                                              Mdl,
  41                                              Offset,
  42                                              Event,
  43                                              StatusBlock,
  44                                              TRUE);
  45    if (Irp == NULL)
  46    {
  47       return (STATUS_INSUFFICIENT_RESOURCES);
  48    }
  49    Irp->Flags = IRP_NOCACHE|IRP_PAGING_IO;
  50    StackPtr = IoGetNextIrpStackLocation(Irp);
  51    StackPtr->FileObject = FileObject;
  52    DPRINT("Before IoCallDriver\n");
  53    Status = IofCallDriver(FileObject->DeviceObject,Irp);
  54    /* FIXME: IoBuildSynchronousFsdRequestWithMdl() will fill 'StatusBlock' to 'Irp->UserIoSb'
  55     * but W32 filesystem takes care just of 'Irp->IoStatus'. Hack it back here.
  56     */
  57    *StatusBlock=Irp->IoStatus;
  58    DPRINT("Status %d STATUS_PENDING %d\n",Status,STATUS_PENDING);
  59    return(Status);
  60 }
  61
  62 #endif /* LIBCAPTIVE */
  63
  64 NTSTATUS STDCALL
  65 IoPageRead(PFILE_OBJECT FileObject,
  66            PMDL Mdl,
  67            PLARGE_INTEGER Offset,
  68            PKEVENT Event,
  69            PIO_STATUS_BLOCK StatusBlock)
  70 {
  71    PIRP Irp;
  72    PIO_STACK_LOCATION StackPtr;
  73    NTSTATUS Status;
  74
  75    DPRINT("IoPageRead(FileObject %x, Mdl %x)\n",
  76           FileObject, Mdl);
  77
  78    Irp = IoBuildSynchronousFsdRequestWithMdl(IRP_MJ_READ,
  79                                              FileObject->DeviceObject,
  80                                              Mdl,
  81                                              Offset,
  82                                              Event,
  83                                              StatusBlock,
  84                                              TRUE);
  85    if (Irp == NULL)
  86    {
  87       return (STATUS_INSUFFICIENT_RESOURCES);
  88    }
  89    Irp->Flags = IRP_NOCACHE
  90 #ifndef LIBCAPTIVE
  91          |IRP_PAGING_IO;
  92 #else /* !LIBCAPTIVE */
  93 /* IRP_SYNCHRONOUS_PAGING_IO: We need to prevent STATUS_PENDING
  94  * IRP_PAGING_IO: We need to pass check in W32 filesystem as we are FO_CLEANUP_COMPLETE (why?)
  95  */
  96          |IRP_PAGING_IO|IRP_SYNCHRONOUS_PAGING_IO;
  97 #endif /* !LIBCAPTIVE */
  98    StackPtr = IoGetNextIrpStackLocation(Irp);
  99    StackPtr->FileObject = FileObject;
 100    DPRINT("Before IoCallDriver\n");
 101    Status = IofCallDriver(FileObject->DeviceObject, Irp);
 102    /* FIXME: IoBuildSynchronousFsdRequestWithMdl() will fill 'StatusBlock' to 'Irp->UserIoSb'
 103     * but W32 filesystem takes care just of 'Irp->IoStatus'. Hack it back here.
 104     */
 105    *StatusBlock=Irp->IoStatus;
 106    DPRINT("Status %d STATUS_PENDING %d\n",Status,STATUS_PENDING);
 107
 108    return(Status);
 109 }
 110
 111 NTSTATUS STDCALL
 112 IoSynchronousPageWrite (PFILE_OBJECT FileObject,
 113                         PMDL Mdl,
 114                         PLARGE_INTEGER Offset,
 115                         PKEVENT Event,
 116                         PIO_STATUS_BLOCK StatusBlock)
 117 {
 118    PIRP Irp;
 119    PIO_STACK_LOCATION StackPtr;
 120    NTSTATUS Status;
 121
 122    DPRINT("IoSynchronousPageWrite(FileObject %x, Mdl %x)\n",
 123           FileObject, Mdl);
 124
 125    Irp = IoBuildSynchronousFsdRequestWithMdl(IRP_MJ_WRITE,
 126                                              FileObject->DeviceObject,
 127                                              Mdl,
 128                                              Offset,
 129                                              Event,
 130                                              StatusBlock,
 131                                              TRUE);
 132    if (Irp == NULL)
 133    {
 134       return (STATUS_INSUFFICIENT_RESOURCES);
 135    }
 136    Irp->Flags = IRP_NOCACHE|IRP_PAGING_IO|IRP_SYNCHRONOUS_PAGING_IO;
 137    StackPtr = IoGetNextIrpStackLocation(Irp);
 138    StackPtr->FileObject = FileObject;
 139    DPRINT("Before IoCallDriver\n");
 140    Status = IofCallDriver(FileObject->DeviceObject,Irp);
 141    /* FIXME: IoBuildSynchronousFsdRequestWithMdl() will fill 'StatusBlock' to 'Irp->UserIoSb'
 142     * but W32 filesystem takes care just of 'Irp->IoStatus'. Hack it back here.
 143     */
 144    *StatusBlock=Irp->IoStatus;
 145    DPRINT("Status %d STATUS_PENDING %d\n",Status,STATUS_PENDING);
 146    return(Status);
 147 }
 148
 149 /* EOF */