fatprocs.h File Reference

#include <ntifs.h>
#include <ntddscsi.h>
#include <scsi.h>
#include <ntddcdrm.h>
#include <ntdddisk.h>
#include <ntddstor.h>
#include <ntintsafe.h>
#include "nodetype.h"
#include "fat.h"
#include "lfn.h"
#include "fatstruc.h"
#include "fatdata.h"

Include dependency graph for fatprocs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_FAT_ENUMERATION_CONTEXT
union	_UCHAR1
union	_UCHAR2
union	_UCHAR4

Macros
#define	INLINE   __inline
#define	Add2Ptr(P, I)   ((PVOID)((PUCHAR)(P) + (I)))
#define	MAX_ULONG   ((ULONG)-1)
#define	MAX_USHORT   ((USHORT)-1)
#define	FAT_CREATE_INITIAL_NAME_BUF_SIZE   32
#define	FatUnpinBcb(IRPCONTEXT, BCB)
#define	FatDirectoryKey(FcbOrDcb)   ((ULONGLONG)((FcbOrDcb)->CreationTime.QuadPart ^ (FcbOrDcb)->FirstClusterOfFile))
#define	FatUpcaseEaName(IRPCONTEXT, NAME, UPCASEDNAME)    RtlUpperString( UPCASEDNAME, NAME )
#define	SizeOfFullEa(EA)   (4+1+1+2+(EA)->EaNameLength+1+(EA)->EaValueLength)
#define	FatAreNamesEqual(IRPCONTEXT, NAMEA, NAMEB)
#define	FatIsNameShortOemValid(IRPCONTEXT, NAME, CAN_CONTAIN_WILD_CARDS, PATH_NAME_OK, LEADING_BACKSLASH_OK)
#define	FatIsNameLongOemValid(IRPCONTEXT, NAME, CAN_CONTAIN_WILD_CARDS, PATH_NAME_OK, LEADING_BACKSLASH_OK)
#define	FatAcquireExclusiveGlobal(IRPCONTEXT)
#define	FatAcquireSharedGlobal(IRPCONTEXT)
#define	FatAcquireExclusiveVolume(IRPCONTEXT, VCB)
#define	FatReleaseVolume(IRPCONTEXT, VCB)
#define	FatSetVcbCondition(V, X)   (V)->VcbCondition = (X)
#define	FatIsFat32(VCB)   ((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 32))
#define	FatIsFat16(VCB)   ((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 16))
#define	FatIsFat12(VCB)   ((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 12))
#define	FatAcquireExclusiveVcb(IC, V)   FatAcquireExclusiveVcb_Real( IC, V, FALSE)
#define	FatAcquireExclusiveVcbNoOpCheck(IC, V)   FatAcquireExclusiveVcb_Real( IC, V, TRUE)
#define	FatVcbAcquiredExclusive(IRPCONTEXT, VCB)
#define	FatFcbAcquiredShared(IRPCONTEXT, FCB)
#define	FatFcbAcquiredExclusive(IRPCONTEXT, FCB)
#define	FatAcquireDirectoryFileMutex(VCB)
#define	FatReleaseDirectoryFileMutex(VCB)
#define	FatConvertToSharedFcb(IRPCONTEXT, Fcb)
#define	FatDeleteResource(RESRC)
#define	FatReleaseGlobal(IRPCONTEXT)
#define	FatReleaseVcb(IRPCONTEXT, Vcb)
#define	FatReleaseFcb(IRPCONTEXT, Fcb)
#define	FatGetFcbOplock(F)   &(F)->Header.Oplock
#define	FatDeleteIrpContext(IRPCONTEXT)
#define	FatGetFirstChild(DIR)
#define	FatGetNextSibling(FILE)
#define	FatIsRawDevice(IC, S)
#define	CompareNames(NAMEA, NAMEB)
#define	PtrOffset(BASE, OFFSET)   ((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))
#define	WordAlign(Ptr)
#define	LongAlign(Ptr)
#define	QuadAlign(Ptr)
#define	CopyUchar1(Dst, Src)
#define	CopyUchar2(Dst, Src)
#define	CopyUchar4(Dst, Src)
#define	CopyU4char(Dst, Src)
#define	FatNotifyReportChange(I, V, F, FL, A)
#define	CanFsdWait(IRP)   IoIsOperationSynchronous(Irp)
#define	FatCompleteRequest(IRPCONTEXT, IRP, STATUS)
#define	IsFileDeleted(IRPCONTEXT, FCB)
#define	IsFileWriteThrough(FO, VCB)
#define	FatIsFastIoPossible(FCB)
#define	FatIsNodeTypeOplockable(N)
#define	FatIsFileOplockable(F)
#define	IsFileObjectReadOnly(FO)   (!((FO)->WriteAccess | (FO)->DeleteAccess))
#define	DebugBreakOnStatus(S)
#define	FatRaiseStatus(IRPCONTEXT, STATUS)
#define	FatResetExceptionState(IRPCONTEXT)
#define	FatNormalizeAndRaiseStatus(IRPCONTEXT, STATUS)
#define	try_return(S)   { S; goto try_exit; }
#define	try_leave(S)   { S; _SEH2_LEAVE; }
#define	FatGenerateFileIdFromDirentOffset(ParentDcb, DirentOffset)
#define	FatGenerateFileIdFromFcb(Fcb)    FatGenerateFileIdFromDirentOffset( (Fcb)->ParentDcb, (Fcb)->DirentOffsetWithinDirectory )
#define	FATDOT   ((ULONG)0x2020202E)
#define	FATDOTDOT   ((ULONG)0x20202E2E)
#define	FatGenerateFileIdFromDirentAndOffset(Dcb, Dirent, DirentOffset)
#define	FatDeviceIsFatFsdo(D)   (((D) == FatData.DiskFileSystemDeviceObject) || ((D) == FatData.CdromFileSystemDeviceObject))
#define	BlockAlign(P, V)   ((ASSERT( V != 0)), (((P)) + (V-1) & (0-(V))))
#define	BlockAlignTruncate(P, V)   ((P) & (0-(V)))
#define	IsDirectory(FcbOrDcb)   ((NodeType((FcbOrDcb)) == FAT_NTC_DCB) || (NodeType((FcbOrDcb)) == FAT_NTC_ROOT_DCB))

Typedefs
typedef BOOLEAN	FINISHED
typedef struct _FAT_ENUMERATION_CONTEXT	FAT_ENUMERATION_CONTEXT
typedef struct _FAT_ENUMERATION_CONTEXT *	PFAT_ENUMERATION_CONTEXT
typedef enum _TYPE_OF_OPEN	TYPE_OF_OPEN
typedef enum _FAT_FLUSH_TYPE	FAT_FLUSH_TYPE
typedef enum _COMPARISON	COMPARISON
typedef enum _FAT_VOLUME_STATE	FAT_VOLUME_STATE
typedef enum _FAT_VOLUME_STATE *	PFAT_VOLUME_STATE
typedef union _UCHAR1	UCHAR1
typedef union _UCHAR1 *	PUCHAR1
typedef union _UCHAR2	UCHAR2
typedef union _UCHAR2 *	PUCHAR2
typedef union _UCHAR4	UCHAR4
typedef union _UCHAR4 *	PUCHAR4

Enumerations
enum	_TYPE_OF_OPEN {   UnopenedFileObject = 0 , StreamFileOpen , UserVolumeOpen , UserDirectoryOpen ,   UserFileOpen , BeyondValidType , UnopenedFileObject = 1 , UserFileOpen ,   UserDirectoryOpen , UserVolumeOpen , VirtualVolumeFile , DirectoryFile ,   EaFile }
enum	_FAT_FLUSH_TYPE { NoFlush = 0 , Flush , FlushAndInvalidate , FlushWithoutPurge }
enum	_COMPARISON { IsLessThan , IsGreaterThan , IsEqual }
enum	_FAT_VOLUME_STATE { VolumeClean , VolumeDirty , VolumeDirtyWithSurfaceTest }

