reactos/drivers/filesystems/fastfat_new/fastio.c

   1 /*
   2  * PROJECT:         ReactOS FAT file system driver
   3  * LICENSE:         GNU GPLv3 as published by the Free Software Foundation
   4  * FILE:            drivers/filesystems/fastfat/fastio.c
   5  * PURPOSE:         Fast IO routines
   6  * PROGRAMMERS:     Herve Poussineau (hpoussin@reactos.org)
   7  */
   8
   9 /* INCLUDES *****************************************************************/
  10
  11 #define NDEBUG
  12 #include "fastfat.h"
  13
  14 /* FUNCTIONS ****************************************************************/
  15
  16 BOOLEAN
  17 NTAPI
  18 FatFastIoCheckIfPossible(IN PFILE_OBJECT FileObject,
  19                           IN PLARGE_INTEGER FileOffset,
  20                           IN ULONG Lenght,
  21                           IN BOOLEAN Wait,
  22                           IN ULONG LockKey,
  23                           IN BOOLEAN CheckForReadOperation,
  24                           OUT PIO_STATUS_BLOCK IoStatus,
  25                           IN PDEVICE_OBJECT DeviceObject)
  26 {
  27     /* Prevent all Fast I/O requests */
  28     DPRINT("FatFastIoCheckIfPossible(): returning FALSE.\n");
  29     return FALSE;
  30 }
  31
  32 BOOLEAN
  33 NTAPI
  34 FatFastIoRead(IN PFILE_OBJECT FileObject,
  35                IN PLARGE_INTEGER FileOffset,
  36                IN ULONG Length,
  37                IN BOOLEAN Wait,
  38                IN ULONG LockKey,
  39                OUT PVOID Buffer,
  40                OUT PIO_STATUS_BLOCK     IoStatus,
  41                IN PDEVICE_OBJECT DeviceObject)
  42 {
  43     DPRINT("FatFastIoRead()\n");
  44     return FALSE;
  45 }
  46
  47 BOOLEAN
  48 NTAPI
  49 FatFastIoWrite(IN PFILE_OBJECT FileObject,
  50                 IN PLARGE_INTEGER FileOffset,
  51                 IN ULONG Length,
  52                 IN BOOLEAN Wait,
  53                 IN ULONG LockKey,
  54                 OUT PVOID Buffer,
  55                 OUT PIO_STATUS_BLOCK IoStatus,
  56                 IN PDEVICE_OBJECT DeviceObject)
  57 {
  58     DPRINT("FatFastIoWrite()\n");
  59     return FALSE;
  60 }
  61
  62 BOOLEAN
  63 NTAPI
  64 FatFastIoQueryBasicInfo(IN PFILE_OBJECT FileObject,
  65                          IN BOOLEAN     Wait,
  66                          OUT PFILE_BASIC_INFORMATION Buffer,
  67                          OUT PIO_STATUS_BLOCK IoStatus,
  68                          IN PDEVICE_OBJECT DeviceObject)
  69 {
  70     DPRINT("FatFastIoQueryBasicInfo()\n");
  71     return FALSE;
  72 }
  73
  74 BOOLEAN
  75 NTAPI
  76 FatFastIoQueryStandardInfo(IN PFILE_OBJECT FileObject,
  77                             IN BOOLEAN Wait,
  78                             OUT PFILE_STANDARD_INFORMATION Buffer,
  79                             OUT PIO_STATUS_BLOCK IoStatus,
  80                             IN PDEVICE_OBJECT DeviceObject)
  81 {
  82     DPRINT("FatFastIoQueryStandardInfo\n");
  83     return FALSE;
  84 }
  85
  86 BOOLEAN
  87 NTAPI
  88 FatFastIoLock(IN PFILE_OBJECT FileObject,
  89                IN PLARGE_INTEGER FileOffset,
  90                IN PLARGE_INTEGER Length,
  91                PEPROCESS ProcessId,
  92                ULONG Key,
  93                BOOLEAN FailImmediately,
  94                BOOLEAN ExclusiveLock,
  95                OUT PIO_STATUS_BLOCK IoStatus,
  96                IN PDEVICE_OBJECT DeviceObject)
  97 {
  98     DPRINT("FatFastIoLock\n");
  99     return FALSE;
 100 }
 101
 102 BOOLEAN
 103 NTAPI
 104 FatFastIoUnlockSingle(IN PFILE_OBJECT FileObject,
 105                        IN PLARGE_INTEGER FileOffset,
 106                        IN PLARGE_INTEGER Length,
 107                        PEPROCESS ProcessId,
 108                        ULONG Key,
 109                        OUT PIO_STATUS_BLOCK IoStatus,
 110                        IN PDEVICE_OBJECT DeviceObject)
 111 {
 112     DPRINT("FatFastIoUnlockSingle\n");
 113     return FALSE;
 114 }
 115
 116 BOOLEAN
 117 NTAPI
 118 FatFastIoUnlockAll(IN PFILE_OBJECT FileObject,
 119                     PEPROCESS ProcessId,
 120                     OUT PIO_STATUS_BLOCK IoStatus,
 121                     IN PDEVICE_OBJECT DeviceObject)
 122 {
 123     DPRINT("FatFastIoUnlockAll\n");
 124     return FALSE;
 125 }
 126
 127 BOOLEAN
 128 NTAPI
 129 FatFastIoUnlockAllByKey(IN PFILE_OBJECT FileObject,
 130                          PVOID ProcessId,
 131                          ULONG Key,
 132                          OUT PIO_STATUS_BLOCK IoStatus,
 133                          IN PDEVICE_OBJECT DeviceObject)
 134 {
 135     DPRINT("FatFastIoUnlockAllByKey\n");
 136     return FALSE;
 137 }
 138
 139 BOOLEAN
 140 NTAPI
 141 FatFastIoQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject,
 142                                IN BOOLEAN Wait,
 143                                OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
 144                                OUT PIO_STATUS_BLOCK IoStatus,
 145                                IN PDEVICE_OBJECT DeviceObject)
 146 {
 147     DPRINT("FatFastIoQueryNetworkOpenInfo\n");
 148     return FALSE;
 149 }
 150
 151 BOOLEAN
 152 NTAPI
 153 FatMdlRead(IN PFILE_OBJECT FileObject,
 154             IN PLARGE_INTEGER FileOffset,
 155             IN ULONG Length,
 156             IN ULONG LockKey,
 157             OUT PMDL* MdlChain,
 158             OUT PIO_STATUS_BLOCK IoStatus,
 159             IN PDEVICE_OBJECT DeviceObject)
 160 {
 161     DPRINT("FatMdlRead\n");
 162     return FALSE;
 163 }
 164
 165 BOOLEAN
 166 NTAPI
 167 FatMdlReadComplete(IN PFILE_OBJECT FileObject,
 168                     IN PMDL MdlChain,
 169                     IN PDEVICE_OBJECT DeviceObject)
 170 {
 171     DPRINT("FatMdlReadComplete\n");
 172     return FALSE;
 173 }
 174
 175 BOOLEAN
 176 NTAPI
 177 FatPrepareMdlWrite(IN PFILE_OBJECT FileObject,
 178                     IN PLARGE_INTEGER FileOffset,
 179                     IN ULONG Length,
 180                     IN ULONG LockKey,
 181                     OUT PMDL* MdlChain,
 182                     OUT PIO_STATUS_BLOCK IoStatus,
 183                     IN PDEVICE_OBJECT DeviceObject)
 184 {
 185     DPRINT("FatPrepareMdlWrite\n");
 186     return FALSE;
 187 }
 188
 189 BOOLEAN
 190 NTAPI
 191 FatMdlWriteComplete(IN PFILE_OBJECT FileObject,
 192                      IN PLARGE_INTEGER FileOffset,
 193                      IN PMDL MdlChain,
 194                      IN PDEVICE_OBJECT DeviceObject)
 195 {
 196     DPRINT("FatMdlWriteComplete\n");
 197     return FALSE;
 198 }
 199
 200 NTSTATUS
 201 NTAPI
 202 FatAcquireForCcFlush(IN PFILE_OBJECT FileObject,
 203                       IN PDEVICE_OBJECT DeviceObject)
 204 {
 205     DPRINT("FatAcquireForCcFlush\n");
 206     return STATUS_SUCCESS;
 207 }
 208
 209 NTSTATUS
 210 NTAPI
 211 FatReleaseForCcFlush(IN PFILE_OBJECT FileObject,
 212                       IN PDEVICE_OBJECT DeviceObject)
 213 {
 214     DPRINT("FatReleaseForCcFlush\n");
 215     return STATUS_SUCCESS;
 216 }
 217
 218 BOOLEAN
 219 NTAPI
 220 FatAcquireForLazyWrite(IN PVOID Context,
 221                         IN BOOLEAN Wait)
 222 {
 223     DPRINT("FatAcquireForLazyWrite()\n");
 224     return FALSE;
 225 }
 226
 227 VOID
 228 NTAPI
 229 FatReleaseFromLazyWrite(IN PVOID Context)
 230 {
 231     DPRINT("FatReleaseFromLazyWrite()\n");
 232 }
 233
 234 BOOLEAN
 235 NTAPI
 236 FatAcquireForReadAhead(IN PVOID Context,
 237                         IN BOOLEAN Wait)
 238 {
 239     DPRINT("FatAcquireForReadAhead()\n");
 240     return FALSE;
 241 }
 242
 243 VOID
 244 NTAPI
 245 FatReleaseFromReadAhead(IN PVOID Context)
 246 {
 247     DPRINT("FatReleaseFromReadAhead()\n");
 248 }
 249
 250 BOOLEAN
 251 NTAPI
 252 FatNoopAcquire(IN PVOID Context,
 253                IN BOOLEAN Wait)
 254 {
 255     return TRUE;
 256 }
 257
 258 VOID
 259 NTAPI
 260 FatNoopRelease(IN PVOID Context)
 261 {
 262 }
 263
 264
 265 VOID
 266 FatInitFastIoRoutines(PFAST_IO_DISPATCH FastIoDispatch)
 267 {
 268     /* Set Fast I/O dispatcher callbacks */
 269     FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
 270     FastIoDispatch->FastIoCheckIfPossible = FatFastIoCheckIfPossible;
 271     FastIoDispatch->FastIoRead = FatFastIoRead;
 272     FastIoDispatch->FastIoWrite = FatFastIoWrite;
 273     FastIoDispatch->FastIoQueryBasicInfo = FatFastIoQueryBasicInfo;
 274     FastIoDispatch->FastIoQueryStandardInfo = FatFastIoQueryStandardInfo;
 275     FastIoDispatch->FastIoLock = FatFastIoLock;
 276     FastIoDispatch->FastIoUnlockSingle = FatFastIoUnlockSingle;
 277     FastIoDispatch->FastIoUnlockAll = FatFastIoUnlockAll;
 278     FastIoDispatch->FastIoUnlockAllByKey = FatFastIoUnlockAllByKey;
 279     FastIoDispatch->FastIoQueryNetworkOpenInfo = FatFastIoQueryNetworkOpenInfo;
 280     FastIoDispatch->MdlRead = FatMdlRead;
 281     FastIoDispatch->MdlReadComplete = FatMdlReadComplete;
 282     FastIoDispatch->PrepareMdlWrite = FatPrepareMdlWrite;
 283     FastIoDispatch->MdlWriteComplete = FatMdlWriteComplete;
 284     FastIoDispatch->AcquireForCcFlush = FatAcquireForCcFlush;
 285     FastIoDispatch->ReleaseForCcFlush = FatReleaseForCcFlush;
 286 }
 287
 288 /* EOF */