mirror of https://github.com/reactos/reactos.git
1245 lines
28 KiB
C
1245 lines
28 KiB
C
#ifndef _FASTFAT_PCH_
|
|
#define _FASTFAT_PCH_
|
|
|
|
#include <ntifs.h>
|
|
#include <ntdddisk.h>
|
|
#include <dos.h>
|
|
#include <pseh/pseh2.h>
|
|
#include <section_attribs.h>
|
|
#ifdef KDBG
|
|
#include <ndk/kdfuncs.h>
|
|
#include <reactos/kdros.h>
|
|
#endif
|
|
|
|
|
|
#define USE_ROS_CC_AND_FS
|
|
#define ENABLE_SWAPOUT
|
|
|
|
/* FIXME: because volume is not cached, we have to perform direct IOs
|
|
* The day this is fixed, just comment out that line, and check
|
|
* it still works (and delete old code ;-))
|
|
*/
|
|
#define VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
|
|
|
|
|
|
#define ROUND_DOWN(n, align) \
|
|
(((ULONG)n) & ~((align) - 1l))
|
|
|
|
#define ROUND_UP(n, align) \
|
|
ROUND_DOWN(((ULONG)n) + (align) - 1, (align))
|
|
|
|
#define ROUND_DOWN_64(n, align) \
|
|
(((ULONGLONG)n) & ~((align) - 1LL))
|
|
|
|
#define ROUND_UP_64(n, align) \
|
|
ROUND_DOWN_64(((ULONGLONG)n) + (align) - 1LL, (align))
|
|
|
|
#include <pshpack1.h>
|
|
struct _BootSector
|
|
{
|
|
unsigned char magic0, res0, magic1;
|
|
unsigned char OEMName[8];
|
|
unsigned short BytesPerSector;
|
|
unsigned char SectorsPerCluster;
|
|
unsigned short ReservedSectors;
|
|
unsigned char FATCount;
|
|
unsigned short RootEntries, Sectors;
|
|
unsigned char Media;
|
|
unsigned short FATSectors, SectorsPerTrack, Heads;
|
|
unsigned long HiddenSectors, SectorsHuge;
|
|
unsigned char Drive, Res1, Sig;
|
|
unsigned long VolumeID;
|
|
unsigned char VolumeLabel[11], SysType[8];
|
|
unsigned char Res2[448];
|
|
unsigned short Signatur1;
|
|
};
|
|
|
|
struct _BootSector32
|
|
{
|
|
unsigned char magic0, res0, magic1; // 0
|
|
unsigned char OEMName[8]; // 3
|
|
unsigned short BytesPerSector; // 11
|
|
unsigned char SectorsPerCluster; // 13
|
|
unsigned short ReservedSectors; // 14
|
|
unsigned char FATCount; // 16
|
|
unsigned short RootEntries, Sectors; // 17
|
|
unsigned char Media; // 21
|
|
unsigned short FATSectors, SectorsPerTrack, Heads; // 22
|
|
unsigned long HiddenSectors, SectorsHuge; // 28
|
|
unsigned long FATSectors32; // 36
|
|
unsigned short ExtFlag; // 40
|
|
unsigned short FSVersion; // 42
|
|
unsigned long RootCluster; // 44
|
|
unsigned short FSInfoSector; // 48
|
|
unsigned short BootBackup; // 50
|
|
unsigned char Res3[12]; // 52
|
|
unsigned char Drive; // 64
|
|
unsigned char Res4; // 65
|
|
unsigned char ExtBootSignature; // 66
|
|
unsigned long VolumeID; // 67
|
|
unsigned char VolumeLabel[11], SysType[8]; // 71
|
|
unsigned char Res2[420]; // 90
|
|
unsigned short Signature1; // 510
|
|
};
|
|
|
|
#define FAT_DIRTY_BIT 0x01
|
|
|
|
struct _BootSectorFatX
|
|
{
|
|
unsigned char SysType[4]; // 0
|
|
unsigned long VolumeID; // 4
|
|
unsigned long SectorsPerCluster; // 8
|
|
unsigned short FATCount; // 12
|
|
unsigned long Unknown; // 14
|
|
unsigned char Unused[4078]; // 18
|
|
};
|
|
|
|
struct _FsInfoSector
|
|
{
|
|
unsigned long ExtBootSignature2; // 0
|
|
unsigned char Res6[480]; // 4
|
|
unsigned long FSINFOSignature; // 484
|
|
unsigned long FreeCluster; // 488
|
|
unsigned long NextCluster; // 492
|
|
unsigned char Res7[12]; // 496
|
|
unsigned long Signatur2; // 508
|
|
};
|
|
|
|
typedef struct _BootSector BootSector;
|
|
|
|
struct _FATDirEntry
|
|
{
|
|
union
|
|
{
|
|
struct { unsigned char Filename[8], Ext[3]; };
|
|
unsigned char ShortName[11];
|
|
};
|
|
unsigned char Attrib;
|
|
unsigned char lCase;
|
|
unsigned char CreationTimeMs;
|
|
unsigned short CreationTime,CreationDate,AccessDate;
|
|
union
|
|
{
|
|
unsigned short FirstClusterHigh; // FAT32
|
|
unsigned short ExtendedAttributes; // FAT12/FAT16
|
|
};
|
|
unsigned short UpdateTime; //time create/update
|
|
unsigned short UpdateDate; //date create/update
|
|
unsigned short FirstCluster;
|
|
unsigned long FileSize;
|
|
};
|
|
|
|
#define FAT_EAFILE "EA DATA. SF"
|
|
|
|
typedef struct _EAFileHeader FAT_EA_FILE_HEADER, *PFAT_EA_FILE_HEADER;
|
|
|
|
struct _EAFileHeader
|
|
{
|
|
unsigned short Signature; // ED
|
|
unsigned short Unknown[15];
|
|
unsigned short EASetTable[240];
|
|
};
|
|
|
|
typedef struct _EASetHeader FAT_EA_SET_HEADER, *PFAT_EA_SET_HEADER;
|
|
|
|
struct _EASetHeader
|
|
{
|
|
unsigned short Signature; // EA
|
|
unsigned short Offset; // relative offset, same value as in the EASetTable
|
|
unsigned short Unknown1[2];
|
|
char TargetFileName[12];
|
|
unsigned short Unknown2[3];
|
|
unsigned int EALength;
|
|
// EA Header
|
|
};
|
|
|
|
typedef struct _EAHeader FAT_EA_HEADER, *PFAT_EA_HEADER;
|
|
|
|
struct _EAHeader
|
|
{
|
|
unsigned char Unknown;
|
|
unsigned char EANameLength;
|
|
unsigned short EAValueLength;
|
|
// Name Data
|
|
// Value Data
|
|
};
|
|
|
|
typedef struct _FATDirEntry FAT_DIR_ENTRY, *PFAT_DIR_ENTRY;
|
|
|
|
struct _FATXDirEntry
|
|
{
|
|
unsigned char FilenameLength; // 0
|
|
unsigned char Attrib; // 1
|
|
unsigned char Filename[42]; // 2
|
|
unsigned long FirstCluster; // 44
|
|
unsigned long FileSize; // 48
|
|
unsigned short UpdateTime; // 52
|
|
unsigned short UpdateDate; // 54
|
|
unsigned short CreationTime; // 56
|
|
unsigned short CreationDate; // 58
|
|
unsigned short AccessTime; // 60
|
|
unsigned short AccessDate; // 62
|
|
};
|
|
|
|
struct _slot
|
|
{
|
|
unsigned char id; // sequence number for slot
|
|
WCHAR name0_4[5]; // first 5 characters in name
|
|
unsigned char attr; // attribute byte
|
|
unsigned char reserved; // always 0
|
|
unsigned char alias_checksum; // checksum for 8.3 alias
|
|
WCHAR name5_10[6]; // 6 more characters in name
|
|
unsigned char start[2]; // starting cluster number
|
|
WCHAR name11_12[2]; // last 2 characters in name
|
|
};
|
|
|
|
typedef struct _slot slot;
|
|
|
|
#include <poppack.h>
|
|
|
|
#define VFAT_CASE_LOWER_BASE 8 // base is lower case
|
|
#define VFAT_CASE_LOWER_EXT 16 // extension is lower case
|
|
|
|
#define LONGNAME_MAX_LENGTH 256 // max length for a long filename
|
|
|
|
#define ENTRY_DELETED(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_DELETED(&((DirEntry)->FatX)) : FAT_ENTRY_DELETED(&((DirEntry)->Fat)))
|
|
#define ENTRY_VOLUME(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_VOLUME(&((DirEntry)->FatX)) : FAT_ENTRY_VOLUME(&((DirEntry)->Fat)))
|
|
#define ENTRY_END(IsFatX, DirEntry) (IsFatX ? FATX_ENTRY_END(&((DirEntry)->FatX)) : FAT_ENTRY_END(&((DirEntry)->Fat)))
|
|
|
|
#define FAT_ENTRY_DELETED(DirEntry) ((DirEntry)->Filename[0] == 0xe5)
|
|
#define FAT_ENTRY_END(DirEntry) ((DirEntry)->Filename[0] == 0)
|
|
#define FAT_ENTRY_LONG(DirEntry) (((DirEntry)->Attrib & 0x3f) == 0x0f)
|
|
#define FAT_ENTRY_VOLUME(DirEntry) (((DirEntry)->Attrib & 0x1f) == 0x08)
|
|
|
|
#define FATX_ENTRY_DELETED(DirEntry) ((DirEntry)->FilenameLength == 0xe5)
|
|
#define FATX_ENTRY_END(DirEntry) ((DirEntry)->FilenameLength == 0xff)
|
|
#define FATX_ENTRY_LONG(DirEntry) (FALSE)
|
|
#define FATX_ENTRY_VOLUME(DirEntry) (((DirEntry)->Attrib & 0x1f) == 0x08)
|
|
|
|
#define FAT_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof (FAT_DIR_ENTRY))
|
|
#define FATX_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof (FATX_DIR_ENTRY))
|
|
|
|
typedef struct _FATXDirEntry FATX_DIR_ENTRY, *PFATX_DIR_ENTRY;
|
|
|
|
union _DIR_ENTRY
|
|
{
|
|
FAT_DIR_ENTRY Fat;
|
|
FATX_DIR_ENTRY FatX;
|
|
};
|
|
|
|
typedef union _DIR_ENTRY DIR_ENTRY, *PDIR_ENTRY;
|
|
|
|
#define BLOCKSIZE 512
|
|
|
|
#define FAT16 (1)
|
|
#define FAT12 (2)
|
|
#define FAT32 (3)
|
|
#define FATX16 (4)
|
|
#define FATX32 (5)
|
|
|
|
#define VCB_VOLUME_LOCKED 0x0001
|
|
#define VCB_DISMOUNT_PENDING 0x0002
|
|
#define VCB_IS_FATX 0x0004
|
|
#define VCB_IS_SYS_OR_HAS_PAGE 0x0008
|
|
#define VCB_IS_DIRTY 0x4000 /* Volume is dirty */
|
|
#define VCB_CLEAR_DIRTY 0x8000 /* Clean dirty flag at shutdown */
|
|
/* VCB condition state */
|
|
#define VCB_GOOD 0x0010 /* If not set, the VCB is improper for usage */
|
|
|
|
typedef struct
|
|
{
|
|
ULONG VolumeID;
|
|
CHAR VolumeLabel[11];
|
|
ULONG FATStart;
|
|
ULONG FATCount;
|
|
ULONG FATSectors;
|
|
ULONG rootDirectorySectors;
|
|
ULONG rootStart;
|
|
ULONG dataStart;
|
|
ULONG RootCluster;
|
|
ULONG SectorsPerCluster;
|
|
ULONG BytesPerSector;
|
|
ULONG BytesPerCluster;
|
|
ULONG NumberOfClusters;
|
|
ULONG FatType;
|
|
ULONG Sectors;
|
|
BOOLEAN FixedMedia;
|
|
ULONG FSInfoSector;
|
|
} FATINFO, *PFATINFO;
|
|
|
|
struct _VFATFCB;
|
|
struct _VFAT_DIRENTRY_CONTEXT;
|
|
struct _VFAT_MOVE_CONTEXT;
|
|
struct _VFAT_CLOSE_CONTEXT;
|
|
|
|
typedef struct _HASHENTRY
|
|
{
|
|
ULONG Hash;
|
|
struct _VFATFCB* self;
|
|
struct _HASHENTRY* next;
|
|
}
|
|
HASHENTRY;
|
|
|
|
typedef struct DEVICE_EXTENSION *PDEVICE_EXTENSION;
|
|
|
|
typedef NTSTATUS (*PGET_NEXT_CLUSTER)(PDEVICE_EXTENSION,ULONG,PULONG);
|
|
typedef NTSTATUS (*PFIND_AND_MARK_AVAILABLE_CLUSTER)(PDEVICE_EXTENSION,PULONG);
|
|
typedef NTSTATUS (*PWRITE_CLUSTER)(PDEVICE_EXTENSION,ULONG,ULONG,PULONG);
|
|
|
|
typedef BOOLEAN (*PIS_DIRECTORY_EMPTY)(PDEVICE_EXTENSION,struct _VFATFCB*);
|
|
typedef NTSTATUS (*PADD_ENTRY)(PDEVICE_EXTENSION,PUNICODE_STRING,struct _VFATFCB**,struct _VFATFCB*,ULONG,UCHAR,struct _VFAT_MOVE_CONTEXT*);
|
|
typedef NTSTATUS (*PDEL_ENTRY)(PDEVICE_EXTENSION,struct _VFATFCB*,struct _VFAT_MOVE_CONTEXT*);
|
|
typedef NTSTATUS (*PGET_NEXT_DIR_ENTRY)(PVOID*,PVOID*,struct _VFATFCB*,struct _VFAT_DIRENTRY_CONTEXT*,BOOLEAN);
|
|
typedef NTSTATUS (*PGET_DIRTY_STATUS)(PDEVICE_EXTENSION,PBOOLEAN);
|
|
typedef NTSTATUS (*PSET_DIRTY_STATUS)(PDEVICE_EXTENSION,BOOLEAN);
|
|
|
|
typedef struct _VFAT_DISPATCH
|
|
{
|
|
PIS_DIRECTORY_EMPTY IsDirectoryEmpty;
|
|
PADD_ENTRY AddEntry;
|
|
PDEL_ENTRY DelEntry;
|
|
PGET_NEXT_DIR_ENTRY GetNextDirEntry;
|
|
} VFAT_DISPATCH, *PVFAT_DISPATCH;
|
|
|
|
#define STATISTICS_SIZE_NO_PAD (sizeof(FILESYSTEM_STATISTICS) + sizeof(FAT_STATISTICS))
|
|
typedef struct _STATISTICS {
|
|
FILESYSTEM_STATISTICS Base;
|
|
FAT_STATISTICS Fat;
|
|
UCHAR Pad[((STATISTICS_SIZE_NO_PAD + 0x3f) & ~0x3f) - STATISTICS_SIZE_NO_PAD];
|
|
} STATISTICS, *PSTATISTICS;
|
|
|
|
typedef struct DEVICE_EXTENSION
|
|
{
|
|
ERESOURCE DirResource;
|
|
ERESOURCE FatResource;
|
|
|
|
KSPIN_LOCK FcbListLock;
|
|
LIST_ENTRY FcbListHead;
|
|
ULONG HashTableSize;
|
|
struct _HASHENTRY **FcbHashTable;
|
|
|
|
PDEVICE_OBJECT VolumeDevice;
|
|
PDEVICE_OBJECT StorageDevice;
|
|
PFILE_OBJECT FATFileObject;
|
|
FATINFO FatInfo;
|
|
ULONG LastAvailableCluster;
|
|
ULONG AvailableClusters;
|
|
BOOLEAN AvailableClustersValid;
|
|
ULONG Flags;
|
|
struct _VFATFCB *VolumeFcb;
|
|
struct _VFATFCB *RootFcb;
|
|
PSTATISTICS Statistics;
|
|
|
|
/* Overflow request queue */
|
|
KSPIN_LOCK OverflowQueueSpinLock;
|
|
LIST_ENTRY OverflowQueue;
|
|
ULONG OverflowQueueCount;
|
|
ULONG PostedRequestCount;
|
|
|
|
/* Pointers to functions for manipulating FAT. */
|
|
PGET_NEXT_CLUSTER GetNextCluster;
|
|
PFIND_AND_MARK_AVAILABLE_CLUSTER FindAndMarkAvailableCluster;
|
|
PWRITE_CLUSTER WriteCluster;
|
|
PGET_DIRTY_STATUS GetDirtyStatus;
|
|
PSET_DIRTY_STATUS SetDirtyStatus;
|
|
|
|
ULONG BaseDateYear;
|
|
|
|
LIST_ENTRY VolumeListEntry;
|
|
|
|
/* Notifications */
|
|
LIST_ENTRY NotifyList;
|
|
PNOTIFY_SYNC NotifySync;
|
|
|
|
/* Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE */
|
|
ULONG OpenHandleCount;
|
|
|
|
/* VPBs for dismount */
|
|
PVPB IoVPB;
|
|
PVPB SpareVPB;
|
|
|
|
/* Pointers to functions for manipulating directory entries. */
|
|
VFAT_DISPATCH Dispatch;
|
|
} DEVICE_EXTENSION, VCB, *PVCB;
|
|
|
|
FORCEINLINE
|
|
BOOLEAN
|
|
VfatIsDirectoryEmpty(PDEVICE_EXTENSION DeviceExt,
|
|
struct _VFATFCB* Fcb)
|
|
{
|
|
return DeviceExt->Dispatch.IsDirectoryEmpty(DeviceExt, Fcb);
|
|
}
|
|
|
|
FORCEINLINE
|
|
NTSTATUS
|
|
VfatAddEntry(PDEVICE_EXTENSION DeviceExt,
|
|
PUNICODE_STRING NameU,
|
|
struct _VFATFCB** Fcb,
|
|
struct _VFATFCB* ParentFcb,
|
|
ULONG RequestedOptions,
|
|
UCHAR ReqAttr,
|
|
struct _VFAT_MOVE_CONTEXT* MoveContext)
|
|
{
|
|
return DeviceExt->Dispatch.AddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr, MoveContext);
|
|
}
|
|
|
|
FORCEINLINE
|
|
NTSTATUS
|
|
VfatDelEntry(PDEVICE_EXTENSION DeviceExt,
|
|
struct _VFATFCB* Fcb,
|
|
struct _VFAT_MOVE_CONTEXT* MoveContext)
|
|
{
|
|
return DeviceExt->Dispatch.DelEntry(DeviceExt, Fcb, MoveContext);
|
|
}
|
|
|
|
FORCEINLINE
|
|
NTSTATUS
|
|
VfatGetNextDirEntry(PDEVICE_EXTENSION DeviceExt,
|
|
PVOID *pContext,
|
|
PVOID *pPage,
|
|
struct _VFATFCB* pDirFcb,
|
|
struct _VFAT_DIRENTRY_CONTEXT* DirContext,
|
|
BOOLEAN First)
|
|
{
|
|
return DeviceExt->Dispatch.GetNextDirEntry(pContext, pPage, pDirFcb, DirContext, First);
|
|
}
|
|
|
|
#define VFAT_BREAK_ON_CORRUPTION 1
|
|
|
|
typedef struct
|
|
{
|
|
PDRIVER_OBJECT DriverObject;
|
|
PDEVICE_OBJECT DeviceObject;
|
|
ULONG Flags;
|
|
ULONG NumberProcessors;
|
|
ERESOURCE VolumeListLock;
|
|
LIST_ENTRY VolumeListHead;
|
|
NPAGED_LOOKASIDE_LIST FcbLookasideList;
|
|
NPAGED_LOOKASIDE_LIST CcbLookasideList;
|
|
NPAGED_LOOKASIDE_LIST IrpContextLookasideList;
|
|
PAGED_LOOKASIDE_LIST CloseContextLookasideList;
|
|
FAST_IO_DISPATCH FastIoDispatch;
|
|
CACHE_MANAGER_CALLBACKS CacheMgrCallbacks;
|
|
FAST_MUTEX CloseMutex;
|
|
ULONG CloseCount;
|
|
LIST_ENTRY CloseListHead;
|
|
BOOLEAN CloseWorkerRunning;
|
|
PIO_WORKITEM CloseWorkItem;
|
|
BOOLEAN ShutdownStarted;
|
|
} VFAT_GLOBAL_DATA, *PVFAT_GLOBAL_DATA;
|
|
|
|
extern PVFAT_GLOBAL_DATA VfatGlobalData;
|
|
|
|
#define FCB_CACHE_INITIALIZED 0x0001
|
|
#define FCB_DELETE_PENDING 0x0002
|
|
#define FCB_IS_FAT 0x0004
|
|
#define FCB_IS_PAGE_FILE 0x0008
|
|
#define FCB_IS_VOLUME 0x0010
|
|
#define FCB_IS_DIRTY 0x0020
|
|
#define FCB_DELAYED_CLOSE 0x0040
|
|
#ifdef KDBG
|
|
#define FCB_CLEANED_UP 0x0080
|
|
#define FCB_CLOSED 0x0100
|
|
#endif
|
|
|
|
#define NODE_TYPE_FCB ((CSHORT)0x0502)
|
|
|
|
typedef struct _VFATFCB
|
|
{
|
|
/* FCB header required by ROS/NT */
|
|
FSRTL_COMMON_FCB_HEADER RFCB;
|
|
SECTION_OBJECT_POINTERS SectionObjectPointers;
|
|
ERESOURCE MainResource;
|
|
ERESOURCE PagingIoResource;
|
|
/* end FCB header required by ROS/NT */
|
|
|
|
/* directory entry for this file or directory */
|
|
DIR_ENTRY entry;
|
|
|
|
/* Pointer to attributes in entry */
|
|
PUCHAR Attributes;
|
|
|
|
/* long file name, points into PathNameBuffer */
|
|
UNICODE_STRING LongNameU;
|
|
|
|
/* short file name */
|
|
UNICODE_STRING ShortNameU;
|
|
|
|
/* directory name, points into PathNameBuffer */
|
|
UNICODE_STRING DirNameU;
|
|
|
|
/* path + long file name 260 max*/
|
|
UNICODE_STRING PathNameU;
|
|
|
|
/* buffer for PathNameU */
|
|
PWCHAR PathNameBuffer;
|
|
|
|
/* buffer for ShortNameU */
|
|
WCHAR ShortNameBuffer[13];
|
|
|
|
/* */
|
|
LONG RefCount;
|
|
|
|
/* List of FCB's for this volume */
|
|
LIST_ENTRY FcbListEntry;
|
|
|
|
/* List of FCB's for the parent */
|
|
LIST_ENTRY ParentListEntry;
|
|
|
|
/* pointer to the parent fcb */
|
|
struct _VFATFCB *parentFcb;
|
|
|
|
/* List for the children */
|
|
LIST_ENTRY ParentListHead;
|
|
|
|
/* Flags for the fcb */
|
|
ULONG Flags;
|
|
|
|
/* pointer to the file object which has initialized the fcb */
|
|
PFILE_OBJECT FileObject;
|
|
|
|
/* Directory index for the short name entry */
|
|
ULONG dirIndex;
|
|
|
|
/* Directory index where the long name starts */
|
|
ULONG startIndex;
|
|
|
|
/* Share access for the file object */
|
|
SHARE_ACCESS FCBShareAccess;
|
|
|
|
/* Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP */
|
|
ULONG OpenHandleCount;
|
|
|
|
/* Entry into the hash table for the path + long name */
|
|
HASHENTRY Hash;
|
|
|
|
/* Entry into the hash table for the path + short name */
|
|
HASHENTRY ShortHash;
|
|
|
|
/* List of byte-range locks for this file */
|
|
FILE_LOCK FileLock;
|
|
|
|
/*
|
|
* Optimization: caching of last read/write cluster+offset pair. Can't
|
|
* be in VFATCCB because it must be reset everytime the allocated clusters
|
|
* change.
|
|
*/
|
|
FAST_MUTEX LastMutex;
|
|
ULONG LastCluster;
|
|
ULONG LastOffset;
|
|
|
|
struct _VFAT_CLOSE_CONTEXT * CloseContext;
|
|
} VFATFCB, *PVFATFCB;
|
|
|
|
#define CCB_DELETE_ON_CLOSE 0x0001
|
|
|
|
typedef struct _VFATCCB
|
|
{
|
|
LARGE_INTEGER CurrentByteOffset;
|
|
ULONG Flags;
|
|
/* for DirectoryControl */
|
|
ULONG Entry;
|
|
/* for DirectoryControl */
|
|
UNICODE_STRING SearchPattern;
|
|
} VFATCCB, *PVFATCCB;
|
|
|
|
#define TAG_CCB 'CtaF'
|
|
#define TAG_FCB 'FtaF'
|
|
#define TAG_IRP 'ItaF'
|
|
#define TAG_CLOSE 'xtaF'
|
|
#define TAG_STATS 'VtaF'
|
|
#define TAG_BUFFER 'OtaF'
|
|
#define TAG_VPB 'vtaF'
|
|
#define TAG_NAME 'ntaF'
|
|
#define TAG_SEARCH 'LtaF'
|
|
#define TAG_DIRENT 'DtaF'
|
|
|
|
#define ENTRIES_PER_SECTOR (BLOCKSIZE / sizeof(FATDirEntry))
|
|
|
|
typedef struct __DOSTIME
|
|
{
|
|
USHORT Second:5;
|
|
USHORT Minute:6;
|
|
USHORT Hour:5;
|
|
}
|
|
DOSTIME, *PDOSTIME;
|
|
|
|
typedef struct __DOSDATE
|
|
{
|
|
USHORT Day:5;
|
|
USHORT Month:4;
|
|
USHORT Year:7;
|
|
}
|
|
DOSDATE, *PDOSDATE;
|
|
|
|
#define IRPCONTEXT_CANWAIT 0x0001
|
|
#define IRPCONTEXT_COMPLETE 0x0002
|
|
#define IRPCONTEXT_QUEUE 0x0004
|
|
#define IRPCONTEXT_PENDINGRETURNED 0x0008
|
|
#define IRPCONTEXT_DEFERRED_WRITE 0x0010
|
|
|
|
typedef struct
|
|
{
|
|
PIRP Irp;
|
|
PDEVICE_OBJECT DeviceObject;
|
|
PDEVICE_EXTENSION DeviceExt;
|
|
ULONG Flags;
|
|
WORK_QUEUE_ITEM WorkQueueItem;
|
|
PIO_STACK_LOCATION Stack;
|
|
UCHAR MajorFunction;
|
|
UCHAR MinorFunction;
|
|
PFILE_OBJECT FileObject;
|
|
ULONG RefCount;
|
|
KEVENT Event;
|
|
CCHAR PriorityBoost;
|
|
} VFAT_IRP_CONTEXT, *PVFAT_IRP_CONTEXT;
|
|
|
|
typedef struct _VFAT_DIRENTRY_CONTEXT
|
|
{
|
|
ULONG StartIndex;
|
|
ULONG DirIndex;
|
|
DIR_ENTRY DirEntry;
|
|
UNICODE_STRING LongNameU;
|
|
UNICODE_STRING ShortNameU;
|
|
PDEVICE_EXTENSION DeviceExt;
|
|
} VFAT_DIRENTRY_CONTEXT, *PVFAT_DIRENTRY_CONTEXT;
|
|
|
|
typedef struct _VFAT_MOVE_CONTEXT
|
|
{
|
|
ULONG FirstCluster;
|
|
ULONG FileSize;
|
|
USHORT CreationDate;
|
|
USHORT CreationTime;
|
|
BOOLEAN InPlace;
|
|
} VFAT_MOVE_CONTEXT, *PVFAT_MOVE_CONTEXT;
|
|
|
|
typedef struct _VFAT_CLOSE_CONTEXT
|
|
{
|
|
PDEVICE_EXTENSION Vcb;
|
|
PVFATFCB Fcb;
|
|
LIST_ENTRY CloseListEntry;
|
|
} VFAT_CLOSE_CONTEXT, *PVFAT_CLOSE_CONTEXT;
|
|
|
|
FORCEINLINE
|
|
NTSTATUS
|
|
VfatMarkIrpContextForQueue(PVFAT_IRP_CONTEXT IrpContext)
|
|
{
|
|
PULONG Flags = &IrpContext->Flags;
|
|
|
|
*Flags &= ~IRPCONTEXT_COMPLETE;
|
|
*Flags |= IRPCONTEXT_QUEUE;
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
FORCEINLINE
|
|
BOOLEAN
|
|
vfatFCBIsDirectory(PVFATFCB FCB)
|
|
{
|
|
return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_DIRECTORY);
|
|
}
|
|
|
|
FORCEINLINE
|
|
BOOLEAN
|
|
vfatFCBIsReadOnly(PVFATFCB FCB)
|
|
{
|
|
return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_READONLY);
|
|
}
|
|
|
|
FORCEINLINE
|
|
BOOLEAN
|
|
vfatVolumeIsFatX(PDEVICE_EXTENSION DeviceExt)
|
|
{
|
|
return BooleanFlagOn(DeviceExt->Flags, VCB_IS_FATX);
|
|
}
|
|
|
|
FORCEINLINE
|
|
VOID
|
|
vfatReportChange(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
IN PVFATFCB Fcb,
|
|
IN ULONG FilterMatch,
|
|
IN ULONG Action)
|
|
{
|
|
FsRtlNotifyFullReportChange(DeviceExt->NotifySync,
|
|
&(DeviceExt->NotifyList),
|
|
(PSTRING)&Fcb->PathNameU,
|
|
Fcb->PathNameU.Length - Fcb->LongNameU.Length,
|
|
NULL, NULL, FilterMatch, Action, NULL);
|
|
}
|
|
|
|
#define vfatAddToStat(Vcb, Stat, Inc) \
|
|
{ \
|
|
PSTATISTICS Stats = &(Vcb)->Statistics[KeGetCurrentProcessorNumber() % VfatGlobalData->NumberProcessors]; \
|
|
Stats->Stat += Inc; \
|
|
}
|
|
|
|
/* blockdev.c */
|
|
|
|
NTSTATUS
|
|
VfatReadDisk(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PLARGE_INTEGER ReadOffset,
|
|
IN ULONG ReadLength,
|
|
IN PUCHAR Buffer,
|
|
IN BOOLEAN Override);
|
|
|
|
NTSTATUS
|
|
VfatReadDiskPartial(
|
|
IN PVFAT_IRP_CONTEXT IrpContext,
|
|
IN PLARGE_INTEGER ReadOffset,
|
|
IN ULONG ReadLength,
|
|
IN ULONG BufferOffset,
|
|
IN BOOLEAN Wait);
|
|
|
|
NTSTATUS
|
|
VfatWriteDisk(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PLARGE_INTEGER WriteOffset,
|
|
IN ULONG WriteLength,
|
|
IN OUT PUCHAR Buffer,
|
|
IN BOOLEAN Override);
|
|
|
|
NTSTATUS
|
|
VfatWriteDiskPartial(
|
|
IN PVFAT_IRP_CONTEXT IrpContext,
|
|
IN PLARGE_INTEGER WriteOffset,
|
|
IN ULONG WriteLength,
|
|
IN ULONG BufferOffset,
|
|
IN BOOLEAN Wait);
|
|
|
|
NTSTATUS
|
|
VfatBlockDeviceIoControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN ULONG CtlCode,
|
|
IN PVOID InputBuffer,
|
|
IN ULONG InputBufferSize,
|
|
IN OUT PVOID OutputBuffer,
|
|
IN OUT PULONG pOutputBufferSize,
|
|
IN BOOLEAN Override);
|
|
|
|
/* cleanup.c */
|
|
|
|
NTSTATUS
|
|
VfatCleanup(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
/* close.c */
|
|
|
|
NTSTATUS
|
|
VfatClose(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatCloseFile(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PFILE_OBJECT FileObject);
|
|
|
|
/* create.c */
|
|
|
|
NTSTATUS
|
|
VfatCreate(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
FindFile(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PVFATFCB Parent,
|
|
PUNICODE_STRING FileToFindU,
|
|
PVFAT_DIRENTRY_CONTEXT DirContext,
|
|
BOOLEAN First);
|
|
|
|
VOID
|
|
vfat8Dot3ToString(
|
|
PFAT_DIR_ENTRY pEntry,
|
|
PUNICODE_STRING NameU);
|
|
|
|
/* dir.c */
|
|
|
|
NTSTATUS
|
|
VfatDirectoryControl(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
BOOLEAN
|
|
FsdDosDateTimeToSystemTime(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
USHORT DosDate,
|
|
USHORT DosTime,
|
|
PLARGE_INTEGER SystemTime);
|
|
|
|
BOOLEAN
|
|
FsdSystemTimeToDosDateTime(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PLARGE_INTEGER SystemTime,
|
|
USHORT *pDosDate,
|
|
USHORT *pDosTime);
|
|
|
|
/* direntry.c */
|
|
|
|
ULONG
|
|
vfatDirEntryGetFirstCluster(
|
|
PDEVICE_EXTENSION pDeviceExt,
|
|
PDIR_ENTRY pDirEntry);
|
|
|
|
/* dirwr.c */
|
|
|
|
NTSTATUS
|
|
vfatFCBInitializeCacheFromVolume(
|
|
PVCB vcb,
|
|
PVFATFCB fcb);
|
|
|
|
NTSTATUS
|
|
VfatUpdateEntry(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
PVFATFCB pFcb);
|
|
|
|
BOOLEAN
|
|
vfatFindDirSpace(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PVFATFCB pDirFcb,
|
|
ULONG nbSlots,
|
|
PULONG start);
|
|
|
|
NTSTATUS
|
|
vfatRenameEntry(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
IN PVFATFCB pFcb,
|
|
IN PUNICODE_STRING FileName,
|
|
IN BOOLEAN CaseChangeOnly);
|
|
|
|
NTSTATUS
|
|
VfatMoveEntry(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
IN PVFATFCB pFcb,
|
|
IN PUNICODE_STRING FileName,
|
|
IN PVFATFCB ParentFcb);
|
|
|
|
/* ea.h */
|
|
|
|
NTSTATUS
|
|
VfatSetExtendedAttributes(
|
|
PFILE_OBJECT FileObject,
|
|
PVOID Ea,
|
|
ULONG EaLength);
|
|
|
|
/* fastio.c */
|
|
|
|
CODE_SEG("INIT")
|
|
VOID
|
|
VfatInitFastIoRoutines(
|
|
PFAST_IO_DISPATCH FastIoDispatch);
|
|
|
|
BOOLEAN
|
|
NTAPI
|
|
VfatAcquireForLazyWrite(
|
|
IN PVOID Context,
|
|
IN BOOLEAN Wait);
|
|
|
|
VOID
|
|
NTAPI
|
|
VfatReleaseFromLazyWrite(
|
|
IN PVOID Context);
|
|
|
|
/* fat.c */
|
|
|
|
NTSTATUS
|
|
FAT12GetNextCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG CurrentCluster,
|
|
PULONG NextCluster);
|
|
|
|
NTSTATUS
|
|
FAT12FindAndMarkAvailableCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PULONG Cluster);
|
|
|
|
NTSTATUS
|
|
FAT12WriteCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG ClusterToWrite,
|
|
ULONG NewValue,
|
|
PULONG OldValue);
|
|
|
|
NTSTATUS
|
|
FAT16GetNextCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG CurrentCluster,
|
|
PULONG NextCluster);
|
|
|
|
NTSTATUS
|
|
FAT16FindAndMarkAvailableCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PULONG Cluster);
|
|
|
|
NTSTATUS
|
|
FAT16WriteCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG ClusterToWrite,
|
|
ULONG NewValue,
|
|
PULONG OldValue);
|
|
|
|
NTSTATUS
|
|
FAT32GetNextCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG CurrentCluster,
|
|
PULONG NextCluster);
|
|
|
|
NTSTATUS
|
|
FAT32FindAndMarkAvailableCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PULONG Cluster);
|
|
|
|
NTSTATUS
|
|
FAT32WriteCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG ClusterToWrite,
|
|
ULONG NewValue,
|
|
PULONG OldValue);
|
|
|
|
NTSTATUS
|
|
OffsetToCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG FirstCluster,
|
|
ULONG FileOffset,
|
|
PULONG Cluster,
|
|
BOOLEAN Extend);
|
|
|
|
ULONGLONG
|
|
ClusterToSector(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG Cluster);
|
|
|
|
NTSTATUS
|
|
GetNextCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG CurrentCluster,
|
|
PULONG NextCluster);
|
|
|
|
NTSTATUS
|
|
GetNextClusterExtend(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG CurrentCluster,
|
|
PULONG NextCluster);
|
|
|
|
NTSTATUS
|
|
CountAvailableClusters(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PLARGE_INTEGER Clusters);
|
|
|
|
NTSTATUS
|
|
WriteCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG ClusterToWrite,
|
|
ULONG NewValue);
|
|
|
|
NTSTATUS
|
|
GetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PBOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
FAT16GetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PBOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
FAT32GetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PBOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
SetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
BOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
FAT16SetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
BOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
FAT32SetDirtyStatus(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
BOOLEAN DirtyStatus);
|
|
|
|
NTSTATUS
|
|
FAT32UpdateFreeClustersCount(
|
|
PDEVICE_EXTENSION DeviceExt);
|
|
|
|
/* fcb.c */
|
|
|
|
PVFATFCB
|
|
vfatNewFCB(
|
|
PDEVICE_EXTENSION pVCB,
|
|
PUNICODE_STRING pFileNameU);
|
|
|
|
NTSTATUS
|
|
vfatSetFCBNewDirName(
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB Fcb,
|
|
PVFATFCB ParentFcb);
|
|
|
|
NTSTATUS
|
|
vfatUpdateFCB(
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB Fcb,
|
|
PVFAT_DIRENTRY_CONTEXT DirContext,
|
|
PVFATFCB ParentFcb);
|
|
|
|
VOID
|
|
vfatDestroyFCB(
|
|
PVFATFCB pFCB);
|
|
|
|
VOID
|
|
vfatDestroyCCB(
|
|
PVFATCCB pCcb);
|
|
|
|
VOID
|
|
#ifndef KDBG
|
|
vfatGrabFCB(
|
|
#else
|
|
_vfatGrabFCB(
|
|
#endif
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB pFCB
|
|
#ifdef KDBG
|
|
,
|
|
PCSTR File,
|
|
ULONG Line,
|
|
PCSTR Func
|
|
#endif
|
|
);
|
|
|
|
VOID
|
|
#ifndef KDBG
|
|
vfatReleaseFCB(
|
|
#else
|
|
_vfatReleaseFCB(
|
|
#endif
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB pFCB
|
|
#ifdef KDBG
|
|
,
|
|
PCSTR File,
|
|
ULONG Line,
|
|
PCSTR Func
|
|
#endif
|
|
);
|
|
|
|
#ifdef KDBG
|
|
#define vfatGrabFCB(v, f) _vfatGrabFCB(v, f, __FILE__, __LINE__, __FUNCTION__)
|
|
#define vfatReleaseFCB(v, f) _vfatReleaseFCB(v, f, __FILE__, __LINE__, __FUNCTION__)
|
|
#endif
|
|
|
|
PVFATFCB
|
|
vfatGrabFCBFromTable(
|
|
PDEVICE_EXTENSION pDeviceExt,
|
|
PUNICODE_STRING pFileNameU);
|
|
|
|
PVFATFCB
|
|
vfatMakeRootFCB(
|
|
PDEVICE_EXTENSION pVCB);
|
|
|
|
PVFATFCB
|
|
vfatOpenRootFCB(
|
|
PDEVICE_EXTENSION pVCB);
|
|
|
|
BOOLEAN
|
|
vfatFCBIsDirectory(
|
|
PVFATFCB FCB);
|
|
|
|
BOOLEAN
|
|
vfatFCBIsRoot(
|
|
PVFATFCB FCB);
|
|
|
|
NTSTATUS
|
|
vfatAttachFCBToFileObject(
|
|
PDEVICE_EXTENSION vcb,
|
|
PVFATFCB fcb,
|
|
PFILE_OBJECT fileObject);
|
|
|
|
NTSTATUS
|
|
vfatDirFindFile(
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB parentFCB,
|
|
PUNICODE_STRING FileToFindU,
|
|
PVFATFCB *fileFCB);
|
|
|
|
NTSTATUS
|
|
vfatGetFCBForFile(
|
|
PDEVICE_EXTENSION pVCB,
|
|
PVFATFCB *pParentFCB,
|
|
PVFATFCB *pFCB,
|
|
PUNICODE_STRING pFileNameU);
|
|
|
|
NTSTATUS
|
|
vfatMakeFCBFromDirEntry(
|
|
PVCB vcb,
|
|
PVFATFCB directoryFCB,
|
|
PVFAT_DIRENTRY_CONTEXT DirContext,
|
|
PVFATFCB *fileFCB);
|
|
|
|
/* finfo.c */
|
|
|
|
NTSTATUS
|
|
VfatGetStandardInformation(
|
|
PVFATFCB FCB,
|
|
PFILE_STANDARD_INFORMATION StandardInfo,
|
|
PULONG BufferLength);
|
|
|
|
NTSTATUS
|
|
VfatGetBasicInformation(
|
|
PFILE_OBJECT FileObject,
|
|
PVFATFCB FCB,
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PFILE_BASIC_INFORMATION BasicInfo,
|
|
PULONG BufferLength);
|
|
|
|
NTSTATUS
|
|
VfatQueryInformation(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatSetInformation(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatSetAllocationSizeInformation(
|
|
PFILE_OBJECT FileObject,
|
|
PVFATFCB Fcb,
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PLARGE_INTEGER AllocationSize);
|
|
|
|
/* flush.c */
|
|
|
|
NTSTATUS
|
|
VfatFlush(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatFlushVolume(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
PVFATFCB VolumeFcb);
|
|
|
|
/* fsctl.c */
|
|
|
|
NTSTATUS
|
|
VfatFileSystemControl(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
/* iface.c */
|
|
|
|
CODE_SEG("INIT")
|
|
NTSTATUS
|
|
NTAPI
|
|
DriverEntry(
|
|
PDRIVER_OBJECT DriverObject,
|
|
PUNICODE_STRING RegistryPath);
|
|
|
|
#ifdef KDBG
|
|
/* kdbg.c */
|
|
KDBG_CLI_ROUTINE vfatKdbgHandler;
|
|
#endif
|
|
|
|
/* misc.c */
|
|
|
|
DRIVER_DISPATCH
|
|
VfatBuildRequest;
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VfatBuildRequest(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp);
|
|
|
|
PVOID
|
|
VfatGetUserBuffer(
|
|
IN PIRP Irp,
|
|
IN BOOLEAN Paging);
|
|
|
|
NTSTATUS
|
|
VfatLockUserBuffer(
|
|
IN PIRP Irp,
|
|
IN ULONG Length,
|
|
IN LOCK_OPERATION Operation);
|
|
|
|
BOOLEAN
|
|
VfatCheckForDismount(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
IN BOOLEAN Create);
|
|
|
|
VOID
|
|
vfatReportChange(
|
|
IN PDEVICE_EXTENSION DeviceExt,
|
|
IN PVFATFCB Fcb,
|
|
IN ULONG FilterMatch,
|
|
IN ULONG Action);
|
|
|
|
VOID
|
|
NTAPI
|
|
VfatHandleDeferredWrite(
|
|
IN PVOID IrpContext,
|
|
IN PVOID Unused);
|
|
|
|
/* pnp.c */
|
|
|
|
NTSTATUS
|
|
VfatPnp(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
/* rw.c */
|
|
|
|
NTSTATUS
|
|
VfatRead(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatWrite(
|
|
PVFAT_IRP_CONTEXT *pIrpContext);
|
|
|
|
NTSTATUS
|
|
NextCluster(
|
|
PDEVICE_EXTENSION DeviceExt,
|
|
ULONG FirstCluster,
|
|
PULONG CurrentCluster,
|
|
BOOLEAN Extend);
|
|
|
|
/* shutdown.c */
|
|
|
|
DRIVER_DISPATCH
|
|
VfatShutdown;
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
VfatShutdown(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp);
|
|
|
|
/* string.c */
|
|
|
|
VOID
|
|
vfatSplitPathName(
|
|
PUNICODE_STRING PathNameU,
|
|
PUNICODE_STRING DirNameU,
|
|
PUNICODE_STRING FileNameU);
|
|
|
|
BOOLEAN
|
|
vfatIsLongIllegal(
|
|
WCHAR c);
|
|
|
|
BOOLEAN
|
|
IsDotOrDotDot(
|
|
PCUNICODE_STRING Name);
|
|
|
|
/* volume.c */
|
|
|
|
NTSTATUS
|
|
VfatQueryVolumeInformation(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
VfatSetVolumeInformation(
|
|
PVFAT_IRP_CONTEXT IrpContext);
|
|
|
|
#endif /* _FASTFAT_PCH_ */
|