reactos/drivers/filesystems/ffs/inc/ffsdrv.h

   1 /*
   2  * FFS File System Driver for Windows
   3  *
   4  * ffsdrv.h
   5  *
   6  * 2004.5.6 ~
   7  *
   8  * Lee Jae-Hong, http://www.pyrasis.com
   9  *
  10  */
  11
  12 #ifndef _FFS_HEADER_
  13 #define _FFS_HEADER_
  14
  15 /* include files */
  16 #ifdef __REACTOS__
  17 #include <ntifs.h>
  18 #include <ntddk.h>
  19 #include <ntdddisk.h>
  20 #include <pseh/pseh2.h>
  21 #endif
  22 #include "fs.h"
  23 #include "dinode.h"
  24 #include "dir.h"
  25 #include "disklabel.h"
  26 #ifndef __REACTOS__
  27 #include <ntdddisk.h>
  28 #endif
  29
  30 #ifndef _PREFAST_
  31 #ifdef _MSC_VER
  32 #pragma warning(disable:4068)
  33 #endif
  34 #define __drv_mustHoldCriticalRegion
  35 #endif // !_PREFAST_
  36
  37 #pragma pack(1)
  38
  39 /* debug */
  40 #if DBG
  41         #define FFSBreakPoint()    /*__asm int 3*/ //DbgBreakPoint()
  42 #else
  43         #define FFSBreakPoint()
  44 #endif
  45
  46 /* Structs & Consts */
  47
  48 #define FFSDRV_VERSION  "0.5.2"
  49
  50 /*
  51  * ffsdrv build options
  52  */
  53
  54 /* To build read-only driver */
  55
  56 #define FFS_READ_ONLY  TRUE
  57
  58
  59 /* To support driver dynamics unload */
  60
  61 #define FFS_UNLOAD     TRUE
  62
  63 /*
  64  * Constants
  65  */
  66
  67 #define FFS_BLOCK_TYPES                 (0x04)
  68
  69 #define MAXIMUM_RECORD_LENGTH           (0x10000)
  70
  71 #define SECTOR_BITS                     (Vcb->SectorBits)
  72 #define SECTOR_SIZE                     (Vcb->DiskGeometry.BytesPerSector)
  73 #define DEFAULT_SECTOR_SIZE             (0x200)
  74
  75 #define SUPER_BLOCK_OFFSET              (0x2000)
  76 #define SUPER_BLOCK_SIZE                SBLOCKSIZE
  77
  78 #define READ_AHEAD_GRANULARITY          (0x10000)
  79
  80 #define SUPER_BLOCK                     (Vcb->ffs_super_block)
  81 #define FS_VERSION                      (Vcb->FSVersion)
  82
  83 #define BLOCK_SIZE                      (Vcb->BlockSize)
  84 #define BLOCK_BITS                      FFSLog2(Vcb->BlockSize)
  85
  86 #define INODES_COUNT                    (Vcb->ffs_super_block->s_inodes_count)
  87
  88 #define INODES_PER_GROUP                (SUPER_BLOCK->fs_ipg)
  89 #define BLOCKS_PER_GROUP                (SUPER_BLOCK->fs_fpg)
  90 #define TOTAL_BLOCKS                    (SUPER_BLOCK->fs_size)
  91
  92
  93
  94 /* File System Releated */
  95
  96 #define DRIVER_NAME     "FFS"
  97 #ifndef __REACTOS__
  98 #define DEVICE_NAME     L"\\FileSystem\\FFS"
  99 #else
 100 #define DEVICE_NAME     L"\\FFS"
 101 #endif
 102
 103 /* Registry */
 104
 105 #define PARAMETERS_KEY    L"\\Parameters"
 106
 107 #define WRITING_SUPPORT     L"WritingSupport"
 108 #define CHECKING_BITMAP     L"CheckingBitmap"
 109 #define PARTITION_NUMBER    L"PartitionNumber"
 110
 111 /* To support select BSD partition and ffsdrv unload routine */
 112 #define DOS_DEVICE_NAME L"\\DosDevices\\ffs"
 113
 114 /*
 115  * Private IOCTL to make the driver ready to unload
 116  */
 117 #if FFS_UNLOAD
 118 #define IOCTL_PREPARE_TO_UNLOAD \
 119 CTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_NEITHER, FILE_WRITE_ACCESS)
 120 #endif // FFS_UNLOAD
 121
 122 /*
 123  * Private IOCTL to select BSD partition.
 124  */
 125 #define IOCTL_SELECT_BSD_PARTITION \
 126 CTL_CODE(FILE_DEVICE_UNKNOWN, 2049, METHOD_BUFFERED, FILE_WRITE_ACCESS)
 127
 128
 129 #ifndef SetFlag
 130 #define SetFlag(x,f)    ((x) |= (f))
 131 #endif
 132
 133 #ifndef ClearFlag
 134 #define ClearFlag(x,f)  ((x) &= ~(f))
 135 #endif
 136
 137 #define IsFlagOn(a,b) ((BOOLEAN)(FlagOn(a,b) == b))
 138
 139 #define FFSRaiseStatus(IRPCONTEXT,STATUS) {  \
 140         (IRPCONTEXT)->ExceptionCode = (STATUS); \
 141         ExRaiseStatus( (STATUS) );                \
 142 }
 143
 144 #define FFSNormalizeAndRaiseStatus(IRPCONTEXT,STATUS) {                        \
 145         /* (IRPCONTEXT)->ExceptionStatus = (STATUS);  */                            \
 146         if ((STATUS) == STATUS_VERIFY_REQUIRED) { ExRaiseStatus((STATUS)); }        \
 147         ExRaiseStatus(FsRtlNormalizeNtstatus((STATUS),STATUS_UNEXPECTED_IO_ERROR)); \
 148 }
 149
 150 /*
 151  * Define IsEndofFile for read and write operations
 152  */
 153
 154 #define FILE_WRITE_TO_END_OF_FILE       0xffffffff
 155 #define FILE_USE_FILE_POINTER_POSITION  0xfffffffe
 156
 157 #define IsEndOfFile(Pos) ((Pos.LowPart == FILE_WRITE_TO_END_OF_FILE) && \
 158                           (Pos.HighPart == FILE_USE_FILE_POINTER_POSITION ))
 159
 160 #define IsDirectory(Fcb) IsFlagOn(Fcb->FFSMcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY)
 161
 162 /*
 163  * Bug Check Codes Definitions
 164  */
 165
 166 #define FFS_FILE_SYSTEM   (FILE_SYSTEM)
 167
 168 #define FFS_BUGCHK_BLOCK               (0x00010000)
 169 #define FFS_BUGCHK_CLEANUP             (0x00020000)
 170 #define FFS_BUGCHK_CLOSE               (0x00030000)
 171 #define FFS_BUGCHK_CMCB                (0x00040000)
 172 #define FFS_BUGCHK_CREATE              (0x00050000)
 173 #define FFS_BUGCHK_DEBUG               (0x00060000)
 174 #define FFS_BUGCHK_DEVCTL              (0x00070000)
 175 #define FFS_BUGCHK_DIRCTL              (0x00080000)
 176 #define FFS_BUGCHK_DISPATCH            (0x00090000)
 177 #define FFS_BUGCHK_EXCEPT              (0x000A0000)
 178 #define FFS_BUGCHK_FFS                 (0x000B0000)
 179 #define FFS_BUGCHK_FASTIO              (0x000C0000)
 180 #define FFS_BUGCHK_FILEINFO            (0x000D0000)
 181 #define FFS_BUGCHK_FLUSH               (0x000E0000)
 182 #define FFS_BUGCHK_FSCTL               (0x000F0000)
 183 #define FFS_BUGCHK_INIT                (0x00100000)
 184 #define FFS_BUGCHK_LOCK                (0x0011000)
 185 #define FFS_BUGCHK_MEMORY              (0x0012000)
 186 #define FFS_BUGCHK_MISC                (0x0013000)
 187 #define FFS_BUGCHK_READ                (0x00140000)
 188 #define FFS_BUGCHK_SHUTDOWN            (0x00150000)
 189 #define FFS_BUGCHK_VOLINFO             (0x00160000)
 190 #define FFS_BUGCHK_WRITE               (0x00170000)
 191
 192 #define FFS_BUGCHK_LAST                (0x00170000)
 193
 194 #define FFSBugCheck(A,B,C,D) { KeBugCheckEx(FFS_FILE_SYSTEM, A | __LINE__, B, C, D ); }
 195
 196
 197 /* FFS file system definions */
 198
 199 /*
 200  * Structure of a directory entry
 201  */
 202 #define FFS_NAME_LEN 255
 203
 204 #define FFS_ROOT_INO           2   /* Root inode */
 205
 206
 207 /*
 208  * FFS_DIR_PAD defines the directory entries boundaries
 209  *
 210  * NOTE: It must be a multiple of 4
 211  */
 212 #define FFS_DIR_PAD                     4
 213 #define FFS_DIR_ROUND                   (FFS_DIR_PAD - 1)
 214 #define FFS_DIR_REC_LEN(name_len)       (((name_len) + 8 + FFS_DIR_ROUND) & \
 215                                          ~FFS_DIR_ROUND)
 216
 217
 218 /* sys/sys/stat.h */
 219
 220 #define S_ISDIR(m)  ((m & _S_IFMT) == _S_IFDIR)         /* directory */
 221 #define S_ISCHR(m)  ((m & _S_IFMT) == _S_IFCHR)         /* char special */
 222 #define S_ISBLK(m)  ((m & _S_IFMT) == _S_IFBLK)         /* block special */
 223 #define S_ISREG(m)  ((m & _S_IFMT) == _S_IFREG)         /* regular file */
 224 #define S_ISFIFO(m) ((m & _S_IFMT) == _S_IFIFO)         /* fifo */
 225 #define S_ISLNK(m)  ((m & _S_IFMT) == _S_IFLNK)         /* symbolic link */
 226 #define S_ISSOCK(m) ((m & _S_IFMT) == _S_IFSOCK)        /* socket */
 227 #define S_ISWHT(m)  ((m & _S_IFMT) == _S_IFWHT)         /* whiteout */
 228
 229
 230 #define S_IPERMISSION_MASK 0x1FF /*  */
 231
 232 #define S_IRWXU 0000700         /* RWX mask for owner */
 233 #define S_IRUSR 0000400         /* R for owner */
 234 #define S_IWUSR 0000200         /* W for owner */
 235 #define S_IXUSR 0000100         /* X for owner */
 236
 237 #define S_IRWXG 0000070         /* RWX mask for group */
 238 #define S_IRGRP 0000040         /* R for group */
 239 #define S_IWGRP 0000020         /* W for group */
 240 #define S_IXGRP 0000010         /* X for group */
 241
 242 #define S_IRWXO 0000007         /* RWX mask for other */
 243 #define S_IROTH 0000004         /* R for other */
 244 #define S_IWOTH 0000002         /* W for other */
 245 #define S_IXOTH 0000001         /* X for other */
 246
 247 #define S_ISREADABLE(m)    (((m) & S_IPERMISSION_MASK) == (S_IRUSR | S_IRGRP | S_IROTH))
 248 #define S_ISWRITABLE(m)    (((m) & S_IPERMISSION_MASK) == (S_IWUSR | S_IWGRP | S_IWOTH))
 249
 250 #define FFSSetReadable(m) (m) = ((m) | (S_IRUSR | S_IRGRP | S_IROTH))
 251 #define FFSSetWritable(m) (m) = ((m) | (S_IWUSR | S_IWGRP | S_IWOTH))
 252
 253 #define FFSSetReadOnly(m) (m) = ((m) & (~(S_IWUSR | S_IWGRP | S_IWOTH)))
 254 #define FFSIsReadOnly(m)  (!((m) & (S_IWUSR | S_IWGRP | S_IWOTH)))
 255
 256 #define FFS_FIRST_DATA_BLOCK   (Vcb->ffs_super_block->fs_dblkno)
 257
 258 typedef struct fs FFS_SUPER_BLOCK, *PFFS_SUPER_BLOCK;
 259
 260 typedef struct disklabel DISKLABEL, *PDISKLABEL;
 261
 262 typedef struct ufs1_dinode FFSv1_INODE, *PFFSv1_INODE;
 263 typedef struct ufs2_dinode FFSv2_INODE, *PFFSv2_INODE;
 264
 265 typedef struct direct FFS_DIR_ENTRY, *PFFS_DIR_ENTRY;
 266
 267
 268 /*
 269  * ffsdrv Driver Definitions
 270  */
 271
 272 /*
 273  * FFS_IDENTIFIER_TYPE
 274  *
 275  * Identifiers used to mark the structures
 276  */
 277
 278 typedef enum _FFS_IDENTIFIER_TYPE {
 279         FFSFGD  = ':DGF',
 280         FFSVCB  = ':BCV',
 281         FFSFCB  = ':BCF',
 282         FFSCCB  = ':BCC',
 283         FFSICX  = ':XCI',
 284         FFSDRV  = ':VRD',
 285         FFSMCB  = ':BCM'
 286 } FFS_IDENTIFIER_TYPE;
 287
 288 /*
 289  * FFS_IDENTIFIER
 290  *
 291  * Header used to mark the structures
 292  */
 293 typedef struct _FFS_IDENTIFIER {
 294         FFS_IDENTIFIER_TYPE      Type;
 295         ULONG                    Size;
 296 } FFS_IDENTIFIER, *PFFS_IDENTIFIER;
 297
 298
 299 #define NodeType(Ptr) (*((FFS_IDENTIFIER_TYPE *)(Ptr)))
 300
 301 typedef struct _FFS_MCB  FFS_MCB, *PFFS_MCB;
 302
 303
 304 typedef PVOID   PBCB;
 305
 306 /*
 307  * REPINNED_BCBS List
 308  */
 309
 310 #define FFS_REPINNED_BCBS_ARRAY_SIZE         (8)
 311
 312 typedef struct _FFS_REPINNED_BCBS {
 313
 314         //
 315         //  A pointer to the next structure contains additional repinned bcbs
 316         //
 317
 318         struct _FFS_REPINNED_BCBS *Next;
 319
 320         //
 321         //  A fixed size array of pinned bcbs.  Whenever a new bcb is added to
 322         //  the repinned bcb structure it is added to this array.  If the
 323         //  array is already full then another repinned bcb structure is allocated
 324         //  and pointed to with Next.
 325         //
 326
 327         PBCB Bcb[ FFS_REPINNED_BCBS_ARRAY_SIZE ];
 328
 329 } FFS_REPINNED_BCBS, *PFFS_REPINNED_BCBS;
 330
 331
 332 /*
 333  * FFS_BSD_PARTITION
 334  */
 335 typedef struct _FFS_BSD_PARTITION
 336 {
 337         ULONG Number;
 338 } FFS_BSD_PARTITION, *PFFS_BSD_PARTITION;
 339
 340
 341 /*
 342  * FFS_GLOBAL_DATA
 343  *
 344  * Data that is not specific to a mounted volume
 345  */
 346 typedef struct _FFS_GLOBAL {
 347
 348         // Identifier for this structure
 349         FFS_IDENTIFIER              Identifier;
 350
 351         // Syncronization primitive for this structure
 352         ERESOURCE                   Resource;
 353
 354         // Syncronization primitive for Counting
 355         ERESOURCE                   CountResource;
 356
 357         // Syncronization primitive for LookAside Lists
 358         ERESOURCE                   LAResource;
 359
 360         // Table of pointers to the fast I/O entry points
 361         FAST_IO_DISPATCH            FastIoDispatch;
 362
 363         // Table of pointers to the Cache Manager callbacks
 364         CACHE_MANAGER_CALLBACKS     CacheManagerCallbacks;
 365         CACHE_MANAGER_CALLBACKS     CacheManagerNoOpCallbacks;
 366
 367         // Pointer to the driver object
 368         PDRIVER_OBJECT              DriverObject;
 369
 370         // Pointer to the main device object
 371         PDEVICE_OBJECT              DeviceObject;
 372
 373         // List of mounted volumes
 374         LIST_ENTRY                  VcbList;
 375
 376         // Look Aside table of IRP_CONTEXT, FCB, MCB, CCB
 377         USHORT                      MaxDepth;
 378         NPAGED_LOOKASIDE_LIST       FFSIrpContextLookasideList;
 379         NPAGED_LOOKASIDE_LIST       FFSFcbLookasideList;
 380         NPAGED_LOOKASIDE_LIST       FFSCcbLookasideList;
 381         PAGED_LOOKASIDE_LIST        FFSMcbLookasideList;
 382
 383         // Mcb Count ...
 384         USHORT                      McbAllocated;
 385
 386 #if DBG
 387         // Fcb Count
 388         USHORT                      FcbAllocated;
 389
 390         // IRP_MJ_CLOSE : FCB
 391         USHORT                      IRPCloseCount;
 392 #endif
 393
 394         // Global flags for the driver
 395         ULONG                       Flags;
 396
 397         ULONG                       PartitionNumber;
 398
 399 } FFS_GLOBAL, *PFFS_GLOBAL;
 400
 401 /*
 402  * Flags for FFS_GLOBAL_DATA
 403  */
 404 #define FFS_UNLOAD_PENDING     0x00000001
 405 #define FFS_SUPPORT_WRITING    0x00000002
 406 #define FFS_CHECKING_BITMAP    0x00000008
 407
 408 /*
 409  * Driver Extension define
 410  */
 411 typedef struct {
 412         FFS_GLOBAL FFSGlobal;
 413 } FFS_EXT, *PFFS_EXT;
 414
 415
 416 typedef struct _FFS_FCBVCB {
 417
 418         // FCB header required by NT
 419         FSRTL_COMMON_FCB_HEADER         CommonFCBHeader;
 420         SECTION_OBJECT_POINTERS         SectionObject;
 421         ERESOURCE                       MainResource;
 422         ERESOURCE                       PagingIoResource;
 423         // end FCB header required by NT
 424
 425         // Identifier for this structure
 426         FFS_IDENTIFIER                  Identifier;
 427 } FFS_FCBVCB, *PFFS_FCBVCB;
 428
 429 /*
 430  * FFS_VCB Volume Control Block
 431  *
 432  * Data that represents a mounted logical volume
 433  * It is allocated as the device extension of the volume device object
 434  */
 435 typedef struct _FFS_VCB {
 436
 437         // FCB header required by NT
 438         // The VCB is also used as an FCB for file objects
 439         // that represents the volume itself
 440         FSRTL_COMMON_FCB_HEADER     Header;
 441         SECTION_OBJECT_POINTERS     SectionObject;
 442         ERESOURCE                   MainResource;
 443         ERESOURCE                   PagingIoResource;
 444         // end FCB header required by NT
 445
 446         // Identifier for this structure
 447         FFS_IDENTIFIER              Identifier;
 448
 449         LIST_ENTRY                  Next;
 450
 451         // Share Access for the file object
 452         SHARE_ACCESS                ShareAccess;
 453
 454         // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
 455         // for files on this volume.
 456         ULONG                       OpenFileHandleCount;
 457
 458         // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
 459         // for both files on this volume and open instances of the
 460         // volume itself.
 461         ULONG                       ReferenceCount;
 462         ULONG                       OpenHandleCount;
 463
 464         //
 465         // Disk change count
 466         //
 467
 468         ULONG                       ChangeCount;
 469
 470         // Pointer to the VPB in the target device object
 471         PVPB                        Vpb;
 472
 473         // The FileObject of Volume used to lock the volume
 474         PFILE_OBJECT                LockFile;
 475
 476         // List of FCBs for open files on this volume
 477         LIST_ENTRY                  FcbList;
 478
 479         // List of IRPs pending on directory change notify requests
 480         LIST_ENTRY                  NotifyList;
 481
 482         // Pointer to syncronization primitive for this list
 483         PNOTIFY_SYNC                NotifySync;
 484
 485         // This volumes device object
 486         PDEVICE_OBJECT              DeviceObject;
 487
 488         // The physical device object (the disk)
 489         PDEVICE_OBJECT              TargetDeviceObject;
 490
 491         // The physical device object (the disk)
 492         PDEVICE_OBJECT              RealDevice;
 493
 494         // Information about the physical device object
 495         DISK_GEOMETRY               DiskGeometry;
 496         PARTITION_INFORMATION       PartitionInformation;
 497
 498         // File System Super Block
 499         PFFS_SUPER_BLOCK            ffs_super_block;
 500
 501         // File System version
 502         ULONG                       FSVersion;
 503
 504         // Number of Group Decsciptions
 505         ULONG                       ffs_groups;
 506         /*
 507         // Bitmap Block per group
 508         PRTL_BITMAP                 BlockBitMaps;
 509         PRTL_BITMAP                 InodeBitMaps;
 510         */
 511         // Block / Cluster size
 512         ULONG                       BlockSize;
 513
 514         // Sector size in bits
 515         ULONG                       SectorBits;
 516
 517         ULONG                       dwData[FFS_BLOCK_TYPES];
 518         ULONG                       dwMeta[FFS_BLOCK_TYPES];
 519
 520         // Flags for the volume
 521         ULONG                       Flags;
 522
 523         // Streaming File Object
 524         PFILE_OBJECT                StreamObj;
 525
 526         // Resource Lock for Mcb
 527         ERESOURCE                   McbResource;
 528
 529         // Dirty Mcbs of modifications for volume stream
 530         LARGE_MCB                   DirtyMcbs;
 531
 532         // Entry of Mcb Tree (Root Node)
 533         PFFS_MCB                    McbTree;
 534         LIST_ENTRY                  McbList;
 535
 536         ULONGLONG                   FSOffset[MAXPARTITIONS];
 537
 538         ULONG                       RootPartition;
 539
 540         ULONG                       PartitionNumber;
 541
 542 } FFS_VCB, *PFFS_VCB;
 543
 544 /*
 545  * Flags for FFS_VCB
 546  */
 547 #define VCB_INITIALIZED         0x00000001
 548 #define VCB_VOLUME_LOCKED       0x00000002
 549 #define VCB_MOUNTED             0x00000004
 550 #define VCB_DISMOUNT_PENDING    0x00000008
 551 #define VCB_READ_ONLY           0x00000010
 552
 553 #define VCB_WRITE_PROTECTED     0x10000000
 554 #define VCB_FLOPPY_DISK         0x20000000
 555 #define VCB_REMOVAL_PREVENTED   0x40000000
 556 #define VCB_REMOVABLE_MEDIA     0x80000000
 557
 558
 559 #define IsMounted(Vcb)    (IsFlagOn(Vcb->Flags, VCB_MOUNTED))
 560
 561
 562 /*
 563  * FFS_FCB File Control Block
 564  *
 565  * Data that represents an open file
 566  * There is a single instance of the FCB for every open file
 567  */
 568 typedef struct _FFS_FCB {
 569
 570         // FCB header required by NT
 571         FSRTL_COMMON_FCB_HEADER         Header;
 572         SECTION_OBJECT_POINTERS         SectionObject;
 573         ERESOURCE                       MainResource;
 574         ERESOURCE                       PagingIoResource;
 575         // end FCB header required by NT
 576
 577         // Identifier for this structure
 578         FFS_IDENTIFIER                  Identifier;
 579
 580         // List of FCBs for this volume
 581         LIST_ENTRY                      Next;
 582
 583         // Share Access for the file object
 584         SHARE_ACCESS                    ShareAccess;
 585
 586         // List of byte-range locks for this file
 587         FILE_LOCK                       FileLockAnchor;
 588
 589         // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
 590         ULONG                           OpenHandleCount;
 591
 592         // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
 593         ULONG                           ReferenceCount;
 594
 595         // Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
 596         // But only for Files with FO_NO_INTERMEDIATE_BUFFERING flag
 597         ULONG                           NonCachedOpenCount;
 598
 599         // Flags for the FCB
 600         ULONG                           Flags;
 601
 602         // Pointer to the inode
 603         PFFSv1_INODE                    dinode1;
 604         PFFSv2_INODE                    dinode2;
 605
 606         // Hint block for next allocation
 607         ULONG                           BlkHint;
 608
 609         // Vcb
 610
 611         PFFS_VCB                        Vcb;
 612
 613         // Mcb Node ...
 614         PFFS_MCB                        FFSMcb;
 615
 616         // Full Path Name
 617         UNICODE_STRING                  LongName;
 618
 619 #if DBG
 620         // The Ansi Filename for debugging
 621         OEM_STRING                      AnsiFileName;
 622 #endif
 623
 624
 625 } FFS_FCB, *PFFS_FCB;
 626
 627
 628 //
 629 // Flags for FFS_FCB
 630 //
 631 #define FCB_FROM_POOL               0x00000001
 632 #define FCB_PAGE_FILE               0x00000002
 633 #define FCB_DELETE_ON_CLOSE         0x00000004
 634 #define FCB_DELETE_PENDING          0x00000008
 635 #define FCB_FILE_DELETED            0x00000010
 636 #define FCB_FILE_MODIFIED           0x00000020
 637
 638 // Mcb Node
 639
 640 struct _FFS_MCB {
 641
 642         // Identifier for this structure
 643         FFS_IDENTIFIER                  Identifier;
 644
 645         // Flags
 646         ULONG                           Flags;
 647
 648         // Link List Info
 649
 650         PFFS_MCB                        Parent; // Parent
 651         PFFS_MCB                        Child;  // Children
 652         PFFS_MCB                        Next;   // Brothers
 653
 654         // Mcb Node Info
 655
 656         // -> Fcb
 657         PFFS_FCB                        FFSFcb;
 658
 659         // Short name
 660         UNICODE_STRING                  ShortName;
 661
 662         // Inode number
 663         ULONG                           Inode;
 664
 665         // Dir entry offset in parent
 666         ULONG                           DeOffset;
 667
 668         // File attribute
 669         ULONG                           FileAttr;
 670
 671         // List Link to Vcb->McbList
 672         LIST_ENTRY                      Link;
 673 };
 674
 675 /*
 676  * Flags for MCB
 677  */
 678 #define MCB_FROM_POOL               0x00000001
 679 #define MCB_IN_TREE                 0x00000002
 680 #define MCB_IN_USE                  0x00000004
 681
 682 #define IsMcbUsed(Mcb) IsFlagOn(Mcb->Flags, MCB_IN_USE)
 683
 684
 685 /*
 686  * FFS_CCB Context Control Block
 687  *
 688  * Data that represents one instance of an open file
 689  * There is one instance of the CCB for every instance of an open file
 690  */
 691 typedef struct _FFS_CCB {
 692
 693         // Identifier for this structure
 694         FFS_IDENTIFIER   Identifier;
 695
 696         // Flags
 697         ULONG             Flags;
 698
 699         // State that may need to be maintained
 700         ULONG             CurrentByteOffset;
 701         UNICODE_STRING    DirectorySearchPattern;
 702
 703 } FFS_CCB, *PFFS_CCB;
 704
 705 /*
 706  * Flags for CCB
 707  */
 708
 709 #define CCB_FROM_POOL               0x00000001
 710
 711 #define CCB_ALLOW_EXTENDED_DASD_IO  0x80000000
 712
 713
 714 /*
 715  * FFS_IRP_CONTEXT
 716  *
 717  * Used to pass information about a request between the drivers functions
 718  */
 719 typedef struct _FFS_IRP_CONTEXT {
 720
 721         // Identifier for this structure
 722         FFS_IDENTIFIER      Identifier;
 723
 724         // Pointer to the IRP this request describes
 725         PIRP                Irp;
 726
 727         // Flags
 728         ULONG               Flags;
 729
 730         // The major and minor function code for the request
 731         UCHAR               MajorFunction;
 732         UCHAR               MinorFunction;
 733
 734         // The device object
 735         PDEVICE_OBJECT      DeviceObject;
 736
 737         // The real device object
 738         PDEVICE_OBJECT      RealDevice;
 739
 740         // The file object
 741         PFILE_OBJECT        FileObject;
 742
 743         PFFS_FCB            Fcb;
 744         PFFS_CCB            Ccb;
 745
 746         // If the request is synchronous (we are allowed to block)
 747         BOOLEAN             IsSynchronous;
 748
 749         // If the request is top level
 750         BOOLEAN             IsTopLevel;
 751
 752         // Used if the request needs to be queued for later processing
 753         WORK_QUEUE_ITEM     WorkQueueItem;
 754
 755         // If an exception is currently in progress
 756         BOOLEAN             ExceptionInProgress;
 757
 758         // The exception code when an exception is in progress
 759         NTSTATUS            ExceptionCode;
 760
 761         // Repinned BCBs List
 762         FFS_REPINNED_BCBS  Repinned;
 763
 764 } FFS_IRP_CONTEXT, *PFFS_IRP_CONTEXT;
 765
 766
 767 #define IRP_CONTEXT_FLAG_FROM_POOL       (0x00000001)
 768 #define IRP_CONTEXT_FLAG_WAIT            (0x00000002)
 769 #define IRP_CONTEXT_FLAG_WRITE_THROUGH   (0x00000004)
 770 #define IRP_CONTEXT_FLAG_FLOPPY          (0x00000008)
 771 #define IRP_CONTEXT_FLAG_RECURSIVE_CALL  (0x00000010)
 772 #define IRP_CONTEXT_FLAG_DISABLE_POPUPS  (0x00000020)
 773 #define IRP_CONTEXT_FLAG_DEFERRED        (0x00000040)
 774 #define IRP_CONTEXT_FLAG_VERIFY_READ     (0x00000080)
 775 #define IRP_CONTEXT_STACK_IO_CONTEXT     (0x00000100)
 776 #define IRP_CONTEXT_FLAG_REQUEUED        (0x00000200)
 777 #define IRP_CONTEXT_FLAG_USER_IO         (0x00000400)
 778 #define IRP_CONTEXT_FLAG_DELAY_CLOSE     (0x00000800)
 779
 780
 781 /*
 782  * FFS_ALLOC_HEADER
 783  *
 784  * In the checked version of the driver this header is put in the beginning of
 785  * every memory allocation
 786  */
 787 typedef struct _FFS_ALLOC_HEADER {
 788     FFS_IDENTIFIER Identifier;
 789 } FFS_ALLOC_HEADER, *PFFS_ALLOC_HEADER;
 790
 791 typedef struct _FCB_LIST_ENTRY {
 792     PFFS_FCB     Fcb;
 793     LIST_ENTRY   Next;
 794 } FCB_LIST_ENTRY, *PFCB_LIST_ENTRY;
 795
 796
 797 /* Block Description List */
 798 typedef struct _FFS_BDL {
 799     LONGLONG    Lba;
 800     ULONG       Offset;
 801     ULONG       Length;
 802     PIRP        Irp;
 803 } FFS_BDL, *PFFS_BDL;
 804
 805 #pragma pack()
 806
 807
 808 /*
 809  *  The following macro is used to determine if an FSD thread can block
 810  *  for I/O or wait for a resource.  It returns TRUE if the thread can
 811  *  block and FALSE otherwise.  This attribute can then be used to call
 812  *  the FSD & FSP common work routine with the proper wait value.
 813  */
 814
 815 #define CanFFSWait(IRP) IoIsOperationSynchronous(Irp)
 816
 817 #define FFS_POOL_TAG 'dsfF'
 818
 819 //
 820 // Block.c
 821 //
 822
 823 NTSTATUS
 824 FFSLockUserBuffer(
 825         IN PIRP             Irp,
 826         IN ULONG            Length,
 827         IN LOCK_OPERATION   Operation);
 828 PVOID
 829 FFSGetUserBuffer(
 830         IN PIRP Irp);
 831
 832 NTSTATUS
 833 FFSReadWriteBlocks(
 834         IN PFFS_IRP_CONTEXT IrpContext,
 835         IN PFFS_VCB         Vcb,
 836         IN PFFS_BDL         FFSBDL,
 837         IN ULONG            Length,
 838         IN ULONG            Count,
 839         IN BOOLEAN          bVerify);
 840
 841 NTSTATUS
 842 FFSReadSync(
 843         IN PFFS_VCB         Vcb,
 844         IN ULONGLONG        Offset,
 845         IN ULONG            Length,
 846         OUT PVOID           Buffer,
 847         IN BOOLEAN          bVerify);
 848
 849 NTSTATUS
 850 FFSReadDisk(
 851         IN PFFS_VCB        Vcb,
 852         IN ULONGLONG       Offset,
 853         IN ULONG           Size,
 854         IN PVOID           Buffer,
 855         IN BOOLEAN         bVerify);
 856
 857 NTSTATUS
 858 FFSDiskIoControl(
 859         IN PDEVICE_OBJECT   DeviceOjbect,
 860         IN ULONG            IoctlCode,
 861         IN PVOID            InputBuffer,
 862         IN ULONG            InputBufferSize,
 863         IN OUT PVOID        OutputBuffer,
 864         IN OUT PULONG       OutputBufferSize);
 865
 866 __drv_mustHoldCriticalRegion
 867 VOID
 868 FFSMediaEjectControl(
 869         IN PFFS_IRP_CONTEXT IrpContext,
 870         IN PFFS_VCB Vcb,
 871         IN BOOLEAN bPrevent);
 872
 873 NTSTATUS
 874 FFSDiskShutDown(
 875         PFFS_VCB Vcb);
 876
 877
 878 //
 879 // Cleanup.c
 880 //
 881
 882 __drv_mustHoldCriticalRegion
 883 NTSTATUS
 884 FFSCleanup(
 885         IN PFFS_IRP_CONTEXT IrpContext);
 886
 887
 888 //
 889 // Close.c
 890 //
 891
 892 __drv_mustHoldCriticalRegion
 893 NTSTATUS
 894 FFSClose(
 895         IN PFFS_IRP_CONTEXT IrpContext);
 896
 897 VOID
 898 FFSQueueCloseRequest(
 899         IN PFFS_IRP_CONTEXT IrpContext);
 900
 901 #ifdef _PREFAST_
 902 IO_WORKITEM_ROUTINE FFSDeQueueCloseRequest;
 903 #endif // _PREFAST_
 904
 905 VOID NTAPI
 906 FFSDeQueueCloseRequest(
 907         IN PVOID Context);
 908
 909
 910 //
 911 // Cmcb.c
 912 //
 913
 914 __drv_mustHoldCriticalRegion
 915 BOOLEAN NTAPI
 916 FFSAcquireForLazyWrite(
 917         IN PVOID    Context,
 918         IN BOOLEAN  Wait);
 919
 920 __drv_mustHoldCriticalRegion
 921 VOID NTAPI
 922 FFSReleaseFromLazyWrite(
 923         IN PVOID Context);
 924
 925 __drv_mustHoldCriticalRegion
 926 BOOLEAN NTAPI
 927 FFSAcquireForReadAhead(
 928         IN PVOID    Context,
 929         IN BOOLEAN  Wait);
 930
 931 BOOLEAN NTAPI
 932 FFSNoOpAcquire(
 933         IN PVOID   Fcb,
 934         IN BOOLEAN Wait);
 935
 936 VOID NTAPI
 937 FFSNoOpRelease(
 938         IN PVOID Fcb);
 939
 940 __drv_mustHoldCriticalRegion
 941 VOID NTAPI
 942 FFSReleaseFromReadAhead(
 943         IN PVOID Context);
 944
 945
 946 //
 947 // Create.c
 948 //
 949
 950 PFFS_FCB
 951 FFSSearchFcbList(
 952         IN PFFS_VCB     Vcb,
 953         IN ULONG        inode);
 954
 955 NTSTATUS
 956 FFSv1ScanDir(
 957         IN PFFS_VCB        Vcb,
 958         IN PFFS_MCB        ParentMcb,
 959         IN PUNICODE_STRING FileName,
 960         IN OUT PULONG      Index,
 961         IN PFFSv1_INODE    dinode1,
 962         IN PFFS_DIR_ENTRY  ffs_dir);
 963
 964 NTSTATUS
 965 FFSv2ScanDir(
 966         IN PFFS_VCB        Vcb,
 967         IN PFFS_MCB        ParentMcb,
 968         IN PUNICODE_STRING FileName,
 969         IN OUT PULONG      Index,
 970         IN PFFSv2_INODE    dinode2,
 971         IN PFFS_DIR_ENTRY  ffs_dir);
 972
 973 NTSTATUS
 974 FFSv1LookupFileName(
 975         IN PFFS_VCB            Vcb,
 976         IN PUNICODE_STRING     FullFileName,
 977         IN PFFS_MCB            ParentMcb,
 978         OUT PFFS_MCB*          FFSMcb,
 979         IN OUT PFFSv1_INODE    dinode1);
 980
 981
 982 NTSTATUS
 983 FFSv2LookupFileName(
 984         IN PFFS_VCB            Vcb,
 985         IN PUNICODE_STRING     FullFileName,
 986         IN PFFS_MCB            ParentMcb,
 987         OUT PFFS_MCB*          FFSMcb,
 988         IN OUT PFFSv2_INODE    dinode2);
 989
 990 __drv_mustHoldCriticalRegion
 991 NTSTATUS
 992 FFSCreateFile(
 993         IN PFFS_IRP_CONTEXT IrpContext,
 994         IN PFFS_VCB         Vcb);
 995
 996 __drv_mustHoldCriticalRegion
 997 NTSTATUS
 998 FFSCreateVolume(
 999         IN PFFS_IRP_CONTEXT IrpContext,
1000         IN PFFS_VCB         Vcb);
1001
1002 __drv_mustHoldCriticalRegion
1003 NTSTATUS
1004 FFSCreate(
1005         IN PFFS_IRP_CONTEXT IrpContext);
1006
1007 __drv_mustHoldCriticalRegion
1008 NTSTATUS
1009 FFSCreateInode(
1010         PFFS_IRP_CONTEXT    IrpContext,
1011         PFFS_VCB            Vcb,
1012         PFFS_FCB            ParentFcb,
1013         ULONG               Type,
1014         ULONG               FileAttr,
1015         PUNICODE_STRING     FileName);
1016
1017 __drv_mustHoldCriticalRegion
1018 NTSTATUS
1019 FFSSupersedeOrOverWriteFile(
1020         IN PFFS_IRP_CONTEXT IrpContext,
1021         IN PFFS_VCB         Vcb,
1022         IN PFFS_FCB         Fcb,
1023         IN ULONG            Disposition);
1024
1025
1026 //
1027 // Debug.c
1028 //
1029
1030 #define DBG_VITAL 0
1031 #define DBG_ERROR 1
1032 #define DBG_USER  2
1033 #define DBG_TRACE 3
1034 #define DBG_INFO  4
1035 #define DBG_FUNC  5
1036
1037 #if DBG
1038 #define FFSPrint(arg)          FFSPrintf   arg
1039 #define FFSPrintNoIndent(arg)  FFSNIPrintf arg
1040
1041 #define FFSCompleteRequest(Irp, bPrint, PriorityBoost) \
1042         FFSDbgPrintComplete(Irp, bPrint); \
1043         IoCompleteRequest(Irp, PriorityBoost)
1044
1045 #else
1046
1047 #define FFSPrint(arg)
1048
1049 #define FFSCompleteRequest(Irp, bPrint, PriorityBoost) \
1050         IoCompleteRequest(Irp, PriorityBoost)
1051
1052 #endif // DBG
1053
1054 VOID
1055 __cdecl
1056 FFSPrintf(
1057         LONG  DebugPrintLevel,
1058         PCHAR DebugMessage,
1059         ...);
1060
1061 VOID
1062 __cdecl
1063 FFSNIPrintf(
1064         LONG  DebugPrintLevel,
1065         PCHAR DebugMessage,
1066         ...);
1067
1068 extern ULONG ProcessNameOffset;
1069
1070 #define FFSGetCurrentProcessName() ( \
1071     (PCHAR) PsGetCurrentProcess() + ProcessNameOffset \
1072 )
1073
1074 ULONG
1075 FFSGetProcessNameOffset(
1076         VOID);
1077
1078 VOID
1079 FFSDbgPrintCall(
1080         IN PDEVICE_OBJECT   DeviceObject,
1081         IN PIRP             Irp);
1082
1083 VOID
1084 FFSDbgPrintComplete(
1085         IN PIRP Irp,
1086         IN BOOLEAN bPrint);
1087
1088 PCHAR
1089 FFSNtStatusToString(
1090         IN NTSTATUS Status);
1091
1092
1093 //
1094 // Devctl.c
1095 //
1096
1097 __drv_mustHoldCriticalRegion
1098 NTSTATUS
1099 FFSDeviceControlNormal(
1100         IN PFFS_IRP_CONTEXT IrpContext);
1101
1102 __drv_mustHoldCriticalRegion
1103 NTSTATUS
1104 FFSPrepareToUnload(
1105         IN PFFS_IRP_CONTEXT IrpContext);
1106
1107 __drv_mustHoldCriticalRegion
1108 NTSTATUS
1109 FFSDeviceControl(
1110         IN PFFS_IRP_CONTEXT IrpContext);
1111
1112
1113 //
1114 // Dirctl.c
1115 //
1116
1117 ULONG
1118 FFSGetInfoLength(
1119         IN FILE_INFORMATION_CLASS  FileInformationClass);
1120
1121 ULONG
1122 FFSProcessDirEntry(
1123         IN PFFS_VCB                Vcb,
1124         IN FILE_INFORMATION_CLASS  FileInformationClass,
1125         IN ULONG                   in,
1126         IN PVOID                   Buffer,
1127         IN ULONG                   UsedLength,
1128         IN ULONG                   Length,
1129         IN ULONG                   FileIndex,
1130         IN PUNICODE_STRING         pName,
1131         IN BOOLEAN                 Single);
1132
1133 __drv_mustHoldCriticalRegion
1134 NTSTATUS
1135 FFSQueryDirectory(
1136         IN PFFS_IRP_CONTEXT IrpContext);
1137
1138 __drv_mustHoldCriticalRegion
1139 NTSTATUS
1140 FFSNotifyChangeDirectory(
1141     IN PFFS_IRP_CONTEXT IrpContext);
1142
1143 VOID
1144 FFSNotifyReportChange(
1145         IN PFFS_IRP_CONTEXT  IrpContext,
1146         IN PFFS_VCB          Vcb,
1147         IN PFFS_FCB          Fcb,
1148         IN ULONG             Filter,
1149         IN ULONG             Action);
1150
1151 __drv_mustHoldCriticalRegion
1152 NTSTATUS
1153 FFSDirectoryControl(
1154         IN PFFS_IRP_CONTEXT IrpContext);
1155
1156 BOOLEAN
1157 FFSIsDirectoryEmpty(
1158         PFFS_VCB Vcb,
1159         PFFS_FCB Dcb);
1160
1161
1162 //
1163 // Dispatch.c
1164 //
1165
1166 NTSTATUS
1167 FFSQueueRequest(
1168         IN PFFS_IRP_CONTEXT IrpContext);
1169
1170 #ifdef _PREFAST_
1171 IO_WORKITEM_ROUTINE FFSDeQueueRequest;
1172 #endif // _PREFAST_
1173
1174 VOID NTAPI
1175 FFSDeQueueRequest(
1176         IN PVOID Context);
1177
1178 NTSTATUS
1179 FFSDispatchRequest(
1180         IN PFFS_IRP_CONTEXT IrpContext);
1181
1182 #ifdef _PREFAST_
1183 __drv_dispatchType(IRP_MJ_CREATE)
1184 __drv_dispatchType(IRP_MJ_CLOSE)
1185 __drv_dispatchType(IRP_MJ_READ)
1186 __drv_dispatchType(IRP_MJ_WRITE)
1187 __drv_dispatchType(IRP_MJ_QUERY_INFORMATION)
1188 __drv_dispatchType(IRP_MJ_SET_INFORMATION)
1189 __drv_dispatchType(IRP_MJ_FLUSH_BUFFERS)
1190 __drv_dispatchType(IRP_MJ_QUERY_VOLUME_INFORMATION)
1191 __drv_dispatchType(IRP_MJ_SET_VOLUME_INFORMATION)
1192 __drv_dispatchType(IRP_MJ_DIRECTORY_CONTROL)
1193 __drv_dispatchType(IRP_MJ_FILE_SYSTEM_CONTROL)
1194 __drv_dispatchType(IRP_MJ_DEVICE_CONTROL)
1195 __drv_dispatchType(IRP_MJ_SHUTDOWN)
1196 __drv_dispatchType(IRP_MJ_LOCK_CONTROL)
1197 __drv_dispatchType(IRP_MJ_CLEANUP)
1198 __drv_dispatchType(IRP_MJ_PNP)
1199 DRIVER_DISPATCH FFSBuildRequest;
1200 #endif // _PREFAST_
1201
1202 NTSTATUS NTAPI
1203 FFSBuildRequest(
1204         PDEVICE_OBJECT   DeviceObject,
1205         PIRP             Irp);
1206
1207
1208 //
1209 // Except.c
1210 //
1211
1212 NTSTATUS
1213 FFSExceptionFilter(
1214         IN PFFS_IRP_CONTEXT    IrpContext,
1215         IN PEXCEPTION_POINTERS ExceptionPointer);
1216
1217 NTSTATUS
1218 FFSExceptionHandler(
1219         IN PFFS_IRP_CONTEXT IrpContext);
1220
1221
1222 //
1223 // ffs.c
1224 //
1225
1226 PFFS_SUPER_BLOCK
1227 FFSLoadSuper(
1228         IN PFFS_VCB       Vcb,
1229         IN BOOLEAN        bVerify,
1230         IN ULONGLONG      SuperBlockOffset);
1231
1232 __drv_mustHoldCriticalRegion
1233 BOOLEAN
1234 FFSSaveSuper(
1235         IN PFFS_IRP_CONTEXT    IrpContext,
1236         IN PFFS_VCB            Vcb);
1237
1238 BOOLEAN
1239 FFSLoadGroup(
1240         IN PFFS_VCB Vcb);
1241
1242 BOOLEAN
1243 FFSSaveGroup(
1244         IN PFFS_IRP_CONTEXT    IrpContext,
1245         IN PFFS_VCB            Vcb);
1246
1247 BOOLEAN
1248 FFSv1GetInodeLba(
1249         IN PFFS_VCB   Vcb,
1250         IN  ULONG     inode,
1251         OUT PLONGLONG offset);
1252
1253 BOOLEAN
1254 FFSv2GetInodeLba(
1255         IN PFFS_VCB   Vcb,
1256         IN  ULONG     inode,
1257         OUT PLONGLONG offset);
1258
1259 BOOLEAN
1260 FFSv1LoadInode(
1261         IN PFFS_VCB     Vcb,
1262         IN ULONG        inode,
1263         IN PFFSv1_INODE dinode1);
1264
1265 BOOLEAN
1266 FFSv2LoadInode(
1267         IN PFFS_VCB     Vcb,
1268         IN ULONG        inode,
1269         IN PFFSv2_INODE dinode2);
1270
1271 __drv_mustHoldCriticalRegion
1272 BOOLEAN
1273 FFSv1SaveInode(
1274         IN PFFS_IRP_CONTEXT   IrpContext,
1275         IN PFFS_VCB           Vcb,
1276         IN ULONG              Inode,
1277         IN PFFSv1_INODE       dinode1);
1278
1279 __drv_mustHoldCriticalRegion
1280 BOOLEAN
1281 FFSv2SaveInode(
1282         IN PFFS_IRP_CONTEXT   IrpContext,
1283         IN PFFS_VCB           Vcb,
1284         IN ULONG              Inode,
1285         IN PFFSv2_INODE       dinode2);
1286
1287 BOOLEAN
1288 FFSv1LoadBlock(
1289         IN PFFS_VCB  Vcb,
1290         IN ULONG     dwBlk,
1291         IN PVOID     Buffer);
1292
1293 BOOLEAN
1294 FFSv2LoadBlock(
1295         IN PFFS_VCB  Vcb,
1296         IN ULONGLONG dwBlk,
1297         IN PVOID     Buffer);
1298
1299 __drv_mustHoldCriticalRegion
1300 BOOLEAN
1301 FFSSaveBlock(
1302         IN PFFS_IRP_CONTEXT IrpContext,
1303         IN PFFS_VCB         Vcb,
1304         IN ULONG            dwBlk,
1305         IN PVOID            Buf);
1306
1307 __drv_mustHoldCriticalRegion
1308 BOOLEAN
1309 FFSSaveBuffer(
1310         IN PFFS_IRP_CONTEXT IrpContext,
1311         IN PFFS_VCB         Vcb,
1312         IN LONGLONG         Offset,
1313         IN ULONG            Size,
1314         IN PVOID            Buf);
1315
1316 ULONG
1317 FFSv1GetBlock(
1318         IN PFFS_VCB Vcb,
1319         IN ULONG       dwContent,
1320         IN ULONG       Index,
1321         IN int         layer);
1322
1323 ULONGLONG
1324 FFSv2GetBlock(
1325         IN PFFS_VCB Vcb,
1326         IN ULONGLONG   dwContent,
1327         IN ULONG       Index,
1328         IN int         layer);
1329
1330 ULONG
1331 FFSv1BlockMap(
1332         IN PFFS_VCB     Vcb,
1333         IN PFFSv1_INODE dinode1,
1334         IN ULONG        Index);
1335
1336 ULONGLONG
1337 FFSv2BlockMap(
1338         IN PFFS_VCB     Vcb,
1339         IN PFFSv2_INODE dinode2,
1340         IN ULONG        Index);
1341
1342 ULONG
1343 FFSv1BuildBDL(
1344         IN PFFS_IRP_CONTEXT IrpContext,
1345         IN PFFS_VCB         Vcb,
1346         IN PFFSv1_INODE     dinode1,
1347         IN ULONGLONG        Offset,
1348         IN ULONG            Size,
1349         OUT PFFS_BDL        *ffs_bdl);
1350
1351 ULONG
1352 FFSv2BuildBDL(
1353         IN PFFS_IRP_CONTEXT IrpContext,
1354         IN PFFS_VCB         Vcb,
1355         IN PFFSv2_INODE     dinode2,
1356         IN ULONGLONG        Offset,
1357         IN ULONG            Size,
1358         OUT PFFS_BDL        *ffs_bdl);
1359
1360 BOOLEAN
1361 FFSNewBlock(
1362         PFFS_IRP_CONTEXT IrpContext,
1363         PFFS_VCB         Vcb,
1364         ULONG            GroupHint,
1365         ULONG            BlockHint,
1366         PULONG           dwRet);
1367
1368 BOOLEAN
1369 FFSFreeBlock(
1370         PFFS_IRP_CONTEXT IrpContext,
1371         PFFS_VCB         Vcb,
1372         ULONG            Block);
1373
1374 __drv_mustHoldCriticalRegion
1375 BOOLEAN
1376 FFSExpandBlock(
1377         PFFS_IRP_CONTEXT IrpContext,
1378         PFFS_VCB         Vcb,
1379         PFFS_FCB         Fcb,
1380         ULONG            dwContent,
1381         ULONG            Index,
1382         ULONG            layer,
1383         BOOLEAN          bNew,
1384         ULONG            *dwRet);
1385
1386 BOOLEAN
1387 FFSExpandInode(
1388         PFFS_IRP_CONTEXT IrpContext,
1389         PFFS_VCB         Vcb,
1390         PFFS_FCB         Fcb,
1391         ULONG            *dwRet);
1392
1393 NTSTATUS
1394 FFSNewInode(
1395         PFFS_IRP_CONTEXT IrpContext,
1396         PFFS_VCB         Vcb,
1397         ULONG            GroupHint,
1398         ULONG            Type,
1399         PULONG           Inode);
1400
1401 BOOLEAN
1402 FFSFreeInode(
1403         PFFS_IRP_CONTEXT IrpContext,
1404         PFFS_VCB         Vcb,
1405         ULONG            Inode,
1406         ULONG            Type);
1407
1408 __drv_mustHoldCriticalRegion
1409 NTSTATUS
1410 FFSAddEntry(
1411         IN PFFS_IRP_CONTEXT IrpContext,
1412         IN PFFS_VCB         Vcb,
1413         IN PFFS_FCB         Dcb,
1414         IN ULONG            FileType,
1415         IN ULONG            Inode,
1416         IN PUNICODE_STRING  FileName);
1417
1418 __drv_mustHoldCriticalRegion
1419 NTSTATUS
1420 FFSRemoveEntry(
1421         IN PFFS_IRP_CONTEXT IrpContext,
1422         IN PFFS_VCB         Vcb,
1423         IN PFFS_FCB         Dcb,
1424         IN ULONG            FileType,
1425         IN ULONG            Inode);
1426
1427 __drv_mustHoldCriticalRegion
1428 NTSTATUS
1429 FFSSetParentEntry(
1430         IN PFFS_IRP_CONTEXT IrpContext,
1431         IN PFFS_VCB         Vcb,
1432         IN PFFS_FCB         Dcb,
1433         IN ULONG            OldParent,
1434         IN ULONG            NewParent);
1435
1436 __drv_mustHoldCriticalRegion
1437 BOOLEAN
1438 FFSTruncateBlock(
1439         IN PFFS_IRP_CONTEXT IrpContext,
1440         IN PFFS_VCB         Vcb,
1441         IN PFFS_FCB         Fcb,
1442         IN ULONG            dwContent,
1443         IN ULONG            Index,
1444         IN ULONG            layer,
1445         OUT BOOLEAN         *bFreed);
1446
1447 BOOLEAN
1448 FFSTruncateInode(
1449         IN PFFS_IRP_CONTEXT IrpContext,
1450         IN PFFS_VCB         Vcb,
1451         IN PFFS_FCB         Fcb);
1452
1453 __drv_mustHoldCriticalRegion
1454 BOOLEAN
1455 FFSAddMcbEntry(
1456         IN PFFS_VCB Vcb,
1457         IN LONGLONG Lba,
1458         IN LONGLONG Length);
1459
1460 __drv_mustHoldCriticalRegion
1461 VOID
1462 FFSRemoveMcbEntry(
1463         IN PFFS_VCB Vcb,
1464         IN LONGLONG Lba,
1465         IN LONGLONG Length);
1466
1467 __drv_mustHoldCriticalRegion
1468 BOOLEAN
1469 FFSLookupMcbEntry(
1470         IN PFFS_VCB     Vcb,
1471         IN LONGLONG     Lba,
1472         OUT PLONGLONG   pLba,
1473         OUT PLONGLONG   pLength,
1474         OUT PLONGLONG   RunStart,
1475         OUT PLONGLONG   RunLength,
1476         OUT PULONG      Index);
1477
1478 ULONG
1479 FFSDataBlocks(
1480         PFFS_VCB Vcb,
1481         ULONG TotalBlocks);
1482
1483 ULONG
1484 FFSTotalBlocks(
1485         PFFS_VCB Vcb,
1486         ULONG DataBlocks);
1487
1488
1489 //
1490 // Fastio.c
1491 //
1492
1493 #ifdef _PREFAST_
1494 FAST_IO_CHECK_IF_POSSIBLE FFSFastIoCheckIfPossible;
1495 #endif // _PREFAST_
1496
1497 BOOLEAN NTAPI
1498 FFSFastIoCheckIfPossible(
1499         IN PFILE_OBJECT         FileObject,
1500         IN PLARGE_INTEGER       FileOffset,
1501         IN ULONG                Length,
1502         IN BOOLEAN              Wait,
1503         IN ULONG                LockKey,
1504         IN BOOLEAN              CheckForReadOperation,
1505         OUT PIO_STATUS_BLOCK    IoStatus,
1506         IN PDEVICE_OBJECT       DeviceObject);
1507
1508 #ifdef _PREFAST_
1509 FAST_IO_READ FFSFastIoRead;
1510 #endif // _PREFAST_
1511
1512 BOOLEAN NTAPI
1513 FFSFastIoRead(
1514         IN PFILE_OBJECT         FileObject,
1515         IN PLARGE_INTEGER       FileOffset,
1516         IN ULONG                Length,
1517         IN BOOLEAN              Wait,
1518         IN ULONG                LockKey,
1519         OUT PVOID               Buffer,
1520         OUT PIO_STATUS_BLOCK    IoStatus,
1521         IN PDEVICE_OBJECT       DeviceObject);
1522
1523 #ifdef _PREFAST_
1524 FAST_IO_WRITE FFSFastIoWrite;
1525 #endif // _PREFAST_
1526
1527 BOOLEAN NTAPI
1528 FFSFastIoWrite(
1529         IN PFILE_OBJECT         FileObject,
1530         IN PLARGE_INTEGER       FileOffset,
1531         IN ULONG                Length,
1532         IN BOOLEAN              Wait,
1533         IN ULONG                LockKey,
1534         OUT PVOID               Buffer,
1535         OUT PIO_STATUS_BLOCK    IoStatus,
1536         IN PDEVICE_OBJECT       DeviceObject);
1537
1538 #ifdef _PREFAST_
1539 FAST_IO_QUERY_BASIC_INFO FFSFastIoQueryBasicInfo;
1540 #endif // _PREFAST_
1541
1542 __drv_mustHoldCriticalRegion
1543 BOOLEAN NTAPI
1544 FFSFastIoQueryBasicInfo(
1545         IN PFILE_OBJECT             FileObject,
1546         IN BOOLEAN                  Wait,
1547         OUT PFILE_BASIC_INFORMATION Buffer,
1548         OUT PIO_STATUS_BLOCK        IoStatus,
1549         IN PDEVICE_OBJECT           DeviceObject);
1550
1551 #ifdef _PREFAST_
1552 FAST_IO_QUERY_STANDARD_INFO FFSFastIoQueryStandardInfo;
1553 #endif // _PREFAST_
1554
1555 __drv_mustHoldCriticalRegion
1556 BOOLEAN NTAPI
1557 FFSFastIoQueryStandardInfo(
1558         IN PFILE_OBJECT                 FileObject,
1559         IN BOOLEAN                      Wait,
1560         OUT PFILE_STANDARD_INFORMATION  Buffer,
1561         OUT PIO_STATUS_BLOCK            IoStatus,
1562         IN PDEVICE_OBJECT               DeviceObject);
1563
1564 #ifdef _PREFAST_
1565 FAST_IO_LOCK FFSFastIoLock;
1566 #endif // _PREFAST_
1567
1568 BOOLEAN NTAPI
1569 FFSFastIoLock(
1570         IN PFILE_OBJECT         FileObject,
1571         IN PLARGE_INTEGER       FileOffset,
1572         IN PLARGE_INTEGER       Length,
1573         IN PEPROCESS            Process,
1574         IN ULONG                Key,
1575         IN BOOLEAN              FailImmediately,
1576         IN BOOLEAN              ExclusiveLock,
1577         OUT PIO_STATUS_BLOCK    IoStatus,
1578         IN PDEVICE_OBJECT       DeviceObject);
1579
1580 #ifdef _PREFAST_
1581 FAST_IO_UNLOCK_SINGLE FFSFastIoUnlockSingle;
1582 #endif // _PREFAST_
1583
1584 BOOLEAN NTAPI
1585 FFSFastIoUnlockSingle(
1586         IN PFILE_OBJECT         FileObject,
1587         IN PLARGE_INTEGER       FileOffset,
1588         IN PLARGE_INTEGER       Length,
1589         IN PEPROCESS            Process,
1590         IN ULONG                Key,
1591         OUT PIO_STATUS_BLOCK    IoStatus,
1592         IN PDEVICE_OBJECT       DeviceObject);
1593
1594 #ifdef _PREFAST_
1595 FAST_IO_UNLOCK_ALL FFSFastIoUnlockAll;
1596 #endif // _PREFAST_
1597
1598 BOOLEAN NTAPI
1599 FFSFastIoUnlockAll(
1600         IN PFILE_OBJECT         FileObject,
1601         IN PEPROCESS            Process,
1602         OUT PIO_STATUS_BLOCK    IoStatus,
1603         IN PDEVICE_OBJECT       DeviceObject);
1604
1605 #ifdef _PREFAST_
1606 FAST_IO_UNLOCK_ALL_BY_KEY FFSFastIoUnlockAllByKey;
1607 #endif // _PREFAST_
1608
1609 BOOLEAN NTAPI
1610 FFSFastIoUnlockAllByKey(
1611         IN PFILE_OBJECT         FileObject,
1612 #ifndef __REACTOS__
1613         IN PEPROCESS            Process,
1614 #else
1615         IN PVOID                Process,
1616 #endif
1617         IN ULONG                Key,
1618         OUT PIO_STATUS_BLOCK    IoStatus,
1619         IN PDEVICE_OBJECT       DeviceObject);
1620
1621 #ifdef _PREFAST_
1622 FAST_IO_QUERY_NETWORK_OPEN_INFO FFSFastIoQueryNetworkOpenInfo;
1623 #endif // _PREFAST_
1624
1625 __drv_mustHoldCriticalRegion
1626 BOOLEAN NTAPI
1627 FFSFastIoQueryNetworkOpenInfo(
1628         IN PFILE_OBJECT                     FileObject,
1629         IN BOOLEAN                          Wait,
1630         OUT PFILE_NETWORK_OPEN_INFORMATION  Buffer,
1631         OUT PIO_STATUS_BLOCK                IoStatus,
1632         IN PDEVICE_OBJECT                   DeviceObject);
1633
1634 //
1635 // FileInfo.c
1636 //
1637
1638 __drv_mustHoldCriticalRegion
1639 NTSTATUS
1640 FFSQueryInformation(
1641         IN PFFS_IRP_CONTEXT IrpContext);
1642
1643 __drv_mustHoldCriticalRegion
1644 NTSTATUS
1645 FFSSetInformation(
1646         IN PFFS_IRP_CONTEXT IrpContext);
1647
1648 BOOLEAN
1649 FFSExpandFile(
1650         PFFS_IRP_CONTEXT IrpContext,
1651         PFFS_VCB         Vcb,
1652         PFFS_FCB         Fcb,
1653         PLARGE_INTEGER   AllocationSize);
1654
1655 BOOLEAN
1656 FFSTruncateFile(
1657         PFFS_IRP_CONTEXT IrpContext,
1658         PFFS_VCB         Vcb,
1659         PFFS_FCB         Fcb,
1660         PLARGE_INTEGER   AllocationSize);
1661
1662 NTSTATUS
1663 FFSSetDispositionInfo(
1664         PFFS_IRP_CONTEXT IrpContext,
1665         PFFS_VCB         Vcb,
1666         PFFS_FCB         Fcb,
1667         BOOLEAN          bDelete);
1668
1669 __drv_mustHoldCriticalRegion
1670 NTSTATUS
1671 FFSSetRenameInfo(
1672         PFFS_IRP_CONTEXT IrpContext,
1673         PFFS_VCB         Vcb,
1674         PFFS_FCB         Fcb);
1675
1676 __drv_mustHoldCriticalRegion
1677 BOOLEAN
1678 FFSDeleteFile(
1679         PFFS_IRP_CONTEXT IrpContext,
1680         PFFS_VCB         Vcb,
1681         PFFS_FCB         Fcb);
1682
1683
1684 //
1685 // Flush.c
1686 //
1687
1688 __drv_mustHoldCriticalRegion
1689 NTSTATUS
1690 FFSFlushFiles(
1691         IN PFFS_VCB Vcb,
1692         BOOLEAN     bShutDown);
1693
1694 __drv_mustHoldCriticalRegion
1695 NTSTATUS
1696 FFSFlushVolume(
1697         IN PFFS_VCB Vcb,
1698         BOOLEAN     bShutDown);
1699
1700 NTSTATUS
1701 FFSFlushFile(
1702         IN PFFS_FCB Fcb);
1703
1704 __drv_mustHoldCriticalRegion
1705 NTSTATUS
1706 FFSFlush(
1707         IN PFFS_IRP_CONTEXT IrpContext);
1708
1709
1710 //
1711 // Fsctl.c
1712 //
1713
1714 VOID
1715 FFSSetVpbFlag(
1716         IN PVPB     Vpb,
1717         IN USHORT   Flag);
1718
1719 VOID
1720 FFSClearVpbFlag(
1721         IN PVPB     Vpb,
1722         IN USHORT   Flag);
1723
1724 NTSTATUS
1725 FFSGetPartition(
1726         IN PDEVICE_OBJECT DeviceObject,
1727         OUT ULONGLONG     *StartOffset);
1728
1729 NTSTATUS
1730 FFSLoadDiskLabel(
1731         PDEVICE_OBJECT  DeviceObject,
1732         IN PFFS_VCB     Vcb);
1733
1734 __drv_mustHoldCriticalRegion
1735 BOOLEAN
1736 FFSCheckDismount(
1737         IN PFFS_IRP_CONTEXT  IrpContext,
1738         IN PFFS_VCB          Vcb,
1739         IN BOOLEAN           bForce);
1740
1741 __drv_mustHoldCriticalRegion
1742 NTSTATUS
1743 FFSPurgeVolume(
1744         IN PFFS_VCB Vcb,
1745         IN BOOLEAN  FlushBeforePurge);
1746
1747 __drv_mustHoldCriticalRegion
1748 NTSTATUS
1749 FFSPurgeFile(
1750         IN PFFS_FCB Fcb,
1751         IN BOOLEAN  FlushBeforePurge);
1752
1753 BOOLEAN
1754 FFSIsHandleCountZero(
1755         IN PFFS_VCB Vcb);
1756
1757 NTSTATUS
1758 FFSLockVcb(
1759         IN PFFS_VCB     Vcb,
1760         IN PFILE_OBJECT FileObject);
1761
1762 __drv_mustHoldCriticalRegion
1763 NTSTATUS
1764 FFSLockVolume(
1765         IN PFFS_IRP_CONTEXT IrpContext);
1766
1767 NTSTATUS
1768 FFSUnlockVcb(
1769         IN PFFS_VCB     Vcb,
1770         IN PFILE_OBJECT FileObject);
1771
1772 __drv_mustHoldCriticalRegion
1773 NTSTATUS
1774 FFSUnlockVolume(
1775         IN PFFS_IRP_CONTEXT IrpContext);
1776
1777 __drv_mustHoldCriticalRegion
1778 NTSTATUS
1779 FFSAllowExtendedDasdIo(
1780         IN PFFS_IRP_CONTEXT IrpContext);
1781
1782 __drv_mustHoldCriticalRegion
1783 NTSTATUS
1784 FFSUserFsRequest(
1785         IN PFFS_IRP_CONTEXT IrpContext);
1786
1787 __drv_mustHoldCriticalRegion
1788 NTSTATUS
1789 FFSMountVolume(
1790         IN PFFS_IRP_CONTEXT IrpContext);
1791
1792 __drv_mustHoldCriticalRegion
1793 NTSTATUS
1794 FFSVerifyVolume(
1795         IN PFFS_IRP_CONTEXT IrpContext);
1796
1797 __drv_mustHoldCriticalRegion
1798 NTSTATUS
1799 FFSIsVolumeMounted(
1800         IN PFFS_IRP_CONTEXT IrpContext);
1801
1802 __drv_mustHoldCriticalRegion
1803 NTSTATUS
1804 FFSDismountVolume(
1805         IN PFFS_IRP_CONTEXT IrpContext);
1806
1807 __drv_mustHoldCriticalRegion
1808 NTSTATUS
1809 FFSSelectBSDPartition(
1810         IN PFFS_IRP_CONTEXT IrpContext);
1811
1812 __drv_mustHoldCriticalRegion
1813 NTSTATUS
1814 FFSFileSystemControl(
1815         IN PFFS_IRP_CONTEXT IrpContext);
1816
1817
1818 //
1819 // Init.c
1820 //
1821
1822 BOOLEAN
1823 FFSQueryParameters(
1824         IN PUNICODE_STRING  RegistryPath);
1825
1826 #ifdef _PREFAST_
1827 DRIVER_INITIALIZE DriverEntry;
1828 #endif // _PREFAST_
1829
1830 #ifdef _PREFAST_
1831 DRIVER_UNLOAD DriverUnload;
1832 #endif // _PREFAST_
1833
1834 VOID NTAPI
1835 DriverUnload(
1836         IN PDRIVER_OBJECT DriverObject);
1837
1838
1839 //
1840 // Lock.c
1841 //
1842
1843 __drv_mustHoldCriticalRegion
1844 NTSTATUS
1845 FFSLockControl(
1846         IN PFFS_IRP_CONTEXT IrpContext);
1847
1848
1849 //
1850 // Memory.c
1851 //
1852
1853 __drv_mustHoldCriticalRegion
1854 PFFS_IRP_CONTEXT
1855 FFSAllocateIrpContext(
1856         IN PDEVICE_OBJECT   DeviceObject,
1857         IN PIRP             Irp);
1858
1859 __drv_mustHoldCriticalRegion
1860 VOID
1861 FFSFreeIrpContext(
1862         IN PFFS_IRP_CONTEXT IrpContext);
1863
1864 __drv_mustHoldCriticalRegion
1865 PFFS_FCB
1866 FFSv1AllocateFcb(
1867         IN PFFS_VCB           Vcb,
1868         IN PFFS_MCB           FFSMcb,
1869         IN PFFSv1_INODE       dinode1);
1870
1871 __drv_mustHoldCriticalRegion
1872 PFFS_FCB
1873 FFSv2AllocateFcb(
1874         IN PFFS_VCB           Vcb,
1875         IN PFFS_MCB           FFSMcb,
1876         IN PFFSv2_INODE       dinode2);
1877
1878 __drv_mustHoldCriticalRegion
1879 VOID
1880 FFSFreeFcb(
1881         IN PFFS_FCB Fcb);
1882
1883 __drv_mustHoldCriticalRegion
1884 PFFS_CCB
1885 FFSAllocateCcb(
1886         VOID);
1887
1888 __drv_mustHoldCriticalRegion
1889 VOID
1890 FFSFreeMcb(
1891         IN PFFS_MCB Mcb);
1892
1893 __drv_mustHoldCriticalRegion
1894 PFFS_FCB
1895 FFSCreateFcbFromMcb(
1896         PFFS_VCB Vcb,
1897         PFFS_MCB Mcb);
1898
1899 __drv_mustHoldCriticalRegion
1900 VOID
1901 FFSFreeCcb(
1902         IN PFFS_CCB Ccb);
1903
1904 PFFS_MCB
1905 FFSAllocateMcb(
1906         PFFS_VCB        Vcb,
1907         PUNICODE_STRING FileName,
1908         ULONG           FileAttr);
1909
1910 PFFS_MCB
1911 FFSSearchMcbTree(
1912         PFFS_VCB Vcb,
1913         PFFS_MCB FFSMcb,
1914         ULONG    Inode);
1915
1916 PFFS_MCB
1917 FFSSearchMcb(
1918         PFFS_VCB        Vcb,
1919         PFFS_MCB        Parent,
1920         PUNICODE_STRING FileName);
1921
1922 BOOLEAN
1923 FFSGetFullFileName(
1924         PFFS_MCB        Mcb,
1925         PUNICODE_STRING FileName);
1926
1927 VOID
1928 FFSRefreshMcb(
1929         PFFS_VCB Vcb, PFFS_MCB Mcb);
1930
1931 VOID
1932 FFSAddMcbNode(
1933         PFFS_VCB Vcb,
1934         PFFS_MCB Parent,
1935         PFFS_MCB Child);
1936
1937 BOOLEAN
1938 FFSDeleteMcbNode(
1939         PFFS_VCB Vcb,
1940         PFFS_MCB McbTree,
1941         PFFS_MCB FFSMcb);
1942
1943 __drv_mustHoldCriticalRegion
1944 VOID
1945 FFSFreeMcbTree(
1946         PFFS_MCB McbTree);
1947
1948 BOOLEAN
1949 FFSCheckSetBlock(
1950         PFFS_IRP_CONTEXT IrpContext,
1951         PFFS_VCB         Vcb,
1952         ULONG            Block);
1953
1954 BOOLEAN
1955 FFSCheckBitmapConsistency(
1956         PFFS_IRP_CONTEXT IrpContext,
1957         PFFS_VCB         Vcb);
1958
1959 VOID
1960 FFSInsertVcb(
1961         PFFS_VCB Vcb);
1962
1963 VOID
1964 FFSRemoveVcb(
1965         PFFS_VCB Vcb);
1966
1967 __drv_mustHoldCriticalRegion
1968 NTSTATUS
1969 FFSInitializeVcb(
1970         IN PFFS_IRP_CONTEXT IrpContext,
1971         IN PFFS_VCB         Vcb,
1972         IN PFFS_SUPER_BLOCK FFSSb,
1973         IN PDEVICE_OBJECT   TargetDevice,
1974         IN PDEVICE_OBJECT   VolumeDevice,
1975         IN PVPB             Vpb);
1976
1977 __drv_mustHoldCriticalRegion
1978 VOID
1979 FFSFreeVcb(
1980         IN PFFS_VCB Vcb);
1981
1982 VOID
1983 FFSRepinBcb(
1984         IN PFFS_IRP_CONTEXT IrpContext,
1985         IN PBCB             Bcb);
1986
1987 VOID
1988 FFSUnpinRepinnedBcbs(
1989         IN PFFS_IRP_CONTEXT IrpContext);
1990
1991
1992 __drv_mustHoldCriticalRegion
1993 NTSTATUS
1994 FFSCompleteIrpContext(
1995         IN PFFS_IRP_CONTEXT IrpContext,
1996         IN NTSTATUS         Status);
1997
1998 VOID
1999 FFSSyncUninitializeCacheMap(
2000         IN PFILE_OBJECT FileObject);
2001
2002
2003 //
2004 // Misc.c
2005 //
2006
2007 ULONG
2008 FFSLog2(
2009         ULONG Value);
2010
2011 LARGE_INTEGER
2012 FFSSysTime(
2013         IN ULONG i_time);
2014
2015 ULONG
2016 FFSInodeTime(
2017         IN LARGE_INTEGER SysTime);
2018
2019 NTSTATUS
2020 FFSOEMToUnicode(
2021         IN OUT PUNICODE_STRING Unicode,
2022         IN     POEM_STRING     Oem);
2023
2024 NTSTATUS
2025 FFSUnicodeToOEM(
2026         IN OUT POEM_STRING Oem,
2027         IN PUNICODE_STRING Unicode);
2028
2029
2030 //
2031 // Pnp.c
2032 //
2033
2034 __drv_mustHoldCriticalRegion
2035 NTSTATUS
2036 FFSPnp(
2037         IN PFFS_IRP_CONTEXT IrpContext);
2038
2039 __drv_mustHoldCriticalRegion
2040 NTSTATUS
2041 FFSPnpQueryRemove(
2042         PFFS_IRP_CONTEXT IrpContext,
2043         PFFS_VCB         Vcb);
2044
2045 __drv_mustHoldCriticalRegion
2046 NTSTATUS
2047 FFSPnpRemove(
2048         PFFS_IRP_CONTEXT IrpContext,
2049         PFFS_VCB         Vcb);
2050
2051 __drv_mustHoldCriticalRegion
2052 NTSTATUS
2053 FFSPnpCancelRemove(
2054         PFFS_IRP_CONTEXT IrpContext,
2055         PFFS_VCB         Vcb);
2056
2057 __drv_mustHoldCriticalRegion
2058 NTSTATUS
2059 FFSPnpSurpriseRemove(
2060         PFFS_IRP_CONTEXT IrpContext,
2061         PFFS_VCB         Vcb);
2062
2063
2064 //
2065 // Read.c
2066 //
2067
2068 BOOLEAN
2069 FFSCopyRead(
2070         IN PFILE_OBJECT       FileObject,
2071         IN PLARGE_INTEGER     FileOffset,
2072         IN ULONG              Length,
2073         IN BOOLEAN            Wait,
2074         OUT PVOID             Buffer,
2075         OUT PIO_STATUS_BLOCK  IoStatus);
2076
2077 NTSTATUS
2078 FFSv1ReadInode(
2079         IN PFFS_IRP_CONTEXT     IrpContext,
2080         IN PFFS_VCB             Vcb,
2081         IN PFFSv1_INODE         dinode1,
2082         IN ULONGLONG            offset,
2083         IN PVOID                Buffer,
2084         IN ULONG                size,
2085         OUT PULONG              dwRet);
2086
2087 NTSTATUS
2088 FFSv2ReadInode(
2089         IN PFFS_IRP_CONTEXT     IrpContext,
2090         IN PFFS_VCB             Vcb,
2091         IN PFFSv2_INODE         dinode2,
2092         IN ULONGLONG            offset,
2093         IN PVOID                Buffer,
2094         IN ULONG                size,
2095         OUT PULONG              dwRet);
2096
2097 __drv_mustHoldCriticalRegion
2098 NTSTATUS
2099 FFSRead(
2100         IN PFFS_IRP_CONTEXT IrpContext);
2101
2102
2103 //
2104 // Shutdown.c
2105 //
2106
2107 __drv_mustHoldCriticalRegion
2108 NTSTATUS
2109 FFSShutDown(
2110         IN PFFS_IRP_CONTEXT IrpContext);
2111
2112
2113 //
2114 // Volinfo.c
2115 //
2116
2117 __drv_mustHoldCriticalRegion
2118 NTSTATUS
2119 FFSQueryVolumeInformation(
2120         IN PFFS_IRP_CONTEXT IrpContext);
2121
2122 __drv_mustHoldCriticalRegion
2123 NTSTATUS
2124 FFSSetVolumeInformation(
2125         IN PFFS_IRP_CONTEXT IrpContext);
2126
2127
2128 //
2129 // Write.c
2130 //
2131
2132 NTSTATUS
2133 FFSv1WriteInode(
2134         IN PFFS_IRP_CONTEXT     IrpContext,
2135         IN PFFS_VCB             Vcb,
2136         IN PFFSv1_INODE         dinode1,
2137         IN ULONGLONG            offset,
2138         IN PVOID                Buffer,
2139         IN ULONG                size,
2140         IN BOOLEAN              bWriteToDisk,
2141         OUT PULONG              dwRet);
2142
2143 NTSTATUS
2144 FFSv2WriteInode(
2145         IN PFFS_IRP_CONTEXT     IrpContext,
2146         IN PFFS_VCB             Vcb,
2147         IN PFFSv2_INODE         dinode2,
2148         IN ULONGLONG            offset,
2149         IN PVOID                Buffer,
2150         IN ULONG                size,
2151         IN BOOLEAN              bWriteToDisk,
2152         OUT PULONG              dwRet);
2153
2154 VOID
2155 FFSStartFloppyFlushDpc(
2156         PFFS_VCB     Vcb,
2157         PFFS_FCB     Fcb,
2158         PFILE_OBJECT FileObject);
2159
2160 BOOLEAN
2161 FFSZeroHoles(
2162         IN PFFS_IRP_CONTEXT IrpContext,
2163         IN PFFS_VCB         Vcb,
2164         IN PFILE_OBJECT     FileObject,
2165         IN LONGLONG         Offset,
2166         IN LONGLONG         Count);
2167
2168 __drv_mustHoldCriticalRegion
2169 NTSTATUS
2170 FFSWrite(
2171         IN PFFS_IRP_CONTEXT IrpContext);
2172
2173 NTSTATUS
2174 DeviceControl(
2175         IN PDEVICE_OBJECT pDeviceObject,
2176         IN PIRP pIrp);
2177
2178 #endif /* _FFS_HEADER_ */