vfat.h File Reference

#include <ntifs.h>
#include <ntdddisk.h>
#include <dos.h>
#include <pseh/pseh2.h>
#include <section_attribs.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for vfat.h:

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

Go to the source code of this file.

Classes
struct	_BootSector
struct	_BootSector32
struct	_BootSectorFatX
struct	_FsInfoSector
struct	_FATDirEntry
struct	_EAFileHeader
struct	_EASetHeader
struct	_EAHeader
struct	_FATXDirEntry
struct	_slot
union	_DIR_ENTRY
struct	FATINFO
struct	_HASHENTRY
struct	_VFAT_DISPATCH
struct	_STATISTICS
struct	DEVICE_EXTENSION
struct	VFAT_GLOBAL_DATA
struct	_VFATFCB
struct	_VFATCCB
struct	__DOSTIME
struct	__DOSDATE
struct	VFAT_IRP_CONTEXT
struct	_VFAT_DIRENTRY_CONTEXT
struct	_VFAT_MOVE_CONTEXT
struct	_VFAT_CLOSE_CONTEXT

Macros
#define	USE_ROS_CC_AND_FS
#define	ENABLE_SWAPOUT
#define	VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
#define	ROUND_DOWN(n, align)    (((ULONG)n) & ~((align) - 1l))
#define	ROUND_UP(n, align)    ROUND_DOWN(((ULONG)n) + (align) - 1, (align))
#define	ROUND_DOWN_64(n, align)    (((ULONGLONG)n) & ~((align) - 1LL))
#define	ROUND_UP_64(n, align)    ROUND_DOWN_64(((ULONGLONG)n) + (align) - 1LL, (align))
#define	FAT_DIRTY_BIT   0x01
#define	FAT_EAFILE   "EA DATA. SF"
#define	VFAT_CASE_LOWER_BASE   8
#define	VFAT_CASE_LOWER_EXT   16
#define	LONGNAME_MAX_LENGTH   256
#define	ENTRY_DELETED(IsFatX, DirEntry)   (IsFatX ? FATX_ENTRY_DELETED(&((DirEntry)->FatX)) : FAT_ENTRY_DELETED(&((DirEntry)->Fat)))
#define	ENTRY_VOLUME(IsFatX, DirEntry)   (IsFatX ? FATX_ENTRY_VOLUME(&((DirEntry)->FatX)) : FAT_ENTRY_VOLUME(&((DirEntry)->Fat)))
#define	ENTRY_END(IsFatX, DirEntry)   (IsFatX ? FATX_ENTRY_END(&((DirEntry)->FatX)) : FAT_ENTRY_END(&((DirEntry)->Fat)))
#define	FAT_ENTRY_DELETED(DirEntry)   ((DirEntry)->Filename[0] == 0xe5)
#define	FAT_ENTRY_END(DirEntry)   ((DirEntry)->Filename[0] == 0)
#define	FAT_ENTRY_LONG(DirEntry)   (((DirEntry)->Attrib & 0x3f) == 0x0f)
#define	FAT_ENTRY_VOLUME(DirEntry)   (((DirEntry)->Attrib & 0x1f) == 0x08)
#define	FATX_ENTRY_DELETED(DirEntry)   ((DirEntry)->FilenameLength == 0xe5)
#define	FATX_ENTRY_END(DirEntry)   ((DirEntry)->FilenameLength == 0xff)
#define	FATX_ENTRY_LONG(DirEntry)   (FALSE)
#define	FATX_ENTRY_VOLUME(DirEntry)   (((DirEntry)->Attrib & 0x1f) == 0x08)
#define	FAT_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FAT_DIR_ENTRY))
#define	FATX_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FATX_DIR_ENTRY))
#define	BLOCKSIZE   512
#define	FAT16   (1)
#define	FAT12   (2)
#define	FAT32   (3)
#define	FATX16   (4)
#define	FATX32   (5)
#define	VCB_VOLUME_LOCKED   0x0001
#define	VCB_DISMOUNT_PENDING   0x0002
#define	VCB_IS_FATX   0x0004
#define	VCB_IS_SYS_OR_HAS_PAGE   0x0008
#define	VCB_IS_DIRTY   0x4000 /* Volume is dirty */
#define	VCB_CLEAR_DIRTY   0x8000 /* Clean dirty flag at shutdown */
#define	VCB_GOOD   0x0010 /* If not set, the VCB is improper for usage */
#define	STATISTICS_SIZE_NO_PAD   (sizeof(FILESYSTEM_STATISTICS) + sizeof(FAT_STATISTICS))
#define	VFAT_BREAK_ON_CORRUPTION   1
#define	FCB_CACHE_INITIALIZED   0x0001
#define	FCB_DELETE_PENDING   0x0002
#define	FCB_IS_FAT   0x0004
#define	FCB_IS_PAGE_FILE   0x0008
#define	FCB_IS_VOLUME   0x0010
#define	FCB_IS_DIRTY   0x0020
#define	FCB_DELAYED_CLOSE   0x0040
#define	NODE_TYPE_FCB   ((CSHORT)0x0502)
#define	CCB_DELETE_ON_CLOSE   0x0001
#define	TAG_CCB   'CtaF'
#define	TAG_FCB   'FtaF'
#define	TAG_IRP   'ItaF'
#define	TAG_CLOSE   'xtaF'
#define	TAG_STATS   'VtaF'
#define	TAG_BUFFER   'OtaF'
#define	TAG_VPB   'vtaF'
#define	TAG_NAME   'ntaF'
#define	TAG_SEARCH   'LtaF'
#define	TAG_DIRENT   'DtaF'
#define	ENTRIES_PER_SECTOR   (BLOCKSIZE / sizeof(FATDirEntry))
#define	IRPCONTEXT_CANWAIT   0x0001
#define	IRPCONTEXT_COMPLETE   0x0002
#define	IRPCONTEXT_QUEUE   0x0004
#define	IRPCONTEXT_PENDINGRETURNED   0x0008
#define	IRPCONTEXT_DEFERRED_WRITE   0x0010
#define	vfatAddToStat(Vcb, Stat, Inc)

Typedefs
typedef struct _BootSector	BootSector
typedef struct _EAFileHeader	FAT_EA_FILE_HEADER
typedef struct _EAFileHeader *	PFAT_EA_FILE_HEADER
typedef struct _EASetHeader	FAT_EA_SET_HEADER
typedef struct _EASetHeader *	PFAT_EA_SET_HEADER
typedef struct _EAHeader	FAT_EA_HEADER
typedef struct _EAHeader *	PFAT_EA_HEADER
typedef struct _FATDirEntry	FAT_DIR_ENTRY
typedef struct _FATDirEntry *	PFAT_DIR_ENTRY
typedef struct _slot	slot
typedef struct _FATXDirEntry	FATX_DIR_ENTRY
typedef struct _FATXDirEntry *	PFATX_DIR_ENTRY
typedef union _DIR_ENTRY	DIR_ENTRY
typedef union _DIR_ENTRY *	PDIR_ENTRY
typedef struct FATINFO *	PFATINFO
typedef struct _HASHENTRY	HASHENTRY
typedef struct DEVICE_EXTENSION *	PDEVICE_EXTENSION
typedef NTSTATUS(*	PGET_NEXT_CLUSTER) (PDEVICE_EXTENSION, ULONG, PULONG)
typedef NTSTATUS(*	PFIND_AND_MARK_AVAILABLE_CLUSTER) (PDEVICE_EXTENSION, PULONG)
typedef NTSTATUS(*	PWRITE_CLUSTER) (PDEVICE_EXTENSION, ULONG, ULONG, PULONG)
typedef BOOLEAN(*	PIS_DIRECTORY_EMPTY) (PDEVICE_EXTENSION, struct _VFATFCB *)
typedef NTSTATUS(*	PADD_ENTRY) (PDEVICE_EXTENSION, PUNICODE_STRING, struct _VFATFCB **, struct _VFATFCB *, ULONG, UCHAR, struct _VFAT_MOVE_CONTEXT *)
typedef NTSTATUS(*	PDEL_ENTRY) (PDEVICE_EXTENSION, struct _VFATFCB *, struct _VFAT_MOVE_CONTEXT *)
typedef NTSTATUS(*	PGET_NEXT_DIR_ENTRY) (PVOID *, PVOID *, struct _VFATFCB *, struct _VFAT_DIRENTRY_CONTEXT *, BOOLEAN)
typedef NTSTATUS(*	PGET_DIRTY_STATUS) (PDEVICE_EXTENSION, PBOOLEAN)
typedef NTSTATUS(*	PSET_DIRTY_STATUS) (PDEVICE_EXTENSION, BOOLEAN)
typedef struct _VFAT_DISPATCH	VFAT_DISPATCH
typedef struct _VFAT_DISPATCH *	PVFAT_DISPATCH
typedef struct _STATISTICS	STATISTICS
typedef struct _STATISTICS *	PSTATISTICS
typedef struct DEVICE_EXTENSION	DEVICE_EXTENSION
typedef struct DEVICE_EXTENSION	VCB
typedef struct DEVICE_EXTENSION *	PVCB
typedef struct VFAT_GLOBAL_DATA *	PVFAT_GLOBAL_DATA
typedef struct _VFATFCB	VFATFCB
typedef struct _VFATFCB *	PVFATFCB
typedef struct _VFATCCB	VFATCCB
typedef struct _VFATCCB *	PVFATCCB
typedef struct __DOSTIME	DOSTIME
typedef struct __DOSTIME *	PDOSTIME
typedef struct __DOSDATE	DOSDATE
typedef struct __DOSDATE *	PDOSDATE
typedef struct VFAT_IRP_CONTEXT *	PVFAT_IRP_CONTEXT
typedef struct _VFAT_DIRENTRY_CONTEXT	VFAT_DIRENTRY_CONTEXT
typedef struct _VFAT_DIRENTRY_CONTEXT *	PVFAT_DIRENTRY_CONTEXT
typedef struct _VFAT_MOVE_CONTEXT	VFAT_MOVE_CONTEXT
typedef struct _VFAT_MOVE_CONTEXT *	PVFAT_MOVE_CONTEXT
typedef struct _VFAT_CLOSE_CONTEXT	VFAT_CLOSE_CONTEXT
typedef struct _VFAT_CLOSE_CONTEXT *	PVFAT_CLOSE_CONTEXT

