reactos/ntoskrnl/fs/fastio.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/fs/fastio.c
   5  * PURPOSE:         File System Routines which support Fast I/O or Cc Access.
   6  *
   7  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   8  */
   9
  10 /* INCLUDES ****************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <internal/debug.h>
  15
  16 /* GLOBALS *******************************************************************/
  17
  18 extern ULONG CcFastReadResourceMiss;
  19 extern ULONG CcFastReadNoWait;
  20
  21 /* FUNCTIONS *****************************************************************/
  22
  23 /*
  24  * @implemented
  25  */
  26 VOID
  27 STDCALL
  28 FsRtlIncrementCcFastReadResourceMiss( VOID )
  29 {
  30     CcFastReadResourceMiss++;
  31 }
  32
  33 /*
  34  * @implemented
  35  */
  36 VOID
  37 STDCALL
  38 FsRtlIncrementCcFastReadNotPossible( VOID )
  39 {
  40     CcFastReadNotPossible++;
  41 }
  42
  43 /*
  44  * @implemented
  45  */
  46 VOID
  47 STDCALL
  48 FsRtlIncrementCcFastReadWait( VOID )
  49 {
  50     CcFastReadWait++;
  51 }
  52
  53 /*
  54  * @implemented
  55  */
  56 VOID
  57 STDCALL
  58 FsRtlIncrementCcFastReadNoWait( VOID )
  59 {
  60     CcFastReadNoWait++;
  61 }
  62
  63 /*
  64  * NAME    EXPORTED
  65  * FsRtlCopyRead@32
  66  *
  67  * DESCRIPTION
  68  *
  69  * ARGUMENTS
  70  *
  71  * RETURN VALUE
  72  *
  73  * NOTE
  74  *  From Bo Branten's ntifs.h v12.
  75  *
  76  * @unimplemented
  77  */
  78 BOOLEAN
  79 STDCALL
  80 FsRtlCopyRead(IN  PFILE_OBJECT FileObject,
  81               IN  PLARGE_INTEGER FileOffset,
  82               IN  ULONG Length,
  83               IN  BOOLEAN Wait,
  84               IN  ULONG LockKey,
  85               OUT PVOID Buffer,
  86               OUT PIO_STATUS_BLOCK IoStatus,
  87               IN  PDEVICE_OBJECT DeviceObject)
  88 {
  89     UNIMPLEMENTED;
  90     return FALSE;
  91 }
  92
  93 /*
  94  * NAME    EXPORTED
  95  * FsRtlCopyWrite@32
  96  *
  97  * DESCRIPTION
  98  *
  99  * ARGUMENTS
 100  *
 101  * RETURN VALUE
 102  *
 103  * NOTE
 104  *  From Bo Branten's ntifs.h v12.
 105  *
 106  * @unimplemented
 107  */
 108 BOOLEAN
 109 STDCALL
 110 FsRtlCopyWrite(IN  PFILE_OBJECT FileObject,
 111                IN  PLARGE_INTEGER FileOffset,
 112                IN  ULONG Length,
 113                IN  BOOLEAN Wait,
 114                IN  ULONG LockKey,
 115                OUT PVOID Buffer,
 116                OUT PIO_STATUS_BLOCK IoStatus,
 117                IN  PDEVICE_OBJECT DeviceObject)
 118 {
 119     UNIMPLEMENTED;
 120     return FALSE;
 121 }
 122
 123 /*
 124  * NAME    EXPORTED
 125  * FsRtlGetFileSize@8
 126  *
 127  * DESCRIPTION
 128  *
 129  * ARGUMENTS
 130  *
 131  * RETURN VALUE
 132  *
 133  * @implemented
 134  */
 135 NTSTATUS
 136 STDCALL
 137 FsRtlGetFileSize(IN PFILE_OBJECT  FileObject,
 138                  IN OUT PLARGE_INTEGER FileSize)
 139 {
 140     FILE_STANDARD_INFORMATION Info;
 141     NTSTATUS Status;
 142     IO_STATUS_BLOCK IoStatusBlock;
 143     ULONG Length;
 144     PDEVICE_OBJECT DeviceObject;
 145     PFAST_IO_DISPATCH FastDispatch;
 146
 147     /* Get Device Object and Fast Calls */
 148     DeviceObject = IoGetRelatedDeviceObject(FileObject);
 149     FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 150
 151     /* Check if we support Fast Calls, and check this one */
 152     if (FastDispatch && FastDispatch->FastIoQueryStandardInfo)
 153     {
 154         /* Fast Path */
 155         FastDispatch->FastIoQueryStandardInfo(FileObject,
 156                                               TRUE,
 157                                               &Info,
 158                                               &IoStatusBlock,
 159                                               DeviceObject);
 160         Status = IoStatusBlock.Status;
 161     }
 162     else
 163     {
 164         /* Slow Path */
 165         Status = IoQueryFileInformation(FileObject,
 166                                         FileStandardInformation,
 167                                         sizeof(Info),
 168                                         &Info,
 169                                         &Length);
 170     }
 171
 172     /* Check success */
 173     if (NT_SUCCESS(Status))
 174     {
 175         *FileSize = Info.EndOfFile;
 176     }
 177
 178     /* Return status */
 179     return Status;
 180 }
 181
 182 /*
 183  * NAME    EXPORTED
 184  * FsRtlMdlRead@24
 185  *
 186  * DESCRIPTION
 187  *
 188  * ARGUMENTS
 189  *
 190  * RETURN VALUE
 191  *
 192  * @implemented
 193  */
 194 BOOLEAN
 195 STDCALL
 196 FsRtlMdlRead(IN PFILE_OBJECT FileObject,
 197              IN PLARGE_INTEGER FileOffset,
 198              IN ULONG Length,
 199              IN ULONG LockKey,
 200              OUT PMDL *MdlChain,
 201              OUT PIO_STATUS_BLOCK IoStatus)
 202 {
 203     PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
 204     PFAST_IO_DISPATCH FastDispatch;
 205
 206     /* Get Device Object and Fast Calls */
 207     DeviceObject = IoGetRelatedDeviceObject(FileObject);
 208     FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 209
 210     /* Check if we support Fast Calls, and check this one */
 211     if (FastDispatch && FastDispatch->MdlRead)
 212     {
 213         /* Use the fast path */
 214         return FastDispatch->MdlRead(FileObject,
 215                                      FileOffset,
 216                                      Length,
 217                                      LockKey,
 218                                      MdlChain,
 219                                      IoStatus,
 220                                      DeviceObject);
 221     }
 222
 223     /* Get the Base File System (Volume) and Fast Calls */
 224     BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
 225     FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 226
 227     /* If the Base Device Object has its own FastDispatch Routine, fail */
 228     if (FastDispatch && FastDispatch->MdlRead &&
 229         BaseDeviceObject != DeviceObject)
 230     {
 231         return FALSE;
 232     }
 233
 234     /* No fast path, use slow path */
 235     return FsRtlMdlReadDev(FileObject,
 236                            FileOffset,
 237                            Length,
 238                            LockKey,
 239                            MdlChain,
 240                            IoStatus,
 241                            DeviceObject);
 242 }
 243
 244 /*
 245  * NAME    EXPORTED
 246  * FsRtlMdlReadComplete@8
 247  *
 248  * DESCRIPTION
 249  *
 250  * ARGUMENTS
 251  *
 252  * RETURN VALUE
 253  *
 254  * @implemented
 255  */
 256 BOOLEAN
 257 STDCALL
 258 FsRtlMdlReadComplete(IN PFILE_OBJECT FileObject,
 259                      IN OUT PMDL MdlChain)
 260 {
 261     PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
 262     PFAST_IO_DISPATCH FastDispatch;
 263
 264     /* Get Device Object and Fast Calls */
 265     DeviceObject = IoGetRelatedDeviceObject(FileObject);
 266     FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 267
 268     /* Check if we support Fast Calls, and check this one */
 269     if (FastDispatch && FastDispatch->MdlReadComplete)
 270     {
 271         /* Use the fast path */
 272         return FastDispatch->MdlReadComplete(FileObject,
 273                                              MdlChain,
 274                                              DeviceObject);
 275     }
 276
 277     /* Get the Base File System (Volume) and Fast Calls */
 278     BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
 279     FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 280
 281     /* If the Base Device Object has its own FastDispatch Routine, fail */
 282     if (FastDispatch && FastDispatch->MdlReadComplete &&
 283         BaseDeviceObject != DeviceObject)
 284     {
 285         return FALSE;
 286     }
 287
 288     /* No fast path, use slow path */
 289     return FsRtlMdlReadCompleteDev(FileObject, MdlChain, DeviceObject);
 290 }
 291
 292
 293 /*
 294  * NAME    EXPORTED
 295  * FsRtlMdlReadCompleteDev@12
 296  *
 297  * DESCRIPTION
 298  *
 299  * ARGUMENTS
 300  *
 301  * RETURN VALUE
 302  *
 303  * NOTE
 304  * From Bo Branten's ntifs.h v13.
 305  * (CcMdlReadCompleteDev declared in internal/cc.h)
 306  *
 307  * @implemented
 308  */
 309 BOOLEAN
 310 STDCALL
 311 FsRtlMdlReadCompleteDev(IN PFILE_OBJECT FileObject,
 312                         IN PMDL MdlChain,
 313                         IN PDEVICE_OBJECT DeviceObject)
 314 {
 315     /* Call the Cache Manager */
 316     CcMdlReadCompleteDev(MdlChain, FileObject);
 317     return TRUE;
 318 }
 319
 320 /*
 321  * NAME    EXPORTED
 322  * FsRtlMdlReadDev@28
 323  *
 324  * DESCRIPTION
 325  *
 326  * ARGUMENTS
 327  *
 328  * RETURN VALUE
 329  *
 330  * @unimplemented
 331  */
 332 BOOLEAN
 333 STDCALL
 334 FsRtlMdlReadDev(IN PFILE_OBJECT FileObject,
 335                 IN PLARGE_INTEGER FileOffset,
 336                 IN ULONG Length,
 337                 IN ULONG LockKey,
 338                 OUT PMDL *MdlChain,
 339                 OUT PIO_STATUS_BLOCK IoStatus,
 340                 IN PDEVICE_OBJECT DeviceObject)
 341 {
 342     UNIMPLEMENTED;
 343     return FALSE;
 344 }
 345
 346
 347 /*
 348  * NAME    EXPORTED
 349  * FsRtlMdlWriteComplete@12
 350  *
 351  * DESCRIPTION
 352  *
 353  * ARGUMENTS
 354  *
 355  * RETURN VALUE
 356  *
 357  * @implemented
 358  */
 359 BOOLEAN
 360 STDCALL
 361 FsRtlMdlWriteComplete(IN PFILE_OBJECT FileObject,
 362                       IN PLARGE_INTEGER FileOffset,
 363                       IN PMDL MdlChain)
 364 {
 365     PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
 366     PFAST_IO_DISPATCH FastDispatch;
 367
 368     /* Get Device Object and Fast Calls */
 369     DeviceObject = IoGetRelatedDeviceObject(FileObject);
 370     FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 371
 372     /* Check if we support Fast Calls, and check this one */
 373     if (FastDispatch && FastDispatch->MdlWriteComplete)
 374     {
 375         /* Use the fast path */
 376         return FastDispatch->MdlWriteComplete(FileObject,
 377                                               FileOffset,
 378                                               MdlChain,
 379                                               DeviceObject);
 380     }
 381
 382     /* Get the Base File System (Volume) and Fast Calls */
 383     BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
 384     FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 385
 386     /* If the Base Device Object has its own FastDispatch Routine, fail */
 387     if (FastDispatch && FastDispatch->MdlWriteComplete &&
 388         BaseDeviceObject != DeviceObject)
 389     {
 390         return FALSE;
 391     }
 392
 393     /* No fast path, use slow path */
 394     return FsRtlMdlWriteCompleteDev(FileObject,
 395                                     FileOffset,
 396                                     MdlChain,
 397                                     DeviceObject);
 398 }
 399
 400 /*
 401  * NAME EXPORTED
 402  * FsRtlMdlWriteCompleteDev@16
 403  *
 404  * DESCRIPTION
 405  *
 406  * ARGUMENTS
 407  *
 408  * RETURN VALUE
 409  *
 410  * @implemented
 411  */
 412 BOOLEAN
 413 STDCALL
 414 FsRtlMdlWriteCompleteDev(IN PFILE_OBJECT FileObject,
 415                          IN PLARGE_INTEGER FileOffset,
 416                          IN PMDL MdlChain,
 417                          IN PDEVICE_OBJECT DeviceObject)
 418 {
 419     /* Call the Cache Manager */
 420     CcMdlWriteCompleteDev(FileOffset, MdlChain, FileObject);
 421     return TRUE;
 422 }
 423
 424
 425 /*
 426  * NAME    EXPORTED
 427  * FsRtlPrepareMdlWrite@24
 428  *
 429  * DESCRIPTION
 430  *
 431  * ARGUMENTS
 432  *
 433  * RETURN VALUE
 434  *
 435  * @implemented
 436  */
 437 BOOLEAN
 438 STDCALL
 439 FsRtlPrepareMdlWrite(IN  PFILE_OBJECT FileObject,
 440                      IN  PLARGE_INTEGER FileOffset,
 441                      IN  ULONG Length,
 442                      IN  ULONG LockKey,
 443                      OUT PMDL *MdlChain,
 444                      OUT PIO_STATUS_BLOCK IoStatus)
 445 {
 446     PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
 447     PFAST_IO_DISPATCH FastDispatch;
 448
 449     /* Get Device Object and Fast Calls */
 450     DeviceObject = IoGetRelatedDeviceObject(FileObject);
 451     FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 452
 453     /* Check if we support Fast Calls, and check this one */
 454     if (FastDispatch && FastDispatch->PrepareMdlWrite)
 455     {
 456         /* Use the fast path */
 457         return FastDispatch->PrepareMdlWrite(FileObject,
 458                                              FileOffset,
 459                                              Length,
 460                                              LockKey,
 461                                              MdlChain,
 462                                              IoStatus,
 463                                              DeviceObject);
 464     }
 465
 466     /* Get the Base File System (Volume) and Fast Calls */
 467     BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
 468     FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 469
 470     /* If the Base Device Object has its own FastDispatch Routine, fail */
 471     if (FastDispatch && FastDispatch->PrepareMdlWrite &&
 472         BaseDeviceObject != DeviceObject)
 473     {
 474         return FALSE;
 475     }
 476
 477     /* No fast path, use slow path */
 478     return FsRtlPrepareMdlWriteDev(FileObject,
 479                                    FileOffset,
 480                                    Length,
 481                                    LockKey,
 482                                    MdlChain,
 483                                    IoStatus,
 484                                    DeviceObject);
 485 }
 486
 487 /*
 488  * NAME EXPORTED
 489  * FsRtlPrepareMdlWriteDev@28
 490  *
 491  * DESCRIPTION
 492  *
 493  * ARGUMENTS
 494  *
 495  * RETURN VALUE
 496  *
 497  * @unimplemented
 498  */
 499 BOOLEAN
 500 STDCALL
 501 FsRtlPrepareMdlWriteDev(IN  PFILE_OBJECT FileObject,
 502                         IN  PLARGE_INTEGER FileOffset,
 503                         IN  ULONG Length,
 504                         IN  ULONG LockKey,
 505                         OUT PMDL *MdlChain,
 506                         OUT PIO_STATUS_BLOCK IoStatus,
 507                         IN PDEVICE_OBJECT DeviceObject)
 508 {
 509     UNIMPLEMENTED;
 510     return FALSE;
 511 }
 512
 513 /* EOF */