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 81 of file fatprocs.h.

BlockAlign

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

Definition at line 3104 of file fatprocs.h.

BlockAlignTruncate

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

Definition at line 3105 of file fatprocs.h.

CanFsdWait

#define CanFsdWait

(

IRP

)

IoIsOperationSynchronous(Irp)

Definition at line 2371 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 1900 of file fatprocs.h.

CopyU4char

#define CopyU4char	(		Dst,
			Src
	)

Value:

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

Definition at line 2154 of file fatprocs.h.

CopyUchar1

#define CopyUchar1	(		Dst,
			Src
	)

Value:

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

Definition at line 2134 of file fatprocs.h.

CopyUchar2

#define CopyUchar2	(		Dst,
			Src
	)

Value:

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

Definition at line 2142 of file fatprocs.h.

CopyUchar4

#define CopyUchar4	(		Dst,
			Src
	)

Value:

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

Definition at line 2150 of file fatprocs.h.

DebugBreakOnStatus

#define DebugBreakOnStatus

(

S

)

Definition at line 2975 of file fatprocs.h.

FAT_CREATE_INITIAL_NAME_BUF_SIZE

#define FAT_CREATE_INITIAL_NAME_BUF_SIZE   32

Definition at line 112 of file fatprocs.h.

FatAcquireDirectoryFileMutex

#define FatAcquireDirectoryFileMutex

(

VCB

)

Value:

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

Definition at line 1509 of file fatprocs.h.

FatAcquireExclusiveGlobal

#define FatAcquireExclusiveGlobal

(

IRPCONTEXT

)

Value:

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

Definition at line 1388 of file fatprocs.h.

FatAcquireExclusiveVcb

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

Definition at line 1461 of file fatprocs.h.

FatAcquireExclusiveVcbNoOpCheck

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

Definition at line 1462 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 1410 of file fatprocs.h.

FatAcquireSharedGlobal

#define FatAcquireSharedGlobal

(

IRPCONTEXT

)

Value:

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

Definition at line 1392 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 1159 of file fatprocs.h.

FatCompleteRequest

#define FatCompleteRequest	(		IRPCONTEXT,
			IRP,
			STATUS
	)

Value:

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

Definition at line 2634 of file fatprocs.h.

FatConvertToSharedFcb

#define FatConvertToSharedFcb	(		IRPCONTEXT,
			Fcb
	)

Value:

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

Definition at line 1610 of file fatprocs.h.

FatDeleteIrpContext

#define FatDeleteIrpContext

(

IRPCONTEXT

)

Value:

    {   \
    FatDeleteIrpContext_Real((IRPCONTEXT)); \
}

Definition at line 1763 of file fatprocs.h.

FatDeleteResource

#define FatDeleteResource

(

RESRC

)

Value:

    {                      \
    ExDeleteResourceLite( (RESRC) );                    \
}

Definition at line 1633 of file fatprocs.h.

FatDeviceIsFatFsdo

#define FatDeviceIsFatFsdo

(

D

)

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

Definition at line 3096 of file fatprocs.h.

FatDirectoryKey

#define FatDirectoryKey

(

FcbOrDcb

)

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

Definition at line 851 of file fatprocs.h.

FATDOT

#define FATDOT   ((ULONG)0x2020202E)

Definition at line 3075 of file fatprocs.h.

FATDOTDOT

#define FATDOTDOT   ((ULONG)0x20202E2E)

Definition at line 3076 of file fatprocs.h.

FatFcbAcquiredExclusive

#define FatFcbAcquiredExclusive	(		IRPCONTEXT,
			FCB
	)

Value:

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

Definition at line 1505 of file fatprocs.h.

FatFcbAcquiredShared

#define FatFcbAcquiredShared	(		IRPCONTEXT,
			FCB
	)

Value:

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

Definition at line 1501 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 3078 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 3055 of file fatprocs.h.

FatGenerateFileIdFromFcb

#define FatGenerateFileIdFromFcb

(

Fcb

)

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

Definition at line 3067 of file fatprocs.h.

FatGetFcbOplock

#define FatGetFcbOplock

(

F

)

&(F)->Header.Oplock

Definition at line 1657 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 1786 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 1792 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 2814 of file fatprocs.h.

FatIsFat12

#define FatIsFat12

(

VCB

)

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

Definition at line 1449 of file fatprocs.h.

FatIsFat16

#define FatIsFat16

(

VCB

)

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

Definition at line 1448 of file fatprocs.h.

FatIsFat32

#define FatIsFat32

(

VCB

)

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

Definition at line 1447 of file fatprocs.h.

FatIsFileOplockable

#define FatIsFileOplockable

(

F

)

Value:

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

Definition at line 2852 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 1206 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 1199 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 2838 of file fatprocs.h.

FatIsRawDevice

#define FatIsRawDevice	(		IC,
			S
	)

Value:

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

Definition at line 1846 of file fatprocs.h.

FatNormalizeAndRaiseStatus

#define FatNormalizeAndRaiseStatus	(		IRPCONTEXT,
			STATUS
	)

Value:

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

Definition at line 2996 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 2169 of file fatprocs.h.

FatRaiseStatus

#define FatRaiseStatus	(		IRPCONTEXT,
			STATUS
	)

Value:

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

Definition at line 2978 of file fatprocs.h.

FatReleaseDirectoryFileMutex

#define FatReleaseDirectoryFileMutex

(

VCB

)

Value:

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

Definition at line 1514 of file fatprocs.h.

FatReleaseFcb

#define FatReleaseFcb	(		IRPCONTEXT,
			Fcb
	)

Value:

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

Definition at line 1645 of file fatprocs.h.

FatReleaseGlobal

#define FatReleaseGlobal

(

IRPCONTEXT

)

Value:

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

Definition at line 1637 of file fatprocs.h.

FatReleaseVcb

#define FatReleaseVcb	(		IRPCONTEXT,
			Vcb
	)

Value:

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

Definition at line 1641 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 1419 of file fatprocs.h.

FatResetExceptionState

#define FatResetExceptionState

(

IRPCONTEXT

)

Value:

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

Definition at line 2984 of file fatprocs.h.

FatSetVcbCondition

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

Definition at line 1439 of file fatprocs.h.

FatUnpinBcb

#define FatUnpinBcb	(		IRPCONTEXT,
			BCB
	)

Value:

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

Definition at line 547 of file fatprocs.h.

FatUpcaseEaName

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

Definition at line 869 of file fatprocs.h.

FatVcbAcquiredExclusive

#define FatVcbAcquiredExclusive	(		IRPCONTEXT,
			VCB
	)

Value:

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

Definition at line 1496 of file fatprocs.h.

INLINE

#define INLINE   __inline

Definition at line 78 of file fatprocs.h.

IsDirectory

#define IsDirectory

(

FcbOrDcb

)

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

Definition at line 3107 of file fatprocs.h.

IsFileDeleted

#define IsFileDeleted	(		IRPCONTEXT,
			FCB
	)

Value:

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

Definition at line 2782 of file fatprocs.h.

IsFileObjectReadOnly

#define IsFileObjectReadOnly

(

FO

)

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

Definition at line 2867 of file fatprocs.h.

IsFileWriteThrough

#define IsFileWriteThrough	(		FO,
			VCB
	)

Value:

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

Definition at line 2797 of file fatprocs.h.

LongAlign

#define LongAlign

(

Ptr

)

Value:

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

Definition at line 2097 of file fatprocs.h.

MAX_ULONG

#define MAX_ULONG   ((ULONG)-1)

Definition at line 84 of file fatprocs.h.

MAX_USHORT

#define MAX_USHORT   ((USHORT)-1)

Definition at line 88 of file fatprocs.h.

PtrOffset

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

Definition at line 2081 of file fatprocs.h.

QuadAlign

#define QuadAlign

(

Ptr

)

Value:

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

Definition at line 2106 of file fatprocs.h.

SizeOfFullEa

#define SizeOfFullEa

(

EA

)

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

Definition at line 1031 of file fatprocs.h.

try_leave

#define try_leave

(

S

)

{ S; _SEH2_LEAVE; }

Definition at line 3031 of file fatprocs.h.

try_return

#define try_return

(

S

)

{ S; goto try_exit; }

Definition at line 3030 of file fatprocs.h.

WordAlign

#define WordAlign

(

Ptr

)

Value:

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

Definition at line 2088 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 105 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 1884 of file fatprocs.h.

                         {
    IsLessThan,
    IsGreaterThan,
    IsEqual
} COMPARISON;

_FAT_FLUSH_TYPE

enum _FAT_FLUSH_TYPE

Enumerator
NoFlush
Flush
FlushAndInvalidate
FlushWithoutPurge

Definition at line 1052 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 1954 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 1040 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 1028 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;
}

FatConstructDirent()

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
	)

Definition at line 2171 of file dirsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatConstructDirent\n", 0);
 
    DebugTrace( 0, Dbg, "  Dirent             = %p\n", Dirent);
    DebugTrace( 0, Dbg, "  FileName           = %Z\n", FileName);
    DebugTrace( 0, Dbg, "  Attributes         = %08lx\n", Attributes);
 
    if (ZeroAndSetTimeFields) {
 
        RtlZeroMemory( Dirent, sizeof(DIRENT) );
    }
 
    //
    //  We just merrily go and fill up the dirent with the fields given.
    //
 
    FatStringTo8dot3( IrpContext, *FileName, (PFAT8DOT3)&Dirent->FileName[0] );
 
    if (ZeroAndSetTimeFields || SetCreationTime) {
 
        LARGE_INTEGER Time, SaveTime;
 
        KeQuerySystemTime( &Time );
 
        if (FatData.ChicagoMode) {
 
            if (!SetCreationTime || !FatNtTimeToFatTime( IrpContext,
                                                         SetCreationTime,
                                                         FALSE,
                                                         &Dirent->CreationTime,
                                                         &Dirent->CreationMSec )) {
 
                //
                //  No tunneled time or the tunneled time was bogus. Since we aren't
                //  responsible for initializing the to-be-created Fcb with creation
                //  time, we can't do the usual thing and let NtTimeToFatTime perform
                //  rounding on the timestamp - this would mess up converting to the
                //  LastWriteTime below.
                //
 
                SaveTime = Time;
 
                if (!FatNtTimeToFatTime( IrpContext,
                                         &SaveTime,
                                         FALSE,
                                         &Dirent->CreationTime,
                                         &Dirent->CreationMSec )) {
 
                    //
                    //  Failed again. Wow.
                    //
 
                    RtlZeroMemory( &Dirent->CreationTime, sizeof(FAT_TIME_STAMP));
                    Dirent->CreationMSec = 0;
                }
            }
        }
 
        if (ZeroAndSetTimeFields) {
 
            //
            //  We only touch the other timestamps if we are initializing the dirent
            //
 
            if (!FatNtTimeToFatTime( IrpContext,
                                     &Time,
                                     TRUE,
                                     &Dirent->LastWriteTime,
                                     NULL )) {
 
                DebugTrace( 0, Dbg, "Current time invalid.\n", 0);
 
                RtlZeroMemory( &Dirent->LastWriteTime, sizeof(FAT_TIME_STAMP) );
            }
 
            if (FatData.ChicagoMode) {
 
                Dirent->LastAccessDate = Dirent->LastWriteTime.Date;
            }
        }
    }
 
    //
    //  Copy the attributes
    //
 
    Dirent->Attributes = (UCHAR)Attributes;
 
    //
    //  Set the magic bit here, to tell dirctrl.c that this name is really
    //  lowercase.
    //
 
    Dirent->NtByte = 0;
 
    if (ComponentReallyLowercase) {
 
        SetFlag( Dirent->NtByte, FAT_DIRENT_NT_BYTE_8_LOWER_CASE );
    }
 
    if (ExtensionReallyLowercase) {
 
        SetFlag( Dirent->NtByte, FAT_DIRENT_NT_BYTE_3_LOWER_CASE );
    }
 
    //
    //  See if we have to create an Lfn entry
    //
 
    if (ARGUMENT_PRESENT(Lfn)) {
 
        UCHAR DirentChecksum;
        UCHAR DirentsInLfn;
        UCHAR LfnOrdinal;
        PWCHAR LfnBuffer;
        PLFN_DIRENT LfnDirent;
 
        NT_ASSERT( FatData.ChicagoMode );
 
        DirentChecksum = FatComputeLfnChecksum( Dirent );
 
        LfnOrdinal =
        DirentsInLfn = (UCHAR)FAT_LFN_DIRENTS_NEEDED(Lfn);
 
        LfnBuffer = &Lfn->Buffer[(DirentsInLfn - 1) * 13];
 
        NT_ASSERT( DirentsInLfn <= MAX_LFN_DIRENTS );
 
        for (LfnDirent = (PLFN_DIRENT)Dirent - DirentsInLfn;
             LfnDirent < (PLFN_DIRENT)Dirent;
             LfnDirent += 1, LfnOrdinal -= 1, LfnBuffer -= 13) {
 
            WCHAR FinalLfnBuffer[13];
            PWCHAR Buffer;
 
            //
            //  We need to special case the "final" dirent.
            //
 
            if (LfnOrdinal == DirentsInLfn) {
 
                ULONG i;
                ULONG RemainderChars;
 
                RemainderChars = (Lfn->Length / sizeof(WCHAR)) % 13;
 
                LfnDirent->Ordinal = LfnOrdinal | FAT_LAST_LONG_ENTRY;
 
                if (RemainderChars != 0) {
 
                    RtlCopyMemory( FinalLfnBuffer,
                                   LfnBuffer,
                                   RemainderChars * sizeof(WCHAR) );
 
                    for (i = RemainderChars; i < 13; i++) {
 
                        //
                        //  Figure out which character to use.
                        //
 
                        if (i == RemainderChars) {
 
                            FinalLfnBuffer[i] = 0x0000;
 
                        } else {
 
                            FinalLfnBuffer[i] = 0xffff;
                        }
                    }
 
                    Buffer = FinalLfnBuffer;
 
                } else {
 
                    Buffer = LfnBuffer;
                }
 
            } else {
 
                LfnDirent->Ordinal = LfnOrdinal;
 
                Buffer = LfnBuffer;
            }
 
            //
            //  Now fill in the name.
            //
 
            RtlCopyMemory( &LfnDirent->Name1[0],
                           &Buffer[0],
                           5 * sizeof(WCHAR) );
 
            RtlCopyMemory( &LfnDirent->Name2[0],
                           &Buffer[5],
                           6 * sizeof(WCHAR) );
 
            RtlCopyMemory( &LfnDirent->Name3[0],
                           &Buffer[11],
                           2 * sizeof(WCHAR) );
 
            //
            //  And the other fields
            //
 
            LfnDirent->Attributes = FAT_DIRENT_ATTR_LFN;
 
            LfnDirent->Type = 0;
 
            LfnDirent->Checksum = DirentChecksum;
 
            LfnDirent->MustBeZero = 0;
        }
    }
 
    DebugTrace(-1, Dbg, "FatConstructDirent -> (VOID)\n", 0);
    return;
}

Referenced by FatSetRenameInfo().

FatConstructLabelDirent()

VOID FatConstructLabelDirent	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PDIRENT	Dirent,
		IN POEM_STRING	Label
	)

Definition at line 2440 of file dirsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatConstructLabelDirent\n", 0);
 
    DebugTrace( 0, Dbg, "  Dirent             = %p\n", Dirent);
    DebugTrace( 0, Dbg, "  Label              = %Z\n", Label);
 
    RtlZeroMemory( Dirent, sizeof(DIRENT) );
 
    //
    //  We just merrily go and fill up the dirent with the fields given.
    //
 
    RtlCopyMemory( Dirent->FileName, Label->Buffer, Label->Length );
 
    //
    // Pad the label with spaces, not nulls.
    //
 
    RtlFillMemory( &Dirent->FileName[Label->Length], 11 - Label->Length, ' ');
 
    Dirent->LastWriteTime = FatGetCurrentFatTime( IrpContext );
 
    Dirent->Attributes = FAT_DIRENT_ATTR_VOLUME_ID;
    Dirent->ExtendedAttributes = 0;
    Dirent->FileSize = 0;
 
    DebugTrace(-1, Dbg, "FatConstructLabelDirent -> (VOID)\n", 0);
    return;
}

Referenced by FatSetFsLabelInfo().

FatConstructNamesInFcb()

VOID FatConstructNamesInFcb	(	IN PIRP_CONTEXT	IrpContext,
		PFCB	Fcb,
		PDIRENT	Dirent,
		PUNICODE_STRING Lfn	OPTIONAL
	)

Definition at line 3022 of file strucsup.c.

{
#ifndef __REACTOS__
    NTSTATUS Status;
#endif
    ULONG i;
 
#ifndef __REACTOS__
    OEM_STRING OemA;
    OEM_STRING OemB;
#endif
    UNICODE_STRING Unicode;
    POEM_STRING ShortName;
    POEM_STRING LongOemName;
    PUNICODE_STRING LongUniName;
 
    PAGED_CODE();
 
    ShortName = &Fcb->ShortName.Name.Oem;
 
    NT_ASSERT( ShortName->Buffer == NULL );
 
    _SEH2_TRY {
 
        //
        //  First do the short name.
        //
 
        //
        //  Copy over the case flags for the short name of the file
        //
 
        if (FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_8_LOWER_CASE)) {
 
            SetFlag(Fcb->FcbState, FCB_STATE_8_LOWER_CASE);
 
        } else {
 
            ClearFlag(Fcb->FcbState, FCB_STATE_8_LOWER_CASE);
        }
 
        if (FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_3_LOWER_CASE)) {
 
            SetFlag(Fcb->FcbState, FCB_STATE_3_LOWER_CASE);
 
        } else {
 
            ClearFlag(Fcb->FcbState, FCB_STATE_3_LOWER_CASE);
        }
 
        ShortName->MaximumLength = 16;
        ShortName->Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                      16,
                                                      TAG_FILENAME_BUFFER );
 
        Fat8dot3ToString( IrpContext, Dirent, FALSE, ShortName );
 
        Fcb->ShortName.FileNameDos = TRUE;
 
        //
        //  If no Lfn was specified, we are done.  In either case, set the
        //  final name length.
        //
 
        NT_ASSERT( Fcb->ExactCaseLongName.Buffer == NULL );
 
        if (!ARGUMENT_PRESENT(Lfn) || (Lfn->Length == 0)) {
 
            Fcb->FinalNameLength = (USHORT) RtlOemStringToCountedUnicodeSize( ShortName );
            Fcb->ExactCaseLongName.Length = Fcb->ExactCaseLongName.MaximumLength = 0;
 
            try_return( NOTHING );
        }
 
        //
        //  If we already set up the full filename, we could be in trouble.  If the fast
        //  path for doing it already fired, FatSetFullFileNameInFcb, it will have missed
        //  this and could have built the full filename out of the shortname of the file.
        //
        //  At that point, disaster could be inevitable since the final name length will not
        //  match.  We use this to tell the notify package what to do - FatNotifyReportChange.
        //
 
        NT_ASSERT( Fcb->FullFileName.Buffer == NULL );
 
        //
        //  We know now we have an Lfn, save away a copy.
        //
 
        Fcb->FinalNameLength = Lfn->Length;
 
        Fcb->ExactCaseLongName.Length = Fcb->ExactCaseLongName.MaximumLength = Lfn->Length;
        Fcb->ExactCaseLongName.Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                                  Lfn->Length,
                                                                  TAG_FILENAME_BUFFER );
        RtlCopyMemory(Fcb->ExactCaseLongName.Buffer, Lfn->Buffer, Lfn->Length);
 
        //
        //  First check for no extended characters.
        //
 
        for (i=0; i < Lfn->Length/sizeof(WCHAR); i++) {
 
            if (Lfn->Buffer[i] >= 0x80) {
 
                break;
            }
        }
 
        if (i == Lfn->Length/sizeof(WCHAR)) {
 
            //
            //  Cool, I can go with the Oem, upcase it fast by hand.
            //
 
            LongOemName = &Fcb->LongName.Oem.Name.Oem;
 
 
            LongOemName->Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                            Lfn->Length/sizeof(WCHAR),
                                                            TAG_FILENAME_BUFFER );
            LongOemName->Length =
            LongOemName->MaximumLength = Lfn->Length/sizeof(WCHAR);
 
            for (i=0; i < Lfn->Length/sizeof(WCHAR); i++) {
 
                WCHAR c;
 
                c = Lfn->Buffer[i];
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable:4244 )
#endif
                LongOemName->Buffer[i] = c < 'a' ?
                                         (UCHAR)c :
                                         c <= 'z' ?
                                         c - (UCHAR)('a'-'A') :
                                         (UCHAR)c;
#ifdef _MSC_VER
#pragma warning( pop )
#endif
            }
 
            //
            //  If this name happens to be exactly the same as the short
            //  name, don't add it to the splay table.
            //
 
            if (FatAreNamesEqual(IrpContext, *ShortName, *LongOemName) ||
                (FatFindFcb( IrpContext,
                             &Fcb->ParentDcb->Specific.Dcb.RootOemNode,
                             LongOemName,
                             NULL) != NULL)) {
 
                ExFreePool( LongOemName->Buffer );
 
                LongOemName->Buffer = NULL;
                LongOemName->Length =
                LongOemName->MaximumLength = 0;
 
            } else {
 
                SetFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
            }
 
            try_return( NOTHING );
        }
 
        //
        //  Now we have the fun part.  Make a copy of the Lfn.
        //
 
#ifndef __REACTOS__
        OemA.Buffer = NULL;
        OemB.Buffer = NULL;
#endif
        Unicode.Buffer = NULL;
 
        Unicode.Length =
        Unicode.MaximumLength = Lfn->Length;
        Unicode.Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                   Lfn->Length,
                                                   TAG_FILENAME_BUFFER );
 
        RtlCopyMemory( Unicode.Buffer, Lfn->Buffer, Lfn->Length );
 
#ifndef __REACTOS__
        Status = STATUS_SUCCESS;
#endif
 
#if TRUE
        //
        //  Unfortunately, this next block of code breaks down when you have
        //  two long Unicode filenames that both map to the same Oem (and are,
        //  well, long, i.e. are not the short names). In this case, with one
        //  in the prefix table first, the other will hit the common Oem
        //  representation.  This leads to several forms of user astonishment.
        //
        //  It isn't worth it, or probably even possible, to try to figure out
        //  when this is really safe to go through.  Simply omit the attempt.
        //
        //  Ex: ANSI 0x82 and 0x84 in the 1252 ANSI->UNI and 437 UNI->OEM codepages.
        //
        //      0x82 => 0x201a => 0x2c
        //      0x84 => 0x201e => 0x2c
        //
        //  0x2c is comma, so is FAT Oem illegal and forces shortname generation.
        //  Since it is otherwise well-formed by the rules articulated previously,
        //  we would have put 0x2c in the Oem prefix tree.  In terms of the
        //  argument given above, even though there exist no Y and U s.t.
        //
        //  Up(Y) == Up(U) && BestOemFit(U) != BestOemFit(Y)
        //
        //  there most certainly exist Y and U s.t.
        //
        //  Up(Y) != Up(U) && BestOemFit(U) == BestOemFit(Y)
        //
        //  and that is enough to keep us from doing this.  Note that the < 0x80
        //  case is OK since we know that the mapping in the OEM codepages are
        //  the identity in that range.
        //
        //  We still need to monocase it, though.  Do this through a full down/up
        //  transition.
        //
 
        (VOID)RtlDowncaseUnicodeString( &Unicode, &Unicode, FALSE );
        (VOID)RtlUpcaseUnicodeString( &Unicode, &Unicode, FALSE );
#else
        //
        //  Downcase and convert to upcased Oem.  Only continue if we can
        //  convert without error.  Any error other than UNMAPPABLE_CHAR
        //  is a fatal error and we raise.
        //
        //  Note that even if the conversion fails, we must leave Unicode
        //  in an upcased state.
        //
        //  NB: The Rtl doesn't NULL .Buffer on error.
        //
 
        (VOID)RtlDowncaseUnicodeString( &Unicode, &Unicode, FALSE );
        Status = RtlUpcaseUnicodeStringToCountedOemString( &OemA, &Unicode, TRUE );
        (VOID)RtlUpcaseUnicodeString( &Unicode, &Unicode, FALSE );
 
        if (!NT_SUCCESS(Status)) {
 
            if (Status != STATUS_UNMAPPABLE_CHARACTER) {
 
                NT_ASSERT( Status == STATUS_NO_MEMORY );
                ExFreePool(Unicode.Buffer);
                FatNormalizeAndRaiseStatus( IrpContext, Status );
            }
 
        } else {
 
            //
            //  The same as above except upcase.
            //
 
            Status = RtlUpcaseUnicodeStringToCountedOemString( &OemB, &Unicode, TRUE );
 
            if (!NT_SUCCESS(Status)) {
 
                RtlFreeOemString( &OemA );
 
                if (Status != STATUS_UNMAPPABLE_CHARACTER) {
 
                    NT_ASSERT( Status == STATUS_NO_MEMORY );
                    ExFreePool(Unicode.Buffer);
                    FatNormalizeAndRaiseStatus( IrpContext, Status );
                }
            }
        }
 
        //
        //  If the final OemNames are equal, I can use save only the Oem
        //  name.  If the name did not map, then I have to go with the UNICODE
        //  name because I could get a case varient that didn't convert
        //  in create, but did match the LFN.
        //
 
        if (NT_SUCCESS(Status) && FatAreNamesEqual( IrpContext, OemA, OemB )) {
 
            //
            //  Cool, I can go with the Oem.  If we didn't convert correctly,
            //  get a fresh convert from the original LFN.
            //
 
            ExFreePool(Unicode.Buffer);
 
            RtlFreeOemString( &OemB );
 
            Fcb->LongName.Oem.Name.Oem = OemA;
 
            //
            //  If this name happens to be exactly the same as the short
            //  name, or a similar short name already exists don't add it
            //  to the splay table (note the final condition implies a
            //  corrupt disk.
            //
 
            if (FatAreNamesEqual(IrpContext, *ShortName, OemA) ||
                (FatFindFcb( IrpContext,
                             &Fcb->ParentDcb->Specific.Dcb.RootOemNode,
                             &OemA,
                             NULL) != NULL)) {
 
                RtlFreeOemString( &OemA );
 
            } else {
 
                SetFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
            }
 
            try_return( NOTHING );
        }
 
        //
        //  The long name must be left in UNICODE.  Free the two Oem strings
        //  if we got here just because they weren't equal.
        //
 
        if (NT_SUCCESS(Status)) {
 
            RtlFreeOemString( &OemA );
            RtlFreeOemString( &OemB );
        }
#endif
 
        LongUniName = &Fcb->LongName.Unicode.Name.Unicode;
 
        LongUniName->Length =
        LongUniName->MaximumLength = Unicode.Length;
        LongUniName->Buffer = Unicode.Buffer;
 
        SetFlag(Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME);
 
    try_exit: NOTHING;
    } _SEH2_FINALLY {
 
        if (_SEH2_AbnormalTermination()) {
 
            if (ShortName->Buffer != NULL) {
 
                ExFreePool( ShortName->Buffer );
                ShortName->Buffer = NULL;
            }
 
        } else {
 
            //
            //  Creating all the names worked, so add all the names
            //  to the splay tree.
            //
 
            FatInsertName( IrpContext,
                           &Fcb->ParentDcb->Specific.Dcb.RootOemNode,
                           &Fcb->ShortName );
 
            Fcb->ShortName.Fcb = Fcb;
 
            if (FlagOn(Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME)) {
 
                FatInsertName( IrpContext,
                               &Fcb->ParentDcb->Specific.Dcb.RootOemNode,
                               &Fcb->LongName.Oem );
 
                Fcb->LongName.Oem.Fcb = Fcb;
            }
 
            if (FlagOn(Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME)) {
 
                FatInsertName( IrpContext,
                               &Fcb->ParentDcb->Specific.Dcb.RootUnicodeNode,
                               &Fcb->LongName.Unicode );
 
                Fcb->LongName.Unicode.Fcb = Fcb;
            }
 
            SetFlag(Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE);
        }
    } _SEH2_END;
 
    return;
}

Referenced by FatCreateDcb(), FatCreateFcb(), and FatSetRenameInfo().

FatCreateCcb()

PCCB FatCreateCcb

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 2155 of file strucsup.c.

{
    PCCB Ccb;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCreateCcb\n", 0);
 
    //
    //  Allocate a new CCB Record
    //
 
    Ccb = FatAllocateCcb();
 
    RtlZeroMemory( Ccb, sizeof(CCB) );
 
    //
    //  Set the proper node type code and node byte size
    //
 
    Ccb->NodeTypeCode = FAT_NTC_CCB;
    Ccb->NodeByteSize = sizeof(CCB);
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatCreateCcb -> %p\n", Ccb);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return Ccb;
}

FatCreateDcb()

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
	)

Definition at line 1623 of file strucsup.c.

{
    PDCB Dcb = NULL;
 
    //
    //  The following variables are used for abnormal unwind
    //
 
    PVOID UnwindStorage[2] = { NULL, NULL  };
    PERESOURCE UnwindResource = NULL;
    PERESOURCE UnwindResource2 = NULL;
    PLIST_ENTRY UnwindEntryList = NULL;
    PLARGE_MCB UnwindMcb = NULL;
    POPLOCK UnwindOplock = NULL;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCreateDcb\n", 0);
 
    _SEH2_TRY {
 
        //
        //  assert that the only time we are called is if wait is true
        //
 
        NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
        //
        //  Allocate a new DCB, and zero it out
        //
 
        UnwindStorage[0] = Dcb = FatAllocateFcb();
 
        RtlZeroMemory( Dcb, sizeof(DCB) );
 
        UnwindStorage[1] =
        Dcb->NonPaged = FatAllocateNonPagedFcb();
 
        RtlZeroMemory( Dcb->NonPaged, sizeof( NON_PAGED_FCB ) );
 
        //
        //  Set the proper node type code, node byte size and call backs
        //
 
        Dcb->Header.NodeTypeCode = FAT_NTC_DCB;
        Dcb->Header.NodeByteSize = sizeof(DCB);
 
        Dcb->FcbCondition = FcbGood;
 
        //
        //  The initial state, open count, and directory change count fields are
        //  already zero so we can skip setting them
        //
 
        //
        //  Initialize the resource variable
        //
 
 
        UnwindResource =
        Dcb->Header.Resource = FatAllocateResource();
 
        //
        //  Initialize the PagingIo Resource.  We no longer use the FsRtl common
        //  shared pool because this led to a) deadlocks due to cases where files
        //  and their parent directories shared a resource and b) there is no way
        //  to anticipate inter-driver induced deadlock via recursive operation.
        //
 
        UnwindResource2 =
        Dcb->Header.PagingIoResource = FatAllocateResource();
 
        //
        //  Insert this Dcb into our parent dcb's queue
        //
        //  There is a deep reason why this goes on the head, to allow us
        //  to easily enumerate all child directories before child files.
        //  This is important to let us maintain whole-volume lockorder
        //  via BottomUp enumeration.
        //
 
        InsertHeadList( &ParentDcb->Specific.Dcb.ParentDcbQueue,
                        &Dcb->ParentDcbLinks );
        UnwindEntryList = &Dcb->ParentDcbLinks;
 
        //
        //  Point back to our parent dcb
        //
 
        Dcb->ParentDcb = ParentDcb;
 
        //
        //  Set the Vcb
        //
 
        Dcb->Vcb = Vcb;
 
        //
        //  Set the dirent offset within the directory
        //
 
        Dcb->LfnOffsetWithinDirectory = LfnOffsetWithinDirectory;
        Dcb->DirentOffsetWithinDirectory = DirentOffsetWithinDirectory;
 
        //
        //  Set the DirentFatFlags and LastWriteTime
        //
 
        Dcb->DirentFatFlags = Dirent->Attributes;
 
        Dcb->LastWriteTime = FatFatTimeToNtTime( IrpContext,
                                                 Dirent->LastWriteTime,
                                                 0 );
 
        //
        //  These fields are only non-zero when in Chicago mode.
        //
 
        if (FatData.ChicagoMode) {
 
            LARGE_INTEGER FatSystemJanOne1980 = {0};
 
            //
            //  If either date is possibly zero, get the system
            //  version of 1/1/80.
            //
 
            if ((((PUSHORT)Dirent)[9] & ((PUSHORT)Dirent)[8]) == 0) {
 
                ExLocalTimeToSystemTime( &FatJanOne1980,
                                         &FatSystemJanOne1980 );
            }
 
            //
            //  Only do the really hard work if this field is non-zero.
            //
 
            if (((PUSHORT)Dirent)[9] != 0) {
 
                Dcb->LastAccessTime =
                    FatFatDateToNtTime( IrpContext,
                                        Dirent->LastAccessDate );
 
            } else {
 
                Dcb->LastAccessTime = FatSystemJanOne1980;
            }
 
            //
            //  Only do the really hard work if this field is non-zero.
            //
 
            if (((PUSHORT)Dirent)[8] != 0) {
 
                Dcb->CreationTime =
                    FatFatTimeToNtTime( IrpContext,
                                        Dirent->CreationTime,
                                        Dirent->CreationMSec );
 
            } else {
 
                Dcb->CreationTime = FatSystemJanOne1980;
            }
        }
 
        //
        //  Initialize Advanced FCB Header fields
        //
 
        ExInitializeFastMutex( &Dcb->NonPaged->AdvancedFcbHeaderMutex );
        FsRtlSetupAdvancedHeader( &Dcb->Header,
                                  &Dcb->NonPaged->AdvancedFcbHeaderMutex );
 
        //
        //  Initialize the Mcb
        //
 
        FsRtlInitializeLargeMcb( &Dcb->Mcb, PagedPool );
        UnwindMcb = &Dcb->Mcb;
 
        //
        //  Set the file size, first cluster of file, and allocation size
        //  based on the information stored in the dirent
        //
 
        Dcb->FirstClusterOfFile = (ULONG)Dirent->FirstClusterOfFile;
 
        if ( FatIsFat32(Dcb->Vcb) ) {
 
            Dcb->FirstClusterOfFile += Dirent->FirstClusterOfFileHi << 16;
        }
 
        if ( Dcb->FirstClusterOfFile == 0 ) {
 
            Dcb->Header.AllocationSize.QuadPart = 0;
 
        } else {
 
            Dcb->Header.AllocationSize.QuadPart = FCB_LOOKUP_ALLOCATIONSIZE_HINT;
        }
 
 
        //  initialize the notify queues, and the parent dcb queue.
        //
 
        InitializeListHead( &Dcb->Specific.Dcb.ParentDcbQueue );
 
        //
        //  Setup the free dirent bitmap buffer.  Since we don't know the
        //  size of the directory, leave it zero for now.
        //
 
        RtlInitializeBitMap( &Dcb->Specific.Dcb.FreeDirentBitmap,
                             NULL,
                             0 );
 
        //
        //  Set our two create dirent aids to represent that we have yet to
        //  enumerate the directory for never used or deleted dirents.
        //
 
        Dcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
        Dcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        //
        //  Initialize the oplock structure.
        //
 
        FsRtlInitializeOplock( FatGetFcbOplock(Dcb) );
        UnwindOplock = FatGetFcbOplock(Dcb);
#endif
 
        //
        //  Postpone initializing the cache map until we need to do a read/write
        //  of the directory file.
 
 
        //
        //  set the file names.  This must be the last thing we do.
        //
 
        FatConstructNamesInFcb( IrpContext,
                                Dcb,
                                Dirent,
                                Lfn );
 
        Dcb->ShortName.FileNameDos = TRUE;
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatCreateDcb );
 
        //
        //  If this is an abnormal termination then undo our work
        //
 
        if (_SEH2_AbnormalTermination()) {
 
            ULONG i;
 
            if (UnwindOplock != NULL) { FsRtlUninitializeOplock( UnwindOplock ); }
            if (UnwindMcb != NULL) { FsRtlUninitializeLargeMcb( UnwindMcb ); }
            if (UnwindEntryList != NULL) { RemoveEntryList( UnwindEntryList ); }
            if (UnwindResource != NULL) { FatFreeResource( UnwindResource ); }
            if (UnwindResource2 != NULL) { FatFreeResource( UnwindResource2 ); }
 
            for (i = 0; i < sizeof(UnwindStorage)/sizeof(PVOID); i += 1) {
                if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
            }
        }
 
        DebugTrace(-1, Dbg, "FatCreateDcb -> %p\n", Dcb);
    } _SEH2_END;
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatCreateDcb -> %p\n", Dcb);
 
    return Dcb;
}