Functions
FORCEINLINE BOOLEAN	VfatIsDirectoryEmpty (PDEVICE_EXTENSION DeviceExt, struct _VFATFCB *Fcb)
FORCEINLINE NTSTATUS	VfatAddEntry (PDEVICE_EXTENSION DeviceExt, PUNICODE_STRING NameU, struct _VFATFCB **Fcb, struct _VFATFCB *ParentFcb, ULONG RequestedOptions, UCHAR ReqAttr, struct _VFAT_MOVE_CONTEXT *MoveContext)
FORCEINLINE NTSTATUS	VfatDelEntry (PDEVICE_EXTENSION DeviceExt, struct _VFATFCB *Fcb, struct _VFAT_MOVE_CONTEXT *MoveContext)
FORCEINLINE NTSTATUS	VfatGetNextDirEntry (PDEVICE_EXTENSION DeviceExt, PVOID *pContext, PVOID *pPage, struct _VFATFCB *pDirFcb, struct _VFAT_DIRENTRY_CONTEXT *DirContext, BOOLEAN First)
FORCEINLINE NTSTATUS	VfatMarkIrpContextForQueue (PVFAT_IRP_CONTEXT IrpContext)
FORCEINLINE BOOLEAN	vfatFCBIsDirectory (PVFATFCB FCB)
FORCEINLINE BOOLEAN	vfatFCBIsReadOnly (PVFATFCB FCB)
FORCEINLINE BOOLEAN	vfatVolumeIsFatX (PDEVICE_EXTENSION DeviceExt)
FORCEINLINE VOID	vfatReportChange (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB Fcb, IN ULONG FilterMatch, IN ULONG Action)
NTSTATUS	VfatReadDisk (IN PDEVICE_OBJECT pDeviceObject, IN PLARGE_INTEGER ReadOffset, IN ULONG ReadLength, IN PUCHAR Buffer, IN BOOLEAN Override)
NTSTATUS	VfatReadDiskPartial (IN PVFAT_IRP_CONTEXT IrpContext, IN PLARGE_INTEGER ReadOffset, IN ULONG ReadLength, IN ULONG BufferOffset, IN BOOLEAN Wait)
NTSTATUS	VfatWriteDisk (IN PDEVICE_OBJECT pDeviceObject, IN PLARGE_INTEGER WriteOffset, IN ULONG WriteLength, IN OUT PUCHAR Buffer, IN BOOLEAN Override)
NTSTATUS	VfatWriteDiskPartial (IN PVFAT_IRP_CONTEXT IrpContext, IN PLARGE_INTEGER WriteOffset, IN ULONG WriteLength, IN ULONG BufferOffset, IN BOOLEAN Wait)
NTSTATUS	VfatBlockDeviceIoControl (IN PDEVICE_OBJECT DeviceObject, IN ULONG CtlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, IN OUT PVOID OutputBuffer, IN OUT PULONG pOutputBufferSize, IN BOOLEAN Override)
NTSTATUS	VfatCleanup (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatClose (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatCloseFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
NTSTATUS	VfatCreate (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	FindFile (PDEVICE_EXTENSION DeviceExt, PVFATFCB Parent, PUNICODE_STRING FileToFindU, PVFAT_DIRENTRY_CONTEXT DirContext, BOOLEAN First)
VOID	vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry, PUNICODE_STRING NameU)
NTSTATUS	VfatDirectoryControl (PVFAT_IRP_CONTEXT IrpContext)
BOOLEAN	FsdDosDateTimeToSystemTime (PDEVICE_EXTENSION DeviceExt, USHORT DosDate, USHORT DosTime, PLARGE_INTEGER SystemTime)
BOOLEAN	FsdSystemTimeToDosDateTime (PDEVICE_EXTENSION DeviceExt, PLARGE_INTEGER SystemTime, USHORT *pDosDate, USHORT *pDosTime)
ULONG	vfatDirEntryGetFirstCluster (PDEVICE_EXTENSION pDeviceExt, PDIR_ENTRY pDirEntry)
NTSTATUS	vfatFCBInitializeCacheFromVolume (PVCB vcb, PVFATFCB fcb)
NTSTATUS	VfatUpdateEntry (IN PDEVICE_EXTENSION DeviceExt, PVFATFCB pFcb)
BOOLEAN	vfatFindDirSpace (PDEVICE_EXTENSION DeviceExt, PVFATFCB pDirFcb, ULONG nbSlots, PULONG start)
NTSTATUS	vfatRenameEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, IN PUNICODE_STRING FileName, IN BOOLEAN CaseChangeOnly)
NTSTATUS	VfatMoveEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, IN PUNICODE_STRING FileName, IN PVFATFCB ParentFcb)
NTSTATUS	VfatSetExtendedAttributes (PFILE_OBJECT FileObject, PVOID Ea, ULONG EaLength)
VOID	VfatInitFastIoRoutines (PFAST_IO_DISPATCH FastIoDispatch)
BOOLEAN NTAPI	VfatAcquireForLazyWrite (IN PVOID Context, IN BOOLEAN Wait)
VOID NTAPI	VfatReleaseFromLazyWrite (IN PVOID Context)
NTSTATUS	FAT12GetNextCluster (PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster, PULONG NextCluster)
NTSTATUS	FAT12FindAndMarkAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
NTSTATUS	FAT12WriteCluster (PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite, ULONG NewValue, PULONG OldValue)
NTSTATUS	FAT16GetNextCluster (PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster, PULONG NextCluster)
NTSTATUS	FAT16FindAndMarkAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
NTSTATUS	FAT16WriteCluster (PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite, ULONG NewValue, PULONG OldValue)
NTSTATUS	FAT32GetNextCluster (PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster, PULONG NextCluster)
NTSTATUS	FAT32FindAndMarkAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
NTSTATUS	FAT32WriteCluster (PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite, ULONG NewValue, PULONG OldValue)
NTSTATUS	OffsetToCluster (PDEVICE_EXTENSION DeviceExt, ULONG FirstCluster, ULONG FileOffset, PULONG Cluster, BOOLEAN Extend)
ULONGLONG	ClusterToSector (PDEVICE_EXTENSION DeviceExt, ULONG Cluster)
NTSTATUS	GetNextCluster (PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster, PULONG NextCluster)
NTSTATUS	GetNextClusterExtend (PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster, PULONG NextCluster)
NTSTATUS	CountAvailableClusters (PDEVICE_EXTENSION DeviceExt, PLARGE_INTEGER Clusters)
NTSTATUS	WriteCluster (PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite, ULONG NewValue)
NTSTATUS	GetDirtyStatus (PDEVICE_EXTENSION DeviceExt, PBOOLEAN DirtyStatus)
NTSTATUS	FAT16GetDirtyStatus (PDEVICE_EXTENSION DeviceExt, PBOOLEAN DirtyStatus)
NTSTATUS	FAT32GetDirtyStatus (PDEVICE_EXTENSION DeviceExt, PBOOLEAN DirtyStatus)
NTSTATUS	SetDirtyStatus (PDEVICE_EXTENSION DeviceExt, BOOLEAN DirtyStatus)
NTSTATUS	FAT16SetDirtyStatus (PDEVICE_EXTENSION DeviceExt, BOOLEAN DirtyStatus)
NTSTATUS	FAT32SetDirtyStatus (PDEVICE_EXTENSION DeviceExt, BOOLEAN DirtyStatus)
NTSTATUS	FAT32UpdateFreeClustersCount (PDEVICE_EXTENSION DeviceExt)
PVFATFCB	vfatNewFCB (PDEVICE_EXTENSION pVCB, PUNICODE_STRING pFileNameU)
NTSTATUS	vfatSetFCBNewDirName (PDEVICE_EXTENSION pVCB, PVFATFCB Fcb, PVFATFCB ParentFcb)
NTSTATUS	vfatUpdateFCB (PDEVICE_EXTENSION pVCB, PVFATFCB Fcb, PVFAT_DIRENTRY_CONTEXT DirContext, PVFATFCB ParentFcb)
VOID	vfatDestroyFCB (PVFATFCB pFCB)
VOID	vfatDestroyCCB (PVFATCCB pCcb)
VOID	vfatGrabFCB (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
VOID	vfatReleaseFCB (PDEVICE_EXTENSION pVCB, PVFATFCB pFCB)
PVFATFCB	vfatGrabFCBFromTable (PDEVICE_EXTENSION pDeviceExt, PUNICODE_STRING pFileNameU)
PVFATFCB	vfatMakeRootFCB (PDEVICE_EXTENSION pVCB)
PVFATFCB	vfatOpenRootFCB (PDEVICE_EXTENSION pVCB)
BOOLEAN	vfatFCBIsRoot (PVFATFCB FCB)
NTSTATUS	vfatAttachFCBToFileObject (PDEVICE_EXTENSION vcb, PVFATFCB fcb, PFILE_OBJECT fileObject)
NTSTATUS	vfatDirFindFile (PDEVICE_EXTENSION pVCB, PVFATFCB parentFCB, PUNICODE_STRING FileToFindU, PVFATFCB *fileFCB)
NTSTATUS	vfatGetFCBForFile (PDEVICE_EXTENSION pVCB, PVFATFCB *pParentFCB, PVFATFCB *pFCB, PUNICODE_STRING pFileNameU)
NTSTATUS	vfatMakeFCBFromDirEntry (PVCB vcb, PVFATFCB directoryFCB, PVFAT_DIRENTRY_CONTEXT DirContext, PVFATFCB *fileFCB)
NTSTATUS	VfatGetStandardInformation (PVFATFCB FCB, PFILE_STANDARD_INFORMATION StandardInfo, PULONG BufferLength)
NTSTATUS	VfatGetBasicInformation (PFILE_OBJECT FileObject, PVFATFCB FCB, PDEVICE_EXTENSION DeviceExt, PFILE_BASIC_INFORMATION BasicInfo, PULONG BufferLength)
NTSTATUS	VfatQueryInformation (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatSetInformation (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatSetAllocationSizeInformation (PFILE_OBJECT FileObject, PVFATFCB Fcb, PDEVICE_EXTENSION DeviceExt, PLARGE_INTEGER AllocationSize)
NTSTATUS	VfatFlush (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatFlushVolume (PDEVICE_EXTENSION DeviceExt, PVFATFCB VolumeFcb)
NTSTATUS	VfatFileSystemControl (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
NTSTATUS NTAPI	VfatBuildRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp)
PVOID	VfatGetUserBuffer (IN PIRP Irp, IN BOOLEAN Paging)
NTSTATUS	VfatLockUserBuffer (IN PIRP Irp, IN ULONG Length, IN LOCK_OPERATION Operation)
BOOLEAN	VfatCheckForDismount (IN PDEVICE_EXTENSION DeviceExt, IN BOOLEAN Create)
VOID NTAPI	VfatHandleDeferredWrite (IN PVOID IrpContext, IN PVOID Unused)
NTSTATUS	VfatPnp (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatRead (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatWrite (PVFAT_IRP_CONTEXT *pIrpContext)
NTSTATUS	NextCluster (PDEVICE_EXTENSION DeviceExt, ULONG FirstCluster, PULONG CurrentCluster, BOOLEAN Extend)
NTSTATUS NTAPI	VfatShutdown (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	vfatSplitPathName (PUNICODE_STRING PathNameU, PUNICODE_STRING DirNameU, PUNICODE_STRING FileNameU)
BOOLEAN	vfatIsLongIllegal (WCHAR c)
BOOLEAN	IsDotOrDotDot (PCUNICODE_STRING Name)
NTSTATUS	VfatQueryVolumeInformation (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS	VfatSetVolumeInformation (PVFAT_IRP_CONTEXT IrpContext)

Variables
PVFAT_GLOBAL_DATA	VfatGlobalData
DRIVER_DISPATCH	VfatBuildRequest
DRIVER_DISPATCH	VfatShutdown

Macro Definition Documentation

BLOCKSIZE

#define BLOCKSIZE   512

Definition at line 232 of file vfat.h.

CCB_DELETE_ON_CLOSE

#define CCB_DELETE_ON_CLOSE   0x0001

Definition at line 534 of file vfat.h.

ENABLE_SWAPOUT

#define ENABLE_SWAPOUT

Definition at line 16 of file vfat.h.

ENTRIES_PER_SECTOR

#define ENTRIES_PER_SECTOR   (BLOCKSIZE / sizeof(FATDirEntry))

Definition at line 557 of file vfat.h.

ENTRY_DELETED

#define ENTRY_DELETED	(		IsFatX,
			DirEntry
	)		(IsFatX ? FATX_ENTRY_DELETED(&((DirEntry)->FatX)) : FAT_ENTRY_DELETED(&((DirEntry)->Fat)))

Definition at line 205 of file vfat.h.

ENTRY_END

#define ENTRY_END	(		IsFatX,
			DirEntry
	)		(IsFatX ? FATX_ENTRY_END(&((DirEntry)->FatX)) : FAT_ENTRY_END(&((DirEntry)->Fat)))

Definition at line 207 of file vfat.h.

ENTRY_VOLUME

#define ENTRY_VOLUME	(		IsFatX,
			DirEntry
	)		(IsFatX ? FATX_ENTRY_VOLUME(&((DirEntry)->FatX)) : FAT_ENTRY_VOLUME(&((DirEntry)->Fat)))

Definition at line 206 of file vfat.h.

FAT12

#define FAT12   (2)

Definition at line 235 of file vfat.h.

FAT16

#define FAT16   (1)

Definition at line 234 of file vfat.h.

FAT32

#define FAT32   (3)

Definition at line 236 of file vfat.h.

FAT_DIRTY_BIT

#define FAT_DIRTY_BIT   0x01

Definition at line 85 of file vfat.h.

FAT_EAFILE

#define FAT_EAFILE   "EA DATA. SF"

Definition at line 132 of file vfat.h.

FAT_ENTRIES_PER_PAGE

#define FAT_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FAT_DIR_ENTRY))

Definition at line 219 of file vfat.h.

FAT_ENTRY_DELETED

#define FAT_ENTRY_DELETED

(

DirEntry

)

((DirEntry)->Filename[0] == 0xe5)

Definition at line 209 of file vfat.h.

FAT_ENTRY_END

#define FAT_ENTRY_END

(

DirEntry

)

((DirEntry)->Filename[0] == 0)

Definition at line 210 of file vfat.h.

FAT_ENTRY_LONG

#define FAT_ENTRY_LONG

(

DirEntry

)

(((DirEntry)->Attrib & 0x3f) == 0x0f)

Definition at line 211 of file vfat.h.

FAT_ENTRY_VOLUME

#define FAT_ENTRY_VOLUME

(

DirEntry

)

(((DirEntry)->Attrib & 0x1f) == 0x08)

Definition at line 212 of file vfat.h.

FATX16

#define FATX16   (4)

Definition at line 237 of file vfat.h.

FATX32

#define FATX32   (5)

Definition at line 238 of file vfat.h.

FATX_ENTRIES_PER_PAGE

#define FATX_ENTRIES_PER_PAGE   (PAGE_SIZE / sizeof (FATX_DIR_ENTRY))

Definition at line 220 of file vfat.h.

FATX_ENTRY_DELETED

#define FATX_ENTRY_DELETED

(

DirEntry

)

((DirEntry)->FilenameLength == 0xe5)

Definition at line 214 of file vfat.h.

FATX_ENTRY_END

#define FATX_ENTRY_END

(

DirEntry

)

((DirEntry)->FilenameLength == 0xff)

Definition at line 215 of file vfat.h.

FATX_ENTRY_LONG

#define FATX_ENTRY_LONG

(

DirEntry

)

(FALSE)

Definition at line 216 of file vfat.h.

FATX_ENTRY_VOLUME

#define FATX_ENTRY_VOLUME

(

DirEntry

)

(((DirEntry)->Attrib & 0x1f) == 0x08)

Definition at line 217 of file vfat.h.

FCB_CACHE_INITIALIZED

#define FCB_CACHE_INITIALIZED   0x0001

Definition at line 433 of file vfat.h.

FCB_DELAYED_CLOSE

#define FCB_DELAYED_CLOSE   0x0040

Definition at line 439 of file vfat.h.

FCB_DELETE_PENDING

#define FCB_DELETE_PENDING   0x0002

Definition at line 434 of file vfat.h.

FCB_IS_DIRTY

#define FCB_IS_DIRTY   0x0020

Definition at line 438 of file vfat.h.

FCB_IS_FAT

#define FCB_IS_FAT   0x0004

Definition at line 435 of file vfat.h.

FCB_IS_PAGE_FILE

#define FCB_IS_PAGE_FILE   0x0008

Definition at line 436 of file vfat.h.

FCB_IS_VOLUME

#define FCB_IS_VOLUME   0x0010

Definition at line 437 of file vfat.h.

IRPCONTEXT_CANWAIT

#define IRPCONTEXT_CANWAIT   0x0001

Definition at line 575 of file vfat.h.

IRPCONTEXT_COMPLETE

#define IRPCONTEXT_COMPLETE   0x0002

Definition at line 576 of file vfat.h.

IRPCONTEXT_DEFERRED_WRITE

#define IRPCONTEXT_DEFERRED_WRITE   0x0010

Definition at line 579 of file vfat.h.

IRPCONTEXT_PENDINGRETURNED

#define IRPCONTEXT_PENDINGRETURNED   0x0008

Definition at line 578 of file vfat.h.

IRPCONTEXT_QUEUE

#define IRPCONTEXT_QUEUE   0x0004

Definition at line 577 of file vfat.h.

LONGNAME_MAX_LENGTH

#define LONGNAME_MAX_LENGTH   256

Definition at line 203 of file vfat.h.

NODE_TYPE_FCB

#define NODE_TYPE_FCB   ((CSHORT)0x0502)

Definition at line 445 of file vfat.h.

ROUND_DOWN

#define ROUND_DOWN	(		n,
			align
	)		(((ULONG)n) & ~((align) - 1l))

Definition at line 25 of file vfat.h.

ROUND_DOWN_64

#define ROUND_DOWN_64	(		n,
			align
	)		(((ULONGLONG)n) & ~((align) - 1LL))

Definition at line 31 of file vfat.h.

ROUND_UP

#define ROUND_UP	(		n,
			align
	)		ROUND_DOWN(((ULONG)n) + (align) - 1, (align))

Definition at line 28 of file vfat.h.

ROUND_UP_64

#define ROUND_UP_64	(		n,
			align
	)		ROUND_DOWN_64(((ULONGLONG)n) + (align) - 1LL, (align))

Definition at line 34 of file vfat.h.

STATISTICS_SIZE_NO_PAD

#define STATISTICS_SIZE_NO_PAD   (sizeof(FILESYSTEM_STATISTICS) + sizeof(FAT_STATISTICS))

Definition at line 304 of file vfat.h.

TAG_BUFFER

#define TAG_BUFFER   'OtaF'

Definition at line 551 of file vfat.h.

TAG_CCB

#define TAG_CCB   'CtaF'

Definition at line 546 of file vfat.h.

TAG_CLOSE

#define TAG_CLOSE   'xtaF'

Definition at line 549 of file vfat.h.

TAG_DIRENT

#define TAG_DIRENT   'DtaF'

Definition at line 555 of file vfat.h.

TAG_FCB

#define TAG_FCB   'FtaF'

Definition at line 547 of file vfat.h.

TAG_IRP

#define TAG_IRP   'ItaF'

Definition at line 548 of file vfat.h.

TAG_NAME

#define TAG_NAME   'ntaF'

Definition at line 553 of file vfat.h.

TAG_SEARCH

#define TAG_SEARCH   'LtaF'

Definition at line 554 of file vfat.h.

TAG_STATS

#define TAG_STATS   'VtaF'

Definition at line 550 of file vfat.h.

TAG_VPB

#define TAG_VPB   'vtaF'

Definition at line 552 of file vfat.h.

USE_ROS_CC_AND_FS

#define USE_ROS_CC_AND_FS

Definition at line 15 of file vfat.h.

VCB_CLEAR_DIRTY

#define VCB_CLEAR_DIRTY   0x8000 /* Clean dirty flag at shutdown */

Definition at line 245 of file vfat.h.

VCB_DISMOUNT_PENDING

#define VCB_DISMOUNT_PENDING   0x0002

Definition at line 241 of file vfat.h.

VCB_GOOD

#define VCB_GOOD   0x0010 /* If not set, the VCB is improper for usage */

Definition at line 247 of file vfat.h.

VCB_IS_DIRTY

#define VCB_IS_DIRTY   0x4000 /* Volume is dirty */

Definition at line 244 of file vfat.h.

VCB_IS_FATX

#define VCB_IS_FATX   0x0004

Definition at line 242 of file vfat.h.

VCB_IS_SYS_OR_HAS_PAGE

#define VCB_IS_SYS_OR_HAS_PAGE   0x0008

Definition at line 243 of file vfat.h.

VCB_VOLUME_LOCKED

#define VCB_VOLUME_LOCKED   0x0001

Definition at line 240 of file vfat.h.

VFAT_BREAK_ON_CORRUPTION

#define VFAT_BREAK_ON_CORRUPTION   1

Definition at line 407 of file vfat.h.

VFAT_CASE_LOWER_BASE

#define VFAT_CASE_LOWER_BASE   8

Definition at line 200 of file vfat.h.

VFAT_CASE_LOWER_EXT

#define VFAT_CASE_LOWER_EXT   16

Definition at line 201 of file vfat.h.

vfatAddToStat

#define vfatAddToStat	(		Vcb,
			Stat,
			Inc
	)

Value:

{                                                                                                             \
    PSTATISTICS Stats = &(Vcb)->Statistics[KeGetCurrentProcessorNumber() % VfatGlobalData->NumberProcessors]; \
    Stats->Stat += Inc;                                                                                       \
}

Definition at line 671 of file vfat.h.

VOLUME_IS_NOT_CACHED_WORK_AROUND_IT

#define VOLUME_IS_NOT_CACHED_WORK_AROUND_IT

Definition at line 22 of file vfat.h.

Typedef Documentation

BootSector

typedef struct _BootSector BootSector

Definition at line 108 of file vfat.h.

DEVICE_EXTENSION

typedef struct DEVICE_EXTENSION DEVICE_EXTENSION

DIR_ENTRY

typedef union _DIR_ENTRY DIR_ENTRY

Definition at line 230 of file vfat.h.

DOSDATE

typedef struct __DOSDATE DOSDATE

DOSTIME

typedef struct __DOSTIME DOSTIME

FAT_DIR_ENTRY

typedef struct _FATDirEntry FAT_DIR_ENTRY

Definition at line 167 of file vfat.h.

FAT_EA_FILE_HEADER

typedef struct _EAFileHeader FAT_EA_FILE_HEADER

Definition at line 134 of file vfat.h.

FAT_EA_HEADER

typedef struct _EAHeader FAT_EA_HEADER

Definition at line 156 of file vfat.h.

FAT_EA_SET_HEADER

typedef struct _EASetHeader FAT_EA_SET_HEADER

Definition at line 143 of file vfat.h.

