cdprocs.h File Reference

#include <ntifs.h>
#include <ntddcdrm.h>
#include <ntdddisk.h>
#include <ntddscsi.h>
#include "nodetype.h"
#include "cd.h"
#include "cdstruc.h"
#include "cddata.h"

Include dependency graph for cdprocs.h:

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

Go to the source code of this file.

Classes
union	_UCHAR1
union	_UCHAR2
union	_UCHAR4
union	_USHORT2

Macros
#define	INLINE   __inline
#define	Min(a, b)   ((a) < (b) ? (a) : (b))
#define	Max(a, b)   ((a) > (b) ? (a) : (b))
#define	TAG_CCB   'ccdC'
#define	TAG_CDROM_TOC   'ctdC'
#define	TAG_DIRENT_NAME   'nddC'
#define	TAG_ENUM_EXPRESSION   'eedC'
#define	TAG_FCB_DATA   'dfdC'
#define	TAG_FCB_INDEX   'ifdC'
#define	TAG_FCB_NONPAGED   'nfdC'
#define	TAG_FCB_TABLE   'tfdC'
#define	TAG_FILE_NAME   'nFdC'
#define	TAG_GEN_SHORT_NAME   'sgdC'
#define	TAG_IO_BUFFER   'fbdC'
#define	TAG_IO_CONTEXT   'oidC'
#define	TAG_IRP_CONTEXT   'cidC'
#define	TAG_IRP_CONTEXT_LITE   'lidC'
#define	TAG_MCB_ARRAY   'amdC'
#define	TAG_PATH_ENTRY_NAME   'nPdC'
#define	TAG_PREFIX_ENTRY   'epdC'
#define	TAG_PREFIX_NAME   'npdC'
#define	TAG_SPANNING_PATH_TABLE   'psdC'
#define	TAG_UPCASE_NAME   'nudC'
#define	TAG_VOL_DESC   'dvdC'
#define	TAG_VPB   'pvdC'
#define	CdIllegalFcbAccess(IC, T, DA)
#define	CdUnpinData(IC, B)    if (*(B) != NULL) { CcUnpinData( *(B) ); *(B) = NULL; }
#define	CdMapUserBuffer(IC, UB)
#define	CdLockUserBuffer(IC, BL, OP)
#define	CdInitializeFileContext(IC, FC)
#define	CdInitializeDirent(IC, D)    RtlZeroMemory( D, sizeof( DIRENT ))
#define	CdInitializeDirContext(IC, DC)    RtlZeroMemory( DC, sizeof( DIRENT_ENUM_CONTEXT ))
#define	CdCleanupDirent(IC, D)
#define	CdCleanupDirContext(IC, DC)    CdUnpinData( (IC), &(DC)->Bcb )
#define	CdLookupInitialFileDirent(IC, F, FC, DO)
#define	CdInitializeCompoundPathEntry(IC, CP)    RtlZeroMemory( CP, sizeof( COMPOUND_PATH_ENTRY ))
#define	CdCleanupCompoundPathEntry(IC, CP)
#define	CdAcquireCacheForRead(IC)    ExAcquireResourceSharedLite( &(IC)->Vcb->SectorCacheResource, TRUE)
#define	CdAcquireCacheForUpdate(IC)    ExAcquireResourceExclusiveLite( &(IC)->Vcb->SectorCacheResource, TRUE)
#define	CdReleaseCache(IC)    ExReleaseResourceLite( &(IC)->Vcb->SectorCacheResource);
#define	CdConvertCacheToShared(IC)    ExConvertExclusiveToSharedLite( &(IC)->Vcb->SectorCacheResource);
#define	CdAcquireCdData(IC)    ExAcquireResourceExclusiveLite( &CdData.DataResource, TRUE )
#define	CdReleaseCdData(IC)    ExReleaseResourceLite( &CdData.DataResource )
#define	CdAcquireVcbExclusive(IC, V, I)    CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireExclusive )
#define	CdAcquireVcbShared(IC, V, I)    CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireShared )
#define	CdReleaseVcb(IC, V)    ExReleaseResourceLite( &(V)->VcbResource )
#define	CdAcquireAllFiles(IC, V)    CdAcquireResource( (IC), &(V)->FileResource, FALSE, AcquireExclusive )
#define	CdReleaseAllFiles(IC, V)    ExReleaseResourceLite( &(V)->FileResource )
#define	CdAcquireFileExclusive(IC, F)    CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireExclusive )
#define	CdAcquireFileShared(IC, F)    CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireShared )
#define	CdAcquireFileSharedStarveExclusive(IC, F)    CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireSharedStarveExclusive )
#define	CdReleaseFile(IC, F)    ExReleaseResourceLite( (F)->Resource )
#define	CdAcquireFcbExclusive(IC, F, I)    CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireExclusive )
#define	CdAcquireFcbShared(IC, F, I)    CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireShared )
#define	CdReleaseFcb(IC, F)    ExReleaseResourceLite( &(F)->FcbNonpaged->FcbResource )
#define	CdLockCdData()
#define	CdUnlockCdData()
#define	CdLockVcb(IC, V)
#define	CdUnlockVcb(IC, V)
#define	CdLockFcb(IC, F)
#define	CdUnlockFcb(IC, F)
#define	CdGetFcbOplock(F)   &(F)->Header.Oplock
#define	CdCreateIrpContextLite(IC)    ExAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT_LITE ), TAG_IRP_CONTEXT_LITE )
#define	CdFreeIrpContextLite(ICL)    CdFreePool( &(ICL) )
#define	CdIncrementCleanupCounts(IC, F)
#define	CdDecrementCleanupCounts(IC, F)
#define	CdIncrementReferenceCounts(IC, F, C, UC)
#define	CdDecrementReferenceCounts(IC, F, C, UC)
#define	CdAllocateIoContext()
#define	CdFreeIoContext(IO)   CdFreePool( (PVOID) &(IO) ) /* ReactOS Change: GCC "passing argument 1 from incompatible pointer type" */
#define	CdPagedPool   PagedPool
#define	CdNonPagedPool   NonPagedPoolNx
#define	CdNonPagedPoolCacheAligned   NonPagedPoolNxCacheAligned
#define	CdUpdateMediaChangeCount(V, C)   (V)->MediaChangeCount = (C)
#define	CdUpdateVcbCondition(V, C)   (V)->VcbCondition = (C)
#define	CdMarkRealDevForVerify(DO)   SetFlag( (DO)->Flags, DO_VERIFY_VOLUME)
#define	CdMarkRealDevVerifyOk(DO)   ClearFlag( (DO)->Flags, DO_VERIFY_VOLUME)
#define	CdRealDevNeedsVerify(DO)   BooleanFlagOn( (DO)->Flags, DO_VERIFY_VOLUME)
#define	CdIsRawDevice(IC, S)
#define	Add2Ptr(PTR, INC, CAST)   ((CAST)((PUCHAR)(PTR) + (INC)))
#define	PtrOffset(BASE, OFFSET)   ((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))
#define	WordAlign(Ptr)
#define	LongAlign(Ptr)
#define	QuadAlign(Ptr)
#define	SectorAlign(L)
#define	LlSectorAlign(L)
#define	SectorTruncate(L)
#define	LlSectorTruncate(L)
#define	BytesFromSectors(L)
#define	SectorsFromBytes(L)
#define	LlBytesFromSectors(L)
#define	LlSectorsFromBytes(L)
#define	SectorOffset(L)
#define	SectorBlockOffset(V, LB)
#define	BytesFromBlocks(V, B)
#define	LlBytesFromBlocks(V, B)
#define	BlockAlign(V, L)
#define	LlBlockAlign(V, L)
#define	BlockOffset(V, L)
#define	RawSectorAlign(B)   ((((B)+(RAW_SECTOR_SIZE - 1)) / RAW_SECTOR_SIZE) * RAW_SECTOR_SIZE)
#define	CopyUchar1(Dst, Src)
#define	CopyUchar2(Dst, Src)
#define	CopyUchar4(Dst, Src)
#define	CopyUshort2(Dst, Src)
#define	SwapCopyUchar4(Dst, Src)
#define	AssertVerifyDevice(C, S)
#define	AssertVerifyDeviceIrp(I)
#define	CdRaiseStatus(IC, S)   CdRaiseStatusEx( (IC), (S), FALSE, BugCheckFileId, __LINE__);
#define	CdNormalizeAndRaiseStatus(IC, S)   CdRaiseStatusEx( (IC), (S), TRUE, BugCheckFileId, __LINE__);
#define	CdRestoreThreadContext(IC)
#define	CanFsdWait(I)   IoIsOperationSynchronous(I)
#define	CdIsFastIoPossible(F)
#define	try_return(S)   { S; goto try_exit; }
#define	try_leave(S)   { S; leave; }
#define	CdFreePool(x)   _CdFreePool((PVOID*)(x))
#define	CdTelemetryMountSafe(...)   NOTHING

Typedefs
typedef enum _TYPE_OF_OPEN	TYPE_OF_OPEN
typedef TYPE_OF_OPEN *	PTYPE_OF_OPEN
typedef enum _TYPE_OF_ACQUIRE	TYPE_OF_ACQUIRE
typedef enum _TYPE_OF_ACQUIRE *	PTYPE_OF_ACQUIRE
typedef union _UCHAR1	UCHAR1
typedef union _UCHAR1 *	PUCHAR1
typedef union _UCHAR2	UCHAR2
typedef union _UCHAR2 *	PUCHAR2
typedef union _UCHAR4	UCHAR4
typedef union _UCHAR4 *	PUCHAR4
typedef union _USHORT2	USHORT2
typedef union _USHORT2 *	PUSHORT2

Enumerations
enum	_TYPE_OF_OPEN {   UnopenedFileObject = 0 , StreamFileOpen , UserVolumeOpen , UserDirectoryOpen ,   UserFileOpen , BeyondValidType , UnopenedFileObject = 1 , UserFileOpen ,   UserDirectoryOpen , UserVolumeOpen , VirtualVolumeFile , DirectoryFile ,   EaFile }
enum	_TYPE_OF_ACQUIRE { AcquireExclusive , AcquireShared , AcquireSharedStarveExclusive }

Functions
	_Requires_lock_held_ (_Global_critical_region_) VOID CdLookupAllocation(_In_ PIRP_CONTEXT IrpContext
VOID	CdAddAllocationFromDirent (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ ULONG McbEntryOffset, _In_ LONGLONG StartingFileOffset, _In_ PDIRENT Dirent)
VOID	CdAddInitialAllocation (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ ULONG StartingBlock, _In_ LONGLONG DataLength)
VOID	CdTruncateAllocation (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ LONGLONG StartingFileOffset)
	_At_ (Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET(FCB, FcbType))) VOID CdInitializeMcb(_In_ PIRP_CONTEXT IrpContext
	_Inout_updates_bytes_ (Fcb->NodeByteSize) PFCB Fcb)
VOID	CdCreateInternalStream (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Inout_ PFCB Fcb, _In_ PUNICODE_STRING Name)
VOID	CdDeleteInternalStream (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb)
NTSTATUS	CdCompleteMdl (_In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
static INLINE VOID	CdVerifyOrCreateDirStreamFile (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)
BOOLEAN	CdReadSectors (_In_ PIRP_CONTEXT IrpContext, _In_ LONGLONG StartingOffset, _In_ ULONG ByteCount, _In_ BOOLEAN ReturnError, _Out_writes_bytes_(ByteCount) PVOID Buffer, _In_ PDEVICE_OBJECT TargetDeviceObject)
NTSTATUS	CdCreateUserMdl (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG BufferLength, _In_ BOOLEAN RaiseOnError, _In_ LOCK_OPERATION Operation)
NTSTATUS FASTCALL	CdPerformDevIoCtrl (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT Device, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_ BOOLEAN OverrideVerify, _Out_opt_ PIO_STATUS_BLOCK Iosb)
NTSTATUS	CdPerformDevIoCtrlEx (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT Device, _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_ BOOLEAN OverrideVerify, _Out_opt_ PIO_STATUS_BLOCK Iosb)
NTSTATUS	CdHijackIrpAndFlushDevice (_In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp, _In_ PDEVICE_OBJECT TargetDeviceObject)
VOID	CdLookupDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG DirentOffset, _Out_ PDIRENT_ENUM_CONTEXT DirContext)
BOOLEAN	CdLookupNextDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext)
	_At_ (Dirent->CdTime, _Post_notnull_) VOID CdUpdateDirentFromRawDirent(_In_ PIRP_CONTEXT IrpContext
VOID	CdUpdateDirentName (_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
	_Success_ (return !=FALSE) BOOLEAN CdFindFile(_In_ PIRP_CONTEXT IrpContext
BOOLEAN	CdFindDirectory (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _Inout_ PFILE_ENUM_CONTEXT FileContext)
	_At_ (FileContext->ShortName.FileName.MaximumLength, _In_range_(>=, BYTE_COUNT_8_DOT_3)) BOOLEAN CdFindFileByShortName(_In_ PIRP_CONTEXT IrpContext
BOOLEAN	CdLookupNextInitialFileDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
VOID	CdLookupLastFileDirent (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext)
VOID	CdCleanupFileContext (_In_ PIRP_CONTEXT IrpContext, _In_ PFILE_ENUM_CONTEXT FileContext)
	_When_ (TypeOfOpen==UnopenedFileObject, _At_(Fcb, _In_opt_)) _When_(TypeOfOpen !
	_At_ (Fcb, _In_)) VOID CdSetFileObject(_In_ PIRP_CONTEXT IrpContext
	_When_ (return==UnopenedFileObject, _At_(*Fcb, _Post_null_)) _When_(return !
	_At_ (Fcb, _Outptr_)) _When_(return
_At_ Ccb	_When_ (return !=UnopenedFileObject, _At_(Ccb, _Outptr_)) TYPE_OF_OPEN CdDecodeFileObject(_In_ PIRP_CONTEXT IrpContext
TYPE_OF_OPEN	CdFastDecodeFileObject (_In_ PFILE_OBJECT FileObject, _Out_ PFCB *Fcb)
	_Post_satisfies_ (_Old_(CdName->FileName.Length) >=CdName->FileName.Length+CdName->VersionString.Length) VOID CdConvertNameToCdName(_In_ PIRP_CONTEXT IrpContext
VOID	CdConvertBigToLittleEndian (_In_ PIRP_CONTEXT IrpContext, _In_reads_bytes_(ByteCount) PCHAR BigEndian, _In_ ULONG ByteCount, _Out_writes_bytes_(ByteCount) PCHAR LittleEndian)
VOID	CdUpcaseName (_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME Name, _Inout_ PCD_NAME UpcaseName)
VOID	CdDissectName (_In_ PIRP_CONTEXT IrpContext, _Inout_ PUNICODE_STRING RemainingName, _Out_ PUNICODE_STRING FinalName)
BOOLEAN	CdIsLegalName (_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName)
BOOLEAN	CdIs8dot3Name (_In_ PIRP_CONTEXT IrpContext, _In_ UNICODE_STRING FileName)
VOID	CdGenerate8dot3Name (_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName, _In_ ULONG DirentOffset, _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName, _Out_ PUSHORT ShortByteCount)
BOOLEAN	CdIsNameInExpression (_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
ULONG	CdShortNameDirentOffset (_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING Name)
FSRTL_COMPARISON_RESULT	CdFullCompareNames (_In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING NameA, _In_ PUNICODE_STRING NameB)
NTSTATUS	CdUnlockVolumeInternal (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_opt_ PFILE_OBJECT FileObject)
VOID	CdLookupPathEntry (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG PathEntryOffset, _In_ ULONG Ordinal, _In_ BOOLEAN VerifyBounds, _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry)
BOOLEAN	CdLookupNextPathEntry (_In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENUM_CONTEXT PathContext, _Inout_ PPATH_ENTRY PathEntry)
VOID	CdUpdatePathEntryName (_In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENTRY PathEntry, _In_ BOOLEAN IgnoreCase)
VOID	CdInsertPrefix (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _In_ BOOLEAN ShortNameMatch, _Inout_ PFCB ParentFcb)
VOID	CdRemovePrefix (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb)
_Acquires_exclusive_lock_ Resource	_When_ (Type==AcquireShared &&return !=FALSE, _Acquires_shared_lock_(*Resource)) _When_(Type
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource	_When_ (IgnoreWait==FALSE, _Post_satisfies_(return==TRUE)) BOOLEAN CdAcquireResource(_In_ PIRP_CONTEXT IrpContext
BOOLEAN NTAPI	CdNoopAcquire (_In_ PVOID Fcb, _In_ BOOLEAN Wait)
VOID NTAPI	CdNoopRelease (_In_ PVOID Fcb)
_Acquires_shared_lock_ Fcb BOOLEAN NTAPI	CdAcquireForCache (_Inout_ PFCB Fcb, _In_ BOOLEAN Wait)
	_Function_class_ (FAST_IO_RELEASE_FILE) _Requires_lock_held_(_Global_critical_region_) VOID NTAPI CdReleaseForCreateSection(_In_ PFILE_OBJECT FileObject)
VOID	CdInitializeVcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_ __drv_aliasesMem PDEVICE_OBJECT TargetDeviceObject, _In_ __drv_aliasesMem PVPB Vpb, _In_ __drv_aliasesMem PCDROM_TOC_LARGE CdromToc, _In_ ULONG TocLength, _In_ ULONG TocTrackCount, _In_ ULONG TocDiskFlags, _In_ ULONG BlockFactor, _In_ ULONG MediaChangeCount)
VOID	CdUpdateVcbFromVolDescriptor (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_reads_bytes_opt_(SECTOR_SIZE) PCHAR RawIsoVd)
VOID	CdDeleteVcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb)
PFCB	CdCreateFcb (_In_ PIRP_CONTEXT IrpContext, _In_ FILE_ID FileId, _In_ NODE_TYPE_CODE NodeTypeCode, _Out_opt_ PBOOLEAN FcbExisted)
VOID	CdInitializeFcbFromPathEntry (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_opt_ PFCB ParentFcb, _In_ PPATH_ENTRY PathEntry)
VOID	CdInitializeFcbFromFileContext (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ PFCB ParentFcb, _In_ PFILE_ENUM_CONTEXT FileContext)
PCCB	CdCreateCcb (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG Flags)
VOID	CdDeleteCcb (_In_ PIRP_CONTEXT IrpContext, _In_ __drv_freesMem(Pool) PCCB Ccb)
	_When_ (RaiseOnError||return, _At_(Fcb->FileLock, _Post_notnull_)) _When_(RaiseOnError
	_At_ (IrpContext, _Pre_notnull_)) BOOLEAN CdCreateFileLock(_In_opt_ PIRP_CONTEXT IrpContext
VOID	CdDeleteFileLock (_In_ PIRP_CONTEXT IrpContext, _Inout_ PFILE_LOCK FileLock)
_Ret_valid_ PIRP_CONTEXT	CdCreateIrpContext (_In_ PIRP Irp, _In_ BOOLEAN Wait)
VOID	CdCleanupIrpContext (_In_ PIRP_CONTEXT IrpContext, _In_ BOOLEAN Post)
VOID	CdInitializeStackIrpContext (_Out_ PIRP_CONTEXT IrpContext, _In_ PIRP_CONTEXT_LITE IrpContextLite)
PFCB	CdLookupFcbTable (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ FILE_ID FileId)
PFCB	CdGetNextFcb (_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ PVOID *RestartKey)
NTSTATUS	CdProcessToc (_In_ PIRP_CONTEXT IrpContext, _In_ PDEVICE_OBJECT TargetDeviceObject, _In_ PCDROM_TOC_LARGE CdromToc, _Inout_ PULONG Length, _Out_ PULONG TrackCount, _Inout_ PULONG DiskFlags)
static INLINE BOOLEAN	CdOperationIsDasdOpen (_In_ PIRP_CONTEXT IrpContext)
BOOLEAN	CdMarkDevForVerifyIfVcbMounted (_Inout_ PVCB Vcb)
VOID	CdVerifyVcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb)
BOOLEAN	CdVerifyFcbOperation (_In_opt_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)
static INLINE ULONG	SectorsFromLlBytes (ULONGLONG Bytes)
VOID	CdLbnToMmSsFf (_In_ ULONG Blocks, _Out_writes_(3) PUCHAR Msf)
	_IRQL_requires_max_ (APC_LEVEL) __drv_dispatchType(DRIVER_DISPATCH) __drv_dispatchType(IRP_MJ_CREATE) __drv_dispatchType(IRP_MJ_CLOSE) __drv_dispatchType(IRP_MJ_READ) __drv_dispatchType(IRP_MJ_WRITE) __drv_dispatchType(IRP_MJ_QUERY_INFORMATION) __drv_dispatchType(IRP_MJ_SET_INFORMATION) __drv_dispatchType(IRP_MJ_QUERY_VOLUME_INFORMATION) __drv_dispatchType(IRP_MJ_DIRECTORY_CONTROL) __drv_dispatchType(IRP_MJ_FILE_SYSTEM_CONTROL) __drv_dispatchType(IRP_MJ_DEVICE_CONTROL) __drv_dispatchType(IRP_MJ_LOCK_CONTROL) __drv_dispatchType(IRP_MJ_CLEANUP) __drv_dispatchType(IRP_MJ_PNP) __drv_dispatchType(IRP_MJ_SHUTDOWN) NTSTATUS NTAPI CdFsdDispatch(_In_ PDEVICE_OBJECT DeviceObject
LONG	CdExceptionFilter (_Inout_ PIRP_CONTEXT IrpContext, _In_ PEXCEPTION_POINTERS ExceptionPointer)
VOID	CdCompleteRequest (_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
INLINE DECLSPEC_NORETURN VOID	CdRaiseStatusEx (_In_ PIRP_CONTEXT IrpContext, _In_ NTSTATUS Status, _In_ BOOLEAN NormalizeStatus, _In_ ULONG Fileid, _In_ ULONG Line)
VOID	CdSetThreadContext (_Inout_ PIRP_CONTEXT IrpContext, _In_ PTHREAD_CONTEXT ThreadContext)
ULONG	CdSerial32 (_In_reads_bytes_(ByteCount) PCHAR Buffer, _In_ ULONG ByteCount)
VOID	CdFspClose (_In_opt_ PVCB Vcb)
NTSTATUS	CdCommonDevControl (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
NTSTATUS	CdCommonLockControl (_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
static INLINE VOID	_CdFreePool (_Inout_ _At_(*Pool, __drv_freesMem(Mem) _Post_null_) PVOID *Pool)

Variables
_In_ PFCB	Fcb
_In_ PFCB _In_ LONGLONG	FileOffset
_In_ PFCB _In_ LONGLONG _Out_ PLONGLONG	DiskOffset
_In_ PFCB _In_ LONGLONG _Out_ PLONGLONG _Out_ PULONG	ByteCount
_In_ PVCB	Vcb
_In_ PVCB _In_ BOOLEAN	DismountUnderway
_In_ PFCB _In_ LONGLONG	StartingOffset
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT	DirContext
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT	Dirent
_In_ PFCB _In_ PCD_NAME	Name
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN	IgnoreCase
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT	FileContext
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT _Out_ PCD_NAME *	MatchingName
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG	ShortNameDirentOffset
_Inout_ PFILE_OBJECT	FileObject
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN	TypeOfOpen
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB	Ccb
_Inout_ PCD_NAME	CdName
_In_ PFCB	ParentFcb
_In_ PFCB _In_ PCD_NAME	DirName
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PCOMPOUND_PATH_ENTRY	CompoundPathEntry
_Inout_ PFCB *	CurrentFcb
_Inout_ PFCB _Inout_ PUNICODE_STRING	RemainingName
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE	Resource
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE _In_ BOOLEAN	IgnoreWait
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE _In_ BOOLEAN _In_ TYPE_OF_ACQUIRE	Type
_Unreferenced_parameter_ PVOID *	CompletionContext
_Inout_ PFCB _In_ BOOLEAN	RaiseOnError
_Inout_ PFCB	StartingFcb
_Inout_ PFCB _Out_ PBOOLEAN	RemovedStartingFcb
_Inout_ PIRP	Irp
_Inout_ PIRP _In_ PDEVICE_OBJECT	DeviceToVerify
_Inout_ PVCB _In_ BOOLEAN	Force
_Inout_ PIRP _In_ NTSTATUS	ExceptionCode
FAST_IO_QUERY_BASIC_INFO	CdFastQueryBasicInfo
FAST_IO_QUERY_STANDARD_INFO	CdFastQueryStdInfo
FAST_IO_LOCK	CdFastLock
FAST_IO_UNLOCK_SINGLE	CdFastUnlockSingle
FAST_IO_UNLOCK_ALL	CdFastUnlockAll
FAST_IO_UNLOCK_ALL_BY_KEY	CdFastUnlockAllByKey
FAST_IO_CHECK_IF_POSSIBLE	CdFastIoCheckIfPossible
FAST_IO_QUERY_NETWORK_OPEN_INFO	CdFastQueryNetworkInfo
WORKER_THREAD_ROUTINE	CdFspDispatch

Macro Definition Documentation

Add2Ptr

#define Add2Ptr	(		PTR,
			INC,
			CAST
	)		((CAST)((PUCHAR)(PTR) + (INC)))

Definition at line 1545 of file cdprocs.h.

AssertVerifyDevice

#define AssertVerifyDevice	(		C,
			S
	)

Definition at line 1810 of file cdprocs.h.

AssertVerifyDeviceIrp

#define AssertVerifyDeviceIrp

(

I

)

Definition at line 1811 of file cdprocs.h.

BlockAlign

#define BlockAlign	(		V,
			L
	)

Value:

    (                                               \
    ((ULONG)(L) + (V)->BlockMask) & (V)->BlockInverseMask               \
)

Definition at line 1638 of file cdprocs.h.

BlockOffset

#define BlockOffset	(		V,
			L
	)

Value:

    (                                              \
    ((ULONG) (L)) & (V)->BlockMask                                      \
)

Definition at line 1650 of file cdprocs.h.

BytesFromBlocks

#define BytesFromBlocks	(		V,
			B
	)

Value:

    (                                          \
    (ULONG) (B) << (V)->BlockToByteShift                                \
)

Definition at line 1630 of file cdprocs.h.

BytesFromSectors

#define BytesFromSectors

(

L

)

Value:

    (                                           \
    ((ULONG) (L)) << SECTOR_SHIFT                                       \
)

Definition at line 1596 of file cdprocs.h.

CanFsdWait

#define CanFsdWait

(

I

)

IoIsOperationSynchronous(I)

Definition at line 2001 of file cdprocs.h.

CdAcquireAllFiles

#define CdAcquireAllFiles	(		IC,
			V
	)		CdAcquireResource( (IC), &(V)->FileResource, FALSE, AcquireExclusive )

Definition at line 988 of file cdprocs.h.

CdAcquireCacheForRead

#define CdAcquireCacheForRead

(

IC

)

ExAcquireResourceSharedLite( &(IC)->Vcb->SectorCacheResource, TRUE)

Definition at line 961 of file cdprocs.h.

CdAcquireCacheForUpdate

#define CdAcquireCacheForUpdate

(

IC

)

ExAcquireResourceExclusiveLite( &(IC)->Vcb->SectorCacheResource, TRUE)

Definition at line 964 of file cdprocs.h.

CdAcquireCdData

#define CdAcquireCdData

(

IC

)

ExAcquireResourceExclusiveLite( &CdData.DataResource, TRUE )

Definition at line 973 of file cdprocs.h.

CdAcquireFcbExclusive

#define CdAcquireFcbExclusive	(		IC,
			F,
			I
	)		CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireExclusive )

Definition at line 1006 of file cdprocs.h.

CdAcquireFcbShared

#define CdAcquireFcbShared	(		IC,
			F,
			I
	)		CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireShared )

Definition at line 1009 of file cdprocs.h.

CdAcquireFileExclusive

#define CdAcquireFileExclusive	(		IC,
			F
	)		CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireExclusive )

Definition at line 994 of file cdprocs.h.

CdAcquireFileShared

#define CdAcquireFileShared	(		IC,
			F
	)		CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireShared )

Definition at line 997 of file cdprocs.h.

CdAcquireFileSharedStarveExclusive

#define CdAcquireFileSharedStarveExclusive	(		IC,
			F
	)		CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireSharedStarveExclusive )

Definition at line 1000 of file cdprocs.h.

CdAcquireVcbExclusive

#define CdAcquireVcbExclusive	(		IC,
			V,
			I
	)		CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireExclusive )

Definition at line 979 of file cdprocs.h.

CdAcquireVcbShared

#define CdAcquireVcbShared	(		IC,
			V,
			I
	)		CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireShared )

Definition at line 982 of file cdprocs.h.

CdAllocateIoContext

#define CdAllocateIoContext

(

)

Value:

    FsRtlAllocatePoolWithTag( CdNonPagedPool,           \
                              sizeof( CD_IO_CONTEXT ),  \
                              TAG_IO_CONTEXT )

Definition at line 1344 of file cdprocs.h.

CdCleanupCompoundPathEntry

#define CdCleanupCompoundPathEntry	(		IC,
			CP
	)

Value:

    {                                 \
    CdUnpinData( (IC), &(CP)->PathContext.Bcb );                                \
    if ((CP)->PathContext.AllocatedData) {                                      \
        CdFreePool( &(CP)->PathContext.Data );                                   \
    }                                                                           \
    if (FlagOn( (CP)->PathEntry.Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER )) {        \
        CdFreePool( &(CP)->PathEntry.CdDirName.FileName.Buffer );                \
    }                                                                           \
}

Definition at line 766 of file cdprocs.h.

CdCleanupDirContext

#define CdCleanupDirContext	(		IC,
			DC
	)		CdUnpinData( (IC), &(DC)->Bcb )

Definition at line 548 of file cdprocs.h.

CdCleanupDirent

#define CdCleanupDirent	(		IC,
			D
	)

Value:

    {                                \
    if (FlagOn( (D)->Flags, DIRENT_FLAG_ALLOC_BUFFER )) {       \
        CdFreePool( &(D)->CdFileName.FileName.Buffer );          \
    }                                                           \
}

