reactos/drivers/filesystems/fastfat/fastio.c

   1 /*
   2  * FILE:             drivers/fs/vfat/fastio.c
   3  * PURPOSE:          Fast IO routines.
   4  * COPYRIGHT:        See COPYING in the top level directory
   5  * PROJECT:          ReactOS kernel
   6  * PROGRAMMER:       Herve Poussineau (hpoussin@reactos.org)
   7  */
   8
   9 #define NDEBUG
  10 #include "vfat.h"
  11
  12 static BOOLEAN NTAPI
  13 VfatFastIoCheckIfPossible(IN PFILE_OBJECT FileObject,
  14                           IN PLARGE_INTEGER FileOffset,
  15                           IN ULONG Length,
  16                           IN BOOLEAN Wait,
  17                           IN ULONG LockKey,
  18                           IN BOOLEAN CheckForReadOperation,
  19                           OUT PIO_STATUS_BLOCK IoStatus,
  20                           IN PDEVICE_OBJECT DeviceObject)
  21 {
  22         /* Prevent all Fast I/O requests */
  23         DPRINT("VfatFastIoCheckIfPossible(): returning FALSE.\n");
  24         return FALSE;
  25 }
  26
  27 static BOOLEAN NTAPI
  28 VfatFastIoRead(IN PFILE_OBJECT FileObject,
  29                            IN PLARGE_INTEGER FileOffset,
  30                            IN ULONG     Length,
  31                            IN BOOLEAN Wait,
  32                            IN ULONG LockKey,
  33                            OUT PVOID Buffer,
  34                            OUT PIO_STATUS_BLOCK IoStatus,
  35                IN PDEVICE_OBJECT DeviceObject)
  36 {
  37    DPRINT("VfatFastIoRead()\n");
  38    return FALSE;
  39 }
  40
  41 static BOOLEAN NTAPI
  42 VfatFastIoWrite(IN PFILE_OBJECT FileObject,
  43                                 IN PLARGE_INTEGER FileOffset,
  44                                 IN ULONG Length,
  45                                 IN BOOLEAN Wait,
  46                                 IN ULONG LockKey,
  47                                 OUT PVOID Buffer,
  48                                 OUT PIO_STATUS_BLOCK IoStatus,
  49                                 IN PDEVICE_OBJECT DeviceObject)
  50 {
  51    DPRINT("VfatFastIoWrite()\n");
  52    return FALSE;
  53 }
  54
  55 static BOOLEAN NTAPI
  56 VfatFastIoQueryBasicInfo(IN PFILE_OBJECT FileObject,
  57                                                  IN BOOLEAN     Wait,
  58                                                  OUT PFILE_BASIC_INFORMATION Buffer,
  59                                                  OUT PIO_STATUS_BLOCK IoStatus,
  60                                                  IN PDEVICE_OBJECT DeviceObject)
  61 {
  62    DPRINT("VfatFastIoQueryBasicInfo()\n");
  63    return FALSE;
  64 }
  65
  66 static BOOLEAN NTAPI
  67 VfatFastIoQueryStandardInfo(IN PFILE_OBJECT FileObject,
  68                                                         IN BOOLEAN Wait,
  69                                                         OUT PFILE_STANDARD_INFORMATION Buffer,
  70                                                         OUT PIO_STATUS_BLOCK IoStatus,
  71                                                         IN PDEVICE_OBJECT DeviceObject)
  72 {
  73    DPRINT("VfatFastIoQueryStandardInfo\n");
  74    return FALSE;
  75 }
  76
  77 static BOOLEAN NTAPI
  78 VfatFastIoLock(IN PFILE_OBJECT FileObject,
  79                            IN PLARGE_INTEGER FileOffset,
  80                            IN PLARGE_INTEGER Length,
  81                            PEPROCESS ProcessId,
  82                            ULONG Key,
  83                            BOOLEAN FailImmediately,
  84                            BOOLEAN ExclusiveLock,
  85                            OUT PIO_STATUS_BLOCK IoStatus,
  86                            IN PDEVICE_OBJECT DeviceObject)
  87 {
  88    DPRINT("VfatFastIoLock\n");
  89    return FALSE;
  90 }
  91
  92 static BOOLEAN NTAPI
  93 VfatFastIoUnlockSingle(IN PFILE_OBJECT FileObject,
  94                                            IN PLARGE_INTEGER FileOffset,
  95                                            IN PLARGE_INTEGER Length,
  96                                            PEPROCESS ProcessId,
  97                                            ULONG Key,
  98                                            OUT PIO_STATUS_BLOCK IoStatus,
  99                                            IN PDEVICE_OBJECT DeviceObject)
 100 {
 101    DPRINT("VfatFastIoUnlockSingle\n");
 102    return FALSE;
 103 }
 104
 105 static BOOLEAN NTAPI
 106 VfatFastIoUnlockAll(IN PFILE_OBJECT FileObject,
 107                                         PEPROCESS ProcessId,
 108                                         OUT PIO_STATUS_BLOCK IoStatus,
 109                                         IN PDEVICE_OBJECT DeviceObject)
 110 {
 111    DPRINT("VfatFastIoUnlockAll\n");
 112    return FALSE;
 113 }
 114
 115 static BOOLEAN NTAPI
 116 VfatFastIoUnlockAllByKey(IN PFILE_OBJECT FileObject,
 117                                                  PVOID ProcessId,
 118                                                  ULONG Key,
 119                                                  OUT PIO_STATUS_BLOCK IoStatus,
 120                                                  IN PDEVICE_OBJECT DeviceObject)
 121 {
 122    DPRINT("VfatFastIoUnlockAllByKey\n");
 123    return FALSE;
 124 }
 125
 126 static BOOLEAN NTAPI
 127 VfatFastIoDeviceControl(IN PFILE_OBJECT FileObject,
 128                                                 IN BOOLEAN Wait,
 129                                                 IN PVOID InputBuffer OPTIONAL,
 130                                                 IN ULONG InputBufferLength,
 131                                                 OUT PVOID OutputBuffer OPTIONAL,
 132                                                 IN ULONG OutputBufferLength,
 133                                                 IN ULONG IoControlCode,
 134                                                 OUT PIO_STATUS_BLOCK IoStatus,
 135                                                 IN PDEVICE_OBJECT DeviceObject)
 136 {
 137    DPRINT("VfatFastIoDeviceControl\n");
 138    return FALSE;
 139 }
 140
 141 static VOID NTAPI
 142 VfatAcquireFileForNtCreateSection(IN PFILE_OBJECT FileObject)
 143 {
 144    DPRINT("VfatAcquireFileForNtCreateSection\n");
 145 }
 146
 147 static VOID NTAPI
 148 VfatReleaseFileForNtCreateSection(IN PFILE_OBJECT FileObject)
 149 {
 150    DPRINT("VfatReleaseFileForNtCreateSection\n");
 151 }
 152
 153 static VOID NTAPI
 154 VfatFastIoDetachDevice(IN PDEVICE_OBJECT SourceDevice,
 155                                            IN PDEVICE_OBJECT TargetDevice)
 156 {
 157    DPRINT("VfatFastIoDetachDevice\n");
 158 }
 159
 160 static BOOLEAN NTAPI
 161 VfatFastIoQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject,
 162                                IN BOOLEAN Wait,
 163                                                            OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
 164                                                            OUT PIO_STATUS_BLOCK IoStatus,
 165                                                            IN PDEVICE_OBJECT DeviceObject)
 166 {
 167    DPRINT("VfatFastIoQueryNetworkOpenInfo\n");
 168    return FALSE;
 169 }
 170
 171 static NTSTATUS NTAPI
 172 VfatAcquireForModWrite(IN PFILE_OBJECT FileObject,
 173                                            IN PLARGE_INTEGER EndingOffset,
 174                                            OUT PERESOURCE* ResourceToRelease,
 175                                            IN PDEVICE_OBJECT DeviceObject)
 176 {
 177    DPRINT("VfatAcquireForModWrite\n");
 178    return STATUS_INVALID_DEVICE_REQUEST;
 179 }
 180
 181 static BOOLEAN NTAPI
 182 VfatMdlRead(IN PFILE_OBJECT FileObject,
 183                         IN PLARGE_INTEGER FileOffset,
 184                         IN ULONG Length,
 185                         IN ULONG LockKey,
 186                         OUT PMDL* MdlChain,
 187                         OUT PIO_STATUS_BLOCK IoStatus,
 188                         IN PDEVICE_OBJECT DeviceObject)
 189 {
 190    DPRINT("VfatMdlRead\n");
 191    return FALSE;
 192 }
 193
 194 static BOOLEAN NTAPI
 195 VfatMdlReadComplete(IN PFILE_OBJECT FileObject,
 196                                         IN PMDL MdlChain,
 197                                         IN PDEVICE_OBJECT DeviceObject)
 198 {
 199    DPRINT("VfatMdlReadComplete\n");
 200    return FALSE;
 201 }
 202
 203 static BOOLEAN NTAPI
 204 VfatPrepareMdlWrite(IN PFILE_OBJECT FileObject,
 205                                         IN PLARGE_INTEGER FileOffset,
 206                                         IN ULONG Length,
 207                                         IN ULONG LockKey,
 208                                         OUT PMDL* MdlChain,
 209                                         OUT PIO_STATUS_BLOCK IoStatus,
 210                                         IN PDEVICE_OBJECT DeviceObject)
 211 {
 212    DPRINT("VfatPrepareMdlWrite\n");
 213    return FALSE;
 214 }
 215
 216 static BOOLEAN NTAPI
 217 VfatMdlWriteComplete(IN PFILE_OBJECT FileObject,
 218                                          IN PLARGE_INTEGER FileOffset,
 219                                          IN PMDL MdlChain,
 220                                          IN PDEVICE_OBJECT DeviceObject)
 221 {
 222    DPRINT("VfatMdlWriteComplete\n");
 223    return FALSE;
 224 }
 225
 226 static BOOLEAN NTAPI
 227 VfatFastIoReadCompressed(IN PFILE_OBJECT FileObject,
 228                                                  IN PLARGE_INTEGER FileOffset,
 229                                                  IN ULONG Length,
 230                                                  IN ULONG LockKey,
 231                                                  OUT PVOID Buffer,
 232                                                  OUT PMDL* MdlChain,
 233                                                  OUT PIO_STATUS_BLOCK IoStatus,
 234                                                  OUT PCOMPRESSED_DATA_INFO CompressedDataInfo,
 235                                                  IN ULONG CompressedDataInfoLength,
 236                                                  IN PDEVICE_OBJECT DeviceObject)
 237 {
 238    DPRINT("VfatFastIoReadCompressed\n");
 239    return FALSE;
 240 }
 241
 242 static BOOLEAN NTAPI
 243 VfatFastIoWriteCompressed(IN PFILE_OBJECT FileObject,
 244                                                   IN PLARGE_INTEGER FileOffset,
 245                                                   IN ULONG Length,
 246                                                   IN ULONG LockKey,
 247                                                   IN PVOID Buffer,
 248                                                   OUT PMDL* MdlChain,
 249                                                   OUT PIO_STATUS_BLOCK IoStatus,
 250                                                   IN PCOMPRESSED_DATA_INFO CompressedDataInfo,
 251                                                   IN ULONG CompressedDataInfoLength,
 252                                                   IN PDEVICE_OBJECT DeviceObject)
 253 {
 254    DPRINT("VfatFastIoWriteCompressed\n");
 255    return FALSE;
 256 }
 257
 258 static BOOLEAN NTAPI
 259 VfatMdlReadCompleteCompressed(IN PFILE_OBJECT FileObject,
 260                                                           IN PMDL MdlChain,
 261                                                           IN PDEVICE_OBJECT DeviceObject)
 262 {
 263    DPRINT("VfatMdlReadCompleteCompressed\n");
 264    return FALSE;
 265 }
 266
 267 static BOOLEAN NTAPI
 268 VfatMdlWriteCompleteCompressed(IN PFILE_OBJECT FileObject,
 269                                                            IN PLARGE_INTEGER FileOffset,
 270                                                            IN PMDL MdlChain,
 271                                                            IN PDEVICE_OBJECT DeviceObject)
 272 {
 273    DPRINT("VfatMdlWriteCompleteCompressed\n");
 274    return FALSE;
 275 }
 276
 277 static BOOLEAN NTAPI
 278 VfatFastIoQueryOpen(IN PIRP Irp,
 279                                         OUT PFILE_NETWORK_OPEN_INFORMATION  NetworkInformation,
 280                                         IN PDEVICE_OBJECT DeviceObject)
 281 {
 282    DPRINT("VfatFastIoQueryOpen\n");
 283    return FALSE;
 284 }
 285
 286 static NTSTATUS NTAPI
 287 VfatReleaseForModWrite(IN PFILE_OBJECT FileObject,
 288                                            IN PERESOURCE ResourceToRelease,
 289                                            IN PDEVICE_OBJECT DeviceObject)
 290 {
 291    DPRINT("VfatReleaseForModWrite\n");
 292    return STATUS_INVALID_DEVICE_REQUEST;
 293 }
 294
 295 static NTSTATUS NTAPI
 296 VfatAcquireForCcFlush(IN PFILE_OBJECT FileObject,
 297                                           IN PDEVICE_OBJECT DeviceObject)
 298 {
 299    PVFATFCB Fcb = (PVFATFCB)FileObject->FsContext;
 300
 301    DPRINT("VfatAcquireForCcFlush\n");
 302
 303    /* Make sure it is not a volume lock */
 304    ASSERT(!(Fcb->Flags & FCB_IS_VOLUME));
 305
 306    /* Acquire the resource */
 307    ExAcquireResourceExclusiveLite(&(Fcb->MainResource), TRUE);
 308
 309    return STATUS_SUCCESS;
 310 }
 311
 312 static NTSTATUS NTAPI
 313 VfatReleaseForCcFlush(IN PFILE_OBJECT FileObject,
 314                                           IN PDEVICE_OBJECT DeviceObject)
 315 {
 316    PVFATFCB Fcb = (PVFATFCB)FileObject->FsContext;
 317
 318    DPRINT("VfatReleaseForCcFlush\n");
 319
 320    /* Make sure it is not a volume lock */
 321    ASSERT(!(Fcb->Flags & FCB_IS_VOLUME));
 322
 323    /* Release the resource */
 324    ExReleaseResourceLite(&(Fcb->MainResource));
 325
 326    return STATUS_SUCCESS;
 327 }
 328
 329 BOOLEAN NTAPI
 330 VfatAcquireForLazyWrite(IN PVOID Context,
 331                         IN BOOLEAN Wait)
 332 {
 333         PVFATFCB Fcb = (PVFATFCB)Context;
 334         ASSERT(Fcb);
 335         DPRINT("VfatAcquireForLazyWrite(): Fcb %p\n", Fcb);
 336
 337         if (!ExAcquireResourceExclusiveLite(&(Fcb->MainResource), Wait))
 338         {
 339                 DPRINT("VfatAcquireForLazyWrite(): ExReleaseResourceLite failed.\n");
 340                 return FALSE;
 341         }
 342         return TRUE;
 343 }
 344
 345 VOID NTAPI
 346 VfatReleaseFromLazyWrite(IN PVOID Context)
 347 {
 348         PVFATFCB Fcb = (PVFATFCB)Context;
 349         ASSERT(Fcb);
 350         DPRINT("VfatReleaseFromLazyWrite(): Fcb %p\n", Fcb);
 351
 352         ExReleaseResourceLite(&(Fcb->MainResource));
 353 }
 354
 355 BOOLEAN NTAPI
 356 VfatAcquireForReadAhead(IN PVOID Context,
 357                         IN BOOLEAN Wait)
 358 {
 359         PVFATFCB Fcb = (PVFATFCB)Context;
 360         ASSERT(Fcb);
 361         DPRINT("VfatAcquireForReadAhead(): Fcb %p\n", Fcb);
 362
 363         if (!ExAcquireResourceExclusiveLite(&(Fcb->MainResource), Wait))
 364         {
 365                 DPRINT("VfatAcquireForReadAhead(): ExReleaseResourceLite failed.\n");
 366                 return FALSE;
 367         }
 368         return TRUE;
 369 }
 370
 371 VOID NTAPI
 372 VfatReleaseFromReadAhead(IN PVOID Context)
 373 {
 374         PVFATFCB Fcb = (PVFATFCB)Context;
 375         ASSERT(Fcb);
 376         DPRINT("VfatReleaseFromReadAhead(): Fcb %p\n", Fcb);
 377
 378         ExReleaseResourceLite(&(Fcb->MainResource));
 379 }
 380
 381 VOID
 382 VfatInitFastIoRoutines(PFAST_IO_DISPATCH FastIoDispatch)
 383 {
 384    FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
 385    FastIoDispatch->FastIoCheckIfPossible = VfatFastIoCheckIfPossible;
 386    FastIoDispatch->FastIoRead = VfatFastIoRead;
 387    FastIoDispatch->FastIoWrite = VfatFastIoWrite;
 388    FastIoDispatch->FastIoQueryBasicInfo = VfatFastIoQueryBasicInfo;
 389    FastIoDispatch->FastIoQueryStandardInfo = VfatFastIoQueryStandardInfo;
 390    FastIoDispatch->FastIoLock = VfatFastIoLock;
 391    FastIoDispatch->FastIoUnlockSingle = VfatFastIoUnlockSingle;
 392    FastIoDispatch->FastIoUnlockAll = VfatFastIoUnlockAll;
 393    FastIoDispatch->FastIoUnlockAllByKey = VfatFastIoUnlockAllByKey;
 394    FastIoDispatch->FastIoDeviceControl = VfatFastIoDeviceControl;
 395    FastIoDispatch->AcquireFileForNtCreateSection = VfatAcquireFileForNtCreateSection;
 396    FastIoDispatch->ReleaseFileForNtCreateSection = VfatReleaseFileForNtCreateSection;
 397    FastIoDispatch->FastIoDetachDevice = VfatFastIoDetachDevice;
 398    FastIoDispatch->FastIoQueryNetworkOpenInfo = VfatFastIoQueryNetworkOpenInfo;
 399    FastIoDispatch->MdlRead = VfatMdlRead;
 400    FastIoDispatch->MdlReadComplete = VfatMdlReadComplete;
 401    FastIoDispatch->PrepareMdlWrite = VfatPrepareMdlWrite;
 402    FastIoDispatch->MdlWriteComplete = VfatMdlWriteComplete;
 403    FastIoDispatch->FastIoReadCompressed = VfatFastIoReadCompressed;
 404    FastIoDispatch->FastIoWriteCompressed = VfatFastIoWriteCompressed;
 405    FastIoDispatch->MdlReadCompleteCompressed = VfatMdlReadCompleteCompressed;
 406    FastIoDispatch->MdlWriteCompleteCompressed = VfatMdlWriteCompleteCompressed;
 407    FastIoDispatch->FastIoQueryOpen = VfatFastIoQueryOpen;
 408    FastIoDispatch->AcquireForModWrite = VfatAcquireForModWrite;
 409    FastIoDispatch->ReleaseForModWrite = VfatReleaseForModWrite;
 410    FastIoDispatch->AcquireForCcFlush = VfatAcquireForCcFlush;
 411    FastIoDispatch->ReleaseForCcFlush = VfatReleaseForCcFlush;
 412 }
 413