FATX_DIR_ENTRY

typedef struct _FATXDirEntry FATX_DIR_ENTRY

Definition at line 222 of file vfat.h.

HASHENTRY

typedef struct _HASHENTRY HASHENTRY

PADD_ENTRY

typedef NTSTATUS(* PADD_ENTRY) (PDEVICE_EXTENSION, PUNICODE_STRING, struct _VFATFCB **, struct _VFATFCB *, ULONG, UCHAR, struct _VFAT_MOVE_CONTEXT *)

Definition at line 290 of file vfat.h.

PDEL_ENTRY

typedef NTSTATUS(* PDEL_ENTRY) (PDEVICE_EXTENSION, struct _VFATFCB *, struct _VFAT_MOVE_CONTEXT *)

Definition at line 291 of file vfat.h.

PDEVICE_EXTENSION

typedef struct DEVICE_EXTENSION* PDEVICE_EXTENSION

Definition at line 283 of file vfat.h.

PDIR_ENTRY

typedef union _DIR_ENTRY * PDIR_ENTRY

Definition at line 230 of file vfat.h.

PDOSDATE

typedef struct __DOSDATE * PDOSDATE

PDOSTIME

typedef struct __DOSTIME * PDOSTIME

PFAT_DIR_ENTRY

typedef struct _FATDirEntry * PFAT_DIR_ENTRY

Definition at line 167 of file vfat.h.

PFAT_EA_FILE_HEADER

typedef struct _EAFileHeader * PFAT_EA_FILE_HEADER

Definition at line 134 of file vfat.h.

PFAT_EA_HEADER

typedef struct _EAHeader * PFAT_EA_HEADER

Definition at line 156 of file vfat.h.

PFAT_EA_SET_HEADER

typedef struct _EASetHeader * PFAT_EA_SET_HEADER

Definition at line 143 of file vfat.h.

PFATINFO

typedef struct FATINFO * PFATINFO

PFATX_DIR_ENTRY

typedef struct _FATXDirEntry * PFATX_DIR_ENTRY

Definition at line 222 of file vfat.h.

PFIND_AND_MARK_AVAILABLE_CLUSTER

typedef NTSTATUS(* PFIND_AND_MARK_AVAILABLE_CLUSTER) (PDEVICE_EXTENSION, PULONG)

Definition at line 286 of file vfat.h.

PGET_DIRTY_STATUS

typedef NTSTATUS(* PGET_DIRTY_STATUS) (PDEVICE_EXTENSION, PBOOLEAN)

Definition at line 293 of file vfat.h.

PGET_NEXT_CLUSTER

typedef NTSTATUS(* PGET_NEXT_CLUSTER) (PDEVICE_EXTENSION, ULONG, PULONG)

Definition at line 285 of file vfat.h.

PGET_NEXT_DIR_ENTRY

typedef NTSTATUS(* PGET_NEXT_DIR_ENTRY) (PVOID *, PVOID *, struct _VFATFCB *, struct _VFAT_DIRENTRY_CONTEXT *, BOOLEAN)

Definition at line 292 of file vfat.h.

PIS_DIRECTORY_EMPTY

typedef BOOLEAN(* PIS_DIRECTORY_EMPTY) (PDEVICE_EXTENSION, struct _VFATFCB *)

Definition at line 289 of file vfat.h.

PSET_DIRTY_STATUS

typedef NTSTATUS(* PSET_DIRTY_STATUS) (PDEVICE_EXTENSION, BOOLEAN)

Definition at line 294 of file vfat.h.

PSTATISTICS

typedef struct _STATISTICS * PSTATISTICS

PVCB

typedef struct DEVICE_EXTENSION * PVCB

PVFAT_CLOSE_CONTEXT

typedef struct _VFAT_CLOSE_CONTEXT * PVFAT_CLOSE_CONTEXT

PVFAT_DIRENTRY_CONTEXT

typedef struct _VFAT_DIRENTRY_CONTEXT * PVFAT_DIRENTRY_CONTEXT

PVFAT_DISPATCH

typedef struct _VFAT_DISPATCH * PVFAT_DISPATCH

PVFAT_GLOBAL_DATA

typedef struct VFAT_GLOBAL_DATA * PVFAT_GLOBAL_DATA

PVFAT_IRP_CONTEXT

typedef struct VFAT_IRP_CONTEXT * PVFAT_IRP_CONTEXT

PVFAT_MOVE_CONTEXT

typedef struct _VFAT_MOVE_CONTEXT * PVFAT_MOVE_CONTEXT

PVFATCCB

typedef struct _VFATCCB * PVFATCCB

PVFATFCB

typedef struct _VFATFCB * PVFATFCB

PWRITE_CLUSTER

typedef NTSTATUS(* PWRITE_CLUSTER) (PDEVICE_EXTENSION, ULONG, ULONG, PULONG)

Definition at line 287 of file vfat.h.

slot

typedef struct _slot slot

Definition at line 196 of file vfat.h.

STATISTICS

typedef struct _STATISTICS STATISTICS

VCB

typedef struct DEVICE_EXTENSION VCB

VFAT_CLOSE_CONTEXT

typedef struct _VFAT_CLOSE_CONTEXT VFAT_CLOSE_CONTEXT

VFAT_DIRENTRY_CONTEXT

typedef struct _VFAT_DIRENTRY_CONTEXT VFAT_DIRENTRY_CONTEXT

VFAT_DISPATCH

typedef struct _VFAT_DISPATCH VFAT_DISPATCH

VFAT_MOVE_CONTEXT

typedef struct _VFAT_MOVE_CONTEXT VFAT_MOVE_CONTEXT

VFATCCB

typedef struct _VFATCCB VFATCCB

VFATFCB

typedef struct _VFATFCB VFATFCB

Function Documentation

ClusterToSector()

ULONGLONG ClusterToSector	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	Cluster
	)

Definition at line 731 of file fat.c.

{
    return DeviceExt->FatInfo.dataStart +
           ((ULONGLONG)(Cluster - 2) * DeviceExt->FatInfo.SectorsPerCluster);
 
}

Referenced by VfatReadFileData(), and VfatWriteFileData().

CountAvailableClusters()

NTSTATUS CountAvailableClusters	(	PDEVICE_EXTENSION	DeviceExt,
		PLARGE_INTEGER	Clusters
	)

Definition at line 541 of file fat.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    ExAcquireResourceExclusiveLite (&DeviceExt->FatResource, TRUE);
    if (!DeviceExt->AvailableClustersValid)
    {
        if (DeviceExt->FatInfo.FatType == FAT12)
            Status = FAT12CountAvailableClusters(DeviceExt);
        else if (DeviceExt->FatInfo.FatType == FAT16 || DeviceExt->FatInfo.FatType == FATX16)
            Status = FAT16CountAvailableClusters(DeviceExt);
        else
            Status = FAT32CountAvailableClusters(DeviceExt);
    }
    if (Clusters != NULL)
    {
        Clusters->QuadPart = DeviceExt->AvailableClusters;
    }
    ExReleaseResourceLite (&DeviceExt->FatResource);
 
    return Status;
}

Referenced by FsdGetFsFullSizeInformation(), FsdGetFsSizeInformation(), and VfatMount().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 16 of file battc.c.

{
    DPRINT("Battery class driver initialized\n");
 
    return STATUS_SUCCESS;
}

FAT12FindAndMarkAvailableCluster()

NTSTATUS FAT12FindAndMarkAvailableCluster	(	PDEVICE_EXTENSION	DeviceExt,
		PULONG	Cluster
	)

Definition at line 244 of file fat.c.

{
    ULONG FatLength;
    ULONG StartCluster;
    ULONG Entry;
    PUSHORT CBlock;
    ULONG i, j;
    PVOID BaseAddress;
    PVOID Context;
    LARGE_INTEGER Offset;
 
    FatLength = DeviceExt->FatInfo.NumberOfClusters + 2;
    *Cluster = 0;
    StartCluster = DeviceExt->LastAvailableCluster;
    Offset.QuadPart = 0;
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector);
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    for (j = 0; j < 2; j++)
    {
        for (i = StartCluster; i < FatLength; i++)
        {
            CBlock = (PUSHORT)((char*)BaseAddress + (i * 12) / 8);
            if ((i % 2) == 0)
            {
                Entry = *CBlock & 0xfff;
            }
            else
            {
                Entry = *CBlock >> 4;
            }
 
            if (Entry == 0)
            {
                DPRINT("Found available cluster 0x%x\n", i);
                DeviceExt->LastAvailableCluster = *Cluster = i;
                if ((i % 2) == 0)
                    *CBlock = (*CBlock & 0xf000) | 0xfff;
                else
                    *CBlock = (*CBlock & 0xf) | 0xfff0;
                CcSetDirtyPinnedData(Context, NULL);
                CcUnpinData(Context);
                if (DeviceExt->AvailableClustersValid)
                    InterlockedDecrement((PLONG)&DeviceExt->AvailableClusters);
                return STATUS_SUCCESS;
            }
        }
        FatLength = StartCluster;
        StartCluster = 2;
    }
    CcUnpinData(Context);
    return STATUS_DISK_FULL;
}

Referenced by VfatMount().

FAT12GetNextCluster()

NTSTATUS FAT12GetNextCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	CurrentCluster,
		PULONG	NextCluster
	)

Definition at line 123 of file fat.c.

{
    PUSHORT CBlock;
    ULONG Entry;
    PVOID BaseAddress;
    PVOID Context;
    LARGE_INTEGER Offset;
 
    *NextCluster = 0;
 
    Offset.QuadPart = 0;
    _SEH2_TRY
    {
        CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, MAP_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    CBlock = (PUSHORT)((char*)BaseAddress + (CurrentCluster * 12) / 8);
    if ((CurrentCluster % 2) == 0)
    {
         Entry = *CBlock & 0x0fff;
    }
    else
    {
        Entry = *CBlock >> 4;
    }
 
//    DPRINT("Entry %x\n",Entry);
    if (Entry >= 0xff8 && Entry <= 0xfff)
        Entry = 0xffffffff;
 
//    DPRINT("Returning %x\n",Entry);
    ASSERT(Entry != 0);
    *NextCluster = Entry;
    CcUnpinData(Context);
//    return Entry == 0xffffffff ? STATUS_END_OF_FILE : STATUS_SUCCESS;
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FAT12WriteCluster()

NTSTATUS FAT12WriteCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	ClusterToWrite,
		ULONG	NewValue,
		PULONG	OldValue
	)

Definition at line 570 of file fat.c.

{
    ULONG FATOffset;
    PUCHAR CBlock;
    PVOID BaseAddress;
    PVOID Context;
    LARGE_INTEGER Offset;
 
    Offset.QuadPart = 0;
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
    CBlock = (PUCHAR)BaseAddress;
 
    FATOffset = (ClusterToWrite * 12) / 8;
    DPRINT("Writing 0x%x for 0x%x at 0x%x\n",
           NewValue, ClusterToWrite, FATOffset);
    if ((ClusterToWrite % 2) == 0)
    {
        *OldValue = CBlock[FATOffset] + ((CBlock[FATOffset + 1] & 0x0f) << 8);
        CBlock[FATOffset] = (UCHAR)NewValue;
        CBlock[FATOffset + 1] &= 0xf0;
        CBlock[FATOffset + 1] |= (NewValue & 0xf00) >> 8;
    }
    else
    {
        *OldValue = (CBlock[FATOffset] >> 4) + (CBlock[FATOffset + 1] << 4);
        CBlock[FATOffset] &= 0x0f;
        CBlock[FATOffset] |= (NewValue & 0xf) << 4;
        CBlock[FATOffset + 1] = (UCHAR)(NewValue >> 4);
    }
    /* Write the changed FAT sector(s) to disk */
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FAT16FindAndMarkAvailableCluster()

NTSTATUS FAT16FindAndMarkAvailableCluster	(	PDEVICE_EXTENSION	DeviceExt,
		PULONG	Cluster
	)

Definition at line 173 of file fat.c.

{
    ULONG FatLength;
    ULONG StartCluster;
    ULONG i, j;
    PVOID BaseAddress;
    ULONG ChunkSize;
    PVOID Context = 0;
    LARGE_INTEGER Offset;
    PUSHORT Block;
    PUSHORT BlockEnd;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
    FatLength = (DeviceExt->FatInfo.NumberOfClusters + 2);
    *Cluster = 0;
    StartCluster = DeviceExt->LastAvailableCluster;
 
    for (j = 0; j < 2; j++)
    {
        for (i = StartCluster; i < FatLength;)
        {
            Offset.QuadPart = ROUND_DOWN(i * 2, ChunkSize);
            _SEH2_TRY
            {
                CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
                _SEH2_YIELD(return _SEH2_GetExceptionCode());
            }
            _SEH2_END;
 
            Block = (PUSHORT)((ULONG_PTR)BaseAddress + (i * 2) % ChunkSize);
            BlockEnd = (PUSHORT)((ULONG_PTR)BaseAddress + ChunkSize);
 
            /* Now process the whole block */
            while (Block < BlockEnd && i < FatLength)
            {
                if (*Block == 0)
                {
                    DPRINT("Found available cluster 0x%x\n", i);
                    DeviceExt->LastAvailableCluster = *Cluster = i;
                    *Block = 0xffff;
                    CcSetDirtyPinnedData(Context, NULL);
                    CcUnpinData(Context);
                    if (DeviceExt->AvailableClustersValid)
                        InterlockedDecrement((PLONG)&DeviceExt->AvailableClusters);
                    return STATUS_SUCCESS;
                }
 
                Block++;
                i++;
            }
 
            CcUnpinData(Context);
        }
 
        FatLength = StartCluster;
        StartCluster = 2;
    }
 
    return STATUS_DISK_FULL;
}

Referenced by VfatMount().

FAT16GetDirtyStatus()

NTSTATUS FAT16GetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		PBOOLEAN	DirtyStatus
	)

Definition at line 858 of file fat.c.

{
    LARGE_INTEGER Offset;
    ULONG Length;
#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    NTSTATUS Status;
#else
    PVOID Context;
#endif
    struct _BootSector * Sector;
 
    /* We'll read the bootsector at 0 */
    Offset.QuadPart = 0;
    Length = DeviceExt->FatInfo.BytesPerSector;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Go through Cc for this */
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
#else
    /* No Cc, do it the old way:
     * - Allocate a big enough buffer
     * - And read the disk
     */
    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_BUFFER);
    if (Sector == NULL)
    {
        *DirtyStatus = TRUE;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    if  (!NT_SUCCESS(Status))
    {
        *DirtyStatus = TRUE;
        ExFreePoolWithTag(Sector, TAG_BUFFER);
        return Status;
    }
#endif
 
    /* Make sure we have a boot sector...
     * FIXME: This check is a bit lame and should be improved
     */
    if (Sector->Signatur1 != 0xaa55)
    {
        /* Set we are dirty so that we don't attempt anything */
        *DirtyStatus = TRUE;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
        CcUnpinData(Context);
#else
        ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
        return STATUS_DISK_CORRUPT_ERROR;
    }
 
    /* Return the status of the dirty bit */
    if (Sector->Res1 & FAT_DIRTY_BIT)
        *DirtyStatus = TRUE;
    else
        *DirtyStatus = FALSE;
 
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    CcUnpinData(Context);
#else
    ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FAT16GetNextCluster()

NTSTATUS FAT16GetNextCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	CurrentCluster,
		PULONG	NextCluster
	)

Definition at line 77 of file fat.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PVOID BaseAddress;
    ULONG FATOffset;
    ULONG ChunkSize;
    PVOID Context;
    LARGE_INTEGER Offset;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
    FATOffset = CurrentCluster * 2;
    Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
    _SEH2_TRY
    {
        CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    CurrentCluster = *((PUSHORT)((char*)BaseAddress + (FATOffset % ChunkSize)));
    if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
        CurrentCluster = 0xffffffff;
 
    if (CurrentCluster == 0)
    {
        DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
        Status = STATUS_FILE_CORRUPT_ERROR;
        if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
            ASSERT(CurrentCluster != 0);
    }
 
    CcUnpinData(Context);
    *NextCluster = CurrentCluster;
    return Status;
}

Referenced by VfatMount().

FAT16SetDirtyStatus()

NTSTATUS FAT16SetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		BOOLEAN	DirtyStatus
	)

Definition at line 1044 of file fat.c.

