drivers/filesystems/ntfs/ntfs.h

   1 #ifndef NTFS_H
   2 #define NTFS_H
   3
   4 #include <ntifs.h>
   5 #include <pseh/pseh2.h>
   6
   7 #ifdef __GNUC__
   8 #define INIT_SECTION __attribute__((section ("INIT")))
   9 #else
  10 #define INIT_SECTION /* Done via alloc_text for MSC */
  11 #endif
  12
  13 #define CACHEPAGESIZE(pDeviceExt) \
  14         ((pDeviceExt)->NtfsInfo.UCHARsPerCluster > PAGE_SIZE ? \
  15          (pDeviceExt)->NtfsInfo.UCHARsPerCluster : PAGE_SIZE)
  16
  17 #define TAG_NTFS 'SFTN'
  18
  19 #define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
  20 #define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
  21
  22 #define DEVICE_NAME L"\\Ntfs"
  23
  24 #include <pshpack1.h>
  25 typedef struct _BIOS_PARAMETERS_BLOCK
  26 {
  27     USHORT    BytesPerSector;                   // 0x0B
  28     UCHAR     SectorsPerCluster;                // 0x0D
  29     UCHAR     Unused0[7];                               // 0x0E, checked when volume is mounted
  30     UCHAR     MediaId;                          // 0x15
  31     UCHAR     Unused1[2];                               // 0x16
  32     USHORT    SectorsPerTrack;          // 0x18
  33     USHORT    Heads;                                    // 0x1A
  34     UCHAR     Unused2[4];                               // 0x1C
  35     UCHAR     Unused3[4];                               // 0x20, checked when volume is mounted
  36 } BIOS_PARAMETERS_BLOCK, *PBIOS_PARAMETERS_BLOCK;
  37
  38 typedef struct _EXTENDED_BIOS_PARAMETERS_BLOCK
  39 {
  40     USHORT    Unknown[2];                               // 0x24, always 80 00 80 00
  41     ULONGLONG SectorCount;                      // 0x28
  42     ULONGLONG MftLocation;                      // 0x30
  43     ULONGLONG MftMirrLocation;          // 0x38
  44     CHAR      ClustersPerMftRecord;     // 0x40
  45     UCHAR     Unused4[3];                               // 0x41
  46     CHAR      ClustersPerIndexRecord; // 0x44
  47     UCHAR     Unused5[3];                               // 0x45
  48     ULONGLONG SerialNumber;                     // 0x48
  49     UCHAR     Checksum[4];                      // 0x50
  50 } EXTENDED_BIOS_PARAMETERS_BLOCK, *PEXTENDED_BIOS_PARAMETERS_BLOCK;
  51
  52 typedef struct _BOOT_SECTOR
  53 {
  54     UCHAR     Jump[3];                          // 0x00
  55     UCHAR     OEMID[8];                         // 0x03
  56     BIOS_PARAMETERS_BLOCK BPB;
  57     EXTENDED_BIOS_PARAMETERS_BLOCK EBPB;
  58     UCHAR     BootStrap[426];                   // 0x54
  59     USHORT    EndSector;                                // 0x1FE
  60 } BOOT_SECTOR, *PBOOT_SECTOR;
  61 #include <poppack.h>
  62
  63 //typedef struct _BootSector BootSector;
  64
  65 typedef struct _NTFS_INFO
  66 {
  67     ULONG BytesPerSector;
  68     ULONG SectorsPerCluster;
  69     ULONG BytesPerCluster;
  70     ULONGLONG SectorCount;
  71     ULONGLONG ClusterCount;
  72     ULARGE_INTEGER MftStart;
  73     ULARGE_INTEGER MftMirrStart;
  74     ULONG BytesPerFileRecord;
  75     ULONG BytesPerIndexRecord;
  76
  77     ULONGLONG SerialNumber;
  78     USHORT VolumeLabelLength;
  79     WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH];
  80     UCHAR MajorVersion;
  81     UCHAR MinorVersion;
  82     USHORT Flags;
  83
  84     ULONG MftZoneReservation;
  85 } NTFS_INFO, *PNTFS_INFO;
  86
  87 #define NTFS_TYPE_CCB         '20SF'
  88 #define NTFS_TYPE_FCB         '30SF'
  89 #define NTFS_TYPE_VCB         '50SF'
  90 #define NTFS_TYPE_IRP_CONTEXT '60SF'
  91 #define NTFS_TYPE_GLOBAL_DATA '70SF'
  92
  93 typedef struct
  94 {
  95     ULONG Type;
  96     ULONG Size;
  97 } NTFSIDENTIFIER, *PNTFSIDENTIFIER;
  98
  99 typedef struct
 100 {
 101     NTFSIDENTIFIER Identifier;
 102
 103     ERESOURCE DirResource;
 104 //    ERESOURCE FatResource;
 105
 106     KSPIN_LOCK FcbListLock;
 107     LIST_ENTRY FcbListHead;
 108
 109     PVPB Vpb;
 110     PDEVICE_OBJECT StorageDevice;
 111     PFILE_OBJECT StreamFileObject;
 112
 113     struct _NTFS_ATTR_CONTEXT* MFTContext;
 114     struct _FILE_RECORD_HEADER* MasterFileTable;
 115     struct _FCB *VolumeFcb;
 116
 117     NTFS_INFO NtfsInfo;
 118
 119     NPAGED_LOOKASIDE_LIST FileRecLookasideList;
 120
 121     ULONG MftDataOffset;
 122     ULONG Flags;
 123     ULONG OpenHandleCount;
 124
 125 } DEVICE_EXTENSION, *PDEVICE_EXTENSION, NTFS_VCB, *PNTFS_VCB;
 126
 127 #define VCB_VOLUME_LOCKED       0x0001
 128
 129 typedef struct
 130 {
 131     NTFSIDENTIFIER Identifier;
 132     LIST_ENTRY     NextCCB;
 133     PFILE_OBJECT   PtrFileObject;
 134     LARGE_INTEGER  CurrentByteOffset;
 135     /* for DirectoryControl */
 136     ULONG Entry;
 137     /* for DirectoryControl */
 138     PWCHAR DirectorySearchPattern;
 139     ULONG LastCluster;
 140     ULONG LastOffset;
 141 } NTFS_CCB, *PNTFS_CCB;
 142
 143 #define TAG_CCB 'BCCI'
 144 #define TAG_FCB 'BCFI'
 145
 146 typedef struct
 147 {
 148     NTFSIDENTIFIER Identifier;
 149     ERESOURCE Resource;
 150     PDRIVER_OBJECT DriverObject;
 151     PDEVICE_OBJECT DeviceObject;
 152     CACHE_MANAGER_CALLBACKS CacheMgrCallbacks;
 153     ULONG Flags;
 154     FAST_IO_DISPATCH FastIoDispatch;
 155     NPAGED_LOOKASIDE_LIST IrpContextLookasideList;
 156     NPAGED_LOOKASIDE_LIST FcbLookasideList;
 157     NPAGED_LOOKASIDE_LIST AttrCtxtLookasideList;
 158     BOOLEAN EnableWriteSupport;
 159 } NTFS_GLOBAL_DATA, *PNTFS_GLOBAL_DATA;
 160
 161
 162 typedef enum
 163 {
 164     AttributeStandardInformation = 0x10,
 165     AttributeAttributeList = 0x20,
 166     AttributeFileName = 0x30,
 167     AttributeObjectId = 0x40,
 168     AttributeSecurityDescriptor = 0x50,
 169     AttributeVolumeName = 0x60,
 170     AttributeVolumeInformation = 0x70,
 171     AttributeData = 0x80,
 172     AttributeIndexRoot = 0x90,
 173     AttributeIndexAllocation = 0xA0,
 174     AttributeBitmap = 0xB0,
 175     AttributeReparsePoint = 0xC0,
 176     AttributeEAInformation = 0xD0,
 177     AttributeEA = 0xE0,
 178     AttributePropertySet = 0xF0,
 179     AttributeLoggedUtilityStream = 0x100,
 180     AttributeEnd = 0xFFFFFFFF
 181 } ATTRIBUTE_TYPE, *PATTRIBUTE_TYPE;
 182
 183 // FILE_RECORD_END seems to follow AttributeEnd in every file record starting with $Quota.
 184 // No clue what data is being represented here.
 185 #define FILE_RECORD_END              0x11477982
 186
 187 #define NTFS_FILE_MFT                0
 188 #define NTFS_FILE_MFTMIRR            1
 189 #define NTFS_FILE_LOGFILE            2
 190 #define NTFS_FILE_VOLUME            3
 191 #define NTFS_FILE_ATTRDEF            4
 192 #define NTFS_FILE_ROOT                5
 193 #define NTFS_FILE_BITMAP            6
 194 #define NTFS_FILE_BOOT                7
 195 #define NTFS_FILE_BADCLUS            8
 196 #define NTFS_FILE_QUOTA                9
 197 #define NTFS_FILE_UPCASE            10
 198 #define NTFS_FILE_EXTEND            11
 199 #define NTFS_FILE_FIRST_USER_FILE   16
 200
 201 #define NTFS_MFT_MASK 0x0000FFFFFFFFFFFFULL
 202
 203 #define COLLATION_BINARY              0x00
 204 #define COLLATION_FILE_NAME           0x01
 205 #define COLLATION_UNICODE_STRING      0x02
 206 #define COLLATION_NTOFS_ULONG         0x10
 207 #define COLLATION_NTOFS_SID           0x11
 208 #define COLLATION_NTOFS_SECURITY_HASH 0x12
 209 #define COLLATION_NTOFS_ULONGS        0x13
 210
 211 #define INDEX_ROOT_SMALL 0x0
 212 #define INDEX_ROOT_LARGE 0x1
 213
 214 #define INDEX_NODE_SMALL 0x0
 215 #define INDEX_NODE_LARGE 0x1
 216
 217 #define NTFS_INDEX_ENTRY_NODE            1
 218 #define NTFS_INDEX_ENTRY_END            2
 219
 220 #define NTFS_FILE_NAME_POSIX            0
 221 #define NTFS_FILE_NAME_WIN32            1
 222 #define NTFS_FILE_NAME_DOS            2
 223 #define NTFS_FILE_NAME_WIN32_AND_DOS        3
 224
 225 #define NTFS_FILE_TYPE_READ_ONLY  0x1
 226 #define NTFS_FILE_TYPE_HIDDEN     0x2
 227 #define NTFS_FILE_TYPE_SYSTEM     0x4
 228 #define NTFS_FILE_TYPE_ARCHIVE    0x20
 229 #define NTFS_FILE_TYPE_REPARSE    0x400
 230 #define NTFS_FILE_TYPE_COMPRESSED 0x800
 231 #define NTFS_FILE_TYPE_DIRECTORY  0x10000000
 232
 233 /* Indexed Flag in Resident attributes - still somewhat speculative */
 234 #define RA_INDEXED    0x01
 235
 236 typedef struct
 237 {
 238     ULONG Type;             /* Magic number 'FILE' */
 239     USHORT UsaOffset;       /* Offset to the update sequence */
 240     USHORT UsaCount;        /* Size in words of Update Sequence Number & Array (S) */
 241     ULONGLONG Lsn;          /* $LogFile Sequence Number (LSN) */
 242 } NTFS_RECORD_HEADER, *PNTFS_RECORD_HEADER;
 243
 244 /* NTFS_RECORD_HEADER.Type */
 245 #define NRH_FILE_TYPE  0x454C4946  /* 'FILE' */
 246 #define NRH_INDX_TYPE  0x58444E49  /* 'INDX' */
 247
 248
 249 typedef struct _FILE_RECORD_HEADER
 250 {
 251     NTFS_RECORD_HEADER Ntfs;
 252     USHORT SequenceNumber;        /* Sequence number */
 253     USHORT LinkCount;             /* Hard link count */
 254     USHORT AttributeOffset;       /* Offset to the first Attribute */
 255     USHORT Flags;                 /* Flags */
 256     ULONG BytesInUse;             /* Real size of the FILE record */
 257     ULONG BytesAllocated;         /* Allocated size of the FILE record */
 258     ULONGLONG BaseFileRecord;     /* File reference to the base FILE record */
 259     USHORT NextAttributeNumber;   /* Next Attribute Id */
 260     USHORT Padding;               /* Align to 4 UCHAR boundary (XP) */
 261     ULONG MFTRecordNumber;        /* Number of this MFT Record (XP) */
 262 } FILE_RECORD_HEADER, *PFILE_RECORD_HEADER;
 263
 264 /* Flags in FILE_RECORD_HEADER */
 265
 266 #define FRH_IN_USE    0x0001    /* Record is in use */
 267 #define FRH_DIRECTORY 0x0002    /* Record is a directory */
 268 #define FRH_UNKNOWN1  0x0004    /* Don't know */
 269 #define FRH_UNKNOWN2  0x0008    /* Don't know */
 270
 271 typedef struct
 272 {
 273     ULONG        Type;
 274     ULONG        Length;
 275     UCHAR        IsNonResident;
 276     UCHAR        NameLength;
 277     USHORT        NameOffset;
 278     USHORT        Flags;
 279     USHORT        Instance;
 280     union
 281     {
 282         // Resident attributes
 283         struct
 284         {
 285             ULONG        ValueLength;
 286             USHORT        ValueOffset;
 287             UCHAR        Flags;
 288             UCHAR        Reserved;
 289         } Resident;
 290         // Non-resident attributes
 291         struct
 292         {
 293             ULONGLONG        LowestVCN;
 294             ULONGLONG        HighestVCN;
 295             USHORT        MappingPairsOffset;
 296             USHORT        CompressionUnit;
 297             UCHAR        Reserved[4];
 298             LONGLONG        AllocatedSize;
 299             LONGLONG        DataSize;
 300             LONGLONG        InitializedSize;
 301             LONGLONG        CompressedSize;
 302         } NonResident;
 303     };
 304 } NTFS_ATTR_RECORD, *PNTFS_ATTR_RECORD;
 305
 306 // The beginning and length of an attribute record are always aligned to an 8-byte boundary,
 307 // relative to the beginning of the file record.
 308 #define ATTR_RECORD_ALIGNMENT 8
 309
 310 // Data runs are aligned to a 4-byte boundary, relative to the start of the attribute record
 311 #define DATA_RUN_ALIGNMENT  4
 312
 313 // Value offset is aligned to a 4-byte boundary, relative to the start of the attribute record
 314 #define VALUE_OFFSET_ALIGNMENT  4
 315
 316 typedef struct
 317 {
 318     ULONGLONG CreationTime;
 319     ULONGLONG ChangeTime;
 320     ULONGLONG LastWriteTime;
 321     ULONGLONG LastAccessTime;
 322     ULONG FileAttribute;
 323     ULONG AlignmentOrReserved[3];
 324 #if 0
 325     ULONG QuotaId;
 326     ULONG SecurityId;
 327     ULONGLONG QuotaCharge;
 328     USN Usn;
 329 #endif
 330 } STANDARD_INFORMATION, *PSTANDARD_INFORMATION;
 331
 332
 333 typedef struct
 334 {
 335     ATTRIBUTE_TYPE AttributeType;
 336     USHORT Length;
 337     UCHAR NameLength;
 338     UCHAR NameOffset;
 339     ULONGLONG StartVcn; // LowVcn
 340     ULONGLONG FileReferenceNumber;
 341     USHORT AttributeNumber;
 342     USHORT AlignmentOrReserved[3];
 343 } ATTRIBUTE_LIST, *PATTRIBUTE_LIST;
 344
 345
 346 typedef struct
 347 {
 348     ULONGLONG DirectoryFileReferenceNumber;
 349     ULONGLONG CreationTime;
 350     ULONGLONG ChangeTime;
 351     ULONGLONG LastWriteTime;
 352     ULONGLONG LastAccessTime;
 353     ULONGLONG AllocatedSize;
 354     ULONGLONG DataSize;
 355     ULONG FileAttributes;
 356     union
 357     {
 358         struct
 359         {
 360             USHORT PackedEaSize;
 361             USHORT AlignmentOrReserved;
 362         } EaInfo;
 363         ULONG ReparseTag;
 364     } Extended;
 365     UCHAR NameLength;
 366     UCHAR NameType;
 367     WCHAR Name[1];
 368 } FILENAME_ATTRIBUTE, *PFILENAME_ATTRIBUTE;
 369
 370 typedef struct
 371 {
 372     ULONG FirstEntryOffset;
 373     ULONG TotalSizeOfEntries;
 374     ULONG AllocatedSize;
 375     UCHAR Flags;
 376     UCHAR Padding[3];
 377 } INDEX_HEADER_ATTRIBUTE, *PINDEX_HEADER_ATTRIBUTE;
 378
 379 typedef struct
 380 {
 381     ULONG AttributeType;
 382     ULONG CollationRule;
 383     ULONG SizeOfEntry;
 384     UCHAR ClustersPerIndexRecord;
 385     UCHAR Padding[3];
 386     INDEX_HEADER_ATTRIBUTE Header;
 387 } INDEX_ROOT_ATTRIBUTE, *PINDEX_ROOT_ATTRIBUTE;
 388
 389 typedef struct
 390 {
 391     NTFS_RECORD_HEADER Ntfs;
 392     ULONGLONG VCN;
 393     INDEX_HEADER_ATTRIBUTE Header;
 394 } INDEX_BUFFER, *PINDEX_BUFFER;
 395
 396 typedef struct
 397 {
 398     union
 399     {
 400         struct
 401         {
 402             ULONGLONG    IndexedFile;
 403         } Directory;
 404         struct
 405         {
 406             USHORT    DataOffset;
 407             USHORT    DataLength;
 408             ULONG    Reserved;
 409         } ViewIndex;
 410     } Data;
 411     USHORT            Length;
 412     USHORT            KeyLength;
 413     USHORT            Flags;
 414     USHORT            Reserved;
 415     FILENAME_ATTRIBUTE    FileName;
 416 } INDEX_ENTRY_ATTRIBUTE, *PINDEX_ENTRY_ATTRIBUTE;
 417
 418 struct _B_TREE_FILENAME_NODE;
 419 typedef struct _B_TREE_FILENAME_NODE B_TREE_FILENAME_NODE;
 420
 421 // Keys are arranged in nodes as an ordered, linked list
 422 typedef struct _B_TREE_KEY
 423 {
 424     struct _B_TREE_KEY *NextKey;
 425     B_TREE_FILENAME_NODE *LesserChild;  // Child-Node. All the keys in this node will be sorted before IndexEntry
 426     PINDEX_ENTRY_ATTRIBUTE IndexEntry;  // must be last member for FIELD_OFFSET
 427 }B_TREE_KEY, *PB_TREE_KEY;
 428
 429 // Every Node is just an ordered list of keys.
 430 // Sub-nodes can be found attached to a key (if they exist).
 431 // A key's sub-node precedes that key in the ordered list.
 432 typedef struct _B_TREE_FILENAME_NODE
 433 {
 434     ULONG KeyCount;
 435     BOOLEAN HasValidVCN;
 436     BOOLEAN DiskNeedsUpdating;
 437     ULONGLONG VCN;
 438     PB_TREE_KEY FirstKey;
 439 } B_TREE_FILENAME_NODE, *PB_TREE_FILENAME_NODE;
 440
 441 typedef struct
 442 {
 443     PB_TREE_FILENAME_NODE RootNode;
 444 } B_TREE, *PB_TREE;
 445
 446 typedef struct
 447 {
 448     ULONGLONG Unknown1;
 449     UCHAR MajorVersion;
 450     UCHAR MinorVersion;
 451     USHORT Flags;
 452     ULONG Unknown2;
 453 } VOLINFO_ATTRIBUTE, *PVOLINFO_ATTRIBUTE;
 454
 455 typedef struct {
 456     ULONG ReparseTag;
 457     USHORT DataLength;
 458     USHORT Reserved;
 459     UCHAR Data[1];
 460 } REPARSE_POINT_ATTRIBUTE, *PREPARSE_POINT_ATTRIBUTE;
 461
 462 #define IRPCONTEXT_CANWAIT 0x1
 463 #define IRPCONTEXT_COMPLETE 0x2
 464 #define IRPCONTEXT_QUEUE 0x4
 465
 466 typedef struct
 467 {
 468     NTFSIDENTIFIER Identifier;
 469     ULONG Flags;
 470     PIO_STACK_LOCATION Stack;
 471     UCHAR MajorFunction;
 472     UCHAR MinorFunction;
 473     WORK_QUEUE_ITEM WorkQueueItem;
 474     PIRP Irp;
 475     BOOLEAN IsTopLevel;
 476     PDEVICE_OBJECT DeviceObject;
 477     PFILE_OBJECT FileObject;
 478     NTSTATUS SavedExceptionCode;
 479     CCHAR PriorityBoost;
 480 } NTFS_IRP_CONTEXT, *PNTFS_IRP_CONTEXT;
 481
 482 typedef struct _NTFS_ATTR_CONTEXT
 483 {
 484     PUCHAR            CacheRun;
 485     ULONGLONG            CacheRunOffset;
 486     LONGLONG            CacheRunStartLCN;
 487     ULONGLONG            CacheRunLength;
 488     LONGLONG            CacheRunLastLCN;
 489     ULONGLONG            CacheRunCurrentOffset;
 490     LARGE_MCB           DataRunsMCB;
 491     ULONGLONG           FileMFTIndex;
 492     PNTFS_ATTR_RECORD    pRecord;
 493 } NTFS_ATTR_CONTEXT, *PNTFS_ATTR_CONTEXT;
 494
 495 #define FCB_CACHE_INITIALIZED   0x0001
 496 #define FCB_IS_VOLUME_STREAM    0x0002
 497 #define FCB_IS_VOLUME           0x0004
 498 #define MAX_PATH                260
 499
 500 typedef struct _FCB
 501 {
 502     NTFSIDENTIFIER Identifier;
 503
 504     FSRTL_COMMON_FCB_HEADER RFCB;
 505     SECTION_OBJECT_POINTERS SectionObjectPointers;
 506
 507     PFILE_OBJECT FileObject;
 508     PNTFS_VCB Vcb;
 509
 510     WCHAR Stream[MAX_PATH];
 511     WCHAR *ObjectName;          /* point on filename (250 chars max) in PathName */
 512     WCHAR PathName[MAX_PATH];   /* path+filename 260 max */
 513
 514     ERESOURCE PagingIoResource;
 515     ERESOURCE MainResource;
 516
 517     LIST_ENTRY FcbListEntry;
 518     struct _FCB* ParentFcb;
 519
 520     ULONG DirIndex;
 521
 522     LONG RefCount;
 523     ULONG Flags;
 524     ULONG OpenHandleCount;
 525
 526     ULONGLONG MFTIndex;
 527     USHORT LinkCount;
 528
 529     FILENAME_ATTRIBUTE Entry;
 530
 531 } NTFS_FCB, *PNTFS_FCB;
 532
 533 typedef struct _FIND_ATTR_CONTXT
 534 {
 535     PDEVICE_EXTENSION Vcb;
 536     BOOLEAN OnlyResident;
 537     PNTFS_ATTR_RECORD FirstAttr;
 538     PNTFS_ATTR_RECORD CurrAttr;
 539     PNTFS_ATTR_RECORD LastAttr;
 540     PNTFS_ATTR_RECORD NonResidentStart;
 541     PNTFS_ATTR_RECORD NonResidentEnd;
 542     ULONG Offset;
 543 } FIND_ATTR_CONTXT, *PFIND_ATTR_CONTXT;
 544
 545 typedef struct
 546 {
 547     USHORT USN;
 548     USHORT Array[];
 549 } FIXUP_ARRAY, *PFIXUP_ARRAY;
 550
 551 extern PNTFS_GLOBAL_DATA NtfsGlobalData;
 552
 553 FORCEINLINE
 554 NTSTATUS
 555 NtfsMarkIrpContextForQueue(PNTFS_IRP_CONTEXT IrpContext)
 556 {
 557     PULONG Flags = &IrpContext->Flags;
 558
 559     *Flags &= ~IRPCONTEXT_COMPLETE;
 560     *Flags |= IRPCONTEXT_QUEUE;
 561
 562     return STATUS_PENDING;
 563 }
 564
 565 /* attrib.c */
 566
 567 //VOID
 568 //NtfsDumpAttribute(PATTRIBUTE Attribute);
 569
 570 NTSTATUS
 571 AddBitmap(PNTFS_VCB Vcb,
 572           PFILE_RECORD_HEADER FileRecord,
 573           PNTFS_ATTR_RECORD AttributeAddress,
 574           PCWSTR Name,
 575           USHORT NameLength);
 576
 577 NTSTATUS
 578 AddData(PFILE_RECORD_HEADER FileRecord,
 579         PNTFS_ATTR_RECORD AttributeAddress);
 580
 581 NTSTATUS
 582 AddRun(PNTFS_VCB Vcb,
 583        PNTFS_ATTR_CONTEXT AttrContext,
 584        ULONG AttrOffset,
 585        PFILE_RECORD_HEADER FileRecord,
 586        ULONGLONG NextAssignedCluster,
 587        ULONG RunLength);
 588
 589 NTSTATUS
 590 AddIndexAllocation(PNTFS_VCB Vcb,
 591                    PFILE_RECORD_HEADER FileRecord,
 592                    PNTFS_ATTR_RECORD AttributeAddress,
 593                    PCWSTR Name,
 594                    USHORT NameLength);
 595
 596 NTSTATUS
 597 AddIndexRoot(PNTFS_VCB Vcb,
 598              PFILE_RECORD_HEADER FileRecord,
 599              PNTFS_ATTR_RECORD AttributeAddress,
 600              PINDEX_ROOT_ATTRIBUTE NewIndexRoot,
 601              ULONG RootLength,
 602              PCWSTR Name,
 603              USHORT NameLength);
 604
 605 NTSTATUS
 606 AddFileName(PFILE_RECORD_HEADER FileRecord,
 607             PNTFS_ATTR_RECORD AttributeAddress,
 608             PDEVICE_EXTENSION DeviceExt,
 609             PFILE_OBJECT FileObject,
 610             BOOLEAN CaseSensitive,
 611             PULONGLONG ParentMftIndex);
 612
 613 NTSTATUS
 614 AddStandardInformation(PFILE_RECORD_HEADER FileRecord,
 615                        PNTFS_ATTR_RECORD AttributeAddress);
 616
 617 NTSTATUS
 618 ConvertDataRunsToLargeMCB(PUCHAR DataRun,
 619                           PLARGE_MCB DataRunsMCB,
 620                           PULONGLONG pNextVBN);
 621
 622 NTSTATUS
 623 ConvertLargeMCBToDataRuns(PLARGE_MCB DataRunsMCB,
 624                           PUCHAR RunBuffer,
 625                           ULONG MaxBufferSize,
 626                           PULONG UsedBufferSize);
 627
 628 PUCHAR
 629 DecodeRun(PUCHAR DataRun,
 630           LONGLONG *DataRunOffset,
 631           ULONGLONG *DataRunLength);
 632
 633 ULONG GetFileNameAttributeLength(PFILENAME_ATTRIBUTE FileNameAttribute);
 634
 635 VOID
 636 NtfsDumpDataRuns(PVOID StartOfRun,
 637                  ULONGLONG CurrentLCN);
 638
 639 VOID
 640 NtfsDumpFileAttributes(PDEVICE_EXTENSION Vcb,
 641                        PFILE_RECORD_HEADER FileRecord);
 642
 643 PSTANDARD_INFORMATION
 644 GetStandardInformationFromRecord(PDEVICE_EXTENSION Vcb,
 645                                  PFILE_RECORD_HEADER FileRecord);
 646
 647 PFILENAME_ATTRIBUTE
 648 GetFileNameFromRecord(PDEVICE_EXTENSION Vcb,
 649                       PFILE_RECORD_HEADER FileRecord,
 650                       UCHAR NameType);
 651
 652 UCHAR
 653 GetPackedByteCount(LONGLONG NumberToPack,
 654                    BOOLEAN IsSigned);
 655
 656 NTSTATUS
 657 GetLastClusterInDataRun(PDEVICE_EXTENSION Vcb,
 658                         PNTFS_ATTR_RECORD Attribute,
 659                         PULONGLONG LastCluster);
 660
 661 PFILENAME_ATTRIBUTE
 662 GetBestFileNameFromRecord(PDEVICE_EXTENSION Vcb,
 663                           PFILE_RECORD_HEADER FileRecord);
 664
 665 NTSTATUS
 666 FindFirstAttribute(PFIND_ATTR_CONTXT Context,
 667                    PDEVICE_EXTENSION Vcb,
 668                    PFILE_RECORD_HEADER FileRecord,
 669                    BOOLEAN OnlyResident,
 670                    PNTFS_ATTR_RECORD * Attribute);
 671
 672 NTSTATUS
 673 FindNextAttribute(PFIND_ATTR_CONTXT Context,
 674                   PNTFS_ATTR_RECORD * Attribute);
 675
 676 VOID
 677 FindCloseAttribute(PFIND_ATTR_CONTXT Context);
 678
 679 NTSTATUS
 680 FreeClusters(PNTFS_VCB Vcb,
 681              PNTFS_ATTR_CONTEXT AttrContext,
 682              ULONG AttrOffset,
 683              PFILE_RECORD_HEADER FileRecord,
 684              ULONG ClustersToFree);
 685
 686 /* blockdev.c */
 687
 688 NTSTATUS
 689 NtfsReadDisk(IN PDEVICE_OBJECT DeviceObject,
 690              IN LONGLONG StartingOffset,
 691              IN ULONG Length,
 692              IN ULONG SectorSize,
 693              IN OUT PUCHAR Buffer,
 694              IN BOOLEAN Override);
 695
 696 NTSTATUS
 697 NtfsWriteDisk(IN PDEVICE_OBJECT DeviceObject,
 698               IN LONGLONG StartingOffset,
 699               IN ULONG Length,
 700               IN ULONG SectorSize,
 701               IN const PUCHAR Buffer);
 702
 703 NTSTATUS
 704 NtfsReadSectors(IN PDEVICE_OBJECT DeviceObject,
 705                 IN ULONG DiskSector,
 706                 IN ULONG SectorCount,
 707                 IN ULONG SectorSize,
 708                 IN OUT PUCHAR Buffer,
 709                 IN BOOLEAN Override);
 710
 711 NTSTATUS
 712 NtfsDeviceIoControl(IN PDEVICE_OBJECT DeviceObject,
 713                     IN ULONG ControlCode,
 714                     IN PVOID InputBuffer,
 715                     IN ULONG InputBufferSize,
 716                     IN OUT PVOID OutputBuffer,
 717                     IN OUT PULONG OutputBufferSize,
 718                     IN BOOLEAN Override);
 719
 720
 721 /* btree.c */
 722
 723 LONG
 724 CompareTreeKeys(PB_TREE_KEY Key1,
 725                 PB_TREE_KEY Key2,
 726                 BOOLEAN CaseSensitive);
 727
 728 NTSTATUS
 729 CreateBTreeFromIndex(PDEVICE_EXTENSION Vcb,
 730                      PFILE_RECORD_HEADER FileRecordWithIndex,
 731                      /*PCWSTR IndexName,*/
 732                      PNTFS_ATTR_CONTEXT IndexRootContext,
 733                      PINDEX_ROOT_ATTRIBUTE IndexRoot,
 734                      PB_TREE *NewTree);
 735
 736 NTSTATUS
 737 CreateIndexRootFromBTree(PDEVICE_EXTENSION DeviceExt,
 738                          PB_TREE Tree,
 739                          ULONG MaxIndexSize,
 740                          PINDEX_ROOT_ATTRIBUTE *IndexRoot,
 741                          ULONG *Length);
 742
 743 NTSTATUS
 744 DemoteBTreeRoot(PB_TREE Tree);
 745
 746 VOID
 747 DestroyBTree(PB_TREE Tree);
 748
 749 VOID
 750 DestroyBTreeNode(PB_TREE_FILENAME_NODE Node);
 751
 752 VOID
 753 DumpBTree(PB_TREE Tree);
 754
 755 VOID
 756 DumpBTreeKey(PB_TREE Tree,
 757              PB_TREE_KEY Key,
 758              ULONG Number,
 759              ULONG Depth);
 760
 761 VOID
 762 DumpBTreeNode(PB_TREE Tree,
 763               PB_TREE_FILENAME_NODE Node,
 764               ULONG Number,
 765               ULONG Depth);
 766
 767 NTSTATUS
 768 CreateEmptyBTree(PB_TREE *NewTree);
 769
 770 ULONGLONG
 771 GetAllocationOffsetFromVCN(PDEVICE_EXTENSION DeviceExt,
 772                            ULONG IndexBufferSize,
 773                            ULONGLONG Vcn);
 774
 775 ULONGLONG
 776 GetIndexEntryVCN(PINDEX_ENTRY_ATTRIBUTE IndexEntry);
 777
 778 ULONG
 779 GetSizeOfIndexEntries(PB_TREE_FILENAME_NODE Node);
 780
 781 NTSTATUS
 782 NtfsInsertKey(PB_TREE Tree,
 783               ULONGLONG FileReference,
 784               PFILENAME_ATTRIBUTE FileNameAttribute,
 785               PB_TREE_FILENAME_NODE Node,
 786               BOOLEAN CaseSensitive,
 787               ULONG MaxIndexRootSize,
 788               ULONG IndexRecordSize,
 789               PB_TREE_KEY *MedianKey,
 790               PB_TREE_FILENAME_NODE *NewRightHandSibling);
 791
 792 NTSTATUS
 793 SplitBTreeNode(PB_TREE Tree,
 794                PB_TREE_FILENAME_NODE Node,
 795                PB_TREE_KEY *MedianKey,
 796                PB_TREE_FILENAME_NODE *NewRightHandSibling,
 797                BOOLEAN CaseSensitive);
 798
 799 NTSTATUS
 800 UpdateIndexAllocation(PDEVICE_EXTENSION DeviceExt,
 801                       PB_TREE Tree,
 802                       ULONG IndexBufferSize,
 803                       PFILE_RECORD_HEADER FileRecord);
 804
 805 NTSTATUS
 806 UpdateIndexNode(PDEVICE_EXTENSION DeviceExt,
 807                 PFILE_RECORD_HEADER FileRecord,
 808                 PB_TREE_FILENAME_NODE Node,
 809                 ULONG IndexBufferSize,
 810                 PNTFS_ATTR_CONTEXT IndexAllocationContext,
 811                 ULONG IndexAllocationOffset);
 812
 813 /* close.c */
 814
 815 NTSTATUS
 816 NtfsCleanup(PNTFS_IRP_CONTEXT IrpContext);
 817
 818
 819 /* close.c */
 820
 821 NTSTATUS
 822 NtfsCloseFile(PDEVICE_EXTENSION DeviceExt,
 823               PFILE_OBJECT FileObject);
 824
 825 NTSTATUS
 826 NtfsClose(PNTFS_IRP_CONTEXT IrpContext);
 827
 828
 829 /* create.c */
 830
 831 NTSTATUS
 832 NtfsCreate(PNTFS_IRP_CONTEXT IrpContext);
 833
 834 NTSTATUS
 835 NtfsCreateDirectory(PDEVICE_EXTENSION DeviceExt,
 836                     PFILE_OBJECT FileObject,
 837                     BOOLEAN CaseSensitive,
 838                     BOOLEAN CanWait);
 839
 840 PFILE_RECORD_HEADER
 841 NtfsCreateEmptyFileRecord(PDEVICE_EXTENSION DeviceExt);
 842
 843 NTSTATUS
 844 NtfsCreateFileRecord(PDEVICE_EXTENSION DeviceExt,
 845                      PFILE_OBJECT FileObject,
 846                      BOOLEAN CaseSensitive,
 847                      BOOLEAN CanWait);
 848
 849 /* devctl.c */
 850
 851 NTSTATUS
 852 NtfsDeviceControl(PNTFS_IRP_CONTEXT IrpContext);
 853
 854
 855 /* dirctl.c */
 856
 857 ULONGLONG
 858 NtfsGetFileSize(PDEVICE_EXTENSION DeviceExt,
 859                 PFILE_RECORD_HEADER FileRecord,
 860                 PCWSTR Stream,
 861                 ULONG StreamLength,
 862                 PULONGLONG AllocatedSize);
 863
 864 NTSTATUS
 865 NtfsDirectoryControl(PNTFS_IRP_CONTEXT IrpContext);
 866
 867
 868 /* dispatch.c */
 869
 870 DRIVER_DISPATCH NtfsFsdDispatch;
 871 NTSTATUS NTAPI
 872 NtfsFsdDispatch(PDEVICE_OBJECT DeviceObject,
 873                 PIRP Irp);
 874
 875
 876 /* fastio.c */
 877
 878 BOOLEAN NTAPI
 879 NtfsAcqLazyWrite(PVOID Context,
 880                  BOOLEAN Wait);
 881
 882 VOID NTAPI
 883 NtfsRelLazyWrite(PVOID Context);
 884
 885 BOOLEAN NTAPI
 886 NtfsAcqReadAhead(PVOID Context,
 887                  BOOLEAN Wait);
 888
 889 VOID NTAPI
 890 NtfsRelReadAhead(PVOID Context);
 891
 892 FAST_IO_CHECK_IF_POSSIBLE NtfsFastIoCheckIfPossible;
 893 FAST_IO_READ NtfsFastIoRead;
 894 FAST_IO_WRITE NtfsFastIoWrite;
 895
 896
 897 /* fcb.c */
 898
 899 PNTFS_FCB
 900 NtfsCreateFCB(PCWSTR FileName,
 901               PCWSTR Stream,
 902               PNTFS_VCB Vcb);
 903
 904 VOID
 905 NtfsDestroyFCB(PNTFS_FCB Fcb);
 906
 907 BOOLEAN
 908 NtfsFCBIsDirectory(PNTFS_FCB Fcb);
 909
 910 BOOLEAN
 911 NtfsFCBIsReparsePoint(PNTFS_FCB Fcb);
 912
 913 BOOLEAN
 914 NtfsFCBIsCompressed(PNTFS_FCB Fcb);
 915
 916 BOOLEAN
 917 NtfsFCBIsRoot(PNTFS_FCB Fcb);
 918
 919 VOID
 920 NtfsGrabFCB(PNTFS_VCB Vcb,
 921             PNTFS_FCB Fcb);
 922
 923 VOID
 924 NtfsReleaseFCB(PNTFS_VCB Vcb,
 925                PNTFS_FCB Fcb);
 926
 927 VOID
 928 NtfsAddFCBToTable(PNTFS_VCB Vcb,
 929                   PNTFS_FCB Fcb);
 930
 931 PNTFS_FCB
 932 NtfsGrabFCBFromTable(PNTFS_VCB Vcb,
 933                      PCWSTR FileName);
 934
 935 NTSTATUS
 936 NtfsFCBInitializeCache(PNTFS_VCB Vcb,
 937                        PNTFS_FCB Fcb);
 938
 939 PNTFS_FCB
 940 NtfsMakeRootFCB(PNTFS_VCB Vcb);
 941
 942 PNTFS_FCB
 943 NtfsOpenRootFCB(PNTFS_VCB Vcb);
 944
 945 NTSTATUS
 946 NtfsAttachFCBToFileObject(PNTFS_VCB Vcb,
 947                           PNTFS_FCB Fcb,
 948                           PFILE_OBJECT FileObject);
 949
 950 NTSTATUS
 951 NtfsGetFCBForFile(PNTFS_VCB Vcb,
 952                   PNTFS_FCB *pParentFCB,
 953                   PNTFS_FCB *pFCB,
 954                   PCWSTR pFileName,
 955                   BOOLEAN CaseSensitive);
 956
 957 NTSTATUS
 958 NtfsReadFCBAttribute(PNTFS_VCB Vcb,
 959                      PNTFS_FCB pFCB,
 960                      ULONG Type,
 961                      PCWSTR Name,
 962                      ULONG NameLength,
 963                      PVOID * Data);
 964
 965 NTSTATUS
 966 NtfsMakeFCBFromDirEntry(PNTFS_VCB Vcb,
 967                         PNTFS_FCB DirectoryFCB,
 968                         PUNICODE_STRING Name,
 969                         PCWSTR Stream,
 970                         PFILE_RECORD_HEADER Record,
 971                         ULONGLONG MFTIndex,
 972                         PNTFS_FCB * fileFCB);
 973
 974
 975 /* finfo.c */
 976
 977 NTSTATUS
 978 NtfsQueryInformation(PNTFS_IRP_CONTEXT IrpContext);
 979
 980 NTSTATUS
 981 NtfsSetEndOfFile(PNTFS_FCB Fcb,
 982                  PFILE_OBJECT FileObject,
 983                  PDEVICE_EXTENSION DeviceExt,
 984                  ULONG IrpFlags,
 985                  BOOLEAN CaseSensitive,
 986                  PLARGE_INTEGER NewFileSize);
 987
 988 NTSTATUS
 989 NtfsSetInformation(PNTFS_IRP_CONTEXT IrpContext);
 990
 991 /* fsctl.c */
 992
 993 NTSTATUS
 994 NtfsFileSystemControl(PNTFS_IRP_CONTEXT IrpContext);
 995
 996
 997 /* mft.c */
 998 NTSTATUS
 999 NtfsAddFilenameToDirectory(PDEVICE_EXTENSION DeviceExt,
1000                            ULONGLONG DirectoryMftIndex,
1001                            ULONGLONG FileReferenceNumber,
1002                            PFILENAME_ATTRIBUTE FilenameAttribute,
1003                            BOOLEAN CaseSensitive);
1004
1005 NTSTATUS
1006 AddNewMftEntry(PFILE_RECORD_HEADER FileRecord,
1007                PDEVICE_EXTENSION DeviceExt,
1008                PULONGLONG DestinationIndex,
1009                BOOLEAN CanWait);
1010
1011 VOID
1012 NtfsDumpData(ULONG_PTR Buffer, ULONG Length);
1013
1014 PNTFS_ATTR_CONTEXT
1015 PrepareAttributeContext(PNTFS_ATTR_RECORD AttrRecord);
1016
1017 VOID
1018 ReleaseAttributeContext(PNTFS_ATTR_CONTEXT Context);
1019
1020 ULONG
1021 ReadAttribute(PDEVICE_EXTENSION Vcb,
1022               PNTFS_ATTR_CONTEXT Context,
1023               ULONGLONG Offset,
1024               PCHAR Buffer,
1025               ULONG Length);
1026
1027 NTSTATUS
1028 WriteAttribute(PDEVICE_EXTENSION Vcb,
1029                PNTFS_ATTR_CONTEXT Context,
1030                ULONGLONG Offset,
1031                const PUCHAR Buffer,
1032                ULONG Length,
1033                PULONG LengthWritten,
1034                PFILE_RECORD_HEADER FileRecord);
1035
1036 ULONGLONG
1037 AttributeDataLength(PNTFS_ATTR_RECORD AttrRecord);
1038
1039 NTSTATUS
1040 InternalSetResidentAttributeLength(PDEVICE_EXTENSION DeviceExt,
1041                                    PNTFS_ATTR_CONTEXT AttrContext,
1042                                    PFILE_RECORD_HEADER FileRecord,
1043                                    ULONG AttrOffset,
1044                                    ULONG DataSize);
1045
1046 PNTFS_ATTR_RECORD
1047 MoveAttributes(PDEVICE_EXTENSION DeviceExt,
1048                PNTFS_ATTR_RECORD FirstAttributeToMove,
1049                ULONG FirstAttributeOffset,
1050                ULONG_PTR MoveTo);
1051
1052 NTSTATUS
1053 SetAttributeDataLength(PFILE_OBJECT FileObject,
1054                        PNTFS_FCB Fcb,
1055                        PNTFS_ATTR_CONTEXT AttrContext,
1056                        ULONG AttrOffset,
1057                        PFILE_RECORD_HEADER FileRecord,
1058                        PLARGE_INTEGER DataSize);
1059
1060 VOID
1061 SetFileRecordEnd(PFILE_RECORD_HEADER FileRecord,
1062                  PNTFS_ATTR_RECORD AttrEnd,
1063                  ULONG EndMarker);
1064
1065 NTSTATUS
1066 SetNonResidentAttributeDataLength(PDEVICE_EXTENSION Vcb,
1067                                   PNTFS_ATTR_CONTEXT AttrContext,
1068                                   ULONG AttrOffset,
1069                                   PFILE_RECORD_HEADER FileRecord,
1070                                   PLARGE_INTEGER DataSize);
1071
1072 NTSTATUS
1073 SetResidentAttributeDataLength(PDEVICE_EXTENSION Vcb,
1074                                PNTFS_ATTR_CONTEXT AttrContext,
1075                                ULONG AttrOffset,
1076                                PFILE_RECORD_HEADER FileRecord,
1077                                PLARGE_INTEGER DataSize);
1078
1079 ULONGLONG
1080 AttributeAllocatedLength(PNTFS_ATTR_RECORD AttrRecord);
1081
1082 BOOLEAN
1083 CompareFileName(PUNICODE_STRING FileName,
1084                 PINDEX_ENTRY_ATTRIBUTE IndexEntry,
1085                 BOOLEAN DirSearch,
1086                 BOOLEAN CaseSensitive);
1087
1088 NTSTATUS
1089 UpdateMftMirror(PNTFS_VCB Vcb);
1090
1091 NTSTATUS
1092 ReadFileRecord(PDEVICE_EXTENSION Vcb,
1093                ULONGLONG index,
1094                PFILE_RECORD_HEADER file);
1095
1096 NTSTATUS
1097 UpdateIndexEntryFileNameSize(PDEVICE_EXTENSION Vcb,
1098                              PFILE_RECORD_HEADER MftRecord,
1099                              PCHAR IndexRecord,
1100                              ULONG IndexBlockSize,
1101                              PINDEX_ENTRY_ATTRIBUTE FirstEntry,
1102                              PINDEX_ENTRY_ATTRIBUTE LastEntry,
1103                              PUNICODE_STRING FileName,
1104                              PULONG StartEntry,
1105                              PULONG CurrentEntry,
1106                              BOOLEAN DirSearch,
1107                              ULONGLONG NewDataSize,
1108                              ULONGLONG NewAllocatedSize,
1109                              BOOLEAN CaseSensitive);
1110
1111 NTSTATUS
1112 UpdateFileNameRecord(PDEVICE_EXTENSION Vcb,
1113                      ULONGLONG ParentMFTIndex,
1114                      PUNICODE_STRING FileName,
1115                      BOOLEAN DirSearch,
1116                      ULONGLONG NewDataSize,
1117                      ULONGLONG NewAllocationSize,
1118                      BOOLEAN CaseSensitive);
1119
1120 NTSTATUS
1121 UpdateFileRecord(PDEVICE_EXTENSION Vcb,
1122                  ULONGLONG MftIndex,
1123                  PFILE_RECORD_HEADER FileRecord);
1124
1125 NTSTATUS
1126 FindAttribute(PDEVICE_EXTENSION Vcb,
1127               PFILE_RECORD_HEADER MftRecord,
1128               ULONG Type,
1129               PCWSTR Name,
1130               ULONG NameLength,
1131               PNTFS_ATTR_CONTEXT * AttrCtx,
1132               PULONG Offset);
1133
1134 VOID
1135 ReadVCN(PDEVICE_EXTENSION Vcb,
1136         PFILE_RECORD_HEADER file,
1137         ATTRIBUTE_TYPE type,
1138         ULONGLONG vcn,
1139         ULONG count,
1140         PVOID buffer);
1141
1142 NTSTATUS
1143 FixupUpdateSequenceArray(PDEVICE_EXTENSION Vcb,
1144                          PNTFS_RECORD_HEADER Record);
1145
1146 NTSTATUS
1147 AddFixupArray(PDEVICE_EXTENSION Vcb,
1148               PNTFS_RECORD_HEADER Record);
1149
1150 NTSTATUS
1151 ReadLCN(PDEVICE_EXTENSION Vcb,
1152         ULONGLONG lcn,
1153         ULONG count,
1154         PVOID buffer);
1155
1156 VOID
1157 EnumerAttribute(PFILE_RECORD_HEADER file,
1158                 PDEVICE_EXTENSION Vcb,
1159                 PDEVICE_OBJECT DeviceObject);
1160
1161 NTSTATUS
1162 NtfsLookupFile(PDEVICE_EXTENSION Vcb,
1163                PUNICODE_STRING PathName,
1164                BOOLEAN CaseSensitive,
1165                PFILE_RECORD_HEADER *FileRecord,
1166                PULONGLONG MFTIndex);
1167
1168 NTSTATUS
1169 NtfsLookupFileAt(PDEVICE_EXTENSION Vcb,
1170                  PUNICODE_STRING PathName,
1171                  BOOLEAN CaseSensitive,
1172                  PFILE_RECORD_HEADER *FileRecord,
1173                  PULONGLONG MFTIndex,
1174                  ULONGLONG CurrentMFTIndex);
1175
1176 VOID
1177 NtfsDumpFileRecord(PDEVICE_EXTENSION Vcb,
1178                    PFILE_RECORD_HEADER FileRecord);
1179
1180 NTSTATUS
1181 NtfsFindFileAt(PDEVICE_EXTENSION Vcb,
1182                PUNICODE_STRING SearchPattern,
1183                PULONG FirstEntry,
1184                PFILE_RECORD_HEADER *FileRecord,
1185                PULONGLONG MFTIndex,
1186                ULONGLONG CurrentMFTIndex,
1187                BOOLEAN CaseSensitive);
1188
1189 NTSTATUS
1190 NtfsFindMftRecord(PDEVICE_EXTENSION Vcb,
1191                   ULONGLONG MFTIndex,
1192                   PUNICODE_STRING FileName,
1193                   PULONG FirstEntry,
1194                   BOOLEAN DirSearch,
1195                   BOOLEAN CaseSensitive,
1196                   ULONGLONG *OutMFTIndex);
1197
1198 /* misc.c */
1199
1200 BOOLEAN
1201 NtfsIsIrpTopLevel(PIRP Irp);
1202
1203 PNTFS_IRP_CONTEXT
1204 NtfsAllocateIrpContext(PDEVICE_OBJECT DeviceObject,
1205                        PIRP Irp);
1206
1207 PVOID
1208 NtfsGetUserBuffer(PIRP Irp,
1209                   BOOLEAN Paging);
1210
1211 NTSTATUS
1212 NtfsLockUserBuffer(IN PIRP Irp,
1213                    IN ULONG Length,
1214                    IN LOCK_OPERATION Operation);
1215
1216 #if 0
1217 BOOLEAN
1218 wstrcmpjoki(PWSTR s1, PWSTR s2);
1219
1220 VOID
1221 CdfsSwapString(PWCHAR Out,
1222                PUCHAR In,
1223                ULONG Count);
1224 #endif
1225
1226 VOID
1227 NtfsFileFlagsToAttributes(ULONG NtfsAttributes,
1228                           PULONG FileAttributes);
1229
1230
1231 /* rw.c */
1232
1233 NTSTATUS
1234 NtfsRead(PNTFS_IRP_CONTEXT IrpContext);
1235
1236 NTSTATUS
1237 NtfsWrite(PNTFS_IRP_CONTEXT IrpContext);
1238
1239
1240 /* volinfo.c */
1241
1242 NTSTATUS
1243 NtfsAllocateClusters(PDEVICE_EXTENSION DeviceExt,
1244                      ULONG FirstDesiredCluster,
1245                      ULONG DesiredClusters,
1246                      PULONG FirstAssignedCluster,
1247                      PULONG AssignedClusters);
1248
1249 ULONGLONG
1250 NtfsGetFreeClusters(PDEVICE_EXTENSION DeviceExt);
1251
1252 NTSTATUS
1253 NtfsQueryVolumeInformation(PNTFS_IRP_CONTEXT IrpContext);
1254
1255 NTSTATUS
1256 NtfsSetVolumeInformation(PNTFS_IRP_CONTEXT IrpContext);
1257
1258
1259 /* ntfs.c */
1260
1261 DRIVER_INITIALIZE DriverEntry;
1262
1263 VOID
1264 NTAPI
1265 NtfsInitializeFunctionPointers(PDRIVER_OBJECT DriverObject);
1266
1267 #endif /* NTFS_H */