Referenced by FatCreateDcb().

FatCreateFcb()

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
	)

Definition at line 1252 of file strucsup.c.

{
    PFCB Fcb = NULL;
    POOL_TYPE PoolType;
 
    //
    //  The following variables are used for abnormal unwind
    //
 
    PVOID UnwindStorage[2] = { NULL, NULL };
    PERESOURCE UnwindResource = NULL;
    PERESOURCE UnwindResource2 = NULL;
    PLIST_ENTRY UnwindEntryList = NULL;
    PLARGE_MCB UnwindMcb = NULL;
    PFILE_LOCK UnwindFileLock = NULL;
    POPLOCK UnwindOplock = NULL;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( OrigLfn );
 
    DebugTrace(+1, Dbg, "FatCreateFcb\n", 0);
 
    _SEH2_TRY {
 
        //
        //  Determine the pool type we should be using for the fcb and the
        //  mcb structure
        //
 
        if (IsPagingFile) {
 
            PoolType = NonPagedPoolNx;
            Fcb = UnwindStorage[0] = FsRtlAllocatePoolWithTag( NonPagedPoolNx,
                                                               sizeof(FCB),
                                                               TAG_FCB );
        } else {
 
            PoolType = PagedPool;
            Fcb = UnwindStorage[0] = FatAllocateFcb();
 
        }
 
        //
        //  ... and zero it out
        //
 
        RtlZeroMemory( Fcb, sizeof(FCB) );
 
        UnwindStorage[1] =
        Fcb->NonPaged = FatAllocateNonPagedFcb();
 
        RtlZeroMemory( Fcb->NonPaged, sizeof( NON_PAGED_FCB ) );
 
        //
        //  Set the proper node type code, node byte size, and call backs
        //
 
        Fcb->Header.NodeTypeCode = FAT_NTC_FCB;
        Fcb->Header.NodeByteSize = sizeof(FCB);
 
        Fcb->FcbCondition = FcbGood;
 
        //
        //  Check to see if we need to set the Fcb state to indicate that this
        //  is a paging/system file.  This will prevent it from being opened
        //  again.
        //
 
        if (IsPagingFile) {
 
            SetFlag( Fcb->FcbState, FCB_STATE_PAGING_FILE | FCB_STATE_SYSTEM_FILE );
        }
 
        //
        //  The initial state, open count, and segment objects fields are already
        //  zero so we can skip setting them
        //
 
        //
        //  Initialize the resource variable
        //
 
 
        UnwindResource =
        Fcb->Header.Resource = FatAllocateResource();
 
        //
        //  Initialize the PagingIo Resource.  We no longer use the FsRtl common
        //  shared pool because this led to a) deadlocks due to cases where files
        //  and their parent directories shared a resource and b) there is no way
        //  to anticipate inter-driver induced deadlock via recursive operation.
        //
 
        if (SingleResource) {
 
            Fcb->Header.PagingIoResource = Fcb->Header.Resource;
 
        } else {
 
            UnwindResource2 =
            Fcb->Header.PagingIoResource = FatAllocateResource();
        }
 
        //
        //  Insert this fcb into our parent dcb's queue.
        //
        //  There is a deep reason why this goes on the tail, to allow us
        //  to easily enumerate all child directories before child files.
        //  This is important to let us maintain whole-volume lockorder
        //  via BottomUp enumeration.
        //
 
        InsertTailList( &ParentDcb->Specific.Dcb.ParentDcbQueue,
                        &Fcb->ParentDcbLinks );
        UnwindEntryList = &Fcb->ParentDcbLinks;
 
        //
        //  Point back to our parent dcb
        //
 
        Fcb->ParentDcb = ParentDcb;
 
        //
        //  Set the Vcb
        //
 
        Fcb->Vcb = Vcb;
 
        //
        //  Set the dirent offset within the directory
        //
 
        Fcb->LfnOffsetWithinDirectory = LfnOffsetWithinDirectory;
        Fcb->DirentOffsetWithinDirectory = DirentOffsetWithinDirectory;
 
        //
        //  Set the DirentFatFlags and LastWriteTime
        //
 
        Fcb->DirentFatFlags = Dirent->Attributes;
 
        Fcb->LastWriteTime = FatFatTimeToNtTime( IrpContext,
                                                 Dirent->LastWriteTime,
                                                 0 );
 
        //
        //  These fields are only non-zero when in Chicago mode.
        //
 
        if (FatData.ChicagoMode) {
 
            LARGE_INTEGER FatSystemJanOne1980 = {0};
 
            //
            //  If either date is possibly zero, get the system
            //  version of 1/1/80.
            //
 
            if ((((PUSHORT)Dirent)[9] & ((PUSHORT)Dirent)[8]) == 0) {
 
                ExLocalTimeToSystemTime( &FatJanOne1980,
                                         &FatSystemJanOne1980 );
            }
 
            //
            //  Only do the really hard work if this field is non-zero.
            //
 
            if (((PUSHORT)Dirent)[9] != 0) {
 
                Fcb->LastAccessTime =
                    FatFatDateToNtTime( IrpContext,
                                        Dirent->LastAccessDate );
 
            } else {
 
                Fcb->LastAccessTime = FatSystemJanOne1980;
            }
 
            //
            //  Only do the really hard work if this field is non-zero.
            //
 
            if (((PUSHORT)Dirent)[8] != 0) {
 
                Fcb->CreationTime =
                    FatFatTimeToNtTime( IrpContext,
                                        Dirent->CreationTime,
                                        Dirent->CreationMSec );
 
            } else {
 
                Fcb->CreationTime = FatSystemJanOne1980;
            }
        }
 
        //
        //  Initialize Advanced FCB Header fields
        //
 
        ExInitializeFastMutex( &Fcb->NonPaged->AdvancedFcbHeaderMutex );
        FsRtlSetupAdvancedHeader( &Fcb->Header,
                                  &Fcb->NonPaged->AdvancedFcbHeaderMutex );
 
        //
        //  To make FAT match the present functionality of NTFS, disable
        //  stream contexts on paging files
        //
 
        if (IsPagingFile) {
 
            SetFlag( Fcb->Header.Flags2, FSRTL_FLAG2_IS_PAGING_FILE );
            ClearFlag( Fcb->Header.Flags2, FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS );
        }
 
        //
        //  Initialize the Mcb
        //
 
        FsRtlInitializeLargeMcb( &Fcb->Mcb, PoolType );
        UnwindMcb = &Fcb->Mcb;
 
        //
        //  Set the file size, valid data length, first cluster of file,
        //  and allocation size based on the information stored in the dirent
        //
 
        Fcb->Header.FileSize.LowPart = Dirent->FileSize;
 
        Fcb->Header.ValidDataLength.LowPart = Dirent->FileSize;
 
        Fcb->ValidDataToDisk = Dirent->FileSize;
 
        Fcb->FirstClusterOfFile = (ULONG)Dirent->FirstClusterOfFile;
 
        if ( FatIsFat32(Vcb) ) {
 
            Fcb->FirstClusterOfFile += Dirent->FirstClusterOfFileHi << 16;
        }
 
        if ( Fcb->FirstClusterOfFile == 0 ) {
 
            Fcb->Header.AllocationSize.QuadPart = 0;
 
        } else {
 
            Fcb->Header.AllocationSize.QuadPart = FCB_LOOKUP_ALLOCATIONSIZE_HINT;
        }
 
 
        //
        //  Initialize the Fcb's file lock record
        //
 
        FsRtlInitializeFileLock( &Fcb->Specific.Fcb.FileLock, NULL, NULL );
        UnwindFileLock = &Fcb->Specific.Fcb.FileLock;
 
        //
        //  Initialize the oplock structure.
        //
 
        FsRtlInitializeOplock( FatGetFcbOplock(Fcb) );
        UnwindOplock = FatGetFcbOplock(Fcb);
 
        //
        //  Indicate that Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = TRUE;
 
        //
        //  Set the file names.  This must be the last thing we do.
        //
 
        FatConstructNamesInFcb( IrpContext,
                                Fcb,
                                Dirent,
                                Lfn );
 
        //
        //  Drop the shortname hint so prefix searches can figure out
        //  what they found
        //
 
        Fcb->ShortName.FileNameDos = TRUE;
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatCreateFcb );
 
        //
        //  If this is an abnormal termination then undo our work
        //
 
        if (_SEH2_AbnormalTermination()) {
 
            ULONG i;
 
            if (UnwindOplock != NULL) { FsRtlUninitializeOplock( UnwindOplock ); }
            if (UnwindFileLock != NULL) { FsRtlUninitializeFileLock( UnwindFileLock ); }
            if (UnwindMcb != NULL) { FsRtlUninitializeLargeMcb( UnwindMcb ); }
            if (UnwindEntryList != NULL) { RemoveEntryList( UnwindEntryList ); }
            if (UnwindResource != NULL) { FatFreeResource( UnwindResource ); }
            if (UnwindResource2 != NULL) { FatFreeResource( UnwindResource2 ); }
 
            for (i = 0; i < sizeof(UnwindStorage)/sizeof(PVOID); i += 1) {
                if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
            }
        }
 
        DebugTrace(-1, Dbg, "FatCreateFcb -> %p\n", Fcb);
    } _SEH2_END;
 
    //
    //  return and tell the caller
    //
 
    return Fcb;
}

Referenced by FatCreateFcb().

FatCreateIrpContext()

PIRP_CONTEXT FatCreateIrpContext	(	IN PIRP	Irp,
		IN BOOLEAN	Wait
	)

Definition at line 2301 of file strucsup.c.

{
    PIRP_CONTEXT IrpContext;
    PIO_STACK_LOCATION IrpSp;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCreateIrpContext\n", 0);
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  The only operations a filesystem device object should ever receive
    //  are create/teardown of fsdo handles and operations which do not
    //  occur in the context of fileobjects (i.e., mount).
    //
 
    if (FatDeviceIsFatFsdo( IrpSp->DeviceObject))  {
 
        if (IrpSp->FileObject != NULL &&
            IrpSp->MajorFunction != IRP_MJ_CREATE &&
            IrpSp->MajorFunction != IRP_MJ_CLEANUP &&
            IrpSp->MajorFunction != IRP_MJ_CLOSE) {
 
            ExRaiseStatus( STATUS_INVALID_DEVICE_REQUEST );
        }
 
        NT_ASSERT( IrpSp->FileObject != NULL ||
 
                (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                 IrpSp->MinorFunction == IRP_MN_USER_FS_REQUEST &&
                 IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_INVALIDATE_VOLUMES) ||
 
                (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                 IrpSp->MinorFunction == IRP_MN_MOUNT_VOLUME ) ||
 
                IrpSp->MajorFunction == IRP_MJ_SHUTDOWN );
    }
 
    //
    //  Attemtp to allocate from the region first and failing that allocate
    //  from pool.
    //
 
    DebugDoit( FatFsdEntryCount += 1);
 
    IrpContext = FatAllocateIrpContext();
 
    //
    //  Zero out the irp context.
    //
 
    RtlZeroMemory( IrpContext, sizeof(IRP_CONTEXT) );
 
    //
    //  Set the proper node type code and node byte size
    //
 
    IrpContext->NodeTypeCode = FAT_NTC_IRP_CONTEXT;
    IrpContext->NodeByteSize = sizeof(IRP_CONTEXT);
 
    //
    //  Set the originating Irp field
    //
 
    IrpContext->OriginatingIrp = Irp;
 
    //
    //  Major/Minor Function codes
    //
 
    IrpContext->MajorFunction = IrpSp->MajorFunction;
    IrpContext->MinorFunction = IrpSp->MinorFunction;
 
    //
    //  Copy RealDevice for workque algorithms, and also set Write Through
    //  and Removable Media if there is a file object.  Only file system
    //  control Irps won't have a file object, and they should all have
    //  a Vpb as the first IrpSp location.
    //
 
    if (IrpSp->FileObject != NULL) {
 
        PFILE_OBJECT FileObject = IrpSp->FileObject;
 
        IrpContext->RealDevice = FileObject->DeviceObject;
        IrpContext->Vcb = &((PVOLUME_DEVICE_OBJECT)(IrpSp->DeviceObject))->Vcb;
 
        //
        //  See if the request is Write Through. Look for both FileObjects opened
        //  as write through, and non-cached requests with the SL_WRITE_THROUGH flag set.
        //
        //  The latter can only originate from kernel components. (Note - NtWriteFile()
        //  does redundantly set the SL_W_T flag for all requests it issues on write
        //  through file objects)
        //
 
        if (IsFileWriteThrough( FileObject, IrpContext->Vcb ) ||
            ( (IrpSp->MajorFunction == IRP_MJ_WRITE) &&
              BooleanFlagOn( Irp->Flags, IRP_NOCACHE) &&
              BooleanFlagOn( IrpSp->Flags, SL_WRITE_THROUGH))) {
 
            SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
        }
    } else if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) {
 
        IrpContext->RealDevice = IrpSp->Parameters.MountVolume.Vpb->RealDevice;
    }
 
    //
    //  Set the wait parameter
    //
 
    if (Wait) { SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); }
 
    //
    //  Set the recursive file system call parameter.  We set it true if
    //  the TopLevelIrp field in the thread local storage is not the current
    //  irp, otherwise we leave it as FALSE.
    //
 
    if ( IoGetTopLevelIrp() != Irp) {
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL);
    }
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatCreateIrpContext -> %p\n", IrpContext);
 
    return IrpContext;
}

Referenced by _Function_class_(), _Requires_lock_held_(), FatMultiAsyncCompletionRoutine(), and FatSingleAsyncCompletionRoutine().

FatDeallocateCcbStrings()

VOID FatDeallocateCcbStrings

(

IN PCCB

Ccb

)

Definition at line 2209 of file strucsup.c.

{
    PAGED_CODE();
 
    //
    //  If we allocated query template buffers, deallocate them now.
    //
 
    if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_UNICODE)) {
 
        NT_ASSERT( Ccb->UnicodeQueryTemplate.Buffer);
        NT_ASSERT( !FlagOn( Ccb->Flags, CCB_FLAG_CLOSE_CONTEXT));
        RtlFreeUnicodeString( &Ccb->UnicodeQueryTemplate );
    }
 
    if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT)) {
 
        NT_ASSERT( Ccb->OemQueryTemplate.Wild.Buffer );
        NT_ASSERT( !FlagOn( Ccb->Flags, CCB_FLAG_CLOSE_CONTEXT));
        RtlFreeOemString( &Ccb->OemQueryTemplate.Wild );
    }
 
    ClearFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT | CCB_FLAG_FREE_UNICODE);
}

Referenced by FatDeleteCcb().

FatDecodeFileObject()

TYPE_OF_OPEN FatDecodeFileObject	(	_In_ PFILE_OBJECT	FileObject,
		_Outptr_ PVCB *	Vcb,
		_Outptr_ PFCB *	FcbOrDcb,
		_Outptr_ PCCB *	Ccb
	)

Definition at line 176 of file filobsup.c.

{
    TYPE_OF_OPEN TypeOfOpen;
    PVOID FsContext;
    PVOID FsContext2;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDecodeFileObject, FileObject = %p\n", FileObject);
 
    //
    //  Reference the fs context fields of the file object, and zero out
    //  the out pointer parameters.
    //
 
    FsContext = FileObject->FsContext;
    FsContext2 = FileObject->FsContext2;
 
    //
    //  Special case the situation where FsContext is null
    //
 
    if (FsContext == NULL) {
 
        *Ccb = NULL;
        *FcbOrDcb = NULL;
        *Vcb = NULL;
 
        TypeOfOpen = UnopenedFileObject;
 
    } else {
 
        //
        //  Now we can case on the node type code of the fscontext pointer
        //  and set the appropriate out pointers
        //
 
        switch (NodeType(FsContext)) {
 
        case FAT_NTC_VCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = NULL;
            *Vcb = FsContext;
 
            TypeOfOpen = ( *Ccb == NULL ? VirtualVolumeFile : UserVolumeOpen );
 
            break;
 
        case FAT_NTC_ROOT_DCB:
        case FAT_NTC_DCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = FsContext;
            *Vcb = (*FcbOrDcb)->Vcb;
 
            TypeOfOpen = ( *Ccb == NULL ? DirectoryFile : UserDirectoryOpen );
 
            DebugTrace(0, Dbg, "Referencing directory: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
            break;
 
        case FAT_NTC_FCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = FsContext;
            *Vcb = (*FcbOrDcb)->Vcb;
 
            if (*Ccb != NULL ) {
 
                TypeOfOpen = UserFileOpen;
                DebugTrace(0, Dbg, "Referencing file: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
            } else {
 
                //
                // No Ccb means this is a special open.
                //
 
 
                if ( *FcbOrDcb == (*Vcb)->EaFcb ) {
 
                    TypeOfOpen = EaFile;
                    DebugTrace(0, Dbg, "Referencing EA file: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
                } else {
 
#ifdef _MSC_VER
#pragma prefast(suppress:28159, "things are seriously wrong if we get here")
#endif
                    FatBugCheck( NodeType(FsContext), 0, 0 );
 
                }
 
            }
 
            break;
 
        default:
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( NodeType(FsContext), 0, 0 );
        }
    }
 
    //
    //  and return to our caller
    //
 
    DebugTrace(0, Dbg, "FatDecodeFileObject -> VCB(%p)\n", *Vcb);
    DebugTrace(0, Dbg, "FatDecodeFileObject -> FCB(%p)\n", *FcbOrDcb);
    DebugTrace(0, Dbg, "FatDecodeFileObject -> CCB(%p)\n", *Ccb);
    DebugTrace(-1, Dbg, "FatDecodeFileObject -> TypeOfOpen = %08lx\n", TypeOfOpen);
 
    return TypeOfOpen;
}

Referenced by _Function_class_(), _Requires_lock_held_(), FatAllowExtendedDasdIo(), FatCommonQueryEa(), FatCommonSetEa(), FatDeferredFlush(), FatFspDispatch(), FatIsVolumeDirty(), FatIsVolumeMounted(), FatSetRenameInfo(), FatSetZeroOnDeallocate(), and FatUnlockVolume().

FatDeleteCcb()

VOID FatDeleteCcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PCCB *	Ccb
	)

Definition at line 2254 of file strucsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeleteCcb, Ccb = %p\n", *Ccb);
 
    FatDeallocateCcbStrings( *Ccb);
 
    //
    //  Deallocate the Ccb record
    //
 
    FatFreeCcb( *Ccb );
    *Ccb = NULL;
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatDeleteCcb -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by if().

FatDeleteFcb()

VOID FatDeleteFcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB *	Fcb
	)

Definition at line 1952 of file strucsup.c.

{
    PFCB Fcb = *FcbPtr;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeleteFcb, Fcb = %p\n", Fcb);
 
    //
    //  We can only delete this record if the open count is zero.
    //
 
    if (Fcb->OpenCount != 0) {
 
        DebugDump("Error deleting Fcb, Still Open\n", 0, Fcb);
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( 0, 0, 0 );
    }
 
    //
    //  Better be an FCB/DCB.
    //
 
    if ((Fcb->Header.NodeTypeCode != FAT_NTC_DCB) &&
        (Fcb->Header.NodeTypeCode != FAT_NTC_ROOT_DCB) &&
        (Fcb->Header.NodeTypeCode != FAT_NTC_FCB)) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( 0, 0, 0 );
    }
 
    //
    //  If this is a DCB then remove every Notify record from the two
    //  notify queues
    //
 
    if ((Fcb->Header.NodeTypeCode == FAT_NTC_DCB) ||
        (Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
 
        //
        //  If we allocated a free dirent bitmap buffer, free it.
        //
 
        if ((Fcb->Specific.Dcb.FreeDirentBitmap.Buffer != NULL) &&
            (Fcb->Specific.Dcb.FreeDirentBitmap.Buffer !=
             &Fcb->Specific.Dcb.FreeDirentBitmapBuffer[0])) {
 
            ExFreePool(Fcb->Specific.Dcb.FreeDirentBitmap.Buffer);
        }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        //
        //  Uninitialize the oplock.
        //
 
        FsRtlUninitializeOplock( FatGetFcbOplock(Fcb) );
#endif
 
        NT_ASSERT( Fcb->Specific.Dcb.DirectoryFileOpenCount == 0 );
        NT_ASSERT( IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) );
        NT_ASSERT( NULL == Fcb->Specific.Dcb.DirectoryFile);
 
    } else {
 
        //
        //  Uninitialize the byte range file locks and opportunistic locks
        //
 
        FsRtlUninitializeFileLock( &Fcb->Specific.Fcb.FileLock );
        FsRtlUninitializeOplock( FatGetFcbOplock(Fcb) );
    }
 
 
    //
    //  Release any Filter Context structures associated with this FCB
    //
 
    FsRtlTeardownPerStreamContexts( &Fcb->Header );
 
    //
    //  Uninitialize the Mcb
    //
 
    FsRtlUninitializeLargeMcb( &Fcb->Mcb );
 
    //
    //  If this is not the root dcb then we need to remove ourselves from
    //  our parents Dcb queue
    //
 
    if (Fcb->Header.NodeTypeCode != FAT_NTC_ROOT_DCB) {
 
        RemoveEntryList( &(Fcb->ParentDcbLinks) );
    }
 
    //
    //  Remove the entry from the splay table if there is still is one.
    //
 
    if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
 
        FatRemoveNames( IrpContext, Fcb );
    }
 
    //
    //  Free the file name pool if allocated.
    //
 
    if (Fcb->Header.NodeTypeCode != FAT_NTC_ROOT_DCB) {
 
        //
        //  If we blew up at inconvenient times, the shortname
        //  could be null even though you will *never* see this
        //  normally.  Rename is a good example of this case.
        //
 
        if (Fcb->ShortName.Name.Oem.Buffer) {
 
            ExFreePool( Fcb->ShortName.Name.Oem.Buffer );
        }
 
        if (Fcb->FullFileName.Buffer) {
 
            ExFreePool( Fcb->FullFileName.Buffer );
        }
    }
 
    if (Fcb->ExactCaseLongName.Buffer) {
 
        ExFreePool(Fcb->ExactCaseLongName.Buffer);
    }
 
#ifdef SYSCACHE_COMPILE
 
    if (Fcb->WriteMask) {
 
        ExFreePool( Fcb->WriteMask );
    }
 
#endif
 
    //
    //  Finally deallocate the Fcb and non-paged fcb records
    //
 
    FatFreeResource( Fcb->Header.Resource );
 
    if (Fcb->Header.PagingIoResource != Fcb->Header.Resource) {
 
        FatFreeResource( Fcb->Header.PagingIoResource );
    }
 
    //
    //  If an Event was allocated, get rid of it.
    //
 
    if (Fcb->NonPaged->OutstandingAsyncEvent) {
 
        ExFreePool( Fcb->NonPaged->OutstandingAsyncEvent );
    }
 
    FatFreeNonPagedFcb( Fcb->NonPaged );
 
    Fcb->Header.NodeTypeCode = NTC_UNDEFINED;
 
    FatFreeFcb( Fcb );
    *FcbPtr = NULL;
 
    //
    //  and return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatDeleteFcb -> VOID\n", 0);
}

Referenced by FatDeleteVcb(), and if().

FatDeleteIrpContext_Real()

VOID FatDeleteIrpContext_Real

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 2461 of file strucsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeleteIrpContext, IrpContext = %p\n", IrpContext);
 
    NT_ASSERT( IrpContext->NodeTypeCode == FAT_NTC_IRP_CONTEXT );
    NT_ASSERT( IrpContext->PinCount == 0 );
 
 
    //
    //  If there is a FatIoContext that was allocated, free it.
    //
 
    if (IrpContext->FatIoContext != NULL) {
 
        if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
 
            if (IrpContext->FatIoContext->ZeroMdl) {
                IoFreeMdl( IrpContext->FatIoContext->ZeroMdl );
            }
 
            ExFreePool( IrpContext->FatIoContext );
        }
    }
 
    //
    //  Drop the IrpContext.
    //
 
    FatFreeIrpContext( IrpContext );
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatDeleteIrpContext -> VOID\n", 0);
 
    return;
}

FatDeletePackedEa()

VOID FatDeletePackedEa	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_SET_HEADER	EaSetHeader,
		IN OUT PULONG	PackedEasLength,
		IN ULONG	Offset
	)

Definition at line 3148 of file easup.c.

{
    PPACKED_EA PackedEa;
    ULONG PackedEaSize;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeletePackedEa, Offset = %08lx\n", Offset);
 
    //
    //  Get a reference to the packed ea and figure out its size
    //
 
    PackedEa = (PPACKED_EA) (&EaSetHeader->PackedEas[Offset]);
 
    SizeOfPackedEa( PackedEa, &PackedEaSize );
 
    //
    //  Determine if we need to decrement our need ea changes count
    //
 
    if (FlagOn(PackedEa->Flags, EA_NEED_EA_FLAG)) {
 
        EaSetHeader->NeedEaCount--;
    }
 
    //
    //  Shrink the ea list over the deleted ea.  The amount to copy is the
    //  total size of the ea list minus the offset to the end of the ea
    //  we're deleting.
    //
    //  Before:
    //              Offset    Offset+PackedEaSize      UsedSize    Allocated
    //                |                |                  |            |
    //                V                V                  V            V
    //      +xxxxxxxx+yyyyyyyyyyyyyyyy+zzzzzzzzzzzzzzzzzz+------------+
    //
    //  After
    //              Offset            UsedSize                     Allocated
    //                |                  |                             |
    //                V                  V                             V
    //      +xxxxxxxx+zzzzzzzzzzzzzzzzzz+-----------------------------+
    //
 
    RtlCopyMemory( PackedEa,
                   (PUCHAR) PackedEa + PackedEaSize,
                   *PackedEasLength - (Offset + PackedEaSize) );
 
    //
    //  And zero out the remaing part of the ea list, to make things
    //  nice and more robust
    //
 
    RtlZeroMemory( &EaSetHeader->PackedEas[*PackedEasLength - PackedEaSize],
                   PackedEaSize );
 
    //
    //  Decrement the used size by the amount we just removed
    //
 
    *PackedEasLength -= PackedEaSize;
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatDeletePackedEa -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by FatCommonSetEa().

FatDeleteVcb()

VOID FatDeleteVcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 772 of file strucsup.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeleteVcb, Vcb = %p\n", Vcb);
 
    //
    //  If the IrpContext points to the VCB being deleted NULL out the stail
    //  pointer.
    //
 
    if (IrpContext->Vcb == Vcb) {
 
        IrpContext->Vcb = NULL;
 
    }
 
    //
    //  Chuck the backpocket Vpb we kept just in case.
    //
 
    if (Vcb->SwapVpb) {
 
        ExFreePool( Vcb->SwapVpb );
 
    }
 
    //
    //  Free the VPB, if we need to.
    //
 
    if (FlagOn( Vcb->VcbState, VCB_STATE_FLAG_VPB_MUST_BE_FREED )) {
 
        //
        //  We swapped the VPB, so we need to free the main one.
        //
 
        ExFreePool( Vcb->Vpb );
    }
 
    if (Vcb->VolumeGuidPath.Buffer) {
        ExFreePool( Vcb->VolumeGuidPath.Buffer );
        Vcb->VolumeGuidPath.Buffer = NULL;
    }
 
    //
    //  Remove this record from the global list of all Vcb records.
    //  Note that the global lock must already be held when calling
    //  this function.
    //
 
    RemoveEntryList( &(Vcb->VcbLinks) );
 
    //
    //  Make sure the direct access open count is zero, and the open file count
    //  is also zero.
    //
 
    if ((Vcb->DirectAccessOpenCount != 0) || (Vcb->OpenFileCount != 0)) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( 0, 0, 0 );
    }
 
    //
    //  Remove the EaFcb and dereference the Fcb for the Ea file if it
    //  exists.
    //
 
    if (Vcb->EaFcb != NULL) {
 
        Vcb->EaFcb->OpenCount = 0;
        FatDeleteFcb( IrpContext, &Vcb->EaFcb );
    }
 
    //
    //  Remove the Root Dcb
    //
 
    if (Vcb->RootDcb != NULL) {
 
        //
        //  Rundown stale child Fcbs that may be hanging around.  Yes, this
        //  can happen.  No, the create path isn't perfectly defensive about
        //  tearing down branches built up on creates that don't wind up
        //  succeeding.  Normal system operation usually winds up having
        //  cleaned them out through re-visiting, but ...
        //
        //  Just pick off Fcbs from the bottom of the tree until we run out.
        //  Then we delete the root Dcb.
        //
 
        while( (Fcb = FatGetNextFcbBottomUp( IrpContext, NULL, Vcb->RootDcb )) != Vcb->RootDcb ) {
 
            FatDeleteFcb( IrpContext, &Fcb );
        }
 
        FatDeleteFcb( IrpContext, &Vcb->RootDcb );
    }
 
    //
    //  Uninitialize the notify sychronization object.
    //
 
    FsRtlNotifyUninitializeSync( &Vcb->NotifySync );
 
    //
    //  Uninitialize the resource variable for the Vcb
    //
 
    FatDeleteResource( &Vcb->Resource );
    FatDeleteResource( &Vcb->ChangeBitMapResource );
 
    //
    //  If allocation support has been setup, free it.
    //
 
    if (Vcb->FreeClusterBitMap.Buffer != NULL) {
 
        FatTearDownAllocationSupport( IrpContext, Vcb );
    }
 
    //
    //  UnInitialize the Mcb structure that kept track of dirty fat sectors.
    //
 
    FsRtlUninitializeLargeMcb( &Vcb->DirtyFatMcb );
 
    //
    //  Uninitialize the Mcb structure that kept track of bad sectors.
    //
 
    FsRtlUninitializeLargeMcb( &Vcb->BadBlockMcb );
 
    //
    //  Free the pool for the stached copy of the boot sector
    //
 
    if ( Vcb->First0x24BytesOfBootSector ) {
 
        ExFreePool( Vcb->First0x24BytesOfBootSector );
        Vcb->First0x24BytesOfBootSector = NULL;
    }
 
    //
    //  Cancel the CleanVolume Timer and Dpc
    //
 
    (VOID)KeCancelTimer( &Vcb->CleanVolumeTimer );
 
    (VOID)KeRemoveQueueDpc( &Vcb->CleanVolumeDpc );
 
    //
    //  Free the performance counters memory
    //
 
    ExFreePool( Vcb->Statistics );
 
    //
    //  Clean out the tunneling cache
    //
 
    FsRtlDeleteTunnelCache(&Vcb->Tunnel);
 
    //
    // Dereference the target device object.
    //
 
    ObDereferenceObject( Vcb->TargetDeviceObject );
 
    //
    //  We better have used all the close contexts we allocated. There could be
    //  one remaining if we're doing teardown due to a final close coming in on
    //  a directory file stream object.  It will be freed on the way back up.
    //
 
    NT_ASSERT( Vcb->CloseContextCount <= 1);
 
    //
    //  And zero out the Vcb, this will help ensure that any stale data is
    //  wiped clean
    //
 
    RtlZeroMemory( Vcb, sizeof(VCB) );
 
    //
    //  return and tell the caller
    //
 
    DebugTrace(-1, Dbg, "FatDeleteVcb -> VOID\n", 0);
 
    return;
}

FatEnsureStringBufferEnough()

VOID FatEnsureStringBufferEnough	(	_Inout_ PVOID	String,
		_In_ USHORT	DesiredBufferSize
	)

Definition at line 3739 of file strucsup.c.

{
    PSTRING LocalString = String;
 
    PAGED_CODE();
 
    if (LocalString->MaximumLength < DesiredBufferSize)  {
 
        FatFreeStringBuffer( LocalString);
 
        LocalString->Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                        DesiredBufferSize,
                                                        TAG_DYNAMIC_NAME_BUFFER);
        NT_ASSERT( LocalString->Buffer);
 
        LocalString->MaximumLength = DesiredBufferSize;
    }
}

FatEvaluateNameCase()

VOID FatEvaluateNameCase	(	IN PIRP_CONTEXT	IrpContext,
		IN PUNICODE_STRING	Name,
		IN OUT BOOLEAN *	AllLowerComponent,
		IN OUT BOOLEAN *	AllLowerExtension,
		IN OUT BOOLEAN *	CreateLfn
	)

Definition at line 891 of file namesup.c.

{
    ULONG i;
    UCHAR Uppers = 0;
    UCHAR Lowers = 0;
 
    BOOLEAN ExtensionPresent = FALSE;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    *CreateLfn = FALSE;
 
    for (i = 0; i < UnicodeName->Length / sizeof(WCHAR); i++) {
 
        WCHAR c;
 
        c = UnicodeName->Buffer[i];
 
        if ((c >= 'A') && (c <= 'Z')) {
 
            Uppers += 1;
 
        } else if ((c >= 'a') && (c <= 'z')) {
 
            Lowers += 1;
 
        } else if ((c >= 0x0080) && FatData.CodePageInvariant) {
 
            break;
        }
 
        //
        //  If we come to a period, figure out if the extension was
        //  all one case.
        //
 
        if (c == L'.') {
 
            *CreateLfn = (Lowers != 0) && (Uppers != 0);
 
            *AllLowerComponent = !(*CreateLfn) && (Lowers != 0);
 
            ExtensionPresent = TRUE;
 
            //
            //  Now reset the uppers and lowers count.
            //
 
            Uppers = Lowers = 0;
        }
    }
 
    //
    //  Now check again for creating an LFN.
    //
 
    *CreateLfn = (*CreateLfn ||
                  (i != UnicodeName->Length / sizeof(WCHAR)) ||
                  ((Lowers != 0) && (Uppers != 0)));
 
    //
    //  Now we know the final state of CreateLfn, update the two
    //  "AllLower" booleans.
    //
 
    if (ExtensionPresent) {
 
        *AllLowerComponent = !(*CreateLfn) && *AllLowerComponent;
        *AllLowerExtension = !(*CreateLfn) && (Lowers != 0);
 
    } else {
 
        *AllLowerComponent = !(*CreateLfn) && (Lowers != 0);
        *AllLowerExtension = FALSE;
    }
 
    return;
}

Referenced by FatSetRenameInfo().

FatExamineFatEntries()

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
	)

Definition at line 4720 of file allocsup.c.