Definition at line 542 of file cdprocs.h.

CdConvertCacheToShared

#define CdConvertCacheToShared

(

IC

)

ExConvertExclusiveToSharedLite( &(IC)->Vcb->SectorCacheResource);

Definition at line 970 of file cdprocs.h.

CdCreateIrpContextLite

#define CdCreateIrpContextLite

(

IC

)

ExAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT_LITE ), TAG_IRP_CONTEXT_LITE )

Definition at line 1249 of file cdprocs.h.

CdDecrementCleanupCounts

#define CdDecrementCleanupCounts	(		IC,
			F
	)

Value:

    {        \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbCleanup -= 1;                       \
    (F)->Vcb->VcbCleanup -= 1;                  \
}

Definition at line 1311 of file cdprocs.h.

CdDecrementReferenceCounts

#define CdDecrementReferenceCounts	(		IC,
			F,
			C,
			UC
	)

Value:

    { \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbReference -= (C);                   \
    (F)->FcbUserReference -= (UC);              \
    (F)->Vcb->VcbReference -= (C);              \
    (F)->Vcb->VcbUserReference -= (UC);         \
}

Definition at line 1325 of file cdprocs.h.

CdFreeIoContext

#define CdFreeIoContext

(

IO

)

CdFreePool( (PVOID) &(IO) ) /* ReactOS Change: GCC "passing argument 1 from incompatible pointer type" */

Definition at line 1349 of file cdprocs.h.

CdFreeIrpContextLite

#define CdFreeIrpContextLite

(

ICL

)

CdFreePool( &(ICL) )

Definition at line 1252 of file cdprocs.h.

CdFreePool

#define CdFreePool

(

x

)

_CdFreePool((PVOID*)(x))

Definition at line 2190 of file cdprocs.h.

CdGetFcbOplock

#define CdGetFcbOplock

(

F

)

&(F)->Header.Oplock

Definition at line 1081 of file cdprocs.h.

CdIllegalFcbAccess

#define CdIllegalFcbAccess	(		IC,
			T,
			DA
	)

Value:

           (                           \
           BooleanFlagOn( (DA),                                 \
                          ((T) != UserVolumeOpen ?              \
                           (FILE_WRITE_ATTRIBUTES           |   \
                            FILE_WRITE_DATA                 |   \
                            FILE_WRITE_EA                   |   \
                            FILE_ADD_FILE                   |   \
                            FILE_ADD_SUBDIRECTORY           |   \
                            FILE_APPEND_DATA) : 0)          |   \
                          FILE_DELETE_CHILD                 |   \
                          DELETE                            |   \
                          WRITE_DAC ))

Definition at line 135 of file cdprocs.h.

CdIncrementCleanupCounts

#define CdIncrementCleanupCounts	(		IC,
			F
	)

Value:

    {        \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbCleanup += 1;                       \
    (F)->Vcb->VcbCleanup += 1;                  \
}

Definition at line 1305 of file cdprocs.h.

CdIncrementReferenceCounts

#define CdIncrementReferenceCounts	(		IC,
			F,
			C,
			UC
	)

Value:

    { \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbReference += (C);                   \
    (F)->FcbUserReference += (UC);              \
    (F)->Vcb->VcbReference += (C);              \
    (F)->Vcb->VcbUserReference += (UC);         \
}

Definition at line 1317 of file cdprocs.h.

CdInitializeCompoundPathEntry

#define CdInitializeCompoundPathEntry	(		IC,
			CP
	)		RtlZeroMemory( CP, sizeof( COMPOUND_PATH_ENTRY ))

Definition at line 763 of file cdprocs.h.

CdInitializeDirContext

#define CdInitializeDirContext	(		IC,
			DC
	)		RtlZeroMemory( DC, sizeof( DIRENT_ENUM_CONTEXT ))

Definition at line 539 of file cdprocs.h.

CdInitializeDirent

#define CdInitializeDirent	(		IC,
			D
	)		RtlZeroMemory( D, sizeof( DIRENT ))

Definition at line 536 of file cdprocs.h.

CdInitializeFileContext

#define CdInitializeFileContext	(		IC,
			FC
	)

Value:

    {                                \
    RtlZeroMemory( FC, sizeof( FILE_ENUM_CONTEXT ));                    \
    (FC)->PriorDirent = &(FC)->Dirents[0];                              \
    (FC)->InitialDirent = &(FC)->Dirents[1];                            \
    (FC)->CurrentDirent = &(FC)->Dirents[2];                            \
    (FC)->ShortName.FileName.MaximumLength = BYTE_COUNT_8_DOT_3;        \
    (FC)->ShortName.FileName.Buffer = (FC)->ShortNameBuffer;            \
}

Definition at line 527 of file cdprocs.h.

CdIsFastIoPossible

#define CdIsFastIoPossible

(

F

)

Value:

    ((BOOLEAN)                                            \
    ((((F)->Vcb->VcbCondition != VcbMounted ) ||                                    \
      !FsRtlOplockIsFastIoPossible( CdGetFcbOplock(F) )) ?                          \
                                                                                    \
     FastIoIsNotPossible :                                                          \
                                                                                    \
     ((((F)->FileLock != NULL) && FsRtlAreThereCurrentFileLocks( (F)->FileLock )) ? \
                                                                                    \
        FastIoIsQuestionable :                                                      \
                                                                                    \
        FastIoIsPossible))                                                          \
)

Definition at line 2015 of file cdprocs.h.

CdIsRawDevice

#define CdIsRawDevice	(		IC,
			S
	)

Value:

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

Definition at line 1466 of file cdprocs.h.

CdLockCdData

#define CdLockCdData

(

)

Value:

    ExAcquireFastMutex( &CdData.CdDataMutex );                                          \
    CdData.CdDataLockThread = PsGetCurrentThread()

Definition at line 1015 of file cdprocs.h.

CdLockFcb

#define CdLockFcb	(		IC,
			F
	)

Value:

    {                                                               \
    PVOID _CurrentThread = PsGetCurrentThread();                                        \
    if (_CurrentThread != (F)->FcbLockThread) {                                         \
        ExAcquireFastMutex( &(F)->FcbNonpaged->FcbMutex );                              \
        NT_ASSERT( (F)->FcbLockCount == 0 );                                            \
        _Analysis_assume_( (F)->FcbLockCount == 0 );                                    \
        (F)->FcbLockThread = _CurrentThread;                                            \
    }                                                                                   \
    else                                                                                \
    {                                                                                   \
        _Analysis_assume_lock_held_( (F)->FcbNonpaged->FcbMutex );                      \
        _Analysis_assume_(FALSE != DummySaveIrql(&(F)->FcbNonpaged->FcbMutex));   \
    }                                                                                   \
    (F)->FcbLockCount += 1;                                                             \
}

Definition at line 1044 of file cdprocs.h.

CdLockUserBuffer

#define CdLockUserBuffer	(		IC,
			BL,
			OP
	)

Value:

    {                        \
    if ((IC)->Irp->MdlAddress == NULL) {                    \
        (VOID) CdCreateUserMdl( (IC), (BL), TRUE, (OP) );   \
    }                                                       \
}

Definition at line 393 of file cdprocs.h.

CdLockVcb

#define CdLockVcb	(		IC,
			V
	)

Value:

    ExAcquireFastMutex( &(V)->VcbMutex );                                               \
    NT_ASSERT( NULL == (V)->VcbLockThread);                                             \
    (V)->VcbLockThread = PsGetCurrentThread()

Definition at line 1023 of file cdprocs.h.

CdLookupInitialFileDirent

#define CdLookupInitialFileDirent	(		IC,
			F,
			FC,
			DO
	)

Value:

    CdLookupDirent( IC,                                             \
                    F,                                              \
                    DO,                                             \
                    &(FC)->InitialDirent->DirContext );             \
    CdUpdateDirentFromRawDirent( IC,                                \
                                 F,                                 \
                                 &(FC)->InitialDirent->DirContext,  \
                                 &(FC)->InitialDirent->Dirent )

Definition at line 551 of file cdprocs.h.

CdMapUserBuffer

#define CdMapUserBuffer	(		IC,
			UB
	)

Value:

            {                                               \
            *(UB) = (PVOID) ( ((IC)->Irp->MdlAddress == NULL) ?                 \
                    (IC)->Irp->UserBuffer :                                     \
                    (MmGetSystemAddressForMdlSafe( (IC)->Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute)));   \
            if (NULL == *(UB))  {                         \
                CdRaiseStatus( (IC), STATUS_INSUFFICIENT_RESOURCES);            \
            }                                                                   \
        }

Definition at line 383 of file cdprocs.h.

CdMarkRealDevForVerify

#define CdMarkRealDevForVerify

(

DO

)

SetFlag( (DO)->Flags, DO_VERIFY_VOLUME)

Definition at line 1451 of file cdprocs.h.

CdMarkRealDevVerifyOk

#define CdMarkRealDevVerifyOk

(

DO

)

ClearFlag( (DO)->Flags, DO_VERIFY_VOLUME)

Definition at line 1453 of file cdprocs.h.

CdNonPagedPool

#define CdNonPagedPool   NonPagedPoolNx

Definition at line 1381 of file cdprocs.h.

CdNonPagedPoolCacheAligned

#define CdNonPagedPoolCacheAligned   NonPagedPoolNxCacheAligned

Definition at line 1382 of file cdprocs.h.

CdNormalizeAndRaiseStatus

#define CdNormalizeAndRaiseStatus	(		IC,
			S
	)		CdRaiseStatusEx( (IC), (S), TRUE, BugCheckFileId, __LINE__);

Definition at line 1860 of file cdprocs.h.

CdPagedPool

#define CdPagedPool   PagedPool

Definition at line 1380 of file cdprocs.h.

CdRaiseStatus

#define CdRaiseStatus	(		IC,
			S
	)		CdRaiseStatusEx( (IC), (S), FALSE, BugCheckFileId, __LINE__);

Definition at line 1859 of file cdprocs.h.

CdRealDevNeedsVerify

#define CdRealDevNeedsVerify

(

DO

)

BooleanFlagOn( (DO)->Flags, DO_VERIFY_VOLUME)

Definition at line 1456 of file cdprocs.h.

CdReleaseAllFiles

#define CdReleaseAllFiles	(		IC,
			V
	)		ExReleaseResourceLite( &(V)->FileResource )

Definition at line 991 of file cdprocs.h.

CdReleaseCache

#define CdReleaseCache

(

IC

)

ExReleaseResourceLite( &(IC)->Vcb->SectorCacheResource);

Definition at line 967 of file cdprocs.h.

CdReleaseCdData

#define CdReleaseCdData

(

IC

)

ExReleaseResourceLite( &CdData.DataResource )

Definition at line 976 of file cdprocs.h.

CdReleaseFcb

#define CdReleaseFcb	(		IC,
			F
	)		ExReleaseResourceLite( &(F)->FcbNonpaged->FcbResource )

Definition at line 1012 of file cdprocs.h.

CdReleaseFile

#define CdReleaseFile	(		IC,
			F
	)		ExReleaseResourceLite( (F)->Resource )

Definition at line 1003 of file cdprocs.h.

CdReleaseVcb

#define CdReleaseVcb	(		IC,
			V
	)		ExReleaseResourceLite( &(V)->VcbResource )

Definition at line 985 of file cdprocs.h.

CdRestoreThreadContext

#define CdRestoreThreadContext

(

IC

)

Value:

    (IC)->ThreadContext->Cdfs = 0;                              \
    IoSetTopLevelIrp( (IC)->ThreadContext->SavedTopLevelIrp );  \
    (IC)->ThreadContext = NULL

Definition at line 1983 of file cdprocs.h.

CdTelemetryMountSafe

#define CdTelemetryMountSafe

(

...

)

NOTHING

Definition at line 2312 of file cdprocs.h.

CdUnlockCdData

#define CdUnlockCdData

(

)

Value:

    CdData.CdDataLockThread = NULL;                                                     \
    ExReleaseFastMutex( &CdData.CdDataMutex )

Definition at line 1019 of file cdprocs.h.

CdUnlockFcb

#define CdUnlockFcb	(		IC,
			F
	)

Value:

    {                                                             \
    (F)->FcbLockCount -= 1;                                                             \
    if ((F)->FcbLockCount == 0) {                                                       \
        (F)->FcbLockThread = NULL;                                                      \
        ExReleaseFastMutex( &(F)->FcbNonpaged->FcbMutex );                              \
    }                                                                                   \
    else                                                                                \
    {                                                                                   \
        _Analysis_assume_lock_not_held_( (F)->FcbNonpaged->FcbMutex );                  \
        _Analysis_assume_(FALSE != DummyRestoreIrql(&(F)->FcbNonpaged->FcbMutex)); \
    }                                                                                   \
}

Definition at line 1060 of file cdprocs.h.

CdUnlockVcb

#define CdUnlockVcb	(		IC,
			V
	)

Value:

    NT_ASSERT( NULL != (V)->VcbLockThread);                                             \
    (V)->VcbLockThread = NULL;                                                          \
    ExReleaseFastMutex( &(V)->VcbMutex )

Definition at line 1028 of file cdprocs.h.

CdUnpinData

#define CdUnpinData	(		IC,
			B
	)		if (*(B) != NULL) { CcUnpinData( *(B) ); *(B) = NULL; }

Definition at line 269 of file cdprocs.h.

CdUpdateMediaChangeCount

#define CdUpdateMediaChangeCount	(		V,
			C
	)		(V)->MediaChangeCount = (C)

Definition at line 1448 of file cdprocs.h.

CdUpdateVcbCondition

#define CdUpdateVcbCondition	(		V,
			C
	)		(V)->VcbCondition = (C)

Definition at line 1449 of file cdprocs.h.

CopyUchar1

#define CopyUchar1	(		Dst,
			Src
	)

Value:

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

Definition at line 1685 of file cdprocs.h.

CopyUchar2

#define CopyUchar2	(		Dst,
			Src
	)

Value:

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

Definition at line 1693 of file cdprocs.h.

CopyUchar4

#define CopyUchar4	(		Dst,
			Src
	)

Value:

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

Definition at line 1701 of file cdprocs.h.

CopyUshort2

#define CopyUshort2	(		Dst,
			Src
	)

Value:

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

Definition at line 1710 of file cdprocs.h.

INLINE

#define INLINE   __inline

Definition at line 38 of file cdprocs.h.

LlBlockAlign

#define LlBlockAlign	(		V,
			L
	)

Value:

    (                                                     \
    ((LONGLONG)(L) + (V)->BlockMask) & (LONGLONG)((LONG)(V)->BlockInverseMask)  \
)

Definition at line 1646 of file cdprocs.h.

LlBytesFromBlocks

#define LlBytesFromBlocks	(		V,
			B
	)

Value:

    (                                        \
    Int64ShllMod32( (LONGLONG) (B), (V)->BlockToByteShift )             \
)

Definition at line 1634 of file cdprocs.h.

LlBytesFromSectors

#define LlBytesFromSectors

(

L

)

Value:

    (                                         \
    Int64ShllMod32( (LONGLONG)(L), SECTOR_SHIFT )                       \
)

Definition at line 1614 of file cdprocs.h.

LlSectorAlign

#define LlSectorAlign

(

L

)

Value:

    (                                              \
    ((((LONGLONG)(L)) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1))        \
)

Definition at line 1584 of file cdprocs.h.

LlSectorsFromBytes

#define LlSectorsFromBytes

(

L

)

Value:

    (                                         \
    Int64ShraMod32( (LONGLONG)(L), SECTOR_SHIFT )                       \
)

Definition at line 1618 of file cdprocs.h.

LlSectorTruncate

#define LlSectorTruncate

(

L

)

Value:

    (                                           \
    ((LONGLONG)(L)) & ~(SECTOR_SIZE - 1)                                \
)

Definition at line 1592 of file cdprocs.h.

LongAlign

#define LongAlign

(

Ptr

)

Value:

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

Definition at line 1563 of file cdprocs.h.

Max

#define Max	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 78 of file cdprocs.h.

Min

#define Min	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 74 of file cdprocs.h.

PtrOffset

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

Definition at line 1547 of file cdprocs.h.

QuadAlign

#define QuadAlign

(

Ptr

)

Value:

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

Definition at line 1572 of file cdprocs.h.

RawSectorAlign

#define RawSectorAlign

(

B

)

((((B)+(RAW_SECTOR_SIZE - 1)) / RAW_SECTOR_SIZE) * RAW_SECTOR_SIZE)

Definition at line 1654 of file cdprocs.h.

SectorAlign

#define SectorAlign

(

L

)

Value:

    (                                                \
    ((((ULONG)(L)) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1))           \
)

Definition at line 1580 of file cdprocs.h.

SectorBlockOffset

#define SectorBlockOffset	(		V,
			LB
	)

Value:

    (                                       \
    ((ULONG) (LB)) & ((V)->BlocksPerSector - 1)                         \
)

Definition at line 1626 of file cdprocs.h.

SectorOffset

#define SectorOffset

(

L

)

Value:

    (                                               \
    ((ULONG)(ULONG_PTR) (L)) & SECTOR_MASK                              \
)

Definition at line 1622 of file cdprocs.h.

SectorsFromBytes

#define SectorsFromBytes

(

L

)

Value:

    (                                           \
    ((ULONG) (L)) >> SECTOR_SHIFT                                       \
)

Definition at line 1600 of file cdprocs.h.

SectorTruncate

#define SectorTruncate

(

L

)

Value:

    (                                             \
    ((ULONG)(L)) & ~(SECTOR_SIZE - 1)                                   \
)

Definition at line 1588 of file cdprocs.h.

SwapCopyUchar4

#define SwapCopyUchar4	(		Dst,
			Src
	)

Value:

    {                                        \
    *((UNALIGNED UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src) + 3);     \
    *((UNALIGNED UCHAR1 *)(Dst) + 1) = *((UNALIGNED UCHAR1 *)(Src) + 2); \
    *((UNALIGNED UCHAR1 *)(Dst) + 2) = *((UNALIGNED UCHAR1 *)(Src) + 1); \
    *((UNALIGNED UCHAR1 *)(Dst) + 3) = *((UNALIGNED UCHAR1 *)(Src));     \
}

Definition at line 1719 of file cdprocs.h.

TAG_CCB

#define TAG_CCB   'ccdC'

Definition at line 85 of file cdprocs.h.

TAG_CDROM_TOC

#define TAG_CDROM_TOC   'ctdC'

Definition at line 86 of file cdprocs.h.

TAG_DIRENT_NAME

#define TAG_DIRENT_NAME   'nddC'

Definition at line 87 of file cdprocs.h.

TAG_ENUM_EXPRESSION

#define TAG_ENUM_EXPRESSION   'eedC'

Definition at line 88 of file cdprocs.h.

TAG_FCB_DATA

#define TAG_FCB_DATA   'dfdC'

Definition at line 89 of file cdprocs.h.

TAG_FCB_INDEX

#define TAG_FCB_INDEX   'ifdC'

Definition at line 90 of file cdprocs.h.

TAG_FCB_NONPAGED

#define TAG_FCB_NONPAGED   'nfdC'

Definition at line 91 of file cdprocs.h.

TAG_FCB_TABLE

#define TAG_FCB_TABLE   'tfdC'

Definition at line 92 of file cdprocs.h.

TAG_FILE_NAME

#define TAG_FILE_NAME   'nFdC'

Definition at line 93 of file cdprocs.h.

TAG_GEN_SHORT_NAME

#define TAG_GEN_SHORT_NAME   'sgdC'

Definition at line 94 of file cdprocs.h.

TAG_IO_BUFFER

#define TAG_IO_BUFFER   'fbdC'

Definition at line 95 of file cdprocs.h.

TAG_IO_CONTEXT

#define TAG_IO_CONTEXT   'oidC'

Definition at line 96 of file cdprocs.h.

TAG_IRP_CONTEXT

#define TAG_IRP_CONTEXT   'cidC'

Definition at line 97 of file cdprocs.h.

TAG_IRP_CONTEXT_LITE

#define TAG_IRP_CONTEXT_LITE   'lidC'

Definition at line 98 of file cdprocs.h.

TAG_MCB_ARRAY

#define TAG_MCB_ARRAY   'amdC'

Definition at line 99 of file cdprocs.h.

TAG_PATH_ENTRY_NAME

#define TAG_PATH_ENTRY_NAME   'nPdC'

Definition at line 100 of file cdprocs.h.

TAG_PREFIX_ENTRY

#define TAG_PREFIX_ENTRY   'epdC'

Definition at line 101 of file cdprocs.h.

TAG_PREFIX_NAME

#define TAG_PREFIX_NAME   'npdC'

Definition at line 102 of file cdprocs.h.

TAG_SPANNING_PATH_TABLE

#define TAG_SPANNING_PATH_TABLE   'psdC'

Definition at line 103 of file cdprocs.h.

TAG_UPCASE_NAME

#define TAG_UPCASE_NAME   'nudC'

Definition at line 104 of file cdprocs.h.

TAG_VOL_DESC

#define TAG_VOL_DESC   'dvdC'

Definition at line 105 of file cdprocs.h.

TAG_VPB

#define TAG_VPB   'pvdC'

Definition at line 106 of file cdprocs.h.

try_leave

#define try_leave

(

S

)

{ S; leave; }

Definition at line 2180 of file cdprocs.h.

try_return

#define try_return

(

S

)

{ S; goto try_exit; }

Definition at line 2179 of file cdprocs.h.

WordAlign

#define WordAlign

(

Ptr

)

Value:

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

Definition at line 1554 of file cdprocs.h.

Typedef Documentation

PTYPE_OF_ACQUIRE

typedef enum _TYPE_OF_ACQUIRE * PTYPE_OF_ACQUIRE

PTYPE_OF_OPEN

typedef TYPE_OF_OPEN* PTYPE_OF_OPEN

Definition at line 581 of file cdprocs.h.

PUCHAR1

typedef union _UCHAR1 * PUCHAR1

PUCHAR2

typedef union _UCHAR2 * PUCHAR2

PUCHAR4

typedef union _UCHAR4 * PUCHAR4

PUSHORT2

typedef union _USHORT2 * PUSHORT2

TYPE_OF_ACQUIRE

typedef enum _TYPE_OF_ACQUIRE TYPE_OF_ACQUIRE

TYPE_OF_OPEN

typedef enum _TYPE_OF_OPEN TYPE_OF_OPEN

UCHAR1

typedef union _UCHAR1 UCHAR1

UCHAR2

typedef union _UCHAR2 UCHAR2

UCHAR4

typedef union _UCHAR4 UCHAR4

USHORT2

typedef union _USHORT2 USHORT2

Enumeration Type Documentation

_TYPE_OF_ACQUIRE

enum _TYPE_OF_ACQUIRE

Enumerator
AcquireExclusive
AcquireShared
AcquireSharedStarveExclusive

Definition at line 827 of file cdprocs.h.

                              {
 
    AcquireExclusive,
    AcquireShared,
    AcquireSharedStarveExclusive
 
} TYPE_OF_ACQUIRE, *PTYPE_OF_ACQUIRE;

_TYPE_OF_OPEN

enum _TYPE_OF_OPEN

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

Definition at line 571 of file cdprocs.h.

                           {
 
    UnopenedFileObject = 0,
    StreamFileOpen,
    UserVolumeOpen,
    UserDirectoryOpen,
    UserFileOpen,
    BeyondValidType
 
} TYPE_OF_OPEN;

Function Documentation

_At_() [1/6]

_At_	(	Dirent->	CdTime,
		_Post_notnull_
	)

_At_() [2/6]

_At_	(	Fcb	,
		_In_
	)

_At_() [3/6]

_At_	(	Fcb	,
		_Outptr_
	)

_At_() [4/6]

_At_	(	Fcb->	NodeByteSize,
		_In_range_(>=, FIELD_OFFSET(FCB, FcbType))
	)

_At_() [5/6]

_At_	(	FileContext->ShortName.FileName.	MaximumLength,
		_In_range_(>=, BYTE_COUNT_8_DOT_3)
	)

_At_() [6/6]

_At_	(	IrpContext	,
		_Pre_notnull_
	)

_CdFreePool()

static INLINE VOID _CdFreePool ( _Inout_ _At_(*, Mem  _Post_null_ )

static

Definition at line 2195 of file cdprocs.h.

{
    if (*Pool != NULL) {
 
        ExFreePool(*Pool);
        *Pool = NULL;
    }
}

_Function_class_()

_Function_class_

(

FAST_IO_RELEASE_FILE

)

Definition at line 366 of file resrcsup.c.

{
    PAGED_CODE();
 
    //
    //  Release the resources.
    //
 
    ExReleaseResourceLite( &((PFCB) FileObject->FsContext)->FcbNonpaged->FcbResource );
    ExReleaseResourceLite( ((PFCB) FileObject->FsContext)->Resource);
}

_Inout_updates_bytes_()

_Inout_updates_bytes_

(

Fcb->

NodeByteSize

)

Definition at line 631 of file allocsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
 
    //
    //  Set the entry counts to show there is one entry in the array and
    //  it is unused.
    //
 
    Fcb->Mcb.MaximumEntryCount = 1;
    Fcb->Mcb.CurrentEntryCount = 0;
 
    Fcb->Mcb.McbArray = &Fcb->McbEntry;
 
    return;
}

_IRQL_requires_max_()

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 37 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;
 
#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif
 
    NTSTATUS Status;
 
#if DBG
 
    KIRQL SaveIrql = KeGetCurrentIrql();
 
#endif
 
    ASSERT_OPTIONAL_IRP( Irp );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif
 
    //
    //  Loop until this request has been completed or posted.
    //
 
    do {
 
        //
        //  Use a try-except to handle the exception cases.
        //
 
        _SEH2_TRY {
 
            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //
 
            if (IrpContext == NULL) {
 
                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //
 
                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
 
                    Wait = TRUE;
 
                } else {
 
                    Wait = CanFsdWait( Irp );
                }
 
                IrpContext = CdCreateIrpContext( Irp, Wait );
 
                //
                //  Update the thread context information.
                //
 
                CdSetThreadContext( IrpContext, &ThreadContext );
 
#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
 
            //
            //  Otherwise cleanup the IrpContext for the retry.
            //
 
            } else {
 
                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }
 
            //
            //  Case on the major irp code.
            //
 
            switch (IrpContext->MajorFunction) {
 
            case IRP_MJ_CREATE :
 
                Status = CdCommonCreate( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLOSE :
 
                Status = CdCommonClose( IrpContext, Irp );
                break;
 
            case IRP_MJ_READ :
 
                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //
 
                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
 
                    Status = CdCompleteMdl( IrpContext, Irp );
 
                } else {
 
                    Status = CdCommonRead( IrpContext, Irp );
                }
 
                break;
 
            case IRP_MJ_WRITE :
 
                Status = CdCommonWrite( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_INFORMATION :
 
                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_SET_INFORMATION :
 
                Status = CdCommonSetInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_VOLUME_INFORMATION :
 
                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_DIRECTORY_CONTROL :
 
                Status = CdCommonDirControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_FILE_SYSTEM_CONTROL :
 
                Status = CdCommonFsControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_DEVICE_CONTROL :
 
                Status = CdCommonDevControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_LOCK_CONTROL :
 
                Status = CdCommonLockControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLEANUP :
 
                Status = CdCommonCleanup( IrpContext, Irp );
                break;
 
            case IRP_MJ_PNP :
 
                Status = CdCommonPnp( IrpContext, Irp );
                break;
 
            case IRP_MJ_SHUTDOWN :
 
                Status = CdCommonShutdown( IrpContext, Irp );
                break;
 
            default :
 
                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }
 
        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;
 
    } while (Status == STATUS_CANT_WAIT);
 
#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
 
    FsRtlExitFileSystem();
 
    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
 
    return Status;
}

_Post_satisfies_()

_Post_satisfies_

(

_Old_(CdName->FileName.Length) >=CdName->FileName.Length+CdName->VersionString.

Length

)

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

_Success_()

_Success_

(

return !

= FALSE

)

Initial value:

== REG_SZ), _At_((PSTR) PropertyBuffer, _Post_valid_))
_When_((*PropertyRegDataType == REG_MULTI_SZ), _At_((PZZSTR) PropertyBuffer, _Post_valid_))
WINSETUPAPI
BOOL
WINAPI
SetupDiGetDeviceRegistryPropertyA(
  _In_ HDEVINFO DeviceInfoSet,
  _In_ PSP_DEVINFO_DATA DeviceInfoData,
  _In_ DWORD Property,
  _Out_opt_ PDWORD PropertyRegDataType,
  _Out_writes_bytes_to_opt_(PropertyBufferSize, *RequiredSize) PBYTE PropertyBuffer,
  _In_ DWORD PropertyBufferSize,
  _Out_opt_ PDWORD RequiredSize)

Definition at line 3139 of file fsctrl.c.

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

_When_() [1/6]

_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _When_	(	IgnoreWait	= = FALSE,
		_Post_satisfies_(return==TRUE)
	)

_When_() [2/6]

_When_	(	RaiseOnError||	return,
		_At_(Fcb->FileLock, _Post_notnull_)
	)

_When_() [3/6]

_At_ Ccb _When_	(	return !	= UnopenedFileObject,
		_At_(Ccb, _Outptr_)
	)

_When_() [4/6]

_When_	(	return	= = UnopenedFileObject,
		_At_ *,	_Post_null_
	)

_When_() [5/6]

_Acquires_exclusive_lock_ Resource _When_	(	Type	= = AcquireShared && return != FALSE,
		_Acquires_shared_lock_ *	Resource
	)

_When_() [6/6]

_When_	(	TypeOfOpen	= = UnopenedFileObject,
		_At_(Fcb, _In_opt_)
	)

CdAcquireForCache()

_Acquires_shared_lock_ Fcb BOOLEAN NTAPI CdAcquireForCache	(	_Inout_ PFCB	Fcb,
		_In_ BOOLEAN	Wait
	)

Referenced by CdInitializeGlobalData().

CdAddAllocationFromDirent()

VOID CdAddAllocationFromDirent	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ ULONG	McbEntryOffset,
		_In_ LONGLONG	StartingFileOffset,
		_In_ PDIRENT	Dirent
	)

