1606 lines
43 KiB
C
1606 lines
43 KiB
C
/*++
|
||
|
||
Copyright (c) 1989-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
FatStruc.h
|
||
|
||
Abstract:
|
||
|
||
This module defines the data structures that make up the major internal
|
||
part of the Fat file system.
|
||
|
||
// @@BEGIN_DDKSPLIT
|
||
|
||
Author:
|
||
|
||
Gary Kimura [GaryKi] 28-Dec-1989
|
||
|
||
Revision History:
|
||
|
||
// @@END_DDKSPLIT
|
||
|
||
--*/
|
||
|
||
#ifndef _FATSTRUC_
|
||
#define _FATSTRUC_
|
||
|
||
typedef PVOID PBCB; //**** Bcb's are now part of the cache module
|
||
|
||
|
||
//
|
||
// The FAT_DATA record is the top record in the Fat file system in-memory
|
||
// data structure. This structure must be allocated from non-paged pool.
|
||
//
|
||
|
||
typedef struct _FAT_DATA {
|
||
|
||
//
|
||
// The type and size of this record (must be FAT_NTC_DATA_HEADER)
|
||
//
|
||
|
||
NODE_TYPE_CODE NodeTypeCode;
|
||
NODE_BYTE_SIZE NodeByteSize;
|
||
|
||
|
||
PVOID LazyWriteThread;
|
||
|
||
|
||
//
|
||
// A queue of all the devices that are mounted by the file system.
|
||
//
|
||
|
||
LIST_ENTRY VcbQueue;
|
||
|
||
//
|
||
// A pointer to the Driver object we were initialized with
|
||
//
|
||
|
||
PDRIVER_OBJECT DriverObject;
|
||
|
||
//
|
||
// A pointer to the filesystem device objects we created.
|
||
//
|
||
|
||
PVOID DiskFileSystemDeviceObject;
|
||
PVOID CdromFileSystemDeviceObject;
|
||
|
||
//
|
||
// A resource variable to control access to the global Fat data record
|
||
//
|
||
|
||
ERESOURCE Resource;
|
||
|
||
//
|
||
// A pointer to our EPROCESS struct, which is a required input to the
|
||
// Cache Management subsystem.
|
||
//
|
||
|
||
PEPROCESS OurProcess;
|
||
|
||
//
|
||
// The following tells us if we should use Chicago extensions.
|
||
//
|
||
|
||
BOOLEAN ChicagoMode:1;
|
||
|
||
//
|
||
// The following field tells us if we are running on a Fujitsu
|
||
// FMR Series. These machines supports extra formats on the
|
||
// FAT file system.
|
||
//
|
||
|
||
BOOLEAN FujitsuFMR:1;
|
||
|
||
//
|
||
// Inidicates that FspClose is currently processing closes.
|
||
//
|
||
|
||
BOOLEAN AsyncCloseActive:1;
|
||
|
||
//
|
||
// The following BOOLEAN says shutdown has started on FAT. It
|
||
// instructs FspClose to not keep the Vcb resources anymore.
|
||
//
|
||
|
||
BOOLEAN ShutdownStarted:1;
|
||
|
||
//
|
||
// The following flag tells us if we are going to generate LFNs
|
||
// for valid 8.3 names with extended characters.
|
||
//
|
||
|
||
BOOLEAN CodePageInvariant:1;
|
||
|
||
//
|
||
// The following flags tell us if we are in an aggresive push to lower
|
||
// the size of the deferred close queues.
|
||
//
|
||
|
||
BOOLEAN HighAsync:1;
|
||
BOOLEAN HighDelayed:1;
|
||
|
||
//
|
||
// The following list entry is used for performing closes that can't
|
||
// be done in the context of the original caller.
|
||
//
|
||
|
||
ULONG AsyncCloseCount;
|
||
LIST_ENTRY AsyncCloseList;
|
||
|
||
//
|
||
// The following two fields record if we are delaying a close.
|
||
//
|
||
|
||
ULONG DelayedCloseCount;
|
||
LIST_ENTRY DelayedCloseList;
|
||
|
||
//
|
||
// This is the ExWorkerItem that does both kinds of deferred closes.
|
||
//
|
||
|
||
PIO_WORKITEM FatCloseItem;
|
||
|
||
//
|
||
// This spinlock protects several rapid-fire operations. NOTE: this is
|
||
// pretty horrible style.
|
||
//
|
||
|
||
KSPIN_LOCK GeneralSpinLock;
|
||
|
||
//
|
||
// Cache manager call back structures, which must be passed on each call
|
||
// to CcInitializeCacheMap.
|
||
//
|
||
|
||
CACHE_MANAGER_CALLBACKS CacheManagerCallbacks;
|
||
CACHE_MANAGER_CALLBACKS CacheManagerNoOpCallbacks;
|
||
|
||
} FAT_DATA;
|
||
typedef FAT_DATA *PFAT_DATA;
|
||
|
||
//
|
||
// An array of these structures will keep
|
||
|
||
typedef struct _FAT_WINDOW {
|
||
|
||
ULONG FirstCluster; // The first cluster in this window.
|
||
ULONG LastCluster; // The last cluster in this window.
|
||
ULONG ClustersFree; // The number of clusters free in this window.
|
||
|
||
} FAT_WINDOW;
|
||
typedef FAT_WINDOW *PFAT_WINDOW;
|
||
|
||
|
||
//
|
||
// The Vcb (Volume control Block) record corresponds to every volume mounted
|
||
// by the file system. They are ordered in a queue off of FatData.VcbQueue.
|
||
// This structure must be allocated from non-paged pool
|
||
//
|
||
|
||
typedef enum _VCB_CONDITION {
|
||
VcbGood = 1,
|
||
VcbNotMounted,
|
||
VcbBad
|
||
} VCB_CONDITION;
|
||
|
||
typedef struct _VCB {
|
||
|
||
//
|
||
// This is a common head for the FAT volume file
|
||
//
|
||
|
||
FSRTL_ADVANCED_FCB_HEADER VolumeFileHeader;
|
||
|
||
//
|
||
// The links for the device queue off of FatData.VcbQueue
|
||
//
|
||
|
||
LIST_ENTRY VcbLinks;
|
||
|
||
//
|
||
// A pointer the device object passed in by the I/O system on a mount
|
||
// This is the target device object that the file system talks to when it
|
||
// needs to do any I/O (e.g., the disk stripper device object).
|
||
//
|
||
//
|
||
|
||
PDEVICE_OBJECT TargetDeviceObject;
|
||
|
||
//
|
||
// A pointer to the VPB for the volume passed in by the I/O system on
|
||
// a mount.
|
||
//
|
||
|
||
PVPB Vpb;
|
||
|
||
//
|
||
// The internal state of the device. This is a collection of fsd device
|
||
// state flags.
|
||
//
|
||
|
||
ULONG VcbState;
|
||
VCB_CONDITION VcbCondition;
|
||
|
||
//
|
||
// A pointer to the root DCB for this volume
|
||
//
|
||
|
||
struct _FCB *RootDcb;
|
||
|
||
//
|
||
// If the FAT has so many entries that the free cluster bitmap would
|
||
// be too large, we split the FAT into buckets, and only one bucket's
|
||
// worth of bits are kept in the bitmap.
|
||
//
|
||
|
||
ULONG NumberOfWindows;
|
||
PFAT_WINDOW Windows;
|
||
PFAT_WINDOW CurrentWindow;
|
||
|
||
//
|
||
// A count of the number of file objects that have opened the volume
|
||
// for direct access, and their share access state.
|
||
//
|
||
|
||
CLONG DirectAccessOpenCount;
|
||
SHARE_ACCESS ShareAccess;
|
||
|
||
//
|
||
// A count of the number of file objects that have any file/directory
|
||
// opened on this volume, not including direct access. And also the
|
||
// count of the number of file objects that have a file opened for
|
||
// only read access (i.e., they cannot be modifying the disk).
|
||
//
|
||
|
||
CLONG OpenFileCount;
|
||
CLONG ReadOnlyCount;
|
||
|
||
//
|
||
// The bios parameter block field contains
|
||
// an unpacked copy of the bpb for the volume, it is initialized
|
||
// during mount time and can be read by everyone else after that.
|
||
//
|
||
|
||
BIOS_PARAMETER_BLOCK Bpb;
|
||
|
||
PUCHAR First0x24BytesOfBootSector;
|
||
|
||
//
|
||
// The following structure contains information useful to the
|
||
// allocation support routines. Many of them are computed from
|
||
// elements of the Bpb, but are too involved to recompute every time
|
||
// they are needed.
|
||
//
|
||
|
||
struct {
|
||
|
||
LBO RootDirectoryLbo; // Lbo of beginning of root directory
|
||
LBO FileAreaLbo; // Lbo of beginning of file area
|
||
ULONG RootDirectorySize; // size of root directory in bytes
|
||
|
||
ULONG NumberOfClusters; // total number of clusters on the volume
|
||
ULONG NumberOfFreeClusters; // number of free clusters on the volume
|
||
|
||
UCHAR FatIndexBitSize; // indicates if 12, 16, or 32 bit fat table
|
||
|
||
UCHAR LogOfBytesPerSector; // Log(Bios->BytesPerSector)
|
||
UCHAR LogOfBytesPerCluster; // Log(Bios->SectorsPerCluster)
|
||
|
||
} AllocationSupport;
|
||
|
||
//
|
||
// The following Mcb is used to keep track of dirty sectors in the Fat.
|
||
// Runs of holes denote clean sectors while runs of LBO == VBO denote
|
||
// dirty sectors. The VBOs are that of the volume file, starting at
|
||
// 0. The granuality of dirt is one sectors, and additions are only
|
||
// made in sector chunks to prevent problems with several simultaneous
|
||
// updaters.
|
||
//
|
||
|
||
LARGE_MCB DirtyFatMcb;
|
||
|
||
//
|
||
// The FreeClusterBitMap keeps track of all the clusters in the fat.
|
||
// A 1 means occupied while a 0 means free. It allows quick location
|
||
// of contiguous runs of free clusters. It is initialized on mount
|
||
// or verify.
|
||
//
|
||
|
||
RTL_BITMAP FreeClusterBitMap;
|
||
|
||
//
|
||
// The following fast mutex controls access to the free cluster bit map
|
||
// and the buckets.
|
||
//
|
||
|
||
FAST_MUTEX FreeClusterBitMapMutex;
|
||
|
||
//
|
||
// A resource variable to control access to the volume specific data
|
||
// structures
|
||
//
|
||
|
||
ERESOURCE Resource;
|
||
|
||
//
|
||
// A resource to make sure no one changes the volume bitmap while
|
||
// you're using it. Only for volumes with NumberOfWindows > 1.
|
||
//
|
||
|
||
ERESOURCE ChangeBitMapResource;
|
||
|
||
|
||
//
|
||
// The following field points to the file object used to do I/O to
|
||
// the virtual volume file. The virtual volume file maps sectors
|
||
// 0 through the end of fat and is of a fixed size (determined during
|
||
// mount)
|
||
//
|
||
|
||
PFILE_OBJECT VirtualVolumeFile;
|
||
|
||
//
|
||
// The following field contains a record of special pointers used by
|
||
// MM and Cache to manipluate section objects. Note that the values
|
||
// are set outside of the file system. However the file system on an
|
||
// open/create will set the file object's SectionObject field to point
|
||
// to this field
|
||
//
|
||
|
||
SECTION_OBJECT_POINTERS SectionObjectPointers;
|
||
|
||
//
|
||
// The following fields is a hint cluster index used by the file system
|
||
// when allocating a new cluster.
|
||
//
|
||
|
||
ULONG ClusterHint;
|
||
|
||
//
|
||
// This field contains the "DeviceObject" that this volume is
|
||
// currently mounted on. Note Vcb->Vpb->RealDevice is constant.
|
||
//
|
||
|
||
PDEVICE_OBJECT CurrentDevice;
|
||
|
||
//
|
||
// This is a pointer to the file object and the Fcb which represent the ea data.
|
||
//
|
||
|
||
PFILE_OBJECT VirtualEaFile;
|
||
struct _FCB *EaFcb;
|
||
|
||
//
|
||
// The following field is a pointer to the file object that has the
|
||
// volume locked. if the VcbState has the locked flag set.
|
||
//
|
||
|
||
PFILE_OBJECT FileObjectWithVcbLocked;
|
||
|
||
//
|
||
// The following is the head of a list of notify Irps.
|
||
//
|
||
|
||
LIST_ENTRY DirNotifyList;
|
||
|
||
//
|
||
// The following is used to synchronize the dir notify list.
|
||
//
|
||
|
||
PNOTIFY_SYNC NotifySync;
|
||
|
||
//
|
||
// The following fast mutex is used to synchronize directory stream
|
||
// file object creation.
|
||
//
|
||
|
||
FAST_MUTEX DirectoryFileCreationMutex;
|
||
|
||
//
|
||
// This field holds the thread address of the current (or most recent
|
||
// depending on VcbState) thread doing a verify operation on this volume.
|
||
//
|
||
|
||
PKTHREAD VerifyThread;
|
||
|
||
//
|
||
// The following two structures are used for CleanVolume callbacks.
|
||
//
|
||
|
||
KDPC CleanVolumeDpc;
|
||
KTIMER CleanVolumeTimer;
|
||
|
||
//
|
||
// This field records the last time FatMarkVolumeDirty was called, and
|
||
// avoids excessive calls to push the CleanVolume forward in time.
|
||
//
|
||
|
||
LARGE_INTEGER LastFatMarkVolumeDirtyCall;
|
||
|
||
//
|
||
// The following fields holds a pointer to a struct which is used to
|
||
// hold performance counters.
|
||
//
|
||
|
||
struct _FILE_SYSTEM_STATISTICS *Statistics;
|
||
|
||
//
|
||
// The property tunneling cache for this volume
|
||
//
|
||
|
||
TUNNEL Tunnel;
|
||
|
||
//
|
||
// The media change count is returned by IOCTL_CHECK_VERIFY and
|
||
// is used to verify that no user-mode app has swallowed a media change
|
||
// notification. This is only meaningful for removable media.
|
||
//
|
||
|
||
ULONG ChangeCount;
|
||
|
||
//
|
||
// Preallocated VPB for swapout, so we are not forced to consider
|
||
// must succeed pool.
|
||
//
|
||
|
||
PVPB SwapVpb;
|
||
|
||
//
|
||
// Per volume threading of the close queues.
|
||
//
|
||
|
||
LIST_ENTRY AsyncCloseList;
|
||
LIST_ENTRY DelayedCloseList;
|
||
|
||
//
|
||
// Fast mutex used by the ADVANCED FCB HEADER in this structure
|
||
//
|
||
|
||
FAST_MUTEX AdvancedFcbHeaderMutex;
|
||
|
||
} VCB;
|
||
typedef VCB *PVCB;
|
||
|
||
#define VCB_STATE_FLAG_LOCKED (0x00000001)
|
||
#define VCB_STATE_FLAG_REMOVABLE_MEDIA (0x00000002)
|
||
#define VCB_STATE_FLAG_VOLUME_DIRTY (0x00000004)
|
||
#define VCB_STATE_FLAG_MOUNTED_DIRTY (0x00000010)
|
||
#define VCB_STATE_FLAG_SHUTDOWN (0x00000040)
|
||
#define VCB_STATE_FLAG_CLOSE_IN_PROGRESS (0x00000080)
|
||
#define VCB_STATE_FLAG_DELETED_FCB (0x00000100)
|
||
#define VCB_STATE_FLAG_CREATE_IN_PROGRESS (0x00000200)
|
||
#define VCB_STATE_FLAG_BOOT_OR_PAGING_FILE (0x00000800)
|
||
#define VCB_STATE_FLAG_DEFERRED_FLUSH (0x00001000)
|
||
#define VCB_STATE_FLAG_ASYNC_CLOSE_ACTIVE (0x00002000)
|
||
#define VCB_STATE_FLAG_WRITE_PROTECTED (0x00004000)
|
||
#define VCB_STATE_FLAG_REMOVAL_PREVENTED (0x00008000)
|
||
#define VCB_STATE_FLAG_VOLUME_DISMOUNTED (0x00010000)
|
||
|
||
//
|
||
// N.B - VOLUME_DISMOUNTED is an indication that FSCTL_DISMOUNT volume was
|
||
// executed on a volume. It does not replace VcbCondition as an indication
|
||
// that the volume is invalid/unrecoverable.
|
||
//
|
||
|
||
//
|
||
// Define the file system statistics struct. Vcb->Statistics points to an
|
||
// array of these (one per processor) and they must be 64 byte aligned to
|
||
// prevent cache line tearing.
|
||
//
|
||
|
||
typedef struct _FILE_SYSTEM_STATISTICS {
|
||
|
||
//
|
||
// This contains the actual data.
|
||
//
|
||
|
||
FILESYSTEM_STATISTICS Common;
|
||
FAT_STATISTICS Fat;
|
||
|
||
//
|
||
// Pad this structure to a multiple of 64 bytes.
|
||
//
|
||
|
||
UCHAR Pad[64-(sizeof(FILESYSTEM_STATISTICS)+sizeof(FAT_STATISTICS))%64];
|
||
|
||
} FILE_SYSTEM_STATISTICS;
|
||
|
||
typedef FILE_SYSTEM_STATISTICS *PFILE_SYSTEM_STATISTICS;
|
||
|
||
|
||
//
|
||
// The Volume Device Object is an I/O system device object with a workqueue
|
||
// and an VCB record appended to the end. There are multiple of these
|
||
// records, one for every mounted volume, and are created during
|
||
// a volume mount operation. The work queue is for handling an overload of
|
||
// work requests to the volume.
|
||
//
|
||
|
||
typedef struct _VOLUME_DEVICE_OBJECT {
|
||
|
||
DEVICE_OBJECT DeviceObject;
|
||
|
||
//
|
||
// The following field tells how many requests for this volume have
|
||
// either been enqueued to ExWorker threads or are currently being
|
||
// serviced by ExWorker threads. If the number goes above
|
||
// a certain threshold, put the request on the overflow queue to be
|
||
// executed later.
|
||
//
|
||
|
||
ULONG PostedRequestCount;
|
||
|
||
//
|
||
// The following field indicates the number of IRP's waiting
|
||
// to be serviced in the overflow queue.
|
||
//
|
||
|
||
ULONG OverflowQueueCount;
|
||
|
||
//
|
||
// The following field contains the queue header of the overflow queue.
|
||
// The Overflow queue is a list of IRP's linked via the IRP's ListEntry
|
||
// field.
|
||
//
|
||
|
||
LIST_ENTRY OverflowQueue;
|
||
|
||
//
|
||
// The following spinlock protects access to all the above fields.
|
||
//
|
||
|
||
KSPIN_LOCK OverflowQueueSpinLock;
|
||
|
||
//
|
||
// This is a common head for the FAT volume file
|
||
//
|
||
|
||
FSRTL_COMMON_FCB_HEADER VolumeFileHeader;
|
||
|
||
//
|
||
// This is the file system specific volume control block.
|
||
//
|
||
|
||
VCB Vcb;
|
||
|
||
} VOLUME_DEVICE_OBJECT;
|
||
|
||
typedef VOLUME_DEVICE_OBJECT *PVOLUME_DEVICE_OBJECT;
|
||
|
||
|
||
//
|
||
// This is the structure used to contains the short name for a file
|
||
//
|
||
|
||
typedef struct _FILE_NAME_NODE {
|
||
|
||
//
|
||
// This points back to the Fcb for this file.
|
||
//
|
||
|
||
struct _FCB *Fcb;
|
||
|
||
//
|
||
// This is the name of this node.
|
||
//
|
||
|
||
union {
|
||
|
||
OEM_STRING Oem;
|
||
|
||
UNICODE_STRING Unicode;
|
||
|
||
} Name;
|
||
|
||
//
|
||
// Marker so we can figure out what kind of name we opened up in
|
||
// Fcb searches
|
||
//
|
||
|
||
BOOLEAN FileNameDos;
|
||
|
||
//
|
||
// And the links. Our parent Dcb has a pointer to the root entry.
|
||
//
|
||
|
||
RTL_SPLAY_LINKS Links;
|
||
|
||
} FILE_NAME_NODE;
|
||
typedef FILE_NAME_NODE *PFILE_NAME_NODE;
|
||
|
||
//
|
||
// This structure contains fields which must be in non-paged pool.
|
||
//
|
||
|
||
typedef struct _NON_PAGED_FCB {
|
||
|
||
//
|
||
// The following field contains a record of special pointers used by
|
||
// MM and Cache to manipluate section objects. Note that the values
|
||
// are set outside of the file system. However the file system on an
|
||
// open/create will set the file object's SectionObject field to point
|
||
// to this field
|
||
//
|
||
|
||
SECTION_OBJECT_POINTERS SectionObjectPointers;
|
||
|
||
//
|
||
// This context is non-zero only if the file currently has asynchronous
|
||
// non-cached valid data length extending writes. It allows
|
||
// synchronization between pending writes and other operations.
|
||
//
|
||
|
||
ULONG OutstandingAsyncWrites;
|
||
|
||
//
|
||
// This event is set when OutstandingAsyncWrites transitions to zero.
|
||
//
|
||
|
||
PKEVENT OutstandingAsyncEvent;
|
||
|
||
//
|
||
// This is the mutex that is inserted into the FCB_ADVANCED_HEADER
|
||
// FastMutex field
|
||
//
|
||
|
||
FAST_MUTEX AdvancedFcbHeaderMutex;
|
||
|
||
} NON_PAGED_FCB;
|
||
|
||
typedef NON_PAGED_FCB *PNON_PAGED_FCB;
|
||
|
||
//
|
||
// The Fcb/Dcb record corresponds to every open file and directory, and to
|
||
// every directory on an opened path. They are ordered in two queues, one
|
||
// queue contains every Fcb/Dcb record off of FatData.FcbQueue, the other
|
||
// queue contains only device specific records off of Vcb.VcbSpecificFcbQueue
|
||
//
|
||
|
||
typedef enum _FCB_CONDITION {
|
||
FcbGood = 1,
|
||
FcbBad,
|
||
FcbNeedsToBeVerified
|
||
} FCB_CONDITION;
|
||
|
||
typedef struct _FCB {
|
||
|
||
//
|
||
// The following field is used for fast I/O
|
||
//
|
||
// The following comments refer to the use of the AllocationSize field
|
||
// of the FsRtl-defined header to the nonpaged Fcb.
|
||
//
|
||
// For a directory when we create a Dcb we will not immediately
|
||
// initialize the cache map, instead we will postpone it until our first
|
||
// call to FatReadDirectoryFile or FatPrepareWriteDirectoryFile.
|
||
// At that time we will search the Fat to find out the current allocation
|
||
// size (by calling FatLookupFileAllocationSize) and then initialize the
|
||
// cache map to this allocation size.
|
||
//
|
||
// For a file when we create an Fcb we will not immediately initialize
|
||
// the cache map, instead we will postpone it until we need it and
|
||
// then we determine the allocation size from either searching the
|
||
// fat to determine the real file allocation, or from the allocation
|
||
// that we've just allocated if we're creating a file.
|
||
//
|
||
// A value of -1 indicates that we do not know what the current allocation
|
||
// size really is, and need to examine the fat to find it. A value
|
||
// of than -1 is the real file/directory allocation size.
|
||
//
|
||
// Whenever we need to extend the allocation size we call
|
||
// FatAddFileAllocation which (if we're really extending the allocation)
|
||
// will modify the Fat, Mcb, and update this field. The caller
|
||
// of FatAddFileAllocation is then responsible for altering the Cache
|
||
// map size.
|
||
//
|
||
// We are now using the ADVANCED fcb header to support filter contexts
|
||
// at the stream level
|
||
//
|
||
|
||
FSRTL_ADVANCED_FCB_HEADER Header;
|
||
|
||
//
|
||
// This structure contains fields which must be in non-paged pool.
|
||
//
|
||
|
||
PNON_PAGED_FCB NonPaged;
|
||
|
||
//
|
||
// The head of the fat alloaction chain. FirstClusterOfFile == 0
|
||
// means that the file has no current allocation.
|
||
//
|
||
|
||
ULONG FirstClusterOfFile;
|
||
|
||
//
|
||
// The links for the queue of all fcbs for a specific dcb off of
|
||
// Dcb.ParentDcbQueue. For the root directory this queue is empty
|
||
// For a non-existent fcb this queue is off of the non existent
|
||
// fcb queue entry in the vcb.
|
||
//
|
||
|
||
LIST_ENTRY ParentDcbLinks;
|
||
|
||
//
|
||
// A pointer to the Dcb that is the parent directory containing
|
||
// this fcb. If this record itself is the root dcb then this field
|
||
// is null.
|
||
//
|
||
|
||
struct _FCB *ParentDcb;
|
||
|
||
//
|
||
// A pointer to the Vcb containing this Fcb
|
||
//
|
||
|
||
PVCB Vcb;
|
||
|
||
//
|
||
// The internal state of the Fcb. This is a collection Fcb state flags.
|
||
// Also the shared access for each time this file/directory is opened.
|
||
//
|
||
|
||
ULONG FcbState;
|
||
FCB_CONDITION FcbCondition;
|
||
SHARE_ACCESS ShareAccess;
|
||
|
||
#ifdef SYSCACHE_COMPILE
|
||
|
||
//
|
||
// For syscache we keep a bitmask that tells us if we have dispatched IO for
|
||
// the page aligned chunks of the stream.
|
||
//
|
||
|
||
PULONG WriteMask;
|
||
ULONG WriteMaskData;
|
||
|
||
#endif
|
||
|
||
//
|
||
// A count of the number of file objects that have been opened for
|
||
// this file/directory, but not yet been cleaned up yet. This count
|
||
// is only used for data file objects, not for the Acl or Ea stream
|
||
// file objects. This count gets decremented in FatCommonCleanup,
|
||
// while the OpenCount below gets decremented in FatCommonClose.
|
||
//
|
||
|
||
CLONG UncleanCount;
|
||
|
||
//
|
||
// A count of the number of file objects that have opened
|
||
// this file/directory. For files & directories the FsContext of the
|
||
// file object points to this record.
|
||
//
|
||
|
||
CLONG OpenCount;
|
||
|
||
//
|
||
// A count of how many of "UncleanCount" handles were opened for
|
||
// non-cached I/O.
|
||
//
|
||
|
||
CLONG NonCachedUncleanCount;
|
||
|
||
//
|
||
// The following field is used to locate the dirent for this fcb/dcb.
|
||
// All directory are opened as mapped files so the only additional
|
||
// information we need to locate this dirent (beside its parent directory)
|
||
// is the byte offset for the dirent. Note that for the root dcb
|
||
// this field is not used.
|
||
//
|
||
|
||
VBO DirentOffsetWithinDirectory;
|
||
|
||
//
|
||
// The following field is filled in when there is an Lfn associated
|
||
// with this file. It is the STARTING offset of the Lfn.
|
||
//
|
||
|
||
VBO LfnOffsetWithinDirectory;
|
||
|
||
//
|
||
// Thess entries is kept in ssync with the dirent. It allows a more
|
||
// accurate verify capability and speeds up FatFastQueryBasicInfo().
|
||
//
|
||
|
||
LARGE_INTEGER CreationTime;
|
||
LARGE_INTEGER LastAccessTime;
|
||
LARGE_INTEGER LastWriteTime;
|
||
|
||
//
|
||
// Valid data to disk
|
||
//
|
||
|
||
ULONG ValidDataToDisk;
|
||
|
||
//
|
||
// The following field contains the retrieval mapping structure
|
||
// for the file/directory. Note that for the Root Dcb this
|
||
// structure is set at mount time. Also note that in this
|
||
// implementation of Fat the Mcb really maps VBOs to LBOs and not
|
||
// VBNs to LBNs.
|
||
//
|
||
|
||
LARGE_MCB Mcb;
|
||
|
||
//
|
||
// The following union is cased off of the node type code for the fcb.
|
||
// There is a seperate case for the directory versus file fcbs.
|
||
//
|
||
|
||
union {
|
||
|
||
//
|
||
// A Directory Control Block (Dcb)
|
||
//
|
||
|
||
struct {
|
||
|
||
//
|
||
// A queue of all the fcbs/dcbs that are opened under this
|
||
// Dcb.
|
||
//
|
||
|
||
LIST_ENTRY ParentDcbQueue;
|
||
|
||
//
|
||
// The following field points to the file object used to do I/O to
|
||
// the directory file for this dcb. The directory file maps the
|
||
// sectors for the directory. This field is initialized by
|
||
// CreateRootDcb but is left null by CreateDcb. It isn't
|
||
// until we try to read/write the directory file that we
|
||
// create the stream file object for non root dcbs.
|
||
//
|
||
|
||
ULONG DirectoryFileOpenCount;
|
||
PFILE_OBJECT DirectoryFile;
|
||
|
||
//
|
||
// If the UnusedDirentVbo is != 0xffffffff, then the dirent at this
|
||
// offset is guarenteed to unused. A value of 0xffffffff means
|
||
// it has yet to be initialized. Note that a value beyond the
|
||
// end of allocation means that there an unused dirent, but we
|
||
// will have to allocate another cluster to use it.
|
||
//
|
||
// DeletedDirentHint contains lowest possible VBO of a deleted
|
||
// dirent (assuming as above that it is not 0xffffffff).
|
||
//
|
||
|
||
VBO UnusedDirentVbo;
|
||
VBO DeletedDirentHint;
|
||
|
||
//
|
||
// The following two entries links together all the Fcbs
|
||
// opened under this Dcb sorted in a splay tree by name.
|
||
//
|
||
// I'd like to go into why we have (and must have) two separate
|
||
// splay trees within the current fastfat architecture. I will
|
||
// provide some insight into what would have to change if we
|
||
// wanted to have a single UNICODE tree.
|
||
//
|
||
// What makes FAT unique is that both Oem and Unicode names sit
|
||
// side by side on disk. Several unique UNICODE names coming
|
||
// into fastfat can match a single OEM on-disk name, and there
|
||
// is really no way to enumerate all the possible UNICODE
|
||
// source strings that can map to a given OEM name. This argues
|
||
// for converting the incomming UNICODE name into OEM, and then
|
||
// running through an OEM splay tree of the open files. This
|
||
// works well when there are only OEM names on disk.
|
||
//
|
||
// The UNICODE name on disk can be VERY different from the short
|
||
// name in the DIRENT and not even representable in the OEM code
|
||
// page. Even if it were representable in OEM, it is possible
|
||
// that a case varient of the original UNICODE name would match
|
||
// a different OEM name, causing us to miss the Fcb in the
|
||
// prefix lookup phase. In these cases, we must put UNICODE
|
||
// name in the splay to guarentee that we find any case varient
|
||
// of the input UNICODE name. See the routine description of
|
||
// FatConstructNamesInFcb() for a detailed analysis of how we
|
||
// detect this case.
|
||
//
|
||
// The fundamental limitation we are imposing here is that if
|
||
// an Fcb exists for an open file, we MUST find it during the
|
||
// prefix stage. This is a basic premise of the create path
|
||
// in fastfat. In fact if we later find it gravelling through
|
||
// the disk (but not the splay tree), we will bug check if we
|
||
// try to add a duplicate entry to the splay tree (not to
|
||
// mention having two Fcbs). If we had some mechanism to deal
|
||
// with cases (and they would be rare) that we don't find the
|
||
// entry in the splay tree, but the Fcb is actually in there,
|
||
// then we could go to a single UNICODE splay tree. While
|
||
// this uses more pool for the splay tree, and makes string
|
||
// compares maybe take a bit as longer, it would eliminate the
|
||
// need for any NLS conversion during the prefix phase, so it
|
||
// might really be a net win.
|
||
//
|
||
// The current scheme was optimized for non-extended names
|
||
// (i.e. US names). As soon as you start using extended
|
||
// characters, then it is clearly a win as many code paths
|
||
// become active that would otherwise not be needed if we
|
||
// only had a single UNICODE splay tree.
|
||
//
|
||
// We may think about changing this someday.
|
||
//
|
||
|
||
PRTL_SPLAY_LINKS RootOemNode;
|
||
PRTL_SPLAY_LINKS RootUnicodeNode;
|
||
|
||
//
|
||
// The following field keeps track of free dirents, i.e.,
|
||
// dirents that are either unallocated for deleted.
|
||
//
|
||
|
||
RTL_BITMAP FreeDirentBitmap;
|
||
|
||
//
|
||
// Since the FCB specific part of this union is larger, use
|
||
// the slack here for an initial bitmap buffer. Currently
|
||
// there is enough space here for an 8K cluster.
|
||
//
|
||
|
||
ULONG FreeDirentBitmapBuffer[1];
|
||
|
||
} Dcb;
|
||
|
||
//
|
||
// A File Control Block (Fcb)
|
||
//
|
||
|
||
struct {
|
||
|
||
//
|
||
// The following field is used by the filelock module
|
||
// to maintain current byte range locking information.
|
||
//
|
||
|
||
FILE_LOCK FileLock;
|
||
|
||
//
|
||
// The following field is used by the oplock module
|
||
// to maintain current oplock information.
|
||
//
|
||
|
||
OPLOCK Oplock;
|
||
|
||
//
|
||
// This pointer is used to detect writes that eminated in the
|
||
// cache manager's lazywriter. It prevents lazy writer threads,
|
||
// who already have the Fcb shared, from trying to acquire it
|
||
// exclusive, and thus causing a deadlock.
|
||
//
|
||
|
||
PVOID LazyWriteThread;
|
||
|
||
} Fcb;
|
||
|
||
} Specific;
|
||
|
||
//
|
||
// The following field is used to verify that the Ea's for a file
|
||
// have not changed between calls to query for Ea's. It is compared
|
||
// with a similar field in a Ccb.
|
||
//
|
||
// IMPORTANT!! **** DO NOT MOVE THIS FIELD ****
|
||
//
|
||
// The slack space in the union above is computed from
|
||
// the field offset of the EaModificationCount.
|
||
//
|
||
|
||
ULONG EaModificationCount;
|
||
|
||
//
|
||
// The following field is the fully qualified file name for this FCB/DCB
|
||
// starting from the root of the volume, and last file name in the
|
||
// fully qualified name.
|
||
//
|
||
|
||
FILE_NAME_NODE ShortName;
|
||
|
||
//
|
||
// The following field is only filled in if it is needed with the user's
|
||
// opened path
|
||
//
|
||
|
||
UNICODE_STRING FullFileName;
|
||
|
||
USHORT FinalNameLength;
|
||
|
||
//
|
||
// To make life simpler we also keep in the Fcb/Dcb a current copy of
|
||
// the fat attribute byte for the file/directory. This field must
|
||
// also be updated when we create the Fcb, modify the File, or verify
|
||
// the Fcb
|
||
//
|
||
|
||
UCHAR DirentFatFlags;
|
||
|
||
//
|
||
// The case preserved long filename
|
||
//
|
||
|
||
UNICODE_STRING ExactCaseLongName;
|
||
|
||
//
|
||
// If the UNICODE Lfn is fully expressible in the system Oem code
|
||
// page, then we will store it in a prefix table, otherwise we will
|
||
// store the last UNICODE name in the Fcb. In both cases the name
|
||
// has been upcased.
|
||
//
|
||
// Note that we may need neither of these fields if an LFN was strict
|
||
// 8.3 or differed only in case. Indeed if there wasn't an LFN, we
|
||
// don't need them at all.
|
||
//
|
||
|
||
union {
|
||
|
||
//
|
||
// This first field is present if FCB_STATE_HAS_OEM_LONG_NAME
|
||
// is set in the FcbState.
|
||
//
|
||
|
||
FILE_NAME_NODE Oem;
|
||
|
||
//
|
||
// This first field is present if FCB_STATE_HAS_UNICODE_LONG_NAME
|
||
// is set in the FcbState.
|
||
//
|
||
|
||
FILE_NAME_NODE Unicode;
|
||
|
||
} LongName;
|
||
|
||
//
|
||
// Defragmentation / ReallocateOnWrite synchronization object. This
|
||
// is filled in by FatMoveFile() and affects the read and write paths.
|
||
//
|
||
|
||
PKEVENT MoveFileEvent;
|
||
|
||
} FCB, *PFCB;
|
||
|
||
#ifndef BUILDING_FSKDEXT
|
||
//
|
||
// DCB clashes with a type defined outside the filesystems, in headers
|
||
// pulled in by FSKD. We don't need this typedef for fskd anyway....
|
||
//
|
||
typedef FCB DCB;
|
||
typedef DCB *PDCB;
|
||
#endif
|
||
|
||
|
||
//
|
||
// Here are the Fcb state fields.
|
||
//
|
||
|
||
#define FCB_STATE_DELETE_ON_CLOSE (0x00000001)
|
||
#define FCB_STATE_TRUNCATE_ON_CLOSE (0x00000002)
|
||
#define FCB_STATE_PAGING_FILE (0x00000004)
|
||
#define FCB_STATE_FORCE_MISS_IN_PROGRESS (0x00000008)
|
||
#define FCB_STATE_FLUSH_FAT (0x00000010)
|
||
#define FCB_STATE_TEMPORARY (0x00000020)
|
||
#define FCB_STATE_SYSTEM_FILE (0x00000080)
|
||
#define FCB_STATE_NAMES_IN_SPLAY_TREE (0x00000100)
|
||
#define FCB_STATE_HAS_OEM_LONG_NAME (0x00000200)
|
||
#define FCB_STATE_HAS_UNICODE_LONG_NAME (0x00000400)
|
||
#define FCB_STATE_DELAY_CLOSE (0x00000800)
|
||
|
||
//
|
||
// Copies of the dirent's FAT_DIRENT_NT_BYTE_* flags for
|
||
// preserving case of the short name of a file
|
||
//
|
||
|
||
#define FCB_STATE_8_LOWER_CASE (0x00001000)
|
||
#define FCB_STATE_3_LOWER_CASE (0x00002000)
|
||
|
||
//
|
||
// This is the slack allocation in the Dcb part of the UNION above
|
||
//
|
||
|
||
#define DCB_UNION_SLACK_SPACE ((ULONG) \
|
||
(FIELD_OFFSET(DCB, EaModificationCount) - \
|
||
FIELD_OFFSET(DCB, Specific.Dcb.FreeDirentBitmapBuffer)) \
|
||
)
|
||
|
||
//
|
||
// This is the special (64bit) allocation size that indicates the
|
||
// real size must be retrieved from disk. Define it here so we
|
||
// avoid excessive magic numbering around the driver.
|
||
//
|
||
|
||
#define FCB_LOOKUP_ALLOCATIONSIZE_HINT ((LONGLONG) -1)
|
||
|
||
|
||
//
|
||
// The Ccb record is allocated for every file object. Note that this
|
||
// record is exactly 0x34 long on x86 so that it will fit into a 0x40
|
||
// piece of pool. Please carefully consider modifications.
|
||
//
|
||
// Define the Flags field.
|
||
//
|
||
|
||
#define CCB_FLAG_MATCH_ALL (0x0001)
|
||
#define CCB_FLAG_SKIP_SHORT_NAME_COMPARE (0x0002)
|
||
|
||
//
|
||
// This tells us whether we allocated buffers to hold search templates.
|
||
//
|
||
|
||
#define CCB_FLAG_FREE_OEM_BEST_FIT (0x0004)
|
||
#define CCB_FLAG_FREE_UNICODE (0x0008)
|
||
|
||
//
|
||
// These flags prevents cleanup from updating the modify time, etc.
|
||
//
|
||
|
||
#define CCB_FLAG_USER_SET_LAST_WRITE (0x0010)
|
||
#define CCB_FLAG_USER_SET_LAST_ACCESS (0x0020)
|
||
#define CCB_FLAG_USER_SET_CREATION (0x0040)
|
||
|
||
//
|
||
// This bit says the file object associated with this Ccb was opened for
|
||
// read only access.
|
||
//
|
||
|
||
#define CCB_FLAG_READ_ONLY (0x0080)
|
||
|
||
//
|
||
// These flags, are used is DASD handles in read and write.
|
||
//
|
||
|
||
#define CCB_FLAG_DASD_FLUSH_DONE (0x0100)
|
||
#define CCB_FLAG_DASD_PURGE_DONE (0x0200)
|
||
|
||
//
|
||
// This flag keeps track of a handle that was opened for
|
||
// DELETE_ON_CLOSE.
|
||
//
|
||
|
||
#define CCB_FLAG_DELETE_ON_CLOSE (0x0400)
|
||
|
||
//
|
||
// This flag keeps track of which side of the name pair on the file
|
||
// associated with the handle was opened
|
||
//
|
||
|
||
#define CCB_FLAG_OPENED_BY_SHORTNAME (0x0800)
|
||
|
||
//
|
||
// This flag indicates that the query template has not been upcased
|
||
// (i.e., query should be case-insensitive)
|
||
//
|
||
|
||
#define CCB_FLAG_QUERY_TEMPLATE_MIXED (0x1000)
|
||
|
||
//
|
||
// This flag indicates that reads and writes via this DASD handle
|
||
// are allowed to start or extend past the end of file.
|
||
//
|
||
|
||
#define CCB_FLAG_ALLOW_EXTENDED_DASD_IO (0x2000)
|
||
|
||
//
|
||
// This flag indicates we want to match volume labels in directory
|
||
// searches (important for the root dir defrag).
|
||
//
|
||
|
||
#define CCB_FLAG_MATCH_VOLUME_ID (0x4000)
|
||
|
||
//
|
||
// This flag indicates the ccb has been converted over into a
|
||
// close context for asynchronous/delayed closing of the handle.
|
||
//
|
||
|
||
#define CCB_FLAG_CLOSE_CONTEXT (0x8000)
|
||
|
||
//
|
||
// This flag indicates that when the handle is closed, we want
|
||
// a physical dismount to occur.
|
||
//
|
||
|
||
#define CCB_FLAG_COMPLETE_DISMOUNT (0x10000)
|
||
|
||
//
|
||
// This flag indicates the handle may not call priveleged
|
||
// FSCTL which modify the volume.
|
||
//
|
||
|
||
#define CCB_FLAG_MANAGE_VOLUME_ACCESS (0x20000)
|
||
|
||
//
|
||
// This structure is used to keep track of information needed to do a
|
||
// deferred close. It is now embedded in a CCB so we don't have to
|
||
// allocate one in the close path (with mustsucceed).
|
||
//
|
||
|
||
typedef struct _CLOSE_CONTEXT {
|
||
|
||
//
|
||
// Two sets of links, one for the global list and one for closes
|
||
// on a particular volume.
|
||
//
|
||
|
||
LIST_ENTRY GlobalLinks;
|
||
LIST_ENTRY VcbLinks;
|
||
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
enum _TYPE_OF_OPEN TypeOfOpen;
|
||
BOOLEAN Free;
|
||
|
||
} CLOSE_CONTEXT;
|
||
|
||
typedef CLOSE_CONTEXT *PCLOSE_CONTEXT;
|
||
|
||
typedef struct _CCB {
|
||
|
||
//
|
||
// Type and size of this record (must be FAT_NTC_CCB)
|
||
//
|
||
|
||
NODE_TYPE_CODE NodeTypeCode;
|
||
NODE_BYTE_SIZE NodeByteSize;
|
||
|
||
//
|
||
// Define a 24bit wide field for Flags, but a UCHAR for Wild Cards Present
|
||
// since it is used so often. Line these up on byte boundaries for grins.
|
||
//
|
||
|
||
ULONG Flags:24;
|
||
BOOLEAN ContainsWildCards;
|
||
|
||
//
|
||
// Overlay a close context on the data of the CCB. The remaining
|
||
// fields are not useful during close, and we would like to avoid
|
||
// paying extra pool for it.
|
||
//
|
||
|
||
union {
|
||
|
||
struct {
|
||
|
||
//
|
||
// Save the offset to start search from.
|
||
//
|
||
|
||
VBO OffsetToStartSearchFrom;
|
||
|
||
//
|
||
// The query template is used to filter directory query requests.
|
||
// It originally is set to null and on the first call the NtQueryDirectory
|
||
// it is set to the input filename or "*" if the name is not supplied.
|
||
// All subsquent queries then use this template.
|
||
//
|
||
// The Oem structure are unions because if the name is wild we store
|
||
// the arbitrary length string, while if the name is constant we store
|
||
// 8.3 representation for fast comparison.
|
||
//
|
||
|
||
union {
|
||
|
||
//
|
||
// If the template contains a wild card use this.
|
||
//
|
||
|
||
OEM_STRING Wild;
|
||
|
||
//
|
||
// If the name is constant, use this part.
|
||
//
|
||
|
||
FAT8DOT3 Constant;
|
||
|
||
} OemQueryTemplate;
|
||
|
||
UNICODE_STRING UnicodeQueryTemplate;
|
||
|
||
//
|
||
// The field is compared with the similar field in the Fcb to determine
|
||
// if the Ea's for a file have been modified.
|
||
//
|
||
|
||
ULONG EaModificationCount;
|
||
|
||
//
|
||
// The following field is used as an offset into the Eas for a
|
||
// particular file. This will be the offset for the next
|
||
// Ea to return. A value of 0xffffffff indicates that the
|
||
// Ea's are exhausted.
|
||
//
|
||
|
||
ULONG OffsetOfNextEaToReturn;
|
||
|
||
};
|
||
|
||
CLOSE_CONTEXT CloseContext;
|
||
};
|
||
|
||
} CCB;
|
||
typedef CCB *PCCB;
|
||
|
||
//
|
||
// The Irp Context record is allocated for every orginating Irp. It is
|
||
// created by the Fsd dispatch routines, and deallocated by the FatComplete
|
||
// request routine. It contains a structure called of type REPINNED_BCBS
|
||
// which is used to retain pinned bcbs needed to handle abnormal termination
|
||
// unwinding.
|
||
//
|
||
|
||
#define REPINNED_BCBS_ARRAY_SIZE (4)
|
||
|
||
typedef struct _REPINNED_BCBS {
|
||
|
||
//
|
||
// A pointer to the next structure contains additional repinned bcbs
|
||
//
|
||
|
||
struct _REPINNED_BCBS *Next;
|
||
|
||
//
|
||
// A fixed size array of pinned bcbs. Whenever a new bcb is added to
|
||
// the repinned bcb structure it is added to this array. If the
|
||
// array is already full then another repinned bcb structure is allocated
|
||
// and pointed to with Next.
|
||
//
|
||
|
||
PBCB Bcb[ REPINNED_BCBS_ARRAY_SIZE ];
|
||
|
||
} REPINNED_BCBS;
|
||
typedef REPINNED_BCBS *PREPINNED_BCBS;
|
||
|
||
typedef struct _IRP_CONTEXT {
|
||
|
||
//
|
||
// Type and size of this record (must be FAT_NTC_IRP_CONTEXT)
|
||
//
|
||
|
||
NODE_TYPE_CODE NodeTypeCode;
|
||
NODE_BYTE_SIZE NodeByteSize;
|
||
|
||
//
|
||
// This structure is used for posting to the Ex worker threads.
|
||
//
|
||
|
||
WORK_QUEUE_ITEM WorkQueueItem;
|
||
|
||
//
|
||
// A pointer to the originating Irp.
|
||
//
|
||
|
||
PIRP OriginatingIrp;
|
||
|
||
//
|
||
// Originating Device (required for workque algorithms)
|
||
//
|
||
|
||
PDEVICE_OBJECT RealDevice;
|
||
|
||
//
|
||
// Originating Vcb (required for exception handling)
|
||
// On mounts, this will be set before any exceptions
|
||
// indicating corruption can be thrown.
|
||
//
|
||
|
||
PVCB Vcb;
|
||
|
||
//
|
||
// Major and minor function codes copied from the Irp
|
||
//
|
||
|
||
UCHAR MajorFunction;
|
||
UCHAR MinorFunction;
|
||
|
||
//
|
||
// The following fields indicate if we can wait/block for a resource
|
||
// or I/O, if we are to do everything write through, and if this
|
||
// entry into the Fsd is a recursive call.
|
||
//
|
||
|
||
UCHAR PinCount;
|
||
|
||
ULONG Flags;
|
||
|
||
//
|
||
// The following field contains the NTSTATUS value used when we are
|
||
// unwinding due to an exception
|
||
//
|
||
|
||
NTSTATUS ExceptionStatus;
|
||
|
||
//
|
||
// The following context block is used for non-cached Io
|
||
//
|
||
|
||
struct _FAT_IO_CONTEXT *FatIoContext;
|
||
|
||
//
|
||
// For a abnormal termination unwinding this field contains the Bcbs
|
||
// that are kept pinned until the Irp is completed.
|
||
//
|
||
|
||
REPINNED_BCBS Repinned;
|
||
|
||
} IRP_CONTEXT;
|
||
typedef IRP_CONTEXT *PIRP_CONTEXT;
|
||
|
||
#define IRP_CONTEXT_FLAG_DISABLE_DIRTY (0x00000001)
|
||
#define IRP_CONTEXT_FLAG_WAIT (0x00000002)
|
||
#define IRP_CONTEXT_FLAG_WRITE_THROUGH (0x00000004)
|
||
#define IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH (0x00000008)
|
||
#define IRP_CONTEXT_FLAG_RECURSIVE_CALL (0x00000010)
|
||
#define IRP_CONTEXT_FLAG_DISABLE_POPUPS (0x00000020)
|
||
#define IRP_CONTEXT_FLAG_DEFERRED_WRITE (0x00000040)
|
||
#define IRP_CONTEXT_FLAG_VERIFY_READ (0x00000080)
|
||
#define IRP_CONTEXT_STACK_IO_CONTEXT (0x00000100)
|
||
#define IRP_CONTEXT_FLAG_IN_FSP (0x00000200)
|
||
#define IRP_CONTEXT_FLAG_USER_IO (0x00000400) // for performance counters
|
||
#define IRP_CONTEXT_FLAG_DISABLE_RAISE (0x00000800)
|
||
#define IRP_CONTEXT_FLAG_PARENT_BY_CHILD (0x80000000)
|
||
|
||
|
||
//
|
||
// Context structure for non-cached I/O calls. Most of these fields
|
||
// are actually only required for the Read/Write Multiple routines, but
|
||
// the caller must allocate one as a local variable anyway before knowing
|
||
// whether there are multiple requests are not. Therefore, a single
|
||
// structure is used for simplicity.
|
||
//
|
||
|
||
typedef struct _FAT_IO_CONTEXT {
|
||
|
||
//
|
||
// These two field are used for multiple run Io
|
||
//
|
||
|
||
LONG IrpCount;
|
||
PIRP MasterIrp;
|
||
|
||
//
|
||
// MDL to describe partial sector zeroing
|
||
//
|
||
|
||
PMDL ZeroMdl;
|
||
|
||
union {
|
||
|
||
//
|
||
// This element handles the asychronous non-cached Io
|
||
//
|
||
|
||
struct {
|
||
PERESOURCE Resource;
|
||
PERESOURCE Resource2;
|
||
ERESOURCE_THREAD ResourceThreadId;
|
||
ULONG RequestedByteCount;
|
||
PFILE_OBJECT FileObject;
|
||
PNON_PAGED_FCB NonPagedFcb;
|
||
} Async;
|
||
|
||
//
|
||
// and this element the sycnrhonous non-cached Io
|
||
//
|
||
|
||
KEVENT SyncEvent;
|
||
|
||
} Wait;
|
||
|
||
} FAT_IO_CONTEXT;
|
||
|
||
typedef FAT_IO_CONTEXT *PFAT_IO_CONTEXT;
|
||
|
||
//
|
||
// An array of these structures is passed to FatMultipleAsync describing
|
||
// a set of runs to execute in parallel.
|
||
//
|
||
|
||
typedef struct _IO_RUNS {
|
||
|
||
LBO Lbo;
|
||
VBO Vbo;
|
||
ULONG Offset;
|
||
ULONG ByteCount;
|
||
PIRP SavedIrp;
|
||
|
||
} IO_RUN;
|
||
|
||
typedef IO_RUN *PIO_RUN;
|
||
|
||
//
|
||
// This structure is used by FatDeleteDirent to preserve the first cluster
|
||
// and file size info for undelete utilities.
|
||
//
|
||
|
||
typedef struct _DELETE_CONTEXT {
|
||
|
||
ULONG FileSize;
|
||
ULONG FirstClusterOfFile;
|
||
|
||
} DELETE_CONTEXT;
|
||
|
||
typedef DELETE_CONTEXT *PDELETE_CONTEXT;
|
||
|
||
//
|
||
// This record is used with to set a flush to go off one second after the
|
||
// first write on slow devices with a physical indication of activity, like
|
||
// a floppy. This is an attempt to keep the red light on.
|
||
//
|
||
|
||
typedef struct _DEFERRED_FLUSH_CONTEXT {
|
||
|
||
KDPC Dpc;
|
||
KTIMER Timer;
|
||
WORK_QUEUE_ITEM Item;
|
||
|
||
PFILE_OBJECT File;
|
||
|
||
} DEFERRED_FLUSH_CONTEXT;
|
||
|
||
typedef DEFERRED_FLUSH_CONTEXT *PDEFERRED_FLUSH_CONTEXT;
|
||
|
||
//
|
||
// This structure is used for the FatMarkVolumeClean callbacks.
|
||
//
|
||
|
||
typedef struct _CLEAN_AND_DIRTY_VOLUME_PACKET {
|
||
|
||
WORK_QUEUE_ITEM Item;
|
||
PIRP Irp;
|
||
PVCB Vcb;
|
||
PKEVENT Event;
|
||
} CLEAN_AND_DIRTY_VOLUME_PACKET, *PCLEAN_AND_DIRTY_VOLUME_PACKET;
|
||
|
||
//
|
||
// This structure is used when a page fault is running out of stack.
|
||
//
|
||
|
||
typedef struct _PAGING_FILE_OVERFLOW_PACKET {
|
||
PIRP Irp;
|
||
PFCB Fcb;
|
||
} PAGING_FILE_OVERFLOW_PACKET, *PPAGING_FILE_OVERFLOW_PACKET;
|
||
|
||
//
|
||
// This structure is used to access the EaFile.
|
||
//
|
||
|
||
#define EA_BCB_ARRAY_SIZE 8
|
||
|
||
typedef struct _EA_RANGE {
|
||
|
||
PCHAR Data;
|
||
ULONG StartingVbo;
|
||
ULONG Length;
|
||
USHORT BcbChainLength;
|
||
BOOLEAN AuxilaryBuffer;
|
||
PBCB *BcbChain;
|
||
PBCB BcbArray[EA_BCB_ARRAY_SIZE];
|
||
|
||
} EA_RANGE, *PEA_RANGE;
|
||
|
||
#define EA_RANGE_HEADER_SIZE (FIELD_OFFSET( EA_RANGE, BcbArray ))
|
||
|
||
//
|
||
// These symbols are used by the upcase/downcase routines.
|
||
//
|
||
|
||
#define WIDE_LATIN_CAPITAL_A (0xff21)
|
||
#define WIDE_LATIN_CAPITAL_Z (0xff3a)
|
||
#define WIDE_LATIN_SMALL_A (0xff41)
|
||
#define WIDE_LATIN_SMALL_Z (0xff5a)
|
||
|
||
//
|
||
// These values are returned by FatInterpretClusterType.
|
||
//
|
||
|
||
typedef enum _CLUSTER_TYPE {
|
||
FatClusterAvailable,
|
||
FatClusterReserved,
|
||
FatClusterBad,
|
||
FatClusterLast,
|
||
FatClusterNext
|
||
} CLUSTER_TYPE;
|
||
|
||
|
||
#endif // _FATSTRUC_
|
||
|