reactos/ntoskrnl/fs/mdl.c

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