Definition at line 335 of file allocsup.c.

{
    ULONG NewArraySize;
    PVOID NewMcbArray;
    PCD_MCB_ENTRY McbEntry;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
    ASSERT_LOCKED_FCB( Fcb );
 
    //
    //  If we need to grow the Mcb then do it now.
    //
 
    if (McbEntryOffset >= Fcb->Mcb.MaximumEntryCount) {
 
        //
        //  Allocate a new buffer and copy the old data over.
        //
 
        NewArraySize = Fcb->Mcb.MaximumEntryCount * 2 * sizeof( CD_MCB_ENTRY );
 
        NewMcbArray = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                NewArraySize,
                                                TAG_MCB_ARRAY );
 
        RtlZeroMemory( NewMcbArray, NewArraySize );
        RtlCopyMemory( NewMcbArray,
                       Fcb->Mcb.McbArray,
                       Fcb->Mcb.MaximumEntryCount * sizeof( CD_MCB_ENTRY ));
 
        //
        //  Deallocate the current array unless it is embedded in the Fcb.
        //
 
        if (Fcb->Mcb.MaximumEntryCount != 1) {
 
            CdFreePool( &Fcb->Mcb.McbArray );
        }
 
        //
        //  Now update the Mcb with the new array.
        //
 
        Fcb->Mcb.MaximumEntryCount *= 2;
        Fcb->Mcb.McbArray = NewMcbArray;
    }
 
    //
    //  Update the new entry with the input data.
    //
 
    McbEntry = Fcb->Mcb.McbArray + McbEntryOffset;
 
    //
    //  Start with the location and length on disk.
    //
 
    McbEntry->DiskOffset = LlBytesFromBlocks( Fcb->Vcb, Dirent->StartingOffset );
    McbEntry->ByteCount = Dirent->DataLength;
 
    //
    //  Round the byte count up to a logical block boundary if this is
    //  the last extent.
    //
 
    if (!FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_MULTI )) {
 
        McbEntry->ByteCount = BlockAlign( Fcb->Vcb, McbEntry->ByteCount );
    }
 
    //
    //  The file offset is the logical position within this file.
    //  We know this is correct regardless of whether we bias the
    //  file size or disk offset.
    //
 
    McbEntry->FileOffset = StartingFileOffset;
 
    //
    //  Convert the interleave information from logical blocks to
    //  bytes.
    //
 
    if (Dirent->FileUnitSize != 0) {
 
        McbEntry->DataBlockByteCount = LlBytesFromBlocks( Fcb->Vcb, Dirent->FileUnitSize );
        McbEntry->TotalBlockByteCount = McbEntry->DataBlockByteCount +
                                        LlBytesFromBlocks( Fcb->Vcb, Dirent->InterleaveGapSize );
 
    //
    //  If the file is not interleaved then the size of the data block
    //  and total block are the same as the byte count.
    //
 
    } else {
 
        McbEntry->DataBlockByteCount =
        McbEntry->TotalBlockByteCount = McbEntry->ByteCount;
    }
 
    //
    //  Update the number of entries in the Mcb.  The Mcb is never sparse
    //  so whenever we add an entry it becomes the last entry in the Mcb.
    //
 
    Fcb->Mcb.CurrentEntryCount = McbEntryOffset + 1;
 
    return;
}

Referenced by _Requires_lock_held_(), and CdInitializeFcbFromFileContext().

CdAddInitialAllocation()

VOID CdAddInitialAllocation	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ ULONG	StartingBlock,
		_In_ LONGLONG	DataLength
	)

Definition at line 484 of file allocsup.c.

{
    PCD_MCB_ENTRY McbEntry;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
    ASSERT_LOCKED_FCB( Fcb );
    NT_ASSERT( 0 == Fcb->Mcb.CurrentEntryCount);
    NT_ASSERT( CDFS_NTC_FCB_DATA != Fcb->NodeTypeCode);
 
    //
    //  Update the new entry with the input data.
    //
 
    McbEntry = Fcb->Mcb.McbArray;
 
    //
    //  Start with the location and length on disk.
    //
 
    McbEntry->DiskOffset = LlBytesFromBlocks( Fcb->Vcb, StartingBlock );
    McbEntry->DiskOffset -= Fcb->StreamOffset;
 
    McbEntry->ByteCount = DataLength;
 
    //
    //  The file offset is the logical position within this file.
    //  We know this is correct regardless of whether we bias the
    //  file size or disk offset.
    //
 
    McbEntry->FileOffset = 0;
 
    //
    //  If the file is not interleaved then the size of the data block
    //  and total block are the same as the byte count.
    //
 
    McbEntry->DataBlockByteCount =
    McbEntry->TotalBlockByteCount = McbEntry->ByteCount;
 
    //
    //  Update the number of entries in the Mcb.  The Mcb is never sparse
    //  so whenever we add an entry it becomes the last entry in the Mcb.
    //
 
    Fcb->Mcb.CurrentEntryCount = 1;
 
    return;
}

Referenced by CdCreateInternalStream(), CdInitializeFcbFromPathEntry(), and CdUpdateVcbFromVolDescriptor().

CdCleanupFileContext()

VOID CdCleanupFileContext	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFILE_ENUM_CONTEXT	FileContext
	)

Definition at line 1636 of file dirsup.c.

{
    PCOMPOUND_DIRENT CurrentCompoundDirent;
    ULONG Count = 2;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Cleanup the individual compound dirents.
    //
 
    do {
 
        CurrentCompoundDirent = &FileContext->Dirents[ Count ];
        CdCleanupDirContext( IrpContext, &CurrentCompoundDirent->DirContext );
        CdCleanupDirent( IrpContext, &CurrentCompoundDirent->Dirent );
 
    } while (Count--);
 
    return;
}

Referenced by _Requires_lock_held_(), and CdInitializeEnumeration().

CdCleanupIrpContext()

VOID CdCleanupIrpContext	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ BOOLEAN	Post
	)

Definition at line 1733 of file strucsup.c.

{
    PAGED_CODE();
 
    //
    //  If we aren't doing more processing then deallocate this as appropriate.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING)) {
 
        //
        //  If this context is the top level CDFS context then we need to
        //  restore the top level thread context.
        //
 
        if (IrpContext->ThreadContext != NULL) {
 
            CdRestoreThreadContext( IrpContext );
        }
 
        //
        //  Deallocate the Io context if allocated.
        //
 
        if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO )) {
 
            CdFreeIoContext( IrpContext->IoContext );
        }
 
        //
        //  Deallocate the IrpContext if not from the stack.
        //
 
        if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ON_STACK )) {
 
            if (CdData.IrpContextDepth < CdData.IrpContextMaxDepth) {
 
                CdLockCdData();
 
                PushEntryList( &CdData.IrpContextList, (PSINGLE_LIST_ENTRY) IrpContext );
                CdData.IrpContextDepth++;
 
                CdUnlockCdData();
 
            } else {
 
                //
                //  We couldn't add this to our lookaside list so free it to
                //  pool.
                //
 
                CdFreePool( &IrpContext );
            }
        }
 
    //
    //  Clear the appropriate flags.
    //
 
    } else if (Post) {
 
        //
        //  If this context is the top level CDFS context then we need to
        //  restore the top level thread context.
        //
 
        if (IrpContext->ThreadContext != NULL) {
 
            CdRestoreThreadContext( IrpContext );
        }
 
        ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAGS_CLEAR_ON_POST );
 
    } else {
 
        ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAGS_CLEAR_ON_RETRY );
    }
 
    return;
}

Referenced by _IRQL_requires_max_(), CdCompleteRequest(), CdFspDispatch(), and CdQueueClose().

CdCommonDevControl()

NTSTATUS CdCommonDevControl	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 46 of file devctrl.c.

{
    NTSTATUS Status;
 
    TYPE_OF_OPEN TypeOfOpen;
    PFCB Fcb;
    PCCB Ccb;
 
    PIO_STACK_LOCATION IrpSp;
    PIO_STACK_LOCATION NextIrpSp;
 
    PAGED_CODE();
 
    //
    //  Extract and decode the file object.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    TypeOfOpen = CdDecodeFileObject( IrpContext,
                                     IrpSp->FileObject,
                                     &Fcb,
                                     &Ccb );
 
    //
    //  The only type of opens we accept are user volume opens.
    //
 
    if (TypeOfOpen != UserVolumeOpen) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_READ_TOC) {
 
        //
        //  Verify the Vcb in this case to detect if the volume has changed.
        //
 
        CdVerifyVcb( IrpContext, Fcb->Vcb );
 
    //
    //  Handle the case of the disk type ourselves.
    //
 
    } else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_DISK_TYPE) {
 
        //
        //  Verify the Vcb in this case to detect if the volume has changed.
        //
 
        CdVerifyVcb( IrpContext, Fcb->Vcb );
 
        //
        //  Check the size of the output buffer.
        //
 
        if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof( CDROM_DISK_DATA )) {
 
            CdCompleteRequest( IrpContext, Irp, STATUS_BUFFER_TOO_SMALL );
            return STATUS_BUFFER_TOO_SMALL;
        }
 
        //
        //  Copy the data from the Vcb.
        //
 
        ((PCDROM_DISK_DATA) Irp->AssociatedIrp.SystemBuffer)->DiskData = Fcb->Vcb->DiskFlags;
 
        Irp->IoStatus.Information = sizeof( CDROM_DISK_DATA );
        CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
        return STATUS_SUCCESS;
    }
 
    //
    //  Get the next stack location, and copy over the stack parameter
    //  information.
    //
 
    NextIrpSp = IoGetNextIrpStackLocation( Irp );
 
    *NextIrpSp = *IrpSp;
 
    //
    //  Set up the completion routine
    //
 
    IoSetCompletionRoutine( Irp,
                            CdDevCtrlCompletionRoutine,
                            NULL,
                            TRUE,
                            TRUE,
                            TRUE );
 
    //
    //  Send the request.
    //
 
    Status = IoCallDriver( IrpContext->Vcb->TargetDeviceObject, Irp );
 
    //
    //  Cleanup our Irp Context.  The driver has completed the Irp.
    //
 
    CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
 
    return Status;
}

Referenced by _IRQL_requires_max_(), and CdFspDispatch().

CdCommonLockControl()

NTSTATUS CdCommonLockControl	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 35 of file lockctrl.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    TYPE_OF_OPEN TypeOfOpen;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    //
    //  Extract and decode the type of file object we're being asked to process
    //
 
    TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
 
    //
    //  If the file is not a user file open then we reject the request
    //  as an invalid parameter
    //
 
    if (TypeOfOpen != UserFileOpen) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    //  We check whether we can proceed based on the state of the file oplocks.
    //  This call might post the irp for us.
    //
 
    Status = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
                               Irp,
                               IrpContext,
                               (PVOID)CdOplockComplete,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
                               NULL );
 
    //
    //  If we don't get success then the oplock package completed the request.
    //
 
    if (Status != STATUS_SUCCESS) {
 
        return Status;
    }
 
    //
    //  Verify the Fcb.
    //
 
    CdVerifyFcbOperation( IrpContext, Fcb );
 
    //
    //  If we don't have a file lock, then get one now.
    //
 
    if (Fcb->FileLock == NULL) { CdCreateFileLock( IrpContext, Fcb, TRUE ); }
 
    //
    //  Now call the FsRtl routine to do the actual processing of the
    //  Lock request
    //
 
    Status = FsRtlProcessFileLock( Fcb->FileLock, Irp, NULL );
 
    //
    //  Set the flag indicating if Fast I/O is possible
    //
 
    CdLockFcb( IrpContext, Fcb );
    Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
    CdUnlockFcb( IrpContext, Fcb );
 
    //
    //  Complete the request.
    //
 
    CdCompleteRequest( IrpContext, NULL, Status );
    return Status;
}

Referenced by _IRQL_requires_max_(), and CdFspDispatch().

CdCompleteMdl()

NTSTATUS CdCompleteMdl	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp
	)

Definition at line 411 of file cachesup.c.

{
    PFILE_OBJECT FileObject;
 
    PAGED_CODE();
 
    //
    // Do completion processing.
    //
 
    FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
 
    CcMdlReadComplete( FileObject, Irp->MdlAddress );
 
    //
    // Mdl is now deallocated.
    //
 
    Irp->MdlAddress = NULL;
 
    //
    // Complete the request and exit right away.
    //
 
    CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
 
    return STATUS_SUCCESS;
}

Referenced by _IRQL_requires_max_().

CdCompleteRequest()

VOID CdCompleteRequest	(	_Inout_opt_ PIRP_CONTEXT	IrpContext,
		_Inout_opt_ PIRP	Irp,
		_In_ NTSTATUS	Status
	)

Definition at line 914 of file cddata.c.

{
    ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
    ASSERT_OPTIONAL_IRP( Irp );
 
    //
    //  Cleanup the IrpContext if passed in here.
    //
 
    if (ARGUMENT_PRESENT( IrpContext )) {
 
        CdCleanupIrpContext( IrpContext, FALSE );
    }
 
    //
    //  If we have an Irp then complete the irp.
    //
 
    if (ARGUMENT_PRESENT( Irp )) {
 
        //
        //  Clear the information field in case we have used this Irp
        //  internally.
        //
 
        if (NT_ERROR( Status ) &&
            FlagOn( Irp->Flags, IRP_INPUT_OPERATION )) {
 
            Irp->IoStatus.Information = 0;
        }
 
        Irp->IoStatus.Status = Status;
 
        AssertVerifyDeviceIrp( Irp );
 
        IoCompleteRequest( Irp, IO_CD_ROM_INCREMENT );
    }
 
    return;
}

Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), _Success_(), CdAllowExtendedDasdIo(), CdCommonDevControl(), CdCommonLockControl(), CdCompleteMdl(), CdFspDispatch(), CdIsPathnameValid(), CdIsVolumeDirty(), CdIsVolumeMounted(), and CdQueueClose().

CdConvertBigToLittleEndian()

VOID CdConvertBigToLittleEndian	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_reads_bytes_(ByteCount) PCHAR	BigEndian,
		_In_ ULONG	ByteCount,
		_Out_writes_bytes_(ByteCount) PCHAR	LittleEndian
	)

Definition at line 110 of file namesup.c.

{
    ULONG RemainingByteCount = ByteCount;
 
    PCHAR Source = BigEndian;
    PCHAR Destination = LittleEndian;
 
    PAGED_CODE();
 
    //
    //  If the byte count isn't an even number then the disk is corrupt.
    //
 
    if (FlagOn( ByteCount, 1 )) {
 
        CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
    }
 
    //
    //  Start by copy the low-order bytes into the correct position.  Do
    //  this by skipping the first byte in the BigEndian string.
    //
 
    RtlCopyMemory( Destination,
                   Source + 1,
                   RemainingByteCount - 1 );
 
    //
    //  Now move the high-order bytes into position.
    //
 
    Destination += 1;
 
    while (RemainingByteCount != 0) {
 
#ifdef _MSC_VER
#pragma prefast(push)
#pragma prefast(suppress:26014, "RemainingByteCount is even")
#endif
        *Destination = *Source;
#ifdef _MSC_VER
#pragma prefast(pop)
#endif
 
        Source += 2;
        Destination += 2;
 
        RemainingByteCount -= 2;
    }
 
    return;
}

Referenced by CdFindActiveVolDescriptor(), CdUpdateDirentName(), and CdUpdatePathEntryName().

CdCreateCcb()

PCCB CdCreateCcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ ULONG	Flags
	)

Definition at line 1405 of file strucsup.c.

{
    PCCB NewCcb;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Allocate and initialize the structure.
    //
 
    NewCcb = CdAllocateCcb( IrpContext );
 
    RtlZeroMemory( NewCcb, sizeof( CCB ));
 
    //
    //  Set the proper node type code and node byte size
    //
 
    NewCcb->NodeTypeCode = CDFS_NTC_CCB;
    NewCcb->NodeByteSize = sizeof( CCB );
 
    //
    //  Set the initial value for the flags and Fcb
    //
 
    NewCcb->Flags = Flags;
    NewCcb->Fcb = Fcb;
 
    return NewCcb;
}

CdCreateFcb()

PFCB CdCreateFcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ FILE_ID	FileId,
		_In_ NODE_TYPE_CODE	NodeTypeCode,
		_Out_opt_ PBOOLEAN	FcbExisted
	)

Definition at line 986 of file strucsup.c.

{
    PFCB NewFcb;
    BOOLEAN LocalFcbExisted;
 
    PAGED_CODE();
 
    //
    //  Use the local boolean if one was not passed in.
    //
 
    if (!ARGUMENT_PRESENT( FcbExisted )) {
 
        FcbExisted = &LocalFcbExisted;
    }
 
    //
    //  Maybe this is already in the table.
    //
 
    NewFcb = CdLookupFcbTable( IrpContext, IrpContext->Vcb, FileId );
 
    //
    //  If not then create the Fcb is requested by our caller.
    //
 
    if (NewFcb == NULL) {
 
        //
        //  Allocate and initialize the structure depending on the
        //  type code.
        //
 
        switch (NodeTypeCode) {
 
        case CDFS_NTC_FCB_PATH_TABLE:
        case CDFS_NTC_FCB_INDEX:
 
            NewFcb = CdAllocateFcbIndex( IrpContext );
 
            RtlZeroMemory( NewFcb, SIZEOF_FCB_INDEX );
 
            NewFcb->NodeByteSize = SIZEOF_FCB_INDEX;
 
            InitializeListHead( &NewFcb->FcbQueue );
 
            break;
 
        case CDFS_NTC_FCB_DATA :
 
            NewFcb = CdAllocateFcbData( IrpContext );
 
            RtlZeroMemory( NewFcb, SIZEOF_FCB_DATA );
 
            NewFcb->NodeByteSize = SIZEOF_FCB_DATA;
 
            break;
 
        default:
 
#ifdef _MSC_VER
#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "This is a bug." )
#endif
            CdBugCheck( 0, 0, 0 );
        }
 
        //
        //  Now do the common initialization.
        //
 
        NewFcb->NodeTypeCode = NodeTypeCode;
 
        NewFcb->Vcb = IrpContext->Vcb;
        NewFcb->FileId = FileId;
 
        CdInitializeMcb( IrpContext, NewFcb );
 
        //
        //  Now create the non-paged section object.
        //
 
        NewFcb->FcbNonpaged = CdCreateFcbNonpaged( IrpContext );
 
        //
        //  Deallocate the Fcb and raise if the allocation failed.
        //
 
        if (NewFcb->FcbNonpaged == NULL) {
 
            CdFreePool( &NewFcb );
 
            CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
 
        *FcbExisted = FALSE;
 
        //
        //  Initialize Advanced FCB Header fields
        //
 
        ExInitializeFastMutex( &NewFcb->FcbNonpaged->AdvancedFcbHeaderMutex );
        FsRtlSetupAdvancedHeader( &NewFcb->Header,
                                  &NewFcb->FcbNonpaged->AdvancedFcbHeaderMutex );
 
        if (NodeTypeCode == CDFS_NTC_FCB_DATA) {
 
            FsRtlInitializeOplock( CdGetFcbOplock(NewFcb) );
        }
 
    } else {
 
        *FcbExisted = TRUE;
    }
 
    return NewFcb;
}

Referenced by _Requires_lock_held_(), and CdUpdateVcbFromVolDescriptor().

CdCreateInternalStream()

VOID CdCreateInternalStream	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_Inout_ PFCB	Fcb,
		_In_ PUNICODE_STRING	Name
	)

Definition at line 38 of file cachesup.c.

{
    PFILE_OBJECT StreamFile = NULL;
    BOOLEAN DecrementReference = FALSE;
 
    BOOLEAN CleanupDirContext = FALSE;
    BOOLEAN UpdateFcbSizes = FALSE;
 
    DIRENT Dirent = {0};
    DIRENT_ENUM_CONTEXT DirContext = {0};
 
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
 
    //
    //  We may only have the Fcb shared.  Lock the Fcb and do a
    //  safe test to see if we need to really create the file object.
    //
 
    CdLockFcb( IrpContext, Fcb );
 
    if (Fcb->FileObject != NULL) {
 
        CdUnlockFcb( IrpContext, Fcb );
        return;
    }
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Create the internal stream.  The Vpb should be pointing at our volume
        //  device object at this point.
        //
 
        StreamFile = IoCreateStreamFileObjectLite( NULL, Vcb->Vpb->RealDevice );
 
        if (StreamFile == NULL) {
 
            CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
 
        //
        //  Initialize the fields of the file object.
        //
 
        StreamFile->ReadAccess = TRUE;
        StreamFile->WriteAccess = FALSE;
        StreamFile->DeleteAccess = FALSE;
 
        StreamFile->SectionObjectPointer = &Fcb->FcbNonpaged->SegmentObject;
 
        //
        //  Set the file object type and increment the Vcb counts.
        //
 
        CdSetFileObject( IrpContext,
                         StreamFile,
                         StreamFileOpen,
                         Fcb,
                         NULL );
 
        //
        //  We'll give stream file objects a name to aid IO profiling etc. We
        //  NULL this in CdDeleteInternalStream before OB deletes the file object,
        //  and before CdRemovePrefix is called (which frees Fcb names).
        //
 
        StreamFile->FileName = *Name;
 
        //
        //  We will reference the current Fcb twice to keep it from going
        //  away in the error path.  Otherwise if we dereference it
        //  below in the finally clause a close could cause the Fcb to
        //  be deallocated.
        //
 
        CdLockVcb( IrpContext, Vcb );
        CdIncrementReferenceCounts( IrpContext, Fcb, 2, 0 );
        CdUnlockVcb( IrpContext, Vcb );
        DecrementReference = TRUE;
 
        //
        //  Initialize the cache map for the file.
        //
 
        CcInitializeCacheMap( StreamFile,
                              (PCC_FILE_SIZES)&Fcb->AllocationSize,
                              TRUE,
                              &CdData.CacheManagerCallbacks,
                              Fcb );
 
        //
        //  Go ahead and store the stream file into the Fcb.
        //
 
        Fcb->FileObject = StreamFile;
        StreamFile = NULL;
 
        //
        //  If this is the first file object for a directory then we need to
        //  read the self entry for this directory and update the sizes
        //  in the Fcb.  We know that the Fcb has been initialized so
        //  that we have a least one sector available to read.
        //
 
        if (!FlagOn( Fcb->FcbState, FCB_STATE_INITIALIZED )) {
 
            ULONG NewDataLength;
 
            //
            //  Initialize the search structures.
            //
 
            CdInitializeDirContext( IrpContext, &DirContext );
            CdInitializeDirent( IrpContext, &Dirent );
            CleanupDirContext = TRUE;
 
            //
            //  Read the dirent from disk and transfer the data to the
            //  in-memory dirent.
            //
 
            CdLookupDirent( IrpContext,
                            Fcb,
                            Fcb->StreamOffset,
                            &DirContext );
 
            CdUpdateDirentFromRawDirent( IrpContext, Fcb, &DirContext, &Dirent );
 
            //
            //  Verify that this really for the self entry.  We do this by
            //  updating the name in the dirent and then checking that it matches
            //  one of the hard coded names.
            //
 
            CdUpdateDirentName( IrpContext, &Dirent, FALSE );
 
            if (Dirent.CdFileName.FileName.Buffer != CdUnicodeSelfArray) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            //
            //  If the data sizes are different then update the header
            //  and Mcb for this Fcb.
            //
 
            NewDataLength = BlockAlign( Vcb, Dirent.DataLength + Fcb->StreamOffset );
 
            if (NewDataLength == 0) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            if (NewDataLength != Fcb->FileSize.QuadPart) {
 
                Fcb->AllocationSize.QuadPart =
                Fcb->FileSize.QuadPart =
                Fcb->ValidDataLength.QuadPart = NewDataLength;
 
                CcSetFileSizes( Fcb->FileObject, (PCC_FILE_SIZES) &Fcb->AllocationSize );
 
                CdTruncateAllocation( IrpContext, Fcb, 0 );
                CdAddInitialAllocation( IrpContext,
                                        Fcb,
                                        Dirent.StartingOffset,
                                        NewDataLength );
 
                UpdateFcbSizes = TRUE;
            }
 
            //
            //  Check for the existence flag and transform to hidden.
            //
 
            if (FlagOn( Dirent.DirentFlags, CD_ATTRIBUTE_HIDDEN )) {
 
                SetFlag( Fcb->FileAttributes, FILE_ATTRIBUTE_HIDDEN );
            }
 
            //
            //  Convert the time to NT time.
            //
 
            CdConvertCdTimeToNtTime( IrpContext,
                                     Dirent.CdTime,
                                     (PLARGE_INTEGER) &Fcb->CreationTime );
 
            //
            //  Update the Fcb flags to indicate we have read the
            //  self entry.
            //
 
            SetFlag( Fcb->FcbState, FCB_STATE_INITIALIZED );
 
            //
            //  If we updated the sizes then we want to purge the file.  Go
            //  ahead and unpin and then purge the first page.
            //
 
            CdCleanupDirContext( IrpContext, &DirContext );
            CdCleanupDirent( IrpContext, &Dirent );
            CleanupDirContext = FALSE;
 
            if (UpdateFcbSizes) {
 
                CcPurgeCacheSection( &Fcb->FcbNonpaged->SegmentObject,
                                     NULL,
                                     0,
                                     FALSE );
            }
        }
 
    } _SEH2_FINALLY {
 
        //
        //  Cleanup any dirent structures we may have used.
        //
 
        if (CleanupDirContext) {
 
            CdCleanupDirContext( IrpContext, &DirContext );
            CdCleanupDirent( IrpContext, &Dirent );
        }
 
        //
        //  If we raised then we need to dereference the file object.
        //
 
        if (StreamFile != NULL) {
 
            //
            //  Null the name pointer, since the stream file object never actually
            //  'owns' the names, we just point it to existing ones.
            //
 
            StreamFile->FileName.Buffer = NULL;
            StreamFile->FileName.MaximumLength = StreamFile->FileName.Length = 0;
 
            ObDereferenceObject( StreamFile );
            Fcb->FileObject = NULL;
        }
 
        //
        //  Dereference and unlock the Fcb.
        //
 
        if (DecrementReference) {
 
            CdLockVcb( IrpContext, Vcb );
            CdDecrementReferenceCounts( IrpContext, Fcb, 1, 0 );
            CdUnlockVcb( IrpContext, Vcb );
        }
 
        CdUnlockFcb( IrpContext, Fcb );
    } _SEH2_END;
 
    return;
}

Referenced by CdUpdateVcbFromVolDescriptor(), and CdVerifyOrCreateDirStreamFile().

CdCreateIrpContext()

_Ret_valid_ PIRP_CONTEXT CdCreateIrpContext	(	_In_ PIRP	Irp,
		_In_ BOOLEAN	Wait
	)

Definition at line 1573 of file strucsup.c.

{
    PIRP_CONTEXT NewIrpContext = NULL;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    PAGED_CODE();
 
    //
    //  The only operations a filesystem device object should ever receive
    //  are create/teardown of fsdo handles and operations which do not
    //  occur in the context of fileobjects (i.e., mount).
    //
 
#ifndef __REACTOS__
    if (IrpSp->DeviceObject == CdData.FileSystemDeviceObject) {
#else
    if (IrpSp->DeviceObject == CdData.FileSystemDeviceObject ||
        IrpSp->DeviceObject == CdData.HddFileSystemDeviceObject) {
#endif
 
        if (IrpSp->FileObject != NULL &&
            IrpSp->MajorFunction != IRP_MJ_CREATE &&
            IrpSp->MajorFunction != IRP_MJ_CLEANUP &&
            IrpSp->MajorFunction != IRP_MJ_CLOSE) {
 
            ExRaiseStatus( STATUS_INVALID_DEVICE_REQUEST );
        }
 
        NT_ASSERT( IrpSp->FileObject != NULL ||
 
                (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                 IrpSp->MinorFunction == IRP_MN_USER_FS_REQUEST &&
                 IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_INVALIDATE_VOLUMES) ||
 
                (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                 IrpSp->MinorFunction == IRP_MN_MOUNT_VOLUME ) ||
 
                IrpSp->MajorFunction == IRP_MJ_SHUTDOWN );
    }
 
    //
    //  Look in our lookaside list for an IrpContext.
    //
 
    if (CdData.IrpContextDepth) {
 
        CdLockCdData();
        NewIrpContext = (PIRP_CONTEXT) PopEntryList( &CdData.IrpContextList );
        if (NewIrpContext != NULL) {
 
            CdData.IrpContextDepth--;
        }
 
        CdUnlockCdData();
    }
 
    if (NewIrpContext == NULL) {
 
        //
        //  We didn't get it from our private list so allocate it from pool.
        //
 
        NewIrpContext = FsRtlAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT ), TAG_IRP_CONTEXT );
    }
 
    RtlZeroMemory( NewIrpContext, sizeof( IRP_CONTEXT ));
 
    //
    //  Set the proper node type code and node byte size
    //
 
    NewIrpContext->NodeTypeCode = CDFS_NTC_IRP_CONTEXT;
    NewIrpContext->NodeByteSize = sizeof( IRP_CONTEXT );
 
    //
    //  Set the originating Irp field
    //
 
    NewIrpContext->Irp = Irp;
 
    //
    //  Copy RealDevice for workque algorithms.  We will update this in the Mount or
    //  Verify since they have no file objects to use here.
    //
 
    if (IrpSp->FileObject != NULL) {
 
        NewIrpContext->RealDevice = IrpSp->FileObject->DeviceObject;
    }
 
    //
    //  Locate the volume device object and Vcb that we are trying to access.
    //  This may be our filesystem device object.  In that case don't initialize
    //  the Vcb field.
    //
 
