Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-06 04:35:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/filesystems/fastfat_new/fatstruc.h
Pierre Schweitzer aeadcaf515
[FASTFAT] Import the MS FastFAT sample from WXP. 
Modified it so that it builds in trunk (with GCC, though).
Not to be switched for now, as it doesn't work in ReactOS (yet?).
2017-11-23 12:35:51 +01:00

1615 lines
43 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
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.
--*/
#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;
//
// A count of the number of internal opens on this VCB.
//
ULONG InternalOpenCount;
//
// A count of the number of residual opens on this volume.
// This is usually two or three. One is for the virtual volume
// file. One is for the root directory. And one is for the
// EA file, if there is one.
//
ULONG ResidualOpenCount;
//
// 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)
#define VCB_STATE_FLAG_VPB_MUST_BE_FREED (0x00040000)
#define VCB_STATE_FLAG_DISMOUNT_IN_PROGRESS (0x00080000)
//
// 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_
Reference in a new issue View git blame Copy permalink