Functions
VOID	FatFreeStringBuffer (_Inout_ PVOID String)
VOID	FatExtendString (_Inout_ PVOID String, _In_ USHORT DesiredBufferSize, _In_ BOOLEAN FreeOldBuffer, __out_opt PBOOLEAN NeedsFree)
VOID	FatEnsureStringBufferEnough (_Inout_ PVOID String, _In_ USHORT DesiredBufferSize)
BOOLEAN	FatAddMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, IN LBO Lbo, IN ULONG SectorCount)
BOOLEAN	FatLookupMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, OUT PLBO Lbo, OUT PULONG ByteCount OPTIONAL, OUT PULONG Index OPTIONAL)
BOOLEAN	FatLookupLastMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, OUT PVBO Vbo, OUT PLBO Lbo, OUT PULONG Index OPTIONAL)
BOOLEAN	FatGetNextMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN ULONG RunIndex, OUT PVBO Vbo, OUT PLBO Lbo, OUT PULONG ByteCount)
VOID	FatRemoveMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, IN ULONG SectorCount)
BOOLEAN	FatCheckFileAccess (PIRP_CONTEXT IrpContext, IN UCHAR DirentAttributes, IN PACCESS_MASK DesiredAccess)
BOOLEAN	FatCheckManageVolumeAccess (_In_ PIRP_CONTEXT IrpContext, _In_ PACCESS_STATE AccessState, _In_ KPROCESSOR_MODE ProcessorMode)
NTSTATUS	FatExplicitDeviceAccessGranted (IN PIRP_CONTEXT IrpContext, IN PDEVICE_OBJECT DeviceObject, IN PACCESS_STATE AccessState, IN KPROCESSOR_MODE ProcessorMode)
static INLINE BOOLEAN	FatIsIoRangeValid (IN PVCB Vcb, IN LARGE_INTEGER Start, IN ULONG Length)
VOID	FatLookupFatEntry (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN ULONG FatIndex, IN OUT PULONG FatEntry, IN OUT PFAT_ENUMERATION_CONTEXT Context)
VOID	FatSetupAllocationSupport (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID	FatTearDownAllocationSupport (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
	_Requires_lock_held_ (_Global_critical_region_) VOID FatLookupFileAllocation(IN PIRP_CONTEXT IrpContext
UCHAR	FatLogOf (IN ULONG Value)
VOID	FatReadVolumeFile (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN VBO StartingVbo, IN ULONG ByteCount, OUT PBCB *Bcb, OUT PVOID *Buffer)
PFILE_OBJECT	FatOpenEaFile (IN PIRP_CONTEXT IrpContext, IN PFCB EaFcb)
VOID	FatCloseEaFile (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN BOOLEAN FlushFirst)
VOID	FatRepinBcb (IN PIRP_CONTEXT IrpContext, IN PBCB Bcb)
VOID	FatUnpinRepinnedBcbs (IN PIRP_CONTEXT IrpContext)
FINISHED	FatZeroData (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN ULONG StartingZero, IN ULONG ByteCount)
NTSTATUS	FatCompleteMdl (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
VOID	FatPinMappedData (IN PIRP_CONTEXT IrpContext, IN PDCB Dcb, IN VBO StartingVbo, IN ULONG ByteCount, OUT PBCB *Bcb)
NTSTATUS	FatPrefetchPages (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN ULONG StartingPage, IN ULONG PageCount)
VOID	FatInitializeCacheMap (_In_ PFILE_OBJECT FileObject, _In_ PCC_FILE_SIZES FileSizes, _In_ BOOLEAN PinAccess, _In_ PCACHE_MANAGER_CALLBACKS Callbacks, _In_ PVOID LazyWriteContext)
VOID	FatSyncUninitializeCacheMap (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject)
VOID	FatPagingFileIo (IN PIRP Irp, IN PFCB Fcb)
VOID	FatMultipleAsync (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PIRP Irp, IN ULONG MultipleIrpCount, IN PIO_RUN IoRuns)
VOID	FatSingleAsync (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN LBO Lbo, IN ULONG ByteCount, IN PIRP Irp)
VOID	FatWaitSync (IN PIRP_CONTEXT IrpContext)
VOID	FatLockUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp, IN LOCK_OPERATION Operation, IN ULONG BufferLength)
PVOID	FatBufferUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp, IN ULONG BufferLength)
PVOID	FatMapUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp)
NTSTATUS	FatToggleMediaEjectDisable (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN BOOLEAN PreventRemoval)
NTSTATUS	FatPerformDevIoCtrl (IN PIRP_CONTEXT IrpContext, IN ULONG IoControlCode, IN PDEVICE_OBJECT Device, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN BOOLEAN OverrideVerify, OUT PIO_STATUS_BLOCK Iosb OPTIONAL)
PMDL	FatBuildZeroMdl (__in PIRP_CONTEXT IrpContext, __in ULONG Length)
VOID	FatTunnelFcbOrDcb (IN PFCB FcbOrDcb, IN PCCB Ccb OPTIONAL)
VOID	FatConstructDirent (IN PIRP_CONTEXT IrpContext, IN OUT PDIRENT Dirent, IN POEM_STRING FileName, IN BOOLEAN ComponentReallyLowercase, IN BOOLEAN ExtensionReallyLowercase, IN PUNICODE_STRING Lfn OPTIONAL, IN USHORT Attributes, IN BOOLEAN ZeroAndSetTimeFields, IN PLARGE_INTEGER SetCreationTime OPTIONAL)
VOID	FatConstructLabelDirent (IN PIRP_CONTEXT IrpContext, IN OUT PDIRENT Dirent, IN POEM_STRING Label)
VOID	FatReadEaSet (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN USHORT EaHandle, IN POEM_STRING FileName, IN BOOLEAN ReturnEntireSet, OUT PEA_RANGE EaSetRange)
VOID	FatDeletePackedEa (IN PIRP_CONTEXT IrpContext, IN OUT PEA_SET_HEADER EaSetHeader, IN OUT PULONG PackedEasLength, IN ULONG Offset)
VOID	FatAppendPackedEa (IN PIRP_CONTEXT IrpContext, IN OUT PEA_SET_HEADER *EaSetHeader, IN OUT PULONG PackedEasLength, IN OUT PULONG AllocationLength, IN PFILE_FULL_EA_INFORMATION FullEa, IN ULONG BytesPerCluster)
ULONG	FatLocateNextEa (IN PIRP_CONTEXT IrpContext, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, IN ULONG PreviousOffset)
BOOLEAN	FatLocateEaByName (IN PIRP_CONTEXT IrpContext, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, IN POEM_STRING EaName, OUT PULONG Offset)
BOOLEAN	FatIsEaNameValid (IN PIRP_CONTEXT IrpContext, IN OEM_STRING Name)
VOID	FatPinEaRange (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT VirtualEaFile, IN PFCB EaFcb, IN OUT PEA_RANGE EaRange, IN ULONG StartingVbo, IN ULONG Length, IN NTSTATUS ErrorStatus)
VOID	FatMarkEaRangeDirty (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT EaFileObject, IN OUT PEA_RANGE EaRange)
VOID	FatUnpinEaRange (IN PIRP_CONTEXT IrpContext, IN OUT PEA_RANGE EaRange)
VOID	FatSetFileObject (IN PFILE_OBJECT FileObject OPTIONAL, IN TYPE_OF_OPEN TypeOfOpen, IN PVOID VcbOrFcbOrDcb, IN PCCB Ccb OPTIONAL)
TYPE_OF_OPEN	FatDecodeFileObject (_In_ PFILE_OBJECT FileObject, _Outptr_ PVCB *Vcb, _Outptr_ PFCB *FcbOrDcb, _Outptr_ PCCB *Ccb)
BOOLEAN	FatIsBootSectorFat (IN PPACKED_BOOT_SECTOR BootSector)
NTSTATUS	FatUnlockVolumeInternal (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PFILE_OBJECT FileObject OPTIONAL)
static INLINE BOOLEAN	FatIsNameLongUnicodeValid (PIRP_CONTEXT IrpContext, PUNICODE_STRING Name, BOOLEAN CanContainWildcards, BOOLEAN PathNameOk, BOOLEAN LeadingBackslashOk)
BOOLEAN	FatIsNameInExpression (IN PIRP_CONTEXT IrpContext, IN OEM_STRING Expression, IN OEM_STRING Name)
VOID	FatStringTo8dot3 (_In_ PIRP_CONTEXT IrpContext, _In_ OEM_STRING InputString, _Out_writes_bytes_(11) PFAT8DOT3 Output8dot3)
VOID	Fat8dot3ToString (_In_ PIRP_CONTEXT IrpContext, _In_ PDIRENT Dirent, _In_ BOOLEAN RestoreCase, _Out_ POEM_STRING OutputString)
VOID	FatSetFullNameInFcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ PUNICODE_STRING FinalName)
VOID	FatUnicodeToUpcaseOem (IN PIRP_CONTEXT IrpContext, IN POEM_STRING OemString, IN PUNICODE_STRING UnicodeString)
VOID	FatEvaluateNameCase (IN PIRP_CONTEXT IrpContext, IN PUNICODE_STRING Name, IN OUT BOOLEAN *AllLowerComponent, IN OUT BOOLEAN *AllLowerExtension, IN OUT BOOLEAN *CreateLfn)
BOOLEAN	FatSpaceInName (IN PIRP_CONTEXT IrpContext, IN PUNICODE_STRING UnicodeName)
VOID	FatUnicodeRestoreShortNameCase (IN PUNICODE_STRING ShortNameWithCase, IN BOOLEAN LowerCase8, IN BOOLEAN LowerCase3)
	_Acquires_exclusive_lock_ (Vcb->Resource)) FINISHED FatAcquireExclusiveVcb_Real(IN PIRP_CONTEXT IrpContext
	_Acquires_shared_lock_ (Vcb->Resource)) FINISHED FatAcquireSharedVcb(IN PIRP_CONTEXT IrpContext
_Acquires_shared_lock_ Fcb FINISHED	FatAcquireSharedFcbWaitForEx (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
BOOLEAN	FatAcquireVolumeForClose (IN PVOID Vcb, IN BOOLEAN Wait)
VOID	FatReleaseVolumeFromClose (IN PVOID Vcb)
	_Function_class_ (FAST_IO_ACQUIRE_FOR_CCFLUSH) _Requires_lock_held_(_Global_critical_region_) NTSTATUS NTAPI FatAcquireForCcFlush(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_RELEASE_FOR_CCFLUSH) _Requires_lock_held_(_Global_critical_region_) NTSTATUS NTAPI FatReleaseForCcFlush(IN PFILE_OBJECT FileObject
BOOLEAN NTAPI	FatNoOpAcquire (IN PVOID Fcb, IN BOOLEAN Wait)
VOID NTAPI	FatNoOpRelease (IN PVOID Fcb)
VOID	FatTearDownVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID	FatDeleteVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
PFCB	FatCreateFcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PDCB ParentDcb, IN ULONG LfnOffsetWithinDirectory, IN ULONG DirentOffsetWithinDirectory, IN PDIRENT Dirent, IN PUNICODE_STRING Lfn OPTIONAL, IN PUNICODE_STRING OrigLfn OPTIONAL, IN BOOLEAN IsPagingFile, IN BOOLEAN SingleResource)
PDCB	FatCreateDcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PDCB ParentDcb, IN ULONG LfnOffsetWithinDirectory, IN ULONG DirentOffsetWithinDirectory, IN PDIRENT Dirent, IN PUNICODE_STRING Lfn OPTIONAL)
VOID	FatDeleteFcb (IN PIRP_CONTEXT IrpContext, IN PFCB *Fcb)
PCCB	FatCreateCcb (IN PIRP_CONTEXT IrpContext)
VOID	FatDeallocateCcbStrings (IN PCCB Ccb)
VOID	FatDeleteCcb (IN PIRP_CONTEXT IrpContext, IN PCCB *Ccb)
PIRP_CONTEXT	FatCreateIrpContext (IN PIRP Irp, IN BOOLEAN Wait)
VOID	FatDeleteIrpContext_Real (IN PIRP_CONTEXT IrpContext)
PFCB	FatGetNextFcbTopDown (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN PFCB TerminationFcb)
PFCB	FatGetNextFcbBottomUp (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN PFCB TerminationFcb)
VOID	FatConstructNamesInFcb (IN PIRP_CONTEXT IrpContext, PFCB Fcb, PDIRENT Dirent, PUNICODE_STRING Lfn OPTIONAL)
ULONG	FatVolumeUncleanCount (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID	FatPreallocateCloseContext (IN PVCB Vcb)
PCLOSE_CONTEXT	FatAllocateCloseContext (IN PVCB Vcb)
VOID	FatInsertName (IN PIRP_CONTEXT IrpContext, IN PRTL_SPLAY_LINKS *RootNode, IN PFILE_NAME_NODE Name)
VOID	FatRemoveNames (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
PFCB	FatFindFcb (IN PIRP_CONTEXT IrpContext, IN OUT PRTL_SPLAY_LINKS *RootNode, IN PSTRING Name, OUT PBOOLEAN FileNameDos OPTIONAL)
BOOLEAN	FatIsHandleCountZero (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
COMPARISON	FatCompareNames (IN PSTRING NameA, IN PSTRING NameB)
	_Success_ (return !=FALSE) BOOLEAN FatNtTimeToFatTime(_In_ PIRP_CONTEXT IrpContext
LARGE_INTEGER	FatFatTimeToNtTime (_In_ PIRP_CONTEXT IrpContext, _In_ FAT_TIME_STAMP FatTime, _In_ UCHAR TenMilliSeconds)
LARGE_INTEGER	FatFatDateToNtTime (_In_ PIRP_CONTEXT IrpContext, _In_ FAT_DATE FatDate)
FAT_TIME_STAMP	FatGetCurrentFatTime (_In_ PIRP_CONTEXT IrpContext)
VOID	FatMarkFcbCondition (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN FCB_CONDITION FcbCondition, IN BOOLEAN Recursive)
VOID	FatVerifyVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID NTAPI	FatCleanVolumeDpc (_In_ PKDPC Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)
VOID NTAPI	FatFspMarkVolumeDirtyWithRecover (PVOID Parameter)
VOID	FatCheckDirtyBit (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID	FatQuickVerifyVcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
VOID	FatVerifyOperationIsLegal (IN PIRP_CONTEXT IrpContext)
VOID NTAPI	FatOplockComplete (IN PVOID Context, IN PIRP Irp)
VOID NTAPI	FatPrePostIrp (IN PVOID Context, IN PIRP Irp)
VOID	FatAddToWorkque (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatFsdPostRequest (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
	_Function_class_ (IRP_MJ_CLEANUP) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdCleanup(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_CLOSE) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdClose(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_CREATE) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdCreate(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_DEVICE_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdDeviceControl(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_DIRECTORY_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdDirectoryControl(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_QUERY_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdQueryEa(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_SET_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdSetEa(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_QUERY_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdQueryInformation(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_SET_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdSetInformation(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_FLUSH_BUFFERS) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdFlushBuffers(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_FILE_SYSTEM_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdFileSystemControl(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_LOCK_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdLockControl(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_PNP) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdPnp(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_READ) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdRead(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_SHUTDOWN) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdShutdown(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_QUERY_VOLUME_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdQueryVolumeInformation(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_SET_VOLUME_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdSetVolumeInformation(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
	_Function_class_ (IRP_MJ_WRITE) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI FatFsdWrite(_In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject
VOID NTAPI	FatFspDispatch (_In_ PVOID Context)
NTSTATUS	FatCommonQueryEa (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatCommonSetEa (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatFlushFat (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
NTSTATUS	FatHijackIrpAndFlushDevice (IN PIRP_CONTEXT IrpContext, IN PIRP Irp, IN PDEVICE_OBJECT TargetDeviceObject)
VOID	FatFlushFatEntries (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN ULONG Cluster, IN ULONG Count)
VOID	FatFlushDirentForFile (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
VOID	FatCompleteRequest_Real (IN PIRP_CONTEXT IrpContext, IN PIRP Irp, IN NTSTATUS Status)
BOOLEAN	FatIsIrpTopLevel (IN PIRP Irp)
	_Function_class_ (FAST_IO_CHECK_IF_POSSIBLE) BOOLEAN NTAPI FatFastIoCheckIfPossible(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_QUERY_BASIC_INFO) BOOLEAN NTAPI FatFastQueryBasicInfo(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_QUERY_STANDARD_INFO) BOOLEAN NTAPI FatFastQueryStdInfo(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_QUERY_NETWORK_OPEN_INFO) BOOLEAN NTAPI FatFastQueryNetworkOpenInfo(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_LOCK) BOOLEAN NTAPI FatFastLock(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_UNLOCK_SINGLE) BOOLEAN NTAPI FatFastUnlockSingle(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_UNLOCK_ALL) BOOLEAN NTAPI FatFastUnlockAll(IN PFILE_OBJECT FileObject
	_Function_class_ (FAST_IO_UNLOCK_ALL_BY_KEY) BOOLEAN NTAPI FatFastUnlockAllByKey(IN PFILE_OBJECT FileObject
VOID	FatExamineFatEntries (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN ULONG StartIndex OPTIONAL, IN ULONG EndIndex OPTIONAL, IN BOOLEAN SetupWindows, IN PFAT_WINDOW SwitchToWindow OPTIONAL, IN PULONG BitMapBuffer OPTIONAL)
BOOLEAN	FatScanForDataTrack (IN PIRP_CONTEXT IrpContext, IN PDEVICE_OBJECT TargetDeviceObject)
ULONG	FatExceptionFilter (IN PIRP_CONTEXT IrpContext, IN PEXCEPTION_POINTERS ExceptionPointer)
CLUSTER_TYPE	FatInterpretClusterType (IN PVCB Vcb, IN FAT_ENTRY Entry)

Variables
IN PFCB	FcbOrDcb
IN PFCB IN VBO	Vbo
IN PFCB IN VBO OUT PLBO	Lbo
IN PFCB IN VBO OUT PLBO OUT PULONG	ByteCount
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN	Allocated
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN OUT PBOOLEAN	EndOnMax
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN OUT PBOOLEAN OUT PULONG Index	OPTIONAL
IN PFCB IN PFILE_OBJECT FileObject IN ULONG	AllocationSize
IN PVCB	Vcb
IN PVCB IN ULONG	AbsoluteClusterHint
IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN	ExactMatchRequired
IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN OUT PLARGE_MCB	Mcb
IN PVCB IN PLARGE_MCB IN BOOLEAN	ZeroOnDeallocate
IN PVCB IN OUT PLARGE_MCB IN VBO	SplitAtVbo
IN PVCB IN OUT PLARGE_MCB IN VBO OUT PLARGE_MCB	RemainingMcb
IN PVCB IN OUT PLARGE_MCB IN PLARGE_MCB	SecondMcb
IN PVCB IN ULONG	FatIndex
IN PVCB IN ULONG IN FAT_ENTRY	FatEntry
IN PVCB IN VBO	StartingVbo
IN PVCB IN VBO IN ULONG OUT PBCB *	Bcb
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID *	Buffer
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN	Reversible
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN	Zero
IN PDCB	Dcb
IN PDCB IN VBO IN ULONG IN BOOLEAN	Pin
IN PDCB IN VBO IN ULONG IN BOOLEAN OUT PBCB OUT PVOID OUT PNTSTATUS	Status
IN PIRP	Irp
IN PIRP IN PFCB IN ULONG IN ULONG IN ULONG	UserByteCount
IN PIRP IN PFCB IN ULONG IN ULONG IN ULONG IN ULONG	StreamFlags
IN PDCB	ParentDirectory
IN PDCB IN ULONG	DirentsNeeded
IN PDCB IN ULONG IN BOOLEAN	RescanDir
IN PDCB IN PDIRENT	ParentDirent
IN PFCB IN PDELETE_CONTEXT DeleteContext IN BOOLEAN	DeleteEa
IN PDCB IN PCCB	Ccb
IN PDCB IN PCCB IN VBO	OffsetToStartSearchFrom
IN PDCB IN PCCB IN VBO IN OUT PULONG	Flags
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT *	Dirent
IN PDCB IN PCCB IN VBO IN OUT PULONG OUT PDIRENT OUT PBCB OUT PVBO	ByteOffset
IN PDCB IN POEM_STRING	FileName
IN PDCB IN PUNICODE_STRING	Lfn
IN PDCB IN PUNICODE_STRING IN PUNICODE_STRING	LfnTmp
IN PFCB IN BOOLEAN	ReturnOnFailure
IN PDCB	TargetDcb
IN PDCB IN ULONG	LfnOffset
IN PDCB IN ULONG IN ULONG	DirentOffset
IN PFCB	Fcb
IN PFILE_OBJECT	FileObject
IN PVCB IN PDIRENT OUT PULONG	EaLength
IN PVCB IN PDIRENT OUT PULONG	NeedEaCount
IN PVCB IN PUCHAR IN ULONG	Length
IN PVCB IN PUCHAR IN ULONG IN POEM_STRING OUT PUSHORT	EaHandle
IN OUT PVCB OUT PDIRENT *	EaDirent
IN OUT PVCB OUT PDIRENT OUT PBCB *	EaBcb
IN OUT PVCB OUT PDIRENT OUT PBCB IN BOOLEAN	CreateFile
IN OUT PVCB OUT PDIRENT OUT PBCB IN BOOLEAN IN BOOLEAN	ExclusiveFcb
IN PVCB IN PBCB OUT PDIRENT IN USHORT IN POEM_STRING	Filename
IN PVCB IN ULONG	EaSetLength
IN PVCB IN ULONG IN PBCB OUT PDIRENT OUT PUSHORT OUT PEA_RANGE	EaSetRange
IN PFCB IN FAT_FLUSH_TYPE	FlushType
IN PDCB	Parent
IN PDCB IN POEM_STRING	OemName
IN PDCB IN POEM_STRING IN PUNICODE_STRING	UnicodeName
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING	ShortName
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING IN PUNICODE_STRING SuggestedShortName IN OUT BOOLEAN *	AllLowerComponent
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING IN PUNICODE_STRING SuggestedShortName IN OUT BOOLEAN IN OUT BOOLEAN *	AllLowerExtension
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING IN PUNICODE_STRING SuggestedShortName IN OUT BOOLEAN IN OUT BOOLEAN IN OUT BOOLEAN *	CreateLfn
IN PVCB IN BOOLEAN	NoOpCheck
IN BOOLEAN	Wait
IN PDEVICE_OBJECT	DeviceObject
OUT PVOID *	CompletionContext
IN OUT PVCB IN PDEVICE_OBJECT	TargetDeviceObject
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB	Vpb
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB IN PDEVICE_OBJECT	FsDeviceObject
PVCB IN BOOLEAN	Force
_In_ PLARGE_INTEGER	NtTime
_In_ PLARGE_INTEGER _In_ BOOLEAN	Rounding
_In_ PLARGE_INTEGER _In_ BOOLEAN _Out_ PFAT_TIME_STAMP	FatTime
_In_ PLARGE_INTEGER _In_ BOOLEAN _Out_ PFAT_TIME_STAMP _Out_opt_ PUCHAR	TenMsecs
KDEFERRED_ROUTINE	FatCleanVolumeDpc
IN PVCB IN FAT_VOLUME_STATE	VolumeState
WORKER_THREAD_ROUTINE	FatFspMarkVolumeDirtyWithRecover
_In_ PIRP _In_ PDEVICE_OBJECT	Device
WORKER_THREAD_ROUTINE	FatFspDispatch
IN PFCB IN PCCB IN TYPE_OF_OPEN	TypeOfOpen
IN PFCB IN PCCB IN TYPE_OF_OPEN IN BOOLEAN IN BOOLEAN	TopLevel
IN PLARGE_INTEGER	FileOffset
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG	LockKey
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN	CheckForReadOperation
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK	IoStatus
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS	ProcessId
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG	Key
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN	FailImmediately
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN	ExclusiveLock
IN PIRP IN NTSTATUS	ExceptionCode

Macro Definition Documentation

Add2Ptr

#define Add2Ptr	(		P,
			I
	)		((PVOID)((PUCHAR)(P) + (I)))

Definition at line 80 of file fatprocs.h.

BlockAlign

#define BlockAlign	(		P,
			V
	)		((ASSERT( V != 0)), (((P)) + (V-1) & (0-(V))))

Definition at line 3103 of file fatprocs.h.

BlockAlignTruncate

#define BlockAlignTruncate	(		P,
			V
	)		((P) & (0-(V)))

Definition at line 3104 of file fatprocs.h.

CanFsdWait

#define CanFsdWait

(

IRP

)

IoIsOperationSynchronous(Irp)

Definition at line 2370 of file fatprocs.h.

CompareNames

#define CompareNames	(		NAMEA,
			NAMEB
	)

Value:

    (                        \
    *(PUCHAR)(NAMEA)->Buffer != *(PUCHAR)(NAMEB)->Buffer ? \
    *(PUCHAR)(NAMEA)->Buffer < *(PUCHAR)(NAMEB)->Buffer ?  \
    IsLessThan : IsGreaterThan :                           \
    FatCompareNames((PSTRING)(NAMEA), (PSTRING)(NAMEB))    \
)

Definition at line 1899 of file fatprocs.h.

CopyU4char

#define CopyU4char	(		Dst,
			Src
	)

Value:

    {                               \
    *((UNALIGNED UCHAR4 *)(Dst)) = *((UCHAR4 *)(Src));      \
    }

Definition at line 2153 of file fatprocs.h.

CopyUchar1

#define CopyUchar1	(		Dst,
			Src
	)

Value:

    {                               \
    *((UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src));      \
    }

Definition at line 2133 of file fatprocs.h.

CopyUchar2

#define CopyUchar2	(		Dst,
			Src
	)

Value:

    {                               \
    *((UCHAR2 *)(Dst)) = *((UNALIGNED UCHAR2 *)(Src));      \
    }

Definition at line 2141 of file fatprocs.h.

CopyUchar4

#define CopyUchar4	(		Dst,
			Src
	)

Value:

    {                               \
    *((UCHAR4 *)(Dst)) = *((UNALIGNED UCHAR4 *)(Src));      \
    }

Definition at line 2149 of file fatprocs.h.

DebugBreakOnStatus

#define DebugBreakOnStatus

(

S

)

Definition at line 2974 of file fatprocs.h.

FAT_CREATE_INITIAL_NAME_BUF_SIZE

#define FAT_CREATE_INITIAL_NAME_BUF_SIZE   32

Definition at line 111 of file fatprocs.h.

FatAcquireDirectoryFileMutex

#define FatAcquireDirectoryFileMutex

(

VCB

)

Value:

    {                         \
    NT_ASSERT(KeAreApcsDisabled());                                 \
    ExAcquireFastMutexUnsafe(&(VCB)->DirectoryFileCreationMutex);   \
}

Definition at line 1508 of file fatprocs.h.

FatAcquireExclusiveGlobal

#define FatAcquireExclusiveGlobal

(

IRPCONTEXT

)

Value:

    (                                                                     \
    ExAcquireResourceExclusiveLite( &FatData.Resource, BooleanFlagOn((IRPCONTEXT)->Flags, IRP_CONTEXT_FLAG_WAIT) )  \
)

Definition at line 1387 of file fatprocs.h.

FatAcquireExclusiveVcb

#define FatAcquireExclusiveVcb	(		IC,
			V
	)		FatAcquireExclusiveVcb_Real( IC, V, FALSE)

Definition at line 1460 of file fatprocs.h.

FatAcquireExclusiveVcbNoOpCheck

#define FatAcquireExclusiveVcbNoOpCheck	(		IC,
			V
	)		FatAcquireExclusiveVcb_Real( IC, V, TRUE)

Definition at line 1461 of file fatprocs.h.

FatAcquireExclusiveVolume

#define FatAcquireExclusiveVolume	(		IRPCONTEXT,
			VCB
	)

Value:

    {                                     \
    PFCB __FFFFFcb = NULL;                                                                    \
    NT_ASSERT(FlagOn((IRPCONTEXT)->Flags, IRP_CONTEXT_FLAG_WAIT));                      \
    (VOID)FatAcquireExclusiveVcb( (IRPCONTEXT), (VCB) );                                \
    while ( (__FFFFFcb = FatGetNextFcbBottomUp((IRPCONTEXT), __FFFFFcb, (VCB)->RootDcb)) != NULL) { \
        (VOID)FatAcquireExclusiveFcb((IRPCONTEXT), __FFFFFcb );                               \
    }                                                                                   \
}

Definition at line 1409 of file fatprocs.h.

FatAcquireSharedGlobal

#define FatAcquireSharedGlobal

(

IRPCONTEXT

)

Value:

    (                                                                        \
    ExAcquireResourceSharedLite( &FatData.Resource, BooleanFlagOn((IRPCONTEXT)->Flags, IRP_CONTEXT_FLAG_WAIT) )     \
)

Definition at line 1391 of file fatprocs.h.

FatAreNamesEqual

#define FatAreNamesEqual	(		IRPCONTEXT,
			NAMEA,
			NAMEB
	)

Value:

    (      \
    ((ULONG)(NAMEA).Length == (ULONG)(NAMEB).Length) && \
    (RtlEqualMemory( &(NAMEA).Buffer[0],                \
                     &(NAMEB).Buffer[0],                \
                     (NAMEA).Length ))                  \
)

Definition at line 1158 of file fatprocs.h.

FatCompleteRequest

#define FatCompleteRequest	(		IRPCONTEXT,
			IRP,
			STATUS
	)

Value:

    { \
    FatCompleteRequest_Real(IRPCONTEXT,IRP,STATUS); \
}

Definition at line 2633 of file fatprocs.h.

FatConvertToSharedFcb

#define FatConvertToSharedFcb	(		IRPCONTEXT,
			Fcb
	)

Value:

    {                 \
    ExConvertExclusiveToSharedLite( (Fcb)->Header.Resource );   \
    }

Definition at line 1609 of file fatprocs.h.

FatDeleteIrpContext

#define FatDeleteIrpContext

(

IRPCONTEXT

)

Value:

    {   \
    FatDeleteIrpContext_Real((IRPCONTEXT)); \
}

Definition at line 1762 of file fatprocs.h.

FatDeleteResource

#define FatDeleteResource

(

RESRC

)

Value:

    {                      \
    ExDeleteResourceLite( (RESRC) );                    \
}

Definition at line 1632 of file fatprocs.h.

FatDeviceIsFatFsdo

#define FatDeviceIsFatFsdo

(

D

)

(((D) == FatData.DiskFileSystemDeviceObject) || ((D) == FatData.CdromFileSystemDeviceObject))

Definition at line 3095 of file fatprocs.h.

FatDirectoryKey

#define FatDirectoryKey

(

FcbOrDcb

)

((ULONGLONG)((FcbOrDcb)->CreationTime.QuadPart ^ (FcbOrDcb)->FirstClusterOfFile))

Definition at line 850 of file fatprocs.h.

FATDOT

#define FATDOT   ((ULONG)0x2020202E)

Definition at line 3074 of file fatprocs.h.

FATDOTDOT

#define FATDOTDOT   ((ULONG)0x20202E2E)

Definition at line 3075 of file fatprocs.h.

FatFcbAcquiredExclusive

#define FatFcbAcquiredExclusive	(		IRPCONTEXT,
			FCB
	)

Value:

    (                   \
    ExIsResourceAcquiredExclusiveLite((FCB)->Header.Resource)       \
)

Definition at line 1504 of file fatprocs.h.

FatFcbAcquiredShared

#define FatFcbAcquiredShared	(		IRPCONTEXT,
			FCB
	)

Value:

    (                      \
    ExIsResourceAcquiredSharedLite((FCB)->Header.Resource)          \
)

Definition at line 1500 of file fatprocs.h.

FatGenerateFileIdFromDirentAndOffset

#define FatGenerateFileIdFromDirentAndOffset	(		Dcb,
			Dirent,
			DirentOffset
	)

Value:

    ((*((PULONG)(Dirent)->FileName)) == FATDOT ? FatGenerateFileIdFromFcb(Dcb) :                    \
     ((*((PULONG)(Dirent)->FileName)) == FATDOTDOT ? ((Dcb)->ParentDcb ?                            \
                                                       FatGenerateFileIdFromFcb((Dcb)->ParentDcb) : \
                                                       0) :                                         \
      FatGenerateFileIdFromDirentOffset(Dcb,DirentOffset)))

Definition at line 3077 of file fatprocs.h.

FatGenerateFileIdFromDirentOffset

#define FatGenerateFileIdFromDirentOffset	(		ParentDcb,
			DirentOffset
	)

Value:

    ((ParentDcb) ? ((NodeType(ParentDcb) != FAT_NTC_ROOT_DCB || FatIsFat32((ParentDcb)->Vcb)) ?     \
                  FatGetLboFromIndex( (ParentDcb)->Vcb,                                             \
                                      (ParentDcb)->FirstClusterOfFile ) :                           \
                  (ParentDcb)->Vcb->AllocationSupport.RootDirectoryLbo) +                           \
                 (DirentOffset)                                                                     \
                  :                                                                                 \
                 0)

Definition at line 3054 of file fatprocs.h.

FatGenerateFileIdFromFcb

#define FatGenerateFileIdFromFcb

(

Fcb

)

FatGenerateFileIdFromDirentOffset( (Fcb)->ParentDcb, (Fcb)->DirentOffsetWithinDirectory )

Definition at line 3066 of file fatprocs.h.

FatGetFcbOplock

#define FatGetFcbOplock

(

F

)

&(F)->Header.Oplock

Definition at line 1656 of file fatprocs.h.

FatGetFirstChild

#define FatGetFirstChild

(

DIR

)

Value:

    ((PFCB)(                          \
    IsListEmpty(&(DIR)->Specific.Dcb.ParentDcbQueue) ? NULL :   \
    CONTAINING_RECORD((DIR)->Specific.Dcb.ParentDcbQueue.Flink, \
                      DCB,                                      \
                      ParentDcbLinks.Flink)))

Definition at line 1785 of file fatprocs.h.

FatGetNextSibling

#define FatGetNextSibling

(

FILE

)

Value:

    ((PFCB)(                     \
    &(FILE)->ParentDcb->Specific.Dcb.ParentDcbQueue.Flink == \
    (PVOID)(FILE)->ParentDcbLinks.Flink ? NULL :             \
    CONTAINING_RECORD((FILE)->ParentDcbLinks.Flink,          \
                      FCB,                                   \
                      ParentDcbLinks.Flink)))

Definition at line 1791 of file fatprocs.h.

FatIsFastIoPossible

#define FatIsFastIoPossible

(

FCB

)

Value:

    ((BOOLEAN)                                     \
    ((((FCB)->FcbCondition != FcbGood) ||                                       \
      (NodeType( (FCB) ) != FAT_NTC_FCB) ||                                     \
      !FsRtlOplockIsFastIoPossible( FatGetFcbOplock(FCB) )) ?                   \
        FastIoIsNotPossible                                                     \
    :                                                                           \
        (!FsRtlAreThereCurrentFileLocks( &(FCB)->Specific.Fcb.FileLock ) &&     \
         ((FCB)->NonPaged->OutstandingAsyncWrites == 0) &&                      \
         !FlagOn( (FCB)->Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED ) ?      \
            FastIoIsPossible                                                    \
        :                                                                       \
            FastIoIsQuestionable                                                \
        )                                                                       \
    )                                                                           \
)

Definition at line 2813 of file fatprocs.h.

FatIsFat12

#define FatIsFat12

(

VCB

)

((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 12))

Definition at line 1448 of file fatprocs.h.

FatIsFat16

#define FatIsFat16

(

VCB

)

((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 16))

Definition at line 1447 of file fatprocs.h.

FatIsFat32

#define FatIsFat32

(

VCB

)

((BOOLEAN)((VCB)->AllocationSupport.FatIndexBitSize == 32))

Definition at line 1446 of file fatprocs.h.

FatIsFileOplockable

#define FatIsFileOplockable

(

F

)

Value:

    (                \
    FatIsNodeTypeOplockable( NodeType( (F) ))   \
)

Definition at line 2851 of file fatprocs.h.

FatIsNameLongOemValid

#define FatIsNameLongOemValid	(		IRPCONTEXT,
			NAME,
			CAN_CONTAIN_WILD_CARDS,
			PATH_NAME_OK,
			LEADING_BACKSLASH_OK
	)

Value:

    ( \
    FsRtlIsHpfsDbcsLegal((NAME),                  \
                        (CAN_CONTAIN_WILD_CARDS), \
                        (PATH_NAME_OK),           \
                        (LEADING_BACKSLASH_OK))   \
)

Definition at line 1205 of file fatprocs.h.

FatIsNameShortOemValid

#define FatIsNameShortOemValid	(		IRPCONTEXT,
			NAME,
			CAN_CONTAIN_WILD_CARDS,
			PATH_NAME_OK,
			LEADING_BACKSLASH_OK
	)

Value:

    ( \
    FsRtlIsFatDbcsLegal((NAME),                   \
                        (CAN_CONTAIN_WILD_CARDS), \
                        (PATH_NAME_OK),           \
                        (LEADING_BACKSLASH_OK))   \
)

Definition at line 1198 of file fatprocs.h.

FatIsNodeTypeOplockable

#define FatIsNodeTypeOplockable

(

N

)

Value:

    (    \
    ((N) == FAT_NTC_FCB) ||             \
    ((N) == FAT_NTC_ROOT_DCB) ||        \
    ((N) == FAT_NTC_DCB)                \
)

Definition at line 2837 of file fatprocs.h.

FatIsRawDevice

#define FatIsRawDevice	(		IC,
			S
	)

Value:

    (          \
    ((S) == STATUS_DEVICE_NOT_READY) || \
    ((S) == STATUS_NO_MEDIA_IN_DEVICE)  \
)

Definition at line 1845 of file fatprocs.h.

FatNormalizeAndRaiseStatus

#define FatNormalizeAndRaiseStatus	(		IRPCONTEXT,
			STATUS
	)

Value:

    {                         \
    (IRPCONTEXT)->ExceptionStatus = (STATUS);                                   \
    ExRaiseStatus(FsRtlNormalizeNtstatus((STATUS),STATUS_UNEXPECTED_IO_ERROR)); \
}

Definition at line 2995 of file fatprocs.h.

FatNotifyReportChange

#define FatNotifyReportChange	(		I,
			V,
			F,
			FL,
			A
	)

Value:

    {                                                         \
    if ((F)->FullFileName.Buffer == NULL) {                                                         \
        FatSetFullFileNameInFcb((I),(F));                                                           \
    }                                                                                               \
    NT_ASSERT( (F)->FullFileName.Length != 0 );                                                     \
    NT_ASSERT( (F)->FinalNameLength != 0 );                                                         \
    NT_ASSERT( (F)->FullFileName.Length > (F)->FinalNameLength );                                   \
    NT_ASSERT( (F)->FullFileName.Buffer[((F)->FullFileName.Length - (F)->FinalNameLength)/sizeof(WCHAR) - 1] == L'\\' ); \
    FsRtlNotifyFullReportChange( (V)->NotifySync,                                                   \
                                 &(V)->DirNotifyList,                                               \
                                 (PSTRING)&(F)->FullFileName,                                       \
                                 (USHORT) ((F)->FullFileName.Length -                               \
                                           (F)->FinalNameLength),                                   \
                                 (PSTRING)NULL,                                                     \
                                 (PSTRING)NULL,                                                     \
                                 (ULONG)FL,                                                         \
                                 (ULONG)A,                                                          \
                                 (PVOID)NULL );                                                     \
}

Definition at line 2168 of file fatprocs.h.

FatRaiseStatus

#define FatRaiseStatus	(		IRPCONTEXT,
			STATUS
	)

Value:

    {             \
    (IRPCONTEXT)->ExceptionStatus = (STATUS);           \
    DebugBreakOnStatus( (STATUS) )                      \
    ExRaiseStatus( (STATUS) );                          \
}

Definition at line 2977 of file fatprocs.h.

FatReleaseDirectoryFileMutex

#define FatReleaseDirectoryFileMutex

(

VCB

)

Value:

    {                         \
    NT_ASSERT(KeAreApcsDisabled());                                 \
    ExReleaseFastMutexUnsafe(&(VCB)->DirectoryFileCreationMutex);   \
}

Definition at line 1513 of file fatprocs.h.

FatReleaseFcb

#define FatReleaseFcb	(		IRPCONTEXT,
			Fcb
	)

Value:

    {                 \
    ExReleaseResourceLite( (Fcb)->Header.Resource );    \
    }

Definition at line 1644 of file fatprocs.h.

FatReleaseGlobal

#define FatReleaseGlobal

(

IRPCONTEXT

)

Value:

    {                  \
    ExReleaseResourceLite( &(FatData.Resource) );       \
    }

Definition at line 1636 of file fatprocs.h.

FatReleaseVcb

#define FatReleaseVcb	(		IRPCONTEXT,
			Vcb
	)