{
    ULONG FatIndexBitSize;
    ULONG Page = 0;
    ULONG Offset = 0;
    ULONG FatIndex;
    FAT_ENTRY FatEntry = FAT_CLUSTER_AVAILABLE;
    FAT_ENTRY FirstFatEntry = FAT_CLUSTER_AVAILABLE;
    PUSHORT FatBuffer;
    PVOID pv;
    PBCB Bcb = NULL;
    ULONG EntriesPerWindow;
 
    ULONG ClustersThisRun;
    ULONG StartIndexOfThisRun;
 
    PULONG FreeClusterCount = NULL;
 
    PFAT_WINDOW CurrentWindow = NULL;
 
    PVOID NewBitMapBuffer = NULL;
    PRTL_BITMAP BitMap = NULL;
    RTL_BITMAP PrivateBitMap;
 
    ULONG ClusterSize = 0;
    ULONG PrefetchPages = 0;
    ULONG FatPages = 0;
 
    VBO BadClusterVbo = 0;
    LBO Lbo = 0;
 
    enum RunType {
        FreeClusters,
        AllocatedClusters,
        UnknownClusters
    } CurrentRun;
 
    PAGED_CODE();
 
    //
    //  Now assert correct usage.
    //
 
    FatIndexBitSize = Vcb->AllocationSupport.FatIndexBitSize;
 
    NT_ASSERT( !(SetupWindows && (SwitchToWindow || BitMapBuffer)));
    NT_ASSERT( !(SetupWindows && FatIndexBitSize != 32));
 
    if (Vcb->NumberOfWindows > 1) {
 
        //
        //  FAT32: Calculate the number of FAT entries covered by a window.  This is
        //  equal to the number of bits in the freespace bitmap,  the size of which
        //  is hardcoded.
        //
 
        EntriesPerWindow = MAX_CLUSTER_BITMAP_SIZE;
 
    } else {
 
        EntriesPerWindow = Vcb->AllocationSupport.NumberOfClusters;
    }
 
    //
    //  We will also fill in the cumulative count of free clusters for
    //  the entire volume.  If this is not appropriate, NULL it out
    //  shortly.
    //
 
    FreeClusterCount = &Vcb->AllocationSupport.NumberOfFreeClusters;
 
    if (SetupWindows) {
 
        NT_ASSERT(BitMapBuffer == NULL);
 
        //
        //  In this case we're just supposed to scan the fat and set up
        //  the information regarding where the buckets fall and how many
        //  free clusters are in each.
        //
        //  It is fine to monkey with the real windows, we must be able
        //  to do this to activate the volume.
        //
 
        BitMap = NULL;
 
        CurrentWindow = &Vcb->Windows[0];
        CurrentWindow->FirstCluster = StartIndex;
        CurrentWindow->ClustersFree = 0;
 
        //
        //  We always wish to calculate total free clusters when
        //  setting up the FAT windows.
        //
 
    } else if (BitMapBuffer == NULL) {
 
        //
        //  We will be filling in the free cluster bitmap for the volume.
        //  Careful, we can raise out of here and be hopelessly hosed if
        //  we built this up in the main bitmap/window itself.
        //
        //  For simplicity's sake, we'll do the swap for everyone. FAT32
        //  provokes the need since we can't tolerate partial results
        //  when switching windows.
        //
 
        NT_ASSERT( SwitchToWindow );
 
        CurrentWindow = SwitchToWindow;
        StartIndex = CurrentWindow->FirstCluster;
        EndIndex = CurrentWindow->LastCluster;
 
        BitMap = &PrivateBitMap;
        NewBitMapBuffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                    (EntriesPerWindow + 7) / 8,
                                                    TAG_FAT_BITMAP );
 
        RtlInitializeBitMap( &PrivateBitMap,
                             NewBitMapBuffer,
                             EndIndex - StartIndex + 1);
 
        if ((FatIndexBitSize == 32) &&
            (Vcb->NumberOfWindows > 1)) {
 
            //
            //  We do not wish count total clusters here.
            //
 
            FreeClusterCount = NULL;
 
        }
 
    } else {
 
        BitMap = &PrivateBitMap;
        RtlInitializeBitMap(&PrivateBitMap,
                            BitMapBuffer,
                            EndIndex - StartIndex + 1);
 
        //
        //  We do not count total clusters here.
        //
 
        FreeClusterCount = NULL;
    }
 
    //
    //  Now, our start index better be in the file heap.
    //
 
    NT_ASSERT( StartIndex >= 2 );
 
    _SEH2_TRY {
 
        //
        //  Pick up the initial chunk of the FAT and first entry.
        //
 
        if (FatIndexBitSize == 12) {
 
            //
            //  We read in the entire fat in the 12 bit case.
            //
 
            FatReadVolumeFile( IrpContext,
                               Vcb,
                               FatReservedBytes( &Vcb->Bpb ),
                               FatBytesPerFat( &Vcb->Bpb ),
                               &Bcb,
                               (PVOID *)&FatBuffer );
 
            FatLookup12BitEntry(FatBuffer, 0, &FirstFatEntry);
 
        } else {
 
            //
            //  Read in one page of fat at a time.  We cannot read in the
            //  all of the fat we need because of cache manager limitations.
            //
 
            ULONG BytesPerEntry = FatIndexBitSize >> 3;
 
            FatPages = (FatReservedBytes(&Vcb->Bpb) + FatBytesPerFat(&Vcb->Bpb) + (PAGE_SIZE - 1)) / PAGE_SIZE;
            Page = (FatReservedBytes(&Vcb->Bpb) + StartIndex * BytesPerEntry) / PAGE_SIZE;
 
            Offset = Page * PAGE_SIZE;
 
            //
            //  Prefetch the FAT entries in memory for optimal performance.
            //
 
            PrefetchPages = FatPages - Page;
 
            if (PrefetchPages > FAT_PREFETCH_PAGE_COUNT) {
 
                PrefetchPages = ALIGN_UP_BY(Page, FAT_PREFETCH_PAGE_COUNT) - Page;
            }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
            FatPrefetchPages( IrpContext,
                              Vcb->VirtualVolumeFile,
                              Page,
                              PrefetchPages );
#endif
 
            FatReadVolumeFile( IrpContext,
                               Vcb,
                               Offset,
                               PAGE_SIZE,
                               &Bcb,
                               &pv);
 
            if (FatIndexBitSize == 32) {
 
                FatBuffer = (PUSHORT)((PUCHAR)pv +
                            (FatReservedBytes(&Vcb->Bpb) + StartIndex * BytesPerEntry) %
                                 PAGE_SIZE);
 
                FirstFatEntry = *((PULONG)FatBuffer);
                FirstFatEntry = FirstFatEntry & FAT32_ENTRY_MASK;
 
            } else {
 
                FatBuffer = (PUSHORT)((PUCHAR)pv +
                            FatReservedBytes(&Vcb->Bpb) % PAGE_SIZE) + 2;
 
                FirstFatEntry = *FatBuffer;
            }
 
        }
 
        ClusterSize = 1 << (Vcb->AllocationSupport.LogOfBytesPerCluster);
 
        CurrentRun = (FirstFatEntry == FAT_CLUSTER_AVAILABLE) ?
                     FreeClusters : AllocatedClusters;
 
        StartIndexOfThisRun = StartIndex;
 
        for (FatIndex = StartIndex; FatIndex <= EndIndex; FatIndex++) {
 
            if (FatIndexBitSize == 12) {
 
                FatLookup12BitEntry(FatBuffer, FatIndex, &FatEntry);
 
            } else {
 
                //
                //  If we are setting up the FAT32 windows and have stepped into a new
                //  bucket, finalize this one and move forward.
                //
 
                if (SetupWindows &&
                    FatIndex > StartIndex &&
                    (FatIndex - 2) % EntriesPerWindow == 0) {
 
                    CurrentWindow->LastCluster = FatIndex - 1;
 
                    if (CurrentRun == FreeClusters) {
 
                        //
                        //  We must be counting clusters in order to modify the
                        //  contents of the window.
                        //
 
                        NT_ASSERT( FreeClusterCount );
 
                        ClustersThisRun = FatIndex - StartIndexOfThisRun;
                        CurrentWindow->ClustersFree += ClustersThisRun;
 
                        if (FreeClusterCount) {
                            *FreeClusterCount += ClustersThisRun;
                        }
 
                    } else {
 
                        NT_ASSERT(CurrentRun == AllocatedClusters);
 
                    }
 
                    StartIndexOfThisRun = FatIndex;
                    CurrentRun = UnknownClusters;
 
                    CurrentWindow++;
                    CurrentWindow->ClustersFree = 0;
                    CurrentWindow->FirstCluster = FatIndex;
                }
 
                //
                //  If we just stepped onto a new page, grab a new pointer.
                //
 
                if (((ULONG_PTR)FatBuffer & (PAGE_SIZE - 1)) == 0) {
 
                    FatUnpinBcb( IrpContext, Bcb );
 
                    Page++;
                    Offset += PAGE_SIZE;
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
                    //
                    //  If we have exhausted all the prefetch pages, prefetch the next chunk.
                    //
 
                    if (--PrefetchPages == 0) {
 
                        PrefetchPages = FatPages - Page;
 
                        if (PrefetchPages > FAT_PREFETCH_PAGE_COUNT) {
 
                            PrefetchPages = FAT_PREFETCH_PAGE_COUNT;
                        }
 
                        FatPrefetchPages( IrpContext,
                                          Vcb->VirtualVolumeFile,
                                          Page,
                                          PrefetchPages );
                    }
#endif
 
                    FatReadVolumeFile( IrpContext,
                                       Vcb,
                                       Offset,
                                       PAGE_SIZE,
                                       &Bcb,
                                       &pv );
 
                    FatBuffer = (PUSHORT)pv;
                }
 
                if (FatIndexBitSize == 32) {
 
#ifndef __REACTOS__
#ifdef _MSC_VER
#pragma warning( suppress: 4213 )
#endif
                    FatEntry = *((PULONG)FatBuffer)++;
                    FatEntry = FatEntry & FAT32_ENTRY_MASK;
#else
                    FatEntry = *((PULONG)FatBuffer);
                    FatBuffer += 2; /* PUSHORT FatBuffer */
                    FatEntry = FatEntry & FAT32_ENTRY_MASK;
#endif
 
                } else {
 
                    FatEntry = *FatBuffer;
                    FatBuffer += 1;
                }
            }
 
            if (CurrentRun == UnknownClusters) {
 
                CurrentRun = (FatEntry == FAT_CLUSTER_AVAILABLE) ?
                              FreeClusters : AllocatedClusters;
            }
 
            //
            //  Are we switching from a free run to an allocated run?
            //
 
            if (CurrentRun == FreeClusters &&
                FatEntry != FAT_CLUSTER_AVAILABLE) {
 
                ClustersThisRun = FatIndex - StartIndexOfThisRun;
 
                if (FreeClusterCount) {
 
                    *FreeClusterCount += ClustersThisRun;
                    CurrentWindow->ClustersFree += ClustersThisRun;
                }
 
                if (BitMap) {
 
                    RtlClearBits( BitMap,
                                  StartIndexOfThisRun - StartIndex,
                                  ClustersThisRun );
                }
 
                CurrentRun = AllocatedClusters;
                StartIndexOfThisRun = FatIndex;
            }
 
            //
            //  Are we switching from an allocated run to a free run?
            //
 
            if (CurrentRun == AllocatedClusters &&
                FatEntry == FAT_CLUSTER_AVAILABLE) {
 
                ClustersThisRun = FatIndex - StartIndexOfThisRun;
 
                if (BitMap) {
 
                    RtlSetBits( BitMap,
                                StartIndexOfThisRun - StartIndex,
                                ClustersThisRun );
                }
 
                CurrentRun = FreeClusters;
                StartIndexOfThisRun = FatIndex;
            }
 
            //
            //  If the entry is marked bad, add it to the bad block MCB
            //
 
            if ((SetupWindows || (Vcb->NumberOfWindows == 1)) &&
                (FatInterpretClusterType( Vcb, FatEntry ) == FatClusterBad)) {
 
                //
                //  This cluster is marked bad.
                //  Add it to the BadBlockMcb.
                //
 
                Lbo = FatGetLboFromIndex( Vcb, FatIndex );
                FatAddMcbEntry( Vcb, &Vcb->BadBlockMcb, BadClusterVbo, Lbo, ClusterSize );
                BadClusterVbo += ClusterSize;
            }
        }
 
        //
        //  If we finished the scan, then we know about all the possible bad clusters.
        //
 
        SetFlag( Vcb->VcbState, VCB_STATE_FLAG_BAD_BLOCKS_POPULATED);
 
        //
        //  Now we have to record the final run we encountered
        //
 
        ClustersThisRun = FatIndex - StartIndexOfThisRun;
 
        if (CurrentRun == FreeClusters) {
 
            if (FreeClusterCount) {
 
                *FreeClusterCount += ClustersThisRun;
                CurrentWindow->ClustersFree += ClustersThisRun;
            }
 
            if (BitMap) {
 
                RtlClearBits( BitMap,
                              StartIndexOfThisRun - StartIndex,
                              ClustersThisRun );
            }
 
        } else {
 
            if (BitMap) {
 
                RtlSetBits( BitMap,
                            StartIndexOfThisRun - StartIndex,
                            ClustersThisRun );
            }
        }
 
        //
        //  And finish the last window if we are in setup.
        //
 
        if (SetupWindows) {
 
            CurrentWindow->LastCluster = FatIndex - 1;
        }
 
        //
        //  Now switch the active window if required.  We've succesfully gotten everything
        //  nailed down.
        //
        //  If we were tracking the free cluster count, this means we should update the
        //  window.  This is the case of FAT12/16 initialization.
        //
 
        if (SwitchToWindow) {
 
            if (Vcb->FreeClusterBitMap.Buffer) {
 
                ExFreePool( Vcb->FreeClusterBitMap.Buffer );
            }
 
            RtlInitializeBitMap( &Vcb->FreeClusterBitMap,
                                 NewBitMapBuffer,
                                 EndIndex - StartIndex + 1 );
 
            NewBitMapBuffer = NULL;
 
            Vcb->CurrentWindow = SwitchToWindow;
            Vcb->ClusterHint = (ULONG)-1;
 
            if (FreeClusterCount) {
 
                NT_ASSERT( !SetupWindows );
 
                Vcb->CurrentWindow->ClustersFree = *FreeClusterCount;
            }
        }
 
        //
        //  Make sure plausible things occured ...
        //
 
        if (!SetupWindows && BitMapBuffer == NULL) {
 
            ASSERT_CURRENT_WINDOW_GOOD( Vcb );
        }
 
        NT_ASSERT(Vcb->AllocationSupport.NumberOfFreeClusters <= Vcb->AllocationSupport.NumberOfClusters);
 
    } _SEH2_FINALLY {
 
        //
        //  Unpin the last bcb and drop the temporary bitmap buffer if it exists.
        //
 
        FatUnpinBcb( IrpContext, Bcb);
 
        if (NewBitMapBuffer) {
 
            ExFreePool( NewBitMapBuffer );
        }
    } _SEH2_END;
}

Referenced by FatSetupAllocationSupport().

FatExceptionFilter()

ULONG FatExceptionFilter	(	IN PIRP_CONTEXT	IrpContext,
		IN PEXCEPTION_POINTERS	ExceptionPointer
	)

Definition at line 204 of file fatdata.c.

{
    NTSTATUS ExceptionCode;
 
    ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
    DebugTrace(0, DEBUG_TRACE_UNWIND, "FatExceptionFilter %X\n", ExceptionCode);
    DebugDump("FatExceptionFilter\n", Dbg, NULL );
 
#if DBG
 
    if( FatBreakOnInterestingExceptionStatus != 0 && ExceptionCode == FatBreakOnInterestingExceptionStatus ) {
        DbgBreakPoint();
    }
 
#endif
 
    //
    // If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
    // from the exception record.
    //
 
    if (ExceptionCode == STATUS_IN_PAGE_ERROR) {
        if (ExceptionPointer->ExceptionRecord->NumberParameters >= 3) {
            ExceptionCode = (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
        }
    }
 
    //
    //  If there is not an irp context, we must have had insufficient resources.
    //
 
    if ( !ARGUMENT_PRESENT( IrpContext ) ) {
 
        if (!FsRtlIsNtstatusExpected( ExceptionCode )) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
                         (ULONG_PTR)ExceptionPointer->ContextRecord,
                         (ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
        }
 
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    //
    //  For the purposes of processing this exception, let's mark this
    //  request as being able to wait and disable  write through if we
    //  aren't posting it.
    //
 
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
    if ( (ExceptionCode != STATUS_CANT_WAIT) &&
         (ExceptionCode != STATUS_VERIFY_REQUIRED) ) {
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
    }
 
    if ( IrpContext->ExceptionStatus == 0 ) {
 
        if (FsRtlIsNtstatusExpected( ExceptionCode )) {
 
            IrpContext->ExceptionStatus = ExceptionCode;
 
            return EXCEPTION_EXECUTE_HANDLER;
 
        } else {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
                         (ULONG_PTR)ExceptionPointer->ContextRecord,
                         (ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
        }
 
    } else {
 
        //
        //  We raised this code explicitly ourselves, so it had better be
        //  expected.
        //
 
        NT_ASSERT( IrpContext->ExceptionStatus == ExceptionCode );
        NT_ASSERT( FsRtlIsNtstatusExpected( ExceptionCode ) );
    }
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by _Function_class_(), _Requires_lock_held_(), FatFlushFat(), FatFspDispatch(), FatFspMarkVolumeDirtyWithRecover(), FatMultiAsyncCompletionRoutine(), and FatSingleAsyncCompletionRoutine().

FatExplicitDeviceAccessGranted()

NTSTATUS FatExplicitDeviceAccessGranted	(	IN PIRP_CONTEXT	IrpContext,
		IN PDEVICE_OBJECT	DeviceObject,
		IN PACCESS_STATE	AccessState,
		IN KPROCESSOR_MODE	ProcessorMode
	)

Definition at line 225 of file acchksup.c.

{
    NTSTATUS Status;
 
    PACCESS_TOKEN OriginalAccessToken;
    PACCESS_TOKEN RestrictedAccessToken;
 
    PACCESS_TOKEN *EffectiveToken;
 
    ACCESS_MASK GrantedAccess;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If the access state indicates that specific access other
    //  than traverse was acquired, either Everyone does have such
    //  access or explicit access was granted.  In both cases, we're
    //  happy to let this proceed.
    //
 
    if (AccessState->PreviouslyGrantedAccess & (SPECIFIC_RIGHTS_ALL ^
                                                FILE_TRAVERSE)) {
 
        return STATUS_SUCCESS;
    }
 
    //
    //  If the manage volume privilege is held, this also permits access.
    //
 
    if (FatCheckManageVolumeAccess( IrpContext,
                                    AccessState,
                                    ProcessorMode )) {
 
        return STATUS_SUCCESS;
    }
 
    //
    //  Capture the subject context as a prelude to everything below.
    //
 
    SeLockSubjectContext( &AccessState->SubjectSecurityContext );
 
    //
    //  Convert the token in the subject context into one which does not
    //  acquire access through the Everyone SID.
    //
    //  The logic for deciding which token is effective comes from
    //  SeQuerySubjectContextToken; since there is no natural way
    //  of getting a pointer to it, do it by hand.
    //
 
    if (ARGUMENT_PRESENT( AccessState->SubjectSecurityContext.ClientToken )) {
        EffectiveToken = &AccessState->SubjectSecurityContext.ClientToken;
    } else {
        EffectiveToken = &AccessState->SubjectSecurityContext.PrimaryToken;
    }
 
    OriginalAccessToken = *EffectiveToken;
    Status = FatCreateRestrictEveryoneToken( OriginalAccessToken, &RestrictedAccessToken );
 
    if (!NT_SUCCESS(Status)) {
 
        SeReleaseSubjectContext( &AccessState->SubjectSecurityContext );
        return Status;
    }
 
    //
    //  Now see if the resulting context has access to the device through
    //  its explicitly granted access.  We swap in our restricted token
    //  for this check as the effective client token.
    //
 
    *EffectiveToken = RestrictedAccessToken;
 
#ifdef _MSC_VER
#pragma prefast( suppress: 28175, "we're a file system, this is ok to touch" )
#endif
    SeAccessCheck( DeviceObject->SecurityDescriptor,
                   &AccessState->SubjectSecurityContext,
                   FALSE,
                   AccessState->OriginalDesiredAccess,
                   0,
                   NULL,
                   IoGetFileObjectGenericMapping(),
                   ProcessorMode,
                   &GrantedAccess,
                   &Status );
 
    *EffectiveToken = OriginalAccessToken;
 
    //
    //  Cleanup and return.
    //
 
    SeUnlockSubjectContext( &AccessState->SubjectSecurityContext );
    ObDereferenceObject( RestrictedAccessToken );
 
    return Status;
}

FatExtendString()

VOID FatExtendString	(	_Inout_ PVOID	String,
		_In_ USHORT	DesiredBufferSize,
		_In_ BOOLEAN	FreeOldBuffer,
		__out_opt PBOOLEAN	NeedsFree
	)

FatFatDateToNtTime()

LARGE_INTEGER FatFatDateToNtTime	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ FAT_DATE	FatDate
	)

Definition at line 171 of file timesup.c.

{
    TIME_FIELDS TimeFields;
    LARGE_INTEGER Time;
 
    PAGED_CODE();
 
    //
    //  Pack the input time/date into a time field record
    //
 
    TimeFields.Year         = (USHORT)(FatDate.Year + 1980);
    TimeFields.Month        = (USHORT)(FatDate.Month);
    TimeFields.Day          = (USHORT)(FatDate.Day);
    TimeFields.Hour         = (USHORT)0;
    TimeFields.Minute       = (USHORT)0;
    TimeFields.Second       = (USHORT)0;
    TimeFields.Milliseconds = (USHORT)0;
 
    //
    //  Convert the time field record to Nt LARGE_INTEGER, and set it to zero
    //  if we were given a bogus time.
    //
 
    if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
 
        Time.LowPart = 0;
        Time.HighPart = 0;
 
    } else {
 
        ExLocalTimeToSystemTime( &Time, &Time );
    }
 
    return Time;
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by FatCreateDcb(), FatCreateFcb(), FatGetDirTimes(), and FatSetRenameInfo().

FatFatTimeToNtTime()

LARGE_INTEGER FatFatTimeToNtTime	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ FAT_TIME_STAMP	FatTime,
		_In_ UCHAR	TenMilliSeconds
	)

Definition at line 233 of file timesup.c.

{
    TIME_FIELDS TimeFields;
    LARGE_INTEGER Time;
 
    PAGED_CODE();
 
    //
    //  Pack the input time/date into a time field record
    //
 
    TimeFields.Year         = (USHORT)(FatTime.Date.Year + 1980);
    TimeFields.Month        = (USHORT)(FatTime.Date.Month);
    TimeFields.Day          = (USHORT)(FatTime.Date.Day);
    TimeFields.Hour         = (USHORT)(FatTime.Time.Hour);
    TimeFields.Minute       = (USHORT)(FatTime.Time.Minute);
    TimeFields.Second       = (USHORT)(FatTime.Time.DoubleSeconds * 2);
 
    if (TenMilliSeconds != 0) {
 
        TimeFields.Second      += (USHORT)(TenMilliSeconds / 100);
        TimeFields.Milliseconds = (USHORT)((TenMilliSeconds % 100) * 10);
 
    } else {
 
        TimeFields.Milliseconds = (USHORT)0;
    }
 
    //
    //  If the second value is greater than 59 then we truncate it to 0.
    //  Note that this can't happen with a proper FAT timestamp.
    //
 
    if (TimeFields.Second > 59) {
 
        TimeFields.Second = 0;
    }
 
    //
    //  Convert the time field record to Nt LARGE_INTEGER, and set it to zero
    //  if we were given a bogus time.
    //
 
    if (!RtlTimeFieldsToTime( &TimeFields, &Time )) {
 
        Time.LowPart = 0;
        Time.HighPart = 0;
 
    } else {
 
        ExLocalTimeToSystemTime( &Time, &Time );
    }
 
    return Time;
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by FatCreateDcb(), FatCreateFcb(), FatGetDirTimes(), and FatSetRenameInfo().

FatFindFcb()

PFCB FatFindFcb	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PRTL_SPLAY_LINKS *	RootNode,
		IN PSTRING	Name,
		OUT PBOOLEAN FileNameDos	OPTIONAL
	)

Definition at line 306 of file splaysup.c.

{
    COMPARISON Comparison;
    PFILE_NAME_NODE Node;
    PRTL_SPLAY_LINKS Links;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    Links = *RootNode;
 
    while (Links != NULL) {
 
        Node = CONTAINING_RECORD(Links, FILE_NAME_NODE, Links);
 
        //
        //  Compare the prefix in the tree with the full name
        //
 
        Comparison = CompareNames(&Node->Name.Oem, Name);
 
        //
        //  See if they don't match
        //
 
        if (Comparison == IsGreaterThan) {
 
            //
            //  The prefix is greater than the full name
            //  so we go down the left child
            //
 
            Links = RtlLeftChild(Links);
 
            //
            //  And continue searching down this tree
            //
 
        } else if (Comparison == IsLessThan) {
 
            //
            //  The prefix is less than the full name
            //  so we go down the right child
            //
 
            Links = RtlRightChild(Links);
 
            //
            //  And continue searching down this tree
            //
 
        } else {
 
            //
            //  We found it.
            //
            //  Splay the tree and save the new root.
            //
 
            *RootNode = RtlSplay(Links);
 
            //
            //  Tell the caller what kind of name we hit
            //
 
            if (FileNameDos) {
 
                *FileNameDos = Node->FileNameDos;
            }
 
            return Node->Fcb;
        }
    }
 
    //
    //  We didn't find the Fcb.
    //
 
    return NULL;
}

Referenced by FatConstructNamesInFcb().

FatFlushDirentForFile()

VOID FatFlushDirentForFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb
	)

Definition at line 1264 of file flush.c.

{
    LARGE_INTEGER FileOffset;
    IO_STATUS_BLOCK Iosb;
 
    PAGED_CODE();
 
    FileOffset.QuadPart = Fcb->DirentOffsetWithinDirectory;
 
    CcFlushCache( &Fcb->ParentDcb->NonPaged->SectionObjectPointers,
                  &FileOffset,
                  sizeof( DIRENT ),
                  &Iosb );
 
    if (NT_SUCCESS(Iosb.Status)) {
        Iosb.Status = FatHijackIrpAndFlushDevice( IrpContext,
                                                  IrpContext->OriginatingIrp,
                                                  Fcb->Vcb->TargetDeviceObject );
    }
 
    if (!NT_SUCCESS(Iosb.Status)) {
        FatNormalizeAndRaiseStatus(IrpContext, Iosb.Status);
    }
}

FatFlushFat()

NTSTATUS FatFlushFat	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 801 of file flush.c.

{
    PBCB Bcb;
    PVOID DontCare;
    IO_STATUS_BLOCK Iosb;
    LARGE_INTEGER Offset;
 
    NTSTATUS ReturnStatus = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    //
    //  If this volume is write protected, no need to flush.
    //
 
    if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
 
        return STATUS_SUCCESS;
    }
 
    //
    //  Make sure the Vcb is OK.
    //
 
    _SEH2_TRY {
 
        FatVerifyVcb( IrpContext, Vcb );
 
    } _SEH2_EXCEPT( FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
              EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
 
        FatResetExceptionState( IrpContext );
    } _SEH2_END;
 
    if (Vcb->VcbCondition != VcbGood) {
 
        return STATUS_FILE_INVALID;
    }
 
    //
    //  The only way we have to correctly synchronize things is to
    //  repin stuff, and then unpin repin it.
    //
    //  With NT 5.0, we can use some new cache manager support to make
    //  this a lot more efficient (important for FAT32).  Since we're
    //  only worried about ranges that are dirty - and since we're a
    //  modified-no-write stream - we can assume that if there is no
    //  BCB, there is no work to do in the range. I.e., the lazy writer
    //  beat us to it.
    //
    //  This is much better than reading the entire FAT in and trying
    //  to punch it out (see the test in the write path to blow
    //  off writes that don't correspond to dirty ranges of the FAT).
    //  For FAT32, this would be a *lot* of reading.
    //
 
    if (Vcb->AllocationSupport.FatIndexBitSize != 12) {
 
        //
        //  Walk through the Fat, one page at a time.
        //
 
        ULONG NumberOfPages;
        ULONG Page;
 
        NumberOfPages = ( FatReservedBytes(&Vcb->Bpb) +
                          FatBytesPerFat(&Vcb->Bpb) +
                          (PAGE_SIZE - 1) ) / PAGE_SIZE;
 
 
        for ( Page = 0, Offset.QuadPart = 0;
              Page < NumberOfPages;
              Page++, Offset.LowPart += PAGE_SIZE ) {
 
            _SEH2_TRY {
 
                if (CcPinRead( Vcb->VirtualVolumeFile,
                               &Offset,
                               PAGE_SIZE,
                               PIN_WAIT | PIN_IF_BCB,
                               &Bcb,
                               &DontCare )) {
 
                    CcSetDirtyPinnedData( Bcb, NULL );
                    CcRepinBcb( Bcb );
                    CcUnpinData( Bcb );
                    CcUnpinRepinnedBcb( Bcb, TRUE, &Iosb );
 
                    if (!NT_SUCCESS(Iosb.Status)) {
 
                        ReturnStatus = Iosb.Status;
                    }
                }
 
            } _SEH2_EXCEPT(FatExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
                ReturnStatus = IrpContext->ExceptionStatus;
                continue;
            } _SEH2_END;
        }
 
    } else {
 
        //
        //  We read in the entire fat in the 12 bit case.
        //
 
        Offset.QuadPart = FatReservedBytes( &Vcb->Bpb );
 
        _SEH2_TRY {
 
            if (CcPinRead( Vcb->VirtualVolumeFile,
                           &Offset,
                           FatBytesPerFat( &Vcb->Bpb ),
                           PIN_WAIT | PIN_IF_BCB,
                           &Bcb,
                           &DontCare )) {
 
                CcSetDirtyPinnedData( Bcb, NULL );
                CcRepinBcb( Bcb );
                CcUnpinData( Bcb );
                CcUnpinRepinnedBcb( Bcb, TRUE, &Iosb );
 
                if (!NT_SUCCESS(Iosb.Status)) {
 
                    ReturnStatus = Iosb.Status;
                }
            }
 
        } _SEH2_EXCEPT(FatExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
            ReturnStatus = IrpContext->ExceptionStatus;
        } _SEH2_END;
    }
 
    return ReturnStatus;
}

Referenced by _Requires_lock_held_().

FatFlushFatEntries()

VOID FatFlushFatEntries	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN ULONG	Cluster,
		IN ULONG	Count
	)

Definition at line 1191 of file flush.c.

{
    ULONG ByteCount;
    LARGE_INTEGER FileOffset;
 
    IO_STATUS_BLOCK Iosb;
 
    PAGED_CODE();
 
    FileOffset.HighPart = 0;
    FileOffset.LowPart = FatReservedBytes( &Vcb->Bpb );
 
    if (Vcb->AllocationSupport.FatIndexBitSize == 12) {
 
        FileOffset.LowPart += Cluster * 3 / 2;
        ByteCount = (Count * 3 / 2) + 1;
 
    } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) {
 
        FileOffset.LowPart += Cluster * sizeof(ULONG);
        ByteCount = Count * sizeof(ULONG);
 
    } else {
 
        FileOffset.LowPart += Cluster * sizeof( USHORT );
        ByteCount = Count * sizeof( USHORT );
 
    }
 
    CcFlushCache( &Vcb->SectionObjectPointers,
                  &FileOffset,
                  ByteCount,
                  &Iosb );
 
    if (NT_SUCCESS(Iosb.Status)) {
        Iosb.Status = FatHijackIrpAndFlushDevice( IrpContext,
                                                  IrpContext->OriginatingIrp,
                                                  Vcb->TargetDeviceObject );
    }
 
    if (!NT_SUCCESS(Iosb.Status)) {
        FatNormalizeAndRaiseStatus(IrpContext, Iosb.Status);
    }
}

FatFreeStringBuffer()

VOID FatFreeStringBuffer

(

_Inout_ PVOID

String

)

Definition at line 3784 of file strucsup.c.

{
    ULONG_PTR High, Low;
    PSTRING LocalString = String;
 
    PAGED_CODE();
 
    if (NULL != LocalString->Buffer)  {
 
        IoGetStackLimits( &Low, &High );
 
        if (((ULONG_PTR)(LocalString->Buffer) < Low) ||
            ((ULONG_PTR)(LocalString->Buffer) > High))  {
 
            ExFreePool( LocalString->Buffer);
        }
 
        LocalString->Buffer = NULL;
    }
 
    LocalString->MaximumLength = LocalString->Length = 0;
}

Referenced by FatEnsureStringBufferEnough().

FatFsdPostRequest()

NTSTATUS FatFsdPostRequest	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 229 of file workque.c.

{
    PAGED_CODE();
 
    NT_ASSERT( ARGUMENT_PRESENT(Irp) );
    NT_ASSERT( IrpContext->OriginatingIrp == Irp );
 
    FatPrePostIrp( IrpContext, Irp );
 
    FatAddToWorkque( IrpContext, Irp );
 
    //
    //  And return to our caller
    //
 
    return STATUS_PENDING;
}

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), FatMultiAsyncCompletionRoutine(), and FatSingleAsyncCompletionRoutine().

FatFspDispatch()

VOID NTAPI FatFspDispatch

(

_In_ PVOID

Context

)

