ntoskrnl/fs/mdl.c

   1 /* $Id$
   2  *
   3  * reactos/ntoskrnl/fs/mdl.c
   4  *
   5  */
   6 #include <ntos.h>
   7 #include <internal/cc.h>
   8 #include <ddk/ntifs.h>
   9
  10 /**********************************************************************
  11  * NAME                                                 EXPORTED
  12  *      FsRtlMdlRead@24
  13  *
  14  * DESCRIPTION
  15  *
  16  * ARGUMENTS
  17  *
  18  * RETURN VALUE
  19  *
  20  */
  21 BOOLEAN
  22 STDCALL
  23 FsRtlMdlRead (
  24         IN      PFILE_OBJECT            FileObject,
  25         IN      PLARGE_INTEGER          FileOffset,
  26         IN      ULONG                   Length,
  27         IN      ULONG                   LockKey,
  28         OUT     PMDL                    *MdlChain,
  29         OUT     PIO_STATUS_BLOCK        IoStatus
  30         )
  31 {
  32         return FALSE; /* FIXME: call FsRtlMdlReadDev ? */
  33 }
  34
  35
  36 /**********************************************************************
  37  * NAME                                                 EXPORTED
  38  *      FsRtlMdlReadComplete@8
  39  *
  40  * DESCRIPTION
  41  *
  42  * ARGUMENTS
  43  *
  44  * RETURN VALUE
  45  *
  46  */
  47 BOOLEAN STDCALL
  48 FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject,
  49                      IN OUT PMDL Mdl)
  50 {
  51         PDEVICE_OBJECT  DeviceObject [2] = {NULL};
  52         PDRIVER_OBJECT  DriverObject = NULL;
  53
  54         /*
  55          * Try fast I/O first
  56          */
  57         DeviceObject [0] = IoGetRelatedDeviceObject (FileObject);
  58         DriverObject = DeviceObject [0]->DriverObject;
  59         if (NULL != DriverObject->FastIoDispatch)
  60         {
  61 #if 0
  62                 if (IRP_MJ_READ <= DriverObject->FastIoDispatch->Count)
  63                 {
  64                         return FALSE;
  65                 }
  66                 if (NULL == DriverObject->FastIoDispatch->Dispatch [IRP_MJ_READ])
  67                 {
  68                         return FALSE;
  69                 }
  70                 return DriverObject->FastIoDispatch->Dispatch
  71                         [IRP_MJ_READ] (
  72                                 Mdl,
  73                                 NULL /* FIXME: how to get the IRP? */
  74                                 );
  75 #endif
  76         }
  77         /*
  78          * Default I/O path
  79          */
  80         DeviceObject [1] = IoGetBaseFileSystemDeviceObject (FileObject);
  81         /*
  82          * Did IoGetBaseFileSystemDeviceObject ()
  83          * returned the same device
  84          * IoGetRelatedDeviceObject () returned?
  85          */
  86         if (DeviceObject [1] != DeviceObject [0])
  87         {
  88 #if 0
  89                 DriverObject = DeviceObject [1]->DriverObject;
  90                 if (NULL != DriverObject->FastIoDispatch)
  91                 {
  92                         /*
  93                          * Check if the driver provides
  94                          * IRP_MJ_READ.
  95                          */
  96                         if (IRP_MJ_READ <= DriverObject->FastIoDispatch->Count)
  97                         {
  98                                 if (NULL == DriverObject->FastIoDispatch->Dispatch [IRP_MJ_READ])
  99                                 {
 100                                         return FALSE;
 101                                 }
 102                         }
 103                 }
 104 #endif
 105                 DeviceObject [0] = DeviceObject [1];
 106         }
 107         return FsRtlMdlReadCompleteDev (
 108                         FileObject,
 109                         Mdl,
 110                         DeviceObject [0]
 111                         );
 112 }
 113
 114
 115 /**********************************************************************
 116  * NAME                                                 EXPORTED
 117  *      FsRtlMdlReadCompleteDev@12
 118  *
 119  * DESCRIPTION
 120  *
 121  * ARGUMENTS
 122  *
 123  * RETURN VALUE
 124  *
 125  * NOTE
 126  *      From Bo Branten's ntifs.h v13.
 127  *      (CcMdlReadCompleteDev declared in internal/cc.h)
 128  */
 129 BOOLEAN
 130 STDCALL
 131 FsRtlMdlReadCompleteDev (
 132         IN      PFILE_OBJECT    FileObject,
 133         IN      PMDL            MdlChain,
 134         IN      PDEVICE_OBJECT  DeviceObject
 135         )
 136 {
 137         FileObject = FileObject; /* unused parameter */
 138         CcMdlReadCompleteDev (MdlChain, DeviceObject);
 139         return TRUE;
 140 }
 141
 142
 143 /**********************************************************************
 144  * NAME                                                 EXPORTED
 145  *      FsRtlMdlReadDev@28
 146  *
 147  * DESCRIPTION
 148  *
 149  * ARGUMENTS
 150  *
 151  * RETURN VALUE
 152  *
 153  */
 154 BOOLEAN
 155 STDCALL
 156 FsRtlMdlReadDev (
 157         IN      PFILE_OBJECT            FileObject,
 158         IN      PLARGE_INTEGER          FileOffset,
 159         IN      ULONG                   Length,
 160         IN      ULONG                   LockKey,
 161         OUT     PMDL                    *MdlChain,
 162         OUT     PIO_STATUS_BLOCK        IoStatus,
 163         IN      PDEVICE_OBJECT          DeviceObject
 164         )
 165 {
 166         return FALSE;
 167 }
 168
 169
 170 /**********************************************************************
 171  * NAME                                                 EXPORTED
 172  *      FsRtlMdlWriteComplete@12
 173  *
 174  * DESCRIPTION
 175  *
 176  * ARGUMENTS
 177  *
 178  * RETURN VALUE
 179  *
 180  */
 181 BOOLEAN
 182 STDCALL
 183 FsRtlMdlWriteComplete (
 184         IN      PFILE_OBJECT    FileObject,
 185         IN      PLARGE_INTEGER  FileOffset,
 186         IN      PMDL            MdlChain
 187         )
 188 {
 189         return FALSE; /* FIXME: call FsRtlMdlWriteCompleteDev ? */
 190 }
 191
 192
 193 /**********************************************************************
 194  * NAME                                                 EXPORTED
 195  *      FsRtlMdlWriteCompleteDev@16
 196  *
 197  * DESCRIPTION
 198  *
 199  * ARGUMENTS
 200  *
 201  * RETURN VALUE
 202  *
 203  */
 204 BOOLEAN
 205 STDCALL
 206 FsRtlMdlWriteCompleteDev (
 207         IN      PFILE_OBJECT    FileObject,
 208         IN      PLARGE_INTEGER  FileOffset,
 209         IN      PMDL            MdlChain,
 210         IN      PDEVICE_OBJECT  DeviceObject
 211         )
 212 {
 213         return FALSE;
 214 }
 215
 216
 217 /**********************************************************************
 218  * NAME                                                 EXPORTED
 219  *      FsRtlPrepareMdlWrite@24
 220  *
 221  * DESCRIPTION
 222  *
 223  * ARGUMENTS
 224  *
 225  * RETURN VALUE
 226  *
 227  */
 228 BOOLEAN
 229 STDCALL
 230 FsRtlPrepareMdlWrite (
 231         IN      PFILE_OBJECT            FileObject,
 232         IN      PLARGE_INTEGER          FileOffset,
 233         IN      ULONG                   Length,
 234         IN      ULONG                   LockKey,
 235         OUT     PMDL                    *MdlChain,
 236         OUT     PIO_STATUS_BLOCK        IoStatus
 237         )
 238 {
 239         return FALSE; /* call FsRtlPrepareMdlWriteDev ? */
 240 }
 241
 242
 243 /**********************************************************************
 244  * NAME                                                 EXPORTED
 245  *      FsRtlPrepareMdlWriteDev@28
 246  *
 247  * DESCRIPTION
 248  *
 249  * ARGUMENTS
 250  *
 251  * RETURN VALUE
 252  *
 253  */
 254 BOOLEAN
 255 STDCALL
 256 FsRtlPrepareMdlWriteDev (
 257         IN      PFILE_OBJECT            FileObject,
 258         IN      PLARGE_INTEGER          FileOffset,
 259         IN      ULONG                   Length,
 260         IN      ULONG                   LockKey,
 261         OUT     PMDL                    *MdlChain,
 262         OUT     PIO_STATUS_BLOCK        IoStatus,
 263         IN      PDEVICE_OBJECT          DeviceObject
 264         )
 265 {
 266         return FALSE;
 267 }
 268
 269
 270 /* EOF */