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