Definition at line 41 of file fspdisp.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
 
    PIRP Irp;
    PIRP_CONTEXT IrpContext;
    PIO_STACK_LOCATION IrpSp;
    BOOLEAN VcbDeleted;
    BOOLEAN  ExceptionCompletedIrp = FALSE;
 
    PVOLUME_DEVICE_OBJECT VolDo;
 
    UCHAR MajorFunction = 0;
 
    PAGED_CODE();
 
    IrpContext = (PIRP_CONTEXT)Context;
 
    Irp = IrpContext->OriginatingIrp;
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Now because we are the Fsp we will force the IrpContext to
    //  indicate true on Wait.
    //
 
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
 
    //
    //  If this request has an associated volume device object, remember it.
    //
 
    if ( IrpSp->FileObject != NULL ) {
 
        VolDo = CONTAINING_RECORD( IrpSp->DeviceObject,
                                   VOLUME_DEVICE_OBJECT,
                                   DeviceObject );
    } else {
 
        VolDo = NULL;
    }
 
    //
    //  Now case on the function code.  For each major function code,
    //  either call the appropriate FSP routine or case on the minor
    //  function and then call the FSP routine.  The FSP routine that
    //  we call is responsible for completing the IRP, and not us.
    //  That way the routine can complete the IRP and then continue
    //  post processing as required.  For example, a read can be
    //  satisfied right away and then read can be done.
    //
    //  We'll do all of the work within an exception handler that
    //  will be invoked if ever some underlying operation gets into
    //  trouble (e.g., if FatReadSectorsSync has trouble).
    //
 
    while ( TRUE ) {
 
        ExceptionCompletedIrp = FALSE;
 
        DebugTrace(0, Dbg, "FatFspDispatch: Irp = %p\n", Irp);
 
        //
        //  If this Irp was top level, note it in our thread local storage.
        //
 
        FsRtlEnterFileSystem();
 
        if ( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) ) {
 
            IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );
 
        } else {
 
            IoSetTopLevelIrp( Irp );
        }
 
        MajorFunction = IrpContext->MajorFunction;
 
        _SEH2_TRY {
 
            switch ( MajorFunction ) {
 
                //
                //  For Create Operation,
                //
 
                case IRP_MJ_CREATE:
 
                    Status = FatCommonCreate( IrpContext, Irp );
                    break;
 
                //
                //  For close operations.  We do a little kludge here in case
                //  this close causes a volume to go away.  It will NULL the
                //  VolDo local variable so that we will not try to look at
                //  the overflow queue.
                //
 
                case IRP_MJ_CLOSE:
 
                {
                    PVCB Vcb;
                    PFCB Fcb;
                    PCCB Ccb;
                    TYPE_OF_OPEN TypeOfOpen;
 
                    //
                    //  Extract and decode the file object
                    //
 
                    TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
 
                    //
                    //  Do the close.  We have a slightly different format
                    //  for this call because of the async closes.
                    //
 
                    Status = FatCommonClose( Vcb,
                                             Fcb,
                                             Ccb,
                                             TypeOfOpen,
                                             TRUE,
                                             TRUE,
                                             &VcbDeleted );
 
                    //
                    //  If the VCB was deleted, do not try to access it later.
                    //
 
                    if (VcbDeleted) {
 
                        VolDo = NULL;
                    }
 
                    NT_ASSERT(Status == STATUS_SUCCESS);
 
                    FatCompleteRequest( IrpContext, Irp, Status );
 
                    break;
                }
 
                //
                //  For read operations
                //
 
                case IRP_MJ_READ:
 
                    (VOID) FatCommonRead( IrpContext, Irp );
                    break;
 
                //
                //  For write operations,
                //
 
                case IRP_MJ_WRITE:
 
                    (VOID) FatCommonWrite( IrpContext, Irp );
                    break;
 
                //
                //  For Query Information operations,
                //
 
                case IRP_MJ_QUERY_INFORMATION:
 
                    (VOID) FatCommonQueryInformation( IrpContext, Irp );
                    break;
 
                //
                //  For Set Information operations,
                //
 
                case IRP_MJ_SET_INFORMATION:
 
                    (VOID) FatCommonSetInformation( IrpContext, Irp );
                    break;
 
                //
                //  For Query EA operations,
                //
 
                case IRP_MJ_QUERY_EA:
 
                    (VOID) FatCommonQueryEa( IrpContext, Irp );
                    break;
 
                //
                //  For Set EA operations,
                //
 
                case IRP_MJ_SET_EA:
 
                    (VOID) FatCommonSetEa( IrpContext, Irp );
                    break;
 
                //
                //  For Flush buffers operations,
                //
 
                case IRP_MJ_FLUSH_BUFFERS:
 
                    (VOID) FatCommonFlushBuffers( IrpContext, Irp );
                    break;
 
                //
                //  For Query Volume Information operations,
                //
 
                case IRP_MJ_QUERY_VOLUME_INFORMATION:
 
                    (VOID) FatCommonQueryVolumeInfo( IrpContext, Irp );
                    break;
 
                //
                //  For Set Volume Information operations,
                //
 
                case IRP_MJ_SET_VOLUME_INFORMATION:
 
                    (VOID) FatCommonSetVolumeInfo( IrpContext, Irp );
                    break;
 
                //
                //  For File Cleanup operations,
                //
 
                case IRP_MJ_CLEANUP:
 
                    (VOID) FatCommonCleanup( IrpContext, Irp );
                    break;
 
                //
                //  For Directory Control operations,
                //
 
                case IRP_MJ_DIRECTORY_CONTROL:
 
                    (VOID) FatCommonDirectoryControl( IrpContext, Irp );
                    break;
 
                //
                //  For File System Control operations,
                //
 
                case IRP_MJ_FILE_SYSTEM_CONTROL:
 
                    (VOID) FatCommonFileSystemControl( IrpContext, Irp );
                    break;
 
                //
                //  For Lock Control operations,
                //
 
                case IRP_MJ_LOCK_CONTROL:
 
                    (VOID) FatCommonLockControl( IrpContext, Irp );
                    break;
 
                //
                //  For Device Control operations,
                //
 
                case IRP_MJ_DEVICE_CONTROL:
 
                    (VOID) FatCommonDeviceControl( IrpContext, Irp );
                    break;
 
                //
                //  For the Shutdown operation,
                //
 
                case IRP_MJ_SHUTDOWN:
 
                    (VOID) FatCommonShutdown( IrpContext, Irp );
                    break;
 
                //
                //  For plug and play operations.
                //
 
                case IRP_MJ_PNP:
 
                    //
                    //  I don't believe this should ever occur, but allow for the unexpected.
                    //
 
                    (VOID) FatCommonPnp( IrpContext, Irp );
                    break;
 
                //
                //  For any other major operations, return an invalid
                //  request.
                //
 
                default:
 
                    FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
                    break;
 
            }
 
        } _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            //
            //  We had some trouble trying to perform the requested
            //  operation, so we'll abort the I/O request with
            //  the error status that we get back from the
            //  execption code.
            //
 
            (VOID) FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
            ExceptionCompletedIrp = TRUE;
        } _SEH2_END;
 
        IoSetTopLevelIrp( NULL );
 
        FsRtlExitFileSystem();
 
 
        if (MajorFunction == IRP_MJ_CREATE && !ExceptionCompletedIrp && Status != STATUS_PENDING) {
 
            //
            // Creates are completed here. IrpContext is also freed here.
            //
 
            FatCompleteRequest( IrpContext, Irp, Status );
        }
 
        //
        //  If there are any entries on this volume's overflow queue, service
        //  them.
        //
 
        if ( VolDo != NULL ) {
 
            PVOID Entry;
 
            //
            //  We have a volume device object so see if there is any work
            //  left to do in its overflow queue.
            //
 
            Entry = FatRemoveOverflowEntry( VolDo );
 
            //
            //  There wasn't an entry, break out of the loop and return to
            //  the Ex Worker thread.
            //
 
            if ( Entry == NULL ) {
 
                break;
            }
 
            //
            //  Extract the IrpContext, Irp, and IrpSp, and loop.
            //
 
            IrpContext = CONTAINING_RECORD( Entry,
                                            IRP_CONTEXT,
                                            WorkQueueItem.List );
 
            SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_IN_FSP);
 
            Irp = IrpContext->OriginatingIrp;
 
            IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
            continue;
 
        } else {
 
            break;
        }
    }
 
    return;
}

FatFspMarkVolumeDirtyWithRecover()

VOID NTAPI FatFspMarkVolumeDirtyWithRecover

(

PVOID

Parameter

)

Definition at line 1098 of file verfysup.c.

{
    PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;
    PVCB Vcb;
    IRP_CONTEXT IrpContext;
    PIRP Irp;
 
    DebugTrace(+1, Dbg, "FatFspMarkVolumeDirtyWithRecover\n", 0);
 
    Packet = (PCLEAN_AND_DIRTY_VOLUME_PACKET)Parameter;
 
    Vcb = Packet->Vcb;
    Irp = Packet->Irp;
 
    //
    //  Dummy up the IrpContext so we can call our worker routines
    //
 
    RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT));
 
    SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
    IrpContext.OriginatingIrp = Irp;
 
    //
    //  Make us appear as a top level FSP request so that we will
    //  receive any errors from the operation.
    //
 
    IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );
 
    //
    //  Try to write out the dirty bit.  If something goes wrong, we
    //  tried.
    //
 
    _SEH2_TRY {
 
        SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
 
        FatMarkVolume( &IrpContext, Vcb, VolumeDirtyWithSurfaceTest );
 
    } _SEH2_EXCEPT(FatExceptionFilter( &IrpContext, _SEH2_GetExceptionInformation() )) {
 
        NOTHING;
    } _SEH2_END;
 
    IoSetTopLevelIrp( NULL );
 
    //
    //  Now complete the originating Irp or set the synchronous event.
    //
 
    if (Packet->Event) {
        KeSetEvent( Packet->Event, 0, FALSE );
    } else {
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
 
    DebugTrace(-1, Dbg, "FatFspMarkVolumeDirtyWithRecover -> VOID\n", 0);
}

FatGetCurrentFatTime()

FAT_TIME_STAMP FatGetCurrentFatTime

(

_In_ PIRP_CONTEXT

IrpContext

)

Definition at line 317 of file timesup.c.

{
    LARGE_INTEGER Time;
    TIME_FIELDS TimeFields;
    FAT_TIME_STAMP FatTime;
 
    PAGED_CODE();
 
    //
    //  Get the current system time, and map it into a time field record.
    //
 
    KeQuerySystemTime( &Time );
 
    ExSystemTimeToLocalTime( &Time, &Time );
 
    //
    //  Always add almost two seconds to round up to the nearest double second.
    //
 
    Time.QuadPart = Time.QuadPart + AlmostTwoSeconds;
 
    (VOID)RtlTimeToTimeFields( &Time, &TimeFields );
 
    //
    //  Now simply copy over the information
    //
 
    FatTime.Time.DoubleSeconds = (USHORT)(TimeFields.Second / 2);
    FatTime.Time.Minute        = (USHORT)(TimeFields.Minute);
    FatTime.Time.Hour          = (USHORT)(TimeFields.Hour);
 
    FatTime.Date.Year          = (USHORT)(TimeFields.Year - 1980);
    FatTime.Date.Month         = (USHORT)(TimeFields.Month);
    FatTime.Date.Day           = (USHORT)(TimeFields.Day);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return FatTime;
}

Referenced by FatConstructLabelDirent().

FatGetNextFcbBottomUp()

PFCB FatGetNextFcbBottomUp	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN PFCB	TerminationFcb
	)

Definition at line 2525 of file strucsup.c.

{
    PFCB NextFcb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    NT_ASSERT( FatVcbAcquiredExclusive( IrpContext, TerminationFcb->Vcb ) ||
            FlagOn( TerminationFcb->Vcb->VcbState, VCB_STATE_FLAG_LOCKED ) );
 
    //
    //  Do we need to begin the enumeration?
    //
 
    if (Fcb != NULL) {
 
        //
        //  Did we complete?
        //
 
        if (Fcb == TerminationFcb) {
 
            return NULL;
        }
 
        //
        //  Do we have a sibling to return?
        //
 
        NextFcb = FatGetNextSibling( Fcb );
 
        //
        //  If not, return our parent.  We are done with this branch.
        //
 
        if (NextFcb == NULL) {
 
            return Fcb->ParentDcb;
        }
 
    } else {
 
        NextFcb = TerminationFcb;
    }
 
    //
    //  Decend to its furthest child (if it exists) and return it.
    //
 
    for (;
         NodeType( NextFcb ) != FAT_NTC_FCB && FatGetFirstChild( NextFcb ) != NULL;
         NextFcb = FatGetFirstChild( NextFcb )) {
    }
 
    return NextFcb;
}

Referenced by FatDeleteVcb(), and FatSetRenameInfo().

FatGetNextFcbTopDown()

PFCB FatGetNextFcbTopDown	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN PFCB	TerminationFcb
	)

Definition at line 2627 of file strucsup.c.

{
    PFCB Sibling;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    NT_ASSERT( FatVcbAcquiredExclusive( IrpContext, Fcb->Vcb ) ||
            FlagOn( Fcb->Vcb->VcbState, VCB_STATE_FLAG_LOCKED ) );
 
    //
    //  If this was a directory (ie. not a file), get the child.  If
    //  there aren't any children and this is our termination Fcb,
    //  return NULL.
    //
 
    if ( ((NodeType(Fcb) == FAT_NTC_DCB) ||
          (NodeType(Fcb) == FAT_NTC_ROOT_DCB)) &&
         !IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) ) {
 
        return FatGetFirstChild( Fcb );
    }
 
    //
    //  Were we only meant to do one iteration?
    //
 
    if ( Fcb == TerminationFcb ) {
 
        return NULL;
    }
 
    Sibling = FatGetNextSibling(Fcb);
 
    while (TRUE) {
 
        //
        //  Do we still have an "older" sibling in this directory who is
        //  not the termination Fcb?
        //
 
        if ( Sibling != NULL ) {
 
            return (Sibling != TerminationFcb) ? Sibling : NULL;
        }
 
        //
        //  OK, let's move on to out parent and see if he is the termination
        //  node or has any older siblings.
        //
 
        if ( Fcb->ParentDcb == TerminationFcb ) {
 
            return NULL;
        }
 
        Fcb = Fcb->ParentDcb;
 
        Sibling = FatGetNextSibling(Fcb);
    }
}

Referenced by _Requires_lock_held_(), and FatIsHandleCountZero().

FatGetNextMcbEntry()

BOOLEAN FatGetNextMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN ULONG	RunIndex,
		OUT PVBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG	ByteCount
	)

Definition at line 541 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiVbo;
    LONGLONG LiLbo;
    LONGLONG LiSectorCount;
 
    PAGED_CODE();
 
    LiVbo = LiLbo = 0;
 
    Results = FsRtlGetNextLargeMcbEntry( Mcb,
                                         RunIndex,
                                         &LiVbo,
                                         &LiLbo,
                                         &LiSectorCount );
 
    if (Results) {
 
        *Vbo = ((VBO) LiVbo) << MCB_SCALE_LOG2;
 
        if (((ULONG) LiLbo) != -1) {
 
            *Lbo = ((LBO) LiLbo) << MCB_SCALE_LOG2;
 
        } else {
 
            *Lbo = 0;
        }
 
        *ByteCount = ((ULONG) LiSectorCount) << MCB_SCALE_LOG2;
 
        if ((*ByteCount == 0) && (LiSectorCount != 0)) {
 
            //
            //  If 'ByteCount' overflows, then this is likely a file of
            //  max supported size (2^32 - 1) in one contiguous run.
            //
 
            NT_ASSERT( RunIndex == 0 );
 
            *ByteCount = 0xFFFFFFFF;
        }
    }
 
    return Results;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), and FatPagingFileIo().

FatHijackIrpAndFlushDevice()

NTSTATUS FatHijackIrpAndFlushDevice	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp,
		IN PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 1101 of file flush.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIO_STACK_LOCATION NextIrpSp;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Get the next stack location, and copy over the stack location
    //
 
    IoCopyCurrentIrpStackLocationToNext(Irp);
 
    NextIrpSp = IoGetNextIrpStackLocation( Irp );
    NextIrpSp->MajorFunction = IRP_MJ_FLUSH_BUFFERS;
    NextIrpSp->MinorFunction = 0;
 
    //
    //  Set up the completion routine
    //
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    IoSetCompletionRoutine( Irp,
                            FatHijackCompletionRoutine,
                            &Event,
                            TRUE,
                            TRUE,
                            TRUE );
 
    //
    //  Send the request.
    //
 
    Status = IoCallDriver( TargetDeviceObject, Irp );
 
    if (Status == STATUS_PENDING) {
 
        KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
 
        Status = Irp->IoStatus.Status;
    }
 
    //
    //  If the driver doesn't support flushes, return SUCCESS.
    //
 
    if (Status == STATUS_INVALID_DEVICE_REQUEST) {
        Status = STATUS_SUCCESS;
    }
 
    Irp->IoStatus.Status = 0;
    Irp->IoStatus.Information = 0;
 
    return Status;
}

Referenced by _Requires_lock_held_(), FatFlushDirentForFile(), and FatFlushFatEntries().

FatInitializeCacheMap()

VOID FatInitializeCacheMap	(	_In_ PFILE_OBJECT	FileObject,
		_In_ PCC_FILE_SIZES	FileSizes,
		_In_ BOOLEAN	PinAccess,
		_In_ PCACHE_MANAGER_CALLBACKS	Callbacks,
		_In_ PVOID	LazyWriteContext
	)

Definition at line 62 of file cachesup.c.

{
    //
    //  Initialize caching
    //
 
    CcInitializeCacheMap( FileObject,
                          FileSizes,
                          PinAccess,
                          Callbacks,
                          LazyWriteContext );
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    //
    //  Enable Disk IO Accounting for this file
    //
 
    if (FatDiskAccountingEnabled) {
 
        CcSetAdditionalCacheAttributesEx( FileObject, CC_ENABLE_DISK_IO_ACCOUNTING );
    }
#endif
}

Referenced by _Requires_lock_held_(), FatOpenEaFile(), and FatSetupAllocationSupport().

FatInsertName()

VOID FatInsertName	(	IN PIRP_CONTEXT	IrpContext,
		IN PRTL_SPLAY_LINKS *	RootNode,
		IN PFILE_NAME_NODE	Name
	)

Definition at line 39 of file splaysup.c.

{
    COMPARISON Comparison;
    PFILE_NAME_NODE Node;
 
    PAGED_CODE();
 
    RtlInitializeSplayLinks(&Name->Links);
 
Restart:
 
    //
    //  If we are the first entry in the tree, just become the root.
    //
 
    if (*RootNode == NULL) {
 
        *RootNode = &Name->Links;
 
        return;
    }
 
    Node = CONTAINING_RECORD( *RootNode, FILE_NAME_NODE, Links );
 
    while (TRUE) {
 
        //
        //  Compare the prefix in the tree with the prefix we want
        //  to insert.  Note that Oem here doesn't mean anything.
        //
 
        Comparison = CompareNames(&Node->Name.Oem, &Name->Name.Oem);
 
        //
        //  We should never find the name in the table already.
        //
 
        if (Comparison == IsEqual) {
 
            //
            //  Almost. If the removable media was taken to another machine and
            //  back, and we have something like:
            //
            //  Old: abcdef~1  /  abcdefxyz
            //  New: abcdef~1  /  abcdefxyzxyz
            //
            //  but a handle was kept open to abcdefxyz so we couldn't purge
            //  away the Fcb in the verify path ... opening abcdefxyzxyz will
            //  try to insert a duplicate shortname. Bang!
            //
            //  Invalidate it and the horse it came in on.  This new one wins.
            //  The old one is gone.  Only if the old one is in normal state
            //  do we really have a problem.
            //
 
            if (Node->Fcb->FcbState == FcbGood) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
                FatBugCheck( (ULONG_PTR)*RootNode, (ULONG_PTR)Name, (ULONG_PTR)Node );
            }
 
            //
            //  Note, once we zap the prefix links we need to restart our walk
            //  of the tree. Note that we aren't properly synchronized to
            //  recursively mark bad.
            //
 
            FatMarkFcbCondition( IrpContext, Node->Fcb, FcbBad, FALSE );
            FatRemoveNames( IrpContext, Node->Fcb );
 
            goto Restart;
        }
 
        //
        //  If the tree prefix is greater than the new prefix then
        //  we go down the left subtree
        //
 
        if (Comparison == IsGreaterThan) {
 
            //
            //  We want to go down the left subtree, first check to see
            //  if we have a left subtree
            //
 
            if (RtlLeftChild(&Node->Links) == NULL) {
 
                //
                //  there isn't a left child so we insert ourselves as the
                //  new left child
                //
 
                RtlInsertAsLeftChild(&Node->Links, &Name->Links);
 
                //
                //  and exit the while loop
                //
 
                break;
 
            } else {
 
                //
                //  there is a left child so simply go down that path, and
                //  go back to the top of the loop
                //
 
                Node = CONTAINING_RECORD( RtlLeftChild(&Node->Links),
                                          FILE_NAME_NODE,
                                          Links );
            }
 
        } else {
 
            //
            //  The tree prefix is either less than or a proper prefix
            //  of the new string.  We treat both cases a less than when
            //  we do insert.  So we want to go down the right subtree,
            //  first check to see if we have a right subtree
            //
 
            if (RtlRightChild(&Node->Links) == NULL) {
 
                //
                //  These isn't a right child so we insert ourselves as the
                //  new right child
                //
 
                RtlInsertAsRightChild(&Node->Links, &Name->Links);
 
                //
                //  and exit the while loop
                //
 
                break;
 
            } else {
 
                //
                //  there is a right child so simply go down that path, and
                //  go back to the top of the loop
                //
 
                Node = CONTAINING_RECORD( RtlRightChild(&Node->Links),
                                          FILE_NAME_NODE,
                                          Links );
            }
 
        }
    }
 
    return;
}

Referenced by FatConstructNamesInFcb().

FatInterpretClusterType()

CLUSTER_TYPE FatInterpretClusterType	(	IN PVCB	Vcb,
		IN FAT_ENTRY	Entry
	)

Definition at line 3473 of file allocsup.c.

{
    DebugTrace(+1, Dbg, "InterpretClusterType\n", 0);
    DebugTrace( 0, Dbg, "  Vcb   = %p\n", Vcb);
    DebugTrace( 0, Dbg, "  Entry = %8lx\n", Entry);
 
    PAGED_CODE();
 
    switch(Vcb->AllocationSupport.FatIndexBitSize ) {
    case 32:
        Entry &= FAT32_ENTRY_MASK;
        break;
 
    case 12:
        NT_ASSERT( Entry <= 0xfff );
        if (Entry >= 0x0ff0) {
            Entry |= 0x0FFFF000;
        }
        break;
 
    default:
    case 16:
        NT_ASSERT( Entry <= 0xffff );
        if (Entry >= 0x0fff0) {
            Entry |= 0x0FFF0000;
        }
        break;
    }
 
    if (Entry == FAT_CLUSTER_AVAILABLE) {
 
        DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterAvailable\n", 0);
 
        return FatClusterAvailable;
 
    } else if (Entry < FAT_CLUSTER_RESERVED) {
 
        DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterNext\n", 0);
 
        return FatClusterNext;
 
    } else if (Entry < FAT_CLUSTER_BAD) {
 
        DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterReserved\n", 0);
 
        return FatClusterReserved;
 
    } else if (Entry == FAT_CLUSTER_BAD) {
 
        DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterBad\n", 0);
 
        return FatClusterBad;
 
    } else {
 
        DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterLast\n", 0);
 
        return FatClusterLast;
    }
}

Referenced by _Requires_lock_held_(), and FatExamineFatEntries().

FatIsBootSectorFat()

BOOLEAN FatIsBootSectorFat

(

IN PPACKED_BOOT_SECTOR

BootSector

)

Definition at line 2522 of file fsctrl.c.

{
    BOOLEAN Result;
    BIOS_PARAMETER_BLOCK Bpb = {0};
 
    DebugTrace(+1, Dbg, "FatIsBootSectorFat, BootSector = %p\n", BootSector);
 
    //
    //  The result is true unless we decide that it should be false
    //
 
    Result = TRUE;
 
    //
    //  Unpack the bios and then test everything
    //
 
    FatUnpackBios( &Bpb, &BootSector->PackedBpb );
    if (Bpb.Sectors != 0) { Bpb.LargeSectors = 0; }
 
    if ((BootSector->Jump[0] != 0xe9) &&
        (BootSector->Jump[0] != 0xeb) &&
        (BootSector->Jump[0] != 0x49)) {
 
        Result = FALSE;
 
    //
    //  Enforce some sanity on the sector size (easy check)
    //
 
    } else if ((Bpb.BytesPerSector !=  128) &&
               (Bpb.BytesPerSector !=  256) &&
               (Bpb.BytesPerSector !=  512) &&
               (Bpb.BytesPerSector != 1024) &&
               (Bpb.BytesPerSector != 2048) &&
               (Bpb.BytesPerSector != 4096)) {
 
        Result = FALSE;
 
    //
    //  Likewise on the clustering.
    //
 
    } else if ((Bpb.SectorsPerCluster !=  1) &&
               (Bpb.SectorsPerCluster !=  2) &&
               (Bpb.SectorsPerCluster !=  4) &&
               (Bpb.SectorsPerCluster !=  8) &&
               (Bpb.SectorsPerCluster != 16) &&
               (Bpb.SectorsPerCluster != 32) &&
               (Bpb.SectorsPerCluster != 64) &&
               (Bpb.SectorsPerCluster != 128)) {
 
        Result = FALSE;
 
    //
    //  Likewise on the reserved sectors (must reflect at least the boot sector!)
    //
 
    } else if (Bpb.ReservedSectors == 0) {
 
        Result = FALSE;
 
    //
    //  No FATs? Wrong ...
    //
 
    } else if (Bpb.Fats == 0) {
 
        Result = FALSE;
 
    //
    // Prior to DOS 3.2 might contains value in both of Sectors and
    // Sectors Large.
    //
 
    } else if ((Bpb.Sectors == 0) && (Bpb.LargeSectors == 0)) {
 
        Result = FALSE;
 
    //
    //  Check that FAT32 (SectorsPerFat == 0) claims some FAT space and
    //  is of a version we recognize, currently Version 0.0.
    //
 
    } else if (Bpb.SectorsPerFat == 0 && ( Bpb.LargeSectorsPerFat == 0 ||
                                           Bpb.FsVersion != 0 )) {
 
        Result = FALSE;
 
    } else if ((Bpb.Media != 0xf0) &&
               (Bpb.Media != 0xf8) &&
               (Bpb.Media != 0xf9) &&
               (Bpb.Media != 0xfb) &&
               (Bpb.Media != 0xfc) &&
               (Bpb.Media != 0xfd) &&
               (Bpb.Media != 0xfe) &&
               (Bpb.Media != 0xff) &&
               (!FatData.FujitsuFMR || ((Bpb.Media != 0x00) &&
                                        (Bpb.Media != 0x01) &&
                                        (Bpb.Media != 0xfa)))) {
 
        Result = FALSE;
 
    //
    //  If this isn't FAT32, then there better be a claimed root directory
    //  size here ...
    //
 
    } else if (Bpb.SectorsPerFat != 0 && Bpb.RootEntries == 0) {
 
        Result = FALSE;
 
    //
    //  If this is FAT32 (i.e., extended BPB), look for and refuse to mount
    //  mirror-disabled volumes. If we did, we would need to only write to
    //  the FAT# indicated in the ActiveFat field. The only user of this is
    //  the FAT->FAT32 converter after the first pass of protected mode work
    //  (booting into realmode) and NT should absolutely not be attempting
    //  to mount such an in-transition volume.
    //
 
    } else if (Bpb.SectorsPerFat == 0 && Bpb.MirrorDisabled) {
 
        Result = FALSE;
    }
 
    DebugTrace(-1, Dbg, "FatIsBootSectorFat -> %08lx\n", Result);
 
    return Result;
}

FatIsEaNameValid()

BOOLEAN FatIsEaNameValid	(	IN PIRP_CONTEXT	IrpContext,
		IN OEM_STRING	Name
	)

Definition at line 3429 of file easup.c.

{
    ULONG Index;
 
    UCHAR Char;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Empty names are not valid.
    //
 
    if ( Name.Length == 0 ) { return FALSE; }
 
    //
    //  At this point we should only have a single name, which can't have
    //  more than 254 characters
    //
 
    if ( Name.Length > 254 ) { return FALSE; }
 
    for ( Index = 0; Index < (ULONG)Name.Length; Index += 1 ) {
 
        Char = Name.Buffer[ Index ];
 
        //
        //  Skip over and Dbcs chacters
        //
 
        if ( FsRtlIsLeadDbcsCharacter( Char ) ) {
 
            NT_ASSERT( Index != (ULONG)(Name.Length - 1) );
 
            Index += 1;
 
            continue;
        }
 
        //
        //  Make sure this character is legal, and if a wild card, that
        //  wild cards are permissible.
        //
 
        if ( !FsRtlIsAnsiCharacterLegalFat(Char, FALSE) ) {
 
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by FatCommonSetEa().

FatIsHandleCountZero()

BOOLEAN FatIsHandleCountZero	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 3614 of file strucsup.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    Fcb = Vcb->RootDcb;
 
    while (Fcb != NULL) {
 
        if (Fcb->UncleanCount != 0) {
 
            return FALSE;
        }
 
        Fcb = FatGetNextFcbTopDown(IrpContext, Fcb, Vcb->RootDcb);
    }
 
    return TRUE;
}

FatIsIoRangeValid()

static INLINE BOOLEAN FatIsIoRangeValid ( IN PVCB  Vcb, IN LARGE_INTEGER  Start, IN ULONG  Length  )

static

Definition at line 219 of file fatprocs.h.

{
 
    UNREFERENCED_PARAMETER( Vcb );
 
    //
    //  The only restriction on a FAT object is that the filesize must
    //  fit in 32bits, i.e. <= 0xffffffff. This then implies that the
    //  range of valid byte offsets is [0, fffffffe].
    //
    //  Two phases which check for illegality
    //
    //      - if the high 32bits are nonzero
    //      - if the length would cause a 32bit overflow
    //
 
    return !(Start.HighPart ||
             Start.LowPart + Length < Start.LowPart);
}

Referenced by _Requires_lock_held_().

FatIsIrpTopLevel()

BOOLEAN FatIsIrpTopLevel

(

IN PIRP

Irp

)

Definition at line 817 of file fatdata.c.

{
    PAGED_CODE();
 
    if ( IoGetTopLevelIrp() == NULL ) {
 
        IoSetTopLevelIrp( Irp );
 
        return TRUE;
 
    } else {
 
        return FALSE;
    }
}

Referenced by _Function_class_(), and _Requires_lock_held_().

FatIsNameInExpression()

BOOLEAN FatIsNameInExpression	(	IN PIRP_CONTEXT	IrpContext,
		IN OEM_STRING	Expression,
		IN OEM_STRING	Name
	)

Definition at line 35 of file namesup.c.

{
    PAGED_CODE();
 
    //
    //  Call the appropriate FsRtl routine do to the real work
    //
 
    return FsRtlIsDbcsInExpression( &Expression,
                                    &Name );
 
    UNREFERENCED_PARAMETER( IrpContext );
}

FatIsNameLongUnicodeValid()

static INLINE BOOLEAN FatIsNameLongUnicodeValid ( PIRP_CONTEXT  IrpContext, PUNICODE_STRING  Name, BOOLEAN  CanContainWildcards, BOOLEAN  PathNameOk, BOOLEAN  LeadingBackslashOk  )

static

Definition at line 1216 of file fatprocs.h.

{
    ULONG i;
 
    UNREFERENCED_PARAMETER( IrpContext );
    UNREFERENCED_PARAMETER( LeadingBackslashOk );
    UNREFERENCED_PARAMETER( PathNameOk );
 
    //
    //  I'm not bothering to do the whole thing, just enough to make this call look
    //  the same as the others.
    //
 
    NT_ASSERT( !PathNameOk && !LeadingBackslashOk );
 
    for (i=0; i < Name->Length/sizeof(WCHAR); i++) {
 
        if ((Name->Buffer[i] < 0x80) &&
            !(FsRtlIsAnsiCharacterLegalHpfs(Name->Buffer[i], CanContainWildcards))) {
 
            return FALSE;
        }
    }
 
    return TRUE;
}

FatLocateEaByName()

BOOLEAN FatLocateEaByName	(	IN PIRP_CONTEXT	IrpContext,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		IN POEM_STRING	EaName,
		OUT PULONG	Offset
	)

Definition at line 3344 of file easup.c.

{
    PPACKED_EA PackedEa;
    OEM_STRING Name;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatLocateEaByName, EaName = %Z\n", EaName);
 
    //
    //  For each packed ea in the list check its name against the
    //  ea name we're searching for
    //
 
    for ( *Offset = 0;
          *Offset < PackedEasLength;
          *Offset = FatLocateNextEa( IrpContext,
                                     FirstPackedEa,
                                     PackedEasLength,
                                     *Offset )) {
 
        //
        //  Reference the packed ea and get a string to its name
        //
 
        PackedEa = (PPACKED_EA) ((PUCHAR) FirstPackedEa + *Offset);
 
        Name.Buffer = &PackedEa->EaName[0];
        Name.Length = PackedEa->EaNameLength;
        Name.MaximumLength = PackedEa->EaNameLength;
 
        //
        //  Compare the two strings, if they are equal then we've
        //  found the caller's ea
        //
 
        if ( RtlCompareString( EaName, &Name, TRUE ) == 0 ) {
 
            DebugTrace(-1, Dbg, "FatLocateEaByName -> TRUE, *Offset = %08lx\n", *Offset);
            return TRUE;
        }
    }
 
    //
    //  We've exhausted the ea list without finding a match so return false
    //
 
    DebugTrace(-1, Dbg, "FatLocateEaByName -> FALSE\n", 0);
    return FALSE;
}

Referenced by FatCommonSetEa().

FatLocateNextEa()

ULONG FatLocateNextEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		IN ULONG	PreviousOffset
	)

Definition at line 3257 of file easup.c.

{
    PPACKED_EA PackedEa;
    ULONG PackedEaSize;
    ULONG Offset;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatLocateNextEa, PreviousOffset = %08lx\n",
               PreviousOffset);
 
    //
    //  Make sure the previous offset is within the used size range
    //
 
    if ( PreviousOffset >= PackedEasLength ) {
 
        DebugTrace(-1, Dbg, "FatLocateNextEa -> 0xffffffff\n", 0);
        return 0xffffffff;
    }
 
    //
    //  Get a reference to the previous packed ea, and compute its size
    //
 
    PackedEa = (PPACKED_EA) ((PUCHAR) FirstPackedEa + PreviousOffset );
    SizeOfPackedEa( PackedEa, &PackedEaSize );
 
    //
    //  Compute to the next ea
    //
 
    Offset = PreviousOffset + PackedEaSize;
 
    //
    //  Now, if the new offset is beyond the ea size then we know
    //  that there isn't one so, we return an offset of 0xffffffff.
    //  otherwise we'll leave the new offset alone.
    //
 
    if ( Offset >= PackedEasLength ) {
 
        Offset = 0xffffffff;
    }
 
    DebugTrace(-1, Dbg, "FatLocateNextEa -> %08lx\n", Offset);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return Offset;
}

Referenced by FatLocateEaByName().

FatLockUserBuffer()

VOID FatLockUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp,
		IN LOCK_OPERATION	Operation,
		IN ULONG	BufferLength
	)

Definition at line 3276 of file deviosup.c.

{
    PMDL Mdl = NULL;
 
    PAGED_CODE();
 
    if (Irp->MdlAddress == NULL) {
 
        //
        // Allocate the Mdl, and Raise if we fail.
        //
 
        Mdl = IoAllocateMdl( Irp->UserBuffer, BufferLength, FALSE, FALSE, Irp );
 
        if (Mdl == NULL) {
 
            FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
 
        //
        // Now probe the buffer described by the Irp.  If we get an exception,
        // deallocate the Mdl and return the appropriate "expected" status.
        //
 
        _SEH2_TRY {
 
            MmProbeAndLockPages( Mdl,
                                 Irp->RequestorMode,
                                 Operation );
 
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 
            NTSTATUS Status;
 
            Status = _SEH2_GetExceptionCode();
 
            IoFreeMdl( Mdl );
            Irp->MdlAddress = NULL;
 
            FatRaiseStatus( IrpContext,
                            FsRtlIsNtstatusExpected(Status) ? Status : STATUS_INVALID_USER_BUFFER );
        } _SEH2_END;
    }
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by _Requires_lock_held_(), and FatPrePostIrp().

FatLogOf()

UCHAR FatLogOf

(

IN ULONG

Value

)

Definition at line 4655 of file allocsup.c.

{
    UCHAR Log = 0;
 
#if FASTFATDBG
    ULONG OrigValue = Value;
#endif
 
    PAGED_CODE();
 
    //
    //  Knock bits off until we we get a one at position 0
    //
 
    while ( (Value & 0xfffffffe) != 0 ) {
 
        Log++;
        Value >>= 1;
    }
 
    //
    //  If there was more than one bit set, the file system messed up,
    //  Bug Check.
    //
 
    if (Value != 0x1) {
 
        DebugTrace(+1, Dbg, "LogOf\n", 0);
        DebugTrace( 0, Dbg, "  Value = %8lx\n", OrigValue);
 
        DebugTrace( 0, Dbg, "Received non power of 2.\n", 0);
 
        DebugTrace(-1, Dbg, "LogOf -> %8lx\n", Log);
 
#ifdef _MSC_VER
#pragma prefast( suppress: 28159, "we bugcheck here because our internal data structures are seriously corrupted if this happens" )
#endif
        FatBugCheck( Value, Log, 0 );
    }
 
    return Log;
}

Referenced by FatSetupAllocationSupport().

FatLookupFatEntry()

VOID FatLookupFatEntry	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN ULONG	FatIndex,
		IN OUT PULONG	FatEntry,
		IN OUT PFAT_ENUMERATION_CONTEXT	Context
	)

Definition at line 3565 of file allocsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatLookupFatEntry\n", 0);
    DebugTrace( 0, Dbg, "  Vcb      = %p\n", Vcb);
    DebugTrace( 0, Dbg, "  FatIndex = %4x\n", FatIndex);
    DebugTrace( 0, Dbg, "  FatEntry = %8lx\n", FatEntry);
 
    //
    //  Make sure they gave us a valid fat index.
    //
 
    FatVerifyIndexIsValid(IrpContext, Vcb, FatIndex);
 
    //
    //  Case on 12 or 16 bit fats.
    //
    //  In the 12 bit case (mostly floppies) we always have the whole fat
    //  (max 6k bytes) pinned during allocation operations.  This is possibly
    //  a wee bit slower, but saves headaches over fat entries with 8 bits
    //  on one page, and 4 bits on the next.
    //
    //  The 16 bit case always keeps the last used page pinned until all
    //  operations are done and it is unpinned.
    //
 
    //
    //  DEAL WITH 12 BIT CASE
    //
 
    if (Vcb->AllocationSupport.FatIndexBitSize == 12) {
 
        //
        //  Check to see if the fat is already pinned, otherwise pin it.
        //
 
        if (Context->Bcb == NULL) {
 
            FatReadVolumeFile( IrpContext,
                               Vcb,
                               FatReservedBytes( &Vcb->Bpb ),
                               FatBytesPerFat( &Vcb->Bpb ),
                               &Context->Bcb,
                               &Context->PinnedPage );
        }
 
        //
        //  Load the return value.
        //
 
 
        FatLookup12BitEntry( Context->PinnedPage, FatIndex, FatEntry );
 
    } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) {
 
        //
        //  DEAL WITH 32 BIT CASE
        //
 
        ULONG PageEntryOffset;
        ULONG OffsetIntoVolumeFile;
 
        //
        //  Initialize two local variables that help us.
        //
        OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex * sizeof(FAT_ENTRY);
        PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) / sizeof(FAT_ENTRY);
 
        //
        //  Check to see if we need to read in a new page of fat
        //
 
        if ((Context->Bcb == NULL) ||
            (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage / PAGE_SIZE)) {
 
            //
            //  The entry wasn't in the pinned page, so must we unpin the current
            //  page (if any) and read in a new page.
            //
 
            FatUnpinBcb( IrpContext, Context->Bcb );
 
            FatReadVolumeFile( IrpContext,
                               Vcb,
                               OffsetIntoVolumeFile & ~(PAGE_SIZE - 1),
                               PAGE_SIZE,
                               &Context->Bcb,
                               &Context->PinnedPage );
 
            Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE - 1);
        }
 
        //
        //  Grab the fat entry from the pinned page, and return
        //
 
        *FatEntry = ((PULONG)(Context->PinnedPage))[PageEntryOffset] & FAT32_ENTRY_MASK;
 
    } else {
 
        //
        //  DEAL WITH 16 BIT CASE
        //
 
        ULONG PageEntryOffset;
        ULONG OffsetIntoVolumeFile;
 
        //
        //  Initialize two local variables that help us.
        //
 
        OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex * sizeof(USHORT);
        PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) / sizeof(USHORT);
 
        //
        //  Check to see if we need to read in a new page of fat
        //
 
        if ((Context->Bcb == NULL) ||
            (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage / PAGE_SIZE)) {
 
            //
            //  The entry wasn't in the pinned page, so must we unpin the current
            //  page (if any) and read in a new page.
            //
 
            FatUnpinBcb( IrpContext, Context->Bcb );
 
            FatReadVolumeFile( IrpContext,
                               Vcb,
                               OffsetIntoVolumeFile & ~(PAGE_SIZE - 1),
                               PAGE_SIZE,
                               &Context->Bcb,
                               &Context->PinnedPage );
 
            Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE - 1);
        }
 
        //
        //  Grab the fat entry from the pinned page, and return
        //
 
        *FatEntry = ((PUSHORT)(Context->PinnedPage))[PageEntryOffset];
    }
 
    DebugTrace(-1, Dbg, "FatLookupFatEntry -> (VOID)\n", 0);
    return;
}