{
    LARGE_INTEGER Offset;
    ULONG Length;
#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    NTSTATUS Status;
#else
    PVOID Context;
#endif
    struct _BootSector * Sector;
 
    /* We'll read (and then write) the bootsector at 0 */
    Offset.QuadPart = 0;
    Length = DeviceExt->FatInfo.BytesPerSector;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Go through Cc for this */
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
#else
    /* No Cc, do it the old way:
     * - Allocate a big enough buffer
     * - And read the disk
     */
    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_BUFFER);
    if (Sector == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    if  (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(Sector, TAG_BUFFER);
        return Status;
    }
#endif
 
    /* Make sure we have a boot sector...
     * FIXME: This check is a bit lame and should be improved
     */
    if (Sector->Signatur1 != 0xaa55)
    {
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
        CcUnpinData(Context);
#else
        ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
        return STATUS_DISK_CORRUPT_ERROR;
    }
 
    /* Modify the dirty bit status according
     * to caller needs
     */
    if (!DirtyStatus)
    {
        Sector->Res1 &= ~FAT_DIRTY_BIT;
    }
    else
    {
        Sector->Res1 |= FAT_DIRTY_BIT;
    }
 
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Mark boot sector dirty so that it gets written to the disk */
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
    return STATUS_SUCCESS;
#else
    /* Write back the boot sector to the disk */
    Status = VfatWriteDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    ExFreePoolWithTag(Sector, TAG_BUFFER);
    return Status;
#endif
}

Referenced by VfatMount().

FAT16WriteCluster()

NTSTATUS FAT16WriteCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	ClusterToWrite,
		ULONG	NewValue,
		PULONG	OldValue
	)

Definition at line 621 of file fat.c.

{
    PVOID BaseAddress;
    ULONG FATOffset;
    ULONG ChunkSize;
    PVOID Context;
    LARGE_INTEGER Offset;
    PUSHORT Cluster;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
    FATOffset = ClusterToWrite * 2;
    Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
           ClusterToWrite);
    Cluster = ((PUSHORT)((char*)BaseAddress + (FATOffset % ChunkSize)));
    *OldValue = *Cluster;
    *Cluster = (USHORT)NewValue;
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FAT32FindAndMarkAvailableCluster()

NTSTATUS FAT32FindAndMarkAvailableCluster	(	PDEVICE_EXTENSION	DeviceExt,
		PULONG	Cluster
	)

Definition at line 312 of file fat.c.

{
    ULONG FatLength;
    ULONG StartCluster;
    ULONG i, j;
    PVOID BaseAddress;
    ULONG ChunkSize;
    PVOID Context;
    LARGE_INTEGER Offset;
    PULONG Block;
    PULONG BlockEnd;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
    FatLength = (DeviceExt->FatInfo.NumberOfClusters + 2);
    *Cluster = 0;
    StartCluster = DeviceExt->LastAvailableCluster;
 
    for (j = 0; j < 2; j++)
    {
        for (i = StartCluster; i < FatLength;)
        {
            Offset.QuadPart = ROUND_DOWN(i * 4, ChunkSize);
            _SEH2_TRY
            {
                CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
                _SEH2_YIELD(return _SEH2_GetExceptionCode());
            }
            _SEH2_END;
            Block = (PULONG)((ULONG_PTR)BaseAddress + (i * 4) % ChunkSize);
            BlockEnd = (PULONG)((ULONG_PTR)BaseAddress + ChunkSize);
 
            /* Now process the whole block */
            while (Block < BlockEnd && i < FatLength)
            {
                if ((*Block & 0x0fffffff) == 0)
                {
                    DPRINT("Found available cluster 0x%x\n", i);
                    DeviceExt->LastAvailableCluster = *Cluster = i;
                    *Block = 0x0fffffff;
                    CcSetDirtyPinnedData(Context, NULL);
                    CcUnpinData(Context);
                    if (DeviceExt->AvailableClustersValid)
                        InterlockedDecrement((PLONG)&DeviceExt->AvailableClusters);
                    return STATUS_SUCCESS;
                }
 
                Block++;
                i++;
            }
 
            CcUnpinData(Context);
        }
        FatLength = StartCluster;
        StartCluster = 2;
    }
    return STATUS_DISK_FULL;
}

Referenced by VfatMount().

FAT32GetDirtyStatus()

NTSTATUS FAT32GetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		PBOOLEAN	DirtyStatus
	)

Definition at line 936 of file fat.c.

{
    LARGE_INTEGER Offset;
    ULONG Length;
#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    NTSTATUS Status;
#else
    PVOID Context;
#endif
    struct _BootSector32 * Sector;
 
    /* We'll read the bootsector at 0 */
    Offset.QuadPart = 0;
    Length = DeviceExt->FatInfo.BytesPerSector;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Go through Cc for this */
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
#else
    /* No Cc, do it the old way:
     * - Allocate a big enough buffer
     * - And read the disk
     */
    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_BUFFER);
    if (Sector == NULL)
    {
        *DirtyStatus = TRUE;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    if  (!NT_SUCCESS(Status))
    {
        *DirtyStatus = TRUE;
        ExFreePoolWithTag(Sector, TAG_BUFFER);
        return Status;
    }
#endif
 
    /* Make sure we have a boot sector...
     * FIXME: This check is a bit lame and should be improved
     */
    if (Sector->Signature1 != 0xaa55)
    {
        /* Set we are dirty so that we don't attempt anything */
        *DirtyStatus = TRUE;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
        CcUnpinData(Context);
#else
        ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
        return STATUS_DISK_CORRUPT_ERROR;
    }
 
    /* Return the status of the dirty bit */
    if (Sector->Res4 & FAT_DIRTY_BIT)
        *DirtyStatus = TRUE;
    else
        *DirtyStatus = FALSE;
 
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    CcUnpinData(Context);
#else
    ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FAT32GetNextCluster()

NTSTATUS FAT32GetNextCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	CurrentCluster,
		PULONG	NextCluster
	)

Definition at line 28 of file fat.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PVOID BaseAddress;
    ULONG FATOffset;
    ULONG ChunkSize;
    PVOID Context = NULL;
    LARGE_INTEGER Offset;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
    FATOffset = CurrentCluster * sizeof(ULONG);
    Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
    _SEH2_TRY
    {
        if (!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress))
        {
            NT_ASSERT(FALSE);
            return STATUS_UNSUCCESSFUL;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    CurrentCluster = (*(PULONG)((char*)BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff;
    if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
        CurrentCluster = 0xffffffff;
 
    if (CurrentCluster == 0)
    {
        DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
        Status = STATUS_FILE_CORRUPT_ERROR;
        if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
            ASSERT(CurrentCluster != 0);
    }
    CcUnpinData(Context);
    *NextCluster = CurrentCluster;
    return Status;
}

Referenced by VfatMount().

FAT32SetDirtyStatus()

NTSTATUS FAT32SetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		BOOLEAN	DirtyStatus
	)

Definition at line 1129 of file fat.c.

{
    LARGE_INTEGER Offset;
    ULONG Length;
#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    NTSTATUS Status;
#else
    PVOID Context;
#endif
    struct _BootSector32 * Sector;
 
    /* We'll read (and then write) the bootsector at 0 */
    Offset.QuadPart = 0;
    Length = DeviceExt->FatInfo.BytesPerSector;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Go through Cc for this */
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
#else
    /* No Cc, do it the old way:
     * - Allocate a big enough buffer
     * - And read the disk
     */
    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_BUFFER);
    if (Sector == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    if  (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(Sector, TAG_BUFFER);
        return Status;
    }
#endif
 
    /* Make sure we have a boot sector...
     * FIXME: This check is a bit lame and should be improved
     */
    if (Sector->Signature1 != 0xaa55)
    {
        ASSERT(FALSE);
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
        CcUnpinData(Context);
#else
        ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
        return STATUS_DISK_CORRUPT_ERROR;
    }
 
    /* Modify the dirty bit status according
     * to caller needs
     */
    if (!DirtyStatus)
    {
        Sector->Res4 &= ~FAT_DIRTY_BIT;
    }
    else
    {
        Sector->Res4 |= FAT_DIRTY_BIT;
    }
 
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Mark boot sector dirty so that it gets written to the disk */
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
    return STATUS_SUCCESS;
#else
    /* Write back the boot sector to the disk */
    Status = VfatWriteDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    ExFreePoolWithTag(Sector, TAG_BUFFER);
    return Status;
#endif
}

Referenced by VfatMount().

FAT32UpdateFreeClustersCount()

NTSTATUS FAT32UpdateFreeClustersCount

(

PDEVICE_EXTENSION

DeviceExt

)

Definition at line 1215 of file fat.c.

{
    LARGE_INTEGER Offset;
    ULONG Length;
#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    NTSTATUS Status;
#else
    PVOID Context;
#endif
    struct _FsInfoSector * Sector;
 
    if (!DeviceExt->AvailableClustersValid)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* We'll read (and then write) the fsinfo sector */
    Offset.QuadPart = DeviceExt->FatInfo.FSInfoSector * DeviceExt->FatInfo.BytesPerSector;
    Length = DeviceExt->FatInfo.BytesPerSector;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Go through Cc for this */
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
#else
    /* No Cc, do it the old way:
     * - Allocate a big enough buffer
     * - And read the disk
     */
    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_BUFFER);
    if (Sector == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    if  (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(Sector, TAG_BUFFER);
        return Status;
    }
#endif
 
    /* Make sure we have a FSINFO sector */
    if (Sector->ExtBootSignature2 != 0x41615252 ||
        Sector->FSINFOSignature != 0x61417272 ||
        Sector->Signatur2 != 0xaa550000)
    {
        ASSERT(FALSE);
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
        CcUnpinData(Context);
#else
        ExFreePoolWithTag(Sector, TAG_BUFFER);
#endif
        return STATUS_DISK_CORRUPT_ERROR;
    }
 
    /* Update the free clusters count */
    Sector->FreeCluster = InterlockedCompareExchange((PLONG)&DeviceExt->AvailableClusters, 0, 0);
 
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
    /* Mark FSINFO sector dirty so that it gets written to the disk */
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
    return STATUS_SUCCESS;
#else
    /* Write back the FSINFO sector to the disk */
    Status = VfatWriteDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
    ExFreePoolWithTag(Sector, TAG_BUFFER);
    return Status;
#endif
}

Referenced by FATAddEntry(), FATDelEntry(), and VfatSetAllocationSizeInformation().

FAT32WriteCluster()

NTSTATUS FAT32WriteCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	ClusterToWrite,
		ULONG	NewValue,
		PULONG	OldValue
	)

Definition at line 661 of file fat.c.

{
    PVOID BaseAddress;
    ULONG FATOffset;
    ULONG ChunkSize;
    PVOID Context;
    LARGE_INTEGER Offset;
    PULONG Cluster;
 
    ChunkSize = CACHEPAGESIZE(DeviceExt);
 
    FATOffset = (ClusterToWrite * 4);
    Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
    _SEH2_TRY
    {
        CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
           ClusterToWrite);
    Cluster = ((PULONG)((char*)BaseAddress + (FATOffset % ChunkSize)));
    *OldValue = *Cluster & 0x0fffffff;
    *Cluster = (*Cluster & 0xf0000000) | (NewValue & 0x0fffffff);
 
    CcSetDirtyPinnedData(Context, NULL);
    CcUnpinData(Context);
 
    return STATUS_SUCCESS;
}

Referenced by VfatMount().

FindFile()

NTSTATUS FindFile	(	PDEVICE_EXTENSION	DeviceExt,
		PVFATFCB	Parent,
		PUNICODE_STRING	FileToFindU,
		PVFAT_DIRENTRY_CONTEXT	DirContext,
		BOOLEAN	First
	)

Definition at line 83 of file create.c.

{
    PWCHAR PathNameBuffer;
    USHORT PathNameBufferLength;
    NTSTATUS Status;
    PVOID Context = NULL;
    PVOID Page;
    PVFATFCB rcFcb;
    BOOLEAN Found;
    UNICODE_STRING PathNameU;
    UNICODE_STRING FileToFindUpcase;
    BOOLEAN WildCard;
    BOOLEAN IsFatX = vfatVolumeIsFatX(DeviceExt);
 
    DPRINT("FindFile(Parent %p, FileToFind '%wZ', DirIndex: %u)\n",
           Parent, FileToFindU, DirContext->DirIndex);
    DPRINT("FindFile: Path %wZ\n",&Parent->PathNameU);
 
    PathNameBufferLength = LONGNAME_MAX_LENGTH * sizeof(WCHAR);
    PathNameBuffer = ExAllocatePoolWithTag(NonPagedPool, PathNameBufferLength + sizeof(WCHAR), TAG_NAME);
    if (!PathNameBuffer)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    PathNameU.Buffer = PathNameBuffer;
    PathNameU.Length = 0;
    PathNameU.MaximumLength = PathNameBufferLength;
 
    DirContext->LongNameU.Length = 0;
    DirContext->ShortNameU.Length = 0;
 
    WildCard = FsRtlDoesNameContainWildCards(FileToFindU);
 
    if (WildCard == FALSE)
    {
        /* if there is no '*?' in the search name, than look first for an existing fcb */
        RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
        if (!vfatFCBIsRoot(Parent))
        {
            PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
            PathNameU.Length += sizeof(WCHAR);
        }
        RtlAppendUnicodeStringToString(&PathNameU, FileToFindU);
        PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
        rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
        if (rcFcb)
        {
            ULONG startIndex = rcFcb->startIndex;
            if (IsFatX && !vfatFCBIsRoot(Parent))
            {
                startIndex += 2;
            }
            if(startIndex >= DirContext->DirIndex)
            {
                RtlCopyUnicodeString(&DirContext->LongNameU, &rcFcb->LongNameU);
                RtlCopyUnicodeString(&DirContext->ShortNameU, &rcFcb->ShortNameU);
                RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
                DirContext->StartIndex = rcFcb->startIndex;
                DirContext->DirIndex = rcFcb->dirIndex;
                DPRINT("FindFile: new Name %wZ, DirIndex %u (%u)\n",
                    &DirContext->LongNameU, DirContext->DirIndex, DirContext->StartIndex);
                Status = STATUS_SUCCESS;
            }
            else
            {
                DPRINT("FCB not found for %wZ\n", &PathNameU);
                Status = STATUS_UNSUCCESSFUL;
            }
            vfatReleaseFCB(DeviceExt, rcFcb);
            ExFreePoolWithTag(PathNameBuffer, TAG_NAME);
            return Status;
        }
    }
 
    /* FsRtlIsNameInExpression need the searched string to be upcase,
    * even if IgnoreCase is specified */
    Status = RtlUpcaseUnicodeString(&FileToFindUpcase, FileToFindU, TRUE);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(PathNameBuffer, TAG_NAME);
        return Status;
    }
 
    while (TRUE)
    {
        Status = VfatGetNextDirEntry(DeviceExt, &Context, &Page, Parent, DirContext, First);
        First = FALSE;
        if (Status == STATUS_NO_MORE_ENTRIES)
        {
            break;
        }
        if (ENTRY_VOLUME(IsFatX, &DirContext->DirEntry))
        {
            DirContext->DirIndex++;
            continue;
        }
        if (DirContext->LongNameU.Length == 0 ||
            DirContext->ShortNameU.Length == 0)
        {
            DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
            if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
            {
                ASSERT(DirContext->LongNameU.Length != 0 &&
                       DirContext->ShortNameU.Length != 0);
            }
            DirContext->DirIndex++;
            continue;
        }
        if (WildCard)
        {
            Found = FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->LongNameU, TRUE, NULL) ||
                FsRtlIsNameInExpression(&FileToFindUpcase, &DirContext->ShortNameU, TRUE, NULL);
        }
        else
        {
            Found = FsRtlAreNamesEqual(&DirContext->LongNameU, FileToFindU, TRUE, NULL) ||
                FsRtlAreNamesEqual(&DirContext->ShortNameU, FileToFindU, TRUE, NULL);
        }
 
        if (Found)
        {
            if (WildCard)
            {
                RtlCopyUnicodeString(&PathNameU, &Parent->PathNameU);
                if (!vfatFCBIsRoot(Parent))
                {
                    PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = L'\\';
                    PathNameU.Length += sizeof(WCHAR);
                }
                RtlAppendUnicodeStringToString(&PathNameU, &DirContext->LongNameU);
                PathNameU.Buffer[PathNameU.Length / sizeof(WCHAR)] = 0;
                rcFcb = vfatGrabFCBFromTable(DeviceExt, &PathNameU);
                if (rcFcb != NULL)
                {
                    RtlCopyMemory(&DirContext->DirEntry, &rcFcb->entry, sizeof(DIR_ENTRY));
                    vfatReleaseFCB(DeviceExt, rcFcb);
                }
            }
            DPRINT("%u\n", DirContext->LongNameU.Length);
            DPRINT("FindFile: new Name %wZ, DirIndex %u\n",
                &DirContext->LongNameU, DirContext->DirIndex);
 
            if (Context)
            {
                CcUnpinData(Context);
            }
            RtlFreeUnicodeString(&FileToFindUpcase);
            ExFreePoolWithTag(PathNameBuffer, TAG_NAME);
            return STATUS_SUCCESS;
        }
        DirContext->DirIndex++;
    }
 
    if (Context)
    {
        CcUnpinData(Context);
    }
 
    RtlFreeUnicodeString(&FileToFindUpcase);
    ExFreePoolWithTag(PathNameBuffer, TAG_NAME);
    return Status;
}