#ifndef __REACTOS__
    if (IrpSp->DeviceObject != CdData.FileSystemDeviceObject) {
#else
    if (IrpSp->DeviceObject != CdData.FileSystemDeviceObject &&
        IrpSp->DeviceObject != CdData.HddFileSystemDeviceObject) {
#endif
 
        NewIrpContext->Vcb =  &((PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject)->Vcb;
 
    }
 
    //
    //  Major/Minor Function codes
    //
 
    NewIrpContext->MajorFunction = IrpSp->MajorFunction;
    NewIrpContext->MinorFunction = IrpSp->MinorFunction;
 
    //
    //  Set the wait parameter
    //
 
    if (Wait) {
 
        SetFlag( NewIrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    } else {
 
        SetFlag( NewIrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST );
    }
 
    //
    //  return and tell the caller
    //
 
    return NewIrpContext;
}

Referenced by _IRQL_requires_max_().

CdCreateUserMdl()

NTSTATUS CdCreateUserMdl	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	BufferLength,
		_In_ BOOLEAN	RaiseOnError,
		_In_ LOCK_OPERATION	Operation
	)

Definition at line 1221 of file deviosup.c.

{
    NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
    PMDL Mdl;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Operation );
    UNREFERENCED_PARAMETER( IrpContext );
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_IRP( IrpContext->Irp );
    NT_ASSERT( IrpContext->Irp->MdlAddress == NULL );
 
    //
    // Allocate the Mdl, and Raise if we fail.
    //
 
    Mdl = IoAllocateMdl( IrpContext->Irp->UserBuffer,
                         BufferLength,
                         FALSE,
                         FALSE,
                         IrpContext->Irp );
 
    if (Mdl != NULL) {
 
        //
        //  Now probe the buffer described by the Irp.  If we get an exception,
        //  deallocate the Mdl and return the appropriate "expected" status.
        //
 
        _SEH2_TRY {
 
            MmProbeAndLockPages( Mdl, IrpContext->Irp->RequestorMode, IoWriteAccess );
 
            Status = STATUS_SUCCESS;
 
#ifdef _MSC_VER
#pragma warning(suppress: 6320)
#endif
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 
            Status = _SEH2_GetExceptionCode();
 
            IoFreeMdl( Mdl );
            IrpContext->Irp->MdlAddress = NULL;
 
            if (!FsRtlIsNtstatusExpected( Status )) {
 
                Status = STATUS_INVALID_USER_BUFFER;
            }
        } _SEH2_END;
    }
 
    //
    //  Check if we are to raise or return
    //
 
    if (Status != STATUS_SUCCESS) {
 
        if (RaiseOnError) {
 
            CdRaiseStatus( IrpContext, Status );
        }
    }
 
    //
    //  Return the status code.
    //
 
    return Status;
}

CdDeleteCcb()

VOID CdDeleteCcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ __drv_freesMem(Pool) PCCB	Ccb
	)

Definition at line 1462 of file strucsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    if (Ccb->SearchExpression.FileName.Buffer != NULL) {
 
        CdFreePool( &Ccb->SearchExpression.FileName.Buffer );
    }
 
    CdDeallocateCcb( IrpContext, Ccb );
    return;
}

CdDeleteFileLock()

VOID CdDeleteFileLock	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFILE_LOCK	FileLock
	)

CdDeleteInternalStream()

VOID CdDeleteInternalStream	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb
	)

Definition at line 333 of file cachesup.c.

{
    PFILE_OBJECT FileObject;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
 
    //
    //  Lock the Fcb.
    //
 
    CdLockFcb( IrpContext, Fcb );
 
    //
    //  Capture the file object.
    //
 
    FileObject = Fcb->FileObject;
    Fcb->FileObject = NULL;
 
    //
    //  It is now safe to unlock the Fcb.
    //
 
    CdUnlockFcb( IrpContext, Fcb );
 
    //
    //  Dereference the file object if present.
    //
 
    if (FileObject != NULL) {
 
        if (FileObject->PrivateCacheMap != NULL) {
 
            CcUninitializeCacheMap( FileObject, NULL, NULL );
        }
 
        //
        //  Null the name pointer, since the stream file object never actually
        //  'owns' the names, we just point it to existing ones.
        //
 
        FileObject->FileName.Buffer = NULL;
        FileObject->FileName.MaximumLength = FileObject->FileName.Length = 0;
 
        ObDereferenceObject( FileObject );
    }
}

Referenced by _Requires_lock_held_().

CdDeleteVcb()

VOID CdDeleteVcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb
	)

Definition at line 876 of file strucsup.c.

{
    PAGED_CODE();
 
    ASSERT_EXCLUSIVE_CDDATA;
    ASSERT_EXCLUSIVE_VCB( Vcb );
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Chuck the backpocket Vpb we kept just in case.
    //
 
    CdFreePool( &Vcb->SwapVpb );
 
    //
    //  If there is a Vpb then we must delete it ourselves.
    //
 
    CdFreePool( &Vcb->Vpb );
 
    //
    //  Dereference our target if we haven't already done so.
    //
 
    if (Vcb->TargetDeviceObject != NULL) {
 
        ObDereferenceObject( Vcb->TargetDeviceObject );
    }
 
    //
    //  Delete the XA Sector and sector cache buffer if allocated.
    //
 
    CdFreePool( &Vcb->XASector );
    CdFreePool( &Vcb->SectorCacheBuffer);
 
    if (Vcb->SectorCacheIrp != NULL) {
 
        IoFreeIrp( Vcb->SectorCacheIrp);
        Vcb->SectorCacheIrp = NULL;
 
        ExDeleteResourceLite( &Vcb->SectorCacheResource);
    }
 
    //
    //  Remove this entry from the global queue.
    //
 
    RemoveEntryList( &Vcb->VcbLinks );
 
    //
    //  Delete the Vcb and File resources.
    //
 
    ExDeleteResourceLite( &Vcb->VcbResource );
    ExDeleteResourceLite( &Vcb->FileResource );
 
    //
    //  Delete the TOC if present.
    //
 
    CdFreePool( &Vcb->CdromToc );
 
    //
    //  Uninitialize the notify structures.
    //
 
    if (Vcb->NotifySync != NULL) {
 
        FsRtlNotifyUninitializeSync( &Vcb->NotifySync );
    }
 
    //
    //  Now delete the volume device object.
    //
#ifdef _MSC_VER
#pragma prefast( suppress: __WARNING_BUFFER_UNDERFLOW, "This is ok, the Vcb is embedded in our volume device object, and that is what we are really deleting." )
#endif
    IoDeleteDevice( (PDEVICE_OBJECT) CONTAINING_RECORD( Vcb,
                                                        VOLUME_DEVICE_OBJECT,
                                                        Vcb ));
 
    return;
}

CdDissectName()

VOID CdDissectName	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PUNICODE_STRING	RemainingName,
		_Out_ PUNICODE_STRING	FinalName
	)

Definition at line 301 of file namesup.c.

{
    ULONG NameLength;
    PWCHAR NextWchar;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Find the offset of the next component separators.
    //
 
    for (NameLength = 0, NextWchar = RemainingName->Buffer;
         (NameLength < RemainingName->Length) && (*NextWchar != L'\\');
         NameLength += sizeof( WCHAR) , NextWchar += 1);
 
    //
    //  Adjust all the strings by this amount.
    //
 
    FinalName->Buffer = RemainingName->Buffer;
 
    FinalName->MaximumLength = FinalName->Length = (USHORT) NameLength;
 
    //
    //  If this is the last component then set the RemainingName lengths to zero.
    //
 
    if (NameLength == RemainingName->Length) {
 
        RemainingName->Length = 0;
 
    //
    //  Otherwise we adjust the string by this amount plus the separating character.
    //
 
    } else {
 
        RemainingName->MaximumLength -= (USHORT) (NameLength + sizeof( WCHAR ));
        RemainingName->Length -= (USHORT) (NameLength + sizeof( WCHAR ));
        RemainingName->Buffer = Add2Ptr( RemainingName->Buffer,
                                         NameLength + sizeof( WCHAR ),
                                         PWCHAR );
    }
 
    return;
}

Referenced by _Requires_lock_held_().

CdExceptionFilter()

LONG CdExceptionFilter	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_In_ PEXCEPTION_POINTERS	ExceptionPointer
	)

Definition at line 525 of file cddata.c.

{
    NTSTATUS ExceptionCode;
    BOOLEAN TestStatus = TRUE;
 
    ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
 
    ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
 
    //
    // If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
    // from the exception record.
    //
 
    if ((ExceptionCode == STATUS_IN_PAGE_ERROR) &&
        (ExceptionPointer->ExceptionRecord->NumberParameters >= 3)) {
 
        ExceptionCode =
            (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
    }
 
    //
    //  If there is an Irp context then check which status code to use.
    //
 
    if (ARGUMENT_PRESENT( IrpContext )) {
 
        if (IrpContext->ExceptionStatus == STATUS_SUCCESS) {
 
            //
            //  Store the real status into the IrpContext.
            //
 
            IrpContext->ExceptionStatus = ExceptionCode;
 
        } else {
 
            //
            //  No need to test the status code if we raised it ourselves.
            //
 
            TestStatus = FALSE;
        }
    }
 
    AssertVerifyDevice( IrpContext, IrpContext->ExceptionStatus );
 
    //
    //  Bug check if this status is not supported.
    //
 
    if (TestStatus && !FsRtlIsNtstatusExpected( ExceptionCode )) {
 
#ifdef _MSC_VER
#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "We're corrupted." )
#endif
        CdBugCheck( (ULONG_PTR) ExceptionPointer->ExceptionRecord,
                    (ULONG_PTR) ExceptionPointer->ContextRecord,
                    (ULONG_PTR) ExceptionPointer->ExceptionRecord->ExceptionAddress );
 
    }
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), and CdFspDispatch().

CdFastDecodeFileObject()

TYPE_OF_OPEN CdFastDecodeFileObject	(	_In_ PFILE_OBJECT	FileObject,
		_Out_ PFCB *	Fcb
	)

Definition at line 206 of file filobsup.c.

{
    PAGED_CODE();
 
    ASSERT_FILE_OBJECT( FileObject );
 
    //
    //  The Fcb is in the FsContext field.  The type of open is in the low
    //  bits of the Ccb.
    //
 
    *Fcb = FileObject->FsContext;
 
    return (TYPE_OF_OPEN)
            FlagOn( (ULONG_PTR) FileObject->FsContext2, TYPE_OF_OPEN_MASK );
}

Referenced by _Function_class_(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), and CdFastUnlockSingle().

CdFindDirectory()

BOOLEAN CdFindDirectory	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ PCD_NAME	Name,
		_In_ BOOLEAN	IgnoreCase,
		_Inout_ PFILE_ENUM_CONTEXT	FileContext
	)

Definition at line 997 of file dirsup.c.

{
    PDIRENT Dirent;
 
    BOOLEAN Found = FALSE;
 
    PAGED_CODE();
 
    //
    //  Make sure there is a stream file for this Fcb.
    //
 
    CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
 
    //
    //  Position ourselves at the first entry.
    //
 
    CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
 
    //
    //  Loop while there are more entries in this directory.
    //
 
    do {
 
        Dirent = &FileContext->InitialDirent->Dirent;
 
        //
        //  We only look for directories.  Directories cannot have the
        //  associated bit set.
        //
 
        if (FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
 
            //
            //  Update the name in the current dirent.
            //
 
            CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
 
            //
            //  Don't bother with constant entries.
            //
 
            if (FlagOn( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY )) {
 
                continue;
            }
 
            //
            //  Now check whether we have a name match.
            //  We exit the loop if we have a match.
            //
 
            if (CdIsNameInExpression( IrpContext,
                                      &Dirent->CdCaseFileName,
                                      Name,
                                      0,
                                      TRUE )) {
 
                Found = TRUE;
                break;
            }
        }
 
        //
        //  Go to the next initial dirent.
        //
 
    } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
 
    return Found;
}

CdFspClose()

VOID CdFspClose

(

_In_opt_ PVCB

Vcb

)

Referenced by _Requires_lock_held_(), and CdCloseWorker().

CdFullCompareNames()

FSRTL_COMPARISON_RESULT CdFullCompareNames	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PUNICODE_STRING	NameA,
		_In_ PUNICODE_STRING	NameB
	)

Definition at line 1064 of file namesup.c.

{
    SIZE_T i;
    ULONG MinLength = NameA->Length;
    FSRTL_COMPARISON_RESULT Result = LessThan;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Figure out the minimum of the two lengths
    //
 
    if (NameA->Length > NameB->Length) {
 
        MinLength = NameB->Length;
        Result = GreaterThan;
 
    } else if (NameA->Length == NameB->Length) {
 
        Result = EqualTo;
    }
 
    //
    //  Loop through looking at all of the characters in both strings
    //  testing for equalilty, less than, and greater than
    //
 
    i = RtlCompareMemory( NameA->Buffer, NameB->Buffer, MinLength );
 
    if (i < MinLength) {
 
        //
        //  We know the offset of the first character which is different.
        //
 
        return ((NameA->Buffer[ i / 2 ] < NameB->Buffer[ i / 2 ]) ?
                 LessThan :
                 GreaterThan);
    }
 
    //
    //  The names match up to the length of the shorter string.
    //  The shorter string lexically appears first.
    //
 
    return Result;
}

Referenced by CdFindNameLink(), and CdInsertNameLink().

CdGenerate8dot3Name()

VOID CdGenerate8dot3Name	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PUNICODE_STRING	FileName,
		_In_ ULONG	DirentOffset,
		_Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR	ShortFileName,
		_Out_ PUSHORT	ShortByteCount
	)

Definition at line 550 of file namesup.c.

{
    NTSTATUS Status;
 
    UNICODE_STRING ShortName;
    UNICODE_STRING BiasedShortName;
    WCHAR ShortNameBuffer[ BYTE_COUNT_8_DOT_3 / sizeof( WCHAR ) ] = {0};
    WCHAR BiasedShortNameBuffer[ BYTE_COUNT_8_DOT_3 / sizeof( WCHAR ) ];
 
    GENERATE_NAME_CONTEXT NameContext;
 
    ULONG BiasedDirentOffset;
 
    ULONG MaximumBaseBytes;
    ULONG BaseNameOffset;
 
    PWCHAR NextWchar;
    WCHAR ThisWchar;
    USHORT Length;
 
    BOOLEAN FoundTilde = FALSE;
 
    OEM_STRING OemName = {0};
    USHORT OemNameOffset = 0;
    BOOLEAN OverflowBuffer = FALSE;
 
    PAGED_CODE();
 
    //
    //  Initialize the short string to use the input buffer.
    //
 
    ShortName.Buffer = ShortNameBuffer;
    ShortName.MaximumLength = BYTE_COUNT_8_DOT_3;
 
    //
    //  Initialize the name context.
    //
 
    RtlZeroMemory( &NameContext, sizeof( GENERATE_NAME_CONTEXT ));
 
    //
    //  We now have the unicode name for the input string.  Go ahead and generate
    //  the short name.
    //
 
    RtlGenerate8dot3Name( FileName, TRUE, &NameContext, &ShortName );
 
    //
    //  We now have the generic short name.  We want incorporate the dirent offset
    //  into the name in order to reduce the chance of name conflicts.  We will use
    //  a tilde character followed by a character representation of the dirent offset.
    //  This will be the hexadecimal representation of the dirent offset in the directory.
    //  It is actuall this offset divided by 32 since we don't need the full
    //  granularity.
    //
 
    BiasedDirentOffset = DirentOffset >> SHORT_NAME_SHIFT;
 
    //
    //  Point to a local buffer to store the offset string.  We start
    //  at the end of the buffer and work backwards.
    //
 
    NextWchar = Add2Ptr( BiasedShortNameBuffer,
                         BYTE_COUNT_8_DOT_3,
                         PWCHAR );
 
    BiasedShortName.MaximumLength = BYTE_COUNT_8_DOT_3;
 
    //
    //  Generate an OEM version of the string so that we can check for double
    //  byte characters.
    //
 
    Status = RtlUnicodeStringToOemString(&OemName, &ShortName, TRUE);
 
    //
    //  If this failed, bail out. Don't expect any problems other than no mem.
    //
 
    if (!NT_SUCCESS( Status)) {
 
        NT_ASSERT( STATUS_INSUFFICIENT_RESOURCES == Status);
        CdRaiseStatus( IrpContext, Status);
    }
 
    Length = 0;
 
    //
    //  Now add the characters for the dirent offset.  We need to start
    //  from the least significant digit and work backwards.
    //
 
    do {
 
        NextWchar -= 1;
 
        ThisWchar = (WCHAR) (BiasedDirentOffset & 0x0000000f);
 
        //
        //  Store in the next character.  Bias against either '0' or 'A'
        //
 
        if (ThisWchar <= 9) {
 
            *NextWchar = ThisWchar + L'0';
 
        } else {
 
            *NextWchar = ThisWchar + L'A' - 0xA;
        }
 
        Length += sizeof( WCHAR );
 
        //
        //  Shift out the low 4 bits of the offset.
        //
 
        BiasedDirentOffset >>= 4;
 
    } while (BiasedDirentOffset != 0);
 
    //
    //  Now store in the tilde character.
    //
 
    NextWchar -= 1;
    *NextWchar = L'~';
    Length += sizeof( WCHAR );
 
    //
    //  Set the length of this string.
    //
 
    BiasedShortName.Length = Length;
    BiasedShortName.Buffer = NextWchar;
 
    //
    //  Figure out the maximum number of characters we can copy of the base
    //  name.  We subract the number of characters in the dirent string from 8.
    //  We will copy this many characters or stop when we reach a '.' character
    //  or a '~' character in the name.
    //
 
    MaximumBaseBytes = 16 - Length;
 
    BaseNameOffset = 0;
 
    //
    //  Keep copying from the base name until we hit a '.', '~'  or the end of
    //  the short name.
    //
 
    NextWchar = ShortFileName;
    Length = 0;
 
    while ((BaseNameOffset < ShortName.Length) &&
           (ShortName.Buffer[BaseNameOffset / 2] != L'.')) {
 
        //
        //  Remember if we found a tilde character in the short name,
        //  so we don't copy it or anything following it.
        //
 
        if (ShortName.Buffer[BaseNameOffset / 2] == L'~') {
 
            FoundTilde = TRUE;
        }
 
        //
        // We need to consider the DBCS code page,  because Unicode characters
        // may use 2 bytes as DBCS characters.
        //
 
#ifdef _MSC_VER
#pragma prefast(push)
#pragma prefast(suppress:26014, "OemNameOffset <= BaseNameOffset throughout this loop; OemName buffer previously allocated based on ShortName's length.")
#endif
        if (FsRtlIsLeadDbcsCharacter(OemName.Buffer[OemNameOffset])) {
#ifdef _MSC_VER
#pragma prefast(pop)
#endif
 
            OemNameOffset += 2;
 
            if ((OemNameOffset + (BiasedShortName.Length / sizeof(WCHAR))) > 8)  {
 
                OverflowBuffer = TRUE;
            }
        }
        else  {
 
            OemNameOffset++;
        }
 
        //
        //  Only copy the bytes if we still have space for the dirent string.
        //
 
        if (!FoundTilde && !OverflowBuffer && (BaseNameOffset < MaximumBaseBytes)) {
 
            *NextWchar = ShortName.Buffer[BaseNameOffset / 2];
            Length += sizeof( WCHAR );
            NextWchar += 1;
        }
 
        BaseNameOffset += 2;
    }
 
    RtlFreeOemString(&OemName);
 
    //
    //  Now copy the dirent string into the biased name buffer.
    //
 
#ifdef _MSC_VER
#pragma prefast(push)
#endif
    RtlCopyMemory( NextWchar,
                   BiasedShortName.Buffer,
                   BiasedShortName.Length );
#ifdef _MSC_VER
#pragma prefast(pop)
#endif
 
    Length += BiasedShortName.Length;
    NextWchar += (BiasedShortName.Length / sizeof( WCHAR ));
 
    //
    //  Now copy any remaining bytes over to the biased short name.
    //
 
    if (BaseNameOffset != ShortName.Length) {
 
        RtlCopyMemory( NextWchar,
                       &ShortName.Buffer[BaseNameOffset / 2],
                       ShortName.Length - BaseNameOffset );
 
        Length += (ShortName.Length - (USHORT) BaseNameOffset);
    }
 
    //
    //  The final short name is stored in the user's buffer.
    //
 
    *ShortByteCount = Length;
}

Referenced by _Success_(), CdEnumerateIndex(), and if().

CdGetNextFcb()

PFCB CdGetNextFcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_In_ PVOID *	RestartKey
	)

Definition at line 2155 of file strucsup.c.

{
    PFCB Fcb;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    Fcb = (PFCB) RtlEnumerateGenericTableWithoutSplaying( &Vcb->FcbTable, RestartKey );
 
    if (Fcb != NULL) {
 
        Fcb = ((PFCB_TABLE_ELEMENT)(Fcb))->Fcb;
    }
 
    return Fcb;
}

Referenced by _Requires_lock_held_().

CdHijackIrpAndFlushDevice()

NTSTATUS CdHijackIrpAndFlushDevice	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp,
		_In_ PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 4105 of file deviosup.c.

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

Referenced by _Requires_lock_held_().

CdInitializeFcbFromFileContext()

VOID CdInitializeFcbFromFileContext	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ PFCB	ParentFcb,
		_In_ PFILE_ENUM_CONTEXT	FileContext
	)

Definition at line 1225 of file strucsup.c.

{
    PDIRENT ThisDirent = &FileContext->InitialDirent->Dirent;
    PCOMPOUND_DIRENT CurrentCompoundDirent;
 
    LONGLONG CurrentFileOffset;
    ULONG CurrentMcbEntryOffset;
 
    PAGED_CODE();
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    CdLockFcb( IrpContext, Fcb );
 
    _SEH2_TRY {
 
        //
        //  Initialize the common header in the Fcb.  The node type is already
        //  present.
        //
 
        Fcb->Resource = &IrpContext->Vcb->FileResource;
 
        //
        //  Allocation occurs in block-sized units.
        //
 
        Fcb->FileSize.QuadPart =
        Fcb->ValidDataLength.QuadPart = FileContext->FileSize;
 
        Fcb->AllocationSize.QuadPart = LlBlockAlign( Fcb->Vcb, FileContext->FileSize );
 
        //
        //  Set the flags from the dirent.  We always start with the read-only bit.
        //
 
        SetFlag( Fcb->FileAttributes, FILE_ATTRIBUTE_READONLY );
        if (FlagOn( ThisDirent->DirentFlags, CD_ATTRIBUTE_HIDDEN )) {
 
            SetFlag( Fcb->FileAttributes, FILE_ATTRIBUTE_HIDDEN );
        }
 
        //
        //  Convert the time to NT time.
        //
 
        CdConvertCdTimeToNtTime( IrpContext,
                                 ThisDirent->CdTime,
                                 (PLARGE_INTEGER) &Fcb->CreationTime );
 
        //
        //  Set the flag indicating the type of extent.
        //
 
        if (ThisDirent->ExtentType != Form1Data) {
 
            if (ThisDirent->ExtentType == Mode2Form2Data) {
 
                SetFlag( Fcb->FcbState, FCB_STATE_MODE2FORM2_FILE );
 
            } else {
 
                SetFlag( Fcb->FcbState, FCB_STATE_DA_FILE );
            }
 
            Fcb->XAAttributes = ThisDirent->XAAttributes;
            Fcb->XAFileNumber = ThisDirent->XAFileNumber;
        }
 
        //
        //  Read through all of the dirents for the file until we find the last
        //  and add the allocation into the Mcb.
        //
 
        CurrentCompoundDirent = FileContext->InitialDirent;
        CurrentFileOffset = 0;
        CurrentMcbEntryOffset = 0;
 
        while (TRUE) {
 
            CdAddAllocationFromDirent( IrpContext,
                                       Fcb,
                                       CurrentMcbEntryOffset,
                                       CurrentFileOffset,
                                       &CurrentCompoundDirent->Dirent );
 
            //
            //  Break out if we are at the last dirent.
            //
 
            if (!FlagOn( CurrentCompoundDirent->Dirent.DirentFlags, CD_ATTRIBUTE_MULTI )) {
 
                break;
            }
 
            CurrentFileOffset += CurrentCompoundDirent->Dirent.DataLength;
            CurrentMcbEntryOffset += 1;
 
            //
            //  We better be able to find the next dirent.
            //
 
            if (!CdLookupNextDirent( IrpContext,
                                     ParentFcb,
                                     &CurrentCompoundDirent->DirContext,
                                     &FileContext->CurrentDirent->DirContext )) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            CurrentCompoundDirent = FileContext->CurrentDirent;
 
            CdUpdateDirentFromRawDirent( IrpContext,
                                         ParentFcb,
                                         &CurrentCompoundDirent->DirContext,
                                         &CurrentCompoundDirent->Dirent );
        }
 
        //
        //  Show that the Fcb is initialized.
        //
 
        SetFlag( Fcb->FcbState, FCB_STATE_INITIALIZED );
 
        //
        //  Link into the other in-memory structures and into the Fcb table.
        //
 
        Fcb->ParentFcb = ParentFcb;
 
        InsertTailList( &ParentFcb->FcbQueue, &Fcb->FcbLinks );
 
        CdIncrementReferenceCounts( IrpContext, ParentFcb, 1, 1 );
 
        CdInsertFcbTable( IrpContext, Fcb );
        SetFlag( Fcb->FcbState, FCB_STATE_IN_FCB_TABLE );
 
    } _SEH2_FINALLY {
 
        CdUnlockFcb( IrpContext, Fcb );
    } _SEH2_END;
 
    return;
}

Referenced by _Requires_lock_held_().

CdInitializeFcbFromPathEntry()

VOID CdInitializeFcbFromPathEntry	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_opt_ PFCB	ParentFcb,
		_In_ PPATH_ENTRY	PathEntry
	)

Definition at line 1136 of file strucsup.c.

{
    PAGED_CODE();
 
    //
    //  Fill in the Index specific fields of the Fcb.
    //
 
    Fcb->StreamOffset = BytesFromBlocks( Fcb->Vcb,
                                         SectorBlockOffset( Fcb->Vcb, PathEntry->DiskOffset ));
 
    Fcb->Ordinal = PathEntry->Ordinal;
 
    //
    //  Initialize the common header in the Fcb.  The node type is already
    //  present.
    //
 
    Fcb->Resource = &Fcb->Vcb->FileResource;
 
    //
    //  Always set the sizes to one sector until we read the self-entry.
    //
 
    Fcb->AllocationSize.QuadPart =
    Fcb->FileSize.QuadPart =
    Fcb->ValidDataLength.QuadPart = SECTOR_SIZE;
 
    CdAddInitialAllocation( IrpContext,
                            Fcb,
                            PathEntry->DiskOffset,
                            SECTOR_SIZE );
    //
    //  State flags for this Fcb.
    //
 
    SetFlag( Fcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY );
 
    //
    //  Link into the other in-memory structures and into the Fcb table.
    //
 
    if (ParentFcb != NULL) {
 
        Fcb->ParentFcb = ParentFcb;
 
        InsertTailList( &ParentFcb->FcbQueue, &Fcb->FcbLinks );
 
        CdIncrementReferenceCounts( IrpContext, ParentFcb, 1, 1 );
    }
 
    CdInsertFcbTable( IrpContext, Fcb );
    SetFlag( Fcb->FcbState, FCB_STATE_IN_FCB_TABLE );
 
    return;
}

Referenced by _Requires_lock_held_(), and CdUpdateVcbFromVolDescriptor().

CdInitializeStackIrpContext()

VOID CdInitializeStackIrpContext	(	_Out_ PIRP_CONTEXT	IrpContext,
		_In_ PIRP_CONTEXT_LITE	IrpContextLite
	)

Definition at line 1839 of file strucsup.c.

{
    PAGED_CODE();
 
    //
    //  Zero and then initialize the structure.
    //
 
    RtlZeroMemory( IrpContext, sizeof( IRP_CONTEXT ));
 
    //
    //  Set the proper node type code and node byte size
    //
 
    IrpContext->NodeTypeCode = CDFS_NTC_IRP_CONTEXT;
    IrpContext->NodeByteSize = sizeof( IRP_CONTEXT );
 
    //
    //  Note that this is from the stack.
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ON_STACK );
 
    //
    //  Copy RealDevice for workque algorithms.
    //
 
    IrpContext->RealDevice = IrpContextLite->RealDevice;
 
    //
    //  The Vcb is found in the Fcb.
    //
 
    IrpContext->Vcb = IrpContextLite->Fcb->Vcb;
 
    //
    //  Major/Minor Function codes
    //
 
    IrpContext->MajorFunction = IRP_MJ_CLOSE;
 
    //
    //  Set the wait parameter
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    return;
}

CdInitializeVcb()

VOID CdInitializeVcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb,
		_In_ __drv_aliasesMem PDEVICE_OBJECT	TargetDeviceObject,
		_In_ __drv_aliasesMem PVPB	Vpb,
		_In_ __drv_aliasesMem PCDROM_TOC_LARGE	CdromToc,
		_In_ ULONG	TocLength,
		_In_ ULONG	TocTrackCount,
		_In_ ULONG	TocDiskFlags,
		_In_ ULONG	BlockFactor,
		_In_ ULONG	MediaChangeCount
	)

