drivers/filesystems/fastfat/vfat.h

   1 #ifndef _FASTFAT_PCH_
   2 #define _FASTFAT_PCH_
   3
   4 #include <ntifs.h>
   5 #include <ntdddisk.h>
   6 #include <dos.h>
   7 #include <pseh/pseh2.h>
   8 #ifdef KDBG
   9 #include <ndk/kdfuncs.h>
  10 #include <reactos/kdros.h>
  11 #endif
  12
  13 #ifdef __GNUC__
  14 #define INIT_SECTION __attribute__((section ("INIT")))
  15 #else
  16 #define INIT_SECTION /* Done via alloc_text for MSC */
  17 #endif
  18
  19 #define USE_ROS_CC_AND_FS
  20 #if 0
  21 #ifndef _MSC_VER
  22 #define ENABLE_SWAPOUT
  23 #endif
  24 #endif
  25
  26 #define ROUND_DOWN(n, align) \
  27     (((ULONG)n) & ~((align) - 1l))
  28
  29 #define ROUND_UP(n, align) \
  30     ROUND_DOWN(((ULONG)n) + (align) - 1, (align))
  31
  32 #define ROUND_DOWN_64(n, align) \
  33     (((ULONGLONG)n) & ~((align) - 1LL))
  34
  35 #define ROUND_UP_64(n, align) \
  36     ROUND_DOWN_64(((ULONGLONG)n) + (align) - 1LL, (align))
  37
  38 #include <pshpack1.h>
  39 struct _BootSector
  40 {
  41     unsigned char  magic0, res0, magic1;
  42     unsigned char  OEMName[8];
  43     unsigned short BytesPerSector;
  44     unsigned char  SectorsPerCluster;
  45     unsigned short ReservedSectors;
  46     unsigned char  FATCount;
  47     unsigned short RootEntries, Sectors;
  48     unsigned char  Media;
  49     unsigned short FATSectors, SectorsPerTrack, Heads;
  50     unsigned long  HiddenSectors, SectorsHuge;
  51     unsigned char  Drive, Res1, Sig;
  52     unsigned long  VolumeID;
  53     unsigned char  VolumeLabel[11], SysType[8];
  54     unsigned char  Res2[448];
  55     unsigned short Signatur1;
  56 };
  57
  58 struct _BootSector32
  59 {
  60     unsigned char  magic0, res0, magic1;                        // 0
  61     unsigned char  OEMName[8];                          // 3
  62     unsigned short BytesPerSector;                      // 11
  63     unsigned char  SectorsPerCluster;                   // 13
  64     unsigned short ReservedSectors;                     // 14
  65     unsigned char  FATCount;                            // 16
  66     unsigned short RootEntries, Sectors;                        // 17
  67     unsigned char  Media;                                       // 21
  68     unsigned short FATSectors, SectorsPerTrack, Heads;  // 22
  69     unsigned long  HiddenSectors, SectorsHuge;          // 28
  70     unsigned long  FATSectors32;                                // 36
  71     unsigned short ExtFlag;                             // 40
  72     unsigned short FSVersion;                           // 42
  73     unsigned long  RootCluster;                         // 44
  74     unsigned short FSInfoSector;                                // 48
  75     unsigned short BootBackup;                          // 50
  76     unsigned char  Res3[12];                            // 52
  77     unsigned char  Drive;                                       // 64
  78     unsigned char  Res4;                                        // 65
  79     unsigned char  ExtBootSignature;                    // 66
  80     unsigned long  VolumeID;                            // 67
  81     unsigned char  VolumeLabel[11], SysType[8];         // 71
  82     unsigned char  Res2[420];                           // 90
  83     unsigned short Signature1;                          // 510
  84 };
  85
  86 #define FAT_DIRTY_BIT 0x01
  87
  88 struct _BootSectorFatX
  89 {
  90     unsigned char SysType[4];        // 0
  91     unsigned long VolumeID;          // 4
  92     unsigned long SectorsPerCluster; // 8
  93     unsigned short FATCount;         // 12
  94     unsigned long Unknown;           // 14
  95     unsigned char Unused[4078];      // 18
  96 };
  97
  98 struct _FsInfoSector
  99 {
 100     unsigned long  ExtBootSignature2;                   // 0
 101     unsigned char  Res6[480];                           // 4
 102     unsigned long  FSINFOSignature;                     // 484
 103     unsigned long  FreeCluster;                         // 488
 104     unsigned long  NextCluster;                         // 492
 105     unsigned char  Res7[12];                            // 496
 106     unsigned long  Signatur2;                           // 508
 107 };
 108
 109 typedef struct _BootSector BootSector;
 110
 111 struct _FATDirEntry
 112 {
 113     union
 114     {
 115         struct { unsigned char Filename[8], Ext[3]; };
 116         unsigned char ShortName[11];
 117     };
 118     unsigned char  Attrib;
 119     unsigned char  lCase;
 120     unsigned char  CreationTimeMs;
 121     unsigned short CreationTime,CreationDate,AccessDate;
 122     union
 123     {
 124         unsigned short FirstClusterHigh; // FAT32
 125         unsigned short ExtendedAttributes; // FAT12/FAT16
 126     };
 127     unsigned short UpdateTime;                            //time create/update
 128     unsigned short UpdateDate;                            //date create/update
 129     unsigned short FirstCluster;
 130     unsigned long  FileSize;
 131 };
 132
 133 #define FAT_EAFILE  "EA DATA. SF"
 134
 135 typedef struct _EAFileHeader FAT_EA_FILE_HEADER, *PFAT_EA_FILE_HEADER;
 136
 137 struct _EAFileHeader
 138 {
 139     unsigned short Signature; // ED
 140     unsigned short Unknown[15];
 141     unsigned short EASetTable[240];
 142 };
 143
 144 typedef struct _EASetHeader FAT_EA_SET_HEADER, *PFAT_EA_SET_HEADER;
 145
 146 struct _EASetHeader
 147 {
 148     unsigned short Signature; // EA
 149     unsigned short Offset; // relative offset, same value as in the EASetTable
 150     unsigned short Unknown1[2];
 151     char TargetFileName[12];
 152     unsigned short Unknown2[3];
 153     unsigned int EALength;
 154     // EA Header
 155 };
 156
 157 typedef struct _EAHeader FAT_EA_HEADER, *PFAT_EA_HEADER;
 158
 159 struct _EAHeader
 160 {
 161     unsigned char Unknown;
 162     unsigned char EANameLength;
 163     unsigned short EAValueLength;
 164     // Name Data
 165     // Value Data
 166 };
 167
 168 typedef struct _FATDirEntry FAT_DIR_ENTRY, *PFAT_DIR_ENTRY;
 169
 170 struct _FATXDirEntry
 171 {
 172     unsigned char FilenameLength; // 0
 173     unsigned char Attrib;         // 1
 174     unsigned char Filename[42];   // 2
 175     unsigned long FirstCluster;   // 44
 176     unsigned long FileSize;       // 48
 177     unsigned short UpdateTime;    // 52
 178     unsigned short UpdateDate;    // 54
 179     unsigned short CreationTime;  // 56
 180     unsigned short CreationDate;  // 58
 181     unsigned short AccessTime;    // 60
 182     unsigned short AccessDate;    // 62
 183 };
 184
 185 struct _slot
 186 {
 187     unsigned char id;               // sequence number for slot
 188     WCHAR  name0_4[5];              // first 5 characters in name
 189     unsigned char attr;             // attribute byte
 190     unsigned char reserved;         // always 0
 191     unsigned char alias_checksum;   // checksum for 8.3 alias
 192     WCHAR  name5_10[6];             // 6 more characters in name
 193     unsigned char start[2];         // starting cluster number
 194     WCHAR  name11_12[2];            // last 2 characters in name
 195 };
 196
 197 typedef struct _slot slot;
 198
 199 #include <poppack.h>
 200
 201 #define VFAT_CASE_LOWER_BASE    8               // base is lower case
 202 #define VFAT_CASE_LOWER_EXT     16              // extension is lower case
 203
 204 #define LONGNAME_MAX_LENGTH     256             // max length for a long filename
 205
 206 #define ENTRY_DELETED(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_DELETED(&((DirEntry)->FatX)) : FAT_ENTRY_DELETED(&((DirEntry)->Fat)))
 207 #define ENTRY_VOLUME(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_VOLUME(&((DirEntry)->FatX)) : FAT_ENTRY_VOLUME(&((DirEntry)->Fat)))
 208 #define ENTRY_END(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_END(&((DirEntry)->FatX)) : FAT_ENTRY_END(&((DirEntry)->Fat)))
 209
 210 #define FAT_ENTRY_DELETED(DirEntry)  ((DirEntry)->Filename[0] == 0xe5)
 211 #define FAT_ENTRY_END(DirEntry)      ((DirEntry)->Filename[0] == 0)
 212 #define FAT_ENTRY_LONG(DirEntry)     (((DirEntry)->Attrib & 0x3f) == 0x0f)
 213 #define FAT_ENTRY_VOLUME(DirEntry)   (((DirEntry)->Attrib & 0x1f) == 0x08)
 214
 215 #define FATX_ENTRY_DELETED(DirEntry) ((DirEntry)->FilenameLength == 0xe5)
 216 #define FATX_ENTRY_END(DirEntry)     ((DirEntry)->FilenameLength == 0xff)
 217 #define FATX_ENTRY_LONG(DirEntry)    (FALSE)
 218 #define FATX_ENTRY_VOLUME(DirEntry)  (((DirEntry)->Attrib & 0x1f) == 0x08)
 219
 220 #define FAT_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FAT_DIR_ENTRY))
 221 #define FATX_ENTRIES_PER_PAGE  (PAGE_SIZE / sizeof (FATX_DIR_ENTRY))
 222
 223 typedef struct _FATXDirEntry FATX_DIR_ENTRY, *PFATX_DIR_ENTRY;
 224
 225 union _DIR_ENTRY
 226 {
 227     FAT_DIR_ENTRY Fat;
 228     FATX_DIR_ENTRY FatX;
 229 };
 230
 231 typedef union _DIR_ENTRY DIR_ENTRY, *PDIR_ENTRY;
 232
 233 #define BLOCKSIZE 512
 234
 235 #define FAT16  (1)
 236 #define FAT12  (2)
 237 #define FAT32  (3)
 238 #define FATX16 (4)
 239 #define FATX32 (5)
 240
 241 #define VCB_VOLUME_LOCKED       0x0001
 242 #define VCB_DISMOUNT_PENDING    0x0002
 243 #define VCB_IS_FATX             0x0004
 244 #define VCB_IS_SYS_OR_HAS_PAGE  0x0008
 245 #define VCB_IS_DIRTY            0x4000 /* Volume is dirty */
 246 #define VCB_CLEAR_DIRTY         0x8000 /* Clean dirty flag at shutdown */
 247
 248 typedef struct
 249 {
 250     ULONG VolumeID;
 251     CHAR VolumeLabel[11];
 252     ULONG FATStart;
 253     ULONG FATCount;
 254     ULONG FATSectors;
 255     ULONG rootDirectorySectors;
 256     ULONG rootStart;
 257     ULONG dataStart;
 258     ULONG RootCluster;
 259     ULONG SectorsPerCluster;
 260     ULONG BytesPerSector;
 261     ULONG BytesPerCluster;
 262     ULONG NumberOfClusters;
 263     ULONG FatType;
 264     ULONG Sectors;
 265     BOOLEAN FixedMedia;
 266     ULONG FSInfoSector;
 267 } FATINFO, *PFATINFO;
 268
 269 struct _VFATFCB;
 270 struct _VFAT_DIRENTRY_CONTEXT;
 271 struct _VFAT_MOVE_CONTEXT;
 272
 273 typedef struct _HASHENTRY
 274 {
 275     ULONG Hash;
 276     struct _VFATFCB* self;
 277     struct _HASHENTRY* next;
 278 }
 279 HASHENTRY;
 280
 281 typedef struct DEVICE_EXTENSION *PDEVICE_EXTENSION;
 282
 283 typedef NTSTATUS (*PGET_NEXT_CLUSTER)(PDEVICE_EXTENSION,ULONG,PULONG);
 284 typedef NTSTATUS (*PFIND_AND_MARK_AVAILABLE_CLUSTER)(PDEVICE_EXTENSION,PULONG);
 285 typedef NTSTATUS (*PWRITE_CLUSTER)(PDEVICE_EXTENSION,ULONG,ULONG,PULONG);
 286
 287 typedef BOOLEAN (*PIS_DIRECTORY_EMPTY)(PDEVICE_EXTENSION,struct _VFATFCB*);
 288 typedef NTSTATUS (*PADD_ENTRY)(PDEVICE_EXTENSION,PUNICODE_STRING,struct _VFATFCB**,struct _VFATFCB*,ULONG,UCHAR,struct _VFAT_MOVE_CONTEXT*);
 289 typedef NTSTATUS (*PDEL_ENTRY)(PDEVICE_EXTENSION,struct _VFATFCB*,struct _VFAT_MOVE_CONTEXT*);
 290 typedef NTSTATUS (*PGET_NEXT_DIR_ENTRY)(PVOID*,PVOID*,struct _VFATFCB*,struct _VFAT_DIRENTRY_CONTEXT*,BOOLEAN);
 291 typedef NTSTATUS (*PGET_DIRTY_STATUS)(PDEVICE_EXTENSION,PBOOLEAN);
 292 typedef NTSTATUS (*PSET_DIRTY_STATUS)(PDEVICE_EXTENSION,BOOLEAN);
 293
 294 typedef struct _VFAT_DISPATCH
 295 {
 296     PIS_DIRECTORY_EMPTY IsDirectoryEmpty;
 297     PADD_ENTRY AddEntry;
 298     PDEL_ENTRY DelEntry;
 299     PGET_NEXT_DIR_ENTRY GetNextDirEntry;
 300 } VFAT_DISPATCH, *PVFAT_DISPATCH;
 301
 302 #define STATISTICS_SIZE_NO_PAD (sizeof(FILESYSTEM_STATISTICS) + sizeof(FAT_STATISTICS))
 303 typedef struct _STATISTICS {
 304     FILESYSTEM_STATISTICS Base;
 305     FAT_STATISTICS Fat;
 306     UCHAR Pad[((STATISTICS_SIZE_NO_PAD + 0x3f) & ~0x3f) - STATISTICS_SIZE_NO_PAD];
 307 } STATISTICS, *PSTATISTICS;
 308
 309 typedef struct DEVICE_EXTENSION
 310 {
 311     ERESOURCE DirResource;
 312     ERESOURCE FatResource;
 313
 314     KSPIN_LOCK FcbListLock;
 315     LIST_ENTRY FcbListHead;
 316     ULONG HashTableSize;
 317     struct _HASHENTRY **FcbHashTable;
 318
 319     PDEVICE_OBJECT VolumeDevice;
 320     PDEVICE_OBJECT StorageDevice;
 321     PFILE_OBJECT FATFileObject;
 322     FATINFO FatInfo;
 323     ULONG LastAvailableCluster;
 324     ULONG AvailableClusters;
 325     BOOLEAN AvailableClustersValid;
 326     ULONG Flags;
 327     struct _VFATFCB *VolumeFcb;
 328     PSTATISTICS Statistics;
 329
 330     /* Pointers to functions for manipulating FAT. */
 331     PGET_NEXT_CLUSTER GetNextCluster;
 332     PFIND_AND_MARK_AVAILABLE_CLUSTER FindAndMarkAvailableCluster;
 333     PWRITE_CLUSTER WriteCluster;
 334     PGET_DIRTY_STATUS GetDirtyStatus;
 335     PSET_DIRTY_STATUS SetDirtyStatus;
 336
 337     ULONG BaseDateYear;
 338
 339     LIST_ENTRY VolumeListEntry;
 340
 341     /* Notifications */
 342     LIST_ENTRY NotifyList;
 343     PNOTIFY_SYNC NotifySync;
 344
 345     /* Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE */
 346     ULONG OpenHandleCount;
 347
 348     /* VPBs for dismount */
 349     PVPB IoVPB;
 350     PVPB SpareVPB;
 351
 352     /* Pointers to functions for manipulating directory entries. */
 353     VFAT_DISPATCH Dispatch;
 354 } DEVICE_EXTENSION, VCB, *PVCB;
 355
 356 FORCEINLINE
 357 BOOLEAN
 358 VfatIsDirectoryEmpty(PDEVICE_EXTENSION DeviceExt,
 359                      struct _VFATFCB* Fcb)
 360 {
 361     return DeviceExt->Dispatch.IsDirectoryEmpty(DeviceExt, Fcb);
 362 }
 363
 364 FORCEINLINE
 365 NTSTATUS
 366 VfatAddEntry(PDEVICE_EXTENSION DeviceExt,
 367              PUNICODE_STRING NameU,
 368              struct _VFATFCB** Fcb,
 369              struct _VFATFCB* ParentFcb,
 370              ULONG RequestedOptions,
 371              UCHAR ReqAttr,
 372              struct _VFAT_MOVE_CONTEXT* MoveContext)
 373 {
 374     return DeviceExt->Dispatch.AddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr, MoveContext);
 375 }
 376
 377 FORCEINLINE
 378 NTSTATUS
 379 VfatDelEntry(PDEVICE_EXTENSION DeviceExt,
 380              struct _VFATFCB* Fcb,
 381              struct _VFAT_MOVE_CONTEXT* MoveContext)
 382 {
 383     return DeviceExt->Dispatch.DelEntry(DeviceExt, Fcb, MoveContext);
 384 }
 385
 386 FORCEINLINE
 387 NTSTATUS
 388 VfatGetNextDirEntry(PDEVICE_EXTENSION DeviceExt,
 389                     PVOID *pContext,
 390                     PVOID *pPage,
 391                     struct _VFATFCB* pDirFcb,
 392                     struct _VFAT_DIRENTRY_CONTEXT* DirContext,
 393                     BOOLEAN First)
 394 {
 395     return DeviceExt->Dispatch.GetNextDirEntry(pContext, pPage, pDirFcb, DirContext, First);
 396 }
 397
 398 #define VFAT_BREAK_ON_CORRUPTION 1
 399
 400 typedef struct
 401 {
 402     PDRIVER_OBJECT DriverObject;
 403     PDEVICE_OBJECT DeviceObject;
 404     ULONG Flags;
 405     ULONG NumberProcessors;
 406     ERESOURCE VolumeListLock;
 407     LIST_ENTRY VolumeListHead;
 408     NPAGED_LOOKASIDE_LIST FcbLookasideList;
 409     NPAGED_LOOKASIDE_LIST CcbLookasideList;
 410     NPAGED_LOOKASIDE_LIST IrpContextLookasideList;
 411     FAST_IO_DISPATCH FastIoDispatch;
 412     CACHE_MANAGER_CALLBACKS CacheMgrCallbacks;
 413 } VFAT_GLOBAL_DATA, *PVFAT_GLOBAL_DATA;
 414
 415 extern PVFAT_GLOBAL_DATA VfatGlobalData;
 416
 417 #define FCB_CACHE_INITIALIZED   0x0001
 418 #define FCB_DELETE_PENDING      0x0002
 419 #define FCB_IS_FAT              0x0004
 420 #define FCB_IS_PAGE_FILE        0x0008
 421 #define FCB_IS_VOLUME           0x0010
 422 #define FCB_IS_DIRTY            0x0020
 423 #ifdef KDBG
 424 #define FCB_CLEANED_UP          0x0040
 425 #define FCB_CLOSED              0x0080
 426 #endif
 427
 428 #define NODE_TYPE_FCB ((CSHORT)0x0502)
 429
 430 typedef struct _VFATFCB
 431 {
 432     /* FCB header required by ROS/NT */
 433     FSRTL_COMMON_FCB_HEADER RFCB;
 434     SECTION_OBJECT_POINTERS SectionObjectPointers;
 435     ERESOURCE MainResource;
 436     ERESOURCE PagingIoResource;
 437     /* end FCB header required by ROS/NT */
 438
 439     /* directory entry for this file or directory */
 440     DIR_ENTRY entry;
 441
 442     /* Pointer to attributes in entry */
 443     PUCHAR Attributes;
 444
 445     /* long file name, points into PathNameBuffer */
 446     UNICODE_STRING LongNameU;
 447
 448     /* short file name */
 449     UNICODE_STRING ShortNameU;
 450
 451     /* directory name, points into PathNameBuffer */
 452     UNICODE_STRING DirNameU;
 453
 454     /* path + long file name 260 max*/
 455     UNICODE_STRING PathNameU;
 456
 457     /* buffer for PathNameU */
 458     PWCHAR PathNameBuffer;
 459
 460     /* buffer for ShortNameU */
 461     WCHAR ShortNameBuffer[13];
 462
 463     /* */
 464     LONG RefCount;
 465
 466     /* List of FCB's for this volume */
 467     LIST_ENTRY FcbListEntry;
 468
 469     /* List of FCB's for the parent */
 470     LIST_ENTRY ParentListEntry;
 471
 472     /* pointer to the parent fcb */
 473     struct _VFATFCB *parentFcb;
 474
 475     /* List for the children */
 476     LIST_ENTRY ParentListHead;
 477
 478     /* Flags for the fcb */
 479     ULONG Flags;
 480
 481     /* pointer to the file object which has initialized the fcb */
 482     PFILE_OBJECT FileObject;
 483
 484     /* Directory index for the short name entry */
 485     ULONG dirIndex;
 486
 487     /* Directory index where the long name starts */
 488     ULONG startIndex;
 489
 490     /* Share access for the file object */
 491     SHARE_ACCESS FCBShareAccess;
 492
 493     /* Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP */
 494     ULONG OpenHandleCount;
 495
 496     /* Entry into the hash table for the path + long name */
 497     HASHENTRY Hash;
 498
 499     /* Entry into the hash table for the path + short name */
 500     HASHENTRY ShortHash;
 501
 502     /* List of byte-range locks for this file */
 503     FILE_LOCK FileLock;
 504
 505     /*
 506      * Optimization: caching of last read/write cluster+offset pair. Can't
 507      * be in VFATCCB because it must be reset everytime the allocated clusters
 508      * change.
 509      */
 510     FAST_MUTEX LastMutex;
 511     ULONG LastCluster;
 512     ULONG LastOffset;
 513 } VFATFCB, *PVFATFCB;
 514
 515 #define CCB_DELETE_ON_CLOSE     0x0001
 516
 517 typedef struct _VFATCCB
 518 {
 519     LARGE_INTEGER  CurrentByteOffset;
 520     ULONG Flags;
 521     /* for DirectoryControl */
 522     ULONG Entry;
 523     /* for DirectoryControl */
 524     UNICODE_STRING SearchPattern;
 525 } VFATCCB, *PVFATCCB;
 526
 527 #define TAG_CCB  'BCCV'
 528 #define TAG_FCB  'BCFV'
 529 #define TAG_IRP  'PRIV'
 530 #define TAG_VFAT 'TAFV'
 531
 532 #define ENTRIES_PER_SECTOR (BLOCKSIZE / sizeof(FATDirEntry))
 533
 534 typedef struct __DOSTIME
 535 {
 536     USHORT Second:5;
 537     USHORT Minute:6;
 538     USHORT Hour:5;
 539 }
 540 DOSTIME, *PDOSTIME;
 541
 542 typedef struct __DOSDATE
 543 {
 544     USHORT Day:5;
 545     USHORT Month:4;
 546     USHORT Year:7;
 547 }
 548 DOSDATE, *PDOSDATE;
 549
 550 #define IRPCONTEXT_CANWAIT          0x0001
 551 #define IRPCONTEXT_COMPLETE         0x0002
 552 #define IRPCONTEXT_QUEUE            0x0004
 553 #define IRPCONTEXT_PENDINGRETURNED  0x0008
 554 #define IRPCONTEXT_DEFERRED_WRITE   0x0010
 555
 556 typedef struct
 557 {
 558     PIRP Irp;
 559     PDEVICE_OBJECT DeviceObject;
 560     PDEVICE_EXTENSION DeviceExt;
 561     ULONG Flags;
 562     WORK_QUEUE_ITEM WorkQueueItem;
 563     PIO_STACK_LOCATION Stack;
 564     UCHAR MajorFunction;
 565     UCHAR MinorFunction;
 566     PFILE_OBJECT FileObject;
 567     ULONG RefCount;
 568     KEVENT Event;
 569     CCHAR PriorityBoost;
 570 } VFAT_IRP_CONTEXT, *PVFAT_IRP_CONTEXT;
 571
 572 typedef struct _VFAT_DIRENTRY_CONTEXT
 573 {
 574     ULONG StartIndex;
 575     ULONG DirIndex;
 576     DIR_ENTRY DirEntry;
 577     UNICODE_STRING LongNameU;
 578     UNICODE_STRING ShortNameU;
 579     PDEVICE_EXTENSION DeviceExt;
 580 } VFAT_DIRENTRY_CONTEXT, *PVFAT_DIRENTRY_CONTEXT;
 581
 582 typedef struct _VFAT_MOVE_CONTEXT
 583 {
 584     ULONG FirstCluster;
 585     ULONG FileSize;
 586     USHORT CreationDate;
 587     USHORT CreationTime;
 588     BOOLEAN InPlace;
 589 } VFAT_MOVE_CONTEXT, *PVFAT_MOVE_CONTEXT;
 590
 591 FORCEINLINE
 592 NTSTATUS
 593 VfatMarkIrpContextForQueue(PVFAT_IRP_CONTEXT IrpContext)
 594 {
 595     PULONG Flags = &IrpContext->Flags;
 596
 597     *Flags &= ~IRPCONTEXT_COMPLETE;
 598     *Flags |= IRPCONTEXT_QUEUE;
 599
 600     return STATUS_PENDING;
 601 }
 602
 603 FORCEINLINE
 604 BOOLEAN
 605 vfatFCBIsDirectory(PVFATFCB FCB)
 606 {
 607     return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_DIRECTORY);
 608 }
 609
 610 FORCEINLINE
 611 BOOLEAN
 612 vfatFCBIsReadOnly(PVFATFCB FCB)
 613 {
 614     return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_READONLY);
 615 }
 616
 617 FORCEINLINE
 618 BOOLEAN
 619 vfatVolumeIsFatX(PDEVICE_EXTENSION DeviceExt)
 620 {
 621     return BooleanFlagOn(DeviceExt->Flags, VCB_IS_FATX);
 622 }
 623
 624 FORCEINLINE
 625 VOID
 626 vfatReportChange(
 627     IN PDEVICE_EXTENSION DeviceExt,
 628     IN PVFATFCB Fcb,
 629     IN ULONG FilterMatch,
 630     IN ULONG Action)
 631 {
 632     FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
 633                                 &(DeviceExt->NotifyList),
 634                                 (PSTRING)&Fcb->PathNameU,
 635                                 Fcb->PathNameU.Length - Fcb->LongNameU.Length,
 636                                 NULL, NULL, FilterMatch, Action, NULL);
 637 }
 638
 639 #define vfatAddToStat(Vcb, Stat, Inc)                                                                         \
 640 {                                                                                                             \
 641     PSTATISTICS Stats = &(Vcb)->Statistics[KeGetCurrentProcessorNumber() % VfatGlobalData->NumberProcessors]; \
 642     Stats->Stat += Inc;                                                                                       \
 643 }
 644
 645 /* blockdev.c */
 646
 647 NTSTATUS
 648 VfatReadDisk(
 649     IN PDEVICE_OBJECT pDeviceObject,
 650     IN PLARGE_INTEGER ReadOffset,
 651     IN ULONG ReadLength,
 652     IN PUCHAR Buffer,
 653     IN BOOLEAN Override);
 654
 655 NTSTATUS
 656 VfatReadDiskPartial(
 657     IN PVFAT_IRP_CONTEXT IrpContext,
 658     IN PLARGE_INTEGER ReadOffset,
 659     IN ULONG ReadLength,
 660     IN ULONG BufferOffset,
 661     IN BOOLEAN Wait);
 662
 663 NTSTATUS
 664 VfatWriteDisk(
 665     IN PDEVICE_OBJECT pDeviceObject,
 666     IN PLARGE_INTEGER WriteOffset,
 667     IN ULONG WriteLength,
 668     IN OUT PUCHAR Buffer,
 669     IN BOOLEAN Override);
 670
 671 NTSTATUS
 672 VfatWriteDiskPartial(
 673     IN PVFAT_IRP_CONTEXT IrpContext,
 674     IN PLARGE_INTEGER WriteOffset,
 675     IN ULONG WriteLength,
 676     IN ULONG BufferOffset,
 677     IN BOOLEAN Wait);
 678
 679 NTSTATUS
 680 VfatBlockDeviceIoControl(
 681     IN PDEVICE_OBJECT DeviceObject,
 682     IN ULONG CtlCode,
 683     IN PVOID InputBuffer,
 684     IN ULONG InputBufferSize,
 685     IN OUT PVOID OutputBuffer,
 686     IN OUT PULONG pOutputBufferSize,
 687     IN BOOLEAN Override);
 688
 689 /* cleanup.c */
 690
 691 NTSTATUS
 692 VfatCleanup(
 693     PVFAT_IRP_CONTEXT IrpContext);
 694
 695 /* close.c */
 696
 697 NTSTATUS
 698 VfatClose(
 699     PVFAT_IRP_CONTEXT IrpContext);
 700
 701 NTSTATUS
 702 VfatCloseFile(
 703     PDEVICE_EXTENSION DeviceExt,
 704     PFILE_OBJECT FileObject);
 705
 706 /* create.c */
 707
 708 NTSTATUS
 709 VfatCreate(
 710     PVFAT_IRP_CONTEXT IrpContext);
 711
 712 NTSTATUS
 713 FindFile(
 714     PDEVICE_EXTENSION DeviceExt,
 715     PVFATFCB Parent,
 716     PUNICODE_STRING FileToFindU,
 717     PVFAT_DIRENTRY_CONTEXT DirContext,
 718     BOOLEAN First);
 719
 720 VOID
 721 vfat8Dot3ToString(
 722     PFAT_DIR_ENTRY pEntry,
 723     PUNICODE_STRING NameU);
 724
 725 /* dir.c */
 726
 727 NTSTATUS
 728 VfatDirectoryControl(
 729     PVFAT_IRP_CONTEXT IrpContext);
 730
 731 BOOLEAN
 732 FsdDosDateTimeToSystemTime(
 733     PDEVICE_EXTENSION DeviceExt,
 734     USHORT DosDate,
 735     USHORT DosTime,
 736     PLARGE_INTEGER SystemTime);
 737
 738 BOOLEAN
 739 FsdSystemTimeToDosDateTime(
 740     PDEVICE_EXTENSION DeviceExt,
 741     PLARGE_INTEGER SystemTime,
 742     USHORT *pDosDate,
 743     USHORT *pDosTime);
 744
 745 /* direntry.c */
 746
 747 ULONG
 748 vfatDirEntryGetFirstCluster(
 749     PDEVICE_EXTENSION pDeviceExt,
 750     PDIR_ENTRY pDirEntry);
 751
 752 /* dirwr.c */
 753
 754 NTSTATUS
 755 vfatFCBInitializeCacheFromVolume(
 756     PVCB vcb,
 757     PVFATFCB fcb);
 758
 759 NTSTATUS
 760 VfatUpdateEntry(
 761     IN PDEVICE_EXTENSION DeviceExt,
 762     PVFATFCB pFcb);
 763
 764 BOOLEAN
 765 vfatFindDirSpace(
 766     PDEVICE_EXTENSION DeviceExt,
 767     PVFATFCB pDirFcb,
 768     ULONG nbSlots,
 769     PULONG start);
 770
 771 NTSTATUS
 772 vfatRenameEntry(
 773     IN PDEVICE_EXTENSION DeviceExt,
 774     IN PVFATFCB pFcb,
 775     IN PUNICODE_STRING FileName,
 776     IN BOOLEAN CaseChangeOnly);
 777
 778 NTSTATUS
 779 VfatMoveEntry(
 780     IN PDEVICE_EXTENSION DeviceExt,
 781     IN PVFATFCB pFcb,
 782     IN PUNICODE_STRING FileName,
 783     IN PVFATFCB ParentFcb);
 784
 785 /* ea.h */
 786
 787 NTSTATUS
 788 VfatSetExtendedAttributes(
 789     PFILE_OBJECT FileObject,
 790     PVOID Ea,
 791     ULONG EaLength);
 792
 793 /* fastio.c */
 794
 795 VOID
 796 VfatInitFastIoRoutines(
 797     PFAST_IO_DISPATCH FastIoDispatch);
 798
 799 BOOLEAN
 800 NTAPI
 801 VfatAcquireForLazyWrite(
 802     IN PVOID Context,
 803     IN BOOLEAN Wait);
 804
 805 VOID
 806 NTAPI
 807 VfatReleaseFromLazyWrite(
 808     IN PVOID Context);
 809
 810 /* fat.c */
 811
 812 NTSTATUS
 813 FAT12GetNextCluster(
 814     PDEVICE_EXTENSION DeviceExt,
 815     ULONG CurrentCluster,
 816     PULONG NextCluster);
 817
 818 NTSTATUS
 819 FAT12FindAndMarkAvailableCluster(
 820     PDEVICE_EXTENSION DeviceExt,
 821     PULONG Cluster);
 822
 823 NTSTATUS
 824 FAT12WriteCluster(
 825     PDEVICE_EXTENSION DeviceExt,
 826     ULONG ClusterToWrite,
 827     ULONG NewValue,
 828     PULONG OldValue);
 829
 830 NTSTATUS
 831 FAT16GetNextCluster(
 832     PDEVICE_EXTENSION DeviceExt,
 833     ULONG CurrentCluster,
 834     PULONG NextCluster);
 835
 836 NTSTATUS
 837 FAT16FindAndMarkAvailableCluster(
 838     PDEVICE_EXTENSION DeviceExt,
 839     PULONG Cluster);
 840
 841 NTSTATUS
 842 FAT16WriteCluster(
 843     PDEVICE_EXTENSION DeviceExt,
 844     ULONG ClusterToWrite,
 845     ULONG NewValue,
 846     PULONG OldValue);
 847
 848 NTSTATUS
 849 FAT32GetNextCluster(
 850     PDEVICE_EXTENSION DeviceExt,
 851     ULONG CurrentCluster,
 852     PULONG NextCluster);
 853
 854 NTSTATUS
 855 FAT32FindAndMarkAvailableCluster(
 856     PDEVICE_EXTENSION DeviceExt,
 857     PULONG Cluster);
 858
 859 NTSTATUS
 860 FAT32WriteCluster(
 861     PDEVICE_EXTENSION DeviceExt,
 862     ULONG ClusterToWrite,
 863     ULONG NewValue,
 864     PULONG OldValue);
 865
 866 NTSTATUS
 867 OffsetToCluster(
 868     PDEVICE_EXTENSION DeviceExt,
 869     ULONG FirstCluster,
 870     ULONG FileOffset,
 871     PULONG Cluster,
 872     BOOLEAN Extend);
 873
 874 ULONGLONG
 875 ClusterToSector(
 876     PDEVICE_EXTENSION DeviceExt,
 877     ULONG Cluster);
 878
 879 NTSTATUS
 880 GetNextCluster(
 881     PDEVICE_EXTENSION DeviceExt,
 882     ULONG CurrentCluster,
 883     PULONG NextCluster);
 884
 885 NTSTATUS
 886 GetNextClusterExtend(
 887     PDEVICE_EXTENSION DeviceExt,
 888     ULONG CurrentCluster,
 889     PULONG NextCluster);
 890
 891 NTSTATUS
 892 CountAvailableClusters(
 893     PDEVICE_EXTENSION DeviceExt,
 894     PLARGE_INTEGER Clusters);
 895
 896 NTSTATUS
 897 WriteCluster(
 898     PDEVICE_EXTENSION DeviceExt,
 899     ULONG ClusterToWrite,
 900     ULONG NewValue);
 901
 902 NTSTATUS
 903 GetDirtyStatus(
 904     PDEVICE_EXTENSION DeviceExt,
 905     PBOOLEAN DirtyStatus);
 906
 907 NTSTATUS
 908 FAT16GetDirtyStatus(
 909     PDEVICE_EXTENSION DeviceExt,
 910     PBOOLEAN DirtyStatus);
 911
 912 NTSTATUS
 913 FAT32GetDirtyStatus(
 914     PDEVICE_EXTENSION DeviceExt,
 915     PBOOLEAN DirtyStatus);
 916
 917 NTSTATUS
 918 SetDirtyStatus(
 919     PDEVICE_EXTENSION DeviceExt,
 920     BOOLEAN DirtyStatus);
 921
 922 NTSTATUS
 923 FAT16SetDirtyStatus(
 924     PDEVICE_EXTENSION DeviceExt,
 925     BOOLEAN DirtyStatus);
 926
 927 NTSTATUS
 928 FAT32SetDirtyStatus(
 929     PDEVICE_EXTENSION DeviceExt,
 930     BOOLEAN DirtyStatus);
 931
 932 NTSTATUS
 933 FAT32UpdateFreeClustersCount(
 934     PDEVICE_EXTENSION DeviceExt,
 935     ULONG Count,
 936     BOOLEAN Freed);
 937
 938 /* fcb.c */
 939
 940 PVFATFCB
 941 vfatNewFCB(
 942     PDEVICE_EXTENSION pVCB,
 943     PUNICODE_STRING pFileNameU);
 944
 945 NTSTATUS
 946 vfatSetFCBNewDirName(
 947     PDEVICE_EXTENSION pVCB,
 948     PVFATFCB Fcb,
 949     PVFATFCB ParentFcb);
 950
 951 NTSTATUS
 952 vfatUpdateFCB(
 953     PDEVICE_EXTENSION pVCB,
 954     PVFATFCB Fcb,
 955     PVFAT_DIRENTRY_CONTEXT DirContext,
 956     PVFATFCB ParentFcb);
 957
 958 VOID
 959 vfatDestroyFCB(
 960     PVFATFCB pFCB);
 961
 962 VOID
 963 vfatDestroyCCB(
 964     PVFATCCB pCcb);
 965
 966 VOID
 967 #ifndef KDBG
 968 vfatGrabFCB(
 969 #else
 970 _vfatGrabFCB(
 971 #endif
 972     PDEVICE_EXTENSION pVCB,
 973     PVFATFCB pFCB
 974 #ifdef KDBG
 975     ,
 976     PCSTR File,
 977     ULONG Line,
 978     PCSTR Func
 979 #endif
 980     );
 981
 982 VOID
 983 #ifndef KDBG
 984 vfatReleaseFCB(
 985 #else
 986 _vfatReleaseFCB(
 987 #endif
 988     PDEVICE_EXTENSION pVCB,
 989     PVFATFCB pFCB
 990 #ifdef KDBG
 991     ,
 992     PCSTR File,
 993     ULONG Line,
 994     PCSTR Func
 995 #endif
 996     );
 997
 998 #ifdef KDBG
 999 #define vfatGrabFCB(v, f) _vfatGrabFCB(v, f, __FILE__, __LINE__, __FUNCTION__)
1000 #define vfatReleaseFCB(v, f) _vfatReleaseFCB(v, f, __FILE__, __LINE__, __FUNCTION__)
1001 #endif
1002
1003 PVFATFCB
1004 vfatGrabFCBFromTable(
1005     PDEVICE_EXTENSION pDeviceExt,
1006     PUNICODE_STRING pFileNameU);
1007
1008 PVFATFCB
1009 vfatMakeRootFCB(
1010     PDEVICE_EXTENSION pVCB);
1011
1012 PVFATFCB
1013 vfatOpenRootFCB(
1014     PDEVICE_EXTENSION pVCB);
1015
1016 BOOLEAN
1017 vfatFCBIsDirectory(
1018     PVFATFCB FCB);
1019
1020 BOOLEAN
1021 vfatFCBIsRoot(
1022     PVFATFCB FCB);
1023
1024 NTSTATUS
1025 vfatAttachFCBToFileObject(
1026     PDEVICE_EXTENSION vcb,
1027     PVFATFCB fcb,
1028     PFILE_OBJECT fileObject);
1029
1030 NTSTATUS
1031 vfatDirFindFile(
1032     PDEVICE_EXTENSION pVCB,
1033     PVFATFCB parentFCB,
1034     PUNICODE_STRING FileToFindU,
1035     PVFATFCB *fileFCB);
1036
1037 NTSTATUS
1038 vfatGetFCBForFile(
1039     PDEVICE_EXTENSION pVCB,
1040     PVFATFCB *pParentFCB,
1041     PVFATFCB *pFCB,
1042     PUNICODE_STRING pFileNameU);
1043
1044 NTSTATUS
1045 vfatMakeFCBFromDirEntry(
1046     PVCB vcb,
1047     PVFATFCB directoryFCB,
1048     PVFAT_DIRENTRY_CONTEXT DirContext,
1049     PVFATFCB *fileFCB);
1050
1051 /* finfo.c */
1052
1053 NTSTATUS
1054 VfatGetStandardInformation(
1055     PVFATFCB FCB,
1056     PFILE_STANDARD_INFORMATION StandardInfo,
1057     PULONG BufferLength);
1058
1059 NTSTATUS
1060 VfatGetBasicInformation(
1061     PFILE_OBJECT FileObject,
1062     PVFATFCB FCB,
1063     PDEVICE_EXTENSION DeviceExt,
1064     PFILE_BASIC_INFORMATION BasicInfo,
1065     PULONG BufferLength);
1066
1067 NTSTATUS
1068 VfatQueryInformation(
1069     PVFAT_IRP_CONTEXT IrpContext);
1070
1071 NTSTATUS
1072 VfatSetInformation(
1073     PVFAT_IRP_CONTEXT IrpContext);
1074
1075 NTSTATUS
1076 VfatSetAllocationSizeInformation(
1077     PFILE_OBJECT FileObject,
1078     PVFATFCB Fcb,
1079     PDEVICE_EXTENSION DeviceExt,
1080     PLARGE_INTEGER AllocationSize);
1081
1082 /* flush.c */
1083
1084 NTSTATUS
1085 VfatFlush(
1086     PVFAT_IRP_CONTEXT IrpContext);
1087
1088 NTSTATUS
1089 VfatFlushVolume(
1090     PDEVICE_EXTENSION DeviceExt,
1091     PVFATFCB VolumeFcb);
1092
1093 /* fsctl.c */
1094
1095 NTSTATUS
1096 VfatFileSystemControl(
1097     PVFAT_IRP_CONTEXT IrpContext);
1098
1099 /* iface.c */
1100
1101 NTSTATUS
1102 NTAPI
1103 DriverEntry(
1104     PDRIVER_OBJECT DriverObject,
1105     PUNICODE_STRING RegistryPath);
1106
1107 #ifdef KDBG
1108 /* kdbg.c */
1109 KDBG_CLI_ROUTINE vfatKdbgHandler;
1110 #endif
1111
1112 /* misc.c */
1113
1114 DRIVER_DISPATCH
1115 VfatBuildRequest;
1116
1117 NTSTATUS
1118 NTAPI
1119 VfatBuildRequest(
1120     PDEVICE_OBJECT DeviceObject,
1121     PIRP Irp);
1122
1123 PVOID
1124 VfatGetUserBuffer(
1125     IN PIRP,
1126     IN BOOLEAN Paging);
1127
1128 NTSTATUS
1129 VfatLockUserBuffer(
1130     IN PIRP,
1131     IN ULONG,
1132     IN LOCK_OPERATION);
1133
1134 BOOLEAN
1135 VfatCheckForDismount(
1136     IN PDEVICE_EXTENSION DeviceExt,
1137     IN BOOLEAN Create);
1138
1139 VOID
1140 vfatReportChange(
1141     IN PDEVICE_EXTENSION DeviceExt,
1142     IN PVFATFCB Fcb,
1143     IN ULONG FilterMatch,
1144     IN ULONG Action);
1145
1146 VOID
1147 NTAPI
1148 VfatHandleDeferredWrite(
1149     IN PVOID IrpContext,
1150     IN PVOID Unused);
1151
1152 /* pnp.c */
1153
1154 NTSTATUS
1155 VfatPnp(
1156     PVFAT_IRP_CONTEXT IrpContext);
1157
1158 /* rw.c */
1159
1160 NTSTATUS
1161 VfatRead(
1162     PVFAT_IRP_CONTEXT IrpContext);
1163
1164 NTSTATUS
1165 VfatWrite(
1166     PVFAT_IRP_CONTEXT IrpContext);
1167
1168 NTSTATUS
1169 NextCluster(
1170     PDEVICE_EXTENSION DeviceExt,
1171     ULONG FirstCluster,
1172     PULONG CurrentCluster,
1173     BOOLEAN Extend);
1174
1175 /* shutdown.c */
1176
1177 DRIVER_DISPATCH
1178 VfatShutdown;
1179
1180 NTSTATUS
1181 NTAPI
1182 VfatShutdown(
1183     PDEVICE_OBJECT DeviceObject,
1184     PIRP Irp);
1185
1186 /* string.c */
1187
1188 VOID
1189 vfatSplitPathName(
1190     PUNICODE_STRING PathNameU,
1191     PUNICODE_STRING DirNameU,
1192     PUNICODE_STRING FileNameU);
1193
1194 BOOLEAN
1195 vfatIsLongIllegal(
1196     WCHAR c);
1197
1198 BOOLEAN
1199 wstrcmpjoki(
1200     PWSTR s1,
1201     PWSTR s2);
1202
1203 /* volume.c */
1204
1205 NTSTATUS
1206 VfatQueryVolumeInformation(
1207     PVFAT_IRP_CONTEXT IrpContext);
1208
1209 NTSTATUS
1210 VfatSetVolumeInformation(
1211     PVFAT_IRP_CONTEXT IrpContext);
1212
1213 #endif /* _FASTFAT_PCH_ */