Referenced by _Requires_lock_held_().

FatLookupLastMcbEntry()

BOOLEAN FatLookupLastMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		OUT PVBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG Index	OPTIONAL
	)

Definition at line 494 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiVbo;
    LONGLONG LiLbo;
    ULONG LocalIndex;
 
    PAGED_CODE();
 
    LiVbo = LiLbo = 0;
    LocalIndex = 0;
 
    Results = FsRtlLookupLastLargeMcbEntryAndIndex( Mcb,
                                                    &LiVbo,
                                                    &LiLbo,
                                                    &LocalIndex );
 
    *Vbo = ((VBO) LiVbo) << MCB_SCALE_LOG2;
 
    if (((ULONG) LiLbo) != -1) {
 
        *Lbo = ((LBO) LiLbo) << MCB_SCALE_LOG2;
 
        *Lbo += (MCB_SCALE - 1);
        *Vbo += (MCB_SCALE - 1);
 
    } else {
 
        *Lbo = 0;
    }
 
    if (Index) {
        *Index = LocalIndex;
    }
 
    return Results;
}

Referenced by _Requires_lock_held_().

FatLookupMcbEntry()

BOOLEAN FatLookupMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG ByteCount	OPTIONAL,
		OUT PULONG Index	OPTIONAL
	)

Definition at line 418 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiLbo;
    LONGLONG LiSectorCount;
    ULONG Remainder;
 
    LiLbo = 0;
    LiSectorCount = 0;
 
    Remainder = Vbo & MCB_SCALE_MODULO;
 
    Results = FsRtlLookupLargeMcbEntry( Mcb,
                                        (Vbo >> MCB_SCALE_LOG2),
                                        &LiLbo,
                                        ARGUMENT_PRESENT(ByteCount) ? &LiSectorCount : NULL,
                                        NULL,
                                        NULL,
                                        Index );
 
    if ((ULONG) LiLbo != -1) {
 
        *Lbo = (((LBO) LiLbo) << MCB_SCALE_LOG2);
 
        if (Results) {
 
            *Lbo += Remainder;
        }
 
    } else {
 
        *Lbo = 0;
    }
 
    if (ARGUMENT_PRESENT(ByteCount)) {
 
        *ByteCount = (ULONG) LiSectorCount;
 
        if (*ByteCount) {
 
            *ByteCount <<= MCB_SCALE_LOG2;
 
            //
            //  If ByteCount overflows, then this is likely the case of
            //  a file of max-supported size (4GiB - 1), allocated in a
            //  single continuous run.
            //
 
            if (*ByteCount == 0) {
 
                *ByteCount = 0xFFFFFFFF;
            }
 
            if (Results) {
 
                *ByteCount -= Remainder;
            }
        }
 
    }
 
    return Results;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), and FatPagingFileIo().

FatMapUserBuffer()

PVOID FatMapUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp
	)

Definition at line 3357 of file deviosup.c.

{
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    // If there is no Mdl, then we must be in the Fsd, and we can simply
    // return the UserBuffer field from the Irp.
    //
 
    if (Irp->MdlAddress == NULL) {
 
        return Irp->UserBuffer;
 
    } else {
 
        PVOID Address = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute );
 
        if (Address == NULL) {
 
            ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
        }
 
        return Address;
    }
}

Referenced by _Requires_lock_held_(), FatBufferUserBuffer(), and FatCommonQueryEa().

FatMarkEaRangeDirty()

VOID FatMarkEaRangeDirty	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	EaFileObject,
		IN OUT PEA_RANGE	EaRange
	)

Definition at line 3709 of file easup.c.

{
    PBCB *NextBcb;
    ULONG BcbCount;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If there is an auxilary buffer we need to copy the data back into the cache.
    //
 
    if (EaRange->AuxilaryBuffer == TRUE) {
 
        LARGE_INTEGER LargeVbo;
 
        LargeVbo.QuadPart = EaRange->StartingVbo;
 
        CcCopyWrite( EaFileObject,
                     &LargeVbo,
                     EaRange->Length,
                     TRUE,
                     EaRange->Data );
    }
 
    //
    //  Now walk through the Bcb chain and mark everything dirty.
    //
 
    BcbCount = EaRange->BcbChainLength;
    NextBcb = EaRange->BcbChain;
 
    while (BcbCount--) {
 
        if (*NextBcb != NULL) {
 
            CcSetDirtyPinnedData( *NextBcb, NULL );
        }
 
        NextBcb += 1;
    }
 
    return;
}

Referenced by FatCommonSetEa().

FatMarkFcbCondition()

VOID FatMarkFcbCondition	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN FCB_CONDITION	FcbCondition,
		IN BOOLEAN	Recursive
	)

Referenced by FatInsertName().

FatMultipleAsync()

VOID FatMultipleAsync	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PIRP	Irp,
		IN ULONG	MultipleIrpCount,
		IN PIO_RUN	IoRuns
	)

Definition at line 1622 of file deviosup.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IrpSp;
    PMDL Mdl;
    BOOLEAN Wait;
    PFAT_IO_CONTEXT Context;
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
    ULONG Length = 0;
#endif
 
    ULONG UnwindRunCount = 0;
 
    BOOLEAN ExceptionExpected = TRUE;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatMultipleAsync\n", 0);
    DebugTrace( 0, Dbg, "MajorFunction    = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "Vcb              = %p\n", Vcb );
    DebugTrace( 0, Dbg, "MasterIrp        = %p\n", MasterIrp );
    DebugTrace( 0, Dbg, "MultipleIrpCount = %08lx\n", MultipleIrpCount );
    DebugTrace( 0, Dbg, "IoRuns           = %08lx\n", IoRuns );
 
    //
    //  If this I/O originating during FatVerifyVolume, bypass the
    //  verify logic.
    //
 
    if (Vcb->VerifyThread == KeGetCurrentThread()) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
    }
 
    //
    //  Set up things according to whether this is truely async.
    //
 
    Wait = BooleanFlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    Context = IrpContext->FatIoContext;
 
    //
    //  Finish initializing Context, for use in Read/Write Multiple Asynch.
    //
 
    Context->MasterIrp = MasterIrp;
 
    IrpSp = IoGetCurrentIrpStackLocation( MasterIrp );
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
    Length = IrpSp->Parameters.Read.Length;
#endif
 
    _SEH2_TRY {
 
        //
        //  Itterate through the runs, doing everything that can fail
        //
 
        for ( UnwindRunCount = 0;
              UnwindRunCount < MultipleIrpCount;
              UnwindRunCount++ ) {
 
            //
            //  Create an associated IRP, making sure there is one stack entry for
            //  us, as well.
            //
 
            IoRuns[UnwindRunCount].SavedIrp = 0;
 
            Irp = IoMakeAssociatedIrp( MasterIrp,
                                       (CCHAR)(Vcb->TargetDeviceObject->StackSize + 1) );
 
            if (Irp == NULL) {
 
                FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
            }
 
            IoRuns[UnwindRunCount].SavedIrp = Irp;
 
            //
            // Allocate and build a partial Mdl for the request.
            //
 
            Mdl = IoAllocateMdl( (PCHAR)MasterIrp->UserBuffer +
                                 IoRuns[UnwindRunCount].Offset,
                                 IoRuns[UnwindRunCount].ByteCount,
                                 FALSE,
                                 FALSE,
                                 Irp );
 
            if (Mdl == NULL) {
 
                FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
            }
 
            //
            //  Sanity Check
            //
 
            NT_ASSERT( Mdl == Irp->MdlAddress );
 
            IoBuildPartialMdl( MasterIrp->MdlAddress,
                               Mdl,
                               (PCHAR)MasterIrp->UserBuffer +
                               IoRuns[UnwindRunCount].Offset,
                               IoRuns[UnwindRunCount].ByteCount );
 
            //
            //  Get the first IRP stack location in the associated Irp
            //
 
            IoSetNextIrpStackLocation( Irp );
            IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
            //
            //  Setup the Stack location to describe our read.
            //
 
            IrpSp->MajorFunction = IrpContext->MajorFunction;
            IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].ByteCount;
            IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].Vbo;
 
            //
            // Set up the completion routine address in our stack frame.
            //
 
            IoSetCompletionRoutine( Irp,
                                    Wait ?
                                    &FatMultiSyncCompletionRoutine :
                                    &FatMultiAsyncCompletionRoutine,
                                    Context,
                                    TRUE,
                                    TRUE,
                                    TRUE );
 
            //
            //  Setup the next IRP stack location in the associated Irp for the disk
            //  driver beneath us.
            //
 
            IrpSp = IoGetNextIrpStackLocation( Irp );
 
            //
            //  Setup the Stack location to do a read from the disk driver.
            //
 
            IrpSp->MajorFunction = IrpContext->MajorFunction;
            IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].ByteCount;
            IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].Lbo;
 
            //
            //  If this Irp is the result of a WriteThough operation,
            //  tell the device to write it through.
            //
 
            if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH )) {
 
                SetFlag( IrpSp->Flags, SL_WRITE_THROUGH );
            }
 
            //
            //  If this I/O requires override verify, bypass the verify logic.
            //
 
            if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY )) {
 
                SetFlag( IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
            }
        }
 
        //
        //  Now we no longer expect an exception.  If the driver raises, we
        //  must bugcheck, because we do not know how to recover from that
        //  case.
        //
 
        ExceptionExpected = FALSE;
 
        //
        //  We only need to set the associated IRP count in the master irp to
        //  make it a master IRP.  But we set the count to one more than our
        //  caller requested, because we do not want the I/O system to complete
        //  the I/O.  We also set our own count.
        //
 
        Context->IrpCount = MultipleIrpCount;
        MasterIrp->AssociatedIrp.IrpCount = MultipleIrpCount;
 
        if (Wait) {
 
            MasterIrp->AssociatedIrp.IrpCount += 1;
        }
        else if (FlagOn( Context->Wait.Async.ResourceThreadId, 3 )) {
 
            //
            //  For async requests if we acquired locks, transition the lock owners to an
            //  object, since when we return this thread could go away before request
            //  completion, and the resource package may try to boost priority.
            //
 
            if (Context->Wait.Async.Resource != NULL) {
 
                ExSetResourceOwnerPointer( Context->Wait.Async.Resource,
                                           (PVOID)Context->Wait.Async.ResourceThreadId );
            }
 
            if (Context->Wait.Async.Resource2 != NULL) {
 
                ExSetResourceOwnerPointer( Context->Wait.Async.Resource2,
                                           (PVOID)Context->Wait.Async.ResourceThreadId );
            }
        }
 
        //
        //  Back up a copy of the IrpContext flags for later use in async completion.
        //
 
        Context->IrpContextFlags = IrpContext->Flags;
 
        //
        //  Now that all the dangerous work is done, issue the read requests
        //
 
        for (UnwindRunCount = 0;
             UnwindRunCount < MultipleIrpCount;
             UnwindRunCount++) {
 
            Irp = IoRuns[UnwindRunCount].SavedIrp;
 
            DebugDoit( FatIoCallDriverCount += 1);
 
            //
            //  If IoCallDriver returns an error, it has completed the Irp
            //  and the error will be caught by our completion routines
            //  and dealt with as a normal IO error.
            //
 
            (VOID)FatLowLevelReadWrite( IrpContext,
                                        Vcb->TargetDeviceObject,
                                        Irp,
                                        Vcb );
        }
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, Length );
        }
 
    } _SEH2_FINALLY {
 
        ULONG i;
 
        DebugUnwind( FatMultipleAsync );
 
        //
        //  Only allocating the spinlock, making the associated Irps
        //  and allocating the Mdls can fail.
        //
 
        if ( _SEH2_AbnormalTermination() ) {
 
            //
            //  If the driver raised, we are hosed.  He is not supposed to raise,
            //  and it is impossible for us to figure out how to clean up.
            //
 
            if (!ExceptionExpected) {
                NT_ASSERT( ExceptionExpected );
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
                FatBugCheck( 0, 0, 0 );
            }
 
            //
            //  Unwind
            //
 
            for (i = 0; i <= UnwindRunCount; i++) {
 
                if ( (Irp = IoRuns[i].SavedIrp) != NULL ) {
 
                    if ( Irp->MdlAddress != NULL ) {
 
                        IoFreeMdl( Irp->MdlAddress );
                    }
 
                    IoFreeIrp( Irp );
                }
            }
        }
 
        //
        //  And return to our caller
        //
 
        DebugTrace(-1, Dbg, "FatMultipleAsync -> VOID\n", 0);
    } _SEH2_END;
 
    return;
}

Referenced by _Requires_lock_held_(), and FatMultipleAsync().

FatNoOpAcquire()

BOOLEAN NTAPI FatNoOpAcquire	(	IN PVOID	Fcb,
		IN BOOLEAN	Wait
	)

Definition at line 795 of file resrcsup.c.

{
    UNREFERENCED_PARAMETER( Fcb );
    UNREFERENCED_PARAMETER( Wait );
 
    PAGED_CODE();
 
    //
    //  This is a kludge because Cc is really the top level.  We it
    //  enters the file system, we will think it is a resursive call
    //  and complete the request with hard errors or verify.  It will
    //  have to deal with them, somehow....
    //
 
    NT_ASSERT(IoGetTopLevelIrp() == NULL);
 
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    return TRUE;
}

FatNoOpRelease()

VOID NTAPI FatNoOpRelease

(

IN PVOID

Fcb

)

Definition at line 842 of file resrcsup.c.

{
    PAGED_CODE();
 
    //
    //  Clear the kludge at this point.
    //
 
    NT_ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    IoSetTopLevelIrp( NULL );
 
    UNREFERENCED_PARAMETER( Fcb );
 
    return;
}

FatOpenEaFile()

PFILE_OBJECT FatOpenEaFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	EaFcb
	)

Definition at line 979 of file cachesup.c.

{
    PFILE_OBJECT EaFileObject = NULL;
    PDEVICE_OBJECT RealDevice;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatOpenEaFile\n", 0);
    DebugTrace( 0, Dbg, "EaFcb = %p\n", EaFcb);
 
    //
    //  Create the special file object for the ea file, and set
    //  up its pointers back to the Fcb and the section object pointer
    //
 
    RealDevice = EaFcb->Vcb->CurrentDevice;
 
    EaFileObject = IoCreateStreamFileObject( NULL, RealDevice );
 
    _SEH2_TRY {
 
        FatPreallocateCloseContext( IrpContext->Vcb);
 
        FatSetFileObject( EaFileObject,
                          EaFile,
                          EaFcb,
                          NULL );
 
        //
        //  Remember this internal, residual open.
        //
 
        InterlockedIncrement( (LONG*)&(EaFcb->Vcb->InternalOpenCount) );
        InterlockedIncrement( (LONG*)&(EaFcb->Vcb->ResidualOpenCount) );
 
        EaFileObject->SectionObjectPointer = &EaFcb->NonPaged->SectionObjectPointers;
 
        EaFileObject->ReadAccess = TRUE;
        EaFileObject->WriteAccess = TRUE;
 
        //
        //  Finally check if we need to initialize the Cache Map for the
        //  ea file.  The size of the section we are going to map
        //  the current allocation size for the Fcb.
        //
 
        EaFcb->Header.ValidDataLength = FatMaxLarge;
 
        FatInitializeCacheMap( EaFileObject,
                               (PCC_FILE_SIZES)&EaFcb->Header.AllocationSize,
                               TRUE,
                               &FatData.CacheManagerCallbacks,
                               EaFcb );
 
        CcSetAdditionalCacheAttributes( EaFileObject, TRUE, TRUE );
 
    } _SEH2_FINALLY {
 
        //
        //  Drop the fileobject if we're raising.  Two cases: couldn't get
        //  the close context, and it is still an UnopenedFileObject, or
        //  we lost trying to build the cache map - in which case we're
        //  OK for the close context if we have to.
        //
 
        if (_SEH2_AbnormalTermination()) {
 
            ObDereferenceObject( EaFileObject );
        }
    } _SEH2_END;
 
    DebugTrace(-1, Dbg, "FatOpenEaFile -> %p\n", EaFileObject);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return EaFileObject;
}

FatOplockComplete()

VOID NTAPI FatOplockComplete	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 35 of file workque.c.

{
    PAGED_CODE();
 
    //
    //  Check on the return value in the Irp.
    //
 
    if (Irp->IoStatus.Status == STATUS_SUCCESS) {
 
        //
        //  Insert the Irp context in the workqueue.
        //
 
        FatAddToWorkque( (PIRP_CONTEXT) Context, Irp );
 
    //
    //  Otherwise complete the request.
    //
 
    } else {
 
        FatCompleteRequest( (PIRP_CONTEXT) Context, Irp, Irp->IoStatus.Status );
    }
 
    return;
}

Referenced by _Requires_lock_held_(), and FatSetRenameInfo().

FatPagingFileIo()

VOID FatPagingFileIo	(	IN PIRP	Irp,
		IN PFCB	Fcb
	)

Definition at line 211 of file deviosup.c.

{
    //
    // Declare some local variables for enumeration through the
    // runs of the file.
    //
 
    VBO Vbo;
    ULONG ByteCount;
 
    PMDL Mdl;
    LBO NextLbo;
    VBO NextVbo = 0;
    ULONG NextByteCount;
    ULONG RemainingByteCount;
    BOOLEAN MustSucceed;
 
    ULONG FirstIndex;
    ULONG CurrentIndex;
    ULONG LastIndex;
 
    LBO LastLbo;
    ULONG LastByteCount;
 
    BOOLEAN MdlIsReserve = FALSE;
    BOOLEAN IrpIsMaster = FALSE;
    FAT_PAGING_FILE_CONTEXT Context;
    LONG IrpCount;
 
    PIRP AssocIrp;
    PIO_STACK_LOCATION IrpSp;
    PIO_STACK_LOCATION NextIrpSp;
    ULONG BufferOffset;
    PDEVICE_OBJECT DeviceObject;
 
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
#endif
 
    DebugTrace(+1, Dbg, "FatPagingFileIo\n", 0);
    DebugTrace( 0, Dbg, "Irp = %p\n", Irp );
    DebugTrace( 0, Dbg, "Fcb = %p\n", Fcb );
 
    NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE ));
 
    //
    //  Initialize some locals.
    //
 
    BufferOffset = 0;
    DeviceObject = Fcb->Vcb->TargetDeviceObject;
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    Vbo = IrpSp->Parameters.Read.ByteOffset.LowPart;
    ByteCount = IrpSp->Parameters.Read.Length;
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
#endif
 
    MustSucceed = FatLookupMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                     Vbo,
                                     &NextLbo,
                                     &NextByteCount,
                                     &FirstIndex);
 
    //
    //  If this run isn't present, something is very wrong.
    //
 
    if (!MustSucceed) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( Vbo, ByteCount, 0 );
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
 
    //
    //  Charge the IO to paging file to current thread
    //
 
    if (FatDiskAccountingEnabled) {
 
        PETHREAD ThreadIssuingIo = PsGetCurrentThread();
        BOOLEAN IsWriteOperation = FALSE;
 
        if (IrpSp->MajorFunction == IRP_MJ_WRITE) {
            IsWriteOperation = TRUE;
        }
 
        PsUpdateDiskCounters( PsGetThreadProcess( ThreadIssuingIo ),
                              (IsWriteOperation ? 0 : ByteCount ),       // bytes to read
                              (IsWriteOperation ? ByteCount : 0),       // bytes to write
                              (IsWriteOperation ? 0 : 1),               // # of reads
                              (IsWriteOperation ? 1 : 0),               // # of writes
                              0 );
    }
#endif
 
    // See if the write covers a single valid run, and if so pass
    // it on.
    //
 
    if ( NextByteCount >= ByteCount ) {
 
        DebugTrace( 0, Dbg, "Passing Irp on to Disk Driver\n", 0 );
 
        //
        //  Setup the next IRP stack location for the disk driver beneath us.
        //
 
        NextIrpSp = IoGetNextIrpStackLocation( Irp );
 
        NextIrpSp->MajorFunction = IrpSp->MajorFunction;
        NextIrpSp->Parameters.Read.Length = ByteCount;
        NextIrpSp->Parameters.Read.ByteOffset.QuadPart = NextLbo;
 
        //
        //  Since this is Paging file IO, we'll just ignore the verify bit.
        //
 
        SetFlag( NextIrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
        //
        //  Set up the completion routine address in our stack frame.
        //  This is only invoked on error or cancel, and just copies
        //  the error Status into master irp's iosb.
        //
        //  If the error implies a media problem, it also enqueues a
        //  worker item to write out the dirty bit so that the next
        //  time we run we will do a autochk /r
        //
 
        IoSetCompletionRoutine( Irp,
                                &FatPagingFileCompletionRoutine,
                                Irp,
                                FALSE,
                                TRUE,
                                TRUE );
 
        //
        //  Issue the read/write request
        //
        //  If IoCallDriver returns an error, it has completed the Irp
        //  and the error will be dealt with as a normal IO error.
        //
 
        (VOID)IoCallDriver( DeviceObject, Irp );
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, ByteCount );
        }
 
        DebugTrace(-1, Dbg, "FatPagingFileIo -> VOID\n", 0);
        return;
    }
 
    //
    //  Find out how may runs there are.
    //
 
    MustSucceed = FatLookupMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                     Vbo + ByteCount - 1,
                                     &LastLbo,
                                     &LastByteCount,
                                     &LastIndex);
 
    //
    //  If this run isn't present, something is very wrong.
    //
 
    if (!MustSucceed) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( Vbo + ByteCount - 1, 1, 0 );
    }
 
    CurrentIndex = FirstIndex;
 
    //
    //  Now set up the Irp->IoStatus.  It will be modified by the
    //  multi-completion routine in case of error or verify required.
    //
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = ByteCount;
 
    //
    //  Loop while there are still byte writes to satisfy.  The way we'll work this
    //  is to hope for the best - one associated IRP per run, which will let us be
    //  completely async after launching all the IO.
    //
    //  IrpCount will indicate the remaining number of associated Irps to launch.
    //
    //  All we have to do is make sure IrpCount doesn't hit zero before we're building
    //  the very last Irp.  If it is positive when we're done, it means we have to
    //  wait for the rest of the associated Irps to come back before we complete the
    //  master by hand.
    //
    //  This will keep the master from completing early.
    //
 
    Irp->AssociatedIrp.IrpCount = IrpCount = LastIndex - FirstIndex + 1;
 
    while (CurrentIndex <= LastIndex) {
 
        //
        //  Reset this for unwinding purposes
        //
 
        AssocIrp = NULL;
 
        //
        //  If next run is larger than we need, "ya get what ya need".
        //
 
        if (NextByteCount > ByteCount) {
            NextByteCount = ByteCount;
        }
 
        RemainingByteCount = 0;
 
        //
        // Allocate and build a partial Mdl for the request.
        //
 
        Mdl = IoAllocateMdl( (PCHAR)Irp->UserBuffer + BufferOffset,
                             NextByteCount,
                             FALSE,
                             FALSE,
                             AssocIrp );
 
        if (Mdl == NULL) {
 
            //
            //  Pick up the reserve MDL
            //
 
            KeWaitForSingleObject( &FatReserveEvent, Executive, KernelMode, FALSE, NULL );
 
            Mdl = FatReserveMdl;
            MdlIsReserve = TRUE;
 
            //
            //  Trim to fit the size of the reserve MDL.
            //
 
            if (NextByteCount > FAT_RESERVE_MDL_SIZE * PAGE_SIZE) {
 
                RemainingByteCount = NextByteCount - FAT_RESERVE_MDL_SIZE * PAGE_SIZE;
                NextByteCount = FAT_RESERVE_MDL_SIZE * PAGE_SIZE;
            }
        }
 
        IoBuildPartialMdl( Irp->MdlAddress,
                           Mdl,
                           (PCHAR)Irp->UserBuffer + BufferOffset,
                           NextByteCount );
 
        //
        //  Now that we have properly bounded this piece of the transfer, it is
        //  time to read/write it.  We can simplify life slightly by always
        //  re-using the master IRP for cases where we use the reserve MDL,
        //  since we'll always be synchronous for those and can use a single
        //  completion context on our local stack.
        //
        //  We also must prevent ourselves from issuing an associated IRP that would
        //  complete the master UNLESS this is the very last IRP we'll issue.
        //
        //  This logic looks a bit complicated, but is hopefully understandable.
        //
 
        if (!MdlIsReserve &&
            (IrpCount != 1 ||
             (CurrentIndex == LastIndex &&
              RemainingByteCount == 0))) {
 
            AssocIrp = IoMakeAssociatedIrp( Irp, (CCHAR)(DeviceObject->StackSize + 1) );
        }
 
        if (AssocIrp == NULL) {
 
            AssocIrp = Irp;
            IrpIsMaster = TRUE;
 
            //
            //  We need to drain the associated Irps so we can reliably figure out if
            //  the master Irp is showing a failed status, in which case we bail out
            //  immediately - as opposed to putting the value in the status field in
            //  jeopardy due to our re-use of the master Irp.
            //
 
            while (Irp->AssociatedIrp.IrpCount != IrpCount) {
 
                KeDelayExecutionThread (KernelMode, FALSE, &Fat30Milliseconds);
            }
 
            //
            //  Note that since we failed to launch this associated Irp, that the completion
            //  code at the bottom will take care of completing the master Irp.
            //
 
            if (!NT_SUCCESS(Irp->IoStatus.Status)) {
 
                NT_ASSERT( IrpCount );
                break;
            }
 
        } else {
 
            //
            //  Indicate we used an associated Irp.
            //
 
            IrpCount -= 1;
        }
 
        //
        //  With an associated IRP, we must take over the first stack location so
        //  we can have one to put the completion routine on.  When re-using the
        //  master IRP, its already there.
        //
 
        if (!IrpIsMaster) {
 
            //
            //  Get the first IRP stack location in the associated Irp
            //
 
            IoSetNextIrpStackLocation( AssocIrp );
            NextIrpSp = IoGetCurrentIrpStackLocation( AssocIrp );
 
            //
            //  Setup the Stack location to describe our read.
            //
 
            NextIrpSp->MajorFunction = IrpSp->MajorFunction;
            NextIrpSp->Parameters.Read.Length = NextByteCount;
            NextIrpSp->Parameters.Read.ByteOffset.QuadPart = Vbo;
 
            //
            //  We also need the VolumeDeviceObject in the Irp stack in case
            //  we take the failure path.
            //
 
            NextIrpSp->DeviceObject = IrpSp->DeviceObject;
 
        } else {
 
            //
            //  Save the MDL in the IRP and prepare the stack
            //  context for the completion routine.
            //
 
            KeInitializeEvent( &Context.Event, SynchronizationEvent, FALSE );
            Context.RestoreMdl = Irp->MdlAddress;
        }
 
        //
        //  And drop our Mdl into the Irp.
        //
 
        AssocIrp->MdlAddress = Mdl;
 
        //
        //  Set up the completion routine address in our stack frame.
        //  For true associated IRPs, this is only invoked on error or
        //  cancel, and just copies the error Status into master irp's
        //  iosb.
        //
        //  If the error implies a media problem, it also enqueues a
        //  worker item to write out the dirty bit so that the next
        //  time we run we will do a autochk /r
        //
 
        if (IrpIsMaster) {
 
            IoSetCompletionRoutine( AssocIrp,
                                    FatPagingFileCompletionRoutineCatch,
                                    &Context,
                                    TRUE,
                                    TRUE,
                                    TRUE );
 
        } else {
 
            IoSetCompletionRoutine( AssocIrp,
                                    FatPagingFileCompletionRoutine,
                                    Irp,
                                    FALSE,
                                    TRUE,
                                    TRUE );
        }
 
        //
        //  Setup the next IRP stack location for the disk driver beneath us.
        //
 
        NextIrpSp = IoGetNextIrpStackLocation( AssocIrp );
 
        //
        //  Since this is paging file IO, we'll just ignore the verify bit.
        //
 
        SetFlag( NextIrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
        //
        //  Setup the Stack location to do a read from the disk driver.
        //
 
        NextIrpSp->MajorFunction = IrpSp->MajorFunction;
        NextIrpSp->Parameters.Read.Length = NextByteCount;
        NextIrpSp->Parameters.Read.ByteOffset.QuadPart = NextLbo;
 
        (VOID)IoCallDriver( DeviceObject, AssocIrp );
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, (ULONG64)NextByteCount );
        }
 
        //
        //  Wait for the Irp in the catch case and drop the flags.
        //
 
        if (IrpIsMaster) {
 
            KeWaitForSingleObject( &Context.Event, Executive, KernelMode, FALSE, NULL );
            IrpIsMaster = MdlIsReserve = FALSE;
 
            //
            //  If the Irp is showing a failed status, there is no point in continuing.
            //  In doing so, we get to avoid squirreling away the failed status in case
            //  we were to re-use the master irp again.
            //
            //  Note that since we re-used the master, we must not have issued the "last"
            //  associated Irp, and thus the completion code at the bottom will take care
            //  of that for us.
            //
 
            if (!NT_SUCCESS(Irp->IoStatus.Status)) {
 
                NT_ASSERT( IrpCount );
                break;
            }
        }
 
        //
        //  Now adjust everything for the next pass through the loop.
        //
 
        Vbo += NextByteCount;
        BufferOffset += NextByteCount;
        ByteCount -= NextByteCount;
 
        //
        //  Try to lookup the next run, if we are not done and we got
        //  all the way through the current run.
        //
 
        if (RemainingByteCount) {
 
            //
            //  Advance the Lbo/Vbo if we have more to do in the current run.
            //
 
            NextLbo += NextByteCount;
            NextVbo += NextByteCount;
 
            NextByteCount = RemainingByteCount;
 
        } else {
 
            CurrentIndex += 1;
 
            if ( CurrentIndex <= LastIndex ) {
 
                NT_ASSERT( ByteCount != 0 );
 
                FatGetNextMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                    CurrentIndex,
                                    &NextVbo,
                                    &NextLbo,
                                    &NextByteCount );
 
                NT_ASSERT( NextVbo == Vbo );
            }
        }
    } // while ( CurrentIndex <= LastIndex )
 
    //
    //  If we didn't get enough associated Irps going to make this asynchronous, we
    //  twiddle our thumbs and wait for those we did launch to complete.
    //
 
    if (IrpCount) {
 
        while (Irp->AssociatedIrp.IrpCount != IrpCount) {
 
            KeDelayExecutionThread (KernelMode, FALSE, &Fat30Milliseconds);
        }
 
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
 
    DebugTrace(-1, Dbg, "FatPagingFileIo -> VOID\n", 0);
    return;
}

Referenced by _Function_class_(), and FatOverflowPagingFileRead().

FatPerformDevIoCtrl()

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
	)

Definition at line 3621 of file deviosup.c.

{
    NTSTATUS Status;
    PIRP Irp;
    KEVENT Event;
    IO_STATUS_BLOCK LocalIosb;
    PIO_STATUS_BLOCK IosbToUse = &LocalIosb;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check if the user gave us an Iosb.
    //
 
    if (ARGUMENT_PRESENT( Iosb )) {
 
        IosbToUse = Iosb;
    }
 
    IosbToUse->Status = 0;
    IosbToUse->Information = 0;
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    Irp = IoBuildDeviceIoControlRequest( IoControlCode,
                                         Device,
                                         InputBuffer,
                                         InputBufferLength,
                                         OutputBuffer,
                                         OutputBufferLength,
                                         InternalDeviceIoControl,
                                         &Event,
                                         IosbToUse );
 
    if (Irp == NULL) {
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (OverrideVerify) {
 
        SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
    }
 
    Status = IoCallDriver( Device, Irp );
 
    //
    //  We check for device not ready by first checking Status
    //  and then if status pending was returned, the Iosb status
    //  value.
    //
 
    if (Status == STATUS_PENDING) {
 
        (VOID) KeWaitForSingleObject( &Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );
 
        Status = IosbToUse->Status;
    }
 
    return Status;
}

Referenced by _Requires_lock_held_(), and FatScanForDataTrack().

FatPinEaRange()

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
	)

Definition at line 3512 of file easup.c.