Definition at line 241 of file strucsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  We start by first zeroing out all of the VCB, this will guarantee
    //  that any stale data is wiped clean.
    //
 
    RtlZeroMemory( Vcb, sizeof( VCB ));
 
    //
    //  Set the proper node type code and node byte size.
    //
 
    Vcb->NodeTypeCode = CDFS_NTC_VCB;
    Vcb->NodeByteSize = sizeof( VCB );
 
    //
    //  Initialize the DirNotify structs.  FsRtlNotifyInitializeSync can raise.
    //
 
    InitializeListHead( &Vcb->DirNotifyList );
    FsRtlNotifyInitializeSync( &Vcb->NotifySync );
 
    //
    //  Pick up a VPB right now so we know we can pull this filesystem stack
    //  off of the storage stack on demand.  This can raise - if it does,
    //  uninitialize the notify structures before returning.
    //
 
    _SEH2_TRY  {
 
        Vcb->SwapVpb = FsRtlAllocatePoolWithTag( CdNonPagedPool,
                                                 sizeof( VPB ),
                                                 TAG_VPB );
    }
    _SEH2_FINALLY {
 
        if (_SEH2_AbnormalTermination())  {
 
            FsRtlNotifyUninitializeSync( &Vcb->NotifySync );
        }
    } _SEH2_END;
 
    //
    //  Nothing beyond this point should raise.
    //
 
    RtlZeroMemory( Vcb->SwapVpb, sizeof( VPB ) );
 
    //
    //  Initialize the resource variable for the Vcb and files.
    //
 
    ExInitializeResourceLite( &Vcb->VcbResource );
    ExInitializeResourceLite( &Vcb->FileResource );
    ExInitializeFastMutex( &Vcb->VcbMutex );
 
    //
    //  Insert this Vcb record on the CdData.VcbQueue.
    //
 
    InsertHeadList( &CdData.VcbQueue, &Vcb->VcbLinks );
 
    //
    //  Set the Target Device Object and Vpb fields, referencing the
    //  Target device for the mount.
    //
 
    ObReferenceObject( TargetDeviceObject );
    Vcb->TargetDeviceObject = TargetDeviceObject;
    Vcb->Vpb = Vpb;
 
    //
    //  Set the removable media flag based on the real device's
    //  characteristics
    //
 
    if (FlagOn( Vpb->RealDevice->Characteristics, FILE_REMOVABLE_MEDIA )) {
 
        SetFlag( Vcb->VcbState, VCB_STATE_REMOVABLE_MEDIA );
    }
 
    //
    //  Initialize the generic Fcb Table.
    //
 
    RtlInitializeGenericTable( &Vcb->FcbTable,
                               (PRTL_GENERIC_COMPARE_ROUTINE) CdFcbTableCompare,
                               (PRTL_GENERIC_ALLOCATE_ROUTINE) CdAllocateFcbTable,
                               (PRTL_GENERIC_FREE_ROUTINE) CdDeallocateFcbTable,
                               NULL );
 
    //
    //  Show that we have a mount in progress.
    //
 
    CdUpdateVcbCondition( Vcb, VcbMountInProgress);
 
    //
    //  Refererence the Vcb for two reasons.  The first is a reference
    //  that prevents the Vcb from going away on the last close unless
    //  dismount has already occurred.  The second is to make sure
    //  we don't go into the dismount path on any error during mount
    //  until we get to the Mount cleanup.
    //
 
    Vcb->VcbReference = 1 + CDFS_RESIDUAL_REFERENCE;
 
    //
    //  Update the TOC information in the Vcb.
    //
 
    Vcb->CdromToc = CdromToc;
    Vcb->TocLength = TocLength;
    Vcb->TrackCount = TocTrackCount;
    Vcb->DiskFlags = TocDiskFlags;
 
    //
    //  If this disk contains audio tracks only then set the audio flag.
    //
 
    if (TocDiskFlags == CDROM_DISK_AUDIO_TRACK) {
 
        SetFlag( Vcb->VcbState, VCB_STATE_AUDIO_DISK | VCB_STATE_CDXA );
    }
 
    //
    //  Set the block factor.
    //
 
    Vcb->BlockFactor = BlockFactor;
 
    //
    //  Set the media change count on the device
    //
 
    CdUpdateMediaChangeCount( Vcb, MediaChangeCount);
}

CdInsertPrefix()

VOID CdInsertPrefix	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ PCD_NAME	Name,
		_In_ BOOLEAN	IgnoreCase,
		_In_ BOOLEAN	ShortNameMatch,
		_Inout_ PFCB	ParentFcb
	)

Definition at line 52 of file prefxsup.c.

{
    ULONG PrefixFlags;
    PNAME_LINK NameLink;
    PPREFIX_ENTRY PrefixEntry;
    PRTL_SPLAY_LINKS *TreeRoot;
 
    PWCHAR NameBuffer;
 
    PAGED_CODE();
 
    //
    //  Check if we need to allocate a prefix entry for the short name.
    //  If we can't allocate one then fail quietly.  We don't have to
    //  insert the name.
    //
 
    PrefixEntry = &Fcb->FileNamePrefix;
 
    if (ShortNameMatch) {
 
        if (Fcb->ShortNamePrefix == NULL) {
 
            Fcb->ShortNamePrefix = ExAllocatePoolWithTag( CdPagedPool,
                                                          sizeof( PREFIX_ENTRY ),
                                                          TAG_PREFIX_ENTRY );
 
            if (Fcb->ShortNamePrefix == NULL) { return; }
 
            RtlZeroMemory( Fcb->ShortNamePrefix, sizeof( PREFIX_ENTRY ));
        }
 
        PrefixEntry = Fcb->ShortNamePrefix;
    }
 
    //
    //  Capture the local variables for the separate cases.
    //
 
    if (IgnoreCase) {
 
        PrefixFlags = PREFIX_FLAG_IGNORE_CASE_IN_TREE;
        NameLink = &PrefixEntry->IgnoreCaseName;
        TreeRoot = &ParentFcb->IgnoreCaseRoot;
 
    } else {
 
        PrefixFlags = PREFIX_FLAG_EXACT_CASE_IN_TREE;
        NameLink = &PrefixEntry->ExactCaseName;
        TreeRoot = &ParentFcb->ExactCaseRoot;
    }
 
    //
    //  If neither name is in the tree then check whether we have a buffer for this
    //  name
    //
 
    if (!FlagOn( PrefixEntry->PrefixFlags,
                 PREFIX_FLAG_EXACT_CASE_IN_TREE | PREFIX_FLAG_IGNORE_CASE_IN_TREE )) {
 
        //
        //  Allocate a new buffer if the embedded buffer is too small.
        //
 
        NameBuffer = PrefixEntry->FileNameBuffer;
 
        if (Name->FileName.Length > BYTE_COUNT_EMBEDDED_NAME) {
 
            NameBuffer = ExAllocatePoolWithTag( CdPagedPool,
                                                Name->FileName.Length * 2,
                                                TAG_PREFIX_NAME );
 
            //
            //  Exit if no name buffer.
            //
 
            if (NameBuffer == NULL) { return; }
        }
 
        //
        //  Split the buffer and fill in the separate components.
        //
 
        PrefixEntry->ExactCaseName.FileName.Buffer = NameBuffer;
        PrefixEntry->IgnoreCaseName.FileName.Buffer = Add2Ptr( NameBuffer,
                                                               Name->FileName.Length,
                                                               PWCHAR );
 
        PrefixEntry->IgnoreCaseName.FileName.MaximumLength =
        PrefixEntry->IgnoreCaseName.FileName.Length =
        PrefixEntry->ExactCaseName.FileName.MaximumLength =
        PrefixEntry->ExactCaseName.FileName.Length = Name->FileName.Length;
    }
 
    //
    //  Only insert the name if not already present.
    //
 
    if (!FlagOn( PrefixEntry->PrefixFlags, PrefixFlags )) {
 
        //
        //  Initialize the name in the prefix entry.
        //
 
        RtlCopyMemory( NameLink->FileName.Buffer,
                       Name->FileName.Buffer,
                       Name->FileName.Length );
 
        CdInsertNameLink( IrpContext,
                          TreeRoot,
                          NameLink );
 
        PrefixEntry->Fcb = Fcb;
        SetFlag( PrefixEntry->PrefixFlags, PrefixFlags );
    }
 
    return;
}

CdIs8dot3Name()

BOOLEAN CdIs8dot3Name	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ UNICODE_STRING	FileName
	)

Definition at line 429 of file namesup.c.

{
    CHAR DbcsNameBuffer[ BYTE_COUNT_8_DOT_3 ];
    STRING DbcsName = {0};
 
    PWCHAR NextWchar;
    ULONG Count;
 
    ULONG DotCount = 0;
    BOOLEAN LastCharDot = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  The length must be less than 24 bytes.
    //
 
    NT_ASSERT( FileName.Length != 0 );
    if (FileName.Length > BYTE_COUNT_8_DOT_3) {
 
        return FALSE;
    }
 
    //
    //  Walk though and check for a space character.
    //
 
    NextWchar = FileName.Buffer;
    Count = 0;
 
    do {
 
        //
        //  No spaces allowed.
        //
 
        if (*NextWchar == L' ') { return FALSE; }
 
        if (*NextWchar == L'.') {
 
            //
            //  Not an 8.3 name if more than 1 dot or more than 8 characters
            //  remaining.  (It is legal for the dot to be in the ninth
            //  position)
            //
 
            if ((DotCount > 0) ||
                (Count > 8 * sizeof( WCHAR ))) {
 
                return FALSE;
            }
 
            DotCount += 1;
            LastCharDot = TRUE;
 
        } else {
 
            LastCharDot = FALSE;
        }
 
        Count += 2;
        NextWchar += 1;
 
    } while (Count < FileName.Length);
 
    //
    //  Go ahead and truncate the dot if at the end.
    //
 
    if (LastCharDot) {
 
        FileName.Length -= sizeof( WCHAR );
    }
 
    //
    //  Create an Oem name to use to check for a valid short name.
    //
 
    DbcsName.MaximumLength = BYTE_COUNT_8_DOT_3;
    DbcsName.Buffer = DbcsNameBuffer;
 
    if (!NT_SUCCESS( RtlUnicodeStringToCountedOemString( &DbcsName,
                                                         &FileName,
                                                         FALSE ))) {
 
        return FALSE;
    }
 
    //
    //  We have now initialized the Oem string.  Call the FsRtl package to check for a
    //  valid FAT name.
    //
 
    return FsRtlIsFatDbcsLegal( DbcsName, FALSE, FALSE, FALSE );
}

Referenced by _Success_(), CdEnumerateIndex(), and if().

CdIsLegalName()

BOOLEAN CdIsLegalName	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PUNICODE_STRING	FileName
	)

Definition at line 377 of file namesup.c.

{
    PWCHAR Wchar;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check if name corresponds to a legal file name.
    //
 
    for (Wchar = FileName->Buffer;
         Wchar < Add2Ptr( FileName->Buffer, FileName->Length, PWCHAR );
         Wchar++) {
 
        if ((*Wchar < 0xff) &&
            !FsRtlIsAnsiCharacterLegalHpfs( *Wchar, FALSE ) &&
            (*Wchar != L'"') &&
            (*Wchar != L'<') &&
            (*Wchar != L'>') &&
            (*Wchar != L'|')) {
 
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by CdUpdateDirentName().

CdIsNameInExpression()

BOOLEAN CdIsNameInExpression	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PCD_NAME	CurrentName,
		_In_ PCD_NAME	SearchExpression,
		_In_ ULONG	WildcardFlags,
		_In_ BOOLEAN	CheckVersion
	)

Definition at line 844 of file namesup.c.

{
    BOOLEAN Match = TRUE;
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If there are wildcards in the expression then we call the
    //  appropriate FsRtlRoutine.
    //
 
    if (FlagOn( WildcardFlags, CCB_FLAG_ENUM_NAME_EXP_HAS_WILD )) {
 
        Match = FsRtlIsNameInExpression( &SearchExpression->FileName,
                                         &CurrentName->FileName,
                                         FALSE,
                                         NULL );
 
    //
    //  Otherwise do a direct memory comparison for the name string.
    //
 
    } else {
 
        if ((CurrentName->FileName.Length != SearchExpression->FileName.Length) ||
            (!RtlEqualMemory( CurrentName->FileName.Buffer,
                              SearchExpression->FileName.Buffer,
                              CurrentName->FileName.Length ))) {
 
            Match = FALSE;
        }
    }
 
    //
    //  Check the version numbers if requested by the user and we have a
    //  match on the name and the version number is present.
    //
 
    if (Match && CheckVersion && SearchExpression->VersionString.Length &&
        !FlagOn( WildcardFlags, CCB_FLAG_ENUM_VERSION_MATCH_ALL )) {
 
        //
        //  If there are wildcards in the expression then call the
        //  appropriate search expression.
        //
 
        if (FlagOn( WildcardFlags, CCB_FLAG_ENUM_VERSION_EXP_HAS_WILD )) {
 
            Match = FsRtlIsNameInExpression( &SearchExpression->VersionString,
                                             &CurrentName->VersionString,
                                             FALSE,
                                             NULL );
 
        //
        //  Otherwise do a direct memory comparison for the name string.
        //
 
        } else {
 
            if ((CurrentName->VersionString.Length != SearchExpression->VersionString.Length) ||
                (!RtlEqualMemory( CurrentName->VersionString.Buffer,
                                  SearchExpression->VersionString.Buffer,
                                  CurrentName->VersionString.Length ))) {
 
                Match = FALSE;
            }
        }
    }
 
    return Match;
}

Referenced by _Success_(), CdEnumerateIndex(), CdFindDirectory(), and if().

CdLbnToMmSsFf()

VOID CdLbnToMmSsFf	(	_In_ ULONG	Blocks,
		_Out_writes_(3) PUCHAR	Msf
	)

Referenced by CdTocSerial().

CdLookupDirent()

VOID CdLookupDirent	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ ULONG	DirentOffset,
		_Out_ PDIRENT_ENUM_CONTEXT	DirContext
	)

Definition at line 125 of file dirsup.c.

{
    LONGLONG BaseOffset;
 
    PAGED_CODE();
 
    //
    //  Initialize the offset of the first dirent we want to map.
    //
 
    DirContext->BaseOffset = SectorTruncate( DirentOffset );
    BaseOffset = DirContext->BaseOffset;
 
    DirContext->DataLength = SECTOR_SIZE;
 
    DirContext->SectorOffset = SectorOffset( DirentOffset );
 
    //
    //  Truncate the data length if we are at the end of the file.
    //
 
    if (DirContext->DataLength > (Fcb->FileSize.QuadPart - BaseOffset)) {
 
        DirContext->DataLength = (ULONG) (Fcb->FileSize.QuadPart - BaseOffset);
    }
 
    //
    //  Now map the data at this offset.
    //
 
    CcMapData( Fcb->FileObject,
               (PLARGE_INTEGER) &BaseOffset,
               DirContext->DataLength,
               TRUE,
               &DirContext->Bcb,
               &DirContext->Sector );
 
    //
    //  Verify the dirent bounds.
    //
 
    DirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
                                                           DirContext );
 
    return;
}

Referenced by _Requires_lock_held_(), and CdCreateInternalStream().

CdLookupFcbTable()

PFCB CdLookupFcbTable	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PVCB	Vcb,
		_In_ FILE_ID	FileId
	)

Definition at line 2107 of file strucsup.c.

{
    FCB_TABLE_ELEMENT Key;
    PFCB_TABLE_ELEMENT Hit;
    PFCB ReturnFcb = NULL;
 
    PAGED_CODE();
 
    Key.FileId = FileId;
 
    Hit = (PFCB_TABLE_ELEMENT) RtlLookupElementGenericTable( &Vcb->FcbTable, &Key );
 
    if (Hit != NULL) {
 
        ReturnFcb = Hit->Fcb;
    }
 
    return ReturnFcb;
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by _Requires_lock_held_(), and CdCreateFcb().

CdLookupLastFileDirent()

VOID CdLookupLastFileDirent	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ PFILE_ENUM_CONTEXT	FileContext
	)

Definition at line 1426 of file dirsup.c.

{
    XA_EXTENT_TYPE ExtentType = Form1Data;
    PCOMPOUND_DIRENT CurrentCompoundDirent;
    PDIRENT CurrentDirent = NULL;
 
    BOOLEAN FirstPass = TRUE;
    BOOLEAN FoundDirent;
 
    PAGED_CODE();
 
    //
    //  The current dirent to look at is the initial dirent for the file.
    //
 
    CurrentCompoundDirent = FileContext->InitialDirent;
 
    //
    //  Loop until we reach the last dirent for the file.
    //
 
    while (TRUE) {
 
        CurrentDirent = &CurrentCompoundDirent->Dirent;
 
        //
        //  Check if this extent has XA sectors.
        //
 
        if ((CurrentDirent->SystemUseOffset != 0) &&
            FlagOn( Fcb->Vcb->VcbState, VCB_STATE_CDXA ) &&
            CdCheckForXAExtent( IrpContext,
                                CdRawDirent( IrpContext, &CurrentCompoundDirent->DirContext ),
                                CurrentDirent )) {
 
            //
            //  Any previous dirent must describe XA sectors as well.
            //
 
            if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            //
            //  If there are XA sectors then the data on the disk must
            //  be correctly aligned on sectors and be an integral number of
            //  sectors.  Only an issue if the logical block size is not
            //  2048.
            //
 
            if (Fcb->Vcb->BlockSize != SECTOR_SIZE) {
 
                //
                //  We will do the following checks.
                //
                //      Data must start on a sector boundary.
                //      Data length must be integral number of sectors.
                //
 
                if ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->StartingOffset ) != 0) ||
                    (SectorBlockOffset( Fcb->Vcb, CurrentDirent->DataLength ) != 0)) {
 
                    CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
                }
 
                //
                //  If interleaved then both the file unit and interleave
                //  gap must be integral number of sectors.
                //
 
                if ((CurrentDirent->FileUnitSize != 0) &&
                    ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->FileUnitSize ) != 0) ||
                     (SectorBlockOffset( Fcb->Vcb, CurrentDirent->InterleaveGapSize ) != 0))) {
 
                    CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
                }
            }
 
            //
            //  If this is the first dirent then add the bytes for the RIFF
            //  header.
            //
 
            if (FirstPass) {
 
                FileContext->FileSize = sizeof( RIFF_HEADER );
            }
 
            //
            //  Add the size of the mode2-form2 sector for each sector
            //  we have here.
            //
 
            FileContext->FileSize += Int32x32To64( CurrentDirent->DataLength >> SECTOR_SHIFT,
                                                   XA_SECTOR_SIZE);
 
        } else {
 
            //
            //  This extent does not have XA sectors.  Any previous dirent
            //  better not have XA sectors.
            //
 
            if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            //
            //  Add these bytes to the file size.
            //
 
            FileContext->FileSize += CurrentDirent->DataLength;
        }
 
        //
        //  If we are at the last dirent then exit.
        //
 
        if (!FlagOn( CurrentDirent->DirentFlags, CD_ATTRIBUTE_MULTI )) {
 
            break;
        }
 
        //
        //  Remember the extent type of the current extent.
        //
 
        ExtentType = CurrentDirent->ExtentType;
 
        //
        //  Look for the next dirent of the file.
        //
 
        FoundDirent = CdLookupNextDirent( IrpContext,
                                          Fcb,
                                          &CurrentCompoundDirent->DirContext,
                                          &FileContext->CurrentDirent->DirContext );
 
        //
        //  If we didn't find the entry then this is a corrupt directory.
        //
 
        if (!FoundDirent) {
 
            CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
        }
 
        //
        //  Remember the dirent we just found.
        //
 
        CurrentCompoundDirent = FileContext->CurrentDirent;
        FirstPass = FALSE;
 
        //
        //  Look up all of the dirent information for the given dirent.
        //
 
        CdUpdateDirentFromRawDirent( IrpContext,
                                     Fcb,
                                     &CurrentCompoundDirent->DirContext,
                                     &CurrentCompoundDirent->Dirent );
 
        //
        //  Set flag to show there were multiple extents.
        //
 
        SetFlag( FileContext->Flags, FILE_CONTEXT_MULTIPLE_DIRENTS );
    }
 
    return;
}

Referenced by _Requires_lock_held_(), _Success_(), CdEnumerateIndex(), and if().

CdLookupNextDirent()

BOOLEAN CdLookupNextDirent	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ PDIRENT_ENUM_CONTEXT	CurrentDirContext,
		_Inout_ PDIRENT_ENUM_CONTEXT	NextDirContext
	)

Definition at line 208 of file dirsup.c.

{
    LONGLONG CurrentBaseOffset = CurrentDirContext->BaseOffset;
    ULONG TempUlong;
 
    BOOLEAN FoundDirent = FALSE;
 
    PAGED_CODE();
 
    //
    //  Check if a different sector is mapped.  If so then move our target
    //  enumeration context to the same sector.
    //
 
    if ((CurrentDirContext->BaseOffset != NextDirContext->BaseOffset) ||
        (NextDirContext->Bcb == NULL)) {
 
        //
        //  Unpin the current target Bcb and map the next sector.
        //
 
        CdUnpinData( IrpContext, &NextDirContext->Bcb );
 
        CcMapData( Fcb->FileObject,
                   (PLARGE_INTEGER) &CurrentBaseOffset,
                   CurrentDirContext->DataLength,
                   TRUE,
                   &NextDirContext->Bcb,
                   &NextDirContext->Sector );
 
        //
        //  Copy the data length and sector offset.
        //
 
        NextDirContext->DataLength = CurrentDirContext->DataLength;
        NextDirContext->BaseOffset = CurrentDirContext->BaseOffset;
    }
 
    //
    //  Now move to the same offset in the sector.
    //
 
    NextDirContext->SectorOffset = CurrentDirContext->SectorOffset;
 
    //
    //  If the value is zero then unmap the current sector and set up
    //  the base offset to the beginning of the next sector.
    //
 
    if (CurrentDirContext->NextDirentOffset == 0) {
 
        CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
 
        //
        //  Unmap the current sector.  We test the value of the Bcb in the
        //  loop below to see if we need to read in another sector.
        //
 
        CdUnpinData( IrpContext, &NextDirContext->Bcb );
 
    //
    //  There is another possible dirent in the current sector.  Update the
    //  enumeration context to reflect this.
    //
 
    } else {
 
        NextDirContext->SectorOffset += CurrentDirContext->NextDirentOffset;
    }
 
    //
    //  Now loop until we find the next possible dirent or walk off the directory.
    //
 
    while (TRUE) {
 
        //
        //  If we don't currently have a sector mapped then map the
        //  directory at the current offset.
        //
 
        if (NextDirContext->Bcb == NULL) {
 
            TempUlong = SECTOR_SIZE;
 
            if (TempUlong > (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset)) {
 
                TempUlong = (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset);
 
                //
                //  If the length is zero then there is no dirent.
                //
 
                if (TempUlong == 0) {
 
                    break;
                }
            }
 
            CcMapData( Fcb->FileObject,
                       (PLARGE_INTEGER) &CurrentBaseOffset,
                       TempUlong,
                       TRUE,
                       &NextDirContext->Bcb,
                       &NextDirContext->Sector );
 
            NextDirContext->BaseOffset = (ULONG) CurrentBaseOffset;
            NextDirContext->SectorOffset = 0;
            NextDirContext->DataLength = TempUlong;
        }
 
        //
        //  The CDFS spec allows for sectors in a directory to contain all zeroes.
        //  In this case we need to move to the next sector.  So look at the
        //  current potential dirent for a zero length.  Move to the next
        //  dirent if length is zero.
        //
 
        if (*((PCHAR) CdRawDirent( IrpContext, NextDirContext )) != 0) {
 
            FoundDirent = TRUE;
            break;
        }
 
        CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
        CdUnpinData( IrpContext, &NextDirContext->Bcb );
    }
 
    //
    //  Check the dirent bounds if we found a dirent.
    //
 
    if (FoundDirent) {
 
        NextDirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
                                                                   NextDirContext );
    }
 
    return FoundDirent;
}

Referenced by _Requires_lock_held_(), CdInitializeFcbFromFileContext(), CdLookupLastFileDirent(), and CdLookupNextInitialFileDirent().

CdLookupNextInitialFileDirent()

BOOLEAN CdLookupNextInitialFileDirent	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_Inout_ PFILE_ENUM_CONTEXT	FileContext
	)

Definition at line 1275 of file dirsup.c.

{
    PRAW_DIRENT RawDirent;
 
    PDIRENT_ENUM_CONTEXT CurrentDirContext;
    PDIRENT_ENUM_CONTEXT TargetDirContext;
    PCOMPOUND_DIRENT TempDirent;
 
    BOOLEAN FoundDirent = FALSE;
    BOOLEAN FoundLastDirent;
 
    PAGED_CODE();
 
    //
    //  Start by saving the initial dirent of the current file as the
    //  previous file.
    //
 
    TempDirent = FileContext->PriorDirent;
    FileContext->PriorDirent = FileContext->InitialDirent;
    FileContext->InitialDirent = TempDirent;
 
    //
    //  We will use the initial dirent of the prior file unless the
    //  previous search returned multiple extents.
    //
 
    CurrentDirContext = &FileContext->PriorDirent->DirContext;
 
    if (FlagOn( FileContext->Flags, FILE_CONTEXT_MULTIPLE_DIRENTS )) {
 
        CurrentDirContext = &FileContext->CurrentDirent->DirContext;
    }
 
    //
    //  Clear all of the flags and file size for the next file.
    //
 
    FileContext->Flags = 0;
    FileContext->FileSize = 0;
 
    FileContext->ShortName.FileName.Length = 0;
 
    //
    //  We always want to store the result into the updated initial dirent
    //  context.
    //
 
    TargetDirContext = &FileContext->InitialDirent->DirContext;
 
    //
    //  Loop until we find the first dirent after the last dirent of the
    //  current file.  We may not be at the last dirent for the current file yet
    //  so we may walk forward looking for the last and then find the
    //  initial dirent for the next file after that.
    //
 
    while (TRUE) {
 
        //
        //  Remember if the last dirent we visited was the last dirent for
        //  a file.
        //
 
        RawDirent = CdRawDirent( IrpContext, CurrentDirContext );
 
        FoundLastDirent = !FlagOn( CdRawDirentFlags( IrpContext, RawDirent ), CD_ATTRIBUTE_MULTI );
 
        //
        //  Try to find another dirent.
        //
 
        FoundDirent = CdLookupNextDirent( IrpContext,
                                          Fcb,
                                          CurrentDirContext,
                                          TargetDirContext );
 
        //
        //  Exit the loop if no entry found.
        //
 
        if (!FoundDirent) {
 
            break;
 
        }
 
        //
        //  Update the in-memory dirent.
        //
 
        CdUpdateDirentFromRawDirent( IrpContext,
                                     Fcb,
                                     TargetDirContext,
                                     &FileContext->InitialDirent->Dirent );
 
        //
        //  Exit the loop if we had the end for the previous file.
        //
 
        if (FoundLastDirent) {
 
            break;
        }
 
        //
        //  Always use a single dirent from this point on.
        //
 
        CurrentDirContext = TargetDirContext;
    }
 
    return FoundDirent;
}

Referenced by _Requires_lock_held_(), _Success_(), CdEnumerateIndex(), CdFindDirectory(), and CdInitializeEnumeration().

CdLookupNextPathEntry()

BOOLEAN CdLookupNextPathEntry	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PPATH_ENUM_CONTEXT	PathContext,
		_Inout_ PPATH_ENTRY	PathEntry
	)

Definition at line 207 of file pathsup.c.

{
    LONGLONG CurrentBaseOffset;
 
    PAGED_CODE();
 
    //
    //  Get the offset of the next path entry within the current
    //  data block.
    //
 
    PathContext->DataOffset += PathEntry->PathEntryLength;
 
    //
    //  If we are in the last data block then check if we are beyond the
    //  end of the file.
    //
 
    if (PathContext->LastDataBlock) {
 
        if (PathContext->DataOffset >= PathContext->DataLength) {
 
            return FALSE;
        }
 
    //
    //  If we are not in the last data block of the path table and
    //  this offset is in the second sector then move to the next
    //  data block.
    //
 
    } else if (PathContext->DataOffset >= SECTOR_SIZE) {
 
        CurrentBaseOffset = PathContext->BaseOffset + SECTOR_SIZE;
 
        CdMapPathTableBlock( IrpContext,
                             IrpContext->Vcb->PathTableFcb,
                             CurrentBaseOffset,
                             PathContext );
 
        //
        //  Set up our current offset into the Path Context.
        //
 
        PathContext->DataOffset -= SECTOR_SIZE;
    }
 
    //
    //  Now update the path entry with the values from the on-disk
    //  structure.
    //
 
    return CdUpdatePathEntryFromRawPathEntry( IrpContext,
                                              PathEntry->Ordinal + 1,
                                              TRUE,
                                              PathContext,
                                              PathEntry );
}

Referenced by _Requires_lock_held_().

CdLookupPathEntry()

VOID CdLookupPathEntry	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	PathEntryOffset,
		_In_ ULONG	Ordinal,
		_In_ BOOLEAN	VerifyBounds,
		_Inout_ PCOMPOUND_PATH_ENTRY	CompoundPathEntry
	)

Referenced by _Requires_lock_held_().

CdMarkDevForVerifyIfVcbMounted()

BOOLEAN CdMarkDevForVerifyIfVcbMounted

(

_Inout_ PVCB

Vcb

)

Definition at line 359 of file verfysup.c.

{
    BOOLEAN Marked = FALSE;
    KIRQL SavedIrql;
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
#ifdef _MSC_VER
#pragma prefast(suppress: 28175, "this is a filesystem driver, touching the vpb is allowed")
#endif
    if (Vcb->Vpb->RealDevice->Vpb == Vcb->Vpb)  {
 
        CdMarkRealDevForVerify( Vcb->Vpb->RealDevice);
        Marked = TRUE;
    }
    else {
 
        //
        //  Flag this to avoid the VPB spinlock in future passes.
        //
 
        SetFlag( Vcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE);
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Marked;
}

Referenced by _Requires_lock_held_(), and CdVerifyVcb().

CdNoopAcquire()

BOOLEAN NTAPI CdNoopAcquire	(	_In_ PVOID	Fcb,
		_In_ BOOLEAN	Wait
	)

Definition at line 218 of file resrcsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Fcb );
    UNREFERENCED_PARAMETER( Wait );
 
    return TRUE;
}

Referenced by CdInitializeGlobalData().

CdNoopRelease()

VOID NTAPI CdNoopRelease

(

_In_ PVOID

Fcb

)

Definition at line 254 of file resrcsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Fcb );
}

Referenced by CdInitializeGlobalData().

CdOperationIsDasdOpen()

static INLINE BOOLEAN CdOperationIsDasdOpen ( _In_ PIRP_CONTEXT  IrpContext )

static

Definition at line 1392 of file cdprocs.h.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->Irp);
 
    return ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
            (IrpSp->FileObject->FileName.Length == 0) &&
            (IrpSp->FileObject->RelatedFileObject == NULL));
}

Referenced by _Requires_lock_held_().

CdPerformDevIoCtrl()