FsdDosDateTimeToSystemTime()

BOOLEAN FsdDosDateTimeToSystemTime	(	PDEVICE_EXTENSION	DeviceExt,
		USHORT	DosDate,
		USHORT	DosTime,
		PLARGE_INTEGER	SystemTime
	)

Definition at line 21 of file dir.c.

{
    PDOSTIME pdtime = (PDOSTIME)&DosTime;
    PDOSDATE pddate = (PDOSDATE)&DosDate;
    TIME_FIELDS TimeFields;
    LARGE_INTEGER LocalTime;
 
    if (SystemTime == NULL)
        return FALSE;
 
    TimeFields.Milliseconds = 0;
    TimeFields.Second = pdtime->Second * 2;
    TimeFields.Minute = pdtime->Minute;
    TimeFields.Hour = pdtime->Hour;
 
    TimeFields.Day = pddate->Day;
    TimeFields.Month = pddate->Month;
    TimeFields.Year = (CSHORT)(DeviceExt->BaseDateYear + pddate->Year);
 
    RtlTimeFieldsToTime(&TimeFields, &LocalTime);
    ExLocalTimeToSystemTime(&LocalTime, SystemTime);
 
    return TRUE;
}

Referenced by FsdGetFsVolumeInformation(), VfatGetBasicInformation(), VfatGetFileBothInformation(), VfatGetFileDirectoryInformation(), VfatGetFileFullDirectoryInformation(), and VfatGetNetworkOpenInformation().

FsdSystemTimeToDosDateTime()

BOOLEAN FsdSystemTimeToDosDateTime	(	PDEVICE_EXTENSION	DeviceExt,
		PLARGE_INTEGER	SystemTime,
		USHORT *	pDosDate,
		USHORT *	pDosTime
	)

GetDirtyStatus()

NTSTATUS GetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		PBOOLEAN	DirtyStatus
	)

Definition at line 831 of file fat.c.

{
    NTSTATUS Status;
 
    DPRINT("GetDirtyStatus(DeviceExt %p)\n", DeviceExt);
 
    /* FAT12 has no dirty bit */
    if (DeviceExt->FatInfo.FatType == FAT12)
    {
        *DirtyStatus = FALSE;
        return STATUS_SUCCESS;
    }
 
    /* Not really in the FAT, but share the lock because
     * we're really low-level and shouldn't happent that often
     * And call the appropriate function
     */
    ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
    Status = DeviceExt->GetDirtyStatus(DeviceExt, DirtyStatus);
    ExReleaseResourceLite(&DeviceExt->FatResource);
 
    return Status;
}

Referenced by VfatMount().

GetNextCluster()

NTSTATUS GetNextCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	CurrentCluster,
		PULONG	NextCluster
	)

Definition at line 744 of file fat.c.

{
    NTSTATUS Status;
 
    DPRINT("GetNextCluster(DeviceExt %p, CurrentCluster %x)\n",
           DeviceExt, CurrentCluster);
 
    if (CurrentCluster == 0)
    {
        DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
        if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
            ASSERT(CurrentCluster != 0);
        return STATUS_FILE_CORRUPT_ERROR;
    }
 
    ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
    Status = DeviceExt->GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
    ExReleaseResourceLite(&DeviceExt->FatResource);
 
    return Status;
}

Referenced by FATDelEntry(), FATXDelEntry(), NextCluster(), and OffsetToCluster().

GetNextClusterExtend()

NTSTATUS GetNextClusterExtend	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	CurrentCluster,
		PULONG	NextCluster
	)

Definition at line 773 of file fat.c.

{
    ULONG NewCluster;
    NTSTATUS Status;
 
    DPRINT("GetNextClusterExtend(DeviceExt %p, CurrentCluster %x)\n",
           DeviceExt, CurrentCluster);
 
    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
    /*
     * If the file hasn't any clusters allocated then we need special
     * handling
     */
    if (CurrentCluster == 0)
    {
        Status = DeviceExt->FindAndMarkAvailableCluster(DeviceExt, &NewCluster);
        if (!NT_SUCCESS(Status))
        {
            ExReleaseResourceLite(&DeviceExt->FatResource);
            return Status;
        }
 
        *NextCluster = NewCluster;
        ExReleaseResourceLite(&DeviceExt->FatResource);
        return STATUS_SUCCESS;
    }
 
    Status = DeviceExt->GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
 
    if ((*NextCluster) == 0xFFFFFFFF)
    {
        /* We are after last existing cluster, we must add one to file */
        /* Firstly, find the next available open allocation unit and
           mark it as end of file */
        Status = DeviceExt->FindAndMarkAvailableCluster(DeviceExt, &NewCluster);
        if (!NT_SUCCESS(Status))
        {
            ExReleaseResourceLite(&DeviceExt->FatResource);
            return Status;
        }
 
        /* Now, write the AU of the LastCluster with the value of the newly
           found AU */
        WriteCluster(DeviceExt, CurrentCluster, NewCluster);
        *NextCluster = NewCluster;
    }
 
    ExReleaseResourceLite(&DeviceExt->FatResource);
    return Status;
}

Referenced by NextCluster(), and OffsetToCluster().

IsDotOrDotDot()

BOOLEAN IsDotOrDotDot

(

PCUNICODE_STRING

Name

)

Definition at line 28 of file string.c.

{
    return ((Name->Length == sizeof(WCHAR) && Name->Buffer[0] == L'.') ||
        (Name->Length == 2 * sizeof(WCHAR) && Name->Buffer[0] == L'.' && Name->Buffer[1] == L'.'));
}

Referenced by VfatCreateFile(), VfatOpenFile(), VfatSetDispositionInformation(), and VfatSetRenameInformation().

NextCluster()

NTSTATUS NextCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	FirstCluster,
		PULONG	CurrentCluster,
		BOOLEAN	Extend
	)

Definition at line 38 of file rw.c.

{
    if (FirstCluster == 1)
    {
        (*CurrentCluster) += DeviceExt->FatInfo.SectorsPerCluster;
        return STATUS_SUCCESS;
    }
    else
    {
        if (Extend)
            return GetNextClusterExtend(DeviceExt, (*CurrentCluster), CurrentCluster);
        else
            return GetNextCluster(DeviceExt, (*CurrentCluster), CurrentCluster);
    }
}

Referenced by FAT12GetNextCluster(), FAT16GetNextCluster(), FAT32GetNextCluster(), FATAddEntry(), FATDelEntry(), FATXDelEntry(), GetNextCluster(), GetNextClusterExtend(), VfatGetRetrievalPointers(), vfatInitFCBFromDirEntry(), vfatMakeRootFCB(), VfatReadFileData(), VfatSetAllocationSizeInformation(), and VfatWriteFileData().

OffsetToCluster()

NTSTATUS OffsetToCluster	(	PDEVICE_EXTENSION	DeviceExt,
		ULONG	FirstCluster,
		ULONG	FileOffset,
		PULONG	Cluster,
		BOOLEAN	Extend
	)

Definition at line 59 of file rw.c.

{
    ULONG CurrentCluster;
    ULONG i;
    NTSTATUS Status;
/*
    DPRINT("OffsetToCluster(DeviceExt %x, Fcb %x, FirstCluster %x,"
           " FileOffset %x, Cluster %x, Extend %d)\n", DeviceExt,
           Fcb, FirstCluster, FileOffset, Cluster, Extend);
*/
    if (FirstCluster == 0)
    {
        DbgPrint("OffsetToCluster is called with FirstCluster = 0!\n");
        ASSERT(FALSE);
    }
 
    if (FirstCluster == 1)
    {
        /* root of FAT16 or FAT12 */
        *Cluster = DeviceExt->FatInfo.rootStart + FileOffset
            / (DeviceExt->FatInfo.BytesPerCluster) * DeviceExt->FatInfo.SectorsPerCluster;
        return STATUS_SUCCESS;
    }
    else
    {
        CurrentCluster = FirstCluster;
        if (Extend)
        {
            for (i = 0; i < FileOffset / DeviceExt->FatInfo.BytesPerCluster; i++)
            {
                Status = GetNextClusterExtend (DeviceExt, CurrentCluster, &CurrentCluster);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            *Cluster = CurrentCluster;
        }
        else
        {
            for (i = 0; i < FileOffset / DeviceExt->FatInfo.BytesPerCluster; i++)
            {
                Status = GetNextCluster (DeviceExt, CurrentCluster, &CurrentCluster);
                if (!NT_SUCCESS(Status))
                    return Status;
            }
            *Cluster = CurrentCluster;
       }
       return STATUS_SUCCESS;
   }
}

Referenced by VfatGetRetrievalPointers(), VfatReadFileData(), VfatSetAllocationSizeInformation(), and VfatWriteFileData().

SetDirtyStatus()

NTSTATUS SetDirtyStatus	(	PDEVICE_EXTENSION	DeviceExt,
		BOOLEAN	DirtyStatus
	)

Definition at line 1017 of file fat.c.

{
    NTSTATUS Status;
 
    DPRINT("SetDirtyStatus(DeviceExt %p, DirtyStatus %d)\n", DeviceExt, DirtyStatus);
 
    /* FAT12 has no dirty bit */
    if (DeviceExt->FatInfo.FatType == FAT12)
    {
        return STATUS_SUCCESS;
    }
 
    /* Not really in the FAT, but share the lock because
     * we're really low-level and shouldn't happent that often
     * And call the appropriate function
     * Acquire exclusive because we will modify ondisk value
     */
    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
    Status = DeviceExt->SetDirtyStatus(DeviceExt, DirtyStatus);
    ExReleaseResourceLite(&DeviceExt->FatResource);
 
    return Status;
}

Referenced by VfatDismountVolume(), VfatLockOrUnlockVolume(), VfatMarkVolumeDirty(), VfatMount(), and VfatShutdown().

vfat8Dot3ToString()

VOID vfat8Dot3ToString	(	PFAT_DIR_ENTRY	pEntry,
		PUNICODE_STRING	NameU
	)

Definition at line 19 of file create.c.

{
    OEM_STRING StringA;
    USHORT Length;
    CHAR  cString[12];
 
    RtlCopyMemory(cString, pEntry->ShortName, 11);
    cString[11] = 0;
    if (cString[0] == 0x05)
    {
        cString[0] = 0xe5;
    }
 
    StringA.Buffer = cString;
    for (StringA.Length = 0;
         StringA.Length < 8 && StringA.Buffer[StringA.Length] != ' ';
         StringA.Length++);
    StringA.MaximumLength = StringA.Length;
 
    RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
 
    if (BooleanFlagOn(pEntry->lCase, VFAT_CASE_LOWER_BASE))
    {
        RtlDowncaseUnicodeString(NameU, NameU, FALSE);
    }
 
    if (cString[8] != ' ')
    {
        Length = NameU->Length;
        NameU->Buffer += Length / sizeof(WCHAR);
        if (!FAT_ENTRY_VOLUME(pEntry))
        {
            Length += sizeof(WCHAR);
            NameU->Buffer[0] = L'.';
            NameU->Buffer++;
        }
        NameU->Length = 0;
        NameU->MaximumLength -= Length;
 
        StringA.Buffer = &cString[8];
        for (StringA.Length = 0;
        StringA.Length < 3 && StringA.Buffer[StringA.Length] != ' ';
        StringA.Length++);
        StringA.MaximumLength = StringA.Length;
        RtlOemStringToUnicodeString(NameU, &StringA, FALSE);
        if (BooleanFlagOn(pEntry->lCase, VFAT_CASE_LOWER_EXT))
        {
            RtlDowncaseUnicodeString(NameU, NameU, FALSE);
        }
        NameU->Buffer -= Length / sizeof(WCHAR);
        NameU->Length += Length;
        NameU->MaximumLength += Length;
    }
 
    NameU->Buffer[NameU->Length / sizeof(WCHAR)] = 0;
    DPRINT("'%wZ'\n", NameU);
}

Referenced by FATGetNextDirEntry(), and ReadVolumeLabel().

VfatAcquireForLazyWrite()

BOOLEAN NTAPI VfatAcquireForLazyWrite	(	IN PVOID	Context,
		IN BOOLEAN	Wait
	)

Definition at line 723 of file fastio.c.

{
    PVFATFCB Fcb = (PVFATFCB)Context;
    ASSERT(Fcb);
    DPRINT("VfatAcquireForLazyWrite(): Fcb %p\n", Fcb);
 
    if (!ExAcquireResourceExclusiveLite(&(Fcb->MainResource), Wait))
    {
        DPRINT("VfatAcquireForLazyWrite(): ExReleaseResourceLite failed.\n");
        return FALSE;
    }
    return TRUE;
}

Referenced by DriverEntry().

VfatAddEntry()

FORCEINLINE NTSTATUS VfatAddEntry	(	PDEVICE_EXTENSION	DeviceExt,
		PUNICODE_STRING	NameU,
		struct _VFATFCB **	Fcb,
		struct _VFATFCB *	ParentFcb,
		ULONG	RequestedOptions,
		UCHAR	ReqAttr,
		struct _VFAT_MOVE_CONTEXT *	MoveContext
	)

Definition at line 375 of file vfat.h.

{
    return DeviceExt->Dispatch.AddEntry(DeviceExt, NameU, Fcb, ParentFcb, RequestedOptions, ReqAttr, MoveContext);
}

Referenced by VfatCreateFile(), and VfatMoveEntry().

vfatAttachFCBToFileObject()

NTSTATUS vfatAttachFCBToFileObject	(	PDEVICE_EXTENSION	vcb,
		PVFATFCB	fcb,
		PFILE_OBJECT	fileObject
	)

Definition at line 754 of file fcb.c.

{
    PVFATCCB newCCB;
 
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &fcb->LongNameU, FALSE, NULL))
    {
        DPRINT1("Attaching %p to %p (%d)\n", fcb, fileObject, fcb->RefCount);
    }
#endif
 
    newCCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
    if (newCCB == NULL)
    {
        return  STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(newCCB, sizeof (VFATCCB));
 
    fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
    fileObject->FsContext = fcb;
    fileObject->FsContext2 = newCCB;
    fileObject->Vpb = vcb->IoVPB;
    DPRINT("file open: fcb:%p PathName:%wZ\n", fcb, &fcb->PathNameU);
 
#ifdef KDBG
    fcb->Flags &= ~FCB_CLEANED_UP;
    fcb->Flags &= ~FCB_CLOSED;
#endif
 
    return STATUS_SUCCESS;
}

Referenced by VfatCreateFile(), VfatMount(), and VfatOpenFile().

VfatBlockDeviceIoControl()

NTSTATUS VfatBlockDeviceIoControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	CtlCode,
		IN PVOID	InputBuffer,
		IN ULONG	InputBufferSize,
		IN OUT PVOID	OutputBuffer,
		IN OUT PULONG	pOutputBufferSize,
		IN BOOLEAN	Override
	)

Definition at line 430 of file blockdev.c.