Value:

    {                 \
    ExReleaseResourceLite( &((Vcb)->Resource) );        \
    }

Definition at line 1640 of file fatprocs.h.

FatReleaseVolume

#define FatReleaseVolume	(		IRPCONTEXT,
			VCB
	)

Value:

    {                                              \
    PFCB __FFFFFcb = NULL;                                                                    \
    NT_ASSERT(FlagOn((IRPCONTEXT)->Flags, IRP_CONTEXT_FLAG_WAIT));                      \
    while ( (__FFFFFcb = FatGetNextFcbBottomUp((IRPCONTEXT), __FFFFFcb, (VCB)->RootDcb)) != NULL) { \
        (VOID)ExReleaseResourceLite( __FFFFFcb->Header.Resource );                            \
    }                                                                                   \
    FatReleaseVcb((IRPCONTEXT), (VCB));                                                 \
}

Definition at line 1418 of file fatprocs.h.

FatResetExceptionState

#define FatResetExceptionState

(

IRPCONTEXT

)

Value:

    {          \
    (IRPCONTEXT)->ExceptionStatus = STATUS_SUCCESS;     \
}

Definition at line 2983 of file fatprocs.h.

FatSetVcbCondition

#define FatSetVcbCondition	(		V,
			X
	)		(V)->VcbCondition = (X)