{
    LARGE_INTEGER LargeVbo;
    ULONG ByteCount;
    PBCB *NextBcb;
    PVOID Buffer;
    PCHAR DestinationBuffer = NULL;
    BOOLEAN FirstPage = TRUE;
 
    PAGED_CODE();
 
    //
    //  Verify that the entire read is contained within the Ea file.
    //
 
    if (Length == 0
        || StartingVbo >= EaFcb->Header.AllocationSize.LowPart
        || (EaFcb->Header.AllocationSize.LowPart - StartingVbo) < Length) {
 
        FatRaiseStatus( IrpContext, ErrorStatus );
    }
 
    //
    //  If the read will span a section, the system addresses may not be contiguous.
    //  Allocate a separate buffer in this case.
    //
 
    if (((StartingVbo & (EA_SECTION_SIZE - 1)) + Length) > EA_SECTION_SIZE) {
 
        EaRange->Data = FsRtlAllocatePoolWithTag( PagedPool,
                                                  Length,
                                                  TAG_EA_DATA );
        EaRange->AuxilaryBuffer = TRUE;
 
        DestinationBuffer = EaRange->Data;
 
    } else {
 
        //
        //  PREfix correctly notes that if we don't decide here to have an aux buffer
        //  and the flag is up in the EaRange, we'll party on random memory since
        //  DestinationBuffer won't be set; however, this will never happen due to
        //  initialization of ea ranges and the cleanup in UnpinEaRange.
        //
 
        NT_ASSERT( EaRange->AuxilaryBuffer == FALSE );
    }
 
 
    //
    //  If the read will require more pages than our structure will hold then
    //  allocate an auxilary buffer.  We have to figure the number of pages
    //  being requested so we have to include the page offset of the first page of
    //  the request.
    //
 
    EaRange->BcbChainLength = (USHORT) (((StartingVbo & (PAGE_SIZE - 1)) + Length + PAGE_SIZE - 1) / PAGE_SIZE);
 
    if (EaRange->BcbChainLength > EA_BCB_ARRAY_SIZE) {
 
        EaRange->BcbChain = FsRtlAllocatePoolWithTag( PagedPool,
                                                      sizeof( PBCB ) * EaRange->BcbChainLength,
                                                      TAG_BCB );
 
        RtlZeroMemory( EaRange->BcbChain, sizeof( PBCB ) * EaRange->BcbChainLength );
 
    } else {
 
        EaRange->BcbChain = (PBCB *) &EaRange->BcbArray;
    }
 
    //
    //  Store the byte range data in the Ea Range structure.
    //
 
    EaRange->StartingVbo = StartingVbo;
    EaRange->Length = Length;
 
    //
    //  Compute the initial pin length.
    //
 
    ByteCount = PAGE_SIZE - (StartingVbo & (PAGE_SIZE - 1));
 
    //
    //  For each page in the range; pin the page and update the Bcb count, copy to
    //  the auxiliary buffer.
    //
 
    NextBcb = EaRange->BcbChain;
 
    while (Length != 0) {
 
        //
        //  Pin the page and remember the data start.
        //
 
        LargeVbo.QuadPart = StartingVbo;
 
        if (ByteCount > Length) {
 
            ByteCount = Length;
        }
 
        if (!CcPinRead( VirtualEaFile,
                        &LargeVbo,
                        ByteCount,
                        BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                        NextBcb,
                        &Buffer )) {
 
            //
            // Could not read the data without waiting (cache miss).
            //
 
            FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
        }
 
        //
        //  Increment the Bcb pointer and copy to the auxilary buffer if necessary.
        //
 
        NextBcb += 1;
 
        if (EaRange->AuxilaryBuffer == TRUE) {
 
            RtlCopyMemory( DestinationBuffer,
                           Buffer,
                           ByteCount );
 
            DestinationBuffer = (PCHAR) Add2Ptr( DestinationBuffer, ByteCount );
        }
 
        StartingVbo += ByteCount;
        Length -= ByteCount;
 
        //
        //  If this is the first page then update the Ea Range structure.
        //
 
        if (FirstPage) {
 
            FirstPage = FALSE;
            ByteCount = PAGE_SIZE;
 
            if (EaRange->AuxilaryBuffer == FALSE) {
 
                EaRange->Data = Buffer;
            }
        }
    }
 
    return;
}

Referenced by FatReadEaSet().

FatPinMappedData()

VOID FatPinMappedData	(	IN PIRP_CONTEXT	IrpContext,
		IN PDCB	Dcb,
		IN VBO	StartingVbo,
		IN ULONG	ByteCount,
		OUT PBCB *	Bcb
	)

Definition at line 1866 of file cachesup.c.

{
    LARGE_INTEGER Vbo;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatPinMappedData\n", 0);
    DebugTrace( 0, Dbg, "Dcb         = %p\n", Dcb);
    DebugTrace( 0, Dbg, "StartingVbo = %08lx\n", StartingVbo);
    DebugTrace( 0, Dbg, "ByteCount   = %08lx\n", ByteCount);
 
    //
    //  Call the Cache manager to perform the operation.
    //
 
    Vbo.QuadPart = StartingVbo;
 
    if (!CcPinMappedData( Dcb->Specific.Dcb.DirectoryFile,
                          &Vbo,
                          ByteCount,
                          BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                          Bcb )) {
 
        //
        // Could not pin the data without waiting (cache miss).
        //
 
        FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
    }
 
    DebugTrace(-1, Dbg, "FatReadDirectoryFile -> VOID, *BCB = %p\n", *Bcb);
 
    return;
}

FatPreallocateCloseContext()

VOID FatPreallocateCloseContext

(

IN PVCB

Vcb

)

Referenced by FatOpenEaFile().

FatPrefetchPages()

NTSTATUS FatPrefetchPages	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject,
		IN ULONG	StartingPage,
		IN ULONG	PageCount
	)

Definition at line 1929 of file cachesup.c.

{
    IO_PRIORITY_INFO PriorityInformation = {0};
    MM_PREFETCH_FLAGS PrefetchFlags;
    ULONG PageNo;
    NTSTATUS Status;
 
    PREAD_LIST ReadList = NULL;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    //  Succeed zero page prefetch requests.
    //
 
    if (PageCount == 0) {
 
        return STATUS_SUCCESS;
    }
 
    //
    //  Mm's prefetch API's "only" support fetching a ULONG worth of pages.
    //  Make sure we don't overflow.
    //
 
    ASSERT( PageCount < (PFN_NUMBER)MAXULONG );
 
    IoInitializePriorityInfo( &PriorityInformation );
 
    Status = IoRetrievePriorityInfo( IrpContext->OriginatingIrp,
                                     FileObject,
                                     IrpContext->OriginatingIrp->Tail.Overlay.Thread,
                                     &PriorityInformation );
 
    if (!NT_SUCCESS( Status)) {
 
        goto Cleanup;
    }
 
    ReadList = ExAllocatePoolWithTag( PagedPool,
                                      FIELD_OFFSET( READ_LIST, List ) + PageCount * sizeof( FILE_SEGMENT_ELEMENT ),
                                      ' taF' );
 
    if (ReadList == NULL) {
 
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Cleanup;
    }
 
    //
    //  Call Mm to prefetch data.
    //
 
    ReadList->FileObject = FileObject;
    ReadList->IsImage = FALSE;
    ReadList->NumberOfEntries = PageCount;
 
    PrefetchFlags.AllFlags = 0;
    PrefetchFlags.Flags.Priority = PriorityInformation.PagePriority;
    PrefetchFlags.Flags.RepurposePriority = SYSTEM_PAGE_PRIORITY_LEVELS - 1;
    PrefetchFlags.Flags.PriorityProtection = 1;
    ReadList->List[0].Alignment = StartingPage * PAGE_SIZE;
    ReadList->List[0].Alignment |= PrefetchFlags.AllFlags;
 
    for (PageNo = 1; PageNo < PageCount; PageNo++) {
 
        ReadList->List[PageNo].Alignment = ReadList->List[PageNo-1].Alignment + PAGE_SIZE;
    }
 
    Status = MmPrefetchPages( 1, &ReadList );
 
Cleanup:
 
    if (ReadList != NULL) {
 
        ExFreePoolWithTag( ReadList, ' taF' );
    }
 
    return Status;
}

Referenced by FatExamineFatEntries().

FatPrePostIrp()

VOID NTAPI FatPrePostIrp	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 91 of file workque.c.

{
    PIO_STACK_LOCATION IrpSp;
    PIRP_CONTEXT IrpContext;
 
    PAGED_CODE();
 
    //
    //  If there is no Irp, we are done.
    //
 
    if (Irp == NULL) {
 
        return;
    }
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    IrpContext = (PIRP_CONTEXT) Context;
 
    //
    //  If there is a STACK FatIoContext pointer, clean and NULL it.
    //
 
    if ((IrpContext->FatIoContext != NULL) &&
        FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
 
        ClearFlag(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT);
        IrpContext->FatIoContext = NULL;
    }
 
    //
    //  We need to lock the user's buffer, unless this is an MDL-read,
    //  in which case there is no user buffer.
    //
    //  **** we need a better test than non-MDL (read or write)!
 
    if (IrpContext->MajorFunction == IRP_MJ_READ ||
        IrpContext->MajorFunction == IRP_MJ_WRITE) {
 
        //
        //  If not an Mdl request, lock the user's buffer.
        //
 
        if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
 
            FatLockUserBuffer( IrpContext,
                               Irp,
                               (IrpContext->MajorFunction == IRP_MJ_READ) ?
                               IoWriteAccess : IoReadAccess,
                               (IrpContext->MajorFunction == IRP_MJ_READ) ?
                               IrpSp->Parameters.Read.Length : IrpSp->Parameters.Write.Length );
        }
 
    //
    //  We also need to check whether this is a query file operation.
    //
 
    } else if (IrpContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL
               && IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
 
        FatLockUserBuffer( IrpContext,
                           Irp,
                           IoWriteAccess,
                           IrpSp->Parameters.QueryDirectory.Length );
 
    //
    //  We also need to check whether this is a query ea operation.
    //
 
    } else if (IrpContext->MajorFunction == IRP_MJ_QUERY_EA) {
 
        FatLockUserBuffer( IrpContext,
                           Irp,
                           IoWriteAccess,
                           IrpSp->Parameters.QueryEa.Length );
 
    //
    //  We also need to check whether this is a set ea operation.
    //
 
    } else if (IrpContext->MajorFunction == IRP_MJ_SET_EA) {
 
        FatLockUserBuffer( IrpContext,
                           Irp,
                           IoReadAccess,
                           IrpSp->Parameters.SetEa.Length );
 
    //
    //  These two FSCTLs use neither I/O, so check for them.
    //
 
    } else if ((IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
               (IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST) &&
               ((IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_VOLUME_BITMAP) ||
                (IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTERS))) {
 
        FatLockUserBuffer( IrpContext,
                           Irp,
                           IoWriteAccess,
                           IrpSp->Parameters.FileSystemControl.OutputBufferLength );
    }
 
    //
    //  Mark that we've already returned pending to the user
    //
 
    IoMarkIrpPending( Irp );
 
    return;
}

Referenced by _Requires_lock_held_(), and FatFsdPostRequest().

FatQuickVerifyVcb()

VOID FatQuickVerifyVcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 1662 of file verfysup.c.

{
    PAGED_CODE();
 
    //
    //  If the real device needs to be verified we'll set the
    //  DeviceToVerify to be our real device and raise VerifyRequired.
    //
 
    if (FlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME)) {
 
        DebugTrace(0, Dbg, "The Vcb needs to be verified\n", 0);
 
        IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                      Vcb->Vpb->RealDevice );
 
        FatRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED );
    }
 
    //
    //  Based on the condition of the Vcb we'll either return to our
    //  caller or raise an error condition
    //
 
    switch (Vcb->VcbCondition) {
 
    case VcbGood:
 
        DebugTrace(0, Dbg, "The Vcb is good\n", 0);
 
        //
        //  Do a check here of an operation that would try to modify a
        //  write protected media.
        //
 
        if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
            ((IrpContext->MajorFunction == IRP_MJ_WRITE) ||
             (IrpContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
             (IrpContext->MajorFunction == IRP_MJ_SET_EA) ||
             (IrpContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
             (IrpContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION) ||
             (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
              IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST &&
              IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp)->Parameters.FileSystemControl.FsControlCode ==
                FSCTL_MARK_VOLUME_DIRTY))) {
 
            //
            //  Set the real device for the pop-up info, and set the verify
            //  bit in the device object, so that we will force a verify
            //  in case the user put the correct media back in.
            //
 
 
            IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                          Vcb->Vpb->RealDevice );
 
            FatMarkDevForVerifyIfVcbMounted(Vcb);
 
            FatRaiseStatus( IrpContext, STATUS_MEDIA_WRITE_PROTECTED );
        }
 
        break;
 
    case VcbNotMounted:
 
        DebugTrace(0, Dbg, "The Vcb is not mounted\n", 0);
 
        //
        //  Set the real device for the pop-up info, and set the verify
        //  bit in the device object, so that we will force a verify
        //  in case the user put the correct media back in.
        //
 
        IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                      Vcb->Vpb->RealDevice );
 
        FatRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
 
        break;
 
    case VcbBad:
 
        DebugTrace(0, Dbg, "The Vcb is bad\n", 0);
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DISMOUNTED )) {
 
            FatRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
        } else {
 
            FatRaiseStatus( IrpContext, STATUS_FILE_INVALID );
        }
        break;
 
    default:
 
        DebugDump("Invalid VcbCondition\n", 0, Vcb);
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( Vcb->VcbCondition, 0, 0 );
    }
}

Referenced by _Requires_lock_held_(), and FatVerifyVcb().

FatReadEaSet()

VOID FatReadEaSet	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN USHORT	EaHandle,
		IN POEM_STRING	FileName,
		IN BOOLEAN	ReturnEntireSet,
		OUT PEA_RANGE	EaSetRange
	)

Definition at line 1306 of file easup.c.

{
    ULONG BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
    ULONG EaOffsetVbo;
    EA_RANGE EaOffsetRange;
    USHORT EaOffsetCluster;
 
    EA_RANGE EaHeaderRange;
    PEA_FILE_HEADER EaHeader;
 
    ULONG EaSetVbo;
    PEA_SET_HEADER EaSet;
 
    ULONG CbList;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( FileName );
 
    DebugTrace(+1, Dbg, "FatReadEaSet\n", 0);
    DebugTrace( 0, Dbg, "  Vcb      = %p\n", Vcb);
 
    //
    //  Verify that the Ea index has a legal value.  Raise status
    //  STATUS_NONEXISTENT_EA_ENTRY if illegal.
    //
 
    if (EaHandle < MIN_EA_HANDLE
        || EaHandle > MAX_EA_HANDLE) {
 
        DebugTrace(-1, Dbg, "FatReadEaSet: Illegal handle value\n", 0);
        FatRaiseStatus( IrpContext, STATUS_NONEXISTENT_EA_ENTRY );
    }
 
    //
    //  Verify that the virtual Ea file is large enough for us to read
    //  the EaOffet table for this index.
    //
 
    EaOffsetVbo = sizeof( EA_FILE_HEADER ) + (((ULONGLONG)EaHandle >> 7) << 8);
 
    //
    //  Zero the Ea range structures.
    //
 
    RtlZeroMemory( &EaHeaderRange, sizeof( EA_RANGE ));
    RtlZeroMemory( &EaOffsetRange, sizeof( EA_RANGE ));
 
    //
    //  Use a try statement to clean up on exit.
    //
 
    _SEH2_TRY {
 
        //
        //  Pin down the EA file header.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       &EaHeaderRange,
                       0,
                       sizeof( EA_FILE_HEADER ),
                       STATUS_NONEXISTENT_EA_ENTRY );
 
        EaHeader = (PEA_FILE_HEADER) EaHeaderRange.Data;
 
        //
        //  Pin down the Ea offset table for the particular index.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       &EaOffsetRange,
                       EaOffsetVbo,
                       sizeof( EA_OFF_TABLE ),
                       STATUS_NONEXISTENT_EA_ENTRY );
 
        //
        //  Check if the specifific handle is currently being used.
        //
 
        EaOffsetCluster = *((PUSHORT) EaOffsetRange.Data
                            + (EaHandle & (MAX_EA_OFFSET_INDEX - 1)));
 
        if (EaOffsetCluster == UNUSED_EA_HANDLE) {
 
            DebugTrace(0, Dbg, "FatReadEaSet: Ea handle is unused\n", 0);
            FatRaiseStatus( IrpContext, STATUS_NONEXISTENT_EA_ENTRY );
        }
 
        //
        //  Compute the file offset for the Ea data.
        //
 
        EaSetVbo = (EaHeader->EaBaseTable[EaHandle >> 7] + EaOffsetCluster)
                   << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
        //
        //  Unpin the file header and offset table.
        //
 
        FatUnpinEaRange( IrpContext, &EaHeaderRange );
        FatUnpinEaRange( IrpContext, &EaOffsetRange );
 
        //
        //  Pin the ea set.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       EaSetRange,
                       EaSetVbo,
                       BytesPerCluster,
                       STATUS_DATA_ERROR );
 
        //
        //  Verify that the Ea set is valid and belongs to this index.
        //  Raise STATUS_DATA_ERROR if there is a data conflict.
        //
 
        EaSet = (PEA_SET_HEADER) EaSetRange->Data;
 
        if (EaSet->Signature != EA_SET_SIGNATURE
            || EaSet->OwnEaHandle != EaHandle ) {
 
            DebugTrace(0, Dbg, "FatReadEaSet: Ea set header is corrupt\n", 0);
            FatRaiseStatus( IrpContext, STATUS_DATA_ERROR );
        }
 
        //
        //  At this point we have pinned a single cluster of Ea data.  If
        //  this represents the entire Ea data for the Ea index, we are
        //  done.  Otherwise we need to check on the entire size of
        //  of the Ea set header and whether it is contained in the allocated
        //  size of the Ea virtual file.  At that point we can unpin
        //  the partial Ea set header and repin the entire header.
        //
 
        CbList = GetcbList( EaSet );
 
        if (ReturnEntireSet
            && CbList > BytesPerCluster ) {
 
            //
            //  Round up to the cluster size.
            //
 
            CbList = (CbList + EA_CBLIST_OFFSET + BytesPerCluster - 1)
                     & ~(BytesPerCluster - 1);
 
            FatUnpinEaRange( IrpContext, EaSetRange );
 
            RtlZeroMemory( EaSetRange, sizeof( EA_RANGE ));
 
            FatPinEaRange( IrpContext,
                           Vcb->VirtualEaFile,
                           Vcb->EaFcb,
                           EaSetRange,
                           EaSetVbo,
                           CbList,
                           STATUS_DATA_ERROR );
        }
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatReadEaSet );
 
        //
        //  Unpin the Ea base and offset tables if locked down.
        //
 
        FatUnpinEaRange( IrpContext, &EaHeaderRange );
        FatUnpinEaRange( IrpContext, &EaOffsetRange );
 
        DebugTrace(-1, Dbg, "FatReadEaSet:  Exit\n", 0);
    } _SEH2_END;
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), and FatReadEaSet().

FatReadVolumeFile()

VOID FatReadVolumeFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN VBO	StartingVbo,
		IN ULONG	ByteCount,
		OUT PBCB *	Bcb,
		OUT PVOID *	Buffer
	)

Definition at line 102 of file cachesup.c.

{
    LARGE_INTEGER Vbo;
 
    PAGED_CODE();
 
    //
    //  Check to see that all references are within the Bios Parameter Block
    //  or the fat(s).  A special case is made when StartingVbo == 0 at
    //  mounting time since we do not know how big the fat is.
    //
 
    NT_ASSERT( ((StartingVbo == 0) || ((StartingVbo + ByteCount) <= (ULONG)
            (FatRootDirectoryLbo( &Vcb->Bpb ) + PAGE_SIZE))));
 
    DebugTrace(+1, Dbg, "FatReadVolumeFile\n", 0);
    DebugTrace( 0, Dbg, "Vcb         = %p\n", Vcb);
    DebugTrace( 0, Dbg, "StartingVbo = %08lx\n", StartingVbo);
    DebugTrace( 0, Dbg, "ByteCount   = %08lx\n", ByteCount);
 
    //
    //  Call the Cache manager to attempt the transfer.
    //
 
    Vbo.QuadPart = StartingVbo;
 
    if (!CcMapData( Vcb->VirtualVolumeFile,
                    &Vbo,
                    ByteCount,
                    BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                    Bcb,
                    Buffer )) {
 
        NT_ASSERT( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
        //
        // Could not read the data without waiting (cache miss).
        //
 
        FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
    }
 
    DbgDoit( IrpContext->PinCount += 1 )
 
    DebugTrace(-1, Dbg, "FatReadVolumeFile -> VOID, *BCB = %p\n", *Bcb);
 
    return;
}

Referenced by FatCheckDirtyBit(), FatExamineFatEntries(), and FatLookupFatEntry().

FatReleaseVolumeFromClose()

VOID FatReleaseVolumeFromClose

(

IN PVOID

Vcb

)

FatRemoveMcbEntry()

VOID FatRemoveMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		IN ULONG	SectorCount
	)

Definition at line 599 of file fsctrl.c.

{
    PAGED_CODE();
 
    if ((SectorCount) && (SectorCount != 0xFFFFFFFF)) {
 
        SectorCount--;
        SectorCount >>= MCB_SCALE_LOG2;
        SectorCount++;
    }
 
    Vbo >>= MCB_SCALE_LOG2;
 
#if DBG
    _SEH2_TRY {
#endif
 
        FsRtlRemoveLargeMcbEntry( Mcb,
                                  (LONGLONG) Vbo,
                                  (LONGLONG) SectorCount);
 
#if DBG
    } _SEH2_EXCEPT(FatBugCheckExceptionFilter( _SEH2_GetExceptionInformation() )) {
 
          NOTHING;
    } _SEH2_END;
#endif
 
}

Referenced by _Requires_lock_held_(), FatCloseEaFile(), and FatTearDownAllocationSupport().

FatRemoveNames()

VOID FatRemoveNames	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb
	)

Definition at line 222 of file splaysup.c.

{
    PDCB Parent;
    PRTL_SPLAY_LINKS NewRoot;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    Parent = Fcb->ParentDcb;
 
    //
    //  We used to assert this condition, but it really isn't good.  If
    //  someone rapidly renames a directory multiple times and we can't
    //  flush the lower fcbs fast enough (that didn't go away synch.)
    //  well, well hit some of them again.
    //
    //  NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE ));
    //
 
    if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
 
        //
        //  Delete the node short name.
        //
 
        NewRoot = RtlDelete(&Fcb->ShortName.Links);
 
        Parent->Specific.Dcb.RootOemNode = NewRoot;
 
        //
        //  Now check for the presence of long name and delete it.
        //
 
        if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME )) {
 
            NewRoot = RtlDelete(&Fcb->LongName.Oem.Links);
 
            Parent->Specific.Dcb.RootOemNode = NewRoot;
 
            RtlFreeOemString( &Fcb->LongName.Oem.Name.Oem );
 
            ClearFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
        }
 
        if (FlagOn( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME )) {
 
            NewRoot = RtlDelete(&Fcb->LongName.Unicode.Links);
 
            Parent->Specific.Dcb.RootUnicodeNode = NewRoot;
 
            RtlFreeUnicodeString( &Fcb->LongName.Unicode.Name.Unicode );
 
            ClearFlag( Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME );
        }
 
        ClearFlag( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE );
    }
 
    return;
}

Referenced by _Requires_lock_held_(), FatDeleteFcb(), FatInsertName(), and FatSetRenameInfo().

FatRepinBcb()

VOID FatRepinBcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PBCB	Bcb
	)

Definition at line 1317 of file cachesup.c.

{
    PREPINNED_BCBS Repinned;
    ULONG i;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatRepinBcb\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
    DebugTrace( 0, Dbg, "Bcb        = %p\n", Bcb );
 
    //
    //  The algorithm is to search the list of repinned records until
    //  we either find a match for the bcb or we find a null slot.
    //
 
    Repinned = &IrpContext->Repinned;
 
    while (TRUE) {
 
        //
        //  For every entry in the repinned record check if the bcb's
        //  match or if the entry is null.  If the bcb's match then
        //  we've done because we've already repinned this bcb, if
        //  the entry is null then we know, because it's densely packed,
        //  that the bcb is not in the list so add it to the repinned
        //  record and repin it.
        //
 
        for (i = 0; i < REPINNED_BCBS_ARRAY_SIZE; i += 1) {
 
            if (Repinned->Bcb[i] == Bcb) {
 
                DebugTrace(-1, Dbg, "FatRepinBcb -> VOID\n", 0 );
                return;
            }
 
            if (Repinned->Bcb[i] == NULL) {
 
                Repinned->Bcb[i] = Bcb;
                CcRepinBcb( Bcb );
 
                DebugTrace(-1, Dbg, "FatRepinBcb -> VOID\n", 0 );
                return;
            }
        }
 
        //
        //  We finished checking one repinned record so now locate the next
        //  repinned record,  If there isn't one then allocate and zero out
        //  a new one.
        //
 
        if (Repinned->Next == NULL) {
 
            Repinned->Next = FsRtlAllocatePoolWithTag( PagedPool,
                                                       sizeof(REPINNED_BCBS),
                                                       TAG_REPINNED_BCB );
 
            RtlZeroMemory( Repinned->Next, sizeof(REPINNED_BCBS) );
        }
 
        Repinned = Repinned->Next;
    }
}

FatScanForDataTrack()

BOOLEAN FatScanForDataTrack	(	IN PIRP_CONTEXT	IrpContext,
		IN PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 3828 of file strucsup.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
 
    ULONG LocalTrackCount;
    ULONG LocalTocLength;
 
    PCDROM_TOC CdromToc;
    BOOLEAN Result = FALSE;
 
    PAGED_CODE();
 
    CdromToc = FsRtlAllocatePoolWithTag( PagedPool,
                                         sizeof( CDROM_TOC ),
                                         TAG_IO_BUFFER );
 
    RtlZeroMemory( CdromToc, sizeof( CDROM_TOC ));
 
    _SEH2_TRY {
 
        //
        //  Go ahead and read the table of contents
        //
 
        Status = FatPerformDevIoCtrl( IrpContext,
                                     IOCTL_CDROM_READ_TOC,
                                     TargetDeviceObject,
                                     NULL,
                                     0,
                                     CdromToc,
                                     sizeof( CDROM_TOC ),
                                     FALSE,
                                     TRUE,
                                     &Iosb );
 
        //
        //  Nothing to process if this request fails.
        //
 
        if (Status != STATUS_SUCCESS) {
 
            //
            //  If we get the special error indicating a failed TOC read on PD media just
            //  plow ahead with the mount (see comments above).
            //
 
            if ((Status == STATUS_IO_DEVICE_ERROR) || (Status == STATUS_INVALID_DEVICE_REQUEST)) {
 
                Result = TRUE;
 
            }
 
            try_leave( NOTHING );
        }
 
        //
        //  Get the number of tracks and stated size of this structure.
        //
 
        LocalTrackCount = CdromToc->LastTrack - CdromToc->FirstTrack + 1;
        LocalTocLength = PtrOffset( CdromToc, &CdromToc->TrackData[LocalTrackCount + 1] );
 
        //
        //  Get out if there is an immediate problem with the TOC,  or more than
        //  one track.
        //
 
        if ((LocalTocLength > Iosb.Information) ||
            (CdromToc->FirstTrack > CdromToc->LastTrack) ||
            (LocalTrackCount != 1)) {
 
            try_leave( NOTHING);
        }
 
        //
        //  Is it a data track?  DVD-RAM reports single,  data,  track.
        //
 
        Result = BooleanFlagOn( CdromToc->TrackData[ 0].Control, 0x04 );
    }
    _SEH2_FINALLY {
 
        ExFreePool( CdromToc);
    } _SEH2_END;
 
    return Result;
}

FatSetFileObject()

VOID FatSetFileObject	(	IN PFILE_OBJECT FileObject	OPTIONAL,
		IN TYPE_OF_OPEN	TypeOfOpen,
		IN PVOID	VcbOrFcbOrDcb,
		IN PCCB Ccb	OPTIONAL
	)

Definition at line 39 of file filobsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSetFileObject, FileObject = %p\n", FileObject );
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
 
    NT_ASSERT(((TypeOfOpen == UnopenedFileObject))
 
                ||
 
           ((TypeOfOpen == UserFileOpen) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == EaFile) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
            (Ccb == NULL))
 
                ||
 
           ((TypeOfOpen == UserDirectoryOpen) &&
            ((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == UserVolumeOpen) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == VirtualVolumeFile) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
            (Ccb == NULL))
 
                ||
 
           ((TypeOfOpen == DirectoryFile) &&
            ((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
            (Ccb == NULL))
            );
 
 
    UNREFERENCED_PARAMETER( TypeOfOpen );
 
    //
    //  If we were given an Fcb, Dcb, or Vcb, we have some processing to do.
    //
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    if ( VcbOrFcbOrDcb != NULL ) {
 
        //
        //  Set the Vpb field in the file object, and if we were given an
        //  Fcb or Dcb move the field over to point to the nonpaged Fcb/Dcb
        //
 
        if (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) {
 
            FileObject->Vpb = ((PVCB)VcbOrFcbOrDcb)->Vpb;
 
        } else {
 
            FileObject->Vpb = ((PFCB)VcbOrFcbOrDcb)->Vcb->Vpb;
 
            //
            //  If this is a temporary file, note it in the FcbState
            //
 
            if (FlagOn(((PFCB)VcbOrFcbOrDcb)->FcbState, FCB_STATE_TEMPORARY)) {
 
                SetFlag(FileObject->Flags, FO_TEMPORARY_FILE);
            }
        }
    }
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    //
    //  Now set the fscontext fields of the file object
    //
 
    if (ARGUMENT_PRESENT( FileObject )) {
 
        FileObject->FsContext  = VcbOrFcbOrDcb;
        FileObject->FsContext2 = Ccb;
    }
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatSetFileObject -> VOID\n", 0);
 
    return;
}

FatSetFullNameInFcb()

VOID FatSetFullNameInFcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ PUNICODE_STRING	FinalName
	)

Definition at line 6719 of file create.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    NT_ASSERT( Fcb->FullFileName.Buffer == NULL );
 
    //
    //  Prefer the ExactCaseLongName of the file for this operation, if set.  In
    //  this way we avoid building the fullname with a short filename.  Several
    //  operations assume this - the FinalNameLength in particular is the Lfn
    //  (if existant) length, and we use this to crack the fullname in paths
    //  such as the FsRtlNotify caller.
    //
    //  If the caller specified a particular name and it is short, it is the
    //  case that the long name was set up.
    //
 
    if (Fcb->ExactCaseLongName.Buffer) {
 
        NT_ASSERT( Fcb->ExactCaseLongName.Length != 0 );
        FinalName = &Fcb->ExactCaseLongName;
    }
 
    //
    //  Special case the root.
    //
 
    if (NodeType(Fcb->ParentDcb) == FAT_NTC_ROOT_DCB) {
 
        Fcb->FullFileName.Length =
        Fcb->FullFileName.MaximumLength = sizeof(WCHAR) + FinalName->Length;
 
        Fcb->FullFileName.Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                             Fcb->FullFileName.Length,
                                                             TAG_FILENAME_BUFFER );
 
        Fcb->FullFileName.Buffer[0] = L'\\';
 
        RtlCopyMemory( &Fcb->FullFileName.Buffer[1],
                       &FinalName->Buffer[0],
                       FinalName->Length );
 
    } else {
 
        PUNICODE_STRING Prefix;
 
        Prefix = &Fcb->ParentDcb->FullFileName;
 
        //
        //  It is possible our parent's full filename is not set.  Simply fail
        //  this attempt.
        //
 
        if (Prefix->Buffer == NULL) {
 
            return;
        }
 
        Fcb->FullFileName.Length =
        Fcb->FullFileName.MaximumLength = Prefix->Length + sizeof(WCHAR) + FinalName->Length;
 
        Fcb->FullFileName.Buffer = FsRtlAllocatePoolWithTag( PagedPool,
                                                             Fcb->FullFileName.Length,
                                                             TAG_FILENAME_BUFFER );
 
        RtlCopyMemory( &Fcb->FullFileName.Buffer[0],
                       &Prefix->Buffer[0],
                       Prefix->Length );
 
        Fcb->FullFileName.Buffer[Prefix->Length / sizeof(WCHAR)] = L'\\';
 
        RtlCopyMemory( &Fcb->FullFileName.Buffer[(Prefix->Length / sizeof(WCHAR)) + 1],
                       &FinalName->Buffer[0],
                       FinalName->Length );
 
    }
}

Referenced by FatSetRenameInfo().

FatSetupAllocationSupport()

VOID FatSetupAllocationSupport	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 359 of file allocsup.c.

{
    ULONG BitIndex;
    ULONG ClustersDescribableByFat;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSetupAllocationSupport\n", 0);
    DebugTrace( 0, Dbg, "  Vcb = %p\n", Vcb);
 
    //
    //  Compute a number of fields for Vcb.AllocationSupport
    //
 
    Vcb->AllocationSupport.RootDirectoryLbo = FatRootDirectoryLbo( &Vcb->Bpb );
    Vcb->AllocationSupport.RootDirectorySize = FatRootDirectorySize( &Vcb->Bpb );
 
    Vcb->AllocationSupport.FileAreaLbo = FatFileAreaLbo( &Vcb->Bpb );
 
    Vcb->AllocationSupport.NumberOfClusters = FatNumberOfClusters( &Vcb->Bpb );
 
    Vcb->AllocationSupport.FatIndexBitSize = FatIndexBitSize( &Vcb->Bpb );
 
    Vcb->AllocationSupport.LogOfBytesPerSector = FatLogOf(Vcb->Bpb.BytesPerSector);
    Vcb->AllocationSupport.LogOfBytesPerCluster = FatLogOf(FatBytesPerCluster( &Vcb->Bpb ));
    Vcb->AllocationSupport.NumberOfFreeClusters = 0;
 
 
    //
    //  Deal with a bug in DOS 5 format, if the Fat is not big enough to
    //  describe all the clusters on the disk, reduce this number.  We expect
    //  that fat32 volumes will not have this problem.
    //
    //  Turns out this was not a good assumption.  We have to do this always now.
    //
 
    ClustersDescribableByFat = ( ((FatIsFat32(Vcb)? Vcb->Bpb.LargeSectorsPerFat :
                                                    Vcb->Bpb.SectorsPerFat) *
                                  Vcb->Bpb.BytesPerSector * 8)
                                 / FatIndexBitSize(&Vcb->Bpb) ) - 2;
 
    if (Vcb->AllocationSupport.NumberOfClusters > ClustersDescribableByFat) {
 
        Vcb->AllocationSupport.NumberOfClusters = ClustersDescribableByFat;
    }
 
    //
    //  Extend the virtual volume file to include the Fat
    //
 
    {
        CC_FILE_SIZES FileSizes;
 
        FileSizes.AllocationSize.QuadPart =
        FileSizes.FileSize.QuadPart = (FatReservedBytes( &Vcb->Bpb ) +
                                       FatBytesPerFat( &Vcb->Bpb ));
        FileSizes.ValidDataLength = FatMaxLarge;
 
        if ( Vcb->VirtualVolumeFile->PrivateCacheMap == NULL ) {
 
            FatInitializeCacheMap( Vcb->VirtualVolumeFile,
                                   &FileSizes,
                                   TRUE,
                                   &FatData.CacheManagerNoOpCallbacks,
                                   Vcb );
 
        } else {
 
            CcSetFileSizes( Vcb->VirtualVolumeFile, &FileSizes );
        }
    }
 
    _SEH2_TRY {
 
        if (FatIsFat32(Vcb) &&
            Vcb->AllocationSupport.NumberOfClusters > MAX_CLUSTER_BITMAP_SIZE) {
 
            Vcb->NumberOfWindows = (Vcb->AllocationSupport.NumberOfClusters +
                                    MAX_CLUSTER_BITMAP_SIZE - 1) /
                                   MAX_CLUSTER_BITMAP_SIZE;
 
        } else {
 
            Vcb->NumberOfWindows = 1;
        }
 
        Vcb->Windows = FsRtlAllocatePoolWithTag( PagedPool,
                                                 Vcb->NumberOfWindows * sizeof(FAT_WINDOW),
                                                 TAG_FAT_WINDOW );
 
        RtlInitializeBitMap( &Vcb->FreeClusterBitMap,
                             NULL,
                             0 );
 
        //
        //  Chose a FAT window to begin operation in.
        //
 
        if (Vcb->NumberOfWindows > 1) {
 
            //
            //  Read the fat and count up free clusters.  We bias by the two reserved
            //  entries in the FAT.
            //
 
            FatExamineFatEntries( IrpContext, Vcb,
                                  2,
                                  Vcb->AllocationSupport.NumberOfClusters + 2 - 1,
                                  TRUE,
                                  NULL,
                                  NULL);
 
 
            //
            //  Pick a window to begin allocating from
            //
 
            Vcb->CurrentWindow = &Vcb->Windows[ FatSelectBestWindow( Vcb)];
 
        } else {
 
            Vcb->CurrentWindow = &Vcb->Windows[0];
 
            //
            //  Carefully bias ourselves by the two reserved entries in the FAT.
            //
 
            Vcb->CurrentWindow->FirstCluster = 2;
            Vcb->CurrentWindow->LastCluster = Vcb->AllocationSupport.NumberOfClusters + 2 - 1;
        }
 
        //
        //  Now transition to the FAT window we have chosen.
        //
 
        FatExamineFatEntries( IrpContext, Vcb,
                              0,
                              0,
                              FALSE,
                              Vcb->CurrentWindow,
                              NULL);
 
        //
        //  Now set the ClusterHint to the first free bit in our favorite
        //  window (except the ClusterHint is off by two).
        //
 
        Vcb->ClusterHint =
            (BitIndex = RtlFindClearBits( &Vcb->FreeClusterBitMap, 1, 0 )) != -1 ?
                BitIndex + 2 : 2;
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatSetupAllocationSupport );
 
        //
        //  If we hit an exception, back out.
        //
 
        if (_SEH2_AbnormalTermination()) {
 
            FatTearDownAllocationSupport( IrpContext, Vcb );
        }
    } _SEH2_END;
 
    return;
}