{
    PIO_STACK_LOCATION Stack;
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    NTSTATUS Status;
 
    DPRINT("VfatBlockDeviceIoControl(DeviceObject %p, CtlCode %x, "
           "InputBuffer %p, InputBufferSize %x, OutputBuffer %p, "
           "OutputBufferSize %p (%x)\n", DeviceObject, CtlCode,
           InputBuffer, InputBufferSize, OutputBuffer, OutputBufferSize,
           OutputBufferSize ? *OutputBufferSize : 0);
 
again:
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    DPRINT("Building device I/O control request ...\n");
    Irp = IoBuildDeviceIoControlRequest(CtlCode,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferSize,
                                        OutputBuffer,
                                        (OutputBufferSize) ? *OutputBufferSize : 0,
                                        FALSE,
                                        &Event,
                                        &IoStatus);
    if (Irp == NULL)
    {
        DPRINT("IoBuildDeviceIoControlRequest failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Override)
    {
        Stack = IoGetNextIrpStackLocation(Irp);
        Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
    }
 
    DPRINT("Calling IO Driver... with irp %p\n", Irp);
    Status = IoCallDriver(DeviceObject, Irp);
 
    DPRINT("Waiting for IO Operation for %p\n", Irp);
    if (Status == STATUS_PENDING)
    {
        DPRINT("Operation pending\n");
        KeWaitForSingleObject (&Event, Suspended, KernelMode, FALSE, NULL);
        DPRINT("Getting IO Status... for %p\n", Irp);
 
        Status = IoStatus.Status;
    }
 
    if (Status == STATUS_VERIFY_REQUIRED)
    {
        PDEVICE_OBJECT DeviceToVerify;
 
        DPRINT1("Media change detected!\n");
 
        /* Find the device to verify and reset the thread field to empty value again. */
        DeviceToVerify = IoGetDeviceToVerify(PsGetCurrentThread());
        IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
        Status = IoVerifyVolume(DeviceToVerify,
                                FALSE);
 
        if (NT_SUCCESS(Status))
        {
            DPRINT1("Volume verification successful; Reissuing IOCTL request\n");
            goto again;
        }
    }
 
    if (OutputBufferSize)
    {
        *OutputBufferSize = IoStatus.Information;
    }
 
    DPRINT("Returning Status %x\n", Status);
 
    return Status;
}

Referenced by VfatHasFileSystem(), VfatOpenFile(), and VfatVerify().

VfatBuildRequest()

NTSTATUS NTAPI VfatBuildRequest	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

VfatCheckForDismount()

BOOLEAN VfatCheckForDismount	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN BOOLEAN	Create
	)

Definition at line 495 of file misc.c.

{
    KIRQL OldIrql;
    ULONG UnCleanCount;
    PVPB Vpb;
    BOOLEAN Delete;
 
    DPRINT1("VfatCheckForDismount(%p, %u)\n", DeviceExt, Force);
 
    /* If the VCB is OK (not under uninitialization) and we don't force dismount, do nothing */
    if (BooleanFlagOn(DeviceExt->Flags, VCB_GOOD) && !Force)
    {
        return FALSE;
    }
 
    /*
     * NOTE: In their *CheckForDismount() function, our 3rd-party FS drivers
     * as well as MS' fastfat, perform a comparison check of the current VCB's
     * VPB ReferenceCount with some sort of "dangling"/"residual" open count,
     * depending on whether or not we are in IRP_MJ_CREATE.
     * It seems to be related to the fact that the volume root directory as
     * well as auxiliary data stream(s) are still opened, and only these are
     * allowed to be opened at that moment. After analysis it appears that for
     * the ReactOS' vfatfs, this number is equal to "2".
     */
    UnCleanCount = 2;
 
    /* Lock VPB */
    IoAcquireVpbSpinLock(&OldIrql);
 
    /* Reference it and check if a create is being done */
    Vpb = DeviceExt->IoVPB;
    DPRINT("Vpb->ReferenceCount = %d\n", Vpb->ReferenceCount);
    if (Vpb->ReferenceCount != UnCleanCount || DeviceExt->OpenHandleCount != 0)
    {
        /* If we force-unmount, copy the VPB to our local own to prepare later dismount */
        if (Force && Vpb->RealDevice->Vpb == Vpb && DeviceExt->SpareVPB != NULL)
        {
            RtlZeroMemory(DeviceExt->SpareVPB, sizeof(VPB));
            DeviceExt->SpareVPB->Type = IO_TYPE_VPB;
            DeviceExt->SpareVPB->Size = sizeof(VPB);
            DeviceExt->SpareVPB->RealDevice = DeviceExt->IoVPB->RealDevice;
            DeviceExt->SpareVPB->DeviceObject = NULL;
            DeviceExt->SpareVPB->Flags = DeviceExt->IoVPB->Flags & VPB_REMOVE_PENDING;
            DeviceExt->IoVPB->RealDevice->Vpb = DeviceExt->SpareVPB;
            DeviceExt->SpareVPB = NULL;
            DeviceExt->IoVPB->Flags |= VPB_PERSISTENT;
 
            /* We are uninitializing, the VCB cannot be used anymore */
            ClearFlag(DeviceExt->Flags, VCB_GOOD);
        }
 
        /* Don't do anything for now */
        Delete = FALSE;
    }
    else
    {
        /* Otherwise, delete the volume */
        Delete = TRUE;
 
        /* Swap the VPB with our local own */
        if (Vpb->RealDevice->Vpb == Vpb && DeviceExt->SpareVPB != NULL)
        {
            RtlZeroMemory(DeviceExt->SpareVPB, sizeof(VPB));
            DeviceExt->SpareVPB->Type = IO_TYPE_VPB;
            DeviceExt->SpareVPB->Size = sizeof(VPB);
            DeviceExt->SpareVPB->RealDevice = DeviceExt->IoVPB->RealDevice;
            DeviceExt->SpareVPB->DeviceObject = NULL;
            DeviceExt->SpareVPB->Flags = DeviceExt->IoVPB->Flags & VPB_REMOVE_PENDING;
            DeviceExt->IoVPB->RealDevice->Vpb = DeviceExt->SpareVPB;
            DeviceExt->SpareVPB = NULL;
            DeviceExt->IoVPB->Flags |= VPB_PERSISTENT;
 
            /* We are uninitializing, the VCB cannot be used anymore */
            ClearFlag(DeviceExt->Flags, VCB_GOOD);
        }
 
        /*
         * We defer setting the VPB's DeviceObject to NULL for later because
         * we want to handle the closing of the internal opened meta-files.
         */
 
        /* Clear the mounted and locked flags in the VPB */
        ClearFlag(Vpb->Flags, VPB_MOUNTED | VPB_LOCKED);
    }
 
    /* Release lock and return status */
    IoReleaseVpbSpinLock(OldIrql);
 
    /* If we were to delete, delete volume */
    if (Delete)
    {
        LARGE_INTEGER Zero = {{0,0}};
        PVFATFCB Fcb;
 
        /* We are uninitializing, the VCB cannot be used anymore */
        ClearFlag(DeviceExt->Flags, VCB_GOOD);
 
        /* Invalidate and close the internal opened meta-files */
        if (DeviceExt->RootFcb)
        {
            Fcb = DeviceExt->RootFcb;
            CcUninitializeCacheMap(Fcb->FileObject,
                                   &Zero,
                                   NULL);
            ObDereferenceObject(Fcb->FileObject);
            DeviceExt->RootFcb = NULL;
            vfatDestroyFCB(Fcb);
        }
        if (DeviceExt->VolumeFcb)
        {
            Fcb = DeviceExt->VolumeFcb;
#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
            CcUninitializeCacheMap(Fcb->FileObject,
                                   &Zero,
                                   NULL);
            ObDereferenceObject(Fcb->FileObject);
#endif
            DeviceExt->VolumeFcb = NULL;
            vfatDestroyFCB(Fcb);
        }
        if (DeviceExt->FATFileObject)
        {
            Fcb = DeviceExt->FATFileObject->FsContext;
            CcUninitializeCacheMap(DeviceExt->FATFileObject,
                                   &Zero,
                                   NULL);
            DeviceExt->FATFileObject->FsContext = NULL;
            ObDereferenceObject(DeviceExt->FATFileObject);
            DeviceExt->FATFileObject = NULL;
            vfatDestroyFCB(Fcb);
        }
 
        ASSERT(DeviceExt->OverflowQueueCount == 0);
        ASSERT(IsListEmpty(&DeviceExt->OverflowQueue));
        ASSERT(DeviceExt->PostedRequestCount == 0);
 
        /*
         * Now that the closing of the internal opened meta-files has been
         * handled, we can now set the VPB's DeviceObject to NULL.
         */
        Vpb->DeviceObject = NULL;
 
        /* If we have a local VPB, we'll have to delete it
         * but we won't dismount us - something went bad before
         */
        if (DeviceExt->SpareVPB)
        {
            ExFreePool(DeviceExt->SpareVPB);
        }
        /* Otherwise, delete any of the available VPB if its reference count is zero */
        else if (DeviceExt->IoVPB->ReferenceCount == 0)
        {
            ExFreePool(DeviceExt->IoVPB);
        }
 
        /* Remove the volume from the list */
        ExAcquireResourceExclusiveLite(&VfatGlobalData->VolumeListLock, TRUE);
        RemoveEntryList(&DeviceExt->VolumeListEntry);
        ExReleaseResourceLite(&VfatGlobalData->VolumeListLock);
 
        /* Uninitialize the notify synchronization object */
        FsRtlNotifyUninitializeSync(&DeviceExt->NotifySync);
 
        /* Release resources */
        ExFreePoolWithTag(DeviceExt->Statistics, TAG_STATS);
        ExDeleteResourceLite(&DeviceExt->DirResource);
        ExDeleteResourceLite(&DeviceExt->FatResource);
 
        /* Dismount our device if possible */
        ObDereferenceObject(DeviceExt->StorageDevice);
        IoDeleteDevice(DeviceExt->VolumeDevice);
    }
 
    return Delete;
}

Referenced by VfatCleanupFile(), VfatCloseFile(), and VfatShutdown().

VfatCleanup()

NTSTATUS VfatCleanup

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 176 of file cleanup.c.

{
    BOOLEAN Deleted;
 
    DPRINT("VfatCleanup(DeviceObject %p, Irp %p)\n", IrpContext->DeviceObject, IrpContext->Irp);
 
    if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
    {
        IrpContext->Irp->IoStatus.Information = 0;
        return STATUS_SUCCESS;
    }
 
    ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);
    Deleted = VfatCleanupFile(IrpContext);
    if (!Deleted) ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
 
    IrpContext->Irp->IoStatus.Information = 0;
    return STATUS_SUCCESS;
}

Referenced by VfatDispatchRequest().

VfatClose()

NTSTATUS VfatClose

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 212 of file close.c.

{
    NTSTATUS Status;
 
    DPRINT("VfatClose(DeviceObject %p, Irp %p)\n", IrpContext->DeviceObject, IrpContext->Irp);
 
    if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
    {
        DPRINT("Closing file system\n");
        IrpContext->Irp->IoStatus.Information = 0;
        return STATUS_SUCCESS;
    }
    if (!ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT)))
    {
        return VfatMarkIrpContextForQueue(IrpContext);
    }
 
    Status = VfatCloseFile(IrpContext->DeviceExt, IrpContext->FileObject);
    ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
 
    IrpContext->Irp->IoStatus.Information = 0;
 
    return Status;
}

Referenced by VfatDispatchRequest().

VfatCloseFile()

NTSTATUS VfatCloseFile	(	PDEVICE_EXTENSION	DeviceExt,
		PFILE_OBJECT	FileObject
	)

Definition at line 159 of file close.c.

{
    PVFATFCB pFcb;
    PVFATCCB pCcb;
    BOOLEAN IsVolume;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("VfatCloseFile(DeviceExt %p, FileObject %p)\n",
            DeviceExt, FileObject);
 
    /* FIXME : update entry in directory? */
    pCcb = (PVFATCCB) (FileObject->FsContext2);
    pFcb = (PVFATFCB) (FileObject->FsContext);
 
    if (pFcb == NULL)
    {
        return STATUS_SUCCESS;
    }
 
    IsVolume = BooleanFlagOn(pFcb->Flags, FCB_IS_VOLUME);
 
    if (pCcb)
    {
        vfatDestroyCCB(pCcb);
    }
 
    /* If we have to close immediately, or if delaying failed, close */
    if (VfatGlobalData->ShutdownStarted || !BooleanFlagOn(pFcb->Flags, FCB_DELAYED_CLOSE) ||
        !NT_SUCCESS(VfatPostCloseFile(DeviceExt, FileObject)))
    {
        VfatCommonCloseFile(DeviceExt, pFcb);
    }
 
    FileObject->FsContext2 = NULL;
    FileObject->FsContext = NULL;
    FileObject->SectionObjectPointer = NULL;
 
#ifdef ENABLE_SWAPOUT
    if (IsVolume && DeviceExt->OpenHandleCount == 0)
    {
        VfatCheckForDismount(DeviceExt, FALSE);
    }
#endif
 
    return Status;
}

Referenced by VfatClose(), VfatCreateFile(), and vfatPrepareTargetForRename().

VfatCreate()

NTSTATUS VfatCreate

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 1070 of file create.c.

{
    NTSTATUS Status;
 
    ASSERT(IrpContext);
 
    if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
    {
        /* DeviceObject represents FileSystem instead of logical volume */
        DPRINT ("FsdCreate called with file system\n");
        IrpContext->Irp->IoStatus.Information = FILE_OPENED;
        IrpContext->PriorityBoost = IO_DISK_INCREMENT;
 
        return STATUS_SUCCESS;
    }
 
    IrpContext->Irp->IoStatus.Information = 0;
    ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);
    Status = VfatCreateFile(IrpContext->DeviceObject, IrpContext->Irp);
    ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
 
    if (NT_SUCCESS(Status))
        IrpContext->PriorityBoost = IO_DISK_INCREMENT;
 
    return Status;
}

Referenced by VfatDispatchRequest().

VfatDelEntry()

FORCEINLINE NTSTATUS VfatDelEntry	(	PDEVICE_EXTENSION	DeviceExt,
		struct _VFATFCB *	Fcb,
		struct _VFAT_MOVE_CONTEXT *	MoveContext
	)

Definition at line 388 of file vfat.h.

{
    return DeviceExt->Dispatch.DelEntry(DeviceExt, Fcb, MoveContext);
}

Referenced by VfatCleanupFile(), VfatMoveEntry(), and vfatPrepareTargetForRename().

vfatDestroyCCB()

VOID vfatDestroyCCB

(

PVFATCCB

pCcb

)

Definition at line 257 of file fcb.c.

{
    if (pCcb->SearchPattern.Buffer)
    {
        ExFreePoolWithTag(pCcb->SearchPattern.Buffer, TAG_SEARCH);
    }
    ExFreeToNPagedLookasideList(&VfatGlobalData->CcbLookasideList, pCcb);
}

Referenced by VfatCloseFile(), and VfatMount().

vfatDestroyFCB()

VOID vfatDestroyFCB

(

PVFATFCB

pFCB

)

Definition at line 268 of file fcb.c.

{
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &pFCB->LongNameU, FALSE, NULL))
    {
        DPRINT1("Destroying: %p (%wZ) %d\n", pFCB, &pFCB->PathNameU, pFCB->RefCount);
    }
#endif
 
    FsRtlUninitializeFileLock(&pFCB->FileLock);
 
    if (!vfatFCBIsRoot(pFCB) &&
        !BooleanFlagOn(pFCB->Flags, FCB_IS_FAT) && !BooleanFlagOn(pFCB->Flags, FCB_IS_VOLUME))
    {
        RemoveEntryList(&pFCB->ParentListEntry);
    }
    ExFreePool(pFCB->PathNameBuffer);
    ExDeleteResourceLite(&pFCB->PagingIoResource);
    ExDeleteResourceLite(&pFCB->MainResource);
    ASSERT(IsListEmpty(&pFCB->ParentListHead));
    ExFreeToNPagedLookasideList(&VfatGlobalData->FcbLookasideList, pFCB);
}

Referenced by VfatCheckForDismount(), VfatDismountVolume(), VfatMount(), and vfatReleaseFCB().

VfatDirectoryControl()

NTSTATUS VfatDirectoryControl

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 727 of file dir.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    IrpContext->Irp->IoStatus.Information = 0;
 
    switch (IrpContext->MinorFunction)
    {
        case IRP_MN_QUERY_DIRECTORY:
            Status = DoQuery (IrpContext);
            break;
 
        case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
            Status = VfatNotifyChangeDirectory(IrpContext);
            break;
 
        default:
            /* Error */
            DPRINT("Unexpected minor function %x in VFAT driver\n",
                   IrpContext->MinorFunction);
            Status = STATUS_INVALID_DEVICE_REQUEST;
            break;
    }
 
    if (Status == STATUS_PENDING && BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_COMPLETE))
    {
        return VfatMarkIrpContextForQueue(IrpContext);
    }
 
    return Status;
}

Referenced by VfatDispatchRequest().

vfatDirEntryGetFirstCluster()

ULONG vfatDirEntryGetFirstCluster	(	PDEVICE_EXTENSION	pDeviceExt,
		PDIR_ENTRY	pDirEntry
	)

Definition at line 18 of file direntry.c.

{
    ULONG cluster;
 
    if (pDeviceExt->FatInfo.FatType == FAT32)
    {
        cluster = pFatDirEntry->Fat.FirstCluster |
                 (pFatDirEntry->Fat.FirstClusterHigh << 16);
    }
    else if (vfatVolumeIsFatX(pDeviceExt))
    {
        cluster = pFatDirEntry->FatX.FirstCluster;
    }
    else
    {
        cluster = pFatDirEntry->Fat.FirstCluster;
    }
 
    return  cluster;
}

Referenced by FATDelEntry(), FATXDelEntry(), VfatGetInternalInformation(), VfatGetRetrievalPointers(), vfatInitFCBFromDirEntry(), VfatReadFileData(), VfatSetAllocationSizeInformation(), VfatWrite(), and VfatWriteFileData().