Definition at line 1438 of file fatprocs.h.

FatUnpinBcb

#define FatUnpinBcb	(		IRPCONTEXT,
			BCB
	)

Value:

    { \
    if ((BCB) != NULL) {              \
        CcUnpinData((BCB));           \
        (BCB) = NULL;                 \
    }                                 \
}

Definition at line 546 of file fatprocs.h.

FatUpcaseEaName

#define FatUpcaseEaName	(		IRPCONTEXT,
			NAME,
			UPCASEDNAME
	)		RtlUpperString( UPCASEDNAME, NAME )

Definition at line 868 of file fatprocs.h.

FatVcbAcquiredExclusive

#define FatVcbAcquiredExclusive	(		IRPCONTEXT,
			VCB
	)

Value:

    (                   \
    ExIsResourceAcquiredExclusiveLite(&(VCB)->Resource)  ||         \
    ExIsResourceAcquiredExclusiveLite(&FatData.Resource)            \
)

Definition at line 1495 of file fatprocs.h.

INLINE

#define INLINE   __inline

Definition at line 77 of file fatprocs.h.

IsDirectory

#define IsDirectory

(

FcbOrDcb

)

((NodeType((FcbOrDcb)) == FAT_NTC_DCB) || (NodeType((FcbOrDcb)) == FAT_NTC_ROOT_DCB))

Definition at line 3106 of file fatprocs.h.

IsFileDeleted

#define IsFileDeleted	(		IRPCONTEXT,
			FCB
	)

Value:

    (FlagOn((FCB)->FcbState, FCB_STATE_DELETE_ON_CLOSE) && \
     ((FCB)->UncleanCount == 0))

Definition at line 2781 of file fatprocs.h.

IsFileObjectReadOnly

#define IsFileObjectReadOnly

(

FO

)

(!((FO)->WriteAccess | (FO)->DeleteAccess))

Definition at line 2866 of file fatprocs.h.

IsFileWriteThrough

#define IsFileWriteThrough	(		FO,
			VCB
	)

Value:

    (             \
    BooleanFlagOn((FO)->Flags, FO_WRITE_THROUGH) \
)

Definition at line 2796 of file fatprocs.h.

LongAlign

#define LongAlign

(

Ptr

)

Value:

    (                \
    ((((ULONG)(Ptr)) + 3) & 0xfffffffc) \
    )

Definition at line 2096 of file fatprocs.h.

MAX_ULONG

#define MAX_ULONG   ((ULONG)-1)

Definition at line 83 of file fatprocs.h.

MAX_USHORT

#define MAX_USHORT   ((USHORT)-1)

Definition at line 87 of file fatprocs.h.

PtrOffset

#define PtrOffset	(		BASE,
			OFFSET
	)		((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))

Definition at line 2080 of file fatprocs.h.

QuadAlign

#define QuadAlign

(

Ptr

)

Value:

    (                \
    ((((ULONG)(Ptr)) + 7) & 0xfffffff8) \
    )

Definition at line 2105 of file fatprocs.h.

SizeOfFullEa

#define SizeOfFullEa

(

EA

)

(4+1+1+2+(EA)->EaNameLength+1+(EA)->EaValueLength)

Definition at line 1030 of file fatprocs.h.

try_leave

#define try_leave

(

S

)

{ S; _SEH2_LEAVE; }

Definition at line 3030 of file fatprocs.h.

try_return

#define try_return

(

S

)

{ S; goto try_exit; }

Definition at line 3029 of file fatprocs.h.

WordAlign

#define WordAlign

(

Ptr

)

Value:

    (                \
    ((((ULONG)(Ptr)) + 1) & 0xfffffffe) \
    )

Definition at line 2087 of file fatprocs.h.

Typedef Documentation

COMPARISON

typedef enum _COMPARISON COMPARISON

FAT_ENUMERATION_CONTEXT

typedef struct _FAT_ENUMERATION_CONTEXT FAT_ENUMERATION_CONTEXT

FAT_FLUSH_TYPE

typedef enum _FAT_FLUSH_TYPE FAT_FLUSH_TYPE

FAT_VOLUME_STATE

typedef enum _FAT_VOLUME_STATE FAT_VOLUME_STATE

FINISHED

typedef BOOLEAN FINISHED

Definition at line 104 of file fatprocs.h.

PFAT_ENUMERATION_CONTEXT

typedef struct _FAT_ENUMERATION_CONTEXT * PFAT_ENUMERATION_CONTEXT

PFAT_VOLUME_STATE

typedef enum _FAT_VOLUME_STATE * PFAT_VOLUME_STATE

PUCHAR1

typedef union _UCHAR1 * PUCHAR1

PUCHAR2

typedef union _UCHAR2 * PUCHAR2

PUCHAR4

typedef union _UCHAR4 * PUCHAR4

TYPE_OF_OPEN

typedef enum _TYPE_OF_OPEN TYPE_OF_OPEN

UCHAR1

typedef union _UCHAR1 UCHAR1

UCHAR2

typedef union _UCHAR2 UCHAR2

UCHAR4

typedef union _UCHAR4 UCHAR4

Enumeration Type Documentation

_COMPARISON

enum _COMPARISON

Enumerator
IsLessThan
IsGreaterThan
IsEqual

Definition at line 1883 of file fatprocs.h.

                         {
    IsLessThan,
    IsGreaterThan,
    IsEqual
} COMPARISON;

_FAT_FLUSH_TYPE

enum _FAT_FLUSH_TYPE

Enumerator
NoFlush
Flush
FlushAndInvalidate
FlushWithoutPurge

Definition at line 1051 of file fatprocs.h.

                             {
 
    NoFlush = 0,
    Flush,
    FlushAndInvalidate,
    FlushWithoutPurge
 
} FAT_FLUSH_TYPE;

_FAT_VOLUME_STATE

enum _FAT_VOLUME_STATE

Enumerator
VolumeClean
VolumeDirty
VolumeDirtyWithSurfaceTest

Definition at line 1953 of file fatprocs.h.

                               {
    VolumeClean,
    VolumeDirty,
    VolumeDirtyWithSurfaceTest
} FAT_VOLUME_STATE, *PFAT_VOLUME_STATE;

_TYPE_OF_OPEN

enum _TYPE_OF_OPEN

Enumerator
UnopenedFileObject
StreamFileOpen
UserVolumeOpen
UserDirectoryOpen
UserFileOpen
BeyondValidType
UnopenedFileObject
UserFileOpen
UserDirectoryOpen
UserVolumeOpen
VirtualVolumeFile
DirectoryFile
EaFile

Definition at line 1039 of file fatprocs.h.

                           {
 
    UnopenedFileObject = 1,
    UserFileOpen,
    UserDirectoryOpen,
    UserVolumeOpen,
    VirtualVolumeFile,
    DirectoryFile,
    EaFile,
} TYPE_OF_OPEN;

Function Documentation

_Acquires_exclusive_lock_()

_Acquires_exclusive_lock_

(

Vcb->

Resource

)

_Acquires_shared_lock_()

_Acquires_shared_lock_

(

Vcb->

Resource

)

_Function_class_() [1/28]

_Function_class_

(

FAST_IO_ACQUIRE_FOR_CCFLUSH

)

_Function_class_() [2/28]

_Function_class_

(

FAST_IO_CHECK_IF_POSSIBLE

)

_Function_class_() [3/28]

_Function_class_

(

FAST_IO_LOCK

)

_Function_class_() [4/28]

_Function_class_

(

FAST_IO_QUERY_BASIC_INFO

)

_Function_class_() [5/28]

_Function_class_

(

FAST_IO_QUERY_NETWORK_OPEN_INFO

)

_Function_class_() [6/28]

_Function_class_

(

FAST_IO_QUERY_STANDARD_INFO

)

_Function_class_() [7/28]

_Function_class_

(

FAST_IO_RELEASE_FOR_CCFLUSH

)

_Function_class_() [8/28]

_Function_class_

(

FAST_IO_UNLOCK_ALL

)

_Function_class_() [9/28]

_Function_class_

(

FAST_IO_UNLOCK_ALL_BY_KEY

)

_Function_class_() [10/28]

_Function_class_

(

FAST_IO_UNLOCK_SINGLE

)

_Function_class_() [11/28]

_Function_class_

(

IRP_MJ_CLEANUP

)

_Function_class_() [12/28]

_Function_class_

(

IRP_MJ_CLOSE

)

_Function_class_() [13/28]

_Function_class_

(

IRP_MJ_CREATE

)

_Function_class_() [14/28]

_Function_class_

(

IRP_MJ_DEVICE_CONTROL

)

_Function_class_() [15/28]

_Function_class_

(

IRP_MJ_DIRECTORY_CONTROL

)

_Function_class_() [16/28]

_Function_class_

(

IRP_MJ_FILE_SYSTEM_CONTROL

)

_Function_class_() [17/28]

_Function_class_

(

IRP_MJ_FLUSH_BUFFERS

)

_Function_class_() [18/28]

_Function_class_

(

IRP_MJ_LOCK_CONTROL

)

_Function_class_() [19/28]

_Function_class_

(

IRP_MJ_PNP

)

_Function_class_() [20/28]

_Function_class_

(

IRP_MJ_QUERY_EA

)

_Function_class_() [21/28]

_Function_class_

(

IRP_MJ_QUERY_INFORMATION

)

_Function_class_() [22/28]

_Function_class_

(

IRP_MJ_QUERY_VOLUME_INFORMATION

)

_Function_class_() [23/28]

_Function_class_

(

IRP_MJ_READ

)

_Function_class_() [24/28]

_Function_class_

(

IRP_MJ_SET_EA

)

_Function_class_() [25/28]

_Function_class_

(

IRP_MJ_SET_INFORMATION

)

_Function_class_() [26/28]

_Function_class_

(

IRP_MJ_SET_VOLUME_INFORMATION

)

_Function_class_() [27/28]

_Function_class_

(

IRP_MJ_SHUTDOWN

)

_Function_class_() [28/28]

_Function_class_

(

IRP_MJ_WRITE

)

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

_Success_()

_Success_

(

return !

= FALSE

)

Definition at line 1042 of file fsctrl.c.

