reactos/drivers/fs/vfat/vfat.h

   1 /* $Id$ */
   2
   3 #include <ddk/ntifs.h>
   4 #include <ddk/ntdddisk.h>
   5 #undef DeleteFile /* FIXME */
   6
   7 #define USE_ROS_CC_AND_FS
   8
   9 /* FIXME */
  10 #ifdef __USE_W32API
  11 NTSTATUS NTAPI RtlOemStringToUnicodeString(PUNICODE_STRING, CONST STRING *, BOOLEAN);
  12 NTSTATUS NTAPI RtlDowncaseUnicodeString(PUNICODE_STRING, PCUNICODE_STRING, BOOLEAN);
  13 NTSTATUS NTAPI RtlUnicodeStringToOemString(POEM_STRING, PCUNICODE_STRING, BOOLEAN);
  14 #endif
  15
  16 #ifdef USE_ROS_CC_AND_FS
  17 NTSTATUS STDCALL CcRosInitializeFileCache(PFILE_OBJECT, ULONG);
  18 NTSTATUS STDCALL CcRosReleaseFileCache(PFILE_OBJECT);
  19 #define FSCTL_ROS_QUERY_LCN_MAPPING CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 63, METHOD_BUFFERED, FILE_ANY_ACCESS)
  20 typedef struct _ROS_QUERY_LCN_MAPPING { LARGE_INTEGER LcnDiskOffset; } ROS_QUERY_LCN_MAPPING, *PROS_QUERY_LCN_MAPPING;
  21 #endif
  22
  23 #define KEBUGCHECK(a) DbgPrint("KeBugCheck at %s:%i\n",__FILE__,__LINE__), KeBugCheck(a)
  24 #define KEBUGCHECKEX(a,b,c,d,e) DbgPrint("KeBugCheckEx at %s:%i\n",__FILE__,__LINE__), KeBugCheckEx(a,b,c,d,e)
  25
  26 #define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
  27 #define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
  28
  29 struct _BootSector
  30 {
  31   unsigned char  magic0, res0, magic1;
  32   unsigned char  OEMName[8];
  33   unsigned short BytesPerSector;
  34   unsigned char  SectorsPerCluster;
  35   unsigned short ReservedSectors;
  36   unsigned char  FATCount;
  37   unsigned short RootEntries, Sectors;
  38   unsigned char  Media;
  39   unsigned short FATSectors, SectorsPerTrack, Heads;
  40   unsigned long  HiddenSectors, SectorsHuge;
  41   unsigned char  Drive, Res1, Sig;
  42   unsigned long  VolumeID;
  43   unsigned char  VolumeLabel[11], SysType[8];
  44   unsigned char  Res2[448];
  45   unsigned short Signatur1;
  46 } __attribute__((packed));
  47
  48 struct _BootSector32
  49 {
  50   unsigned char  magic0, res0, magic1;                  // 0
  51   unsigned char  OEMName[8];                            // 3
  52   unsigned short BytesPerSector;                        // 11
  53   unsigned char  SectorsPerCluster;                     // 13
  54   unsigned short ReservedSectors;                       // 14
  55   unsigned char  FATCount;                              // 16
  56   unsigned short RootEntries, Sectors;                  // 17
  57   unsigned char  Media;                                 // 21
  58   unsigned short FATSectors, SectorsPerTrack, Heads;    // 22
  59   unsigned long  HiddenSectors, SectorsHuge;            // 28
  60   unsigned long  FATSectors32;                          // 36
  61   unsigned short ExtFlag;                               // 40
  62   unsigned short FSVersion;                             // 42
  63   unsigned long  RootCluster;                           // 44
  64   unsigned short FSInfoSector;                          // 48
  65   unsigned short BootBackup;                            // 50
  66   unsigned char  Res3[12];                              // 52
  67   unsigned char  Drive;                                 // 64
  68   unsigned char  Res4;                                  // 65
  69   unsigned char  ExtBootSignature;                      // 66
  70   unsigned long  VolumeID;                              // 67
  71   unsigned char  VolumeLabel[11], SysType[8];           // 71
  72   unsigned char  Res2[420];                             // 90
  73   unsigned short Signature1;                            // 510
  74 } __attribute__((packed));
  75
  76 struct _BootSectorFatX
  77 {
  78    unsigned char SysType[4];        // 0
  79    unsigned long VolumeID;          // 4
  80    unsigned long SectorsPerCluster; // 8
  81    unsigned short FATCount;         // 12
  82    unsigned long Unknown;           // 14
  83    unsigned char Unused[4078];      // 18
  84 } __attribute__((packed));
  85
  86 struct _FsInfoSector
  87 {
  88   unsigned long  ExtBootSignature2;                     // 0
  89   unsigned char  Res6[480];                             // 4
  90   unsigned long  FSINFOSignature;                       // 484
  91   unsigned long  FreeCluster;                           // 488
  92   unsigned long  NextCluster;                           // 492
  93   unsigned char  Res7[12];                              // 496
  94   unsigned long  Signatur2;                             // 508
  95 } __attribute__((packed));
  96
  97 typedef struct _BootSector BootSector;
  98
  99 #define VFAT_CASE_LOWER_BASE    8               // base is lower case
 100 #define VFAT_CASE_LOWER_EXT     16              // extension is lower case
 101
 102 #define LONGNAME_MAX_LENGTH     256             // max length for a long filename
 103
 104 #define ENTRY_DELETED(DeviceExt, DirEntry) ((DeviceExt)->Flags & VCB_IS_FATX ? FATX_ENTRY_DELETED(&((DirEntry)->FatX)) : FAT_ENTRY_DELETED(&((DirEntry)->Fat)))
 105 #define ENTRY_VOLUME(DeviceExt, DirEntry)  ((DeviceExt)->Flags & VCB_IS_FATX ? FATX_ENTRY_VOLUME(&((DirEntry)->FatX)) : FAT_ENTRY_VOLUME(&((DirEntry)->Fat)))
 106 #define ENTRY_END(DeviceExt, DirEntry)     ((DeviceExt)->Flags & VCB_IS_FATX ? FATX_ENTRY_END(&((DirEntry)->FatX)) : FAT_ENTRY_END(&((DirEntry)->Fat)))
 107
 108 #define FAT_ENTRY_DELETED(DirEntry)  ((DirEntry)->Filename[0] == 0xe5)
 109 #define FAT_ENTRY_END(DirEntry)      ((DirEntry)->Filename[0] == 0)
 110 #define FAT_ENTRY_LONG(DirEntry)     (((DirEntry)->Attrib & 0x3f) == 0x0f)
 111 #define FAT_ENTRY_VOLUME(DirEntry)   (((DirEntry)->Attrib & 0x1f) == 0x08)
 112
 113 #define FATX_ENTRY_DELETED(DirEntry) ((DirEntry)->FilenameLength == 0xe5)
 114 #define FATX_ENTRY_END(DirEntry)     ((DirEntry)->FilenameLength == 0xff)
 115 #define FATX_ENTRY_LONG(DirEntry)    (FALSE)
 116 #define FATX_ENTRY_VOLUME(DirEntry)  (((DirEntry)->Attrib & 0x1f) == 0x08)
 117
 118 #define FAT_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FAT_DIR_ENTRY))
 119 #define FATX_ENTRIES_PER_PAGE  (PAGE_SIZE / sizeof (FATX_DIR_ENTRY))
 120
 121 struct _FATDirEntry
 122 {
 123   unsigned char  Filename[8], Ext[3];
 124   unsigned char  Attrib;
 125   unsigned char  lCase;
 126   unsigned char  CreationTimeMs;
 127   unsigned short CreationTime,CreationDate,AccessDate;
 128   unsigned short FirstClusterHigh;                      // higher
 129   unsigned short UpdateTime;                            //time create/update
 130   unsigned short UpdateDate;                            //date create/update
 131   unsigned short FirstCluster;
 132   unsigned long  FileSize;
 133 } __attribute__((packed));
 134
 135 typedef struct _FATDirEntry FAT_DIR_ENTRY, *PFAT_DIR_ENTRY;
 136
 137 struct _FATXDirEntry
 138 {
 139    unsigned char FilenameLength; // 0
 140    unsigned char Attrib;         // 1
 141    unsigned char Filename[42];   // 2
 142    unsigned long FirstCluster;   // 44
 143    unsigned long FileSize;       // 48
 144    unsigned short UpdateTime;    // 52
 145    unsigned short UpdateDate;    // 54
 146    unsigned short CreationTime;  // 56
 147    unsigned short CreationDate;  // 58
 148    unsigned short AccessTime;    // 60
 149    unsigned short AccessDate;    // 62
 150 } __attribute__((packed));
 151
 152 typedef struct _FATXDirEntry FATX_DIR_ENTRY, *PFATX_DIR_ENTRY;
 153
 154 union _DIR_ENTRY
 155 {
 156    FAT_DIR_ENTRY Fat;
 157    FATX_DIR_ENTRY FatX;
 158 };
 159
 160 typedef union _DIR_ENTRY DIR_ENTRY, *PDIR_ENTRY;
 161
 162 struct _slot
 163 {
 164   unsigned char id;               // sequence number for slot
 165   WCHAR  name0_4[5];              // first 5 characters in name
 166   unsigned char attr;             // attribute byte
 167   unsigned char reserved;         // always 0
 168   unsigned char alias_checksum;   // checksum for 8.3 alias
 169   WCHAR  name5_10[6];             // 6 more characters in name
 170   unsigned char start[2];         // starting cluster number
 171   WCHAR  name11_12[2];            // last 2 characters in name
 172 } __attribute__((packed));
 173
 174
 175 typedef struct _slot slot;
 176
 177 #define BLOCKSIZE 512
 178
 179 #define FAT16  (1)
 180 #define FAT12  (2)
 181 #define FAT32  (3)
 182 #define FATX16 (4)
 183 #define FATX32 (5)
 184
 185 #define VCB_VOLUME_LOCKED       0x0001
 186 #define VCB_DISMOUNT_PENDING    0x0002
 187 #define VCB_IS_FATX             0x0004
 188
 189 typedef struct
 190 {
 191   ULONG VolumeID;
 192   ULONG FATStart;
 193   ULONG FATCount;
 194   ULONG FATSectors;
 195   ULONG rootDirectorySectors;
 196   ULONG rootStart;
 197   ULONG dataStart;
 198   ULONG RootCluster;
 199   ULONG SectorsPerCluster;
 200   ULONG BytesPerSector;
 201   ULONG BytesPerCluster;
 202   ULONG NumberOfClusters;
 203   ULONG FatType;
 204   ULONG Sectors;
 205   BOOLEAN FixedMedia;
 206 } FATINFO, *PFATINFO;
 207
 208 struct _VFATFCB;
 209 struct _VFAT_DIRENTRY_CONTEXT;
 210
 211 typedef struct _HASHENTRY
 212 {
 213   ULONG Hash;
 214   struct _VFATFCB* self;
 215   struct _HASHENTRY* next;
 216 }
 217 HASHENTRY;
 218
 219 #define FCB_HASH_TABLE_SIZE 65536
 220
 221 typedef struct DEVICE_EXTENSION *PDEVICE_EXTENSION;
 222
 223 typedef NTSTATUS (*PGET_NEXT_CLUSTER)(PDEVICE_EXTENSION,ULONG,PULONG);
 224 typedef NTSTATUS (*PFIND_AND_MARK_AVAILABLE_CLUSTER)(PDEVICE_EXTENSION,PULONG);
 225 typedef NTSTATUS (*PWRITE_CLUSTER)(PDEVICE_EXTENSION,ULONG,ULONG,PULONG);
 226
 227 typedef NTSTATUS (*PGET_NEXT_DIR_ENTRY)(PVOID*,PVOID*,struct _VFATFCB*,struct _VFAT_DIRENTRY_CONTEXT*,BOOLEAN);
 228
 229 typedef struct DEVICE_EXTENSION
 230 {
 231   ERESOURCE DirResource;
 232   ERESOURCE FatResource;
 233
 234   KSPIN_LOCK FcbListLock;
 235   LIST_ENTRY FcbListHead;
 236   struct _HASHENTRY* FcbHashTable[FCB_HASH_TABLE_SIZE];
 237
 238   PDEVICE_OBJECT StorageDevice;
 239   PFILE_OBJECT FATFileObject;
 240   FATINFO FatInfo;
 241   ULONG LastAvailableCluster;
 242   ULONG AvailableClusters;
 243   BOOLEAN AvailableClustersValid;
 244   ULONG Flags;
 245   struct _VFATFCB * VolumeFcb;
 246
 247   /* Pointers to functions for manipulating FAT. */
 248   PGET_NEXT_CLUSTER GetNextCluster;
 249   PFIND_AND_MARK_AVAILABLE_CLUSTER FindAndMarkAvailableCluster;
 250   PWRITE_CLUSTER WriteCluster;
 251
 252   /* Pointers to functions for manipulating directory entries. */
 253   PGET_NEXT_DIR_ENTRY GetNextDirEntry;
 254
 255   ULONG BaseDateYear;
 256
 257   LIST_ENTRY VolumeListEntry;
 258 } DEVICE_EXTENSION, VCB, *PVCB;
 259
 260 typedef struct
 261 {
 262   PDRIVER_OBJECT DriverObject;
 263   PDEVICE_OBJECT DeviceObject;
 264   ULONG Flags;
 265   ERESOURCE VolumeListLock;
 266   LIST_ENTRY VolumeListHead;
 267   NPAGED_LOOKASIDE_LIST FcbLookasideList;
 268   NPAGED_LOOKASIDE_LIST CcbLookasideList;
 269   NPAGED_LOOKASIDE_LIST IrpContextLookasideList;
 270 } VFAT_GLOBAL_DATA, *PVFAT_GLOBAL_DATA;
 271
 272 extern PVFAT_GLOBAL_DATA VfatGlobalData;
 273
 274 #define FCB_CACHE_INITIALIZED   0x0001
 275 #define FCB_DELETE_PENDING      0x0002
 276 #define FCB_IS_FAT              0x0004
 277 #define FCB_IS_PAGE_FILE        0x0008
 278 #define FCB_IS_VOLUME           0x0010
 279 #define FCB_IS_DIRTY            0x0020
 280 #define FCB_IS_FATX_ENTRY       0x0040
 281
 282 typedef struct _VFATFCB
 283 {
 284   /* FCB header required by ROS/NT */
 285   FSRTL_COMMON_FCB_HEADER RFCB;
 286   SECTION_OBJECT_POINTERS SectionObjectPointers;
 287   ERESOURCE MainResource;
 288   ERESOURCE PagingIoResource;
 289   /* end FCB header required by ROS/NT */
 290
 291   /* directory entry for this file or directory */
 292   DIR_ENTRY entry;
 293
 294   /* Pointer to attributes in entry */
 295   PUCHAR Attributes;
 296
 297   /* long file name, points into PathNameBuffer */
 298   UNICODE_STRING LongNameU;
 299
 300   /* short file name */
 301   UNICODE_STRING ShortNameU;
 302
 303   /* directory name, points into PathNameBuffer */
 304   UNICODE_STRING DirNameU;
 305
 306   /* path + long file name 260 max*/
 307   UNICODE_STRING PathNameU;
 308
 309   /* buffer for PathNameU */
 310   PWCHAR PathNameBuffer;
 311
 312   /* buffer for ShortNameU */
 313   WCHAR ShortNameBuffer[13];
 314
 315   /* */
 316   LONG RefCount;
 317
 318   /* List of FCB's for this volume */
 319   LIST_ENTRY FcbListEntry;
 320
 321   /* pointer to the parent fcb */
 322   struct _VFATFCB* parentFcb;
 323
 324   /* Flags for the fcb */
 325   ULONG Flags;
 326
 327   /* pointer to the file object which has initialized the fcb */
 328   PFILE_OBJECT FileObject;
 329
 330   /* Directory index for the short name entry */
 331   ULONG dirIndex;
 332
 333   /* Directory index where the long name starts */
 334   ULONG startIndex;
 335
 336   /* Share access for the file object */
 337   SHARE_ACCESS FCBShareAccess;
 338
 339   /* Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP */
 340   ULONG OpenHandleCount;
 341
 342   /* Entry into the hash table for the path + long name */
 343   HASHENTRY Hash;
 344
 345   /* Entry into the hash table for the path + short name */
 346   HASHENTRY ShortHash;
 347
 348   /* List of byte-range locks for this file */
 349   FILE_LOCK FileLock;
 350
 351   /*
 352    * Optimalization: caching of last read/write cluster+offset pair. Can't
 353    * be in VFATCCB because it must be reset everytime the allocated clusters
 354    * change.
 355    */
 356   FAST_MUTEX LastMutex;
 357   ULONG LastCluster;
 358   ULONG LastOffset;
 359 } VFATFCB, *PVFATFCB;
 360
 361 typedef struct _VFATCCB
 362 {
 363   LARGE_INTEGER  CurrentByteOffset;
 364   /* for DirectoryControl */
 365   ULONG Entry;
 366   /* for DirectoryControl */
 367   UNICODE_STRING SearchPattern;
 368 } VFATCCB, *PVFATCCB;
 369
 370 #ifndef TAG
 371 #define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
 372 #endif
 373
 374 #define TAG_CCB TAG('V', 'C', 'C', 'B')
 375 #define TAG_FCB TAG('V', 'F', 'C', 'B')
 376 #define TAG_IRP TAG('V', 'I', 'R', 'P')
 377
 378 #define ENTRIES_PER_SECTOR (BLOCKSIZE / sizeof(FATDirEntry))
 379
 380 typedef struct __DOSTIME
 381 {
 382    USHORT Second:5;
 383    USHORT Minute:6;
 384    USHORT Hour:5;
 385 }
 386 DOSTIME, *PDOSTIME;
 387
 388 typedef struct __DOSDATE
 389 {
 390    USHORT Day:5;
 391    USHORT Month:4;
 392    USHORT Year:5;
 393 }
 394 DOSDATE, *PDOSDATE;
 395
 396 #define IRPCONTEXT_CANWAIT          0x0001
 397 #define IRPCONTEXT_PENDINGRETURNED  0x0002
 398
 399 typedef struct
 400 {
 401    PIRP Irp;
 402    PDEVICE_OBJECT DeviceObject;
 403    PDEVICE_EXTENSION DeviceExt;
 404    ULONG Flags;
 405    WORK_QUEUE_ITEM WorkQueueItem;
 406    PIO_STACK_LOCATION Stack;
 407    UCHAR MajorFunction;
 408    UCHAR MinorFunction;
 409    PFILE_OBJECT FileObject;
 410    ULONG RefCount;
 411    KEVENT Event;
 412 } VFAT_IRP_CONTEXT, *PVFAT_IRP_CONTEXT;
 413
 414 typedef struct _VFAT_DIRENTRY_CONTEXT
 415 {
 416   ULONG StartIndex;
 417   ULONG DirIndex;
 418   DIR_ENTRY DirEntry;
 419   UNICODE_STRING LongNameU;
 420   UNICODE_STRING ShortNameU;
 421 } VFAT_DIRENTRY_CONTEXT, *PVFAT_DIRENTRY_CONTEXT;
 422
 423
 424 /*  ------------------------------------------------------  shutdown.c  */
 425
 426 NTSTATUS STDCALL VfatShutdown (PDEVICE_OBJECT DeviceObject,
 427                                PIRP Irp);
 428
 429 /*  --------------------------------------------------------  volume.c  */
 430
 431 NTSTATUS VfatQueryVolumeInformation (PVFAT_IRP_CONTEXT IrpContext);
 432
 433 NTSTATUS VfatSetVolumeInformation (PVFAT_IRP_CONTEXT IrpContext);
 434
 435 /*  ------------------------------------------------------  blockdev.c  */
 436
 437 NTSTATUS VfatReadDisk(IN PDEVICE_OBJECT pDeviceObject,
 438                       IN PLARGE_INTEGER ReadOffset,
 439                       IN ULONG ReadLength,
 440                       IN PUCHAR Buffer,
 441                       IN BOOLEAN Override);
 442
 443 NTSTATUS VfatReadDiskPartial (IN PVFAT_IRP_CONTEXT IrpContext,
 444                               IN PLARGE_INTEGER ReadOffset,
 445                               IN ULONG ReadLength,
 446                               IN ULONG BufferOffset,
 447                               IN BOOLEAN Wait);
 448
 449 NTSTATUS VfatWriteDiskPartial(IN PVFAT_IRP_CONTEXT IrpContext,
 450                               IN PLARGE_INTEGER WriteOffset,
 451                               IN ULONG WriteLength,
 452                               IN ULONG BufferOffset,
 453                               IN BOOLEAN Wait);
 454
 455 NTSTATUS VfatBlockDeviceIoControl (IN PDEVICE_OBJECT DeviceObject,
 456                                    IN ULONG CtlCode,
 457                                    IN PVOID InputBuffer,
 458                                    IN ULONG InputBufferSize,
 459                                    IN OUT PVOID OutputBuffer,
 460                                    IN OUT PULONG pOutputBufferSize,
 461                                    IN BOOLEAN Override);
 462
 463 /*  -----------------------------------------------------------  dir.c  */
 464
 465 NTSTATUS VfatDirectoryControl (PVFAT_IRP_CONTEXT);
 466
 467 BOOLEAN FsdDosDateTimeToSystemTime (PDEVICE_EXTENSION DeviceExt,
 468                                     USHORT DosDate,
 469                                     USHORT DosTime,
 470                                     PLARGE_INTEGER SystemTime);
 471
 472 BOOLEAN FsdSystemTimeToDosDateTime (PDEVICE_EXTENSION DeviceExt,
 473                                     PLARGE_INTEGER SystemTime,
 474                                     USHORT *pDosDate,
 475                                     USHORT *pDosTime);
 476
 477 /*  --------------------------------------------------------  create.c  */
 478
 479 NTSTATUS VfatCreate (PVFAT_IRP_CONTEXT IrpContext);
 480
 481 NTSTATUS VfatOpenFile (PDEVICE_EXTENSION DeviceExt,
 482                        PFILE_OBJECT FileObject,
 483                        PVFATFCB* parentFcb);
 484
 485 NTSTATUS FindFile (PDEVICE_EXTENSION DeviceExt,
 486                    PVFATFCB Parent,
 487                    PUNICODE_STRING FileToFindU,
 488                    PVFAT_DIRENTRY_CONTEXT DirContext,
 489                    BOOLEAN First);
 490
 491 VOID vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry,
 492                         PUNICODE_STRING NameU);
 493
 494 NTSTATUS ReadVolumeLabel(PDEVICE_EXTENSION DeviceExt,
 495                          PVPB Vpb);
 496
 497 /*  ---------------------------------------------------------  close.c  */
 498
 499 NTSTATUS VfatClose (PVFAT_IRP_CONTEXT IrpContext);
 500
 501 NTSTATUS VfatCloseFile(PDEVICE_EXTENSION DeviceExt,
 502                        PFILE_OBJECT FileObject);
 503
 504 /*  -------------------------------------------------------  cleanup.c  */
 505
 506 NTSTATUS VfatCleanup (PVFAT_IRP_CONTEXT IrpContext);
 507
 508 /*  ---------------------------------------------------------  fsctl.c  */
 509
 510 NTSTATUS VfatFileSystemControl (PVFAT_IRP_CONTEXT IrpContext);
 511
 512 /*  ---------------------------------------------------------  finfo.c  */
 513
 514 NTSTATUS VfatQueryInformation (PVFAT_IRP_CONTEXT IrpContext);
 515
 516 NTSTATUS VfatSetInformation (PVFAT_IRP_CONTEXT IrpContext);
 517
 518 NTSTATUS
 519 VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
 520                                  PVFATFCB Fcb,
 521                                  PDEVICE_EXTENSION DeviceExt,
 522                                  PLARGE_INTEGER AllocationSize);
 523
 524 /*  ---------------------------------------------------------  iface.c  */
 525
 526 NTSTATUS STDCALL DriverEntry (PDRIVER_OBJECT DriverObject,
 527                               PUNICODE_STRING RegistryPath);
 528
 529 /*  ---------------------------------------------------------  dirwr.c  */
 530
 531 NTSTATUS VfatAddEntry (PDEVICE_EXTENSION DeviceExt,
 532                        PUNICODE_STRING PathNameU,
 533                        PVFATFCB* Fcb,
 534                        PVFATFCB ParentFcb,
 535                        ULONG RequestedOptions,
 536                        UCHAR ReqAttr);
 537
 538 NTSTATUS VfatUpdateEntry (PVFATFCB pFcb);
 539
 540 NTSTATUS VfatDelEntry(PDEVICE_EXTENSION, PVFATFCB);
 541
 542 BOOLEAN
 543 vfatFindDirSpace(PDEVICE_EXTENSION DeviceExt,
 544                  PVFATFCB pDirFcb,
 545                  ULONG nbSlots,
 546                  PULONG start);
 547
 548 /*  --------------------------------------------------------  string.c  */
 549
 550 VOID
 551 vfatSplitPathName(PUNICODE_STRING PathNameU,
 552                   PUNICODE_STRING DirNameU,
 553                   PUNICODE_STRING FileNameU);
 554
 555 BOOLEAN vfatIsLongIllegal(WCHAR c);
 556
 557 BOOLEAN wstrcmpjoki (PWSTR s1,
 558                      PWSTR s2);
 559
 560 /*  -----------------------------------------------------------  fat.c  */
 561
 562 NTSTATUS FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
 563                              ULONG CurrentCluster,
 564                              PULONG NextCluster);
 565
 566 NTSTATUS FAT12FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
 567                                           PULONG Cluster);
 568
 569 NTSTATUS FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt,
 570                            ULONG ClusterToWrite,
 571                            ULONG NewValue,
 572                            PULONG OldValue);
 573
 574 NTSTATUS FAT16GetNextCluster(PDEVICE_EXTENSION DeviceExt,
 575                              ULONG CurrentCluster,
 576                              PULONG NextCluster);
 577
 578 NTSTATUS FAT16FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
 579                                           PULONG Cluster);
 580
 581 NTSTATUS FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt,
 582                            ULONG ClusterToWrite,
 583                            ULONG NewValue,
 584                            PULONG OldValue);
 585
 586 NTSTATUS FAT32GetNextCluster(PDEVICE_EXTENSION DeviceExt,
 587                              ULONG CurrentCluster,
 588                              PULONG NextCluster);
 589
 590 NTSTATUS FAT32FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
 591                                           PULONG Cluster);
 592
 593 NTSTATUS FAT32WriteCluster(PDEVICE_EXTENSION DeviceExt,
 594                            ULONG ClusterToWrite,
 595                            ULONG NewValue,
 596                            PULONG OldValue);
 597
 598 NTSTATUS OffsetToCluster (PDEVICE_EXTENSION DeviceExt,
 599                           ULONG FirstCluster,
 600                           ULONG FileOffset,
 601                           PULONG Cluster,
 602                           BOOLEAN Extend);
 603
 604 ULONGLONG ClusterToSector (PDEVICE_EXTENSION DeviceExt,
 605                            ULONG Cluster);
 606
 607 NTSTATUS GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 608                          ULONG CurrentCluster,
 609                          PULONG NextCluster);
 610
 611 NTSTATUS GetNextClusterExtend (PDEVICE_EXTENSION DeviceExt,
 612                                ULONG CurrentCluster,
 613                                PULONG NextCluster);
 614
 615 NTSTATUS CountAvailableClusters (PDEVICE_EXTENSION DeviceExt,
 616                                  PLARGE_INTEGER Clusters);
 617
 618 NTSTATUS
 619 WriteCluster(PDEVICE_EXTENSION DeviceExt,
 620              ULONG ClusterToWrite,
 621              ULONG NewValue);
 622
 623 /*  ------------------------------------------------------  direntry.c  */
 624
 625 ULONG  vfatDirEntryGetFirstCluster (PDEVICE_EXTENSION  pDeviceExt,
 626                                     PDIR_ENTRY  pDirEntry);
 627
 628 BOOLEAN VfatIsDirectoryEmpty(PVFATFCB Fcb);
 629
 630 NTSTATUS FATGetNextDirEntry(PVOID * pContext,
 631                              PVOID * pPage,
 632                              IN PVFATFCB pDirFcb,
 633                              IN PVFAT_DIRENTRY_CONTEXT DirContext,
 634                              BOOLEAN First);
 635
 636 NTSTATUS FATXGetNextDirEntry(PVOID * pContext,
 637                              PVOID * pPage,
 638                              IN PVFATFCB pDirFcb,
 639                              IN PVFAT_DIRENTRY_CONTEXT DirContext,
 640                              BOOLEAN First);
 641
 642 /*  -----------------------------------------------------------  fcb.c  */
 643
 644 PVFATFCB vfatNewFCB (PDEVICE_EXTENSION  pVCB,
 645                         PUNICODE_STRING pFileNameU);
 646
 647 VOID vfatDestroyFCB (PVFATFCB  pFCB);
 648
 649 VOID vfatDestroyCCB(PVFATCCB pCcb);
 650
 651 VOID vfatGrabFCB (PDEVICE_EXTENSION  pVCB,
 652                   PVFATFCB  pFCB);
 653
 654 VOID vfatReleaseFCB (PDEVICE_EXTENSION  pVCB,
 655                      PVFATFCB  pFCB);
 656
 657 VOID vfatAddFCBToTable (PDEVICE_EXTENSION  pVCB,
 658                         PVFATFCB  pFCB);
 659
 660 PVFATFCB vfatGrabFCBFromTable (PDEVICE_EXTENSION  pDeviceExt,
 661                                PUNICODE_STRING  pFileNameU);
 662
 663 PVFATFCB vfatMakeRootFCB (PDEVICE_EXTENSION  pVCB);
 664
 665 PVFATFCB vfatOpenRootFCB (PDEVICE_EXTENSION  pVCB);
 666
 667 BOOLEAN vfatFCBIsDirectory (PVFATFCB FCB);
 668
 669 BOOLEAN vfatFCBIsRoot(PVFATFCB FCB);
 670
 671 NTSTATUS vfatAttachFCBToFileObject (PDEVICE_EXTENSION  vcb,
 672                                     PVFATFCB  fcb,
 673                                     PFILE_OBJECT  fileObject);
 674
 675 NTSTATUS vfatDirFindFile (PDEVICE_EXTENSION  pVCB,
 676                           PVFATFCB  parentFCB,
 677                           PUNICODE_STRING FileToFindU,
 678                           PVFATFCB * fileFCB);
 679
 680 NTSTATUS vfatGetFCBForFile (PDEVICE_EXTENSION  pVCB,
 681                             PVFATFCB  *pParentFCB,
 682                             PVFATFCB  *pFCB,
 683                             PUNICODE_STRING pFileNameU);
 684
 685 NTSTATUS vfatMakeFCBFromDirEntry (PVCB  vcb,
 686                                   PVFATFCB  directoryFCB,
 687                                   PVFAT_DIRENTRY_CONTEXT DirContext,
 688                                   PVFATFCB * fileFCB);
 689
 690 /*  ------------------------------------------------------------  rw.c  */
 691
 692 NTSTATUS VfatRead (PVFAT_IRP_CONTEXT IrpContext);
 693
 694 NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext);
 695
 696 NTSTATUS NextCluster(PDEVICE_EXTENSION DeviceExt,
 697                      ULONG FirstCluster,
 698                      PULONG CurrentCluster,
 699                      BOOLEAN Extend);
 700
 701 /*  -----------------------------------------------------------  misc.c  */
 702
 703 NTSTATUS VfatQueueRequest(PVFAT_IRP_CONTEXT IrpContext);
 704
 705 PVFAT_IRP_CONTEXT VfatAllocateIrpContext(PDEVICE_OBJECT DeviceObject,
 706                                          PIRP Irp);
 707
 708 VOID VfatFreeIrpContext(PVFAT_IRP_CONTEXT IrpContext);
 709
 710 NTSTATUS STDCALL VfatBuildRequest (PDEVICE_OBJECT DeviceObject,
 711                                    PIRP Irp);
 712
 713 PVOID VfatGetUserBuffer(IN PIRP);
 714
 715 NTSTATUS VfatLockUserBuffer(IN PIRP, IN ULONG,
 716                             IN LOCK_OPERATION);
 717
 718 NTSTATUS
 719 VfatSetExtendedAttributes(PFILE_OBJECT FileObject,
 720                           PVOID Ea,
 721                           ULONG EaLength);
 722 /*  ------------------------------------------------------------- flush.c  */
 723
 724 NTSTATUS VfatFlush(PVFAT_IRP_CONTEXT IrpContext);
 725
 726 NTSTATUS VfatFlushVolume(PDEVICE_EXTENSION DeviceExt, PVFATFCB VolumeFcb);
 727
 728
 729 /* EOF */