vfatDirFindFile()

NTSTATUS vfatDirFindFile	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	parentFCB,
		PUNICODE_STRING	FileToFindU,
		PVFATFCB *	fileFCB
	)

Definition at line 790 of file fcb.c.

{
    NTSTATUS status;
    PVOID Context = NULL;
    PVOID Page = NULL;
    BOOLEAN First = TRUE;
    VFAT_DIRENTRY_CONTEXT DirContext;
    /* This buffer must have a size of 260 characters, because
    vfatMakeFCBFromDirEntry can copy 20 name entries with 13 characters. */
    WCHAR LongNameBuffer[260];
    WCHAR ShortNameBuffer[13];
    BOOLEAN FoundLong = FALSE;
    BOOLEAN FoundShort = FALSE;
    BOOLEAN IsFatX = vfatVolumeIsFatX(pDeviceExt);
 
    ASSERT(pDeviceExt);
    ASSERT(pDirectoryFCB);
    ASSERT(FileToFindU);
 
    DPRINT("vfatDirFindFile(VCB:%p, dirFCB:%p, File:%wZ)\n",
           pDeviceExt, pDirectoryFCB, FileToFindU);
    DPRINT("Dir Path:%wZ\n", &pDirectoryFCB->PathNameU);
 
    DirContext.DirIndex = 0;
    DirContext.LongNameU.Buffer = LongNameBuffer;
    DirContext.LongNameU.Length = 0;
    DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
    DirContext.ShortNameU.Buffer = ShortNameBuffer;
    DirContext.ShortNameU.Length = 0;
    DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
    DirContext.DeviceExt = pDeviceExt;
 
    while (TRUE)
    {
        status = VfatGetNextDirEntry(pDeviceExt,
            &Context,
            &Page,
            pDirectoryFCB,
            &DirContext,
            First);
        First = FALSE;
        if (status == STATUS_NO_MORE_ENTRIES)
        {
            return STATUS_OBJECT_NAME_NOT_FOUND;
        }
        if (!NT_SUCCESS(status))
        {
            return status;
        }
 
        DPRINT("  Index:%u  longName:%wZ\n",
               DirContext.DirIndex, &DirContext.LongNameU);
 
        if (!ENTRY_VOLUME(IsFatX, &DirContext.DirEntry))
        {
            if (DirContext.LongNameU.Length == 0 ||
                DirContext.ShortNameU.Length == 0)
            {
                DPRINT1("WARNING: File system corruption detected. You may need to run a disk repair utility.\n");
                if (VfatGlobalData->Flags & VFAT_BREAK_ON_CORRUPTION)
                {
                    ASSERT(DirContext.LongNameU.Length != 0 &&
                           DirContext.ShortNameU.Length != 0);
                }
                DirContext.DirIndex++;
                continue;
            }
            FoundLong = RtlEqualUnicodeString(FileToFindU, &DirContext.LongNameU, TRUE);
            if (FoundLong == FALSE)
            {
                FoundShort = RtlEqualUnicodeString(FileToFindU, &DirContext.ShortNameU, TRUE);
            }
            if (FoundLong || FoundShort)
            {
                status = vfatMakeFCBFromDirEntry(pDeviceExt,
                    pDirectoryFCB,
                    &DirContext,
                    pFoundFCB);
                CcUnpinData(Context);
                return status;
            }
        }
        DirContext.DirIndex++;
    }
 
    return STATUS_OBJECT_NAME_NOT_FOUND;
}

Referenced by vfatGetFCBForFile().

vfatFCBInitializeCacheFromVolume()

NTSTATUS vfatFCBInitializeCacheFromVolume	(	PVCB	vcb,
		PVFATFCB	fcb
	)

Definition at line 22 of file dirwr.c.

{
    PFILE_OBJECT fileObject;
    PVFATCCB newCCB;
    NTSTATUS status;
    BOOLEAN Acquired;
 
    /* Don't re-initialize if already done */
    if (BooleanFlagOn(fcb->Flags, FCB_CACHE_INITIALIZED))
    {
        return STATUS_SUCCESS;
    }
 
    ASSERT(vfatFCBIsDirectory(fcb));
    ASSERT(fcb->FileObject == NULL);
 
    Acquired = FALSE;
    if (!ExIsResourceAcquiredExclusive(&vcb->DirResource))
    {
        ExAcquireResourceExclusiveLite(&vcb->DirResource, TRUE);
        Acquired = TRUE;
    }
 
    fileObject = IoCreateStreamFileObject (NULL, vcb->StorageDevice);
    if (fileObject == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }
 
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &fcb->LongNameU, FALSE, NULL))
    {
        DPRINT1("Attaching %p to %p (%d)\n", fcb, fileObject, fcb->RefCount);
    }
#endif
 
    newCCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
    if (newCCB == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
        ObDereferenceObject(fileObject);
        goto Quit;
    }
    RtlZeroMemory(newCCB, sizeof (VFATCCB));
 
    fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
    fileObject->FsContext = fcb;
    fileObject->FsContext2 = newCCB;
    fileObject->Vpb = vcb->IoVPB;
    fcb->FileObject = fileObject;
 
    _SEH2_TRY
    {
        CcInitializeCacheMap(fileObject,
                             (PCC_FILE_SIZES)(&fcb->RFCB.AllocationSize),
                             TRUE,
                             &VfatGlobalData->CacheMgrCallbacks,
                             fcb);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        status = _SEH2_GetExceptionCode();
        fcb->FileObject = NULL;
        ExFreeToNPagedLookasideList(&VfatGlobalData->CcbLookasideList, newCCB);
        ObDereferenceObject(fileObject);
        if (Acquired)
        {
            ExReleaseResourceLite(&vcb->DirResource);
        }
        return status;
    }
    _SEH2_END;
 
    vfatGrabFCB(vcb, fcb);
    SetFlag(fcb->Flags, FCB_CACHE_INITIALIZED);
    status = STATUS_SUCCESS;
 
Quit:
    if (Acquired)
    {
        ExReleaseResourceLite(&vcb->DirResource);
    }
 
    return status;
}

Referenced by FATAddEntry(), FATDelEntry(), FATGetNextDirEntry(), FATIsDirectoryEmpty(), FATXDelEntry(), FATXGetNextDirEntry(), FATXIsDirectoryEmpty(), FsdSetFsLabelInformation(), vfatFindDirSpace(), vfatMakeRootFCB(), vfatRenameEntry(), and VfatUpdateEntry().

vfatFCBIsDirectory()

BOOLEAN vfatFCBIsDirectory

(

PVFATFCB

FCB

)

Definition at line 637 of file vfat.h.

{
    return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_DIRECTORY);
}

Referenced by IsThereAChildOpened(), UpdateFileSize(), VfatCleanupFile(), VfatCreateFile(), vfatFCBInitializeCacheFromVolume(), VfatFlushVolume(), vfatGetFCBForFile(), VfatGetNetworkOpenInformation(), VfatGetStandardInformation(), vfatInitFCBFromDirEntry(), VfatLockControl(), VfatLockOrUnlockVolume(), VfatMoveEntry(), VfatOpenFile(), vfatPrepareTargetForRename(), VfatRead(), VfatRenameChildFCB(), VfatSetBasicInformation(), VfatSetDispositionInformation(), VfatSetRenameInformation(), vfatUpdateFCB(), and VfatWrite().

vfatFCBIsReadOnly()

FORCEINLINE BOOLEAN vfatFCBIsReadOnly

(

PVFATFCB

FCB

)

Definition at line 644 of file vfat.h.

{
    return BooleanFlagOn(*FCB->Attributes, FILE_ATTRIBUTE_READONLY);
}

Referenced by VfatOpenFile(), vfatPrepareTargetForRename(), and VfatSetDispositionInformation().

vfatFCBIsRoot()

BOOLEAN vfatFCBIsRoot

(

PVFATFCB

FCB

)

Definition at line 293 of file fcb.c.

{
    return FCB->PathNameU.Length == sizeof(WCHAR) && FCB->PathNameU.Buffer[0] == L'\\' ? TRUE : FALSE;
}

Referenced by FATAddEntry(), FATIsDirectoryEmpty(), FATXAddEntry(), FATXGetNextDirEntry(), FindFile(), vfatDestroyFCB(), vfatFindDirSpace(), vfatInitFCBFromDirEntry(), vfatMakeFullName(), VfatOpenFile(), VfatSetDispositionInformation(), VfatSetRenameInformation(), and VfatUpdateEntry().

VfatFileSystemControl()

NTSTATUS VfatFileSystemControl

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 1378 of file fsctl.c.

{
    NTSTATUS Status;
 
    DPRINT("VfatFileSystemControl(IrpContext %p)\n", IrpContext);
 
    ASSERT(IrpContext);
    ASSERT(IrpContext->Irp);
    ASSERT(IrpContext->Stack);
 
    IrpContext->Irp->IoStatus.Information = 0;
 
    switch (IrpContext->MinorFunction)
    {
        case IRP_MN_KERNEL_CALL:
        case IRP_MN_USER_FS_REQUEST:
            switch(IrpContext->Stack->Parameters.DeviceIoControl.IoControlCode)
            {
                case FSCTL_GET_VOLUME_BITMAP:
                    Status = VfatGetVolumeBitmap(IrpContext);
                    break;
 
                case FSCTL_GET_RETRIEVAL_POINTERS:
                    Status = VfatGetRetrievalPointers(IrpContext);
                    break;
 
                case FSCTL_MOVE_FILE:
                    Status = VfatMoveFile(IrpContext);
                    break;
 
                case FSCTL_IS_VOLUME_DIRTY:
                    Status = VfatIsVolumeDirty(IrpContext);
                    break;
 
                case FSCTL_MARK_VOLUME_DIRTY:
                    Status = VfatMarkVolumeDirty(IrpContext);
                    break;
 
                case FSCTL_LOCK_VOLUME:
                    Status = VfatLockOrUnlockVolume(IrpContext, TRUE);
                    break;
 
                case FSCTL_UNLOCK_VOLUME:
                    Status = VfatLockOrUnlockVolume(IrpContext, FALSE);
                    break;
 
                case FSCTL_DISMOUNT_VOLUME:
                    Status = VfatDismountVolume(IrpContext);
                    break;
 
                case FSCTL_FILESYSTEM_GET_STATISTICS:
                    Status = VfatGetStatistics(IrpContext);
                    break;
 
                default:
                    Status = STATUS_INVALID_DEVICE_REQUEST;
            }
            break;
 
        case IRP_MN_MOUNT_VOLUME:
            Status = VfatMount(IrpContext);
            break;
 
        case IRP_MN_VERIFY_VOLUME:
            DPRINT("VFATFS: IRP_MN_VERIFY_VOLUME\n");
            Status = VfatVerify(IrpContext);
            break;
 
        default:
            DPRINT("VFAT FSC: MinorFunction %u\n", IrpContext->MinorFunction);
            Status = STATUS_INVALID_DEVICE_REQUEST;
            break;
    }
 
    return Status;
}

Referenced by VfatDispatchRequest().

vfatFindDirSpace()

BOOLEAN vfatFindDirSpace	(	PDEVICE_EXTENSION	DeviceExt,
		PVFATFCB	pDirFcb,
		ULONG	nbSlots,
		PULONG	start
	)

VfatFlush()

NTSTATUS VfatFlush

(

PVFAT_IRP_CONTEXT

IrpContext

)

Definition at line 149 of file flush.c.

{
    NTSTATUS Status;
    PVFATFCB Fcb;
 
    /* This request is not allowed on the main device object. */
    if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
    {
        IrpContext->Irp->IoStatus.Information = 0;
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    Fcb = (PVFATFCB)IrpContext->FileObject->FsContext;
    ASSERT(Fcb);
 
    if (BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME))
    {
        ExAcquireResourceExclusiveLite(&IrpContext->DeviceExt->DirResource, TRUE);
        Status = VfatFlushVolume(IrpContext->DeviceExt, Fcb);
        ExReleaseResourceLite(&IrpContext->DeviceExt->DirResource);
    }
    else
    {
        ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
        Status = VfatFlushFile(IrpContext->DeviceExt, Fcb);
        ExReleaseResourceLite (&Fcb->MainResource);
    }
 
    IrpContext->Irp->IoStatus.Information = 0;
    return Status;
}

Referenced by VfatDispatchRequest().

VfatFlushVolume()

NTSTATUS VfatFlushVolume	(	PDEVICE_EXTENSION	DeviceExt,
		PVFATFCB	VolumeFcb
	)

Definition at line 51 of file flush.c.

{
    PLIST_ENTRY ListEntry;
    PVFATFCB Fcb;
    NTSTATUS Status, ReturnStatus = STATUS_SUCCESS;
    PIRP Irp;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;
 
    DPRINT("VfatFlushVolume(DeviceExt %p, VolumeFcb %p)\n", DeviceExt, VolumeFcb);
 
    ASSERT(VolumeFcb == DeviceExt->VolumeFcb);
 
    ListEntry = DeviceExt->FcbListHead.Flink;
    while (ListEntry != &DeviceExt->FcbListHead)
    {
        Fcb = CONTAINING_RECORD(ListEntry, VFATFCB, FcbListEntry);
        ListEntry = ListEntry->Flink;
        if (!vfatFCBIsDirectory(Fcb))
        {
            ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
            Status = VfatFlushFile(DeviceExt, Fcb);
            ExReleaseResourceLite (&Fcb->MainResource);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("VfatFlushFile failed, status = %x\n", Status);
                ReturnStatus = Status;
            }
        }
        /* FIXME: Stop flushing if this is a removable media and the media was removed */
    }
 
    ListEntry = DeviceExt->FcbListHead.Flink;
    while (ListEntry != &DeviceExt->FcbListHead)
    {
        Fcb = CONTAINING_RECORD(ListEntry, VFATFCB, FcbListEntry);
        ListEntry = ListEntry->Flink;
        if (vfatFCBIsDirectory(Fcb))
        {
            ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
            Status = VfatFlushFile(DeviceExt, Fcb);
            ExReleaseResourceLite (&Fcb->MainResource);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("VfatFlushFile failed, status = %x\n", Status);
                ReturnStatus = Status;
            }
        }
        /* FIXME: Stop flushing if this is a removable media and the media was removed */
    }
 
    Fcb = (PVFATFCB) DeviceExt->FATFileObject->FsContext;
 
    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
    Status = VfatFlushFile(DeviceExt, Fcb);
    ExReleaseResourceLite(&DeviceExt->FatResource);
 
    /* Prepare an IRP to flush device buffers */
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_FLUSH_BUFFERS,
                                       DeviceExt->StorageDevice,
                                       NULL, 0, NULL, &Event,
                                       &IoStatusBlock);
    if (Irp != NULL)
    {
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
        Status = IoCallDriver(DeviceExt->StorageDevice, Irp);
        if (Status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* Ignore device not supporting flush operation */
        if (Status == STATUS_INVALID_DEVICE_REQUEST)
        {
            DPRINT1("Flush not supported, ignored\n");
            Status = STATUS_SUCCESS;
 
        }
    }
    else
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("VfatFlushFile failed, status = %x\n", Status);
        ReturnStatus = Status;
    }
 
    return ReturnStatus;
}

Referenced by VfatDismountVolume(), VfatFlush(), VfatLockOrUnlockVolume(), and VfatShutdown().

VfatGetBasicInformation()

NTSTATUS VfatGetBasicInformation	(	PFILE_OBJECT	FileObject,
		PVFATFCB	FCB,
		PDEVICE_EXTENSION	DeviceExt,
		PFILE_BASIC_INFORMATION	BasicInfo,
		PULONG	BufferLength
	)

Definition at line 280 of file finfo.c.