{
    PLIST_ENTRY Link;
 
    PVPB Vpb = Vcb->Vpb;
    PVPB OldVpb;
 
    BOOLEAN Remount = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check whether we are looking for a device only Mvcb.
    //
 
    for (Link = CdData.VcbQueue.Flink;
         Link != &CdData.VcbQueue;
         Link = Link->Flink) {
 
        *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
 
        //
        //  Skip ourselves.
        //
 
        if (Vcb == *OldVcb) { continue; }
 
        //
        //  Look at the Vpb and state of the previous Vcb.
        //
 
        OldVpb = (*OldVcb)->Vpb;
 
        if ((OldVpb != Vpb) &&
            (OldVpb->RealDevice == Vpb->RealDevice) &&
            ((*OldVcb)->VcbCondition == VcbNotMounted)) {
 
            //
            //  If the current disk is a raw disk then it can match a previous music or
            //  raw disk.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
                if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                    //
                    //  If we have both TOC then fail the remount if the lengths
                    //  are different or they don't match.
                    //
 
                    if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
                        ((Vcb->TocLength != 0) &&
                         !RtlEqualMemory( Vcb->CdromToc,
                                          (*OldVcb)->CdromToc,
                                          Vcb->TocLength ))) {
 
                        continue;
                    }
 
                    Remount = TRUE;
                    break;
                }
 
            //
            //  The current disk is not a raw disk.  Go ahead and compare
            //  serial numbers, volume label and TOC.
            //
 
            }
            else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
                     (Vcb->TocLength == (*OldVcb)->TocLength) &&
                     ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
                                                               (*OldVcb)->CdromToc,
                                                               Vcb->TocLength )) &&
                     (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
                     (RtlEqualMemory( OldVpb->VolumeLabel,
                                        Vpb->VolumeLabel,
                                        Vpb->VolumeLabelLength ))) {
                //
                //  Remember the old Vcb.  Then set the return value to
                //  TRUE and break.
                //
 
                Remount = TRUE;
                break;
            }
        }
    }
 
    return Remount;
}

Fat8dot3ToString()

VOID Fat8dot3ToString	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PDIRENT	Dirent,
		_In_ BOOLEAN	RestoreCase,
		_Out_ POEM_STRING	OutputString
	)

Definition at line 179 of file namesup.c.

{
    ULONG StringIndex;
    ULONG BaseLength, ExtensionLength;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "Fat8dot3ToString\n", 0);
 
    //
    //  First, find the length of the base component.
    //
 
    for (BaseLength = 8; BaseLength > 0; BaseLength -= 1) {
 
        if (Dirent->FileName[BaseLength - 1] != UCHAR_SP) {
 
            break;
        }
    }
 
    //
    //  Now find the length of the extension.
    //
 
    for (ExtensionLength = 3; ExtensionLength > 0; ExtensionLength -= 1) {
 
        if (Dirent->FileName[8 + ExtensionLength - 1] != UCHAR_SP) {
 
            break;
        }
    }
 
    //
    //  If there was a base part, copy it and check the case.  Don't forget
    //  if the first character needs to be changed from 0x05 to 0xe5.
    //
 
    if (BaseLength != 0) {
 
        RtlCopyMemory( OutputString->Buffer, Dirent->FileName, BaseLength );
 
        if (OutputString->Buffer[0] == FAT_DIRENT_REALLY_0E5) {
 
            OutputString->Buffer[0] = 0xe5;
        }
 
        //
        //  Now if we are to restore case, look for A-Z
        //
 
        if (FatData.ChicagoMode &&
            RestoreCase &&
            FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_8_LOWER_CASE)) {
 
            for (StringIndex = 0; StringIndex < BaseLength; StringIndex += 1) {
 
                //
                //  Depending on whether the media was built in a system that was
                //  running with "code page invariance" (see FatEvaluateNameCase),
                //  there could be double-byte OEM characters lying in wait here.
                //  Gotta skip them.
                //
 
                if (FsRtlIsLeadDbcsCharacter(OutputString->Buffer[StringIndex])) {
 
                    StringIndex += 1;
                    continue;
                }
 
                if ((OutputString->Buffer[StringIndex] >= 'A') &&
                    (OutputString->Buffer[StringIndex] <= 'Z')) {
 
                    OutputString->Buffer[StringIndex] += 'a' - 'A';
                }
            }
        }
    }
 
    //
    //  If there was an extension, copy that over.  Else we now know the
    //  size of the string.
    //
 
    if (ExtensionLength != 0) {
 
        PUCHAR o, d;
 
        //
        //  Now add the dot
        //
 
        OutputString->Buffer[BaseLength++] = '.';
 
        //
        //  Copy over the extension into the output buffer.
        //
 
        o = (PUCHAR)&OutputString->Buffer[BaseLength];
        d = &Dirent->FileName[8];
 
        switch (ExtensionLength) {
        case 3:
            *o++ = *d++;
        case 2:
            *o++ = *d++;
        case 1:
            *o++ = *d++;
        }
 
        //
        //  Set the output string length
        //
 
        OutputString->Length = (USHORT)(BaseLength + ExtensionLength);
 
        //
        //  Now if we are to restore case, look for A-Z
        //
 
        if (FatData.ChicagoMode &&
            RestoreCase &&
            FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_3_LOWER_CASE)) {
 
            for (StringIndex = BaseLength;
                 StringIndex < OutputString->Length;
                 StringIndex++ ) {
 
                //
                //  Depending on whether the media was built in a system that was
                //  running with "code page invariance" (see FatEvaluateNameCase),
                //  there could be double-byte OEM characters lying in wait here.
                //  Gotta skip them.
                //
 
                if (FsRtlIsLeadDbcsCharacter(OutputString->Buffer[StringIndex])) {
 
                    StringIndex += 1;
                    continue;
                }
 
                if ((OutputString->Buffer[StringIndex] >= 'A') &&
                    (OutputString->Buffer[StringIndex] <= 'Z')) {
 
                    OutputString->Buffer[StringIndex] += 'a' - 'A';
                }
            }
        }
 
    } else {
 
        //
        //  Set the output string length
        //
 
        OutputString->Length = (USHORT)BaseLength;
    }
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "Fat8dot3ToString, OutputString = \"%Z\" -> VOID\n", OutputString);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by _Requires_lock_held_(), and FatConstructNamesInFcb().

FatAcquireSharedFcbWaitForEx()

_Acquires_shared_lock_ Fcb FINISHED FatAcquireSharedFcbWaitForEx	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb
	)

Referenced by _Requires_lock_held_().

FatAcquireVolumeForClose()

BOOLEAN FatAcquireVolumeForClose	(	IN PVOID	Vcb,
		IN BOOLEAN	Wait
	)

FatAddMcbEntry()

BOOLEAN FatAddMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		IN LBO	Lbo,
		IN ULONG	SectorCount
	)

Definition at line 364 of file fsctrl.c.

{
    BOOLEAN Result;
#if DBG
    VBO SparseVbo;
    LONGLONG SparseByteCount;
#endif
 
    PAGED_CODE();
 
    if (SectorCount) {
 
        //
        //  Round up sectors, but be careful as SectorCount approaches 4Gb.
        //  Note that for x>0, (x+m-1)/m = ((x-1)/m)+(m/m) = ((x-1)/m)+1
        //
 
        SectorCount--;
        SectorCount >>= MCB_SCALE_LOG2;
        SectorCount++;
    }
 
    Vbo >>= MCB_SCALE_LOG2;
    Lbo >>= MCB_SCALE_LOG2;
 
    NT_ASSERT( SectorCount != 0 );
 
    if (Mcb != &Vcb->DirtyFatMcb) {
        NT_ASSERT( FatNonSparseMcb( Vcb, Mcb, &SparseVbo, &SparseByteCount ) ||
                ((SparseVbo == Vbo) && (SparseByteCount == SectorCount )) );
    }
 
    Result = FsRtlAddLargeMcbEntry( Mcb,
                                  ((LONGLONG) Vbo),
                                  ((LONGLONG) Lbo),
                                  ((LONGLONG) SectorCount) );
 
    if (Mcb != &Vcb->DirtyFatMcb) {
        NT_ASSERT( FatNonSparseMcb( Vcb, Mcb, &SparseVbo, &SparseByteCount ) ||
                ((SparseVbo == Vbo) && (SparseByteCount == SectorCount )) );
    }
 
    return Result;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), FatExamineFatEntries(), and FatSetFatRun().

FatAddToWorkque()

VOID FatAddToWorkque	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 280 of file workque.c.

{
    KIRQL SavedIrql;
    PIO_STACK_LOCATION IrpSp;
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Check if this request has an associated file object, and thus volume
    //  device object.
    //
 
    if ( IrpSp->FileObject != NULL ) {
 
        PVOLUME_DEVICE_OBJECT Vdo;
 
        Vdo = CONTAINING_RECORD( IrpSp->DeviceObject,
                                 VOLUME_DEVICE_OBJECT,
                                 DeviceObject );
 
        //
        //  Check to see if this request should be sent to the overflow
        //  queue.  If not, then send it off to an exworker thread.
        //
 
        KeAcquireSpinLock( &Vdo->OverflowQueueSpinLock, &SavedIrql );
 
        if ( Vdo->PostedRequestCount > FSP_PER_DEVICE_THRESHOLD) {
 
            //
            //  We cannot currently respond to this IRP so we'll just enqueue it
            //  to the overflow queue on the volume.
            //
 
            InsertTailList( &Vdo->OverflowQueue,
                            &IrpContext->WorkQueueItem.List );
 
            Vdo->OverflowQueueCount += 1;
 
            KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
 
            return;
 
        } else {
 
            //
            //  We are going to send this Irp to an ex worker thread so up
            //  the count.
            //
 
            Vdo->PostedRequestCount += 1;
 
            KeReleaseSpinLock( &Vdo->OverflowQueueSpinLock, SavedIrql );
        }
    }
 
    //
    //  Send it off.....
    //
 
    ExInitializeWorkItem( &IrpContext->WorkQueueItem,
                          FatFspDispatch,
                          IrpContext );
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "prefast indicates this is an obsolete API but it is ok for fastfat to keep using it." )
#endif
    ExQueueWorkItem( &IrpContext->WorkQueueItem, CriticalWorkQueue );
 
    return;
}

Referenced by _Requires_lock_held_(), FatFsdPostRequest(), and FatOplockComplete().

FatAllocateCloseContext()

PCLOSE_CONTEXT FatAllocateCloseContext

(

IN PVCB

Vcb

)

FatAppendPackedEa()

VOID FatAppendPackedEa	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_SET_HEADER *	EaSetHeader,
		IN OUT PULONG	PackedEasLength,
		IN OUT PULONG	AllocationLength,
		IN PFILE_FULL_EA_INFORMATION	FullEa,
		IN ULONG	BytesPerCluster
	)

Definition at line 2967 of file easup.c.

{
    ULONG PackedEaSize;
    PPACKED_EA ThisPackedEa;
    OEM_STRING EaName;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatAppendPackedEa...\n", 0);
 
    //
    //  As a quick check see if the computed packed ea size plus the
    //  current packed ea list size will overflow the buffer.  Full Ea and
    //  packed Ea only differ by 4 in their size
    //
 
    PackedEaSize = SizeOfFullEa( FullEa ) - 4;
 
    if ( PackedEaSize + *PackedEasLength > *AllocationLength ) {
 
        //
        //  We will overflow our current work buffer so allocate a larger
        //  one and copy over the current buffer
        //
 
        PVOID Temp;
        ULONG NewAllocationSize;
        ULONG OldAllocationSize;
 
        DebugTrace(0, Dbg, "Allocate a new ea list buffer\n", 0);
 
        //
        //  Compute a new size and allocate space.  Always increase the
        //  allocation in cluster increments.
        //
 
        NewAllocationSize = (SIZE_OF_EA_SET_HEADER
                             + PackedEaSize
                             + *PackedEasLength
                             + BytesPerCluster - 1)
                            & ~(BytesPerCluster - 1);
 
        Temp = FsRtlAllocatePoolWithTag( PagedPool,
                                         NewAllocationSize,
                                         TAG_EA_SET_HEADER );
 
        //
        //  Move over the existing ea list, and deallocate the old one
        //
 
        RtlCopyMemory( Temp,
                       *EaSetHeader,
                       OldAllocationSize = *AllocationLength
                                           + SIZE_OF_EA_SET_HEADER );
 
        ExFreePool( *EaSetHeader );
 
        //
        //  Set up so we will use the new packed ea list
        //
 
        *EaSetHeader = Temp;
 
        //
        //  Zero out the added memory.
        //
 
        RtlZeroMemory( &(*EaSetHeader)->PackedEas[*AllocationLength],
                       NewAllocationSize - OldAllocationSize );
 
        *AllocationLength = NewAllocationSize - SIZE_OF_EA_SET_HEADER;
    }
 
    //
    //  Determine if we need to increment our need ea changes count
    //
 
    if ( FlagOn(FullEa->Flags, FILE_NEED_EA )) {
 
        //
        //  The NeedEaCount field is long aligned so we will write
        //  directly to it.
        //
 
        (*EaSetHeader)->NeedEaCount++;
    }
 
    //
    //  Now copy over the ea, full ea's and packed ea are identical except
    //  that full ea also have a next ea offset that we skip over
    //
    //  Before:
    //             UsedSize                     Allocated
    //                |                             |
    //                V                             V
    //      +xxxxxxxx+-----------------------------+
    //
    //  After:
    //                              UsedSize    Allocated
    //                                 |            |
    //                                 V            V
    //      +xxxxxxxx+yyyyyyyyyyyyyyyy+------------+
    //
 
    ThisPackedEa = (PPACKED_EA) (RtlOffsetToPointer( (*EaSetHeader)->PackedEas,
                                                     *PackedEasLength ));
 
    RtlCopyMemory( ThisPackedEa,
                   (PUCHAR) FullEa + 4,
                   PackedEaSize );
 
    //
    //  Now convert the name to uppercase.
    //
 
    EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
    EaName.Buffer = ThisPackedEa->EaName;
 
    FatUpcaseEaName( IrpContext, &EaName, &EaName );
 
    //
    //  Increment the used size in the packed ea list structure
    //
 
    *PackedEasLength += PackedEaSize;
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatAppendPackedEa -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by FatCommonSetEa().

FatBufferUserBuffer()

PVOID FatBufferUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp,
		IN ULONG	BufferLength
	)

Definition at line 3411 of file deviosup.c.

{
    PUCHAR UserBuffer;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    //  Handle the no buffer case.
    //
 
    if (BufferLength == 0) {
 
        return NULL;
    }
 
    //
    //  If there is no system buffer we must have been supplied an Mdl
    //  describing the users input buffer, which we will now snapshot.
    //
 
    if (Irp->AssociatedIrp.SystemBuffer == NULL) {
 
        UserBuffer = FatMapUserBuffer( IrpContext, Irp );
 
        Irp->AssociatedIrp.SystemBuffer = FsRtlAllocatePoolWithQuotaTag( NonPagedPoolNx,
                                                                         BufferLength,
                                                                         TAG_IO_USER_BUFFER );
 
        //
        // Set the flags so that the completion code knows to deallocate the
        // buffer.
        //
 
        Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
 
        _SEH2_TRY {
 
            RtlCopyMemory( Irp->AssociatedIrp.SystemBuffer,
                           UserBuffer,
                           BufferLength );
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
 
              NTSTATUS Status;
 
              Status = _SEH2_GetExceptionCode();
              FatRaiseStatus( IrpContext,
                              FsRtlIsNtstatusExpected(Status) ? Status : STATUS_INVALID_USER_BUFFER );
        } _SEH2_END;
    }
 
    return Irp->AssociatedIrp.SystemBuffer;
}