NTSTATUS FASTCALL CdPerformDevIoCtrl	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	IoControlCode,
		_In_ PDEVICE_OBJECT	Device,
		_Out_writes_bytes_opt_(OutputBufferLength) PVOID	OutputBuffer,
		_In_ ULONG	OutputBufferLength,
		_In_ BOOLEAN	InternalDeviceIoControl,
		_In_ BOOLEAN	OverrideVerify,
		_Out_opt_ PIO_STATUS_BLOCK	Iosb
	)

Definition at line 1446 of file deviosup.c.

{
    PAGED_CODE();
 
    return CdPerformDevIoCtrlEx( IrpContext,
                                 IoControlCode,
                                 Device,
                                 NULL,
                                 0,
                                 OutputBuffer,
                                 OutputBufferLength,
                                 InternalDeviceIoControl,
                                 OverrideVerify,
                                 Iosb);
}

Referenced by _Success_(), and CdVerifyVcb().

CdPerformDevIoCtrlEx()

NTSTATUS CdPerformDevIoCtrlEx	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	IoControlCode,
		_In_ PDEVICE_OBJECT	Device,
		_In_reads_bytes_opt_(InputBufferLength) PVOID	InputBuffer,
		_In_ ULONG	InputBufferLength,
		_Out_writes_bytes_opt_(OutputBufferLength) PVOID	OutputBuffer,
		_In_ ULONG	OutputBufferLength,
		_In_ BOOLEAN	InternalDeviceIoControl,
		_In_ BOOLEAN	OverrideVerify,
		_Out_opt_ PIO_STATUS_BLOCK	Iosb
	)

Definition at line 1329 of file deviosup.c.

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

Referenced by CdPerformDevIoCtrl(), and CdProcessToc().

CdProcessToc()

NTSTATUS CdProcessToc	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PDEVICE_OBJECT	TargetDeviceObject,
		_In_ PCDROM_TOC_LARGE	CdromToc,
		_Inout_ PULONG	Length,
		_Out_ PULONG	TrackCount,
		_Inout_ PULONG	DiskFlags
	)

Definition at line 2201 of file strucsup.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
    CDROM_READ_TOC_EX Command;
 
    ULONG CurrentTrack;
    ULONG LocalTrackCount;
    ULONG LocalTocLength;
    ULONG Address = 0;
    BOOLEAN UseReadToc = FALSE;
 
    union {
 
        UCHAR BigEndian[2];
        USHORT Length;
 
    } BiasedTocLength;
 
    PTRACK_DATA Track;
 
    PAGED_CODE();
 
    //
    //  Zero the command block.  This conveniently corresponds to an
    //  LBA mode READ_TOC request.
    //
 
    RtlZeroMemory( &Command, sizeof( Command));
 
RetryReadToc:
 
    //
    //  Go ahead and read the table of contents
    //
 
    Status = CdPerformDevIoCtrlEx( IrpContext,
                                   UseReadToc ? IOCTL_CDROM_READ_TOC : IOCTL_CDROM_READ_TOC_EX,
                                   TargetDeviceObject,
                                   &Command,
                                   sizeof( Command ),
                                   CdromToc,
                                   sizeof( CDROM_TOC_LARGE ),
                                   FALSE,
                                   TRUE,
                                   &Iosb );
 
    //
    //  Nothing to process if this request fails.
    //
 
    if (!NT_SUCCESS( Status )) {
 
        //
        //  If the underlying device does not support READ_TOC_EX, try the old method.
        //
 
        if (!UseReadToc &&
            ((Status == STATUS_INVALID_DEVICE_REQUEST) ||
             (Status == STATUS_NOT_IMPLEMENTED) || /* ReactOS Change: we return STATUS_NOT_IMPLEMENTED for IOCTL_CDROM_READ_TOC_EX */
             (Status == STATUS_INVALID_PARAMETER))) {
 
            UseReadToc = TRUE;
            goto RetryReadToc;
        }
 
        return Status;
    }
 
    //
    //  Get the number of tracks and stated size of this structure.
    //
 
    CurrentTrack = 0;
    LocalTrackCount = CdromToc->LastTrack - CdromToc->FirstTrack + 1;
    LocalTocLength = PtrOffset( CdromToc, &CdromToc->TrackData[LocalTrackCount + 1] );
 
    //
    //  Get out if there is an immediate problem with the TOC.
    //
 
    if ((LocalTocLength > Iosb.Information) ||
        (CdromToc->FirstTrack > CdromToc->LastTrack)) {
 
        Status = STATUS_DISK_CORRUPT_ERROR;
        return Status;
    }
 
    //
    //  Walk through the individual tracks.  Stop at the first data track after
    //  any lead-in audio tracks.
    //
 
    do {
 
        //
        //  Get the next track.
        //
 
        Track = &CdromToc->TrackData[CurrentTrack];
 
        //
        //  If this is a data track then check if we have only seen audio tracks
        //  to this point.
        //
 
        if (FlagOn( Track->Control, TOC_DATA_TRACK )) {
 
            //
            //  If we have only seen audio tracks then assume this is a
            //  CD+ disk.  Hide the current data track and only return
            //  the previous audio tracks.  Set the disk type to be mixed
            //  data/audio.
            //
 
            if (FlagOn( *DiskFlags, CDROM_DISK_AUDIO_TRACK ) &&
                !FlagOn( *DiskFlags, CDROM_DISK_DATA_TRACK )) {
 
                //
                //  Remove one track from the TOC.
                //
 
                CdromToc->LastTrack -= 1;
 
                //
                //  Knock 2.5 minutes off the current track to hide the final leadin.
                //  2.5 min = 150 sec = (x 75) 11250 frames (sectors).
                //
 
                SwapCopyUchar4( &Address, &Track->Address);
                Address -= 11250;
                SwapCopyUchar4( &Track->Address, &Address);
 
                Track->TrackNumber = TOC_LAST_TRACK;
 
                //
                //  Set the disk type to mixed data/audio.
                //
 
                SetFlag( *DiskFlags, CDROM_DISK_DATA_TRACK );
 
                break;
            }
 
            //
            //  Set the flag to indicate data tracks present.
            //
 
            SetFlag( *DiskFlags, CDROM_DISK_DATA_TRACK );
 
        //
        //  If this is a audio track then set the flag indicating audio
        //  tracks.
        //
 
        } else {
 
            SetFlag( *DiskFlags, CDROM_DISK_AUDIO_TRACK );
        }
 
        //
        //  Set our index for the next track.
        //
 
        CurrentTrack += 1;
 
    } while (CurrentTrack < LocalTrackCount);
 
    //
    //  Set the length to point just past the last track we looked at.
    //
 
    *TrackCount = CurrentTrack;
    *Length = PtrOffset( CdromToc, &CdromToc->TrackData[CurrentTrack + 1] );
    BiasedTocLength.Length = (USHORT) *Length - 2;
 
    CdromToc->Length[0] = BiasedTocLength.BigEndian[1];
    CdromToc->Length[1] = BiasedTocLength.BigEndian[0];
 
    return Status;
}

CdRaiseStatusEx()

INLINE DECLSPEC_NORETURN VOID CdRaiseStatusEx	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ NTSTATUS	Status,
		_In_ BOOLEAN	NormalizeStatus,
		_In_ ULONG	Fileid,
		_In_ ULONG	Line
	)

Definition at line 1835 of file cdprocs.h.

{
    if (NormalizeStatus)  {
 
        IrpContext->ExceptionStatus = FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR);
    }
    else {
 
        IrpContext->ExceptionStatus = Status;
    }
 
    IrpContext->RaisedAtLineFile = (Fileid << 16) | Line;
 
    ExRaiseStatus( IrpContext->ExceptionStatus );
}

CdReadSectors()

BOOLEAN CdReadSectors	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ LONGLONG	StartingOffset,
		_In_ ULONG	ByteCount,
		_In_ BOOLEAN	ReturnError,
		_Out_writes_bytes_(ByteCount) PVOID	Buffer,
		_In_ PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 1080 of file deviosup.c.

{
    NTSTATUS Status;
    KEVENT  Event;
    PIRP Irp;
 
    PAGED_CODE();
 
    //
    //  Initialize the event.
    //
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    //
    //  Attempt to allocate the IRP.  If unsuccessful, raise
    //  STATUS_INSUFFICIENT_RESOURCES.
    //
 
    Irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ,
                                        TargetDeviceObject,
                                        Buffer,
                                        ByteCount,
                                        (PLARGE_INTEGER) &StartingOffset,
                                        &Event,
                                        &IrpContext->Irp->IoStatus );
 
    if (Irp == NULL) {
 
        CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
    }
 
    //
    //  Ignore the change line (verify) for mount and verify requests
    //
 
    SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
    //
    //  Send the request down to the driver.  If an error occurs return
    //  it to the caller.
    //
 
    Status = IoCallDriver( TargetDeviceObject, Irp );
 
    //
    //  If the status was STATUS_PENDING then wait on the event.
    //
 
    if (Status == STATUS_PENDING) {
 
        Status = KeWaitForSingleObject( &Event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL );
 
        //
        //  On a successful wait pull the status out of the IoStatus block.
        //
 
        if (NT_SUCCESS( Status )) {
 
            Status = IrpContext->Irp->IoStatus.Status;
        }
    }
 
    //
    //  Check whether we should raise in the error case.
    //
 
    if (!NT_SUCCESS( Status )) {
 
        if (!ReturnError) {
 
            CdNormalizeAndRaiseStatus( IrpContext, Status );
        }
 
        //
        //  We don't raise, but return FALSE to indicate an error.
        //
 
        return FALSE;
 
    //
    //  The operation completed successfully.
    //
 
    } else {
 
        return TRUE;
    }
}

Referenced by _Success_(), and CdFindActiveVolDescriptor().

CdRemovePrefix()

VOID CdRemovePrefix	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb
	)

Definition at line 207 of file prefxsup.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Start with the short name prefix entry.
    //
 
    if (Fcb->ShortNamePrefix != NULL) {
 
        if (FlagOn( Fcb->ShortNamePrefix->PrefixFlags, PREFIX_FLAG_IGNORE_CASE_IN_TREE )) {
 
            Fcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Fcb->ShortNamePrefix->IgnoreCaseName.Links );
        }
 
        if (FlagOn( Fcb->ShortNamePrefix->PrefixFlags, PREFIX_FLAG_EXACT_CASE_IN_TREE )) {
 
            Fcb->ParentFcb->ExactCaseRoot = RtlDelete( &Fcb->ShortNamePrefix->ExactCaseName.Links );
        }
 
        ClearFlag( Fcb->ShortNamePrefix->PrefixFlags,
                   PREFIX_FLAG_IGNORE_CASE_IN_TREE | PREFIX_FLAG_EXACT_CASE_IN_TREE );
    }
 
    //
    //  Now do the long name prefix entries.
    //
 
    if (FlagOn( Fcb->FileNamePrefix.PrefixFlags, PREFIX_FLAG_IGNORE_CASE_IN_TREE )) {
 
        Fcb->ParentFcb->IgnoreCaseRoot = RtlDelete( &Fcb->FileNamePrefix.IgnoreCaseName.Links );
    }
 
    if (FlagOn( Fcb->FileNamePrefix.PrefixFlags, PREFIX_FLAG_EXACT_CASE_IN_TREE )) {
 
        Fcb->ParentFcb->ExactCaseRoot = RtlDelete( &Fcb->FileNamePrefix.ExactCaseName.Links );
    }
 
    ClearFlag( Fcb->FileNamePrefix.PrefixFlags,
               PREFIX_FLAG_IGNORE_CASE_IN_TREE | PREFIX_FLAG_EXACT_CASE_IN_TREE );
 
    //
    //  Deallocate any buffer we may have allocated.
    //
 
    if ((Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer != (PWCHAR) &Fcb->FileNamePrefix.FileNameBuffer) &&
        (Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer != NULL)) {
 
        CdFreePool( &Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer );
        Fcb->FileNamePrefix.ExactCaseName.FileName.Buffer = NULL;
    }
 
    return;
}

Referenced by _Requires_lock_held_().

CdSerial32()

ULONG CdSerial32	(	_In_reads_bytes_(ByteCount) PCHAR	Buffer,
		_In_ ULONG	ByteCount
	)

Definition at line 1185 of file cddata.c.

{
    union {
        UCHAR   Bytes[4];
        ULONG   SerialId;
    } Checksum;
 
    PAGED_CODE();
 
    //
    //  Initialize the serial number.
    //
 
    Checksum.SerialId = 0;
 
    //
    //  Continue while there are more bytes to use.
    //
 
    while (ByteCount--) {
 
        //
        //  Increment this sub-checksum.
        //
 
        Checksum.Bytes[ByteCount & 0x3] += *(Buffer++);
    }
 
    //
    //  Return the checksums as a ULONG.
    //
 
    return Checksum.SerialId;
}

Referenced by CdFindActiveVolDescriptor().

CdSetThreadContext()

VOID CdSetThreadContext	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_In_ PTHREAD_CONTEXT	ThreadContext
	)

Definition at line 981 of file cddata.c.

{
    PTHREAD_CONTEXT CurrentThreadContext;
#ifdef __REACTOS__
    ULONG_PTR StackTop;
    ULONG_PTR StackBottom;
#endif
 
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
 
    //
    //  Get the current top-level irp out of the thread storage.
    //  If NULL then this is the top-level request.
    //
 
    CurrentThreadContext = (PTHREAD_CONTEXT) IoGetTopLevelIrp();
 
    if (CurrentThreadContext == NULL) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL );
    }
 
    //
    //  Initialize the input context unless we are using the current
    //  thread context block.  We use the new block if our caller
    //  specified this or the existing block is invalid.
    //
    //  The following must be true for the current to be a valid Cdfs context.
    //
    //      Structure must lie within current stack.
    //      Address must be ULONG aligned.
    //      Cdfs signature must be present.
    //
    //  If this is not a valid Cdfs context then use the input thread
    //  context and store it in the top level context.
    //
 
#ifdef __REACTOS__
    IoGetStackLimits( &StackTop, &StackBottom);
#endif
 
#ifdef _MSC_VER
#pragma warning(suppress: 6011) // Bug in PREFast around bitflag operations
#endif
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) ||
#ifndef __REACTOS__
        (!IoWithinStackLimits( (ULONG_PTR)CurrentThreadContext, sizeof( THREAD_CONTEXT ) ) ||
#else
        (((ULONG_PTR) CurrentThreadContext > StackBottom - sizeof( THREAD_CONTEXT )) ||
         ((ULONG_PTR) CurrentThreadContext <= StackTop) ||
#endif
         FlagOn( (ULONG_PTR) CurrentThreadContext, 0x3 ) ||
         (CurrentThreadContext->Cdfs != 0x53464443))) {
 
        ThreadContext->Cdfs = 0x53464443;
        ThreadContext->SavedTopLevelIrp = (PIRP) CurrentThreadContext;
        ThreadContext->TopLevelIrpContext = IrpContext;
        IoSetTopLevelIrp( (PIRP) ThreadContext );
 
        IrpContext->TopLevel = IrpContext;
        IrpContext->ThreadContext = ThreadContext;
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS );
 
    //
    //  Otherwise use the IrpContext in the thread context.
    //
 
    } else {
 
        IrpContext->TopLevel = CurrentThreadContext->TopLevelIrpContext;
    }
 
    return;
}

Referenced by _IRQL_requires_max_(), and CdFspDispatch().

CdShortNameDirentOffset()

ULONG CdShortNameDirentOffset	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PUNICODE_STRING	Name
	)

Definition at line 955 of file namesup.c.

{
    ULONG ResultOffset = MAXULONG;
    ULONG RemainingByteCount = Name->Length;
 
    BOOLEAN FoundTilde = FALSE;
 
    PWCHAR NextWchar;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Walk through the name until we either reach the end of the name
    //  or find a tilde character.
    //
 
    for (NextWchar = Name->Buffer;
         RemainingByteCount != 0;
         NextWchar += 1, RemainingByteCount -= sizeof( WCHAR )) {
 
        //
        //  Check if this is a dot.  Stop constructing any string if
        //  we found a dot.
        //
 
        if (*NextWchar == L'.') {
 
            break;
        }
 
        //
        //  If we already found a tilde then check this character as a
        //  valid character.  It must be a digit or A to F.
        //
 
        if (FoundTilde) {
 
            if ((*NextWchar < L'0') ||
                (*NextWchar > L'F') ||
                ((*NextWchar > L'9') && (*NextWchar < 'A'))) {
 
                ResultOffset = MAXULONG;
                break;
            }
 
            //
            //  Shift the result by 4 bits and add in this new character.
            //
 
            ResultOffset <<= 4;
 
            if (*NextWchar < L'A') {
 
                ResultOffset += *NextWchar - L'0';
 
            } else {
 
                ResultOffset += (*NextWchar - L'A') + 10;
            }
 
            continue;
        }
 
        //
        //  If this is a tilde then start building the dirent string.
        //
 
        if (*NextWchar == L'~') {
 
            FoundTilde = TRUE;
            ResultOffset = 0;
        }
    }
 
    return ResultOffset;
}

Referenced by _Success_().

CdTruncateAllocation()

VOID CdTruncateAllocation	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PFCB	Fcb,
		_In_ LONGLONG	StartingFileOffset
	)

Definition at line 575 of file allocsup.c.

{
    ULONG McbEntryOffset;
 
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
    ASSERT_LOCKED_FCB( Fcb );
 
    //
    //  Find the entry containg this starting offset.
    //
 
    McbEntryOffset = CdFindMcbEntry( IrpContext, Fcb, StartingFileOffset );
 
    //
    //  Now set the current size of the mcb to this point.
    //
 
    Fcb->Mcb.CurrentEntryCount = McbEntryOffset;
 
    return;
}

Referenced by CdCreateInternalStream().

CdUnlockVolumeInternal()

NTSTATUS CdUnlockVolumeInternal	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb,
		_In_opt_ PFILE_OBJECT	FileObject
	)

Definition at line 288 of file fsctrl.c.

{
    NTSTATUS Status = STATUS_NOT_LOCKED;
    KIRQL SavedIrql;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Note that we check the VPB_LOCKED flag here rather than the Vcb
    //  lock flag.  The Vpb flag is only set for an explicit lock request,  not
    //  for the implicit lock obtained on a volume open with zero share mode.
    //
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
    if (FlagOn(Vcb->Vpb->Flags, VPB_LOCKED) &&
        (FileObject == Vcb->VolumeLockFileObject))  {
 
        ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
        ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED);
        Vcb->VolumeLockFileObject = NULL;
        Status = STATUS_SUCCESS;
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Status;
}

CdUpcaseName()

VOID CdUpcaseName	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PCD_NAME	Name,
		_Inout_ PCD_NAME	UpcaseName
	)

Definition at line 194 of file namesup.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If the name structures are different then initialize the different components.
    //
 
    if (Name != UpcaseName) {
 
        //
        //  Initialize the version string portion of the name.
        //
 
        UpcaseName->VersionString.Length = 0;
 
        if (Name->VersionString.Length != 0) {
 
            UpcaseName->VersionString.MaximumLength =
            UpcaseName->VersionString.Length = Name->VersionString.Length;
 
            //
            //  Initially set the buffer to point to where we need to insert
            //  the separator.
            //
 
            UpcaseName->VersionString.Buffer = Add2Ptr( UpcaseName->FileName.Buffer,
                                                        Name->FileName.Length,
                                                        PWCHAR );
 
            //
            //  We are currently pointing to the location to store the separator.
            //  Store the ';' and then move to the next character to
            //  copy the data.
            //
 
#ifdef _MSC_VER
#pragma prefast( suppress:26015, "CD_NAME structures have two UNICODE_STRING structures pointing to the same allocation. there is no way to tell prefast this is the case and that the allocation is always big enough.");
#endif
            *(UpcaseName->VersionString.Buffer) = L';';
 
            UpcaseName->VersionString.Buffer += 1;
        }
    }
 
    //
    //  Upcase the string using the correct upcase routine.
    //
 
    Status = RtlUpcaseUnicodeString( &UpcaseName->FileName,
                                     &Name->FileName,
                                     FALSE );
 
    //
    //  This should never fail.
    //
 
    NT_ASSERT( Status == STATUS_SUCCESS );
    __analysis_assert( Status == STATUS_SUCCESS );
 
    if (Name->VersionString.Length != 0) {
 
        Status = RtlUpcaseUnicodeString( &UpcaseName->VersionString,
                                         &Name->VersionString,
                                         FALSE );
 
        //
        //  This should never fail.
        //
 
        NT_ASSERT( Status == STATUS_SUCCESS );
        __analysis_assert( Status == STATUS_SUCCESS );
    }
 
    return;
}

Referenced by CdUpdateDirentName(), and CdUpdatePathEntryName().

CdUpdateDirentName()

VOID CdUpdateDirentName	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PDIRENT	Dirent,
		_In_ ULONG	IgnoreCase
	)

Definition at line 534 of file dirsup.c.

{
    UCHAR DirectoryValue;
    ULONG Length;
 
    NTSTATUS Status;
 
    PAGED_CODE();
 
    //
    //  Check if this is a self or parent entry.  There is no version number
    //  in these cases.  We use a fixed string for these.
    //
    //      Self-Entry - Length is 1, value is 0.
    //      Parent-Entry - Length is 1, value is 1.
    //
 
    if ((Dirent->FileNameLen == 1) &&
        FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
 
        DirectoryValue = *((PCHAR) Dirent->FileName);
 
        if ((DirectoryValue == 0) || (DirectoryValue == 1)) {
 
            //
            //  We should not have allocated a name by the time we see these cases.
            //  If we have, this means that the image is in violation of ISO 9660 7.6.2,
            //  which states that the ./.. entries must be the first two in the directory.
            //
 
            if (FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER )) {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
            }
 
            //
            //  Now use one of the hard coded directory names.
            //
 
            Dirent->CdFileName.FileName = CdUnicodeDirectoryNames[DirectoryValue];
 
            //
            //  Show that there is no version number.
            //
 
            Dirent->CdFileName.VersionString.Length = 0;
 
            //
            //  The case name is the same as the exact name.
            //
 
            Dirent->CdCaseFileName = Dirent->CdFileName;
 
            //
            //  Mark this as a constant value entry.
            //
 
            SetFlag( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY );
 
            //
            //  Return now.
            //
 
            return;
        }
    }
 
    //
    //  Mark this as a non-constant value entry.
    //
 
    ClearFlag( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY );
 
    //
    //  Compute how large a buffer we will need.  If this is an ignore
    //  case operation then we will want a double size buffer.  If the disk is not
    //  a Joliet disk then we might need two bytes for each byte in the name.
    //
 
    Length = Dirent->FileNameLen;
 
    if (IgnoreCase) {
 
        Length *= 2;
    }
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Length *= sizeof( WCHAR );
    }
 
    //
    //  Now decide if we need to allocate a new buffer.  We will if
    //  this name won't fit in the embedded name buffer and it is
    //  larger than the current allocated buffer.  We always use the
    //  allocated buffer if present.
    //
    //  If we haven't allocated a buffer then use the embedded buffer if the data
    //  will fit.  This is the typical case.
    //
 
    if (!FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER ) &&
        (Length <= sizeof( Dirent->NameBuffer ))) {
 
        Dirent->CdFileName.FileName.MaximumLength = sizeof( Dirent->NameBuffer );
        Dirent->CdFileName.FileName.Buffer = Dirent->NameBuffer;
 
    } else {
 
        //
        //  We need to use an allocated buffer.  Check if the current buffer
        //  is large enough.
        //
 
        if (Length > Dirent->CdFileName.FileName.MaximumLength) {
 
            //
            //  Free any allocated buffer.
            //
 
            if (FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER )) {
 
                CdFreePool( &Dirent->CdFileName.FileName.Buffer );
                ClearFlag( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER );
            }
 
            Dirent->CdFileName.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                                            Length,
                                                                            TAG_DIRENT_NAME );
 
            SetFlag( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER );
 
            Dirent->CdFileName.FileName.MaximumLength = (USHORT) Length;
        }
    }
 
    //
    //  We now have a buffer for the name.  We need to either convert the on-disk bigendian
    //  to little endian or covert the name to Unicode.
    //
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Status = RtlOemToUnicodeN( Dirent->CdFileName.FileName.Buffer,
                                   Dirent->CdFileName.FileName.MaximumLength,
                                   &Length,
                                   Dirent->FileName,
                                   Dirent->FileNameLen );
 
        __analysis_assert( Status == STATUS_SUCCESS );
        NT_ASSERT( Status == STATUS_SUCCESS );
        Dirent->CdFileName.FileName.Length = (USHORT) Length;
 
    } else {
 
        //
        //  Convert this string to little endian.
        //
 
        CdConvertBigToLittleEndian( IrpContext,
                                    Dirent->FileName,
                                    Dirent->FileNameLen,
                                    (PCHAR) Dirent->CdFileName.FileName.Buffer );
 
        Dirent->CdFileName.FileName.Length = (USHORT) Dirent->FileNameLen;
    }
 
    //
    //  Split the name into name and version strings.
    //
 
    CdConvertNameToCdName( IrpContext,
                           &Dirent->CdFileName );
 
    //
    //  The name length better be non-zero.
    //
 
    if (Dirent->CdFileName.FileName.Length == 0) {
 
        CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
    }
 
    //
    //  If the filename ends with a period then back up one character.
    //
 
    if (Dirent->CdFileName.FileName.Buffer[(Dirent->CdFileName.FileName.Length - sizeof( WCHAR )) / 2] == L'.') {
 
        //
        //  Slide the version string down.
        //
 
        if (Dirent->CdFileName.VersionString.Length != 0) {
 
            PWCHAR NewVersion;
 
            //
            //  Start from the position currently containing the separator.
            //
 
            NewVersion = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
                                  Dirent->CdFileName.FileName.Length,
                                  PWCHAR );
 
            //
            //  Now overwrite the period.
            //
 
            RtlMoveMemory( NewVersion - 1,
                           NewVersion,
                           Dirent->CdFileName.VersionString.Length + sizeof( WCHAR ));
 
            //
            //  Now point to the new version string.
            //
 
            Dirent->CdFileName.VersionString.Buffer = NewVersion;
        }
 
        //
        //  Shrink the filename length.
        //
 
        Dirent->CdFileName.FileName.Length -= sizeof( WCHAR );
    }
 
    if (!CdIsLegalName( IrpContext, &Dirent->CdFileName.FileName )) {
 
        CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
    }
 
    //
    //  If this an exact case operation then use the filename exactly.
    //
 
    if (!IgnoreCase) {
 
        Dirent->CdCaseFileName = Dirent->CdFileName;
 
    //
    //  Otherwise perform our upcase operation.  We already have guaranteed the buffers are
    //  there.
    //
 
    } else {
 
        Dirent->CdCaseFileName.FileName.Buffer = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
                                                          Dirent->CdFileName.FileName.MaximumLength / 2,
                                                          PWCHAR);
 
        Dirent->CdCaseFileName.FileName.MaximumLength = Dirent->CdFileName.FileName.MaximumLength / 2;
 
        CdUpcaseName( IrpContext,
                      &Dirent->CdFileName,
                      &Dirent->CdCaseFileName );
    }
 
    return;
}

Referenced by _Success_(), CdCreateInternalStream(), CdEnumerateIndex(), CdFindDirectory(), CdInitializeEnumeration(), and if().

CdUpdatePathEntryName()

VOID CdUpdatePathEntryName	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PPATH_ENTRY	PathEntry,
		_In_ BOOLEAN	IgnoreCase
	)

Definition at line 781 of file pathsup.c.

{
    ULONG Length;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    //
    //  Check if this is a self entry.  We use a fixed string for this.
    //
    //      Self-Entry - Length is 1, value is 0.
    //
 
    if ((*PathEntry->DirName == 0) &&
        (PathEntry->DirNameLen == 1)) {
 
        //
        //  There should be no allocated buffers.
        //
 
        NT_ASSERT( !FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER ));
 
        //
        //  Now use one of the hard coded directory names.
        //
 
        PathEntry->CdDirName.FileName = CdUnicodeDirectoryNames[0];
 
        //
        //  Show that there is no version number.
        //
 
        PathEntry->CdDirName.VersionString.Length = 0;
 
        //
        //  The case name is identical.
        //
 
        PathEntry->CdCaseDirName = PathEntry->CdDirName;
 
        //
        //  Return now.
        //
 
        return;
    }
 
    //
    //  Compute how large a buffer we will need.  If this is an ignore
    //  case operation then we will want a double size buffer.  If the disk is not
    //  a Joliet disk then we might need two bytes for each byte in the name.
    //
 
    Length = PathEntry->DirNameLen;
 
    if (IgnoreCase) {
 
        Length *= 2;
    }
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Length *= sizeof( WCHAR );
    }
 
    //
    //  Now decide if we need to allocate a new buffer.  We will if
    //  this name won't fit in the embedded name buffer and it is
    //  larger than the current allocated buffer.  We always use the
    //  allocated buffer if present.
    //
    //  If we haven't allocated a buffer then use the embedded buffer if the data
    //  will fit.  This is the typical case.
    //
 
    if (!FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER ) &&
        (Length <= sizeof( PathEntry->NameBuffer ))) {
 
        PathEntry->CdDirName.FileName.MaximumLength = sizeof( PathEntry->NameBuffer );
        PathEntry->CdDirName.FileName.Buffer = PathEntry->NameBuffer;
 
    } else {
 
        //
        //  We need to use an allocated buffer.  Check if the current buffer
        //  is large enough.
        //
 
        if (Length > PathEntry->CdDirName.FileName.MaximumLength) {
 
            //
            //  Free any allocated buffer.
            //
 
            if (FlagOn( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER )) {
 
                CdFreePool( &PathEntry->CdDirName.FileName.Buffer );
                ClearFlag( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER );
            }
 
            PathEntry->CdDirName.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
                                                                             Length,
                                                                             TAG_PATH_ENTRY_NAME );
 
            SetFlag( PathEntry->Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER );
 
            PathEntry->CdDirName.FileName.MaximumLength = (USHORT) Length;
        }
    }
 
    //
    //  We now have a buffer for the name.  We need to either convert the on-disk bigendian
    //  to little endian or covert the name to Unicode.
    //
 
    if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 
        Status = RtlOemToUnicodeN( PathEntry->CdDirName.FileName.Buffer,
                                   PathEntry->CdDirName.FileName.MaximumLength,
                                   &Length,
                                   PathEntry->DirName,
                                   PathEntry->DirNameLen );
 
        NT_ASSERT( Status == STATUS_SUCCESS );
        __analysis_assert( Status == STATUS_SUCCESS );
        PathEntry->CdDirName.FileName.Length = (USHORT) Length;
 
    } else {
 
        //
        //  Convert this string to little endian.
        //
 
        CdConvertBigToLittleEndian( IrpContext,
                                    PathEntry->DirName,
                                    PathEntry->DirNameLen,
                                    (PCHAR) PathEntry->CdDirName.FileName.Buffer );
 
        PathEntry->CdDirName.FileName.Length = (USHORT) PathEntry->DirNameLen;
    }
 
    //
    //  There is no version string.
    //
 
    PathEntry->CdDirName.VersionString.Length =
    PathEntry->CdCaseDirName.VersionString.Length = 0;
 
    //
    //  If the name string ends with a period then knock off the last
    //  character.
    //
 
    if (PathEntry->CdDirName.FileName.Buffer[(PathEntry->CdDirName.FileName.Length - sizeof( WCHAR )) / 2] == L'.') {
 
        //
        //  Shrink the filename length.
        //
 
        PathEntry->CdDirName.FileName.Length -= sizeof( WCHAR );
    }
 
    //
    //  Update the case name buffer if necessary.  If this is an exact case
    //  operation then just copy the exact case string.
    //
 
    if (IgnoreCase) {
 
        PathEntry->CdCaseDirName.FileName.Buffer = Add2Ptr( PathEntry->CdDirName.FileName.Buffer,
                                                            PathEntry->CdDirName.FileName.MaximumLength / 2,
                                                            PWCHAR);
 
        PathEntry->CdCaseDirName.FileName.MaximumLength = PathEntry->CdDirName.FileName.MaximumLength / 2;
 
        CdUpcaseName( IrpContext,
                      &PathEntry->CdDirName,
                      &PathEntry->CdCaseDirName );
 
    } else {
 
        PathEntry->CdCaseDirName = PathEntry->CdDirName;
    }
 
    return;
}