{
    UNREFERENCED_PARAMETER(FileObject);
 
    DPRINT("VfatGetBasicInformation()\n");
 
    if (*BufferLength < sizeof(FILE_BASIC_INFORMATION))
        return STATUS_BUFFER_OVERFLOW;
 
    RtlZeroMemory(BasicInfo, sizeof(FILE_BASIC_INFORMATION));
 
    if (vfatVolumeIsFatX(DeviceExt))
    {
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.FatX.CreationDate,
                                   FCB->entry.FatX.CreationTime,
                                   &BasicInfo->CreationTime);
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.FatX.AccessDate,
                                   FCB->entry.FatX.AccessTime,
                                   &BasicInfo->LastAccessTime);
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.FatX.UpdateDate,
                                   FCB->entry.FatX.UpdateTime,
                                   &BasicInfo->LastWriteTime);
        BasicInfo->ChangeTime = BasicInfo->LastWriteTime;
    }
    else
    {
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.Fat.CreationDate,
                                   FCB->entry.Fat.CreationTime,
                                   &BasicInfo->CreationTime);
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.Fat.AccessDate,
                                   0,
                                   &BasicInfo->LastAccessTime);
        FsdDosDateTimeToSystemTime(DeviceExt,
                                   FCB->entry.Fat.UpdateDate,
                                   FCB->entry.Fat.UpdateTime,
                                   &BasicInfo->LastWriteTime);
        BasicInfo->ChangeTime = BasicInfo->LastWriteTime;
    }
 
    BasicInfo->FileAttributes = *FCB->Attributes & 0x3f;
    /* Synthesize FILE_ATTRIBUTE_NORMAL */
    if (0 == (BasicInfo->FileAttributes & (FILE_ATTRIBUTE_DIRECTORY |
                                           FILE_ATTRIBUTE_ARCHIVE |
                                           FILE_ATTRIBUTE_SYSTEM |
                                           FILE_ATTRIBUTE_HIDDEN |
                                           FILE_ATTRIBUTE_READONLY)))
    {
        DPRINT("Synthesizing FILE_ATTRIBUTE_NORMAL\n");
        BasicInfo->FileAttributes |= FILE_ATTRIBUTE_NORMAL;
    }
    DPRINT("Getting attributes 0x%02x\n", BasicInfo->FileAttributes);
 
    *BufferLength -= sizeof(FILE_BASIC_INFORMATION);
    return STATUS_SUCCESS;
}

Referenced by VfatFastIoQueryBasicInfo(), VfatGetAllInformation(), and VfatQueryInformation().

vfatGetFCBForFile()

NTSTATUS vfatGetFCBForFile	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB *	pParentFCB,
		PVFATFCB *	pFCB,
		PUNICODE_STRING	pFileNameU
	)

Definition at line 883 of file fcb.c.

{
    NTSTATUS status;
    PVFATFCB FCB = NULL;
    PVFATFCB parentFCB;
    UNICODE_STRING NameU;
    UNICODE_STRING RootNameU = RTL_CONSTANT_STRING(L"\\");
    UNICODE_STRING FileNameU;
    WCHAR NameBuffer[260];
    PWCHAR curr, prev, last;
    ULONG Length;
 
    DPRINT("vfatGetFCBForFile (%p,%p,%p,%wZ)\n",
           pVCB, pParentFCB, pFCB, pFileNameU);
 
    RtlInitEmptyUnicodeString(&FileNameU, NameBuffer, sizeof(NameBuffer));
 
    parentFCB = *pParentFCB;
 
    if (parentFCB == NULL)
    {
        /* Passed-in name is the full name */
        RtlCopyUnicodeString(&FileNameU, pFileNameU);
 
        //  Trivial case, open of the root directory on volume
        if (RtlEqualUnicodeString(&FileNameU, &RootNameU, FALSE))
        {
            DPRINT("returning root FCB\n");
 
            FCB = vfatOpenRootFCB(pVCB);
            *pFCB = FCB;
            *pParentFCB = NULL;
 
            return (FCB != NULL) ? STATUS_SUCCESS : STATUS_OBJECT_PATH_NOT_FOUND;
        }
 
        /* Check for an existing FCB */
        FCB = vfatGrabFCBFromTable(pVCB, &FileNameU);
        if (FCB)
        {
            *pFCB = FCB;
            *pParentFCB = FCB->parentFcb;
            vfatGrabFCB(pVCB, *pParentFCB);
            return STATUS_SUCCESS;
        }
 
        last = curr = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
        while (*curr != L'\\' && curr > FileNameU.Buffer)
        {
            curr--;
        }
 
        if (curr > FileNameU.Buffer)
        {
            NameU.Buffer = FileNameU.Buffer;
            NameU.MaximumLength = NameU.Length = (curr - FileNameU.Buffer) * sizeof(WCHAR);
            FCB = vfatGrabFCBFromTable(pVCB, &NameU);
            if (FCB)
            {
                Length = (curr - FileNameU.Buffer) * sizeof(WCHAR);
                if (Length != FCB->PathNameU.Length)
                {
                    if (FileNameU.Length + FCB->PathNameU.Length - Length > FileNameU.MaximumLength)
                    {
                        vfatReleaseFCB(pVCB, FCB);
                        return STATUS_OBJECT_NAME_INVALID;
                    }
                    RtlMoveMemory(FileNameU.Buffer + FCB->PathNameU.Length / sizeof(WCHAR),
                        curr, FileNameU.Length - Length);
                    FileNameU.Length += (USHORT)(FCB->PathNameU.Length - Length);
                    curr = FileNameU.Buffer + FCB->PathNameU.Length / sizeof(WCHAR);
                    last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
                }
                RtlCopyMemory(FileNameU.Buffer, FCB->PathNameU.Buffer, FCB->PathNameU.Length);
            }
        }
        else
        {
            FCB = NULL;
        }
 
        if (FCB == NULL)
        {
            FCB = vfatOpenRootFCB(pVCB);
            curr = FileNameU.Buffer;
        }
 
        parentFCB = NULL;
        prev = curr;
    }
    else
    {
        /* Make absolute path */
        RtlCopyUnicodeString(&FileNameU, &parentFCB->PathNameU);
        curr = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
        if (*curr != L'\\')
        {
            RtlAppendUnicodeToString(&FileNameU, L"\\");
            curr++;
        }
        ASSERT(*curr == L'\\');
        RtlAppendUnicodeStringToString(&FileNameU, pFileNameU);
 
        FCB = parentFCB;
        parentFCB = NULL;
        prev = curr;
        last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
    }
 
    while (curr <= last)
    {
        if (parentFCB)
        {
            vfatReleaseFCB(pVCB, parentFCB);
            parentFCB = NULL;
        }
        //  fail if element in FCB is not a directory
        if (!vfatFCBIsDirectory(FCB))
        {
            DPRINT ("Element in requested path is not a directory\n");
 
            vfatReleaseFCB(pVCB, FCB);
            FCB = NULL;
            *pParentFCB = NULL;
            *pFCB = NULL;
 
            return  STATUS_OBJECT_PATH_NOT_FOUND;
        }
        parentFCB = FCB;
        if (prev < curr)
        {
            Length = (curr - prev) * sizeof(WCHAR);
            if (Length != parentFCB->LongNameU.Length)
            {
                if (FileNameU.Length + parentFCB->LongNameU.Length - Length > FileNameU.MaximumLength)
                {
                    vfatReleaseFCB(pVCB, parentFCB);
                    *pParentFCB = NULL;
                    *pFCB = NULL;
                    return STATUS_OBJECT_NAME_INVALID;
                }
                RtlMoveMemory(prev + parentFCB->LongNameU.Length / sizeof(WCHAR), curr,
                    FileNameU.Length - (curr - FileNameU.Buffer) * sizeof(WCHAR));
                FileNameU.Length += (USHORT)(parentFCB->LongNameU.Length - Length);
                curr = prev + parentFCB->LongNameU.Length / sizeof(WCHAR);
                last = FileNameU.Buffer + FileNameU.Length / sizeof(WCHAR) - 1;
            }
            RtlCopyMemory(prev, parentFCB->LongNameU.Buffer, parentFCB->LongNameU.Length);
        }
        curr++;
        prev = curr;
        while (*curr != L'\\' && curr <= last)
        {
            curr++;
        }
        NameU.Buffer = FileNameU.Buffer;
        NameU.Length = (curr - NameU.Buffer) * sizeof(WCHAR);
        NameU.MaximumLength = FileNameU.MaximumLength;
        DPRINT("%wZ\n", &NameU);
        FCB = vfatGrabFCBFromTable(pVCB, &NameU);
        if (FCB == NULL)
        {
            NameU.Buffer = prev;
            NameU.MaximumLength = NameU.Length = (curr - prev) * sizeof(WCHAR);
            status = vfatDirFindFile(pVCB, parentFCB, &NameU, &FCB);
            if (status == STATUS_OBJECT_NAME_NOT_FOUND)
            {
                *pFCB = NULL;
                if (curr > last)
                {
                    *pParentFCB = parentFCB;
                    return STATUS_OBJECT_NAME_NOT_FOUND;
                }
                else
                {
                    vfatReleaseFCB(pVCB, parentFCB);
                    *pParentFCB = NULL;
                    return STATUS_OBJECT_PATH_NOT_FOUND;
                }
            }
            else if (!NT_SUCCESS(status))
            {
                vfatReleaseFCB(pVCB, parentFCB);
                *pParentFCB = NULL;
                *pFCB = NULL;
 
                return status;
            }
        }
    }
 
    *pParentFCB = parentFCB;
    *pFCB = FCB;
 
    return STATUS_SUCCESS;
}

Referenced by VfatCreateFile(), VfatOpenFile(), and vfatPrepareTargetForRename().

VfatGetNextDirEntry()

FORCEINLINE NTSTATUS VfatGetNextDirEntry	(	PDEVICE_EXTENSION	DeviceExt,
		PVOID *	pContext,
		PVOID *	pPage,
		struct _VFATFCB *	pDirFcb,
		struct _VFAT_DIRENTRY_CONTEXT *	DirContext,
		BOOLEAN	First
	)

Definition at line 397 of file vfat.h.

{
    return DeviceExt->Dispatch.GetNextDirEntry(pContext, pPage, pDirFcb, DirContext, First);
}

Referenced by FindFile(), and vfatDirFindFile().

VfatGetStandardInformation()

NTSTATUS VfatGetStandardInformation	(	PVFATFCB	FCB,
		PFILE_STANDARD_INFORMATION	StandardInfo,
		PULONG	BufferLength
	)

Definition at line 73 of file finfo.c.

{
    if (*BufferLength < sizeof(FILE_STANDARD_INFORMATION))
        return STATUS_BUFFER_OVERFLOW;
 
    /* PRECONDITION */
    ASSERT(StandardInfo != NULL);
    ASSERT(FCB != NULL);
 
    if (vfatFCBIsDirectory(FCB))
    {
        StandardInfo->AllocationSize.QuadPart = 0;
        StandardInfo->EndOfFile.QuadPart = 0;
        StandardInfo->Directory = TRUE;
    }
    else
    {
        StandardInfo->AllocationSize = FCB->RFCB.AllocationSize;
        StandardInfo->EndOfFile = FCB->RFCB.FileSize;
        StandardInfo->Directory = FALSE;
    }
    StandardInfo->NumberOfLinks = 1;
    StandardInfo->DeletePending = BooleanFlagOn(FCB->Flags, FCB_DELETE_PENDING);
 
    *BufferLength -= sizeof(FILE_STANDARD_INFORMATION);
    return STATUS_SUCCESS;
}

Referenced by VfatFastIoQueryStandardInfo(), VfatGetAllInformation(), and VfatQueryInformation().

VfatGetUserBuffer()

PVOID VfatGetUserBuffer	(	IN PIRP	Irp,
		IN BOOLEAN	Paging
	)

Definition at line 443 of file misc.c.

{
    ASSERT(Irp);
 
    if (Irp->MdlAddress)
    {
        return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, (Paging ? HighPagePriority : NormalPagePriority));
    }
    else
    {
        return Irp->UserBuffer;
    }
}

Referenced by DoQuery(), VfatCommonRead(), and VfatWrite().

vfatGrabFCB()

VOID vfatGrabFCB	(	PDEVICE_EXTENSION	pVCB,
		PVFATFCB	pFCB
	)

Definition at line 301 of file fcb.c.

{
#ifdef KDBG
    if (DebugFile.Buffer != NULL && FsRtlIsNameInExpression(&DebugFile, &pFCB->LongNameU, FALSE, NULL))
    {
        DPRINT1("Inc ref count (%d, oc: %d) for: %p (%wZ) at: %s(%d) %s\n", pFCB->RefCount, pFCB->OpenHandleCount, pFCB, &pFCB->PathNameU, File, Line, Func);
    }
#else
    DPRINT("Grabbing FCB at %p: %wZ, refCount:%d\n",
           pFCB, &pFCB->PathNameU, pFCB->RefCount);
#endif
 
    ASSERT(ExIsResourceAcquiredExclusive(&pVCB->DirResource));
 
    ASSERT(!BooleanFlagOn(pFCB->Flags, FCB_IS_FAT));
    ASSERT(pFCB != pVCB->VolumeFcb && !BooleanFlagOn(pFCB->Flags, FCB_IS_VOLUME));
    ASSERT(pFCB->RefCount > 0);
    ++pFCB->RefCount;
}

Referenced by vfatAddFCBToTable(), VfatCreateFile(), vfatFCBInitializeCacheFromVolume(), vfatGetFCBForFile(), vfatGrabFCBFromTable(), VfatOpenFile(), and VfatSetRenameInformation().

vfatGrabFCBFromTable()

PVFATFCB vfatGrabFCBFromTable	(	PDEVICE_EXTENSION	pDeviceExt,
		PUNICODE_STRING	pFileNameU
	)

Definition at line 594 of file fcb.c.

{
    PVFATFCB  rcFCB;
    ULONG Hash;
    UNICODE_STRING DirNameU;
    UNICODE_STRING FileNameU;
    PUNICODE_STRING FcbNameU;
 
    HASHENTRY* entry;
 
    DPRINT("'%wZ'\n", PathNameU);
 
    ASSERT(PathNameU->Length >= sizeof(WCHAR) && PathNameU->Buffer[0] == L'\\');
    Hash = vfatNameHash(0, PathNameU);
 
    entry = pVCB->FcbHashTable[Hash % pVCB->HashTableSize];
    if (entry)
    {
        vfatSplitPathName(PathNameU, &DirNameU, &FileNameU);
    }
 
    while (entry)
    {
        if (entry->Hash == Hash)
        {
            rcFCB = entry->self;
            DPRINT("'%wZ' '%wZ'\n", &DirNameU, &rcFCB->DirNameU);
            if (RtlEqualUnicodeString(&DirNameU, &rcFCB->DirNameU, TRUE))
            {
                if (rcFCB->Hash.Hash == Hash)
                {
                    FcbNameU = &rcFCB->LongNameU;
                }
                else
                {
                    FcbNameU = &rcFCB->ShortNameU;
                }
                /* compare the file name */
                DPRINT("'%wZ' '%wZ'\n", &FileNameU, FcbNameU);
                if (RtlEqualUnicodeString(&FileNameU, FcbNameU, TRUE))
                {
                    vfatGrabFCB(pVCB, rcFCB);
                    return rcFCB;
                }
            }
        }
        entry = entry->next;
    }
    return NULL;
}

Referenced by FindFile(), vfatGetFCBForFile(), and vfatOpenRootFCB().

VfatHandleDeferredWrite()

VOID NTAPI VfatHandleDeferredWrite	(	IN PVOID	IrpContext,
		IN PVOID	Unused
	)

Definition at line 220 of file misc.c.

{
    VfatDispatchRequest((PVFAT_IRP_CONTEXT)IrpContext);
}

Referenced by VfatWrite().

VfatInitFastIoRoutines()

VOID VfatInitFastIoRoutines

(

PFAST_IO_DISPATCH

FastIoDispatch

)

Definition at line 753 of file fastio.c.

{
    FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
    FastIoDispatch->FastIoCheckIfPossible = VfatFastIoCheckIfPossible;
    FastIoDispatch->FastIoRead = VfatFastIoRead;
    FastIoDispatch->FastIoWrite = VfatFastIoWrite;
    FastIoDispatch->FastIoQueryBasicInfo = VfatFastIoQueryBasicInfo;
    FastIoDispatch->FastIoQueryStandardInfo = VfatFastIoQueryStandardInfo;
    FastIoDispatch->FastIoLock = VfatFastIoLock;
    FastIoDispatch->FastIoUnlockSingle = VfatFastIoUnlockSingle;
    FastIoDispatch->FastIoUnlockAll = VfatFastIoUnlockAll;
    FastIoDispatch->FastIoUnlockAllByKey = VfatFastIoUnlockAllByKey;
    FastIoDispatch->FastIoDeviceControl = VfatFastIoDeviceControl;
    FastIoDispatch->AcquireFileForNtCreateSection = VfatAcquireFileForNtCreateSection;
    FastIoDispatch->ReleaseFileForNtCreateSection = VfatReleaseFileForNtCreateSection;
    FastIoDispatch->FastIoDetachDevice = VfatFastIoDetachDevice;
    FastIoDispatch->FastIoQueryNetworkOpenInfo = VfatFastIoQueryNetworkOpenInfo;
    FastIoDispatch->MdlRead = VfatMdlRead;
    FastIoDispatch->MdlReadComplete = VfatMdlReadComplete;
    FastIoDispatch->PrepareMdlWrite = VfatPrepareMdlWrite;
    FastIoDispatch->