Referenced by FatCommonSetEa().

FatBuildZeroMdl()

PMDL FatBuildZeroMdl	(	__in PIRP_CONTEXT	IrpContext,
		__in ULONG	Length
	)

Definition at line 3734 of file deviosup.c.

{
    PMDL ZeroMdl;
    ULONG SavedByteCount;
    PPFN_NUMBER Page;
    ULONG i;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Spin down trying to get an MDL which can describe our operation.
    //
 
    while (TRUE) {
 
        ZeroMdl = IoAllocateMdl( FatData.ZeroPage, Length, FALSE, FALSE, NULL );
 
        //
        //  Throttle ourselves to what we've physically allocated.  Note that
        //  we could have started with an odd multiple of this number.  If we
        //  tried for exactly that size and failed, we're toast.
        //
 
        if (ZeroMdl || (Length <= PAGE_SIZE)) {
 
            break;
        }
 
        //
        //  Fallback by half and round down to a page multiple.
        //
 
        ASSERT( IrpContext->Vcb->Bpb.BytesPerSector <= PAGE_SIZE );
        Length = BlockAlignTruncate( Length / 2, PAGE_SIZE );
        if (Length < PAGE_SIZE) {
            Length = PAGE_SIZE;
        }
    }
 
    if (ZeroMdl == NULL) {
        return NULL;
    }
 
    //
    //  If we have throttled all the way down, stop and just build a
    //  simple MDL describing our previous allocation.
    //
 
    if (Length == PAGE_SIZE) {
 
        MmBuildMdlForNonPagedPool( ZeroMdl );
        return ZeroMdl;
    }
 
    //
    //  Now we will temporarily lock the allocated pages
    //  only, and then replicate the page frame numbers through
    //  the entire Mdl to keep writing the same pages of zeros.
    //
    //  It would be nice if Mm exported a way for us to not have
    //  to pull the Mdl apart and rebuild it ourselves, but this
    //  is so bizarre a purpose as to be tolerable.
    //
 
    SavedByteCount = ZeroMdl->ByteCount;
    ZeroMdl->ByteCount = PAGE_SIZE;
    MmBuildMdlForNonPagedPool( ZeroMdl );
 
    ZeroMdl->MdlFlags &= ~MDL_SOURCE_IS_NONPAGED_POOL;
    ZeroMdl->MdlFlags |= MDL_PAGES_LOCKED;
    ZeroMdl->MappedSystemVa = NULL;
    ZeroMdl->StartVa = NULL;
    ZeroMdl->ByteCount = SavedByteCount;
    Page = MmGetMdlPfnArray( ZeroMdl );
    for (i = 1; i < (ADDRESS_AND_SIZE_TO_SPAN_PAGES( 0, SavedByteCount )); i++) {
        *(Page + i) = *(Page);
    }
 
 
    return ZeroMdl;
}

FatCheckDirtyBit()

VOID FatCheckDirtyBit	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 1185 of file verfysup.c.

{
    BOOLEAN Dirty;
 
    PPACKED_BOOT_SECTOR BootSector;
    PBCB BootSectorBcb;
 
    UNICODE_STRING VolumeLabel;
 
    PAGED_CODE();
 
    //
    //  Look in the boot sector
    //
 
    FatReadVolumeFile( IrpContext,
                       Vcb,
                       0,
                       sizeof(PACKED_BOOT_SECTOR),
                       &BootSectorBcb,
                       (PVOID *)&BootSector );
 
    _SEH2_TRY {
 
        //
        //  Check if the magic bit is set
        //
 
        if (IsBpbFat32(&BootSector->PackedBpb)) {
            Dirty = BooleanFlagOn( ((PPACKED_BOOT_SECTOR_EX)BootSector)->CurrentHead,
                                   FAT_BOOT_SECTOR_DIRTY );
        } else {
            Dirty = BooleanFlagOn( BootSector->CurrentHead, FAT_BOOT_SECTOR_DIRTY );
        }
 
        //
        //  Setup the VolumeLabel string
        //
 
        VolumeLabel.Length = Vcb->Vpb->VolumeLabelLength;
        VolumeLabel.MaximumLength = MAXIMUM_VOLUME_LABEL_LENGTH;
        VolumeLabel.Buffer = &Vcb->Vpb->VolumeLabel[0];
 
        if ( Dirty ) {
 
            //
            //  Do not trigger the mounted dirty bit if this is a verify
            //  and the volume is a boot or paging device.  We know that
            //  a boot or paging device cannot leave the system, and thus
            //  that on its mount we will have figured this out correctly.
            //
            //  This logic is a reasonable change.  Why?
            //  'cause setup cracked a non-exclusive DASD handle near the
            //  end of setup, wrote some data, closed the handle and we
            //  set the verify bit ... came back around and saw that other
            //  arbitrary activity had left the volume in a temporarily dirty
            //  state.
            //
            //  Of course, the real problem is that we don't have a journal.
            //
 
            if (!(IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                  IrpContext->MinorFunction == IRP_MN_VERIFY_VOLUME &&
                  FlagOn( Vcb->VcbState, VCB_STATE_FLAG_BOOT_OR_PAGING_FILE))) {
 
                KdPrintEx((DPFLTR_FASTFAT_ID,
                           DPFLTR_INFO_LEVEL,
                           "FASTFAT: WARNING! Mounting Dirty Volume %Z\n",
                           &VolumeLabel));
 
                SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
            }
 
        } else {
 
            if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
 
                KdPrintEx((DPFLTR_FASTFAT_ID,
                           DPFLTR_INFO_LEVEL,
                           "FASTFAT: Volume %Z has been cleaned.\n",
                           &VolumeLabel));
 
                ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
 
            } else {
 
                (VOID)FsRtlBalanceReads( Vcb->TargetDeviceObject );
            }
        }
 
    } _SEH2_FINALLY {
 
        FatUnpinBcb( IrpContext, BootSectorBcb );
    } _SEH2_END;
}

FatCheckFileAccess()

BOOLEAN FatCheckFileAccess	(	PIRP_CONTEXT	IrpContext,
		IN UCHAR	DirentAttributes,
		IN PACCESS_MASK	DesiredAccess
	)

Definition at line 39 of file acchksup.c.

{
    BOOLEAN Result;
 
    DebugTrace(+1, Dbg, "FatCheckFileAccess\n", 0);
    DebugTrace( 0, Dbg, "DirentAttributes = %8lx\n", DirentAttributes);
    DebugTrace( 0, Dbg, "DesiredAccess    = %8lx\n", *DesiredAccess);
 
    PAGED_CODE();
 
    //
    //  This procedures is programmed like a string of filters each
    //  filter checks to see if some access is allowed,  if it is not allowed
    //  the filter return FALSE to the user without further checks otherwise
    //  it moves on to the next filter.  The filter check is to check for
    //  desired access flags that are not allowed for a particular dirent
    //
 
    Result = TRUE;
 
    _SEH2_TRY {
 
        //
        //  Check for Volume ID or Device Dirents, these are not allowed user
        //  access at all
        //
 
        if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_VOLUME_ID) ||
            FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DEVICE)) {
 
            DebugTrace(0, Dbg, "Cannot access volume id or device\n", 0);
 
            try_return( Result = FALSE );
        }
 
        //
        //  Check the desired access for the object - we only blackball that
        //  we do not understand.  The model of filesystems using ACLs is that
        //  they do not type the ACL to the object the ACL is on.  Permissions
        //  are not checked for consistency vs. the object type - dir/file.
        //
 
        if (FlagOn(*DesiredAccess, ~(DELETE |
                                     READ_CONTROL |
                                     WRITE_OWNER |
                                     WRITE_DAC |
                                     SYNCHRONIZE |
                                     ACCESS_SYSTEM_SECURITY |
                                     FILE_WRITE_DATA |
                                     FILE_READ_EA |
                                     FILE_WRITE_EA |
                                     FILE_READ_ATTRIBUTES |
                                     FILE_WRITE_ATTRIBUTES |
                                     FILE_LIST_DIRECTORY |
                                     FILE_TRAVERSE |
                                     FILE_DELETE_CHILD |
                                     FILE_APPEND_DATA |
                                     MAXIMUM_ALLOWED))) {
 
            DebugTrace(0, Dbg, "Cannot open object\n", 0);
 
            try_return( Result = FALSE );
        }
 
        //
        //  Check for a read-only Dirent
        //
 
        if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_READ_ONLY)) {
 
            //
            //  Check the desired access for a read-only dirent.  AccessMask will contain
            //  the flags we're going to allow.
            //
 
            ACCESS_MASK AccessMask = DELETE | READ_CONTROL | WRITE_OWNER | WRITE_DAC |
                                    SYNCHRONIZE | ACCESS_SYSTEM_SECURITY | FILE_READ_DATA |
                                    FILE_READ_EA | FILE_WRITE_EA | FILE_READ_ATTRIBUTES |
                                    FILE_WRITE_ATTRIBUTES | FILE_EXECUTE | FILE_LIST_DIRECTORY |
                                    FILE_TRAVERSE;
 
            //
            //  If this is a subdirectory also allow add file/directory and delete.
            //
 
            if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DIRECTORY)) {
 
                AccessMask |= FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE | FILE_DELETE_CHILD;
            }
 
            if (FlagOn(*DesiredAccess, ~AccessMask)) {
 
                DebugTrace(0, Dbg, "Cannot open readonly\n", 0);
 
                try_return( Result = FALSE );
            }
        }
 
    try_exit: NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatCheckFileAccess );
 
        DebugTrace(-1, Dbg, "FatCheckFileAccess -> %08lx\n", Result);
    } _SEH2_END;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return Result;
}

Referenced by FatCheckFileAccess().

FatCheckManageVolumeAccess()

BOOLEAN FatCheckManageVolumeAccess	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PACCESS_STATE	AccessState,
		_In_ KPROCESSOR_MODE	ProcessorMode
	)

Definition at line 176 of file acchksup.c.

{
    PRIVILEGE_SET PrivilegeSet;
 
    PAGED_CODE();
 
    PrivilegeSet.PrivilegeCount = 1;
    PrivilegeSet.Control = PRIVILEGE_SET_ALL_NECESSARY;
    PrivilegeSet.Privilege[0].Luid = RtlConvertLongToLuid( SE_MANAGE_VOLUME_PRIVILEGE );
    PrivilegeSet.Privilege[0].Attributes = 0;
 
    if (SePrivilegeCheck( &PrivilegeSet,
                          &AccessState->SubjectSecurityContext,
                          ProcessorMode )) {
 
        return TRUE;
    }
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return FALSE;
}

Referenced by FatExplicitDeviceAccessGranted().

FatCleanVolumeDpc()

VOID NTAPI FatCleanVolumeDpc	(	_In_ PKDPC	Dpc,
		_In_opt_ PVOID	DeferredContext,
		_In_opt_ PVOID	SystemArgument1,
		_In_opt_ PVOID	SystemArgument2
	)

Definition at line 654 of file verfysup.c.

{
    PVCB Vcb;
    PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;
 
    UNREFERENCED_PARAMETER( SystemArgument1 );
    UNREFERENCED_PARAMETER( SystemArgument2 );
    UNREFERENCED_PARAMETER( Dpc );
 
    Vcb = (PVCB)DeferredContext;
 
 
    //
    //  If there is still dirty data (highly unlikely), set the timer for a
    //  second in the future.
    //
 
    if (CcIsThereDirtyData(Vcb->Vpb)) {
 
        LARGE_INTEGER TwoSecondsFromNow;
 
        TwoSecondsFromNow.QuadPart = (LONG)-2*1000*1000*10;
 
        KeSetTimer( &Vcb->CleanVolumeTimer,
                    TwoSecondsFromNow,
                    &Vcb->CleanVolumeDpc );
 
        return;
    }
 
    //
    //  If we couldn't get pool, oh well....
    //
 
    Packet = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(CLEAN_AND_DIRTY_VOLUME_PACKET), ' taF');
 
    if ( Packet ) {
 
        Packet->Vcb = Vcb;
        Packet->Irp = NULL;
 
        //
        //  Clear the dirty flag now since we cannot synchronize after this point.
        //
 
        ClearFlag( Packet->Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY );
 
        ExInitializeWorkItem( &Packet->Item, &FatDeferredCleanVolume, Packet );
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "prefast indicates this is an obsolete API, but it is ok for fastfat to keep using it" )
#endif
        ExQueueWorkItem( &Packet->Item, CriticalWorkQueue );
    }
 
    return;
}

FatCloseEaFile()

VOID FatCloseEaFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN BOOLEAN	FlushFirst
	)

Definition at line 1079 of file cachesup.c.

{
    PFILE_OBJECT EaFileObject = Vcb->VirtualEaFile;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCloseEaFile\n", 0);
    DebugTrace( 0, Dbg, "Vcb = %p\n", Vcb);
 
    NT_ASSERT( FatVcbAcquiredExclusive(IrpContext, Vcb) );
 
    if (EaFileObject != NULL) {
 
        EaFileObject = Vcb->VirtualEaFile;
 
        if (FlushFirst) {
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
        }
 
        Vcb->VirtualEaFile = NULL;
 
        //
        //  Empty the Mcb for the Ea file.
        //
 
        FatRemoveMcbEntry( Vcb, &Vcb->EaFcb->Mcb, 0, 0xFFFFFFFF );
 
        //
        //  Uninitialize the cache for this file object and dereference it.
        //
 
        FatSyncUninitializeCacheMap( IrpContext, EaFileObject );
 
        ObDereferenceObject( EaFileObject );
    }
 
    DebugTrace(-1, Dbg, "FatCloseEaFile -> %p\n", EaFileObject);
}

Referenced by FatTearDownVcb().

FatCommonQueryEa()

NTSTATUS FatCommonQueryEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 250 of file ea.c.