Referenced by FatSetupAllocationSupport().

FatSingleAsync()

VOID FatSingleAsync	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN LBO	Lbo,
		IN ULONG	ByteCount,
		IN PIRP	Irp
	)

Definition at line 1990 of file deviosup.c.

{
    PIO_STACK_LOCATION IrpSp;
    PFAT_IO_CONTEXT Context;
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
#endif
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSingleAsync\n", 0);
    DebugTrace( 0, Dbg, "MajorFunction = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "Vcb           = %p\n", Vcb );
    DebugTrace( 0, Dbg, "Lbo           = %08lx\n", Lbo);
    DebugTrace( 0, Dbg, "ByteCount     = %08lx\n", ByteCount);
    DebugTrace( 0, Dbg, "Irp           = %p\n", Irp );
 
    //
    //  If this I/O originating during FatVerifyVolume, bypass the
    //  verify logic.
    //
 
    if (Vcb->VerifyThread == KeGetCurrentThread()) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
    }
 
    //
    //  Set up the completion routine address in our stack frame.
    //
 
    IoSetCompletionRoutine( Irp,
                            FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) ?
                            &FatSingleSyncCompletionRoutine :
                            &FatSingleAsyncCompletionRoutine,
                            IrpContext->FatIoContext,
                            TRUE,
                            TRUE,
                            TRUE );
 
    //
    //  Setup the next IRP stack location in the associated Irp for the disk
    //  driver beneath us.
    //
 
    IrpSp = IoGetNextIrpStackLocation( Irp );
 
    //
    //  Setup the Stack location to do a read from the disk driver.
    //
 
    IrpSp->MajorFunction = IrpContext->MajorFunction;
    IrpSp->Parameters.Read.Length = ByteCount;
    IrpSp->Parameters.Read.ByteOffset.QuadPart = Lbo;
 
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
#endif
 
    //
    //  If this Irp is the result of a WriteThough operation,
    //  tell the device to write it through.
    //
 
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH )) {
 
        SetFlag( IrpSp->Flags, SL_WRITE_THROUGH );
    }
 
    //
    //  If this I/O requires override verify, bypass the verify logic.
    //
 
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY )) {
 
        SetFlag( IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
    }
 
    //
    //  For async requests if we acquired locks, transition the lock owners to an
    //  object, since when we return this thread could go away before request
    //  completion, and the resource package may try to boost priority.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ) &&
        FlagOn( IrpContext->FatIoContext->Wait.Async.ResourceThreadId, 3 )) {
 
        Context = IrpContext->FatIoContext;
 
        if (Context->Wait.Async.Resource != NULL) {
 
            ExSetResourceOwnerPointer( Context->Wait.Async.Resource,
                                       (PVOID)Context->Wait.Async.ResourceThreadId );
        }
 
        if (Context->Wait.Async.Resource2 != NULL) {
 
            ExSetResourceOwnerPointer( Context->Wait.Async.Resource2,
                                       (PVOID)Context->Wait.Async.ResourceThreadId );
        }
    }
 
    //
    //  Back up a copy of the IrpContext flags for later use in async completion.
    //
 
    IrpContext->FatIoContext->IrpContextFlags = IrpContext->Flags;
 
    //
    //  Issue the read request
    //
 
    DebugDoit( FatIoCallDriverCount += 1);
 
    //
    //  If IoCallDriver returns an error, it has completed the Irp
    //  and the error will be caught by our completion routines
    //  and dealt with as a normal IO error.
    //
 
    (VOID)FatLowLevelReadWrite( IrpContext,
                                Vcb->TargetDeviceObject,
                                Irp,
                                Vcb );
 
    //
    //  We just issued an IO to the storage stack, update the counters indicating so.
    //
 
    if (FatDiskAccountingEnabled) {
 
        FatUpdateIOCountersPCW( IsAWrite, ByteCount );
    }
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatSingleAsync -> VOID\n", 0);
 
    return;
}

Referenced by _Requires_lock_held_().

FatSpaceInName()

BOOLEAN FatSpaceInName	(	IN PIRP_CONTEXT	IrpContext,
		IN PUNICODE_STRING	UnicodeName
	)

Definition at line 1003 of file namesup.c.

{
    ULONG i;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    for (i=0; i < UnicodeName->Length/sizeof(WCHAR); i++) {
 
        if (UnicodeName->Buffer[i] == L' ') {
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by FatSetRenameInfo().

FatStringTo8dot3()

VOID FatStringTo8dot3	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ OEM_STRING	InputString,
		_Out_writes_bytes_(11) PFAT8DOT3	Output8dot3
	)

Definition at line 79 of file namesup.c.

{
    ULONG i;
    ULONG j;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatStringTo8dot3\n", 0);
    DebugTrace( 0, Dbg, "InputString = %Z\n", &InputString);
 
    NT_ASSERT( InputString.Length <= 12 );
 
    //
    //  Make the output name all blanks
    //
 
    RtlFillMemory( Output8dot3, 11, UCHAR_SP );
 
    //
    //  Copy over the first part of the file name.  Stop when we get to
    //  the end of the input string or a dot.
    //
 
    for (i = 0;
         (i < (ULONG)InputString.Length) && (InputString.Buffer[i] != '.') && (i < 11);
         i += 1) {
 
        (*Output8dot3)[i] = InputString.Buffer[i];
    }
 
    //
    //  Check if we need to process an extension
    //
 
    if (i < (ULONG)InputString.Length) {
 
        //
        //  Make sure we have a dot and then skip over it.
        //
 
        NT_ASSERT( (InputString.Length - i) <= 4 );
        NT_ASSERT( InputString.Buffer[i] == '.' );
 
        i += 1;
 
        //
        //  Copy over the extension.  Stop when we get to the
        //  end of the input string.
        //
 
        for (j = 8; (i < (ULONG)InputString.Length); j += 1, i += 1) {
 
            (*Output8dot3)[j] = InputString.Buffer[i];
        }
    }
 
    //
    //  Before we return check if we should translate the first character
    //  from 0xe5 to 0x5.
    //
 
    if ((*Output8dot3)[0] == 0xe5) {
 
        (*Output8dot3)[0] = FAT_DIRENT_REALLY_0E5;
    }
 
    DebugTrace(-1, Dbg, "FatStringTo8dot3 -> (VOID)\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by _Requires_lock_held_(), FatConstructDirent(), and FatSetRenameInfo().

FatSyncUninitializeCacheMap()

VOID FatSyncUninitializeCacheMap	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 1812 of file cachesup.c.

{
    CACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent;
    NTSTATUS WaitStatus;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    KeInitializeEvent( &UninitializeCompleteEvent.Event,
                       SynchronizationEvent,
                       FALSE);
 
    CcUninitializeCacheMap( FileObject,
                            &FatLargeZero,
                            &UninitializeCompleteEvent );
 
    //
    //  Now wait for the cache manager to finish purging the file.
    //  This will garentee that Mm gets the purge before we
    //  delete the Vcb.
    //
 
#ifdef _MSC_VER
#pragma prefast( suppress: 28931, "we use WaitStatus in the debug assert, in fre builds prefast complains it's unused" )
#endif
    WaitStatus = KeWaitForSingleObject( &UninitializeCompleteEvent.Event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);
 
    NT_ASSERT(WaitStatus == STATUS_SUCCESS);
}

Referenced by _Requires_lock_held_(), and FatCloseEaFile().

FatTearDownAllocationSupport()

VOID FatTearDownAllocationSupport	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 549 of file allocsup.c.

{
    DebugTrace(+1, Dbg, "FatTearDownAllocationSupport\n", 0);
    DebugTrace( 0, Dbg, "  Vcb = %p\n", Vcb);
 
    PAGED_CODE();
 
    //
    //  If there are FAT buckets, free them.
    //
 
    if ( Vcb->Windows != NULL ) {
 
        ExFreePool( Vcb->Windows );
        Vcb->Windows = NULL;
    }
 
    //
    //  Free the memory associated with the free cluster bitmap.
    //
 
    if ( Vcb->FreeClusterBitMap.Buffer != NULL ) {
 
        ExFreePool( Vcb->FreeClusterBitMap.Buffer );
 
        //
        //  NULL this field as an flag.
        //
 
        Vcb->FreeClusterBitMap.Buffer = NULL;
    }
 
    //
    //  And remove all the runs in the dirty fat Mcb
    //
 
    FatRemoveMcbEntry( Vcb, &Vcb->DirtyFatMcb, 0, 0xFFFFFFFF );
 
    DebugTrace(-1, Dbg, "FatTearDownAllocationSupport -> (VOID)\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by FatDeleteVcb(), and FatSetupAllocationSupport().

FatTearDownVcb()

VOID FatTearDownVcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 684 of file strucsup.c.

{
    PFILE_OBJECT DirectoryFileObject;
 
 
    PAGED_CODE();
 
    //
    //  Get rid of the virtual volume file, if we need to.
    //
 
    if (Vcb->VirtualVolumeFile != NULL) {
 
        //
        //  Uninitialize the cache
        //
 
        CcUninitializeCacheMap( Vcb->VirtualVolumeFile,
                                &FatLargeZero,
                                NULL );
 
        FsRtlTeardownPerStreamContexts( &Vcb->VolumeFileHeader );
 
        ObDereferenceObject( Vcb->VirtualVolumeFile );
 
        Vcb->VirtualVolumeFile = NULL;
    }
 
    //
    //  Close down the EA file.
    //
 
    FatCloseEaFile( IrpContext, Vcb, FALSE );
 
    //
    //  Close down the root directory stream..
    //
 
    if (Vcb->RootDcb != NULL) {
 
        DirectoryFileObject = Vcb->RootDcb->Specific.Dcb.DirectoryFile;
 
        if (DirectoryFileObject != NULL) {
 
            //
            //  Tear down this directory file.
            //
 
            CcUninitializeCacheMap( DirectoryFileObject,
                                    &FatLargeZero,
                                    NULL );
 
            Vcb->RootDcb->Specific.Dcb.DirectoryFile = NULL;
            ObDereferenceObject( DirectoryFileObject );
        }
    }
 
    //
    //  The VCB can no longer be used.
    //
 
    FatSetVcbCondition( Vcb, VcbBad );
}

FatToggleMediaEjectDisable()

NTSTATUS FatToggleMediaEjectDisable	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN BOOLEAN	PreventRemoval
	)

Definition at line 3495 of file deviosup.c.

{
    PIRP Irp;
    KIRQL SavedIrql;
    NTSTATUS Status;
    FAT_SYNC_CONTEXT SyncContext;
    PREVENT_MEDIA_REMOVAL Prevent;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If PreventRemoval is the same as VCB_STATE_FLAG_REMOVAL_PREVENTED,
    //  no-op this call, otherwise toggle the state of the flag.
    //
 
    KeAcquireSpinLock( &FatData.GeneralSpinLock, &SavedIrql );
 
    if ((PreventRemoval ^
         BooleanFlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVAL_PREVENTED)) == 0) {
 
        KeReleaseSpinLock( &FatData.GeneralSpinLock, SavedIrql );
 
        return STATUS_SUCCESS;
 
    } else {
 
        Vcb->VcbState ^= VCB_STATE_FLAG_REMOVAL_PREVENTED;
 
        KeReleaseSpinLock( &FatData.GeneralSpinLock, SavedIrql );
    }
 
    Prevent.PreventMediaRemoval = PreventRemoval;
 
    KeInitializeEvent( &SyncContext.Event, NotificationEvent, FALSE );
 
    //
    //  We build this IRP using a junk Iosb that will receive the final
    //  completion status since we won't be around for it.
    //
    // We fill in the UserIosb manually below,
    // So passing NULL for the final parameter is ok in this special case.
    //
#ifdef _MSC_VER
#pragma warning(suppress: 6387)
#endif
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_MEDIA_REMOVAL,
                                         Vcb->TargetDeviceObject,
                                         &Prevent,
                                         sizeof(PREVENT_MEDIA_REMOVAL),
                                         NULL,
                                         0,
                                         FALSE,
                                         NULL,
                                         NULL );
 
    if ( Irp != NULL ) {
 
        //
        //  Use our special completion routine which will remove the requirement that
        //  the caller must be below APC level.  All it tells us is that the Irp got
        //  back, but will not tell us if it was succesful or not.  We don't care,
        //  and there is of course no fallback if the attempt to prevent removal
        //  doesn't work for some mysterious reason.
        //
        //  Normally, all IO is done at passive level. However, MM needs to be able
        //  to issue IO with fast mutexes locked down, which raises us to APC.  The
        //  overlying IRP is set up to complete in yet another magical fashion even
        //  though APCs are disabled, and any IRPage we do in these cases has to do
        //  the same.  Marking media dirty (and toggling eject state) is one.
        //
 
        Irp->UserIosb = &Irp->IoStatus;
 
        IoSetCompletionRoutine( Irp,
                                FatSpecialSyncCompletionRoutine,
                                &SyncContext,
                                TRUE,
                                TRUE,
                                TRUE );
 
        Status = IoCallDriver( Vcb->TargetDeviceObject, Irp );
 
        if (Status == STATUS_PENDING) {
 
            (VOID) KeWaitForSingleObject( &SyncContext.Event,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL );
 
            Status = SyncContext.Iosb.Status;
        }
 
        return Status;
    }
 
    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by _Requires_lock_held_(), and FatDeferredCleanVolume().

FatTunnelFcbOrDcb()

VOID FatTunnelFcbOrDcb	(	IN PFCB	FcbOrDcb,
		IN PCCB Ccb	OPTIONAL
	)

Definition at line 652 of file dirsup.c.

{
    UNICODE_STRING ShortNameWithCase = {0};
    UNICODE_STRING DownCaseSeg;
    WCHAR ShortNameBuffer[8+1+3];
    NTSTATUS Status;
    USHORT i;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatTunnelFcbOrDcb\n", 0);
 
    if (NodeType(FcbOrDcb) == FAT_NTC_DCB) {
 
        //
        //  Directory deletion. Flush all entries from this directory in
        //  the cache for this volume
        //
 
        FsRtlDeleteKeyFromTunnelCache( &FcbOrDcb->Vcb->Tunnel,
                                       FatDirectoryKey(FcbOrDcb) );
 
    } else {
 
        //
        //  Was a file, so throw it into the tunnel cache
        //
 
        //
        //  Get the short name into UNICODE
        //
 
        ShortNameWithCase.Length = 0;
        ShortNameWithCase.MaximumLength = sizeof(ShortNameBuffer);
        ShortNameWithCase.Buffer = ShortNameBuffer;
 
#ifdef _MSC_VER
#pragma prefast( suppress:28931, "needed for debug build" )
#endif
        Status = RtlOemStringToCountedUnicodeString( &ShortNameWithCase,
                                                     &FcbOrDcb->ShortName.Name.Oem,
                                                     FALSE);
 
        NT_ASSERT(ShortNameWithCase.Length != 0);
 
        NT_ASSERT(NT_SUCCESS(Status));
 
        if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_8_LOWER_CASE | FCB_STATE_3_LOWER_CASE)) {
 
            //
            //  Have to repair the case of the short name
            //
 
            for (i = 0; i < (ShortNameWithCase.Length/sizeof(WCHAR)) &&
                        ShortNameWithCase.Buffer[i] != L'.'; i++);
 
            //
            //  Now pointing at the '.', or otherwise the end of name component
            //
 
            if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_8_LOWER_CASE)) {
 
                DownCaseSeg.Buffer = ShortNameWithCase.Buffer;
                DownCaseSeg.MaximumLength = DownCaseSeg.Length = i*sizeof(WCHAR);
 
                RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
            }
 
            i++;
 
            //
            //  Now pointing at first wchar of the extension.
            //
 
            if (FlagOn(FcbOrDcb->FcbState, FCB_STATE_3_LOWER_CASE)) {
 
                //
                //  It is not neccesarily the case that we can rely on the flag
                //  indicating that we really have an extension.
                //
 
                if ((i*sizeof(WCHAR)) < ShortNameWithCase.Length) {
                    DownCaseSeg.Buffer = &ShortNameWithCase.Buffer[i];
                    DownCaseSeg.MaximumLength = DownCaseSeg.Length = ShortNameWithCase.Length - i*sizeof(WCHAR);
 
                    RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
                }
            }
        }
 
        //
        //  ... and add it in
        //
 
        FsRtlAddToTunnelCache( &FcbOrDcb->Vcb->Tunnel,
                               FatDirectoryKey(FcbOrDcb->ParentDcb),
                               &ShortNameWithCase,
                               &FcbOrDcb->ExactCaseLongName,
                               BooleanFlagOn(Ccb->Flags, CCB_FLAG_OPENED_BY_SHORTNAME),
                               sizeof(LARGE_INTEGER),
                               &FcbOrDcb->CreationTime );
    }
 
    DebugTrace(-1, Dbg, "FatTunnelFcbOrDcb -> (VOID)\n", 0);
 
    return;
}

Referenced by _Requires_lock_held_(), and FatSetRenameInfo().

FatUnicodeRestoreShortNameCase()

VOID FatUnicodeRestoreShortNameCase	(	IN PUNICODE_STRING	ShortNameWithCase,
		IN BOOLEAN	LowerCase8,
		IN BOOLEAN	LowerCase3
	)

Definition at line 1041 of file namesup.c.

{
    USHORT i;
    UNICODE_STRING DownCaseSeg;
 
    PAGED_CODE();
 
    NT_ASSERT( ShortNameWithCase->Length <= 24 );
 
    //
    //  Have to repair the case of the short name
    //
 
    for (i = 0; i < (ShortNameWithCase->Length/sizeof(WCHAR)) &&
                ShortNameWithCase->Buffer[i] != L'.'; i++);
 
    //
    //  Now pointing at the '.', or otherwise the end of name component
    //
 
    if (LowerCase8) {
 
        DownCaseSeg.Buffer = ShortNameWithCase->Buffer;
        DownCaseSeg.MaximumLength = DownCaseSeg.Length = i*sizeof(WCHAR);
 
        RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
    }
 
    i++;
 
    //
    //  Now pointing at first wchar of the extension.
    //
 
    if (LowerCase3) {
 
        //
        //  It is not neccesarily the case that we can rely on the flag
        //  indicating that we really have an extension.
        //
 
        if ((i*sizeof(WCHAR)) < ShortNameWithCase->Length) {
            DownCaseSeg.Buffer = &ShortNameWithCase->Buffer[i];
            DownCaseSeg.MaximumLength = DownCaseSeg.Length = ShortNameWithCase->Length - i*sizeof(WCHAR);
 
            RtlDowncaseUnicodeString(&DownCaseSeg, &DownCaseSeg, FALSE);
        }
    }
 
}

FatUnicodeToUpcaseOem()

VOID FatUnicodeToUpcaseOem	(	IN PIRP_CONTEXT	IrpContext,
		IN POEM_STRING	OemString,
		IN PUNICODE_STRING	UnicodeString
	)

Definition at line 632 of file namesup.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    Status = RtlUpcaseUnicodeStringToCountedOemString( OemString,
                                                       UnicodeString,
                                                       FALSE );
 
    if (Status == STATUS_BUFFER_OVERFLOW) {
 
        OemString->Buffer = NULL;
        OemString->Length = 0;
        OemString->MaximumLength = 0;
 
        Status = RtlUpcaseUnicodeStringToCountedOemString( OemString,
                                                           UnicodeString,
                                                           TRUE );
    }
 
    if (!NT_SUCCESS(Status)) {
 
        if (Status == STATUS_UNMAPPABLE_CHARACTER) {
 
            OemString->Length = 0;
 
        } else {
 
            FatNormalizeAndRaiseStatus( IrpContext, Status );
        }
    }
 
    return;
}

Referenced by FatSetRenameInfo().

FatUnlockVolumeInternal()

NTSTATUS FatUnlockVolumeInternal	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PFILE_OBJECT FileObject	OPTIONAL
	)

Definition at line 3601 of file fsctrl.c.

{
    KIRQL SavedIrql;
    NTSTATUS Status = STATUS_NOT_LOCKED;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
    if (FlagOn(Vcb->Vpb->Flags, VPB_LOCKED) && FileObject == Vcb->FileObjectWithVcbLocked) {
 
        //
        //  This one locked it, unlock the volume
        //
 
        ClearFlag( Vcb->Vpb->Flags, (VPB_LOCKED | VPB_DIRECT_WRITES_ALLOWED) );
        ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_LOCKED );
        Vcb->FileObjectWithVcbLocked = NULL;
 
        Status = STATUS_SUCCESS;
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Status;
}

Referenced by FatUnlockVolume().

FatUnpinEaRange()

VOID FatUnpinEaRange	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_RANGE	EaRange
	)

Definition at line 3782 of file easup.c.

{
    PBCB *NextBcb;
    ULONG BcbCount;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If we allocated a auxilary buffer, deallocate it here.
    //
 
    if (EaRange->AuxilaryBuffer == TRUE) {
 
        ExFreePool( EaRange->Data );
        EaRange->AuxilaryBuffer = FALSE;
    }
 
    //
    //  Walk through the Bcb chain and unpin the data.
    //
 
    if (EaRange->BcbChain != NULL) {
 
        BcbCount = EaRange->BcbChainLength;
        NextBcb = EaRange->BcbChain;
 
        while (BcbCount--) {
 
            if (*NextBcb != NULL) {
 
                CcUnpinData( *NextBcb );
                *NextBcb = NULL;
            }
 
            NextBcb += 1;
        }
 
        //
        //  If we allocated a Bcb chain, deallocate it here.
        //
 
        if (EaRange->BcbChain != &EaRange->BcbArray[0]) {
 
            ExFreePool( EaRange->BcbChain );
        }
 
        EaRange->BcbChain = NULL;
    }
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), and FatReadEaSet().

FatUnpinRepinnedBcbs()

VOID FatUnpinRepinnedBcbs

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 1407 of file cachesup.c.

{
    IO_STATUS_BLOCK RaiseIosb;
    PREPINNED_BCBS Repinned;
    BOOLEAN WriteThroughToDisk;
    PFILE_OBJECT FileObject = NULL;
    BOOLEAN ForceVerify = FALSE;
    ULONG i;
    PFCB FcbOrDcb = NULL;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatUnpinRepinnedBcbs\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
 
    //
    //  The algorithm for this procedure is to scan the entire list of
    //  repinned records unpinning any repinned bcbs.  We start off
    //  with the first record in the irp context, and while there is a
    //  record to scan we do the following loop.
    //
 
    Repinned = &IrpContext->Repinned;
    RaiseIosb.Status = STATUS_SUCCESS;
 
    //
    //  WinSE bug #307418 "Occasional data corruption when
    //  standby/resume while copying files to removable FAT
    //  formatted media".
    //  Extract main FCB pointer from the irp context - we
    //  will need it later to detect new file creation operation.
    //
 
    if (IrpContext->MajorFunction == IRP_MJ_CREATE &&
        IrpContext->OriginatingIrp != NULL) {
        PIO_STACK_LOCATION IrpSp;
 
        IrpSp = IoGetCurrentIrpStackLocation( IrpContext->OriginatingIrp );
 
        if (IrpSp != NULL &&
            IrpSp->FileObject != NULL &&
            IrpSp->FileObject->FsContext != NULL) {
 
            FcbOrDcb = IrpSp->FileObject->FsContext;
        }
    }
 
    //
    //  If the request is write through or the media is deferred flush,
    //  unpin the bcb's write through.
    //
 
    WriteThroughToDisk = (BOOLEAN) (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH) &&
                                    IrpContext->Vcb != NULL &&
                                    (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH) ||
                                     FlagOn(IrpContext->Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH)));
 
    while (Repinned != NULL) {
 
        //
        //  For every non-null entry in the repinned record unpin the
        //  repinned entry.
        //
        //  If the this is removable media (therefore all requests write-
        //  through) and the write fails, purge the cache so that we throw
        //  away the modifications as we will be returning an error to the
        //  user.
        //
 
        for (i = 0; i < REPINNED_BCBS_ARRAY_SIZE; i += 1) {
 
            if (Repinned->Bcb[i] != NULL) {
 
                IO_STATUS_BLOCK Iosb;
 
                if (WriteThroughToDisk &&
                    FlagOn(IrpContext->Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH)) {
 
                    FileObject = CcGetFileObjectFromBcb( Repinned->Bcb[i] );
                }
 
                CcUnpinRepinnedBcb( Repinned->Bcb[i],
                                    WriteThroughToDisk,
                                    &Iosb );
 
                if (!NT_SUCCESS(Iosb.Status)) {
 
                    if (RaiseIosb.Status == STATUS_SUCCESS) {
 
                        RaiseIosb = Iosb;
                    }
 
                    //
                    //  If this was a writethrough device, purge the cache,
                    //  except for Irp major codes that either don't handle
                    //  the error paths correctly or are simple victims like
                    //  cleanup.c.
                    //
 
                    if (FileObject &&
                        (IrpContext->MajorFunction != IRP_MJ_CLEANUP) &&
                        (IrpContext->MajorFunction != IRP_MJ_FLUSH_BUFFERS) &&
                        (IrpContext->MajorFunction != IRP_MJ_SET_INFORMATION)
 
                                        &&
 
                            //
                            //  WinSE bug #307418 "Occasional data corruption when
                            //  standby/resume while copying files to removable FAT
                            //  formatted media".
                            //  Buffer unpinning for new file creation operation can
                            //  be interrupted by system syspend. As a result some BCBs
                            //  will be successfully written to the disk while others will
                            //  be kicked back with STATUS_VERIFY_REQUIRED. Since there is
                            //  is still a chance for the failed BCBs to reach the disk
                            //  after the volume verification we'll not purge them.
                            //  Instead FatCommonCreate() will unroll the file creation
                            //  changes for these pages.
                            //
 
                        !(IrpContext->MajorFunction == IRP_MJ_CREATE &&
                          Iosb.Status == STATUS_VERIFY_REQUIRED &&
                          FcbOrDcb != NULL &&
                          NodeType( FcbOrDcb ) == FAT_NTC_FCB)) {
 
                        //
                        //  The call to CcPurgeCacheSection() below will
                        //  purge the entire file from memory.  It will also
                        //  block until all the file's BCB's are pinned.
                        //
                        //  We end up in a deadlock situation of there
                        //  are any other pinned BCB's in this IRP context
                        //  so the first thing we do is search the list
                        //  for BCB's pinned in the same file and unpin
                        //  them.
                        //
                        //  We are probably not going to lose data because
                        //  it's safe to assume that all flushes will
                        //  fail after the first one fails.
                        //
 
                        ULONG j;
                        ULONG k = i + 1;
                        PREPINNED_BCBS RepinnedToPurge = Repinned;
 
                        while( RepinnedToPurge != NULL ) {
 
                            for (j = k; j < REPINNED_BCBS_ARRAY_SIZE; j++) {
 
                                if (RepinnedToPurge->Bcb[j] != NULL) {
 
                                    if (CcGetFileObjectFromBcb( RepinnedToPurge->Bcb[j] ) == FileObject) {
 
                                        CcUnpinRepinnedBcb( RepinnedToPurge->Bcb[j],
                                                            FALSE,
                                                            &Iosb );
 
                                        RepinnedToPurge->Bcb[j] = NULL;
                                    }
                                }
                            }
 
                            RepinnedToPurge = RepinnedToPurge->Next;
                            k = 0;
                        }
 
                        CcPurgeCacheSection( FileObject->SectionObjectPointer,
                                             NULL,
                                             0,
                                             FALSE );
 
                        //
                        //  Force a verify operation here since who knows
                        //  what state things are in.
                        //
 
                        ForceVerify = TRUE;
                    }
                }
 
                Repinned->Bcb[i] = NULL;
 
            }
        }
 
        //
        //  Now find the next repinned record in the list, and possibly
        //  delete the one we've just processed.
        //
 
        if (Repinned != &IrpContext->Repinned) {
 
            PREPINNED_BCBS Saved;
 
            Saved = Repinned->Next;
            ExFreePool( Repinned );
            Repinned = Saved;
 
        } else {
 
            Repinned = Repinned->Next;
            IrpContext->Repinned.Next = NULL;
        }
    }
 
    //
    //  Now if we weren't completely successful in the our unpin
    //  then raise the iosb we got
    //
 
    if (!NT_SUCCESS(RaiseIosb.Status)) {
 
        if (ForceVerify && FileObject) {
 
            SetFlag(FileObject->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
            IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                          FileObject->DeviceObject );
        }
 
        if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_RAISE )) {
            if (IrpContext->OriginatingIrp) {
                IrpContext->OriginatingIrp->IoStatus = RaiseIosb;
            }
            FatNormalizeAndRaiseStatus( IrpContext, RaiseIosb.Status );
        }
    }
 
    DebugTrace(-1, Dbg, "FatUnpinRepinnedBcbs -> VOID\n", 0 );
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonSetEa(), FatCompleteRequest_Real(), FatDeferredCleanVolume(), FatSetFsLabelInfo(), and FatSetRenameInfo().

FatVerifyOperationIsLegal()

VOID FatVerifyOperationIsLegal

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 1304 of file verfysup.c.

{
    PIRP Irp;
    PFILE_OBJECT FileObject;
 
    PAGED_CODE();
 
    Irp = IrpContext->OriginatingIrp;
 
    //
    //  If the Irp is not present, then we got here via close.
    //
    //
 
    if ( Irp == NULL ) {
 
        return;
    }
 
    FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
 
    //
    //  If there is not a file object, we cannot continue.
    //
 
    if ( FileObject == NULL ) {
 
        return;
    }
 
    //
    //  If the file object has already been cleaned up, and
    //
    //  A) This request is a paging io read or write, or
    //  B) This request is a close operation, or
    //  C) This request is a set or query info call (for Lou)
    //  D) This is an MDL complete
    //
    //  let it pass, otherwise return STATUS_FILE_CLOSED.
    //
 
    if ( FlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE) ) {
 
        PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
        if ( (FlagOn(Irp->Flags, IRP_PAGING_IO)) ||
             (IrpSp->MajorFunction == IRP_MJ_CLOSE ) ||
             (IrpSp->MajorFunction == IRP_MJ_SET_INFORMATION) ||
             (IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) ||
             ( ( (IrpSp->MajorFunction == IRP_MJ_READ) ||
                 (IrpSp->MajorFunction == IRP_MJ_WRITE) ) &&
               FlagOn(IrpSp->MinorFunction, IRP_MN_COMPLETE) ) ) {
 
            NOTHING;
 
        } else {
 
            FatRaiseStatus( IrpContext, STATUS_FILE_CLOSED );
        }
    }
 
    return;
}

Referenced by _Requires_lock_held_().

FatVerifyVcb()

VOID FatVerifyVcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

Definition at line 270 of file verfysup.c.

{
    BOOLEAN DevMarkedForVerify;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatVerifyVcb, Vcb = %p\n", Vcb );
 
    //
    //  If the verify volume flag in the device object is set
    //  this means the media has potentially changed.
    //
    //  Note that we only force this ping for create operations.
    //  For others we take a sporting chance.  If in the end we
    //  have to physically access the disk, the right thing will happen.
    //
 
    DevMarkedForVerify = BooleanFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
 
    //
    //  We ALWAYS force CREATE requests on unmounted volumes through the
    //  verify path.  These requests could have been in limbo between
    //  IoCheckMountedVpb and us, when a verify/mount took place and caused
    //  a completely different fs/volume to be mounted.  In this case the
    //  checks above may not have caught the condition, since we may already
    //  have verified (wrong volume) and decided that we have nothing to do.
    //  We want the requests to be re routed to the currently mounted volume,
    //  since they were directed at the 'drive',  not our volume.  So we take
    //  the verify path for synchronisation,  and the request will eventually
    //  be bounced back to IO with STATUS_REPARSE by our verify handler.
    //
 
    if (!DevMarkedForVerify &&
        (IrpContext->MajorFunction == IRP_MJ_CREATE) &&
        (IrpContext->OriginatingIrp != NULL)) {
 
        PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->OriginatingIrp);
 
        if ((IrpSp->FileObject->RelatedFileObject == NULL) &&
            (Vcb->VcbCondition == VcbNotMounted)) {
 
            DevMarkedForVerify = TRUE;
        }
    }
 
    //
    //  Raise any error condition otherwise.
    //
 
    if (DevMarkedForVerify) {
 
        DebugTrace(0, Dbg, "The Vcb needs to be verified\n", 0);
 
        IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                      Vcb->Vpb->RealDevice );
 
        FatNormalizeAndRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED );
    }
 
    //
    //  Check the operation is legal for current Vcb state.
    //
 
    FatQuickVerifyVcb( IrpContext, Vcb );
 
    DebugTrace(-1, Dbg, "FatVerifyVcb -> VOID\n", 0);
}

Referenced by FatFlushFat(), FatIsVolumeDirty(), and FatIsVolumeMounted().

FatVolumeUncleanCount()

ULONG FatVolumeUncleanCount	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb
	)

FatWaitSync()

VOID FatWaitSync

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 2367 of file deviosup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatWaitSync, Context = %p\n", IrpContext->FatIoContext );
 
    KeWaitForSingleObject( &IrpContext->FatIoContext->Wait.SyncEvent,
                           Executive, KernelMode, FALSE, NULL );
 
    KeClearEvent( &IrpContext->FatIoContext->Wait.SyncEvent );
 
    DebugTrace(-1, Dbg, "FatWaitSync -> VOID\n", 0 );
}

Referenced by _Requires_lock_held_(), and FatSingleNonAlignedSync().

FatZeroData()

FINISHED FatZeroData	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PFILE_OBJECT	FileObject,
		IN ULONG	StartingZero,
		IN ULONG	ByteCount
	)

Definition at line 1659 of file cachesup.c.