CdUpdateVcbFromVolDescriptor()

VOID CdUpdateVcbFromVolDescriptor	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb,
		_In_reads_bytes_opt_(SECTOR_SIZE) PCHAR	RawIsoVd
	)

Definition at line 436 of file strucsup.c.

{
    ULONG StartingBlock;
    ULONG ByteCount;
 
    LONGLONG FileId = 0;
 
    PRAW_DIRENT RawDirent;
    PATH_ENTRY PathEntry;
    PCD_MCB_ENTRY McbEntry;
 
    BOOLEAN UnlockVcb = FALSE;
 
    PAGED_CODE();
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Copy the block size and compute the various block masks.
        //  Block size must not be larger than the sector size.  We will
        //  use a default of the CD physical sector size if we are not
        //  on a data-full disc.
        //
        //  This must always be set.
        //
 
        Vcb->BlockSize = ( ARGUMENT_PRESENT( RawIsoVd ) ?
                            CdRvdBlkSz( RawIsoVd, Vcb->VcbState ) :
                            SECTOR_SIZE );
 
        //
        //  We no longer accept media where blocksize != sector size.
        //
 
        if (Vcb->BlockSize != SECTOR_SIZE)  {
 
            CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
        }
 
        Vcb->BlocksPerSector = SECTOR_SIZE / Vcb->BlockSize;
        Vcb->BlockMask = Vcb->BlockSize - 1;
        Vcb->BlockInverseMask = ~Vcb->BlockMask;
 
        Vcb->BlockToSectorShift = 0;
        Vcb->BlockToByteShift = SECTOR_SHIFT;
 
        //
        //  If there is a volume descriptor then do the internal Fcb's and
        //  other Vcb fields.
        //
 
        if (ARGUMENT_PRESENT( RawIsoVd )) {
 
            //
            //  Create the path table Fcb and refererence it and the Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
 
            Vcb->PathTableFcb = CdCreateFcb( IrpContext,
                                             *((PFILE_ID) &FileId),
                                             CDFS_NTC_FCB_PATH_TABLE,
                                             NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->PathTableFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  Compute the stream offset and size of this path table.
            //
 
            StartingBlock = CdRvdPtLoc( RawIsoVd, Vcb->VcbState );
 
            ByteCount = CdRvdPtSz( RawIsoVd, Vcb->VcbState );
 
            Vcb->PathTableFcb->StreamOffset = BytesFromBlocks( Vcb,
                                                               SectorBlockOffset( Vcb, StartingBlock ));
 
            Vcb->PathTableFcb->FileSize.QuadPart = (LONGLONG) (Vcb->PathTableFcb->StreamOffset +
                                                               ByteCount);
 
            Vcb->PathTableFcb->ValidDataLength.QuadPart = Vcb->PathTableFcb->FileSize.QuadPart;
 
            Vcb->PathTableFcb->AllocationSize.QuadPart = LlSectorAlign( Vcb->PathTableFcb->FileSize.QuadPart );
 
            //
            //  Now add the mapping information.
            //
 
            CdLockFcb( IrpContext, Vcb->PathTableFcb );
 
            CdAddInitialAllocation( IrpContext,
                                    Vcb->PathTableFcb,
                                    StartingBlock,
                                    Vcb->PathTableFcb->AllocationSize.QuadPart );
 
            CdUnlockFcb( IrpContext, Vcb->PathTableFcb );
 
            //
            //  Point to the file resource.
            //
 
            Vcb->PathTableFcb->Resource = &Vcb->FileResource;
 
            //
            //  Mark the Fcb as initialized and create the stream file for this.
            //
 
            SetFlag( Vcb->PathTableFcb->FcbState, FCB_STATE_INITIALIZED );
 
            CdCreateInternalStream( IrpContext, Vcb, Vcb->PathTableFcb, &CdInternalStreamNames[0]);
 
            //
            //  Create the root index and reference it in the Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
            Vcb->RootIndexFcb = CdCreateFcb( IrpContext,
                                             *((PFILE_ID) &FileId),
                                             CDFS_NTC_FCB_INDEX,
                                             NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->RootIndexFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  Create the File id by hand for this Fcb.
            //
 
            CdSetFidPathTableOffset( Vcb->RootIndexFcb->FileId, Vcb->PathTableFcb->StreamOffset );
            CdFidSetDirectory( Vcb->RootIndexFcb->FileId );
 
            //
            //  Create a pseudo path table entry so we can call the initialization
            //  routine for the directory.
            //
 
            RawDirent = (PRAW_DIRENT) CdRvdDirent( RawIsoVd, Vcb->VcbState );
 
            CopyUchar4( &PathEntry.DiskOffset, RawDirent->FileLoc );
 
            PathEntry.DiskOffset += RawDirent->XarLen;
            PathEntry.Ordinal = 1;
            PathEntry.PathTableOffset = Vcb->PathTableFcb->StreamOffset;
 
            CdInitializeFcbFromPathEntry( IrpContext,
                                          Vcb->RootIndexFcb,
                                          NULL,
                                          &PathEntry );
 
            //
            //  Create the stream file for the root directory.
            //
 
            CdCreateInternalStream( IrpContext, Vcb, Vcb->RootIndexFcb, &CdInternalStreamNames[1] );
 
            //
            //  Now do the volume dasd Fcb.  Create this and reference it in the
            //  Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
 
            Vcb->VolumeDasdFcb = CdCreateFcb( IrpContext,
                                              *((PFILE_ID) &FileId),
                                              CDFS_NTC_FCB_DATA,
                                              NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->VolumeDasdFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  The file size is the full disk.
            //
 
            StartingBlock = CdRvdVolSz( RawIsoVd, Vcb->VcbState );
 
            Vcb->VolumeDasdFcb->FileSize.QuadPart = LlBytesFromBlocks( Vcb, StartingBlock );
 
            Vcb->VolumeDasdFcb->AllocationSize.QuadPart =
            Vcb->VolumeDasdFcb->ValidDataLength.QuadPart = Vcb->VolumeDasdFcb->FileSize.QuadPart;
 
            //
            //  Now add the extent representing the volume 'by hand'.
            //
 
            CdLockFcb( IrpContext, Vcb->VolumeDasdFcb );
 
            McbEntry = Vcb->VolumeDasdFcb->Mcb.McbArray;
 
            McbEntry->FileOffset =
            McbEntry->DiskOffset = 0;
 
            McbEntry->ByteCount = Vcb->VolumeDasdFcb->AllocationSize.QuadPart;
 
            McbEntry->DataBlockByteCount =
            McbEntry->TotalBlockByteCount = McbEntry->ByteCount;
 
            Vcb->VolumeDasdFcb->Mcb.CurrentEntryCount = 1;
 
            CdUnlockFcb( IrpContext, Vcb->VolumeDasdFcb );
 
            //
            //  Point to the file resource.
            //
 
            Vcb->VolumeDasdFcb->Resource = &Vcb->FileResource;
 
            Vcb->VolumeDasdFcb->FileAttributes = FILE_ATTRIBUTE_READONLY;
 
            //
            //  Mark the Fcb as initialized.
            //
 
            SetFlag( Vcb->VolumeDasdFcb->FcbState, FCB_STATE_INITIALIZED );
 
            //
            //  Check and see if this is an XA disk.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_ISO | VCB_STATE_JOLIET)
                && RtlEqualMemory( CdXaId,
                                   Add2Ptr( RawIsoVd, 0x400, PCHAR ),
                                   8 )) {
 
                SetFlag( Vcb->VcbState, VCB_STATE_CDXA );
            }
 
        //
        //  If this is a music disk then we want to mock this disk to make it
        //  look like ISO disk.  We will create a pseudo root directory in
        //  that case.
        //
 
        } else if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK )) {
 
            ULONG RootDirectorySize;
 
            //
            //  Create the path table Fcb and refererence it and the Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
 
            Vcb->PathTableFcb = CdCreateFcb( IrpContext,
                                             *((PFILE_ID) &FileId),
                                             CDFS_NTC_FCB_PATH_TABLE,
                                             NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->PathTableFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  We only create a pseudo entry for the root.
            //
 
            Vcb->PathTableFcb->FileSize.QuadPart = (LONGLONG) (FIELD_OFFSET( RAW_PATH_ISO, DirId ) + 2);
 
            Vcb->PathTableFcb->ValidDataLength.QuadPart = Vcb->PathTableFcb->FileSize.QuadPart;
 
            Vcb->PathTableFcb->AllocationSize.QuadPart = LlSectorAlign( Vcb->PathTableFcb->FileSize.QuadPart );
 
            //
            //  Point to the file resource.
            //
 
            Vcb->PathTableFcb->Resource = &Vcb->FileResource;
 
            //
            //  Mark the Fcb as initialized and create the stream file for this.
            //
 
            SetFlag( Vcb->PathTableFcb->FcbState, FCB_STATE_INITIALIZED );
 
            CdCreateInternalStream( IrpContext, Vcb, Vcb->PathTableFcb, &CdInternalStreamNames[0]);
 
            //
            //  Create the root index and reference it in the Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
            Vcb->RootIndexFcb = CdCreateFcb( IrpContext,
                                             *((PFILE_ID) &FileId),
                                             CDFS_NTC_FCB_INDEX,
                                             NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->RootIndexFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  Create the File id by hand for this Fcb.
            //
 
            CdSetFidPathTableOffset( Vcb->RootIndexFcb->FileId, Vcb->PathTableFcb->StreamOffset );
            CdFidSetDirectory( Vcb->RootIndexFcb->FileId );
 
            //
            //  Create a pseudo path table entry so we can call the initialization
            //  routine for the directory.
            //
 
            RtlZeroMemory( &PathEntry, sizeof( PATH_ENTRY ));
 
 
            PathEntry.Ordinal = 1;
            PathEntry.PathTableOffset = Vcb->PathTableFcb->StreamOffset;
 
            CdInitializeFcbFromPathEntry( IrpContext,
                                          Vcb->RootIndexFcb,
                                          NULL,
                                          &PathEntry );
 
            //
            //  Set the sizes by hand for this Fcb.  It should have an entry for each track plus an
            //  entry for the root and parent.
            //
 
            RootDirectorySize = (Vcb->TrackCount + 2) * CdAudioDirentSize;
            RootDirectorySize = SectorAlign( RootDirectorySize );
 
            Vcb->RootIndexFcb->AllocationSize.QuadPart =
            Vcb->RootIndexFcb->ValidDataLength.QuadPart =
            Vcb->RootIndexFcb->FileSize.QuadPart = RootDirectorySize;
 
            SetFlag( Vcb->RootIndexFcb->FcbState, FCB_STATE_INITIALIZED );
 
            //
            //  Create the stream file for the root directory.
            //
 
            CdCreateInternalStream( IrpContext, Vcb, Vcb->RootIndexFcb, &CdInternalStreamNames[1] );
 
            //
            //  Now do the volume dasd Fcb.  Create this and reference it in the
            //  Vcb.
            //
 
            CdLockVcb( IrpContext, Vcb );
            UnlockVcb = TRUE;
 
            Vcb->VolumeDasdFcb = CdCreateFcb( IrpContext,
                                              *((PFILE_ID) &FileId),
                                              CDFS_NTC_FCB_DATA,
                                              NULL );
 
            CdIncrementReferenceCounts( IrpContext, Vcb->VolumeDasdFcb, 1, 1 );
            CdUnlockVcb( IrpContext, Vcb );
            UnlockVcb = FALSE;
 
            //
            //  We won't allow raw reads on this Fcb so leave the size at
            //  zero.
            //
 
            //
            //  Point to the file resource.
            //
 
            Vcb->VolumeDasdFcb->Resource = &Vcb->FileResource;
 
            Vcb->VolumeDasdFcb->FileAttributes = FILE_ATTRIBUTE_READONLY;
 
            //
            //  Mark the Fcb as initialized.
            //
 
            SetFlag( Vcb->VolumeDasdFcb->FcbState, FCB_STATE_INITIALIZED );
 
            //
            //  We will store a hard-coded name in the Vpb and use the toc as
            //  the serial number.
            //
 
            Vcb->Vpb->VolumeLabelLength = CdAudioLabelLength;
 
            RtlCopyMemory( Vcb->Vpb->VolumeLabel,
                           CdAudioLabel,
                           CdAudioLabelLength );
 
            //
            //  Find the serial number for the audio disk.
            //
 
            Vcb->Vpb->SerialNumber = CdTocSerial( IrpContext, Vcb->CdromToc );
 
            //
            //  Set the ISO bit so we know how to treat the names.
            //
 
            SetFlag( Vcb->VcbState, VCB_STATE_ISO );
        }
 
    } _SEH2_FINALLY {
 
        if (UnlockVcb) { CdUnlockVcb( IrpContext, Vcb ); }
    } _SEH2_END;
}

CdVerifyFcbOperation()

BOOLEAN CdVerifyFcbOperation	(	_In_opt_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb
	)

Definition at line 615 of file verfysup.c.

{
    PVCB Vcb = Fcb->Vcb;
    PDEVICE_OBJECT RealDevice = Vcb->Vpb->RealDevice;
    PIRP Irp;
 
    PAGED_CODE();
 
    //
    //  Check that the fileobject has not been cleaned up.
    //
 
    if ( ARGUMENT_PRESENT( IrpContext ))  {
 
        PFILE_OBJECT FileObject;
 
        Irp = IrpContext->Irp;
        FileObject = IoGetCurrentIrpStackLocation( Irp)->FileObject;
 
        if ( FileObject && FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE))  {
 
            PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
            //
            //  Following FAT,  we allow certain operations even on cleaned up
            //  file objects.  Everything else,  we fail.
            //
 
            if ( (FlagOn(Irp->Flags, IRP_PAGING_IO)) ||
                 (IrpSp->MajorFunction == IRP_MJ_CLOSE ) ||
                 (IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) ||
                 ( (IrpSp->MajorFunction == IRP_MJ_READ) &&
                   FlagOn(IrpSp->MinorFunction, IRP_MN_COMPLETE) ) ) {
 
                NOTHING;
 
            } else {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CLOSED );
            }
        }
    }
 
    //
    //  Fail immediately if the volume is in the progress of being dismounted
    //  or has been marked invalid.
    //
 
    if ((Vcb->VcbCondition == VcbInvalid) ||
        (Vcb->VcbCondition == VcbDismountInProgress)) {
 
        if (ARGUMENT_PRESENT( IrpContext )) {
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
                CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
            } else {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
            }
        }
 
        return FALSE;
    }
 
    //
    //  Always fail if the volume needs to be verified.
    //
 
    if (CdRealDevNeedsVerify( RealDevice)) {
 
        if (ARGUMENT_PRESENT( IrpContext )) {
 
            IoSetHardErrorOrVerifyDevice( IrpContext->Irp,
                                          RealDevice );
 
            CdRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED );
        }
 
        return FALSE;
 
    //
    //
    //  All operations are allowed on mounted.
    //
 
    } else if ((Vcb->VcbCondition == VcbMounted) ||
               (Vcb->VcbCondition == VcbMountInProgress)) {
 
        return TRUE;
 
    //
    //  Fail all requests for fast Io on other Vcb conditions.
    //
 
    } else if (!ARGUMENT_PRESENT( IrpContext )) {
 
        return FALSE;
 
    //
    //  The remaining case is VcbNotMounted.
    //  Mark the device to be verified and raise WRONG_VOLUME.
    //
 
    } else if (Vcb->VcbCondition == VcbNotMounted) {
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp, RealDevice );
        CdRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
 
//        return FALSE; // unreachable code
    }
 
    return TRUE;
}

Referenced by _Function_class_(), _Requires_lock_held_(), CdCommonLockControl(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), and CdFastUnlockSingle().

CdVerifyOrCreateDirStreamFile()

static INLINE VOID CdVerifyOrCreateDirStreamFile ( _In_ PIRP_CONTEXT  IrpContext, _In_ PFCB  Fcb  )

static

Definition at line 242 of file cdprocs.h.

{
    //
    //  Unsafe test to see if call / lock neccessary.
    //
 
    if (NULL == Fcb->FileObject) {
 
        CdCreateInternalStream( IrpContext,
                                Fcb->Vcb,
                                Fcb,
                                &Fcb->FileNamePrefix.ExactCaseName.FileName);
    }
}

Referenced by _Requires_lock_held_(), and CdInitializeEnumeration().

CdVerifyVcb()

VOID CdVerifyVcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb
	)

Definition at line 411 of file verfysup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    IO_STATUS_BLOCK Iosb;
    ULONG MediaChangeCount = 0;
    BOOLEAN ForceVerify = FALSE;
    BOOLEAN DevMarkedForVerify;
 
    PAGED_CODE();
 
    //
    //  Fail immediately if the volume is in the progress of being dismounted
    //  or has been marked invalid.
    //
 
    if ((Vcb->VcbCondition == VcbInvalid) ||
        ((Vcb->VcbCondition == VcbDismountInProgress) &&
         (IrpContext->MajorFunction != IRP_MJ_CREATE))) {
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
            CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
        } else {
 
            CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
        }
    }
 
    //
    //  Capture the real device verify state.
    //
 
    DevMarkedForVerify = CdRealDevNeedsVerify( Vcb->Vpb->RealDevice);
 
    if (FlagOn( Vcb->VcbState, VCB_STATE_REMOVABLE_MEDIA ) && !DevMarkedForVerify) {
 
        //
        //  If the media is removable and the verify volume flag in the
        //  device object is not set then we want to ping the device
        //  to see if it needs to be verified.
        //
 
        if (Vcb->VcbCondition != VcbMountInProgress) {
 
            Status = CdPerformDevIoCtrl( IrpContext,
                                         IOCTL_CDROM_CHECK_VERIFY,
                                         Vcb->TargetDeviceObject,
                                         &MediaChangeCount,
                                         sizeof(ULONG),
                                         FALSE,
                                         FALSE,
                                         &Iosb );
 
            if (Iosb.Information != sizeof(ULONG)) {
 
                //
                //  Be safe about the count in case the driver didn't fill it in
                //
 
                MediaChangeCount = 0;
            }
 
            //
            //  There are four cases when we want to do a verify.  These are the
            //  first three.
            //
            //  1. We are mounted,  and the device has become empty
            //  2. The device has returned verify required (=> DO_VERIFY_VOL flag is
            //     set, but could be due to hardware condition)
            //  3. Media change count doesn't match the one in the Vcb
            //
 
            if (((Vcb->VcbCondition == VcbMounted) &&
                 CdIsRawDevice( IrpContext, Status ))
                ||
                (Status == STATUS_VERIFY_REQUIRED)
                ||
                (NT_SUCCESS(Status) &&
                 (Vcb->MediaChangeCount != MediaChangeCount))) {
 
                //
                //  If we are currently the volume on the device then it is our
                //  responsibility to set the verify flag.  If we're not on the device,
                //  then we shouldn't touch the flag.
                //
 
                if (!FlagOn( Vcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE) &&
                    !DevMarkedForVerify)  {
 
                     DevMarkedForVerify = CdMarkDevForVerifyIfVcbMounted( Vcb);
                }
 
                ForceVerify = TRUE;
 
                //
                //  NOTE that we no longer update the media change count here. We
                //  do so only when we've actually completed a verify at a particular
                //  change count value.
                //
            }
        }
 
        //
        //  This is the 4th verify case.
        //
        //  We ALWAYS force CREATE requests on unmounted volumes through the
        //  verify path.  These requests could have been in limbo between
        //  IoCheckMountedVpb and us when a verify/mount took place and caused
        //  a completely different fs/volume to be mounted.  In this case the
        //  checks above may not have caught the condition,  since we may already
        //  have verified (wrong volume) and decided that we have nothing to do.
        //  We want the requests to be re routed to the currently mounted volume,
        //  since they were directed at the 'drive',  not our volume.
        //
 
        if (NT_SUCCESS( Status) && !ForceVerify && !DevMarkedForVerify &&
            (IrpContext->MajorFunction == IRP_MJ_CREATE))  {
 
            PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->Irp);
 
            ForceVerify = (IrpSp->FileObject->RelatedFileObject == NULL) &&
                          ((Vcb->VcbCondition == VcbDismountInProgress) ||
                           (Vcb->VcbCondition == VcbNotMounted));
 
            //
            //  Note that we don't touch the device verify flag here.  It required
            //  it would have been caught and set by the first set of checks.
            //
        }
    }
 
    //
    //  Raise the verify / error if neccessary.
    //
 
    if (ForceVerify || DevMarkedForVerify || !NT_SUCCESS( Status)) {
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp,
                                      Vcb->Vpb->RealDevice );
 
        CdRaiseStatus( IrpContext, (ForceVerify || DevMarkedForVerify)
                                   ? STATUS_VERIFY_REQUIRED
                                   : Status);
    }
 
    //
    //  Based on the condition of the Vcb we'll either return to our
    //  caller or raise an error condition
    //
 
    switch (Vcb->VcbCondition) {
 
    case VcbNotMounted:
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp, Vcb->Vpb->RealDevice );
 
        CdRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
        break;
 
    case VcbInvalid:
    case VcbDismountInProgress:
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
            CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
        } else {
 
            CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
        }
        break;
 
    /* ReactOS Change: GCC "enumeration value not handled in switch" */
    default: break;
    }
}

Referenced by CdCommonDevControl(), and CdIsVolumeMounted().

SectorsFromLlBytes()

static INLINE ULONG SectorsFromLlBytes ( ULONGLONG  Bytes )

static

Definition at line 1607 of file cdprocs.h.

  {
 
    return (ULONG)(Bytes >> SECTOR_SHIFT);
}

Variable Documentation

ByteCount

_In_ PFCB _In_ LONGLONG _In_ ULONG ByteCount

Definition at line 162 of file cdprocs.h.

Ccb

IN PFCB IN PCCB Ccb

Definition at line 591 of file cdprocs.h.