{
#if 0
    PIO_STACK_LOCATION IrpSp;
 
    NTSTATUS Status;
 
    PUCHAR  Buffer;
    ULONG   UserBufferLength;
 
    PUCHAR  UserEaList;
    ULONG   UserEaListLength;
    ULONG   UserEaIndex;
    BOOLEAN RestartScan;
    BOOLEAN ReturnSingleEntry;
    BOOLEAN IndexSpecified;
 
    PVCB Vcb;
    PCCB Ccb;
 
    PFCB Fcb;
    PDIRENT Dirent;
    PBCB Bcb;
 
    PDIRENT EaDirent;
    PBCB EaBcb;
    BOOLEAN LockedEaFcb;
 
    PEA_SET_HEADER EaSetHeader;
    EA_RANGE EaSetRange;
 
    USHORT ExtendedAttributes;
#endif
 
    PAGED_CODE();
 
    FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
    return STATUS_INVALID_DEVICE_REQUEST;
 
#if 0
    //
    //  Get the current Irp stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatCommonQueryEa...\n", 0);
    DebugTrace( 0, Dbg, " Wait                = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
    DebugTrace( 0, Dbg, " Irp                 = %p\n", Irp );
    DebugTrace( 0, Dbg, " ->SystemBuffer      = %p\n", Irp->AssociatedIrp.SystemBuffer );
    DebugTrace( 0, Dbg, " ->Length            = %08lx\n", IrpSp->Parameters.QueryEa.Length );
    DebugTrace( 0, Dbg, " ->EaList            = %08lx\n", IrpSp->Parameters.QueryEa.EaList );
    DebugTrace( 0, Dbg, " ->EaListLength      = %08lx\n", IrpSp->Parameters.QueryEa.EaListLength );
    DebugTrace( 0, Dbg, " ->EaIndex           = %08lx\n", IrpSp->Parameters.QueryEa.EaIndex );
    DebugTrace( 0, Dbg, " ->RestartScan       = %08lx\n", FlagOn(IrpSp->Flags, SL_RESTART_SCAN));
    DebugTrace( 0, Dbg, " ->ReturnSingleEntry = %08lx\n", FlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY));
    DebugTrace( 0, Dbg, " ->IndexSpecified    = %08lx\n", FlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED));
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    //
    //  Check that the file object is associated with either a user file
    //  or directory open.  We don't allow Ea operations on the root
    //  directory.
    //
 
    {
        TYPE_OF_OPEN OpenType;
 
        if (((OpenType = FatDecodeFileObject( IrpSp->FileObject,
                                             &Vcb,
                                             &Fcb,
                                             &Ccb )) != UserFileOpen
             && OpenType != UserDirectoryOpen) ||
 
            (NodeType( Fcb )) == FAT_NTC_ROOT_DCB) {
 
            FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
            DebugTrace(-1, Dbg,
                       "FatCommonQueryEa -> %08lx\n",
                       STATUS_INVALID_PARAMETER);
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    //  Fat32 does not support ea's.
    //
 
    if (FatIsFat32(Vcb)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_EAS_NOT_SUPPORTED );
        DebugTrace(-1, Dbg,
                   "FatCommonQueryEa -> %08lx\n",
                   STATUS_EAS_NOT_SUPPORTED);
        return STATUS_EAS_NOT_SUPPORTED;
    }
 
    //
    //  Acquire shared access to the Fcb and enqueue the Irp if we didn't
    //  get access.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
 
        DebugTrace(0, Dbg, "FatCommonQueryEa:  Thread can't wait\n", 0);
 
        Status = FatFsdPostRequest( IrpContext, Irp );
 
        DebugTrace(-1, Dbg, "FatCommonQueryEa -> %08lx\n", Status );
 
        return Status;
    }
 
    FatAcquireSharedFcb( IrpContext, Fcb );
 
    //
    //  Reference our input parameters to make things easier
    //
 
    UserBufferLength  = IrpSp->Parameters.QueryEa.Length;
    UserEaList        = IrpSp->Parameters.QueryEa.EaList;
    UserEaListLength  = IrpSp->Parameters.QueryEa.EaListLength;
    UserEaIndex       = IrpSp->Parameters.QueryEa.EaIndex;
    RestartScan       = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
    ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
    IndexSpecified    = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
 
    //
    //  Initialize our local values.
    //
 
    LockedEaFcb = FALSE;
    Bcb = NULL;
    EaBcb = NULL;
 
    Status = STATUS_SUCCESS;
 
    RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
    try {
 
        PPACKED_EA FirstPackedEa;
        ULONG PackedEasLength;
 
        Buffer = FatMapUserBuffer( IrpContext, Irp );
 
        //
        //  We verify that the Fcb is still valid.
        //
 
        FatVerifyFcb( IrpContext, Fcb );
 
        //
        //  We need to get the dirent for the Fcb to recover the Ea handle.
        //
 
        FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
        //
        //  Verify that the Ea file is in a consistant state.  If the
        //  Ea modification count in the Fcb doesn't match that in
        //  the CCB, then the Ea file has been changed from under
        //  us.  If we are not starting the search from the beginning
        //  of the Ea set, we return an error.
        //
 
        if (UserEaList == NULL
            && Ccb->OffsetOfNextEaToReturn != 0
            && !IndexSpecified
            && !RestartScan
            && Fcb->EaModificationCount != Ccb->EaModificationCount) {
 
            DebugTrace(0, Dbg,
                      "FatCommonQueryEa:  Ea file in unknown state\n", 0);
 
            Status = STATUS_EA_CORRUPT_ERROR;
 
            try_return( Status );
        }
 
        //
        //  Show that the Ea's for this file are consistant for this
        //  file handle.
        //
 
        Ccb->EaModificationCount = Fcb->EaModificationCount;
 
        //
        //  If the handle value is 0, then the file has no Eas.  We dummy up
        //  an ea list to use below.
        //
 
        ExtendedAttributes = Dirent->ExtendedAttributes;
 
        FatUnpinBcb( IrpContext, Bcb );
 
        if (ExtendedAttributes == 0) {
 
            DebugTrace(0, Dbg,
                      "FatCommonQueryEa:  Zero handle, no Ea's for this file\n", 0);
 
            FirstPackedEa = (PPACKED_EA) NULL;
 
            PackedEasLength = 0;
 
        } else {
 
            //
            //  We need to get the Ea file for this volume.  If the
            //  operation doesn't complete due to blocking, then queue the
            //  Irp to the Fsp.
            //
 
            FatGetEaFile( IrpContext,
                          Vcb,
                          &EaDirent,
                          &EaBcb,
                          FALSE,
                          FALSE );
 
            LockedEaFcb = TRUE;
 
            //
            //  If the above operation completed and the Ea file did not exist,
            //  the disk has been corrupted.  There is an existing Ea handle
            //  without any Ea data.
            //
 
            if (Vcb->VirtualEaFile == NULL) {
 
                DebugTrace(0, Dbg,
                          "FatCommonQueryEa:  No Ea file found when expected\n", 0);
 
                Status = STATUS_NO_EAS_ON_FILE;
 
                try_return( Status );
            }
 
            //
            //  We need to try to get the Ea set for the desired file.  If
            //  blocking is necessary then we'll post the request to the Fsp.
            //
 
            FatReadEaSet( IrpContext,
                          Vcb,
                          ExtendedAttributes,
                          &Fcb->ShortName.Name.Oem,
                          TRUE,
                          &EaSetRange );
 
            EaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            //
            //  Find the start and length of the Eas.
            //
 
            FirstPackedEa = (PPACKED_EA) EaSetHeader->PackedEas;
 
            PackedEasLength = GetcbList( EaSetHeader ) - 4;
        }
 
        //
        //  Protect our access to the user buffer since IO dosn't do this
        //  for us in this path unless we had specified that our driver
        //  requires buffering for these large requests.  We don't, so ...
        //
 
        try {
 
            //
            //  Let's clear the output buffer.
            //
 
            RtlZeroMemory( Buffer, UserBufferLength );
 
            //
            //  We now satisfy the user's request depending on whether he
            //  specified an Ea name list, an Ea index or restarting the
            //  search.
            //
 
            //
            //  The user has supplied a list of Ea names.
            //
 
            if (UserEaList != NULL) {
 
                Irp->IoStatus = FatQueryEaUserEaList( IrpContext,
                                                      Ccb,
                                                      FirstPackedEa,
                                                      PackedEasLength,
                                                      Buffer,
                                                      UserBufferLength,
                                                      UserEaList,
                                                      UserEaListLength,
                                                      ReturnSingleEntry );
 
            //
            //  The user supplied an index into the Ea list.
            //
 
            } else if (IndexSpecified) {
 
                Irp->IoStatus = FatQueryEaIndexSpecified( IrpContext,
                                                          Ccb,
                                                          FirstPackedEa,
                                                          PackedEasLength,
                                                          Buffer,
                                                          UserBufferLength,
                                                          UserEaIndex,
                                                          ReturnSingleEntry );
 
            //
            //  Else perform a simple scan, taking into account the restart
            //  flag and the position of the next Ea stored in the Ccb.
            //
 
            } else {
 
                Irp->IoStatus = FatQueryEaSimpleScan( IrpContext,
                                                      Ccb,
                                                      FirstPackedEa,
                                                      PackedEasLength,
                                                      Buffer,
                                                      UserBufferLength,
                                                      ReturnSingleEntry,
                                                      RestartScan
                                                      ? 0
                                                      : Ccb->OffsetOfNextEaToReturn );
            }
 
        }  except (!FsRtlIsNtstatusExpected(GetExceptionCode()) ?
                   EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
 
               //
               //  We must have had a problem filling in the user's buffer, so fail.
               //
 
               Irp->IoStatus.Status = GetExceptionCode();
               Irp->IoStatus.Information = 0;
        }
 
        Status = Irp->IoStatus.Status;
 
    try_exit: NOTHING;
    } finally {
 
        DebugUnwind( FatCommonQueryEa );
 
        //
        //  Release the Fcb for the file object, and the Ea Fcb if
        //  successfully locked.
        //
 
        FatReleaseFcb( IrpContext, Fcb );
 
        if (LockedEaFcb) {
 
            FatReleaseFcb( IrpContext, Vcb->EaFcb );
        }
 
        //
        //  Unpin the dirents for the Fcb, EaFcb and EaSetFcb if necessary.
        //
 
        FatUnpinBcb( IrpContext, Bcb );
        FatUnpinBcb( IrpContext, EaBcb );
 
        FatUnpinEaRange( IrpContext, &EaSetRange );
 
        if (!AbnormalTermination()) {
 
            FatCompleteRequest( IrpContext, Irp, Status );
        }
 
        DebugTrace(-1, Dbg, "FatCommonQueryEa -> %08lx\n", Status);
    }
 
    return Status;
#endif
}

Referenced by _Function_class_(), FatCommonQueryEa(), and FatFspDispatch().

FatCommonSetEa()

NTSTATUS FatCommonSetEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 659 of file ea.c.