{
#ifndef __REACTOS__
    LARGE_INTEGER ZeroStart = {0,0};
    LARGE_INTEGER BeyondZeroEnd = {0,0};
#else
    LARGE_INTEGER ZeroStart = {{0,0}};
    LARGE_INTEGER BeyondZeroEnd = {{0,0}};
#endif
 
    ULONG SectorSize;
 
    BOOLEAN Finished;
 
    PAGED_CODE();
 
    SectorSize = (ULONG)Vcb->Bpb.BytesPerSector;
 
    ZeroStart.LowPart = (StartingZero + (SectorSize - 1)) & ~(SectorSize - 1);
 
    //
    //  Detect overflow if we were asked to zero in the last sector of the file,
    //  which must be "zeroed" already (or we're in trouble).
    //
 
    if (StartingZero != 0 && ZeroStart.LowPart == 0) {
 
        return TRUE;
    }
 
    //
    //  Note that BeyondZeroEnd can take the value 4gb.
    //
 
    BeyondZeroEnd.QuadPart = ((ULONGLONG) StartingZero + ByteCount + (SectorSize - 1))
                             & (~((LONGLONG) SectorSize - 1));
 
    //
    //  If we were called to just zero part of a sector we are in trouble.
    //
 
    if ( ZeroStart.QuadPart == BeyondZeroEnd.QuadPart ) {
 
        return TRUE;
    }
 
    Finished = CcZeroData( FileObject,
                           &ZeroStart,
                           &BeyondZeroEnd,
                           BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
    return Finished;
}

Referenced by _Requires_lock_held_().

Variable Documentation

AbsoluteClusterHint

IN PVCB IN ULONG AbsoluteClusterHint

Definition at line 345 of file fatprocs.h.

AllLowerComponent

IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING IN PUNICODE_STRING SuggestedShortName IN OUT BOOLEAN* AllLowerComponent

Definition at line 1309 of file fatprocs.h.

Referenced by FatEvaluateNameCase(), and FatSetRenameInfo().

AllLowerExtension

IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING IN PUNICODE_STRING SuggestedShortName IN OUT BOOLEAN IN OUT BOOLEAN* AllLowerExtension

Definition at line 1310 of file fatprocs.h.

Referenced by FatEvaluateNameCase(), and FatSetRenameInfo().

Allocated

IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated

Definition at line 311 of file fatprocs.h.

Referenced by _Requires_lock_held_(), AccpGetTrusteeSid(), CcRosInitializeFileCache(), CmpGetValueDataFromCache(), EmsIntHandler(), Hid_GetDescriptor(), NtfsGetFileSize(), RxDereferenceAndDeleteRxContext_Real(), and SetClassLongA().

AllocationSize

_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE _Outptr_opt_ PFILE_OBJECT _In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Out_ PIO_STATUS_BLOCK _In_opt_ PLARGE_INTEGER AllocationSize

Definition at line 322 of file fatprocs.h.

Referenced by Allocate(), AVrfInternalHeapFreeNotification(), AVrfpNtdllHeapFreeCallback(), DECLSPEC_ALIGN(), Ext2ProcessEntry(), Ext2SetFileInformation(), Ext2SupersedeOrOverWriteFile(), Ext2WriteFile(), Free(), FsRtlTest_StartTest(), FxPoolAddHeaderSize(), IoCreateFile(), IoCreateFileSpecifyDeviceObjectHint(), IopCreateFile(), NICAllocateIoResources(), NtCreatePagingFile(), NtfsSetEndOfFile(), NtfsWriteFile(), PUEFI_LoadMemoryMap(), RtlAllocateHeap(), RtlCreateBootStatusDataFile(), RtlCreateQueryDebugBuffer(), RtlpAllocateNonDedicated(), RtlpSplitEntry(), RtlReAllocateHeap(), SetNonResidentAttributeDataLength(), SetThreadStackGuarantee(), TestRelativeNames(), UDFCommonCreate(), UDFGetRetrievalPointers(), ValidateAllocations(), vfatFindDirSpace(), VfatSetAllocationSizeInformation(), and VfatWrite().

Bcb

IN PFCB IN BOOLEAN OUT PDIRENT OUT PBCB * Bcb

Definition at line 415 of file fatprocs.h.

Referenced by _CcpFlushCache(), _Requires_lock_held_(), CcCopyRead(), CcCopyWrite(), CcFlushImageSection(), CcGetFileObjectFromBcb(), CcGetFileObjectFromSectionPtrs(), CcMapData(), CcpAllocateCacheSections(), CcpBuildCacheMdl(), CcpDereferenceBcb(), CcpDereferenceCache(), CcpFindBcb(), CcpFindMatchingMap(), CcPinMappedData(), CcPinRead(), CcpMapData(), CcpMarkForExclusive(), CcpPinData(), CcpPinMappedData(), CcpReadAhead(), CcpReferenceCache(), CcpReferenceCacheExclusive(), CcPreparePinWrite(), CcRemapBcb(), CcRepinBcb(), CcSetBcbOwnerPointer(), CcSetDirtyPinnedData(), CcSetFileSizes(), CcShutdownSystem(), CcUninitializeCacheMap(), CcUnpinData(), CcUnpinDataForThread(), CcUnpinRepinnedBcb(), CcZeroData(), Ext2ExpandBlock(), Ext2GetBlock(), Ext2TruncateBlock(), Ext2ZeroData(), FatCommonQueryEa(), FatCommonSetEa(), FatExamineFatEntries(), FatFlushFat(), FatPinMappedData(), FatQueryEaInfo(), FatReadVolumeFile(), FatRepinBcb(), main(), MapInAnotherThread(), PerformTest(), PinInAnotherThread(), PinInAnotherThreadExclusive(), and submit_bh_mdl().

Buffer

IN BOOLEAN IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer

Definition at line 416 of file fatprocs.h.

ByteCount

IN PIRP IN PFCB IN ULONG IN ULONG ByteCount

Definition at line 310 of file fatprocs.h.

ByteOffset

_Out_ PIO_STATUS_BLOCK _In_ PLARGE_INTEGER ByteOffset

Definition at line 732 of file fatprocs.h.

Referenced by _Struct_size_bytes_(), BlFileReadAtOffsetEx(), BlImgLoadImageWithProgress2(), CompareFileContents(), Ext2QueryDirectory(), Ext2ReadFile(), Ext2ReadVolume(), Ext2WriteFile(), Ext2WriteVolume(), FatPerformVerifyDiskRead(), FatSetFsLabelInfo(), FsRtlProcessFileLock(), GetRemoteDatabaseEntry(), HalpCopyBufferMap(), ImgpReadAtFileOffset(), IoMapTransfer(), IopCreateLogFile(), MiniportTransferData(), NdisTransferData(), nfs41_IsLockRealizable(), NpAddDataQueueEntry(), NpCompleteStalledWrites(), NtfsWrite(), NtLockFile(), NtReadFile(), NtUnlockFile(), NtWriteFile(), ProTransferData(), RawInputThreadMain(), ReadLogBuffer(), RtlCreateBootStatusDataFile(), RtlGetSetBootStatusData(), RxCommonRead(), RxCommonWrite(), SetupCopyFile(), START_TEST(), UDFCommonRead(), UDFCommonWrite(), VfatCommonRead(), VfatRead(), VfatWrite(), WriteLogBuffer(), and WriteRemoteDatabaseEntry().

Ccb

IN PFCB IN PCCB Ccb

Definition at line 727 of file fatprocs.h.

CheckForReadOperation

IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN CheckForReadOperation

Definition at line 2667 of file fatprocs.h.

Referenced by _Function_class_(), Ext2FastIoCheckIfPossible(), FltpFastIoCheckIfPossible(), NtfsFastIoCheckIfPossible(), RxFastIoCheckIfPossible(), UDFFastIoCheckIfPossible(), and VfatFastIoCheckIfPossible().

CompletionContext

OUT PVOID* CompletionContext

Definition at line 1599 of file fatprocs.h.

CreateFile

IN OUT PVCB OUT PDIRENT OUT PBCB IN BOOLEAN CreateFile

Definition at line 917 of file fatprocs.h.

CreateLfn

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

Definition at line 1311 of file fatprocs.h.

Referenced by FatEvaluateNameCase(), and FatSetRenameInfo().

Dcb

IN PDCB Dcb

Definition at line 425 of file fatprocs.h.

DeleteEa

IN PFCB IN PDELETE_CONTEXT DeleteContext IN BOOLEAN DeleteEa

Definition at line 718 of file fatprocs.h.

Device

_In_ PIRP _In_ PDEVICE_OBJECT Device

Definition at line 2031 of file fatprocs.h.

DeviceObject

PVOID ULONG OUT PIO_STATUS_BLOCK IN PDEVICE_OBJECT DeviceObject

Definition at line 1569 of file fatprocs.h.

Dirent

IN PVCB IN PDIRENT Dirent

Definition at line 730 of file fatprocs.h.

DirentOffset

IN PDCB IN ULONG IN ULONG DirentOffset

Definition at line 791 of file fatprocs.h.

DirentsNeeded

IN PDCB IN ULONG DirentsNeeded

Definition at line 700 of file fatprocs.h.

EaBcb

IN PVCB IN ULONG IN PBCB EaBcb

Definition at line 916 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), and FatCommonSetEa().

EaDirent

IN PVCB IN ULONG IN PBCB OUT PDIRENT EaDirent

Definition at line 915 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), and FatCommonSetEa().

EaHandle

IN PVCB IN ULONG IN PBCB OUT PDIRENT OUT PUSHORT EaHandle

Definition at line 898 of file fatprocs.h.

Referenced by FatCommonSetEa(), and FatReadEaSet().

EaLength

_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE _Outptr_opt_ PFILE_OBJECT _In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Out_ PIO_STATUS_BLOCK _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _In_ ULONG _In_ ULONG _In_ ULONG EaLength

Definition at line 878 of file fatprocs.h.

Referenced by _Requires_lock_held_(), AfdCreateSocket(), CreateDirectoryExW(), CreateFileW(), GetConnectionHandle(), IoCheckEaBufferValidity(), IoCheckEaBufferValidityROS(), IoCreateFile(), IoCreateFileSpecifyDeviceObjectHint(), IopCreateFile(), main(), nfs41_CreateConnection(), nfs41_GetConnectionInfoFromBuffer(), NtCreateFile(), FxIoTargetRemoveOpenParams::Set(), TdiOpenAddressFile(), TdiOpenConnectionEndpointFile(), TdiOpenDevice(), TdiOpenTransport(), and VfatSetExtendedAttributes().

EaSetLength

IN PVCB IN ULONG EaSetLength

Definition at line 947 of file fatprocs.h.

EaSetRange

IN PVCB IN ULONG IN PBCB OUT PDIRENT OUT PUSHORT OUT PEA_RANGE EaSetRange

Definition at line 951 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), and FatReadEaSet().

EndOnMax

IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN OUT PBOOLEAN EndOnMax

Definition at line 312 of file fatprocs.h.

Referenced by _Requires_lock_held_().

ExactMatchRequired

IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN ExactMatchRequired

Definition at line 347 of file fatprocs.h.

ExceptionCode

IN PIRP IN NTSTATUS ExceptionCode

Definition at line 2935 of file fatprocs.h.

ExclusiveFcb

IN OUT PVCB OUT PDIRENT OUT PBCB IN BOOLEAN IN BOOLEAN ExclusiveFcb

Definition at line 918 of file fatprocs.h.

ExclusiveLock

IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN BOOLEAN ExclusiveLock

Definition at line 2715 of file fatprocs.h.

Referenced by _Function_class_(), CdFastLock(), Ext2FastIoLock(), FltpFastIoLock(), FsRtlPrivateLock(), NtLockFile(), UDFFastLock(), and VfatFastIoLock().

FailImmediately

IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ULONG BOOLEAN FailImmediately

Definition at line 2714 of file fatprocs.h.

Referenced by _Function_class_(), CdFastLock(), Ext2FastIoLock(), FltpFastIoLock(), FsRtlPrivateLock(), NtLockFile(), UDFFastLock(), and VfatFastIoLock().

FatCleanVolumeDpc

KDEFERRED_ROUTINE FatCleanVolumeDpc

Definition at line 1982 of file fatprocs.h.

Referenced by _Requires_lock_held_().

FatEntry

IN PVCB IN ULONG IN FAT_ENTRY FatEntry

Definition at line 385 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatExamineFatEntries(), FatLookupFatEntry(), FatSetFatRun(), and FatVerifyLookupFatEntry().

FatFspDispatch

WORKER_THREAD_ROUTINE FatFspDispatch

Definition at line 2381 of file fatprocs.h.

Referenced by FatAddToWorkque().

FatFspMarkVolumeDirtyWithRecover

WORKER_THREAD_ROUTINE FatFspMarkVolumeDirtyWithRecover

Definition at line 2001 of file fatprocs.h.

Referenced by FatPagingFileErrorHandler().

FatIndex

IN PVCB IN ULONG FatIndex

Definition at line 384 of file fatprocs.h.

Referenced by FatExamineFatEntries(), FatLookupFatEntry(), and FatVerifyLookupFatEntry().

FatTime

_In_ PLARGE_INTEGER _In_ BOOLEAN _Out_ PFAT_TIME_STAMP FatTime

Definition at line 1917 of file fatprocs.h.

Referenced by _Success_(), FatFatTimeToNtTime(), FatGetCurrentFatTime(), and get_fattime().

Fcb

IN PFCB Fcb

Definition at line 821 of file fatprocs.h.

FcbOrDcb

IN PFCB FcbOrDcb

Definition at line 307 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatCheckShareAccess(), FatComputeMoveFileSplicePoints(), FatDecodeFileObject(), FatDeferredFlush(), FatSetZeroOnDeallocate(), FatTunnelFcbOrDcb(), and FatUnpinRepinnedBcbs().

FileName

IN PVCB IN USHORT IN POEM_STRING FileName

Definition at line 743 of file fatprocs.h.

Filename

IN PVCB IN PBCB OUT PDIRENT IN USHORT IN POEM_STRING Filename

Definition at line 939 of file fatprocs.h.

Referenced by _CZipAskReplace(), _CZipExtract_runWizard(), asn_dump(), CZipExtract::CZipExtract(), extract_resource(), GetEnhancedVar(), MxFileObject::GetFileName(), GetLayerInfo(), GetModuleFileNameExA(), GetVersionFromFileA(), GetVersionFromFileW(), hash_file(), CLayerUIPropPage::InitFile(), InitializeShellFolder_(), main(), MapFileAndCheckSumA(), MapFileAndCheckSumW(), MediaDet_WriteBitmapBits(), ParseRedirection(), PerformRedirection(), test_DataObject(), test_EnumObjects(), test_EnumObjects_Files(), test_EnumObjects_Folders(), and wWinMain().

FileObject

IN PFILE_OBJECT FileObject

Definition at line 838 of file fatprocs.h.

FileOffset

IN PLARGE_INTEGER FileOffset

Definition at line 2663 of file fatprocs.h.

Flags

IN PDCB IN PCCB IN VBO IN OUT PULONG Flags

Definition at line 729 of file fatprocs.h.

FlushType

IN PVCB IN FAT_FLUSH_TYPE FlushType

Definition at line 1082 of file fatprocs.h.

Referenced by _Requires_lock_held_(), CcFlushImageSection(), and MmFlushImageSection().

Force

PVCB IN BOOLEAN Force

Definition at line 1804 of file fatprocs.h.

FsDeviceObject

IN OUT PVCB IN PDEVICE_OBJECT IN PVPB IN PDEVICE_OBJECT FsDeviceObject

Definition at line 1677 of file fatprocs.h.

Referenced by _Requires_lock_held_().

IoStatus

PVOID ULONG OUT PIO_STATUS_BLOCK IoStatus

Definition at line 2668 of file fatprocs.h.

Irp

IN PIRP Irp

Definition at line 590 of file fatprocs.h.

Key

PVOID ULONG Key

Definition at line 2713 of file fatprocs.h.

Lbo

IN PFCB IN VBO OUT PLBO Lbo

Definition at line 309 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatAddMcbEntry(), FatExamineFatEntries(), FatGetNextMcbEntry(), FatLookupLastMcbEntry(), FatLookupMcbEntry(), FatPerformVerifyDiskRead(), FatSetFatRun(), FatSingleAsync(), and FatSingleNonAlignedSync().

Length

IN PLARGE_INTEGER IN PLARGE_INTEGER Length

Definition at line 896 of file fatprocs.h.

Lfn

IN PFCB IN OUT PUNICODE_STRING Lfn

Definition at line 754 of file fatprocs.h.

LfnOffset

IN PDCB IN ULONG LfnOffset

Definition at line 790 of file fatprocs.h.

LfnTmp

IN PDCB IN PUNICODE_STRING IN PUNICODE_STRING LfnTmp

Definition at line 755 of file fatprocs.h.

LockKey

_In_ PLARGE_INTEGER _In_ ULONG _In_ ULONG LockKey

Definition at line 2666 of file fatprocs.h.

Referenced by _Function_class_(), Dispatch_fnFastRead(), Dispatch_fnFastWrite(), Ext2FastIoCheckIfPossible(), Ext2FastIoRead(), Ext2FastIoWrite(), FltpFastIoCheckIfPossible(), FltpFastIoMdlRead(), FltpFastIoPrepareMdlWrite(), FltpFastIoRead(), FltpFastIoReadCompressed(), FltpFastIoWrite(), FltpFastIoWriteCompressed(), FsRtlCopyRead(), FsRtlCopyRead2(), FsRtlCopyWrite(), FsRtlCopyWrite2(), FsRtlMdlRead(), FsRtlMdlReadDev(), FsRtlPrepareMdlWrite(), FsRtlPrepareMdlWriteDev(), NtfsFastIoCheckIfPossible(), NtfsFastIoRead(), NtfsFastIoWrite(), RxFastIoCheckIfPossible(), RxFastIoRead(), RxFastIoWrite(), TestCommonRead(), TestCommonWrite(), TestFastIoRead(), TestFastIoWrite(), TestGetReturnStatus(), UDFFastIoCheckIfPossible(), UDFFastIoCopyWrite(), VfatFastIoCheckIfPossible(), VfatFastIoRead(), VfatFastIoReadCompressed(), VfatFastIoWrite(), VfatFastIoWriteCompressed(), VfatMdlRead(), and VfatPrepareMdlWrite().

Mcb

IN PVCB IN OUT PLARGE_MCB Mcb

Definition at line 348 of file fatprocs.h.

Referenced by _Requires_lock_held_(), bmap(), CdFindMcbEntry(), DosChangeMemoryOwner(), DosFreeMemory(), DosInitializeMemory(), DosInitializeUmb(), DosInitPsp(), DosLinkUmb(), DosResizeMemory(), DosUnlinkUmb(), DumpAllRuns(), Ext2AddBlockExtent(), Ext2AddMcbExtent(), Ext2AddMcbMetaExts(), Ext2AllocateFcb(), Ext2AllocateMcb(), Ext2BlockMap(), Ext2BuildExtents(), Ext2CheckFileAccess(), Ext2Cleanup(), Ext2CleanupAllMcbs(), Ext2CreateFile(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2DoExtentExpand(), Ext2ExpandBlock(), Ext2ExpandExtent(), Ext2ExpandFile(), Ext2ExpandIndirect(), Ext2ExpandLast(), Ext2FastIoQueryBasicInfo(), Ext2FastIoQueryNetworkOpenInfo(), Ext2FirstUnusedMcb(), Ext2FollowLink(), Ext2FreeMcb(), Ext2GetBlock(), Ext2GetReparsePoint(), Ext2InitializeZone(), Ext2InodeType(), Ext2InsertMcb(), Ext2IsDirectoryEmpty(), Ext2IsFileRemovable(), Ext2LinkHeadMcb(), Ext2LinkTailMcb(), Ext2LookupBlockExtent(), Ext2LookupFile(), Ext2LookupMcbExtent(), Ext2MapExtent(), Ext2MapIndirect(), Ext2McbReaperThread(), Ext2NotifyReportChange(), Ext2OverwriteEa(), Ext2ProcessEntry(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2ReadInode(), Ext2ReadSymlink(), Ext2ReleaseFcb(), Ext2RemoveBlockExtent(), Ext2RemoveEntry(), Ext2RemoveMcb(), Ext2RemoveMcbExtent(), Ext2RemoveMcbMetaExts(), Ext2SearchMcb(), Ext2SetDispositionInfo(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetFileType(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), Ext2TruncateBlock(), Ext2TruncateExtent(), Ext2TruncateFile(), Ext2TruncateIndirect(), Ext2TruncateIndirectFast(), Ext2TruncateSymlink(), Ext2UnlinkFcb(), Ext2UnlinkMcb(), Ext2WriteInode(), Ext2WriteSymlink(), ext3_bread(), FatAddMcbEntry(), FatGetNextMcbEntry(), FatLookupLastMcbEntry(), FatLookupMcbEntry(), FatRemoveMcbEntry(), FsRtlAddBaseMcbEntry(), FsRtlAddLargeMcbEntry(), FsRtlAddMcbEntry(), FsRtlGetNextBaseMcbEntry(), FsRtlGetNextLargeMcbEntry(), FsRtlGetNextMcbEntry(), FsRtlInitializeBaseMcb(), FsRtlInitializeLargeMcb(), FsRtlInitializeMcb(), FsRtlLargeMcbTestsFastFat(), FsRtlLargeMcbTestsFastFat_2(), FsRtlLargeMcbTestsFastFat_3(), FsRtlLookupLargeMcbEntry(), FsRtlLookupLastBaseMcbEntry(), FsRtlLookupLastBaseMcbEntryAndIndex(), FsRtlLookupLastLargeMcbEntry(), FsRtlLookupLastLargeMcbEntryAndIndex_internal(), FsRtlLookupLastMcbEntry(), FsRtlLookupMcbEntry(), FsRtlNumberOfRunsInLargeMcb(), FsRtlNumberOfRunsInMcb(), FsRtlRemoveBaseMcbEntry(), FsRtlRemoveLargeMcbEntry(), FsRtlRemoveMcbEntry(), FsRtlResetBaseMcb(), FsRtlResetLargeMcb(), FsRtlSplitBaseMcb(), FsRtlSplitLargeMcb(), FsRtlTruncateLargeMcb(), FsRtlTruncateMcb(), FsRtlUninitializeBaseMcb(), FsRtlUninitializeLargeMcb(), FsRtlUninitializeMcb(), main(), McbMappingAllocate(), and ValidateMcb().

NeedEaCount

IN PVCB IN PDIRENT OUT PULONG NeedEaCount

Definition at line 887 of file fatprocs.h.

NoOpCheck

IN PVCB IN BOOLEAN NoOpCheck

Definition at line 1458 of file fatprocs.h.

Referenced by _Requires_lock_held_().

NtTime

_In_ PLARGE_INTEGER NtTime

Definition at line 1915 of file fatprocs.h.

Referenced by _Success_(), Ext2LinuxTime(), UDFCommonCleanup(), UDFFlushAFile(), UDFTimeToNT(), and UDFTimeToUDF().

OemName

IN PDCB IN POEM_STRING OemName

Definition at line 1305 of file fatprocs.h.

Referenced by _IRQL_requires_max_(), CdGenerate8dot3Name(), Ext2FollowLink(), Ext2GetReparsePoint(), Ext2InitializeLabel(), Ext2IsWearingCloak(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), InstallFat32BootCode(), InstallFatBootCode(), and START_TEST().

OffsetToStartSearchFrom

IN PDCB IN PCCB IN VBO OffsetToStartSearchFrom

Definition at line 728 of file fatprocs.h.

OPTIONAL

IN PFCB IN PCCB IN TYPE_OF_OPEN IN BOOLEAN IN BOOLEAN OUT PBOOLEAN VcbDeleted OPTIONAL

Definition at line 313 of file fatprocs.h.

Parent

IN PDCB Parent

Definition at line 1304 of file fatprocs.h.

ParentDirectory

IN PDCB ParentDirectory

Definition at line 699 of file fatprocs.h.

Referenced by ObpLookupObjectName(), ObpQueryNameInfoSize(), and ObQueryNameString().

ParentDirent

IN PDCB IN PDIRENT ParentDirent

Definition at line 709 of file fatprocs.h.

Pin

IN PDCB IN VBO IN ULONG IN BOOLEAN Pin

Definition at line 428 of file fatprocs.h.

Referenced by AudioPositionPropertyHandler(), BdaMethodCreatePin(), BdaPropertyGetPinControl(), CaptureAvoidPipeStarvationWorker(), CaptureGateOnWorkItem(), CaptureInitializeUrbAndIrp(), CapturePinStateChange(), DECLARE_INTERFACE_(), DoDataIntersection(), FilterProcess(), GetFilterPinCount(), GetSysAudioDeviceCount(), GetSysAudioDevicePnpName(), HandleDataIntersection(), HandleNecessaryPropertyInstances(), HandlePhysicalConnection(), HandlePropertyInstances(), IKsFilter_AddPin(), IKsFilter_RemovePin(), IKsPin_Close(), IKsPin_DispatchCreateClock(), IKsPin_DispatchDeviceIoControl(), IKsPin_PinAllocatorFramingPropertyHandler(), IKsPin_PinDataFormatPropertyHandler(), IKsPin_PinMasterClock(), IKsPin_PinStatePropertyHandler(), InitCapturePin(), InitStreamPin(), IOAPICClear(), IOAPICClearPin(), KsGetPinFromIrp(), KspHandleDataIntersection(), KspHandleNecessaryPropertyInstances(), KspHandlePropertyInstances(), KsPinAcquireProcessingMutex(), KsPinAttachAndGate(), KsPinAttachOrGate(), KsPinDataIntersection(), KsPinGetAndGate(), KsPinGetFirstCloneStreamPointer(), KsPinGetLeadingEdgeStreamPointer(), KsPinGetNextSiblingPin(), KsPinGetParentFilter(), KsPinGetReferenceClockInterface(), KsPinRegisterFrameReturnCallback(), KsPinRegisterHandshakeCallback(), KsPinRegisterIrpCompletionCallback(), KsPinRegisterPowerCallbacks(), KsPinReleaseProcessingMutex(), KspPinPropertyHandler(), CKsInterfaceHandler::KsSetPin(), KsStreamPointerAdvanceOffsets(), KsStreamPointerClone(), KsStreamPointerDelete(), MMixerAddPinConnection(), MMixerGetAllUpOrDownstreamNodesFromPinIndex(), MMixerGetAllUpOrDownstreamPinsFromPinIndex(), MMixerGetFilterPinCount(), MMixerGetNextNodesFromPinIndex(), MMixerGetPhysicalConnection(), MMixerGetPinDataFlowAndCommunication(), MMixerGetPinName(), MMixerGetUpOrDownStreamPins(), MMixerHandleNodePinConnection(), MMixerHandleTopologyFilter(), PcCreatePinDispatch(), PinCaptureProcess(), PinClose(), PinCreate(), PinGetIrpFromReadyList(), PinIntersectHandler(), PinRenderProcess(), PinReset(), PinState(), RenderInitializeUrbAndIrp(), CKsProxy::SetPinState(), StartCaptureIsocTransfer(), SysAudioHandleProperty(), CMiniport::TestDataFormat(), CAC97MiniportTopology::TransPinDefToPinNr(), CAC97MiniportTopology::TransPinNrToPinDef(), UsbAudioCaptureComplete(), USBAudioPinCreate(), UsbAudioPinDataIntersect(), USBAudioPinProcess(), USBAudioPinSetDataFormat(), USBAudioPinSetDeviceState(), UsbAudioRenderComplete(), USBAudioSelectAudioStreamingInterface(), UsbAudioSetFormat(), and CMiniport::ValidateFormat().

ProcessId

_In_ PVOID ProcessId

Definition at line 2712 of file fatprocs.h.

Referenced by _Function_class_(), CIconWatcher::AddIconToWatcher(), BaseSrvCleanupVDMResources(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), CdFastUnlockSingle(), CloseProcessAndVerify_(), co_IntRegisterLogonProcess(), CON_API_NOCONSOLE(), CreateProcessNotifyRoutine(), CreateThreadNotifyRoutine(), DbgLoadImageSymbols(), DbgUnLoadImageSymbols(), DisplayScreen(), find_process(), FltpFastIoLock(), FltpFastIoUnlockAll(), FltpFastIoUnlockAllByKey(), FltpFastIoUnlockSingle(), GetOwnerModuleFromTagEntry(), GetProcessVersion(), GetSelectedProcessId(), HandleList_Update(), IntAttachConsole(), KdbpAttachToProcess(), LoadImageNotifyRoutine(), PerfDataGetCommandLine(), PerfDataGetProcessId(), PerfDataGetProcessIndex(), PerfDataRefresh(), PNP_ReportLogOn(), ProcessRunning(), PsLookupProcessByProcessId(), PspRunLoadImageNotifyRoutines(), RtlQueryProcessDebugInformation(), service_main(), SmpExecuteCommand(), SmpLoadSubSystem(), SmpLoadSubSystemsForMuSession(), StartChild(), TestTerminateProcess(), ThemeDestroyWndData(), UDFFastLock(), UDFFastUnlockAll(), UDFFastUnlockAllByKey(), UDFFastUnlockSingle(), UserExitReactOS(), VfatFastIoLock(), VfatFastIoUnlockAll(), VfatFastIoUnlockAllByKey(), VfatFastIoUnlockSingle(), and WTSTerminateProcess().

RemainingMcb

IN PVCB IN OUT PLARGE_MCB IN VBO OUT PLARGE_MCB RemainingMcb

Definition at line 367 of file fatprocs.h.

RescanDir

IN PDCB IN ULONG IN BOOLEAN RescanDir

Definition at line 701 of file fatprocs.h.

ReturnOnFailure

IN PFCB IN BOOLEAN ReturnOnFailure

Definition at line 773 of file fatprocs.h.

Reversible

IN PBCB IN PVCB Vcb IN BOOLEAN Reversible

Definition at line 417 of file fatprocs.h.

Referenced by _Requires_lock_held_().

Rounding

_In_ PLARGE_INTEGER _In_ BOOLEAN Rounding

Definition at line 1916 of file fatprocs.h.

Referenced by _Success_().

SecondMcb

IN PVCB IN OUT PLARGE_MCB IN PLARGE_MCB SecondMcb

Definition at line 376 of file fatprocs.h.

Referenced by FsRtlLargeMcbTestsExt2().

ShortName

_Must_inspect_result_ _In_ ULONGLONG _In_ PUNICODE_STRING _Out_ PUNICODE_STRING ShortName

Definition at line 1307 of file fatprocs.h.

Referenced by _Requires_lock_held_(), CdGenerate8dot3Name(), demFileFindFirst(), demFileFindNext(), dempIsFileMatch(), DuplicatesTest(), FATAddEntry(), FatConstructNamesInFcb(), FatQueryShortNameInfo(), FsRtlAddToTunnelCache(), FsRtlFindInTunnelCache(), implicit_handle(), main(), RtlGetFullPathName_U(), RtlGetFullPathName_Ustr(), RtlGetFullPathName_UstrEx(), RunTestCases(), SetFileShortNameW(), SetUserEnvironmentVariable(), START_TEST(), Test_ShortTests(), UDFFindFile(), UDFGetAltNameInformation(), and UDFIsNameInExpression().

SplitAtVbo

IN PVCB IN OUT PLARGE_MCB IN VBO SplitAtVbo

Definition at line 366 of file fatprocs.h.

StartingVbo

IN PIRP IN PFCB IN ULONG StartingVbo

Definition at line 413 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatPinEaRange(), FatPinMappedData(), and FatReadVolumeFile().

Status

IN PDCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN OUT PNTSTATUS Status

Definition at line 431 of file fatprocs.h.

StreamFlags

IN PIRP IN PFCB IN ULONG IN ULONG IN ULONG IN ULONG StreamFlags

Definition at line 595 of file fatprocs.h.

Referenced by _Requires_lock_held_().

TargetDcb

IN PDCB TargetDcb

Definition at line 789 of file fatprocs.h.

Referenced by Ext2SetLinkInfo(), Ext2SetRenameInfo(), and FatSetRenameInfo().

TargetDeviceObject

IN OUT PVCB IN PDEVICE_OBJECT TargetDeviceObject

Definition at line 1675 of file fatprocs.h.

Referenced by _Requires_lock_held_(), CdHijackIrpAndFlushDevice(), CdInitializeVcb(), CdProcessToc(), CdReadSectors(), ClassSendDeviceIoControlSynchronous(), ClassSendIrpSynchronous(), DeviceSendIoctlAsynchronously(), Ext2DeviceControlNormal(), Ext2MountVolume(), FatHijackIrpAndFlushDevice(), FatIsMediaWriteProtected(), FatScanForDataTrack(), main(), NtSetVolumeInformationFile(), RawInitializeVcb(), UDFCompareVcb(), UDFMountVolume(), UDFResetDeviceDriver(), and USBD_CreateHandle().

TenMsecs

_In_ PLARGE_INTEGER _In_ BOOLEAN _Out_ PFAT_TIME_STAMP _Out_opt_ PUCHAR TenMsecs

Definition at line 1918 of file fatprocs.h.

Referenced by _Success_().

TopLevel

IN PFCB IN PCCB IN TYPE_OF_OPEN IN BOOLEAN IN BOOLEAN TopLevel

Definition at line 2418 of file fatprocs.h.

Referenced by _Function_class_(), _Requires_lock_held_(), AtapiStartIo__(), CcWorkerThread(), main(), RxFsdCommonDispatch(), RxGetTopIrpIfRdbssIrp(), and UniataNeedQueueing().

TypeOfOpen

IN PFCB IN PCCB IN TYPE_OF_OPEN TypeOfOpen

Definition at line 2416 of file fatprocs.h.

UnicodeName

IN PDCB IN POEM_STRING IN PUNICODE_STRING UnicodeName

Definition at line 1306 of file fatprocs.h.

Referenced by ComputeUnicodeNameLength(), ConvertAddrinfoFromUnicodeToAnsi(), FatEvaluateNameCase(), FatSpaceInName(), IntGetCodePageEntry(), IsShortName_U(), OpenFileMappingW(), PeLdrpCompareDllName(), USBPORT_GetUnicodeName(), USBPORT_UserGetHcName(), and USBPORT_UserGetRootHubName().

UserByteCount

IN PIRP IN PFCB IN ULONG IN ULONG IN ULONG UserByteCount

Definition at line 594 of file fatprocs.h.

Referenced by _Requires_lock_held_().

Vbo

IN PFCB IN VBO Vbo

Definition at line 308 of file fatprocs.h.

Referenced by _Requires_lock_held_(), FatAddMcbEntry(), FatGetNextMcbEntry(), FatLookupLastMcbEntry(), FatLookupMcbEntry(), FatPagingFileIo(), FatPinMappedData(), FatReadVolumeFile(), and FatRemoveMcbEntry().

Vcb

IN PVCB Vcb

Definition at line 344 of file fatprocs.h.

Referenced by FatIsIoRangeValid().

VolumeState

IN PVCB IN FAT_VOLUME_STATE VolumeState

Definition at line 1998 of file fatprocs.h.

Referenced by CdIsVolumeDirty(), Ext2IsVolumeDirty(), FatIsVolumeDirty(), and UDFIsVolumeDirty().

Vpb

IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb

Definition at line 1676 of file fatprocs.h.

Referenced by $endif(), _Requires_lock_held_(), _Success_(), CcIsThereDirtyData(), CdInitializeVcb(), Ext2CheckDismount(), Ext2ClearVpbFlag(), Ext2ExceptionHandler(), Ext2InitializeVcb(), Ext2MountVolume(), Ext2SetVpbFlag(), FatSearchBufferForLabel(), FsdGetFsVolumeInformation(), IoGetDiskDeviceObject(), IopCheckVpbMounted(), IopCreateVpb(), IopDeleteFile(), IopDereferenceVpbAndFree(), IopGetMountFlag(), IopMountInitializeVpb(), IopMountVolume(), IopParseDevice(), IopReferenceVerifyVpb(), IoRaiseHardError(), IoVerifyVolume(), main(), RawCheckForDismount(), RawInitializeVcb(), UDFExceptionHandler(), UDFMountVolume(), UDFVerifyVolume(), VfatCheckForDismount(), VfatLockOrUnlockVolume(), VfatMount(), and VfatVerify().

Wait

IN BOOLEAN Wait

Definition at line 1538 of file fatprocs.h.

Zero

IN PDCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN Zero

Definition at line 418 of file fatprocs.h.

Referenced by _Requires_lock_held_(), AcpiUtFormatNumber(), CcPreparePinWrite(), CleanupTest(), Ext2WriteSymlink(), Free(), KeyboardDeviceWorker(), KmtFltAddAltitude(), MiRemoveZeroPage(), NtfsCreateFile(), RamdiskGetPartitionInfo(), RamdiskSetPartitionInfo(), SermouseDeviceWorker(), TestIrpHandler(), VfatCheckForDismount(), and VfatMount().

ZeroOnDeallocate

IN PVCB IN PLARGE_MCB IN BOOLEAN ZeroOnDeallocate

Definition at line 357 of file fatprocs.h.