Referenced by _At_(), _Function_class_(), _Requires_lock_held_(), _When_(), BroadcastOpen(), BuildAndSubmitIrp(), CdAllowExtendedDasdIo(), CdCommonDevControl(), CdCommonLockControl(), CdDeleteCcb(), CdEnumerateIndex(), CdInitializeEnumeration(), CdIsVolumeDirty(), CdIsVolumeMounted(), CloseClientPort(), Ext2AllocateCcb(), Ext2AllowExtendedDasdIo(), Ext2Cleanup(), Ext2Close(), Ext2CreateFile(), Ext2CreateVolume(), Ext2DeleteReparsePoint(), Ext2FastIoCheckIfPossible(), Ext2FastIoQueryBasicInfo(), Ext2FastIoQueryNetworkOpenInfo(), Ext2FillEntry(), Ext2Flush(), Ext2FlushFile(), Ext2FreeCcb(), Ext2GetReparsePoint(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2IsFileRemovable(), Ext2NotifyChangeDirectory(), Ext2OplockRequest(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2ReadFile(), Ext2ReadVolume(), Ext2SetDispositionInfo(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), Ext2WriteFile(), Ext2WriteVolume(), FatAllowExtendedDasdIo(), FatCommonQueryEa(), FatCommonSetEa(), FatCreateCcb(), FatDeallocateCcbStrings(), FatDecodeFileObject(), FatDeferredFlush(), FatDeleteCcb(), FatFreeCcb(), FatFspDispatch(), FatIsVolumeDirty(), FatIsVolumeMounted(), FatSetFileObject(), FatSetRenameInfo(), FatSetZeroOnDeallocate(), FatTunnelFcbOrDcb(), FatUnlockVolume(), if(), MsfsClose(), MsfsCreate(), MsfsCreateMailslot(), MsfsQueryInformation(), MsfsRead(), MsfsSetInformation(), MsfsWrite(), MupCleanup(), MupCleanupFcb(), MupClose(), MupCreateCcb(), MupDereferenceCcb(), MupForwardIoRequest(), MupSetFileObject(), NpAddDataQueueEntry(), NpCommonCleanup(), NpCommonClose(), NpCommonFlushBuffers(), NpCommonQueryInformation(), NpCommonQuerySecurityInfo(), NpCommonRead(), NpCommonSetInformation(), NpCommonSetSecurityInfo(), NpCommonWrite(), NpCopyClientContext(), NpCreateCcb(), NpCreateClientEnd(), NpCreateExistingNamedPipe(), NpCreateNewNamedPipe(), NpDecodeFileObject(), NpDeleteCcb(), NpDisconnect(), NpFsdCreate(), NpGetClientSecurityContext(), NpImpersonate(), NpImpersonateClientContext(), NpInitializeSecurity(), NpListen(), NpOpenNamedPipeRootDirectory(), NpPeek(), NpQueryClientProcess(), NpQueryNameInfo(), NpQueryPipeInfo(), NpQueryPipeLocalInfo(), NpQueryPositionInfo(), NpQueryStandardInfo(), NpReadDataQueue(), NpSetClientProcess(), NpSetClosingPipeState(), NpSetConnectedPipeState(), NpSetDisconnectedPipeState(), NpSetFileObject(), NpSetListeningPipeState(), NpSetPipeInfo(), NpTransceive(), NpUninitializeSecurity(), NpWaitForNamedPipe(), NpWriteDataQueue(), NtfsCloseFile(), NtfsMountVolume(), NtfsQueryDirectory(), RegisterUncProvider(), UDFCheckAccessRights(), UDFCleanUpCCB(), UDFCommonCleanup(), UDFCommonClose(), UDFCommonDeviceControl(), UDFCommonDirControl(), UDFCommonFileInfo(), UDFCommonFlush(), UDFCommonLockControl(), UDFCommonQueryVolInfo(), UDFCommonRead(), UDFCommonSetVolInfo(), UDFCommonWrite(), UDFDismountVolume(), UDFFastIoCheckIfPossible(), UDFFastIoCopyWrite(), UDFFastIoQueryBasicInfo(), UDFFastIoQueryStdInfo(), UDFFastLock(), UDFFastUnlockAll(), UDFFastUnlockAllByKey(), UDFFastUnlockSingle(), UDFFlushAFile(), UDFGetFileAllocModeFromICB(), UDFGetInternalInformation(), UDFGetRetrievalPointers(), UDFGetVolumeBitmap(), UDFIsVolumeDirty(), UDFIsVolumeMounted(), UDFLockVolume(), UDFNotifyChangeDirectory(), UDFOpenFile(), UDFQueryDirectory(), UDFReleaseCCB(), UDFSetAccessRights(), UDFSetBasicInformation(), UDFSetDispositionInformation(), UDFSetEOF(), UDFSetFileAllocModeFromICB(), UDFStoreFileId(), UDFUnlockVolume(), and VfatMount().

CdFastIoCheckIfPossible

FAST_IO_CHECK_IF_POSSIBLE CdFastIoCheckIfPossible

Definition at line 1951 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastLock

FAST_IO_LOCK CdFastLock

Definition at line 1903 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastQueryBasicInfo

FAST_IO_QUERY_BASIC_INFO CdFastQueryBasicInfo

Definition at line 1876 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastQueryNetworkInfo

FAST_IO_QUERY_NETWORK_OPEN_INFO CdFastQueryNetworkInfo

Definition at line 1963 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastQueryStdInfo

FAST_IO_QUERY_STANDARD_INFO CdFastQueryStdInfo

Definition at line 1888 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastUnlockAll

FAST_IO_UNLOCK_ALL CdFastUnlockAll

Definition at line 1926 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastUnlockAllByKey

FAST_IO_UNLOCK_ALL_BY_KEY CdFastUnlockAllByKey

Definition at line 1937 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFastUnlockSingle

FAST_IO_UNLOCK_SINGLE CdFastUnlockSingle

Definition at line 1916 of file cdprocs.h.

Referenced by CdInitializeGlobalData().

CdFspDispatch

WORKER_THREAD_ROUTINE CdFspDispatch

Definition at line 2040 of file cdprocs.h.

Referenced by CdAddToWorkque().

CdName

_Inout_ PCD_NAME CdName

Definition at line 622 of file cdprocs.h.

CompletionContext

_Unreferenced_parameter_ PVOID* CompletionContext

Definition at line 1124 of file cdprocs.h.

CompoundPathEntry

_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry

Definition at line 739 of file cdprocs.h.

Referenced by _Requires_lock_held_().

CurrentFcb

_Inout_ PFCB* CurrentFcb

Definition at line 801 of file cdprocs.h.

Referenced by _Requires_lock_held_().

DeviceToVerify

_Inout_ PIRP _In_ PDEVICE_OBJECT DeviceToVerify

Definition at line 1408 of file cdprocs.h.

Referenced by _Requires_lock_held_(), UDFPerformVerify(), VfatBlockDeviceIoControl(), VfatReadDisk(), VfatReadDiskPartial(), VfatVerify(), VfatWriteDisk(), and VfatWriteDiskPartial().

DirContext

_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext

Definition at line 425 of file cdprocs.h.

Referenced by _Requires_lock_held_(), AddSectionToCopyQueueCab(), CdCreateInternalStream(), DoQuery(), FATAddEntry(), FATGetNextDirEntry(), FATXAddEntry(), FATXGetNextDirEntry(), FindFile(), GetSourceFileAndTargetLocation(), main(), PrepareCopyInfFile(), vfatDirFindFile(), VfatGetFileBothInformation(), VfatGetFileDirectoryInformation(), VfatGetFileFullDirectoryInformation(), VfatGetFileNamesInformation(), VfatGetNextDirEntry(), vfatInitFCBFromDirEntry(), vfatMakeFCBFromDirEntry(), vfatRenameEntry(), and vfatUpdateFCB().

Dirent

IN PVCB IN PDIRENT Dirent

Definition at line 426 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdAddAllocationFromDirent(), CdCreateInternalStream(), EtfspCachedSearchForDirent(), Fat8dot3ToString(), FatCommonQueryEa(), FatCommonSetEa(), FatConstructNamesInFcb(), FatCreateDcb(), FatCreateFcb(), FatGetDirTimes(), FatMatchFileSize(), FatQueryEaInfo(), FatSearchBufferForLabel(), FatSetFsLabelInfo(), FatSetRenameInfo(), and main().

DirName

_In_ PFCB _In_ PCD_NAME DirName

Definition at line 737 of file cdprocs.h.

Referenced by CheckForSameCurdir(), EtfspFileMatch(), ExpInitializeCallbacks(), IopCreateRootDirectories(), main(), NlsInit(), ScmCheckDriver(), ScmGetDriverStatus(), and SetCurrentDirectoryA().

DiskOffset

_In_ PFCB _In_ LONGLONG _Out_ PLONGLONG DiskOffset

Definition at line 161 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdDiskOffsetFromMcbEntry(), and main().

DismountUnderway

_In_ PVCB _In_ BOOLEAN DismountUnderway

Definition at line 236 of file cdprocs.h.

Referenced by _Requires_lock_held_().

ExceptionCode

_Inout_ PIRP _In_ NTSTATUS ExceptionCode

Definition at line 1773 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdExceptionFilter(), DbgUiConvertStateChangeStructure(), ExceptionFilter(), Ext2ExceptionFilter(), Fast486ExceptionWithErrorCode(), FatExceptionFilter(), I_RpcAsyncAbortCall(), KdbEnterDebuggerException(), KdbpGetExceptionNumberFromStatus(), KdbpIsBreakPointOurs(), KdpReport(), KeRaiseUserException(), KiRaiseUserExceptionDispatcher(), KiSystemFatalException(), KiXmmExceptionHandler(), main(), page_fault(), RpcAsyncAbortCall(), RpcExceptionFilter(), test_pack_EXCEPTION_RECORD(), UDFExceptionFilter(), UDFExceptionHandler(), and UserpFormatMessages().

Fcb

IN PFCB Fcb

Definition at line 159 of file cdprocs.h.

Referenced by __RxAcquireFcb(), _At_(), _Function_class_(), _Inout_updates_bytes_(), _Requires_lock_held_(), _When_(), BroadcastOpen(), CcCanIWrite(), CcDeferWrite(), CcSetDirtyPageThreshold(), CdAddAllocationFromDirent(), CdAddInitialAllocation(), CdAllowExtendedDasdIo(), CdCommonDevControl(), CdCommonLockControl(), CdCreateCcb(), CdCreateInternalStream(), CdDeleteFcb(), CdDeleteInternalStream(), CdFastDecodeFileObject(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), CdFastUnlockSingle(), CdFileTrackMode(), CdFindMcbEntry(), CdGetNextFcb(), CdInitializeEnumeration(), CdInitializeFcbFromFileContext(), CdInitializeFcbFromPathEntry(), CdInsertPrefix(), CdIsVolumeDirty(), CdIsVolumeMounted(), CdMapPathTableBlock(), CdNoopAcquire(), CdNoopRelease(), CdQueryBasicInfo(), CdQueryEaInfo(), CdQueryInternalInfo(), CdQueryNetworkInfo(), CdQueryStandardInfo(), CdQueueClose(), CdRemovePrefix(), CdTruncateAllocation(), CdVerifyFcbOperation(), CdVerifyOrCreateDirStreamFile(), check_nfs41_create_args(), DosInt21h(), Ext2AcquireFileForCcFlush(), Ext2AcquireFileForModWrite(), Ext2AcquireForCreateSection(), Ext2AcquireForLazyWrite(), Ext2AcquireForReadAhead(), Ext2AllocateFcb(), Ext2Cleanup(), Ext2Close(), Ext2CreateFile(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2FastIoCheckIfPossible(), Ext2FastIoLock(), Ext2FastIoQueryBasicInfo(), Ext2FastIoQueryNetworkOpenInfo(), Ext2FastIoQueryStandardInfo(), Ext2FastIoRead(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), Ext2FastIoUnlockSingle(), Ext2FastIoWrite(), Ext2FcbReaperThread(), Ext2FillEntry(), Ext2FloppyFlush(), Ext2Flush(), Ext2FlushFile(), Ext2FlushFiles(), Ext2FreeFcb(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2InsertFcb(), Ext2IsFastIoPossible(), Ext2IsFileRemovable(), Ext2IsHandleCountZero(), Ext2LockControl(), Ext2NotifyChangeDirectory(), Ext2OplockRequest(), Ext2OverwriteEa(), Ext2PreAcquireForCreateSection(), Ext2PurgeFile(), Ext2PurgeVolume(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryExtentMappings(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryUnusedFcb(), Ext2ReadFile(), Ext2ReleaseFcb(), Ext2ReleaseFileForCcFlush(), Ext2ReleaseFileForModWrite(), Ext2ReleaseForCreateSection(), Ext2ReleaseFromLazyWrite(), Ext2ReleaseFromReadAhead(), Ext2SetDispositionInfo(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), Ext2StartFloppyFlushDpc(), Ext2SupersedeOrOverWriteFile(), Ext2UnlinkFcb(), Ext2WriteFile(), Ext2ZeroData(), FATAddEntry(), FatAllowExtendedDasdIo(), FatCommonQueryEa(), FatCommonSetEa(), FatConstructNamesInFcb(), FatCreateFcb(), FatDeleteFcb(), FatDeleteVcb(), FatFlushDirentForFile(), FatFreeFcb(), FatFspDispatch(), FatGetNextFcbBottomUp(), FatGetNextFcbTopDown(), FATIsDirectoryEmpty(), FatIsHandleCountZero(), FatIsVolumeDirty(), FatIsVolumeMounted(), FatMatchFileSize(), FatNoOpAcquire(), FatNoOpRelease(), FatPagingFileIo(), FatQueryBasicInfo(), FatQueryEaInfo(), FatQueryInternalInfo(), FatQueryShortNameInfo(), FatRemoveNames(), FatResetFcb(), FatSetFullNameInFcb(), FatSetRenameInfo(), FatUnlockVolume(), FATXAddEntry(), FATXIsDirectoryEmpty(), FsRtlCopyRead2(), FsRtlCopyWrite2(), GET_ALREADY_PREFIXED_NAME(), LockOrUnlockVolume(), main(), MsfsAcquireLock(), MsfsClose(), MsfsCreate(), MsfsCreateMailslot(), MsfsFileSystemControl(), MsfsInsertIrp(), MsfsPeekNextIrp(), MsfsQueryInformation(), MsfsQueryMailslotInformation(), MsfsRead(), MsfsReleaseLock(), MsfsSetInformation(), MsfsSetMailslotInformation(), MsfsWrite(), MupCleanup(), MupCleanupFcb(), MupClose(), MupCloseFcb(), MupCreateFcb(), MupDecodeFileObject(), MupDereferenceFcb(), MupForwardIoRequest(), MupSetFileObject(), nfs41_Create(), NpCommonCleanup(), NpCommonClose(), NpCommonQueryInformation(), NpCommonQuerySecurityInfo(), NpCommonSetInformation(), NpCommonSetSecurityInfo(), NpCreateCcb(), NpCreateClientEnd(), NpCreateExistingNamedPipe(), NpCreateFcb(), NpCreateNewNamedPipe(), NpDeleteFcb(), NpFindPrefix(), NpFindRelativePrefix(), NpFsdCreate(), NpFsdCreateNamedPipe(), NpQueryPipeLocalInfo(), NpSetClosingPipeState(), NpSetPipeInfo(), NpWaitForNamedPipe(), NtfsAddFCBToTable(), NtfsAttachFCBToFileObject(), NtfsCleanupFile(), NtfsCloseFile(), NtfsCreateFCB(), NtfsCreateFile(), NtfsDestroyFCB(), NtfsFCBInitializeCache(), NtfsFCBIsCompressed(), NtfsFCBIsDirectory(), NtfsFCBIsEncrypted(), NtfsFCBIsReparsePoint(), NtfsFCBIsRoot(), NtfsGetBasicInformation(), NtfsGetInternalInformation(), NtfsGetNameInformation(), NtfsGetNetworkOpenInformation(), NtfsGetStandardInformation(), NtfsGetStreamInformation(), NtfsGrabFCB(), NtfsGrabFCBFromTable(), NtfsMakeAbsoluteFilename(), NtfsMakeRootFCB(), NtfsMountVolume(), NtfsOpenFile(), NtfsOpenRootFCB(), NtfsQueryDirectory(), NtfsQueryInformation(), NtfsReadFile(), NtfsReleaseFCB(), NtfsSetEndOfFile(), NtfsSetInformation(), NtfsWrite(), NtfsWriteFile(), PerformTest(), RegisterUncProvider(), RxAcquireExclusiveFcbResourceInMRx(), RxAcquireFcbForLazyWrite(), RxAcquireFcbForReadAhead(), RxAllocateFcbObject(), RxCanonicalizeNameAndObtainNetRoot(), RxChangeBufferingState(), RxCheckShareAccessPerSrvOpens(), RxCloseAssociatedSrvOpen(), RxCommonCleanup(), RxCommonClose(), RxCommonDevFCBCleanup(), RxCommonDevFCBClose(), RxCommonDirectoryControl(), RxCommonQueryInformation(), RxCommonQueryVolumeInformation(), RxCommonRead(), RxCommonSetInformation(), RxCommonWrite(), RxConjureOriginalName(), RxCreateFromNetRoot(), RxCreateNetFcb(), RxCreateNetFobx(), RxCreateSrvOpen(), RxFastIoCheckIfPossible(), RxFcbTableInsertFcb(), RxFcbTableLookupFcb(), RxFcbTableRemoveFcb(), RxFinalizeConnection(), RxFinalizeNetFobx(), RxFinalizeNetRoot(), RxFinalizeSrvOpen(), RxFindOrCreateFcb(), RxFinishFcbInitialization(), RxFlushFcbInSystemCache(), RxFreeFcbObject(), RxFsdCommonDispatch(), RxFsdDispatch(), RxGetFileSizeWithLock(), RxInitializeContext(), RxIsOkToPurgeFcb(), RxLowIoReadShell(), RxLowIoReadShellCompletion(), RxLowIoSubmit(), RxLowIoWriteShell(), RxLowIoWriteShellCompletion(), RxMarkFobxOnCleanup(), RxMarkFobxOnClose(), RxOrphanSrvOpens(), RxpDereferenceNetFcb(), RxpQueryInfoMiniRdr(), RxpReferenceNetFcb(), RxProcessChangeBufferingStateRequestsForSrvOpen(), RxpScavengeFobxs(), RxpSetInfoMiniRdr(), RxPurgeFcb(), RxPurgeFcbInSystemCache(), RxPurgeNetFcb(), RxPurgeRelatedFobxs(), RxQueryDirectory(), RxQueryNameInfo(), RxQueryStandardInfo(), RxReleaseFcbFromLazyWrite(), RxReleaseFcbFromReadAhead(), RxScavengeFobxsForNetRoot(), RxScavengeRelatedFobxs(), RxSearchForCollapsibleOpen(), RxSetBasicInfo(), RxSetDispositionInfo(), RxSetFileSizeWithLock(), RxSetRenameInfo(), RxSetupNetFileObject(), RxUninitializeCacheMap(), RxVerifyOperationIsLegal(), SetAttributeDataLength(), TestFastIoRead(), TestFastIoWrite(), TestIrpHandler(), UDFAssignAcl(), UDFCheckAccessRights(), UDFCleanUpFCB(), UDFCleanUpFcbChain(), UDFCloseAllXXXDelayedInDir(), UDFCloseFileInfoChain(), UDFCommonCleanup(), UDFCommonClose(), UDFCommonDeviceControl(), UDFCommonDirControl(), UDFCommonFileInfo(), UDFCommonFlush(), UDFCommonLockControl(), UDFCommonRead(), UDFCommonWrite(), UDFDismountVolume(), UDFFastIoCheckIfPossible(), UDFFastIoCopyWrite(), UDFFastIoQueryBasicInfo(), UDFFastIoQueryStdInfo(), UDFFastLock(), UDFFastUnlockAll(), UDFFastUnlockAllByKey(), UDFFastUnlockSingle(), UDFFlushAFile(), UDFGetAltNameInformation(), UDFGetBasicInformation(), UDFGetFileAllocModeFromICB(), UDFGetFileStreamInformation(), UDFGetInternalInformation(), UDFGetNetworkInformation(), UDFGetRetrievalPointers(), UDFGetStandardInformation(), UDFGetVolumeBitmap(), UDFHardLink(), UDFInitializeIrpContextLite(), UDFIsFastIoPossible(), UDFIsLastClose(), UDFIsVolumeDirty(), UDFIsVolumeMounted(), UDFLockVolume(), UDFLookUpAcl(), UDFMarkStreamsForDeletion(), UDFNotifyChangeDirectory(), UDFNotifyFullReportChange(), UDFPostStackOverflowRead(), UDFQueryDirectory(), UDFQueueDelayedClose(), UDFReadSecurity(), UDFReleaseFCB(), UDFRename(), UDFSetAccessRights(), UDFSetAllocationInformation(), UDFSetBasicInformation(), UDFSetDispositionInformation(), UDFSetEOF(), UDFSetFileAllocModeFromICB(), UDFUnlockVolume(), UDFWriteSecurity(), UpdateFileSize(), VfatAcquireForCcFlush(), VfatAcquireForLazyWrite(), VfatAddEntry(), VfatCheckForDismount(), VfatCommonRead(), VfatDelEntry(), VfatDismountVolume(), VfatFlush(), VfatFlushFile(), VfatFlushVolume(), VfatGetAllInformation(), VfatGetEaInformation(), VfatGetInternalInformation(), VfatGetNetworkOpenInformation(), VfatGetRetrievalPointers(), vfatInitFcb(), vfatInitFCBFromDirEntry(), VfatIsDirectoryEmpty(), VfatLockControl(), VfatLockOrUnlockVolume(), VfatMount(), VfatOpenFile(), VfatRead(), VfatReadFileData(), VfatReleaseForCcFlush(), VfatReleaseFromLazyWrite(), vfatReportChange(), VfatSetAllocationSizeInformation(), vfatSetFCBNewDirName(), vfatUpdateFCB(), VfatWrite(), and VfatWriteFileData().

FileContext

_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext

Definition at line 442 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdEnumerateIndex(), CdInitializeEnumeration(), CdInitializeFcbFromFileContext(), GetSourceFileAndTargetLocation(), RosSymCreateFromFile(), RosSymIoReadFile(), RosSymIoSeekFile(), RosSymZwReadFile(), and RosSymZwSeekFile().

FileObject

_At_ Ccb _In_ PFILE_OBJECT FileObject

Definition at line 588 of file cdprocs.h.

FileOffset

_In_ PLARGE_INTEGER FileOffset

Definition at line 160 of file cdprocs.h.

Referenced by _CcpFlushCache(), _Function_class_(), _MmGetPageEntrySectionSegment(), _Requires_lock_held_(), AddDiskToList(), BlFileReadAtOffsetEx(), CcCopyRead(), CcCopyWrite(), CcFastCopyRead(), CcFastCopyWrite(), CcFlushCache(), CcMapData(), CcMdlRead(), CcMdlWriteComplete(), CcpBuildCacheMdl(), CcpFindBcb(), CcpFindMatchingMap(), CcpGetAppropriateBcb(), CcPinMappedData(), CcPinRead(), CcpMapData(), CcpPinData(), CcpPinMappedData(), CcPrepareMdlWrite(), CcPreparePinWrite(), CcPurgeCacheSection(), CcRosCreateVacb(), CcRosGetVacb(), CcRosLookupVacb(), CcRosRequestVacb(), CcScheduleReadAhead(), CdDiskOffsetFromMcbEntry(), CdFastLock(), CdFastUnlockSingle(), CdFindMcbEntry(), CmpFileRead(), CmpFileWrite(), Dispatch_fnFastRead(), Dispatch_fnFastWrite(), DumpDisk(), DumpPartition(), ElfBackupFile(), ElfFlushFile(), ElfpInitExistingFile(), ElfpInitNewFile(), ElfReadRecord(), ElfWriteRecord(), EtfsOpen(), EtfspGetDirectoryInfo(), EtfspGetDirent(), ExeFmtpReadFile(), Ext2FastIoCheckIfPossible(), Ext2FastIoLock(), Ext2FastIoRead(), Ext2FastIoUnlockSingle(), Ext2FastIoWrite(), Fat12WriteBootSector(), Fat12WriteFAT(), Fat12WriteRootDirectory(), Fat16WriteBootSector(), Fat16WriteFAT(), Fat16WriteRootDirectory(), Fat32WriteBootSector(), Fat32WriteFAT(), Fat32WriteFsInfo(), Fat32WriteRootDirectory(), FATAddEntry(), FatComputeMoveFileSplicePoints(), FatFlushDirentForFile(), FatFlushFatEntries(), FATGetNextDirEntry(), FATIsDirectoryEmpty(), FatWipeSectors(), Fatx16WriteFAT(), Fatx32WriteFAT(), FATXAddEntry(), FATXGetNextDirEntry(), FATXIsDirectoryEmpty(), FatxWriteBootSector(), FatxWriteRootDirectory(), FltpFastIoCheckIfPossible(), FltpFastIoLock(), FltpFastIoMdlRead(), FltpFastIoMdlWriteComplete(), FltpFastIoMdlWriteCompleteCompressed(), FltpFastIoPrepareMdlWrite(), FltpFastIoRead(), FltpFastIoReadCompressed(), FltpFastIoUnlockSingle(), FltpFastIoWrite(), FltpFastIoWriteCompressed(), FsdSetFsLabelInformation(), FsRtlCopyRead(), FsRtlCopyRead2(), FsRtlCopyWrite(), FsRtlCopyWrite2(), FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), FsRtlFastUnlockSingle(), FsRtlMdlRead(), FsRtlMdlReadDev(), FsRtlMdlWriteComplete(), FsRtlMdlWriteCompleteDev(), FsRtlPrepareMdlWrite(), FsRtlPrepareMdlWriteDev(), FsRtlPrivateLock(), HvpGetHiveHeader(), HvpRecoverDataFromLog(), HvpRecoverHeaderFromLog(), HvpWriteHive(), HvpWriteLog(), InfOpenFile(), IniCacheLoadByHandle(), InstallBtrfsBootCode(), InstallFat32BootCode(), InstallFatBootCode(), InstallMbrBootCode(), InstallNtfsBootCode(), KmtInitTestFiles(), LogfpFlushFile(), LogfpReadFile(), LogfpWriteFile(), main(), MergeStabsAndCoffs(), MiFreeSegmentPage(), MiReadFilePage(), MiSectionPageTableGet(), MiSectionPageTableGetOrAllocate(), MiSimpleRead(), MiWritePage(), MmFinalizeSectionPageOut(), MmMakeSegmentResident(), MmMapViewOfSegment(), MmpPageOutPhysicalAddress(), MmWithdrawSectionPage(), NtfsFastIoCheckIfPossible(), NtfsFastIoRead(), NtfsFastIoWrite(), OffsetToCluster(), ReadBootCodeByHandle(), ReadLogBuffer(), ReadVolumeLabel(), RxFastIoCheckIfPossible(), RxFastIoRead(), RxFastIoWrite(), RxPurgeFcbInSystemCache(), START_TEST(), TestCommonRead(), TestFastIoRead(), TestFastIoWrite(), TestSharedCacheMap(), UDFFastIoCheckIfPossible(), UDFFastIoCopyWrite(), UDFFastLock(), UDFFastUnlockSingle(), VfatFastIoCheckIfPossible(), VfatFastIoLock(), VfatFastIoRead(), VfatFastIoReadCompressed(), VfatFastIoUnlockSingle(), VfatFastIoWrite(), VfatFastIoWriteCompressed(), vfatFindDirSpace(), VfatMdlRead(), VfatMdlWriteComplete(), VfatMdlWriteCompleteCompressed(), VfatPrepareMdlWrite(), and WriteLogBuffer().

Force

_Inout_ PVCB _In_ BOOLEAN Force

Definition at line 1416 of file cdprocs.h.

Referenced by CreateCommand(), DceFreeDCE(), DismountVolume(), DxEngDeleteDC(), file_Delete(), filesys_DeleteFile(), filesys_DeleteFolder(), implicit_handle(), IntGdiDeleteDC(), IopPrepareDeviceForRemoval(), IopQueryRemoveChildDevices(), IopQueryRemoveDeviceRelations(), and VfatCheckForDismount().

IgnoreCase

_Inout_ PFCB _Inout_ PUNICODE_STRING _In_ BOOLEAN IgnoreCase

Definition at line 441 of file cdprocs.h.

IgnoreWait

_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE _In_ BOOLEAN IgnoreWait

Definition at line 844 of file cdprocs.h.

Referenced by _Requires_lock_held_().

Irp

_Inout_ PIRP Irp

Definition at line 1407 of file cdprocs.h.

MatchingName

_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _Inout_ PFILE_ENUM_CONTEXT _Out_ PCD_NAME* MatchingName

Definition at line 443 of file cdprocs.h.

Referenced by _Success_().

Name

_In_ PFCB _In_ PCD_NAME Name

Definition at line 440 of file cdprocs.h.

ParentFcb

_In_ PFCB ParentFcb

Definition at line 736 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdInitializeFcbFromFileContext(), CdInitializeFcbFromPathEntry(), CdInsertPrefix(), Ext2CreateFile(), FATAddEntry(), FATXAddEntry(), main(), NtfsOpenFile(), UDFCleanUpFcbChain(), UDFCloseFileInfoChain(), VfatAddEntry(), VfatCreateFile(), vfatInitFCBFromDirEntry(), VfatMoveEntry(), VfatOpenFile(), vfatSetFCBNewDirName(), and vfatUpdateFCB().

RaiseOnError

_Inout_ PFCB _In_ BOOLEAN RaiseOnError

Definition at line 1210 of file cdprocs.h.

Referenced by _At_(), and CdCreateUserMdl().

RemainingName

_Inout_ PFCB _Inout_ PUNICODE_STRING RemainingName

Definition at line 802 of file cdprocs.h.

Referenced by _Requires_lock_held_(), CdDissectName(), CmpComputeHashValue(), CmpGetNextName(), CmpGetSymbolicLink(), CmpLookInCache(), CmpParseKey(), CmpRemoveSubkeysInRemainingName(), ExpWinStaObjectParse(), IntDesktopObjectParse(), IntWinStaObjectParse(), IopCheckVpbMounted(), IopParseDevice(), IopParseFile(), ObpLookupObjectName(), ObpParseSymbolicLink(), RxCreateTreeConnect(), RxFindOrConstructVirtualNetRoot(), RxFindOrCreateConnections(), RxPrefixTableLookupName(), and RxTableLookupName().

RemovedStartingFcb

_Inout_ PFCB _Out_ PBOOLEAN RemovedStartingFcb

Definition at line 1260 of file cdprocs.h.

Referenced by _Requires_lock_held_().

Resource

_Acquires_lock_ _Curr_ PERESOURCE Resource

Definition at line 843 of file cdprocs.h.

Referenced by _Requires_lock_held_(), AcpiBufferToResource(), AcpiResourceToAddress64(), AcpiRsConvertAmlToResource(), AcpiRsConvertAmlToResources(), AcpiRsConvertResourcesToAml(), AcpiRsConvertResourceToAml(), AcpiRsCreateResourceList(), AcpiRsDumpAddressCommon(), AcpiRsDumpDescriptor(), AcpiRsGetAddressCommon(), AcpiRsGetAmlLength(), AcpiRsMatchVendorResource(), AcpiRsSetAddressCommon(), AcpiWalkResourceBuffer(), DLDAcquireExclusive(), DLDAcquireShared(), DLDpAcquireResourceExclusiveLite(), DLDpFindCurrentThread(), DLDProcessResource(), DLDProcessThread(), DLDpWaitForResource(), DxEngLockHdev(), DxEngUnlockHdev(), ExAcquireResourceExclusiveLite(), ExAcquireResourceLock(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToSharedLite(), ExDeleteResourceLite(), ExDisableResourceBoostLite(), ExEnterCriticalRegionAndAcquireResourceExclusive(), ExEnterCriticalRegionAndAcquireResourceShared(), ExEnterCriticalRegionAndAcquireSharedWaitForExclusive(), ExGetExclusiveWaiterCount(), ExGetSharedWaiterCount(), ExInitializeResourceLite(), ExIsResourceAcquiredExclusiveLite(), ExIsResourceAcquiredSharedLite(), ExpAllocateExclusiveWaiterEvent(), ExpAllocateSharedWaiterSemaphore(), ExpExpandResourceOwnerTable(), ExpFindEntryForThread(), ExpFindFreeEntry(), ExpWaitForResource(), ExReinitializeResourceLite(), ExReleaseResourceAndLeaveCriticalRegion(), ExReleaseResourceForThreadLite(), ExReleaseResourceLite(), ExReleaseResourceLock(), ExSetResourceOwnerPointer(), Ext2EresourceAlignmentChecking(), ExTryToAcquireResourceExclusiveLite(), FatAllocateResource(), FatFreeResource(), FindDmaDescriptor(), FindIoDescriptor(), FindIrqDescriptor(), FindMemoryDescriptor(), FsRtlCopyRead2(), FxResourceCm::FxResourceCm(), FxResourceIo::FxResourceIo(), InitializeIdEntry(), InitializeNamedEntry(), InitializeTestResource(), IsaPnpCreateLogicalDeviceRequirements(), KsLoadResource(), LdrAccessResource(), LoadMenuA(), LoadMenuW(), main(), NdisCloseConfiguration(), NtfsWrite(), NtGetVersionResource(), ParseTags(), PciQueryResources(), RtlAcquireResourceExclusive(), RtlAcquireResourceShared(), RtlConvertExclusiveToShared(), RtlConvertSharedToExclusive(), RtlDeleteResource(), RtlDumpResource(), RtlInitializeResource(), RtlReleaseResource(), START_TEST(), UDFAcquireResourceExclusiveWithCheck(), UDFAcquireResourceSharedWithCheck(), UDFIsResourceAcquired(), UDFPostStackOverflowRead(), VfatRead(), and VfatWrite().

ShortNameDirentOffset

_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG ShortNameDirentOffset

Definition at line 462 of file cdprocs.h.

StartingFcb

_Inout_ PFCB StartingFcb

Definition at line 1259 of file cdprocs.h.

Referenced by _Requires_lock_held_().

StartingOffset

_Must_inspect_result_ __drv_aliasesMem _In_ PDEVICE_OBJECT _Inout_opt_ PVOID _In_opt_ ULONG _In_opt_ PLARGE_INTEGER StartingOffset

Definition at line 291 of file cdprocs.h.

Referenced by _Requires_lock_held_(), _When_(), CdReadSectors(), ClasspDeviceGetLBAStatusWorker(), ClasspDeviceTrimProcess(), DeleteRemoteDatabaseEntry(), ExtReadPartialBlock(), FatReadPartialCluster(), FstubDbgPrintPartitionEx(), FstubReadSector(), FstubWriteSector(), GetRemoteDatabaseEntry(), IoBuildAsynchronousFsdRequest(), IoBuildSynchronousFsdRequest(), IopCreateArcNamesCd(), IopCreateArcNamesDisk(), main(), NtfsReadDisk(), NtfsWriteDisk(), ScratchBuffer_SetupReadWriteSrb(), sync_read_phys(), WriteAttribute(), xHalIoReadPartitionTable(), and xHalIoWritePartitionTable().

Type

_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE _In_ BOOLEAN _In_ TYPE_OF_ACQUIRE Type

Definition at line 845 of file cdprocs.h.

TypeOfOpen

_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN TypeOfOpen

Definition at line 589 of file cdprocs.h.

Referenced by _At_(), _Function_class_(), _Requires_lock_held_(), _When_(), CdCommonDevControl(), CdCommonLockControl(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), CdFastUnlockSingle(), CdIsVolumeDirty(), FatDecodeFileObject(), FatFspDispatch(), FatIsVolumeDirty(), FatSetFileObject(), and FatSetZeroOnDeallocate().

Vcb

_Inout_ PVCB Vcb

Definition at line 235 of file cdprocs.h.