{
#if 0
    PIO_STACK_LOCATION IrpSp;
 
    NTSTATUS Status;
 
    USHORT ExtendedAttributes;
 
    PUCHAR Buffer;
    ULONG UserBufferLength;
 
    PVCB Vcb;
    PCCB Ccb;
 
    PFCB Fcb;
    PDIRENT Dirent;
    PBCB Bcb = NULL;
 
    PDIRENT EaDirent = NULL;
    PBCB EaBcb = NULL;
 
    PEA_SET_HEADER EaSetHeader = NULL;
 
    PEA_SET_HEADER PrevEaSetHeader;
    PEA_SET_HEADER NewEaSetHeader;
    EA_RANGE EaSetRange;
 
    BOOLEAN AcquiredVcb = FALSE;
    BOOLEAN AcquiredFcb = FALSE;
    BOOLEAN AcquiredParentDcb = FALSE;
    BOOLEAN AcquiredRootDcb = FALSE;
    BOOLEAN AcquiredEaFcb = FALSE;
#endif
 
    PAGED_CODE();
 
    FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
    return STATUS_INVALID_DEVICE_REQUEST;
 
#if 0
 
    //
    //  The following booleans are used in the unwind process.
    //
 
    //
    //  Get the current Irp stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatCommonSetEa...\n", 0);
    DebugTrace( 0, Dbg, " Wait                = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
    DebugTrace( 0, Dbg, " Irp                 = %p\n", Irp );
    DebugTrace( 0, Dbg, " ->SystemBuffer      = %p\n", Irp->AssociatedIrp.SystemBuffer );
    DebugTrace( 0, Dbg, " ->Length            = %08lx\n", IrpSp->Parameters.SetEa.Length );
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    //
    //  Check that the file object is associated with either a user file
    //  or directory open.
    //
 
    {
        TYPE_OF_OPEN OpenType;
 
        if (((OpenType = FatDecodeFileObject( IrpSp->FileObject,
                                             &Vcb,
                                             &Fcb,
                                             &Ccb )) != UserFileOpen
             && OpenType != UserDirectoryOpen) ||
 
            (NodeType( Fcb )) == FAT_NTC_ROOT_DCB) {
 
            FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
            DebugTrace(-1, Dbg,
                       "FatCommonSetEa -> %08lx\n",
                       STATUS_INVALID_PARAMETER);
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // Fat32 does not support ea's.
    //
 
    if (FatIsFat32(Vcb)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_EAS_NOT_SUPPORTED );
        DebugTrace(-1, Dbg,
                   "FatCommonSetEa -> %08lx\n",
                   STATUS_EAS_NOT_SUPPORTED);
        return STATUS_EAS_NOT_SUPPORTED;
    }
 
    //
    //  Reference our input parameters to make things easier
    //
 
    UserBufferLength  = IrpSp->Parameters.SetEa.Length;
 
    //
    //  Since we ask for no outside help (direct or buffered IO), it
    //  is our responsibility to insulate ourselves from the
    //  deviousness of the user above.  Now, buffer and validate the
    //  contents.
    //
 
    Buffer = FatBufferUserBuffer( IrpContext, Irp, UserBufferLength );
 
    //
    //  Check the validity of the buffer with the new eas.  We really
    //  need to do this always since we don't know, if it was already
    //  buffered, that we buffered and checked it or some overlying
    //  filter buffered without checking.
    //
 
    Status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION) Buffer,
                                      UserBufferLength,
                                      (PULONG)&Irp->IoStatus.Information );
 
    if (!NT_SUCCESS( Status )) {
 
        FatCompleteRequest( IrpContext, Irp, Status );
        DebugTrace(-1, Dbg,
                   "FatCommonSetEa -> %08lx\n",
                   Status);
        return Status;
    }
 
    //
    //  Acquire exclusive access to the Fcb.  If this is a write-through operation
    //  we will need to pick up the other possible streams that can be modified in
    //  this operation so that the locking order is preserved - the root directory
    //  (dirent addition if EA database doesn't already exist) and the parent
    //  directory (addition of the EA handle to the object's dirent).
    //
    //  We are primarily synchronizing with directory enumeration here.
    //
    //  If we cannot wait need to send things off to the fsp.
    //
 
    if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Set Ea must be waitable\n", 0);
 
        Status = FatFsdPostRequest( IrpContext, Irp );
 
        DebugTrace(-1, Dbg, "FatCommonSetEa -> %08lx\n", Status );
 
        return Status;
    }
 
    //
    //  Set this handle as having modified the file
    //
 
    IrpSp->FileObject->Flags |= FO_FILE_MODIFIED;
 
    RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
    try {
 
        ULONG PackedEasLength;
        BOOLEAN PreviousEas;
        ULONG AllocationLength;
        ULONG BytesPerCluster;
        USHORT EaHandle;
 
        PFILE_FULL_EA_INFORMATION FullEa;
 
        //
        //  Now go pick up everything
        //
 
        FatAcquireSharedVcb( IrpContext, Fcb->Vcb );
        AcquiredVcb = TRUE;
        FatAcquireExclusiveFcb( IrpContext, Fcb );
        AcquiredFcb = TRUE;
 
        if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH)) {
 
            if (Fcb->ParentDcb) {
 
                FatAcquireExclusiveFcb( IrpContext, Fcb->ParentDcb );
                AcquiredParentDcb = TRUE;
            }
 
            FatAcquireExclusiveFcb( IrpContext, Fcb->Vcb->RootDcb );
            AcquiredRootDcb = TRUE;
        }
 
        //
        //  We verify that the Fcb is still valid.
        //
 
        FatVerifyFcb( IrpContext, Fcb );
 
        //
        //  We need to get the dirent for the Fcb to recover the Ea handle.
        //
 
        FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Dirent Address -> %p\n",
                   Dirent );
        DebugTrace(0, Dbg, "FatCommonSetEa:  Dirent Bcb -> %p\n",
                   Bcb);
 
        //
        //  If the handle value is 0, then the file has no Eas.  In that
        //  case we allocate memory to hold the Eas to be added.  If there
        //  are existing Eas for the file, then we must read from the
        //  file and copy the Eas.
        //
 
        ExtendedAttributes = Dirent->ExtendedAttributes;
 
        FatUnpinBcb( IrpContext, Bcb );
 
        if (ExtendedAttributes == 0) {
 
            PreviousEas = FALSE;
 
            DebugTrace(0, Dbg,
                      "FatCommonSetEa:  File has no current Eas\n", 0 );
 
        } else {
 
            PreviousEas = TRUE;
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  File has previous Eas\n", 0 );
 
            FatGetEaFile( IrpContext,
                          Vcb,
                          &EaDirent,
                          &EaBcb,
                          FALSE,
                          TRUE );
 
            AcquiredEaFcb = TRUE;
 
            //
            //  If we didn't get the file then there is an error on
            //  the disk.
            //
 
            if (Vcb->VirtualEaFile == NULL) {
 
                Status = STATUS_NO_EAS_ON_FILE;
                try_return( Status );
            }
        }
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  EaBcb -> %p\n", EaBcb);
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  EaDirent -> %p\n", EaDirent);
 
        //
        //  If the file has existing ea's, we need to read them to
        //  determine the size of the buffer allocation.
        //
 
        if (PreviousEas) {
 
            //
            //  We need to try to get the Ea set for the desired file.
            //
 
            FatReadEaSet( IrpContext,
                          Vcb,
                          ExtendedAttributes,
                          &Fcb->ShortName.Name.Oem,
                          TRUE,
                          &EaSetRange );
 
            PrevEaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            //
            //  We now must allocate pool memory for our copy of the
            //  EaSetHeader and then copy the Ea data into it.  At that
            //  time we can unpin the EaSet.
            //
 
            PackedEasLength = GetcbList( PrevEaSetHeader ) - 4;
 
        //
        //  Else we will create a dummy EaSetHeader.
        //
 
        } else {
 
            PackedEasLength = 0;
        }
 
        BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
        AllocationLength = (PackedEasLength
                            + SIZE_OF_EA_SET_HEADER
                            + BytesPerCluster - 1)
                           & ~(BytesPerCluster - 1);
 
        EaSetHeader = FsRtlAllocatePoolWithTag( PagedPool,
                                                AllocationLength,
                                                TAG_EA_SET_HEADER );
 
        //
        //  Copy the existing Eas over to pool memory.
        //
 
        if (PreviousEas) {
 
            RtlCopyMemory( EaSetHeader, PrevEaSetHeader, AllocationLength );
 
            FatUnpinEaRange( IrpContext, &EaSetRange );
 
        } else {
 
            RtlZeroMemory( EaSetHeader, AllocationLength );
 
            RtlCopyMemory( EaSetHeader->OwnerFileName,
                           Fcb->ShortName.Name.Oem.Buffer,
                           Fcb->ShortName.Name.Oem.Length );
        }
 
 
        AllocationLength -= SIZE_OF_EA_SET_HEADER;
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Initial Ea set -> %p\n",
                   EaSetHeader);
 
        //
        //  At this point we have either read in the current eas for the file
        //  or we have initialized a new empty buffer for the eas.  Now for
        //  each full ea in the input user buffer we do the specified operation
        //  on the ea
        //
 
        for (FullEa = (PFILE_FULL_EA_INFORMATION) Buffer;
             FullEa < (PFILE_FULL_EA_INFORMATION) &Buffer[UserBufferLength];
             FullEa = (PFILE_FULL_EA_INFORMATION) (FullEa->NextEntryOffset == 0 ?
                                  &Buffer[UserBufferLength] :
                                  (PUCHAR) FullEa + FullEa->NextEntryOffset)) {
 
            OEM_STRING EaName;
            ULONG Offset;
 
            EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
            EaName.Buffer = &FullEa->EaName[0];
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  Next Ea name -> %Z\n",
                       &EaName);
 
            //
            //  Make sure the ea name is valid
            //
 
            if (!FatIsEaNameValid( IrpContext,EaName )) {
 
                Irp->IoStatus.Information = (PUCHAR)FullEa - Buffer;
                Status = STATUS_INVALID_EA_NAME;
                try_return( Status );
            }
 
            //
            //  Check that no invalid ea flags are set.
            //
 
            //
            //  TEMPCODE  We are returning STATUS_INVALID_EA_NAME
            //  until a more appropriate error code exists.
            //
 
            if (FullEa->Flags != 0
                && FullEa->Flags != FILE_NEED_EA) {
 
                Irp->IoStatus.Information = (PUCHAR)FullEa - (PUCHAR)Buffer;
                try_return( Status = STATUS_INVALID_EA_NAME );
            }
 
            //
            //  See if we can locate the ea name in the ea set
            //
 
            if (FatLocateEaByName( IrpContext,
                                   (PPACKED_EA) EaSetHeader->PackedEas,
                                   PackedEasLength,
                                   &EaName,
                                   &Offset )) {
 
                DebugTrace(0, Dbg, "FatCommonSetEa:  Found Ea name\n", 0);
 
                //
                //  We found the ea name so now delete the current entry,
                //  and if the new ea value length is not zero then we
                //  replace if with the new ea
                //
 
                FatDeletePackedEa( IrpContext,
                                   EaSetHeader,
                                   &PackedEasLength,
                                   Offset );
            }
 
            if (FullEa->EaValueLength != 0) {
 
                FatAppendPackedEa( IrpContext,
                                   &EaSetHeader,
                                   &PackedEasLength,
                                   &AllocationLength,
                                   FullEa,
                                   BytesPerCluster );
            }
        }
 
        //
        //  If there are any ea's not removed, we
        //  call 'AddEaSet' to insert them into the Fat chain.
        //
 
        if (PackedEasLength != 0) {
 
            LARGE_INTEGER EaOffset;
 
            EaOffset.HighPart = 0;
 
            //
            //  If the packed eas length (plus 4 bytes) is greater
            //  than the maximum allowed ea size, we return an error.
            //
 
            if (PackedEasLength + 4 > MAXIMUM_EA_SIZE) {
 
                DebugTrace( 0, Dbg, "Ea length is greater than maximum\n", 0 );
 
                try_return( Status = STATUS_EA_TOO_LARGE );
            }
 
            //
            //  We need to now read the ea file if we haven't already.
            //
 
            if (EaDirent == NULL) {
 
                FatGetEaFile( IrpContext,
                              Vcb,
                              &EaDirent,
                              &EaBcb,
                              TRUE,
                              TRUE );
 
                AcquiredEaFcb = TRUE;
            }
 
            FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
            RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
            FatAddEaSet( IrpContext,
                         Vcb,
                         PackedEasLength + SIZE_OF_EA_SET_HEADER,
                         EaBcb,
                         EaDirent,
                         &EaHandle,
                         &EaSetRange );
 
            NewEaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  Adding an ea set\n", 0);
 
            //
            //  Store the length of the new Ea's into the EaSetHeader.
            //  This is the PackedEasLength + 4.
            //
 
            PackedEasLength += 4;
 
            CopyU4char( EaSetHeader->cbList, &PackedEasLength );
 
            //
            //  Copy all but the first four bytes of EaSetHeader into
            //  NewEaSetHeader.  The signature and index fields have
            //  already been filled in.
            //
 
            RtlCopyMemory( &NewEaSetHeader->NeedEaCount,
                           &EaSetHeader->NeedEaCount,
                           PackedEasLength + SIZE_OF_EA_SET_HEADER - 8 );
 
            FatMarkEaRangeDirty( IrpContext, Vcb->VirtualEaFile, &EaSetRange );
            FatUnpinEaRange( IrpContext, &EaSetRange );
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
 
        } else {
 
            FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
            EaHandle = 0;
        }
 
        //
        //  Now we do a wholesale replacement of the ea for the file
        //
 
        if (PreviousEas) {
 
            FatDeleteEaSet( IrpContext,
                            Vcb,
                            EaBcb,
                            EaDirent,
                            ExtendedAttributes,
                            &Fcb->ShortName.Name.Oem );
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
        }
 
        if (PackedEasLength != 0 ) {
 
            Fcb->EaModificationCount++;
        }
 
        //
        //  Mark the dirent with the new ea's
        //
 
        Dirent->ExtendedAttributes = EaHandle;
 
        FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE );
 
        //
        //  We call the notify package to report that the ea's were
        //  modified.
        //
 
        FatNotifyReportChange( IrpContext,
                               Vcb,
                               Fcb,
                               FILE_NOTIFY_CHANGE_EA,
                               FILE_ACTION_MODIFIED );
 
        Irp->IoStatus.Information = 0;
        Status = STATUS_SUCCESS;
 
    try_exit: NOTHING;
 
        //
        //  Unpin the dirents for the Fcb and EaFcb if necessary.
        //
 
        FatUnpinBcb( IrpContext, Bcb );
        FatUnpinBcb( IrpContext, EaBcb );
 
        FatUnpinRepinnedBcbs( IrpContext );
 
    } finally {
 
        DebugUnwind( FatCommonSetEa );
 
        //
        //  If this is an abnormal termination, we need to clean up
        //  any locked resources.
        //
 
        if (AbnormalTermination()) {
 
            //
            //  Unpin the dirents for the Fcb, EaFcb and EaSetFcb if necessary.
            //
 
            FatUnpinBcb( IrpContext, Bcb );
            FatUnpinBcb( IrpContext, EaBcb );
 
            FatUnpinEaRange( IrpContext, &EaSetRange );
        }
 
        //
        //  Release the Fcbs/Vcb acquired.
        //
 
        if (AcquiredEaFcb) {
            FatReleaseFcb( IrpContext, Vcb->EaFcb );
        }
 
        if (AcquiredFcb) {
            FatReleaseFcb( IrpContext, Fcb );
        }
 
        if (AcquiredParentDcb) {
            FatReleaseFcb( IrpContext, Fcb->ParentDcb );
        }
 
        if (AcquiredRootDcb) {
            FatReleaseFcb( IrpContext, Fcb->Vcb->RootDcb );
        }
 
        if (AcquiredVcb) {
            FatReleaseVcb( IrpContext, Fcb->Vcb );
        }
 
        //
        //  Deallocate our Ea buffer.
        //
 
        if (EaSetHeader != NULL) {
 
            ExFreePool( EaSetHeader );
        }
 
        //
        //  Complete the irp.
        //
 
        if (!AbnormalTermination()) {
 
            FatCompleteRequest( IrpContext, Irp, Status );
        }
 
        DebugTrace(-1, Dbg, "FatCommonSetEa -> %08lx\n", Status);
    }
 
    //
    //  And return to our caller
    //
 
    return Status;
#endif
}

Referenced by _Function_class_(), FatCommonSetEa(), and FatFspDispatch().

FatCompareNames()

COMPARISON FatCompareNames	(	IN PSTRING	NameA,
		IN PSTRING	NameB
	)

Definition at line 421 of file splaysup.c.

{
    ULONG i;
    ULONG MinLength;
 
    PAGED_CODE();
 
    //
    //  Figure out the minimum of the two lengths
    //
 
    MinLength = NameA->Length < NameB->Length ? NameA->Length :
                                                NameB->Length;
 
    //
    //  Loop through looking at all of the characters in both strings
    //  testing for equalilty, less than, and greater than
    //
 
    i = (ULONG)RtlCompareMemory( NameA->Buffer, NameB->Buffer, MinLength );
 
 
    if (i < MinLength) {
 
        return NameA->Buffer[i] < NameB->Buffer[i] ? IsLessThan :
                                                     IsGreaterThan;
    }
 
    if (NameA->Length < NameB->Length) {
 
        return IsLessThan;
    }
 
    if (NameA->Length > NameB->Length) {
 
        return IsGreaterThan;
    }
 
    return IsEqual;
}

FatCompleteMdl()

NTSTATUS FatCompleteMdl	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 1728 of file cachesup.c.

{
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION IrpSp;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCompleteMdl\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
    DebugTrace( 0, Dbg, "Irp        = %p\n", Irp );
 
    //
    // Do completion processing.
    //
 
    FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
 
    switch( IrpContext->MajorFunction ) {
 
    case IRP_MJ_READ:
 
        CcMdlReadComplete( FileObject, Irp->MdlAddress );
        break;
 
    case IRP_MJ_WRITE:
 
        IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
        NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ));
 
        CcMdlWriteComplete( FileObject, &IrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress );
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
 
        break;
 
    default:
 
        DebugTrace( DEBUG_TRACE_ERROR, 0, "Illegal Mdl Complete.\n", 0);
#ifdef _MSC_VER
#pragma prefast( suppress: 28159, "we're very broken if we get here" )
#endif
        FatBugCheck( IrpContext->MajorFunction, 0, 0 );
    }
 
    //
    // Mdl is now deallocated.
    //
 
    Irp->MdlAddress = NULL;
 
    //
    // Complete the request and exit right away.
    //
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
 
    DebugTrace(-1, Dbg, "FatCompleteMdl -> STATUS_SUCCESS\n", 0 );
 
    return STATUS_SUCCESS;
}

Referenced by _Function_class_().

FatCompleteRequest_Real()

VOID FatCompleteRequest_Real	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp,
		IN NTSTATUS	Status
	)

Definition at line 733 of file fatdata.c.

{
    PAGED_CODE();
 
#if DBG
    if ( (FatBreakOnInterestingIrpCompletion != 0) && (Status == FatBreakOnInterestingIrpCompletion) ) {
        DbgBreakPoint();
    }
 
#endif
 
    //
    //  If we have an Irp Context then unpin all of the repinned bcbs
    //  we might have collected.
    //
 
    if (IrpContext != NULL) {
 
        NT_ASSERT( IrpContext->Repinned.Bcb[0] == NULL );
 
        FatUnpinRepinnedBcbs( IrpContext );
    }
 
    //
    //  Delete the Irp context before completing the IRP so if
    //  we run into some of the asserts, we can still backtrack
    //  through the IRP.
    //
 
    if (IrpContext != NULL) {
 
        FatDeleteIrpContext( IrpContext );
    }
 
    //
    //  If we have an Irp then complete the irp.
    //
 
    if (Irp != NULL) {
 
        //
        //  We got an error, so zero out the information field before
        //  completing the request if this was an input operation.
        //  Otherwise IopCompleteRequest will try to copy to the user's buffer.
        //
 
        if ( NT_ERROR(Status) &&
             FlagOn(Irp->Flags, IRP_INPUT_OPERATION) ) {
 
            Irp->IoStatus.Information = 0;
        }
 
        Irp->IoStatus.Status = Status;
 
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
 
    return;
}