fsrtl.h File Reference

Go to the source code of this file.

Classes
struct	_FSRTL_COMMON_FCB_HEADER
struct	_FSRTL_ADVANCED_FCB_HEADER
struct	_EOF_WAIT_BLOCK
struct	_FSRTL_AUXILIARY_BUFFER
struct	_FILE_LOCK_INFO
struct	_FILE_LOCK
struct	TUNNEL
struct	_LARGE_MCB
struct	_MCB
struct	_FSRTL_FILTER_CONTEXT
Defines
#define	FSRTL_FLAG_FILE_MODIFIED   (0x01)
#define	FSRTL_FLAG_FILE_LENGTH_CHANGED   (0x02)
#define	FSRTL_FLAG_LIMIT_MODIFIED_PAGES   (0x04)
#define	FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX   (0x08)
#define	FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH   (0x10)
#define	FSRTL_FLAG_USER_MAPPED_FILE   (0x20)
#define	FSRTL_FLAG_ADVANCED_HEADER   (0x40)
#define	FSRTL_FLAG_EOF_ADVANCE_ACTIVE   (0x80)
#define	FSRTL_FLAG2_DO_MODIFIED_WRITE   (0x01)
#define	FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS   (0x02)
#define	FSRTL_FLAG2_PURGE_WHEN_MAPPED   (0x04)
#define	FSRTL_FSP_TOP_LEVEL_IRP   0x01
#define	FSRTL_CACHE_TOP_LEVEL_IRP   0x02
#define	FSRTL_MOD_WRITE_TOP_LEVEL_IRP   0x03
#define	FSRTL_FAST_IO_TOP_LEVEL_IRP   0x04
#define	FSRTL_MAX_TOP_LEVEL_IRP_FLAG   0x04
#define	FSRTL_AUXILIARY_FLAG_DEALLOCATE   0x00000001
#define	FsRtlSetTopLevelIrpForModWriter()
#define	FsRtlFastLock(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)
#define	FsRtlAreThereCurrentFileLocks(FL)
#define	LEGAL_ANSI_CHARACTER_ARRAY   FsRtlLegalAnsiCharacterArray
#define	NLS_MB_CODE_PAGE_TAG   NlsMbOemCodePageTag
#define	NLS_OEM_LEAD_BYTE_INFO   NlsOemLeadByteInfo
#define	FSRTL_FAT_LEGAL   0x01
#define	FSRTL_HPFS_LEGAL   0x02
#define	FSRTL_NTFS_LEGAL   0x04
#define	FSRTL_WILD_CHARACTER   0x08
#define	FSRTL_OLE_LEGAL   0x10
#define	FSRTL_NTFS_STREAM_LEGAL   (FSRTL_NTFS_LEGAL | FSRTL_OLE_LEGAL)
#define	FsRtlIsAnsiCharacterWild(C)
#define	FsRtlIsAnsiCharacterLegalFat(C, WILD_OK)
#define	FsRtlIsAnsiCharacterLegalHpfs(C, WILD_OK)
#define	FsRtlIsAnsiCharacterLegalNtfs(C, WILD_OK)
#define	FsRtlIsAnsiCharacterLegalNtfsStream(C, WILD_OK)
#define	FsRtlIsAnsiCharacterLegal(C, FLAGS)
#define	FsRtlTestAnsiCharacter(C, DEFAULT_RET, WILD_OK, FLAGS)
#define	FsRtlIsLeadDbcsCharacter(DBCS_CHAR)
#define	FsRtlAllocatePoolWithTag(PoolType, NumberOfBytes, Tag)
#define	FsRtlAllocatePoolWithQuotaTag(PoolType, NumberOfBytes, Tag)
#define	FSRTL_VOLUME_DISMOUNT   1
#define	FSRTL_VOLUME_DISMOUNT_FAILED   2
#define	FSRTL_VOLUME_LOCK   3
#define	FSRTL_VOLUME_LOCK_FAILED   4
#define	FSRTL_VOLUME_UNLOCK   5
#define	FSRTL_VOLUME_MOUNT   6
#define	FsRtlIsUnicodeCharacterWild(C)
#define	FsRtlLookupFilterContext(fo, oid, iid)
#define	FsRtlCompleteRequest(IRP, STATUS)
#define	FsRtlEnterFileSystem()
#define	FsRtlExitFileSystem()
Typedefs
typedef ULONG	LBN
typedef LBN *	PLBN
typedef ULONG	VBN
typedef VBN *	PVBN
typedef enum _FAST_IO_POSSIBLE	FAST_IO_POSSIBLE
typedef _FSRTL_COMMON_FCB_HEADER	FSRTL_COMMON_FCB_HEADER
typedef FSRTL_COMMON_FCB_HEADER *	PFSRTL_COMMON_FCB_HEADER
typedef _FSRTL_ADVANCED_FCB_HEADER	FSRTL_ADVANCED_FCB_HEADER
typedef FSRTL_ADVANCED_FCB_HEADER *	PFSRTL_ADVANCED_FCB_HEADER
typedef _EOF_WAIT_BLOCK	EOF_WAIT_BLOCK
typedef EOF_WAIT_BLOCK *	PEOF_WAIT_BLOCK
typedef _FSRTL_AUXILIARY_BUFFER	FSRTL_AUXILIARY_BUFFER
typedef FSRTL_AUXILIARY_BUFFER *	PFSRTL_AUXILIARY_BUFFER
typedef _FILE_LOCK_INFO	FILE_LOCK_INFO
typedef FILE_LOCK_INFO *	PFILE_LOCK_INFO
typedef NTSTATUS(*	PCOMPLETE_LOCK_IRP_ROUTINE )(IN PVOID Context, IN PIRP Irp)
typedef VOID(*	PUNLOCK_ROUTINE )(IN PVOID Context, IN PFILE_LOCK_INFO FileLockInfo)
typedef _FILE_LOCK	FILE_LOCK
typedef FILE_LOCK *	PFILE_LOCK
typedef *	PTUNNEL
typedef enum _FSRTL_COMPARISON_RESULT	FSRTL_COMPARISON_RESULT
typedef _LARGE_MCB	LARGE_MCB
typedef LARGE_MCB *	PLARGE_MCB
typedef _MCB	MCB
typedef MCB *	PMCB
typedef PVOID	OPLOCK
typedef PVOID *	POPLOCK
typedef VOID(*	POPLOCK_WAIT_COMPLETE_ROUTINE )(IN PVOID Context, IN PIRP Irp)
typedef VOID(*	POPLOCK_FS_PREPOST_IRP )(IN PVOID Context, IN PIRP Irp)
typedef PVOID	PNOTIFY_SYNC
typedef BOOLEAN(*	PCHECK_FOR_TRAVERSE_ACCESS )(IN PVOID NotifyContext, IN PVOID TargetContext, IN PSECURITY_SUBJECT_CONTEXT SubjectContext)
typedef VOID(*	PFSRTL_STACK_OVERFLOW_ROUTINE )(IN PVOID Context, IN PKEVENT Event)
typedef _FSRTL_FILTER_CONTEXT	FSRTL_FILTER_CONTEXT
typedef _FSRTL_FILTER_CONTEXT *	PFSRTL_FILTER_CONTEXT
Enumerations
enum	_FAST_IO_POSSIBLE { FastIoIsNotPossible = 0, FastIoIsPossible, FastIoIsQuestionable }
enum	_FSRTL_COMPARISON_RESULT { LessThan = -1, EqualTo = 0, GreaterThan = 1 }
Functions
NTKERNELAPI BOOLEAN	FsRtlInitSystem ()
NTKERNELAPI BOOLEAN	FsRtlCopyRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlCopyWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlMdlRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN	FsRtlMdlReadComplete (IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
NTKERNELAPI BOOLEAN	FsRtlPrepareMdlWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN	FsRtlMdlWriteComplete (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
NTKERNELAPI BOOLEAN	FsRtlMdlReadDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlMdlReadCompleteDev (IN PFILE_OBJECT FileObject, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlPrepareMdlWriteDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlMdlWriteCompleteDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlAcquireFileForModWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER StartingOffset, OUT PERESOURCE *ResourceToRelease)
NTKERNELAPI VOID	FsRtlReleaseFileForModWrite (IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease)
NTKERNELAPI VOID	FsRtlAcquireFileForCcFlush (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlReleaseFileForCcFlush (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlAcquireFileExclusive (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlReleaseFile (IN PFILE_OBJECT FileObject)
NTSTATUS	FsRtlGetFileSize (IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)
NTSTATUS	FsRtlSetFileSize (IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)
NTKERNELAPI BOOLEAN	FsRtlIsTotalDeviceFailure (IN NTSTATUS Status)
PFILE_LOCK	FsRtlAllocateFileLock (IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL)
VOID	FsRtlFreeFileLock (IN PFILE_LOCK FileLock)
NTKERNELAPI VOID	FsRtlInitializeFileLock (IN PFILE_LOCK FileLock, IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL)
NTKERNELAPI VOID	FsRtlUninitializeFileLock (IN PFILE_LOCK FileLock)
NTKERNELAPI NTSTATUS	FsRtlProcessFileLock (IN PFILE_LOCK FileLock, IN PIRP Irp, IN PVOID Context OPTIONAL)
NTKERNELAPI BOOLEAN	FsRtlCheckLockForReadAccess (IN PFILE_LOCK FileLock, IN PIRP Irp)
NTKERNELAPI BOOLEAN	FsRtlCheckLockForWriteAccess (IN PFILE_LOCK FileLock, IN PIRP Irp)
NTKERNELAPI BOOLEAN	FsRtlFastCheckLockForRead (IN PFILE_LOCK FileLock, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID ProcessId)
NTKERNELAPI BOOLEAN	FsRtlFastCheckLockForWrite (IN PFILE_LOCK FileLock, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER Length, IN ULONG Key, IN PVOID FileObject, IN PVOID ProcessId)
NTKERNELAPI PFILE_LOCK_INFO	FsRtlGetNextFileLock (IN PFILE_LOCK FileLock, IN BOOLEAN Restart)
NTKERNELAPI NTSTATUS	FsRtlFastUnlockSingle (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN LARGE_INTEGER UNALIGNED *FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS ProcessId, IN ULONG Key, IN PVOID Context OPTIONAL, IN BOOLEAN AlreadySynchronized)
NTKERNELAPI NTSTATUS	FsRtlFastUnlockAll (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS ProcessId, IN PVOID Context OPTIONAL)
NTKERNELAPI NTSTATUS	FsRtlFastUnlockAllByKey (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS ProcessId, IN ULONG Key, IN PVOID Context OPTIONAL)
NTKERNELAPI BOOLEAN	FsRtlPrivateLock (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS ProcessId, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK Iosb, IN PIRP Irp, IN PVOID Context, IN BOOLEAN AlreadySynchronized)
NTKERNELAPI VOID	FsRtlInitializeTunnelCache (IN TUNNEL *Cache)
NTKERNELAPI VOID	FsRtlAddToTunnelCache (IN TUNNEL *Cache, IN ULONGLONG DirectoryKey, IN UNICODE_STRING *ShortName, IN UNICODE_STRING *LongName, IN BOOLEAN KeyByShortName, IN ULONG DataLength, IN VOID *Data)
NTKERNELAPI BOOLEAN	FsRtlFindInTunnelCache (IN TUNNEL *Cache, IN ULONGLONG DirectoryKey, IN UNICODE_STRING *Name, OUT UNICODE_STRING *ShortName, OUT UNICODE_STRING *LongName, IN OUT ULONG *DataLength, OUT VOID *Data)
NTKERNELAPI VOID	FsRtlDeleteKeyFromTunnelCache (IN TUNNEL *Cache, IN ULONGLONG DirectoryKey)
NTKERNELAPI VOID	FsRtlDeleteTunnelCache (IN TUNNEL *Cache)
NTKERNELAPI VOID	FsRtlDissectDbcs (IN ANSI_STRING InputName, OUT PANSI_STRING FirstPart, OUT PANSI_STRING RemainingPart)
NTKERNELAPI BOOLEAN	FsRtlDoesDbcsContainWildCards (IN PANSI_STRING Name)
NTKERNELAPI BOOLEAN	FsRtlIsDbcsInExpression (IN PANSI_STRING Expression, IN PANSI_STRING Name)
NTKERNELAPI BOOLEAN	FsRtlIsFatDbcsLegal (IN ANSI_STRING DbcsName, IN BOOLEAN WildCardsPermissible, IN BOOLEAN PathNamePermissible, IN BOOLEAN LeadingBackslashPermissible)
NTKERNELAPI BOOLEAN	FsRtlIsHpfsDbcsLegal (IN ANSI_STRING DbcsName, IN BOOLEAN WildCardsPermissible, IN BOOLEAN PathNamePermissible, IN BOOLEAN LeadingBackslashPermissible)
NTKERNELAPI NTSTATUS	FsRtlNormalizeNtstatus (IN NTSTATUS Exception, IN NTSTATUS GenericException)
NTKERNELAPI BOOLEAN	FsRtlIsNtstatusExpected (IN NTSTATUS Exception)
NTKERNELAPI PERESOURCE	FsRtlAllocateResource ()
NTKERNELAPI VOID	FsRtlInitializeLargeMcb (IN PLARGE_MCB Mcb, IN POOL_TYPE PoolType)
NTKERNELAPI VOID	FsRtlUninitializeLargeMcb (IN PLARGE_MCB Mcb)
NTKERNELAPI VOID	FsRtlResetLargeMcb (IN PLARGE_MCB Mcb, IN BOOLEAN SelfSynchronized)
NTKERNELAPI VOID	FsRtlTruncateLargeMcb (IN PLARGE_MCB Mcb, IN LONGLONG Vbn)
NTKERNELAPI BOOLEAN	FsRtlAddLargeMcbEntry (IN PLARGE_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG Lbn, IN LONGLONG SectorCount)
NTKERNELAPI VOID	FsRtlRemoveLargeMcbEntry (IN PLARGE_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG SectorCount)
NTKERNELAPI BOOLEAN	FsRtlLookupLargeMcbEntry (IN PLARGE_MCB Mcb, IN LONGLONG Vbn, OUT PLONGLONG Lbn OPTIONAL, OUT PLONGLONG SectorCountFromLbn OPTIONAL, OUT PLONGLONG StartingLbn OPTIONAL, OUT PLONGLONG SectorCountFromStartingLbn OPTIONAL, OUT PULONG Index OPTIONAL)
NTKERNELAPI BOOLEAN	FsRtlLookupLastLargeMcbEntry (IN PLARGE_MCB Mcb, OUT PLONGLONG Vbn, OUT PLONGLONG Lbn)
NTKERNELAPI BOOLEAN	FsRtlLookupLastLargeMcbEntryAndIndex (IN PLARGE_MCB OpaqueMcb, OUT PLONGLONG LargeVbn, OUT PLONGLONG LargeLbn, OUT PULONG Index)
NTKERNELAPI ULONG	FsRtlNumberOfRunsInLargeMcb (IN PLARGE_MCB Mcb)
NTKERNELAPI BOOLEAN	FsRtlGetNextLargeMcbEntry (IN PLARGE_MCB Mcb, IN ULONG RunIndex, OUT PLONGLONG Vbn, OUT PLONGLONG Lbn, OUT PLONGLONG SectorCount)
NTKERNELAPI BOOLEAN	FsRtlSplitLargeMcb (IN PLARGE_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG Amount)
NTKERNELAPI VOID	FsRtlInitializeMcb (IN PMCB Mcb, IN POOL_TYPE PoolType)
NTKERNELAPI VOID	FsRtlUninitializeMcb (IN PMCB Mcb)
NTKERNELAPI VOID	FsRtlTruncateMcb (IN PMCB Mcb, IN VBN Vbn)
NTKERNELAPI BOOLEAN	FsRtlAddMcbEntry (IN PMCB Mcb, IN VBN Vbn, IN LBN Lbn, IN ULONG SectorCount)
NTKERNELAPI VOID	FsRtlRemoveMcbEntry (IN PMCB Mcb, IN VBN Vbn, IN ULONG SectorCount)
NTKERNELAPI BOOLEAN	FsRtlLookupMcbEntry (IN PMCB Mcb, IN VBN Vbn, OUT PLBN Lbn, OUT PULONG SectorCount OPTIONAL, OUT PULONG Index)
NTKERNELAPI BOOLEAN	FsRtlLookupLastMcbEntry (IN PMCB Mcb, OUT PVBN Vbn, OUT PLBN Lbn)
NTKERNELAPI ULONG	FsRtlNumberOfRunsInMcb (IN PMCB Mcb)
NTKERNELAPI BOOLEAN	FsRtlGetNextMcbEntry (IN PMCB Mcb, IN ULONG RunIndex, OUT PVBN Vbn, OUT PLBN Lbn, OUT PULONG SectorCount)
NTKERNELAPI NTSTATUS	FsRtlBalanceReads (IN PDEVICE_OBJECT TargetDevice)
NTKERNELAPI NTSTATUS	FsRtlSyncVolumes (IN PDEVICE_OBJECT TargetDevice, IN PLARGE_INTEGER ByteOffset OPTIONAL, IN PLARGE_INTEGER ByteCount)
NTKERNELAPI VOID	FsRtlInitializeOplock (IN OUT POPLOCK Oplock)
NTKERNELAPI VOID	FsRtlUninitializeOplock (IN OUT POPLOCK Oplock)
NTKERNELAPI NTSTATUS	FsRtlOplockFsctrl (IN POPLOCK Oplock, IN PIRP Irp, IN ULONG OpenCount)
NTKERNELAPI NTSTATUS	FsRtlCheckOplock (IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
NTKERNELAPI BOOLEAN	FsRtlOplockIsFastIoPossible (IN POPLOCK Oplock)
NTKERNELAPI BOOLEAN	FsRtlCurrentBatchOplock (IN POPLOCK Oplock)
NTKERNELAPI NTSTATUS	FsRtlNotifyVolumeEvent (IN PFILE_OBJECT FileObject, IN ULONG EventCode)
NTKERNELAPI VOID	FsRtlNotifyInitializeSync (IN PNOTIFY_SYNC *NotifySync)
NTKERNELAPI VOID	FsRtlNotifyUninitializeSync (IN PNOTIFY_SYNC *NotifySync)
NTKERNELAPI VOID	FsRtlNotifyChangeDirectory (IN PNOTIFY_SYNC NotifySync, IN PVOID FsContext, IN PSTRING FullDirectoryName, IN PLIST_ENTRY NotifyList, IN BOOLEAN WatchTree, IN ULONG CompletionFilter, IN PIRP NotifyIrp)
NTKERNELAPI VOID	FsRtlNotifyFullChangeDirectory (IN PNOTIFY_SYNC NotifySync, IN PLIST_ENTRY NotifyList, IN PVOID FsContext, IN PSTRING FullDirectoryName, IN BOOLEAN WatchTree, IN BOOLEAN IgnoreBuffer, IN ULONG CompletionFilter, IN PIRP NotifyIrp, IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL, IN PSECURITY_SUBJECT_CONTEXT SubjectContext OPTIONAL)
NTKERNELAPI VOID	FsRtlNotifyReportChange (IN PNOTIFY_SYNC NotifySync, IN PLIST_ENTRY NotifyList, IN PSTRING FullTargetName, IN PSTRING TargetName, IN ULONG FilterMatch)
NTKERNELAPI VOID	FsRtlNotifyFullReportChange (IN PNOTIFY_SYNC NotifySync, IN PLIST_ENTRY NotifyList, IN PSTRING FullTargetName, IN USHORT TargetNameOffset, IN PSTRING StreamName OPTIONAL, IN PSTRING NormalizedParentName OPTIONAL, IN ULONG FilterMatch, IN ULONG Action, IN PVOID TargetContext)
NTKERNELAPI VOID	FsRtlNotifyCleanup (IN PNOTIFY_SYNC NotifySync, IN PLIST_ENTRY NotifyList, IN PVOID FsContext)
NTKERNELAPI VOID	FsRtlDissectName (IN UNICODE_STRING Path, OUT PUNICODE_STRING FirstName, OUT PUNICODE_STRING RemainingName)
NTKERNELAPI BOOLEAN	FsRtlDoesNameContainWildCards (IN PUNICODE_STRING Name)
NTKERNELAPI BOOLEAN	FsRtlAreNamesEqual (PCUNICODE_STRING ConstantNameA, PCUNICODE_STRING ConstantNameB, IN BOOLEAN IgnoreCase, IN PCWCH UpcaseTable OPTIONAL)
NTKERNELAPI BOOLEAN	FsRtlIsNameInExpression (IN PUNICODE_STRING Expression, IN PUNICODE_STRING Name, IN BOOLEAN IgnoreCase, IN PWCH UpcaseTable OPTIONAL)
NTKERNELAPI VOID	FsRtlPostStackOverflow (IN PVOID Context, IN PKEVENT Event, IN PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)
NTKERNELAPI VOID	FsRtlPostPagingFileStackOverflow (IN PVOID Context, IN PKEVENT Event, IN PFSRTL_STACK_OVERFLOW_ROUTINE StackOverflowRoutine)
NTKERNELAPI NTSTATUS	FsRtlRegisterUncProvider (IN OUT PHANDLE MupHandle, IN PUNICODE_STRING RedirectorDeviceName, IN BOOLEAN MailslotsSupported)
NTKERNELAPI VOID	FsRtlDeregisterUncProvider (IN HANDLE Handle)
NTKERNELAPI NTSTATUS	FsRtlInsertFilterContext (IN PFILE_OBJECT FileObject, IN PFSRTL_FILTER_CONTEXT Ptr)
NTKERNELAPI PFSRTL_FILTER_CONTEXT	FsRtlLookupFilterContextInternal (IN PFILE_OBJECT FileObject, IN PVOID OwnerId OPTIONAL, IN PVOID InstanceId OPTIONAL)
NTKERNELAPI PFSRTL_FILTER_CONTEXT	FsRtlRemoveFilterContext (IN PFILE_OBJECT FileObject, IN PVOID OwnerId OPTIONAL, IN PVOID InstanceId OPTIONAL)
NTKERNELAPI VOID	FsRtlTeardownFilterContexts (IN PLIST_ENTRY FilterContexts)
Variables
PUCHAR	LEGAL_ANSI_CHARACTER_ARRAY
PUSHORT	NLS_OEM_LEAD_BYTE_INFO

---

Define Documentation

#define FSRTL_AUXILIARY_FLAG_DEALLOCATE   0x00000001

Definition at line 453 of file fsrtl.h.

#define FSRTL_CACHE_TOP_LEVEL_IRP   0x02

Definition at line 283 of file fsrtl.h. Referenced by UdfAcquireForCache(), and UdfReleaseFromCache().

#define FSRTL_FAST_IO_TOP_LEVEL_IRP   0x04

Definition at line 285 of file fsrtl.h. Referenced by FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), and FsRtlPrepareMdlWriteDev().

#define FSRTL_FAT_LEGAL   0x01

Definition at line 935 of file fsrtl.h.

#define FSRTL_FLAG2_DO_MODIFIED_WRITE   (0x01)

Definition at line 256 of file fsrtl.h. Referenced by CcInitializeCacheMap().

#define FSRTL_FLAG2_PURGE_WHEN_MAPPED   (0x04)

Definition at line 272 of file fsrtl.h. Referenced by CcZeroEndOfLastPage().

#define FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS   (0x02)

Definition at line 265 of file fsrtl.h. Referenced by FsRtlInsertFilterContext(), FsRtlLookupFilterContextInternal(), and FsRtlRemoveFilterContext().

#define FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX   (0x08)

Definition at line 221 of file fsrtl.h. Referenced by FsRtlAcquireFileForModWrite().

#define FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH   (0x10)

Definition at line 222 of file fsrtl.h. Referenced by FsRtlAcquireFileForModWrite().

#define FSRTL_FLAG_ADVANCED_HEADER   (0x40)

Definition at line 236 of file fsrtl.h. Referenced by CcCopyWrite(), and CcZeroEndOfLastPage().

#define FSRTL_FLAG_EOF_ADVANCE_ACTIVE   (0x80)

Definition at line 243 of file fsrtl.h.

#define FSRTL_FLAG_FILE_LENGTH_CHANGED   (0x02)

Definition at line 210 of file fsrtl.h.

#define FSRTL_FLAG_FILE_MODIFIED   (0x01)

Definition at line 209 of file fsrtl.h.

#define FSRTL_FLAG_LIMIT_MODIFIED_PAGES   (0x04)

Definition at line 211 of file fsrtl.h. Referenced by CcCanIWrite(), CcDeferWrite(), and CcSetDirtyPageThreshold().

#define FSRTL_FLAG_USER_MAPPED_FILE   (0x20)

Definition at line 229 of file fsrtl.h. Referenced by CcFlushCache(), and CcZeroEndOfLastPage().

#define FSRTL_FSP_TOP_LEVEL_IRP   0x01

Definition at line 282 of file fsrtl.h. Referenced by FsRtlStackOverflowRead(), MiRemoveUnusedSegments(), and MmCreateSection().

#define FSRTL_HPFS_LEGAL   0x02

Definition at line 936 of file fsrtl.h.

#define FSRTL_MAX_TOP_LEVEL_IRP_FLAG   0x04

Definition at line 286 of file fsrtl.h.

#define FSRTL_MOD_WRITE_TOP_LEVEL_IRP   0x03

Definition at line 284 of file fsrtl.h.

#define FSRTL_NTFS_LEGAL   0x04

Definition at line 937 of file fsrtl.h.

#define FSRTL_NTFS_STREAM_LEGAL   (FSRTL_NTFS_LEGAL | FSRTL_OLE_LEGAL)

Definition at line 940 of file fsrtl.h.

#define FSRTL_OLE_LEGAL   0x10

Definition at line 939 of file fsrtl.h.

#define FSRTL_VOLUME_DISMOUNT   1

Definition at line 1421 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), and UdfDismountVolume().

#define FSRTL_VOLUME_DISMOUNT_FAILED   2

Definition at line 1422 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), and UdfDismountVolume().

#define FSRTL_VOLUME_LOCK   3

Definition at line 1423 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), and UdfLockVolume().

#define FSRTL_VOLUME_LOCK_FAILED   4

Definition at line 1424 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), and UdfLockVolume().

#define FSRTL_VOLUME_MOUNT   6

Definition at line 1426 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), UdfMountVolume(), and UdfVerifyVolume().

#define FSRTL_VOLUME_UNLOCK   5

Definition at line 1425 of file fsrtl.h. Referenced by FsRtlNotifyVolumeEvent(), UdfCommonCleanup(), and UdfUnlockVolume().

#define FSRTL_WILD_CHARACTER   0x08

Definition at line 938 of file fsrtl.h.

#define FsRtlAllocatePoolWithQuotaTag (  PoolType, NumberOfBytes, Tag   )

Value: ExAllocatePoolWithQuotaTag((POOL_TYPE)((PoolType) | POOL_RAISE_IF_ALLOCATION_FAILURE), \ NumberOfBytes, \ Tag) Definition at line 1107 of file fsrtl.h.

#define FsRtlAllocatePoolWithTag (  PoolType, NumberOfBytes, Tag   )

Value: ExAllocatePoolWithTag((POOL_TYPE)((PoolType) | POOL_RAISE_IF_ALLOCATION_FAILURE), \ NumberOfBytes, \ Tag) Definition at line 1101 of file fsrtl.h. Referenced by CcAllocateObcb(), CcExtendVacbArray(), CcInitializeVacbs(), FsRtlFindInTunnelCache(), UdfAllocateTable(), UdfCreatePcb(), UdfDetermineVolumeBounding(), UdfEnumerateIndex(), UdfFindAnchorVolumeDescriptor(), UdfFindDirEntry(), UdfFindFileSetDescriptor(), UdfFindVolumeDescriptors(), UdfInitializeCrc16(), UdfInitializeEnumeration(), UdfInitializePcb(), UdfInsertPrefix(), UdfLoadSparingTables(), UdfLookupDirEntryPostProcessing(), UdfNormalizeFileNames(), UdfPrepareBuffers(), UdfRecognizeVolume(), UdfStoreVolumeDescriptorIfPrevailing(), UdfUpdateDirNames(), and UdfUpdateVcbPhase0().

#define FsRtlAreThereCurrentFileLocks (  FL   )

Value: ( \ ((FL)->FastIoIsQuestionable)) Definition at line 807 of file fsrtl.h. Referenced by UdfFastUnlockSingle(), and UdfOplockRequest().

#define FsRtlCompleteRequest (  IRP, STATUS   )

Value: { \ (IRP)->IoStatus.Status = (STATUS); \ IoCompleteRequest( (IRP), IO_DISK_INCREMENT ); \ } Definition at line 1745 of file fsrtl.h. Referenced by FsRtlAcknowledgeOplockBreak(), FsRtlCancelExclusiveIrp(), FsRtlCancelNotify(), FsRtlCompleteLockIrpReal(), FsRtlNotifyCompleteIrp(), FsRtlNotifyCompletion(), FsRtlNotifyFullChangeDirectory(), FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakNotify(), FsRtlOplockBreakToII(), FsRtlOplockBreakToNone(), FsRtlOplockCleanup(), FsRtlOplockFsctrl(), FsRtlProcessFileLock(), FsRtlRemoveAndCompleteIrp(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), and FsRtlUninitializeOplock().

#define FsRtlEnterFileSystem (   )

Value: { \ KeEnterCriticalRegion(); \ } Definition at line 1772 of file fsrtl.h. Referenced by FsRtlAcquireFileExclusive(), FsRtlAcquireFileForCcFlush(), FsRtlCancelNotify(), FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), FsRtlPrepareMdlWriteDev(), UdfFastLock(), UdfFastQueryBasicInfo(), UdfFastQueryNetworkInfo(), UdfFastQueryStdInfo(), UdfFastUnlockAll(), UdfFastUnlockAllByKey(), UdfFastUnlockSingle(), UdfFsdDispatch(), UdfFspClose(), and UdfFspDispatch().

#define FsRtlExitFileSystem (   )

Value: { \ KeLeaveCriticalRegion(); \ } Definition at line 1795 of file fsrtl.h. Referenced by FsRtlCancelNotify(), FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), FsRtlPrepareMdlWriteDev(), FsRtlReleaseFile(), FsRtlReleaseFileForCcFlush(), UdfFastLock(), UdfFastQueryBasicInfo(), UdfFastQueryNetworkInfo(), UdfFastQueryStdInfo(), UdfFastUnlockAll(), UdfFastUnlockAllByKey(), UdfFastUnlockSingle(), UdfFsdDispatch(), UdfFspClose(), and UdfFspDispatch().

#define FsRtlFastLock (  A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11   )

Value: ( \ FsRtlPrivateLock( A1, /* FileLock */ \ A2, /* FileObject */ \ A3, /* FileOffset */ \ A4, /* Length */ \ A5, /* ProcessId */ \ A6, /* Key */ \ A7, /* FailImmediately */ \ A8, /* ExclusiveLock */ \ A9, /* Iosb */ \ NULL, /* Irp */ \ A10, /* Context */ \ A11 /* AlreadySynchronized */ ) \ ) Definition at line 785 of file fsrtl.h. Referenced by UdfFastLock().

#define FsRtlIsAnsiCharacterLegal (  C, FLAGS   )

Value: ( \ FsRtlTestAnsiCharacter((C), TRUE, FALSE, (FLAGS)) \ ) Definition at line 988 of file fsrtl.h.

#define FsRtlIsAnsiCharacterLegalFat (  C, WILD_OK   )

Value: ( \ FsRtlTestAnsiCharacter((C), TRUE, (WILD_OK), FSRTL_FAT_LEGAL) \ ) Definition at line 954 of file fsrtl.h. Referenced by FsRtlIsFatDbcsLegal().

#define FsRtlIsAnsiCharacterLegalHpfs (  C, WILD_OK   )

Value: ( \ FsRtlTestAnsiCharacter((C), TRUE, (WILD_OK), FSRTL_HPFS_LEGAL) \ ) Definition at line 962 of file fsrtl.h. Referenced by FsRtlIsHpfsDbcsLegal(), and UdfIsCharacterLegal().

#define FsRtlIsAnsiCharacterLegalNtfs (  C, WILD_OK   )

Value: ( \ FsRtlTestAnsiCharacter((C), TRUE, (WILD_OK), FSRTL_NTFS_LEGAL) \ ) Definition at line 970 of file fsrtl.h.

#define FsRtlIsAnsiCharacterLegalNtfsStream (  C, WILD_OK   )

Value: ( \ FsRtlTestAnsiCharacter((C), TRUE, (WILD_OK), FSRTL_NTFS_STREAM_LEGAL) \ ) Definition at line 979 of file fsrtl.h.

#define FsRtlIsAnsiCharacterWild (  C   )

Value: ( \ FsRtlTestAnsiCharacter((C), FALSE, FALSE, FSRTL_WILD_CHARACTER) \ ) Definition at line 946 of file fsrtl.h. Referenced by FsRtlDoesDbcsContainWildCards().

#define FsRtlIsLeadDbcsCharacter (  DBCS_CHAR   )

Value: ( \ (BOOLEAN)((UCHAR)(DBCS_CHAR) < 0x80 ? FALSE : \ (NLS_MB_CODE_PAGE_TAG && \ (NLS_OEM_LEAD_BYTE_INFO[(UCHAR)(DBCS_CHAR)] != 0))) \ ) Definition at line 1033 of file fsrtl.h. Referenced by FsRtlDissectDbcs(), FsRtlDoesDbcsContainWildCards(), FsRtlIsDbcsInExpression(), FsRtlIsFatDbcsLegal(), and FsRtlIsHpfsDbcsLegal().

#define FsRtlIsUnicodeCharacterWild (  C   )

Value: ( \ (((C) >= 0x40) ? FALSE : FlagOn( LEGAL_ANSI_CHARACTER_ARRAY[(C)], \ FSRTL_WILD_CHARACTER ) ) \ ) Definition at line 1538 of file fsrtl.h. Referenced by FsRtlDoesNameContainWildCards().

#define FsRtlLookupFilterContext (  fo, oid, iid   )

Value: (( (fo)->FsContext \ && ( ((PFSRTL_COMMON_FCB_HEADER)(fo)->FsContext)->Flags2 & \ FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS ) \ && !IsListEmpty( (PLIST_ENTRY) \ &((PFSRTL_COMMON_FCB_HEADER)(fo)->FsContext)->FilterContexts ) \ ) ? FsRtlLookupFilterContextInternal(fo, oid, iid) \ : NULL) Definition at line 1682 of file fsrtl.h.

#define FsRtlSetTopLevelIrpForModWriter (   )

Value: { \ IoSetTopLevelIrp((PIRP)FSRTL_MOD_WRITE_TOP_LEVEL_IRP); \ } Definition at line 465 of file fsrtl.h. Referenced by MiMappedPageWriter().

#define FsRtlTestAnsiCharacter (  C, DEFAULT_RET, WILD_OK, FLAGS   )

Value: ( \ ((SCHAR)(C) < 0) ? DEFAULT_RET : \ FlagOn( LEGAL_ANSI_CHARACTER_ARRAY[(C)], \ (FLAGS) | \ ((WILD_OK) ? FSRTL_WILD_CHARACTER : 0) ) \ ) Definition at line 997 of file fsrtl.h.

#define LEGAL_ANSI_CHARACTER_ARRAY   FsRtlLegalAnsiCharacterArray

Definition at line 921 of file fsrtl.h.

#define NLS_MB_CODE_PAGE_TAG   NlsMbOemCodePageTag

Definition at line 922 of file fsrtl.h.

#define NLS_OEM_LEAD_BYTE_INFO   NlsOemLeadByteInfo

Definition at line 923 of file fsrtl.h.

---

Typedef Documentation

typedef struct _EOF_WAIT_BLOCK EOF_WAIT_BLOCK

typedef enum _FAST_IO_POSSIBLE FAST_IO_POSSIBLE

typedef struct _FILE_LOCK FILE_LOCK

Referenced by FsRtlInitializeFileLocks().

typedef struct _FILE_LOCK_INFO FILE_LOCK_INFO

typedef struct _FSRTL_ADVANCED_FCB_HEADER FSRTL_ADVANCED_FCB_HEADER

typedef struct _FSRTL_AUXILIARY_BUFFER FSRTL_AUXILIARY_BUFFER

typedef struct _FSRTL_COMMON_FCB_HEADER FSRTL_COMMON_FCB_HEADER

typedef enum _FSRTL_COMPARISON_RESULT FSRTL_COMPARISON_RESULT

Referenced by UdfFindNameLink(), UdfFullCompareNames(), and UdfInsertNameLink().

typedef struct _FSRTL_FILTER_CONTEXT FSRTL_FILTER_CONTEXT

Referenced by FsRtlLookupFilterContextInternal().

typedef struct _LARGE_MCB LARGE_MCB

typedef ULONG LBN

Definition at line 29 of file fsrtl.h. Referenced by FsRtlAddLargeMcbEntry(), FsRtlLookupLargeMcbEntry(), FsRtlRemoveMcbEntryPrivate(), FsRtlSplitLargeMcb(), UdfAddVmcbMapping(), and UdfRemoveVmcbMapping().

typedef struct _MCB MCB

Referenced by main().

typedef PVOID OPLOCK

Definition at line 1355 of file fsrtl.h.

typedef BOOLEAN(* PCHECK_FOR_TRAVERSE_ACCESS)(IN PVOID NotifyContext, IN PVOID TargetContext, IN PSECURITY_SUBJECT_CONTEXT SubjectContext)

Definition at line 1446 of file fsrtl.h.

typedef NTSTATUS(* PCOMPLETE_LOCK_IRP_ROUTINE)(IN PVOID Context, IN PIRP Irp)

Definition at line 591 of file fsrtl.h. Referenced by FsRtlCompleteLockIrpReal().

typedef EOF_WAIT_BLOCK* PEOF_WAIT_BLOCK

Definition at line 300 of file fsrtl.h.

typedef FILE_LOCK* PFILE_LOCK

Definition at line 641 of file fsrtl.h. Referenced by UdfCreateFileLock().

typedef FILE_LOCK_INFO* PFILE_LOCK_INFO

Definition at line 579 of file fsrtl.h.

typedef FSRTL_ADVANCED_FCB_HEADER* PFSRTL_ADVANCED_FCB_HEADER

Definition at line 202 of file fsrtl.h. Referenced by CcCopyWrite().

typedef FSRTL_AUXILIARY_BUFFER* PFSRTL_AUXILIARY_BUFFER

Definition at line 442 of file fsrtl.h.

typedef FSRTL_COMMON_FCB_HEADER* PFSRTL_COMMON_FCB_HEADER

Definition at line 147 of file fsrtl.h. Referenced by CcFlushCache().

typedef struct _FSRTL_FILTER_CONTEXT * PFSRTL_FILTER_CONTEXT

Referenced by FsRtlInsertFilterContext().

typedef VOID(* PFSRTL_STACK_OVERFLOW_ROUTINE)(IN PVOID Context, IN PKEVENT Event)

Definition at line 1582 of file fsrtl.h.

typedef LARGE_MCB* PLARGE_MCB

Definition at line 1140 of file fsrtl.h. Referenced by UdfResetVmcb().

typedef LBN* PLBN

Definition at line 30 of file fsrtl.h.

typedef MCB* PMCB

Definition at line 1251 of file fsrtl.h.

typedef PVOID PNOTIFY_SYNC

Definition at line 1443 of file fsrtl.h. Referenced by FsRtlCancelNotify(), and FsRtlNotifyInitializeSync().

typedef PVOID * POPLOCK

Definition at line 1355 of file fsrtl.h.

typedef VOID(* POPLOCK_FS_PREPOST_IRP)(IN PVOID Context, IN PIRP Irp)

Definition at line 1366 of file fsrtl.h.

typedef VOID(* POPLOCK_WAIT_COMPLETE_ROUTINE)(IN PVOID Context, IN PIRP Irp)

Definition at line 1359 of file fsrtl.h.

typedef * PTUNNEL

typedef VOID(* PUNLOCK_ROUTINE)(IN PVOID Context, IN PFILE_LOCK_INFO FileLockInfo)

Definition at line 596 of file fsrtl.h. Referenced by FsRtlInitializeFileLock().

typedef VBN* PVBN

Definition at line 33 of file fsrtl.h.

typedef ULONG VBN

Definition at line 32 of file fsrtl.h. Referenced by FsRtlAddLargeMcbEntry(), FsRtlRemoveLargeMcbEntry(), FsRtlSplitLargeMcb(), FsRtlTruncateLargeMcb(), and UdfAddVmcbMapping().

---

Enumeration Type Documentation

enum _FAST_IO_POSSIBLE

Enumeration values: FastIoIsNotPossible  FastIoIsPossible  FastIoIsQuestionable  Definition at line 58 of file fsrtl.h. { FastIoIsNotPossible = 0, FastIoIsPossible, FastIoIsQuestionable } FAST_IO_POSSIBLE;

enum _FSRTL_COMPARISON_RESULT

Enumeration values: LessThan  EqualTo  GreaterThan  Definition at line 900 of file fsrtl.h. { LessThan = -1, EqualTo = 0, GreaterThan = 1 } FSRTL_COMPARISON_RESULT;

---

Function Documentation

NTKERNELAPI VOID FsRtlAcquireFileExclusive (  IN PFILE_OBJECT  FileObject  )

Definition at line 2555 of file fastio.c. References _FAST_IO_DISPATCH::AcquireFileForNtCreateSection, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, _DRIVER_OBJECT::FastIoDispatch, FsRtlEnterFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and TRUE. Referenced by CcWriteBehind(), CcZeroEndOfLastPage(), and MmCreateSection(). 02561 : 02562 02563 This routine is used by NtCreateSection to pre-acquire file system 02564 resources in order to avoid deadlocks. If there is a FastIo entry 02565 for AcquireFileForNtCreateSection then that routine will be called. 02566 Otherwise, we will simply acquire the main file resource exclusive. 02567 If there is no main resource then we acquire nothing and return 02568 FALSE. In the cases that we acquire a resource, we also set the 02569 TopLevelIrp field in the thread local storage to indicate to file 02570 systems beneath us that we have acquired file system resources. 02571 02572 Arguments: 02573 02574 FileObject - Pointer to the file object being written. 02575 02576 Return Value: 02577 02578 NONE 02579 02580 --*/ 02581 02582 { 02583 PDEVICE_OBJECT DeviceObject; 02584 PFAST_IO_DISPATCH FastIoDispatch; 02585 PFSRTL_COMMON_FCB_HEADER Header; 02586 02587 PAGED_CODE(); 02588 02589 // 02590 // First see if we have to call the file system. 02591 // 02592 02593 DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); 02594 02595 if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && 02596 (FastIoDispatch->SizeOfFastIoDispatch > 02597 FIELD_OFFSET( FAST_IO_DISPATCH, AcquireFileForNtCreateSection )) && 02598 (FastIoDispatch->AcquireFileForNtCreateSection != NULL)) { 02599 02600 FsRtlEnterFileSystem(); 02601 FastIoDispatch->AcquireFileForNtCreateSection( FileObject ); 02602 02603 return; 02604 } 02605 02606 // 02607 // If there is a main file resource, acquire that. 02608 // 02609 02610 if ((Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext) && 02611 (Header->Resource != NULL)) { 02612 02613 FsRtlEnterFileSystem(); 02614 ExAcquireResourceExclusive( Header->Resource, TRUE ); 02615 02616 return; 02617 } 02618 02619 // 02620 // Nothing to acquire. 02621 // 02622 02623 return; 02624 }

NTKERNELAPI VOID FsRtlAcquireFileForCcFlush (  IN PFILE_OBJECT  FileObject  )

Definition at line 2402 of file fastio.c. References _FAST_IO_DISPATCH::AcquireForCcFlush, ASSERT, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, ExIsResourceAcquiredShared, _DRIVER_OBJECT::FastIoDispatch, FsRtlEnterFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, Status, and TRUE. Referenced by MiRemoveUnusedSegments(), MmFlushSection(), and MmFlushVirtualMemory(). : This routine acquires a file system resource prior to a call to CcFlush. Arguments: FileObject - Pointer to the file object being written. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FsRtlEnterFileSystem(); if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, AcquireForCcFlush )) && (FastIoDispatch->AcquireForCcFlush != NULL)) { Status = FastIoDispatch->AcquireForCcFlush( FileObject, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { PFSRTL_COMMON_FCB_HEADER Header = FileObject->FsContext; // // If not already owned get the main resource exclusive because me may // extend ValidDataLength. Otherwise acquire it one more time recursively. // if (Header->Resource != NULL) { if (!ExIsResourceAcquiredShared(Header->Resource)) { ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { ExAcquireResourceShared( Header->Resource, TRUE ); } } // // Also get the paging I/O resource ahead of any MM resources. // if (Header->PagingIoResource != NULL) { ExAcquireResourceShared( Header->PagingIoResource, TRUE ); } } }

NTKERNELAPI BOOLEAN FsRtlAcquireFileForModWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  StartingOffset, OUT PERESOURCE *  ResourceToRelease )

Definition at line 2064 of file fastio.c. References AcquireExclusive, _FAST_IO_DISPATCH::AcquireForModWrite, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToShared, ExReleaseResource, FALSE, _DRIVER_OBJECT::FastIoDispatch, FlagOn, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, Status, and TRUE. Referenced by MiGatherMappedPages(), and MiMappedPageWriter(). : This routine decides which file system resource the modified page writer should acquire and acquires it if possible. Wait is always specified as FALSE. We pass back the resource Mm has to release when the write completes. Arguments: FileObject - Pointer to the file object being written. EndingOffset - The offset of the last byte being written + 1. ByteCount - Length of data in bytes. ResourceToRelease - Returns the resource to release. Not defined if FALSE is returned. Return Value: FALSE - The resource could not be acquired without waiting. TRUE - The returned resource has been acquired. --*/ { PFSRTL_COMMON_FCB_HEADER Header; PERESOURCE ResourceAcquired; PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; BOOLEAN AcquireExclusive; PAGED_CODE(); Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // First see if we have to call the file system. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, AcquireForModWrite )) && (FastIoDispatch->AcquireForModWrite != NULL)) { NTSTATUS Status; Status = FastIoDispatch->AcquireForModWrite(FileObject, EndingOffset, ResourceToRelease, DeviceObject); if (Status == STATUS_SUCCESS) { return( TRUE ); } else if (Status == STATUS_CANT_WAIT) { return( FALSE ); } else { // // Fall through. When dealing with layered file systems, it might // be the case that the layered file system has the above dispatch // routine, but the FS it is layered on top of does not. In that // case, the layered file system will return an error code other // than STATUS_SUCCESS or STATUS_CANT_WAIT, and we simply handle // it as if the file system did not have the dispatch routine to // begin with. // NOTHING; } } // // We follow the following rules to determine which resource // to acquire. We use the flags in the common header. These // flags can't change once we have acquired any resource. // This means we can do an unsafe test and optimisticly // acquire a resource. At that point we can test the bits // to see if we have what we want. // // 0 - If there is no main resource, acquire nothing. // // 1 - Acquire the main resource exclusively if the // ACQUIRE_MAIN_RSRC_EX flag is set or we are extending // valid data. // // 2 - Acquire the main resource shared if there is // no paging io resource or the // ACQUIRE_MAIN_RSRC_SH flag is set. // // 3 - Otherwise acquire the paging io resource shared. // if (Header->Resource == NULL) { *ResourceToRelease = NULL; return TRUE; } if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX ) || (EndingOffset->QuadPart > Header->ValidDataLength.QuadPart && Header->ValidDataLength.QuadPart != Header->FileSize.QuadPart)) { ResourceAcquired = Header->Resource; AcquireExclusive = TRUE; } else if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH ) || Header->PagingIoResource == NULL) { ResourceAcquired = Header->Resource; AcquireExclusive = FALSE; } else { ResourceAcquired = Header->PagingIoResource; AcquireExclusive = FALSE; } // // Perform the following in a loop in case we need to back and // check the state of the resource acquisition. In most cases // the initial checks will succeed and we can proceed immediately. // We have to worry about the two FsRtl bits changing but // if there is no paging io resource before there won't ever be // one. // while (TRUE) { // // Now acquire the desired resource. // if (AcquireExclusive) { if (!ExAcquireResourceExclusive( ResourceAcquired, FALSE )) { return FALSE; } } else if (!ExAcquireSharedWaitForExclusive( ResourceAcquired, FALSE )) { return FALSE; } // // If the valid data length is changing or the exclusive bit is // set and we don't have the main resource exclusive then // release the current resource and acquire the main resource // exclusively and move to the top of the loop. // if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX ) || (EndingOffset->QuadPart > Header->ValidDataLength.QuadPart && Header->ValidDataLength.QuadPart != Header->FileSize.QuadPart)) { // // If we don't have the main resource exclusively then // release the current resource and attempt to acquire // the main resource exclusively. // if (!AcquireExclusive) { ExReleaseResource( ResourceAcquired ); AcquireExclusive = TRUE; ResourceAcquired = Header->Resource; continue; } // // We have the correct resource. Exit the loop. // // // If we should be acquiring the main resource shared then move // to acquire the correct resource and proceed to the top of the loop. // } else if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH )) { // // If we have the main resource exclusively then downgrade to // shared and exit the loop. // if (AcquireExclusive) { ExConvertExclusiveToShared( ResourceAcquired ); // // If we have the paging io resource then give up this resource // and acquire the main resource exclusively. This is going // at it with a large hammer but is guaranteed to be resolved // in the next pass through the loop. // } else if (ResourceAcquired != Header->Resource) { ExReleaseResource( ResourceAcquired ); ResourceAcquired = Header->Resource; AcquireExclusive = TRUE; continue; } // // We have the correct resource. Exit the loop. // // // At this point we should have the paging Io resource shared // if it exists. If not then acquire it shared and release the // other resource and exit the loop. // } else if (Header->PagingIoResource != NULL && ResourceAcquired != Header->PagingIoResource) { ResourceAcquired = NULL; if (ExAcquireSharedWaitForExclusive( Header->PagingIoResource, FALSE )) { ResourceAcquired = Header->PagingIoResource; } ExReleaseResource( Header->Resource ); if (ResourceAcquired == NULL) { return FALSE; } // // We now have the correct resource. Exit the loop. // // // We should have the main resource shared. If we don't then // degrade our lock to shared access. // } else if (AcquireExclusive) { ExConvertExclusiveToShared( ResourceAcquired ); // // We now have the correct resource. Exit the loop. // } // // We have the correct resource. Exit the loop. // break; } *ResourceToRelease = ResourceAcquired; return TRUE; }

NTKERNELAPI BOOLEAN FsRtlAddLargeMcbEntry (  IN PLARGE_MCB  Mcb, IN LONGLONG  Vbn, IN LONGLONG  Lbn, IN LONGLONG  SectorCount )

Definition at line 977 of file largemcb.c. References ASSERT, ASSERTMSG, Dbg, DebugTrace, EndingLbn, EndingVbn, FALSE, _NONOPAQUE_MCB::FastMutex, FsRtlAddLargeEntry(), FsRtlFindLargeIndex(), FsRtlRemoveLargeEntry(), Index, LBN, _NONOPAQUE_MCB::Mapping, NextStartingLbn, NextStartingVbn, PAGED_CODE, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, PreviousEndingLbn, PreviousEndingVbn, StartingLbn, StartingVbn, TRUE, try_return, UNUSED_LBN, and VBN. Referenced by FsRtlAddMcbEntry(), UdfInitializeAllocations(), UdfLoadSparingTables(), and UdfUpdateVcbPhase1(). : This routine is used to add a new mapping of VBNs to LBNs to an existing Mcb. The information added will map Vbn to Lbn, Vbn+1 to Lbn+1,... Vbn+(SectorCount-1) to Lbn+(SectorCount-1). The mapping for the VBNs must not already exist in the Mcb. If the mapping continues a previous run, then this routine will actually coalesce them into 1 run. If pool is not available to store the information this routine will raise a status value indicating insufficient resources. An input Lbn value of zero is illegal (i.e., the Mcb structure will never map a Vbn to a zero Lbn value). Arguments: OpaqueMcb - Supplies the Mcb in which to add the new mapping. Vbn - Supplies the starting Vbn of the new mapping run to add to the Mcb. Lbn - Supplies the starting Lbn of the new mapping run to add to the Mcb. SectorCount - Supplies the size of the new mapping run (in sectors). Return Value: BOOLEAN - TRUE if the mapping was added successfully (i.e., the new Vbns did not collide with existing Vbns), and FALSE otherwise. If FALSE is returned then the Mcb is not changed. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; VBN Vbn = ((ULONG)LargeVbn); LBN Lbn = ((ULONG)LargeLbn); ULONG SectorCount = ((ULONG)LargeSectorCount); ULONG Index; VBN LastVbn; BOOLEAN Result; ASSERTMSG("LargeInteger not supported yet ", ((PLARGE_INTEGER)&LargeVbn)->HighPart == 0); ASSERTMSG("LargeInteger not supported yet ", ((PLARGE_INTEGER)&LargeLbn)->HighPart == 0); ASSERTMSG("LargeInteger not supported yet ", ((PLARGE_INTEGER)&LargeSectorCount)->HighPart == 0); PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlAddLargeMcbEntry, Mcb = %08lx\n", Mcb ); DebugTrace( 0, Dbg, " Vbn = %08lx\n", Vbn ); DebugTrace( 0, Dbg, " Lbn = %08lx\n", Lbn ); DebugTrace( 0, Dbg, " SectorCount = %08lx\n", SectorCount ); ExAcquireFastMutex( Mcb->FastMutex ); try { if (FsRtlFindLargeIndex(Mcb, Vbn, &Index)) { ULONG EndVbn = Vbn + SectorCount - 1; ULONG EndIndex; // // First check the case where we are adding to an existing mcb run // and if so then we will modify the insertion to complete the run // // --ExistingRun--| ==becomes==> --ExistingRun--| // |--NewRun--| |---| // // --ExistingRun----| ==becomes==> a noop // |--NewRun--| // if (StartingLbn(Mcb, Index) != UNUSED_LBN) { // // Check that the Lbn's line up between the new and existing run // if (Lbn != (StartingLbn(Mcb, Index) + (Vbn - StartingVbn(Mcb, Index)))) { // // Let our caller know we couldn't insert the run. // try_return(Result = FALSE); } // // Check if the new run is contained in the existing run // if (EndVbn <= EndingVbn(Mcb, Index)) { // // Do nothing because the run is contained within the existing run // try_return(Result = TRUE); } // // Otherwise we will simply trim off the request for the new run // to not overlap with the existing run // Vbn = NextStartingVbn(Mcb, Index); Lbn = EndingLbn(Mcb, Index) + 1; ASSERT(EndVbn >= Vbn); SectorCount = EndVbn - Vbn + 1; // // At this point the new run start in a hole, now check that if // crosses into a non hole and if so then adjust new run to fit // in the hole // // // |--ExistingRun-- ==becomes==> |--ExistingRun-- // |--NewRun--| |--New| // } else if (FsRtlFindLargeIndex(Mcb, EndVbn, &EndIndex) && (Index == (EndIndex-1))) { // // Check that the Lbn's line up in the overlap // if (StartingLbn(Mcb, EndIndex) != Lbn + (StartingVbn(Mcb, EndIndex) - Vbn)) { // // Let our caller know we couldn't insert the run. // try_return(Result = FALSE); } // // Truncate the sector count to go up to but not include // the existing run // SectorCount = StartingVbn(Mcb, EndIndex) - Vbn; } } // // Find the index for the starting Vbn of our new run, if there isn't // a hole found then index will be set to paircount. // if (((Index = Mcb->PairCount) == 0) || (PreviousEndingVbn(Mcb,Index)+1 <= Vbn) || !FsRtlFindLargeIndex(Mcb, Vbn, &Index)) { // // We didn't find a mapping, therefore this new mapping must // go on at the end of the current mapping. // // See if we can just grow the last mapping in the current mcb. // We can grow the last entry if (1) the Vbns follow on, and (2) // the Lbns follow on. We can only grow the last mapping if the // index is not 0. // if ((Index != 0) && (PreviousEndingVbn(Mcb,Index) + 1 == Vbn) && (PreviousEndingLbn(Mcb,Index) + 1 == Lbn)) { // // --LastRun--|---NewRun--| // // // Extend the last run in the mcb // DebugTrace( 0, Dbg, "Continuing last run\n", 0); (Mcb->Mapping)[Mcb->PairCount-1].NextVbn += SectorCount; try_return (Result = TRUE); } // // We couldn't grow the last mapping, now check to see if // this is a continuation of the last Vbn (i.e., there isn't // going to be a hole in the mapping). Or if this is the first // run in the mapping // if ((Vbn == 0) || (PreviousEndingVbn(Mcb,Index) + 1 == Vbn)) { // // --LastRun--||---NewRun--| // // 0:|--NewRun--| // // // We only need to add one more run to the mcb, so make sure // there is enough room for one. // DebugTrace( 0, Dbg, "Adding new contiguous last run\n", 0); FsRtlAddLargeEntry( Mcb, Index, 1 ); // // Add the new mapping // (Mcb->Mapping)[Index].Lbn = Lbn; (Mcb->Mapping)[Index].NextVbn = Vbn + SectorCount; try_return (Result = TRUE); } // // If we reach this point then there is going to be a hole in the // mapping. and the mapping gets appended to the end of the current // allocation. So need to make room for two more runs in the mcb. // // // --LastRun--| hole |---NewRun--| // // 0: hole |--NewRun--| // DebugTrace( 0, Dbg, "Adding new noncontiguous last run\n", 0); FsRtlAddLargeEntry( Mcb, Index, 2 ); // // Add the hole // (Mcb->Mapping)[Index].Lbn = (LBN)UNUSED_LBN; (Mcb->Mapping)[Index].NextVbn = Vbn; // // Add the new mapping // (Mcb->Mapping)[Index+1].Lbn = Lbn; (Mcb->Mapping)[Index+1].NextVbn = Vbn + SectorCount; try_return (Result = TRUE); } // // We found an index for the Vbn therefore we must be trying // to fill up a hole in the mcb. So first we need to check to make // sure there really is a hole to be filled // LastVbn = Vbn + SectorCount - 1; if ((StartingLbn(Mcb,Index) == UNUSED_LBN) && (StartingVbn(Mcb,Index) <= Vbn) && (LastVbn <= EndingVbn(Mcb,Index))) { // // The mapping fits in this hole, but now here are the following // cases we must consider for the new mapping // if ((StartingVbn(Mcb,Index) < Vbn) && (LastVbn < EndingVbn(Mcb,Index))) { // Leaves a hole are both ends // // --PreviousRun--| hole |--NewRun--| hole |--FollowingRun-- // // 0: hole |--NewRun--| hole |--FollowingRun-- // DebugTrace( 0, Dbg, "Hole at both ends\n", 0); // // Make room for two more entries. The NextVbn field of the // one we're shifting remains valid. // FsRtlAddLargeEntry( Mcb, Index, 2 ); // // Add the first hole // (Mcb->Mapping)[Index].Lbn = (LBN)UNUSED_LBN; (Mcb->Mapping)[Index].NextVbn = Vbn; // // Add the new mapping // (Mcb->Mapping)[Index+1].Lbn = Lbn; (Mcb->Mapping)[Index+1].NextVbn = Vbn + SectorCount; // // The second hole is already set up by the add entry call, because // that call just shift over the original hole to that slot // try_return (Result = TRUE); } if ((StartingVbn(Mcb,Index) == Vbn) && (LastVbn < EndingVbn(Mcb,Index))) { if (PreviousEndingLbn(Mcb,Index) + 1 == Lbn) { // // Leaves a hole at the rear, and continues the earlier run // // --PreviousRun--|--NewRun--| hole |--FollowingRun-- // DebugTrace( 0, Dbg, "Hole at rear and continue\n", 0); // // We just need to extend the previous run // (Mcb->Mapping)[Index-1].NextVbn += SectorCount; try_return (Result = TRUE); } else { // // Leaves a hole at the rear, and does not continue the // earlier run. As occurs if index is zero. // // --PreviousRun--||--NewRun--| hole |--FollowingRun-- // // 0:|--NewRun--| hole |--FollowingRun-- // DebugTrace( 0, Dbg, "Hole at rear and not continue\n", 0); // // Make room for one more entry. The NextVbn field of the // one we're shifting remains valid. // FsRtlAddLargeEntry( Mcb, Index, 1 ); // // Add the new mapping // (Mcb->Mapping)[Index].Lbn = Lbn; (Mcb->Mapping)[Index].NextVbn = Vbn + SectorCount; // // The hole is already set up by the add entry call, because // that call just shift over the original hole to that slot // try_return (Result = TRUE); } } if ((StartingVbn(Mcb,Index) < Vbn) && (LastVbn == EndingVbn(Mcb,Index))) { if (NextStartingLbn(Mcb,Index) == Lbn + SectorCount) { // // Leaves a hole at the front, and continues the following run // // --PreviousRun--| hole |--NewRun--|--FollowingRun-- // // 0: hole |--NewRun--|--FollowingRun-- // DebugTrace( 0, Dbg, "Hole at front and continue\n", 0); // // We just need to extend the following run // (Mcb->Mapping)[Index].NextVbn = Vbn; (Mcb->Mapping)[Index+1].Lbn = Lbn; try_return (Result = TRUE); } else { // // Leaves a hole at the front, and does not continue the following // run // // --PreviousRun--| hole |--NewRun--||--FollowingRun-- // // 0: hole |--NewRun--||--FollowingRun-- // DebugTrace( 0, Dbg, "Hole at front and not continue\n", 0); // // Make room for one more entry. The NextVbn field of the // one we're shifting remains valid. // FsRtlAddLargeEntry( Mcb, Index, 1 ); // // Add the hole // (Mcb->Mapping)[Index].Lbn = (LBN)UNUSED_LBN; (Mcb->Mapping)[Index].NextVbn = Vbn; // // Add the new mapping // (Mcb->Mapping)[Index+1].Lbn = Lbn; try_return (Result = TRUE); } } if ((PreviousEndingLbn(Mcb,Index) + 1 == Lbn) && (NextStartingLbn(Mcb,Index) == Lbn + SectorCount)) { // // Leaves no holes, and continues both runs // // --PreviousRun--|--NewRun--|--FollowingRun-- // DebugTrace( 0, Dbg, "No holes, and continues both runs\n", 0); // // We need to collapse the current index and the following index // but first we copy the NextVbn of the follwing run into // the NextVbn field of the previous run to so it all becomes // one run // (Mcb->Mapping)[Index-1].NextVbn = (Mcb->Mapping)[Index+1].NextVbn; FsRtlRemoveLargeEntry( Mcb, Index, 2 ); try_return (Result = TRUE); } if (NextStartingLbn(Mcb,Index) == Lbn + SectorCount) { // // Leaves no holes, and continues only following run // // --PreviousRun--||--NewRun--|--FollowingRun-- // // 0:|--NewRun--|--FollowingRun-- // DebugTrace( 0, Dbg, "No holes, and continues following\n", 0); // // This index is going away so we need to stretch the // following run to meet up with the previous run // (Mcb->Mapping)[Index+1].Lbn = Lbn; FsRtlRemoveLargeEntry( Mcb, Index, 1 ); try_return (Result = TRUE); } if (PreviousEndingLbn(Mcb,Index) + 1 == Lbn) { // // Leaves no holes, and continues only earlier run // // --PreviousRun--|--NewRun--||--FollowingRun-- // DebugTrace( 0, Dbg, "No holes, and continues earlier\n", 0); // // This index is going away so we need to stretch the // previous run to meet up with the following run // (Mcb->Mapping)[Index-1].NextVbn = (Mcb->Mapping)[Index].NextVbn; FsRtlRemoveLargeEntry( Mcb, Index, 1 ); try_return (Result = TRUE); } // // Leaves no holes, and continues neither run // // --PreviousRun--||--NewRun--||--FollowingRun-- // // 0:|--NewRun--||--FollowingRun-- // DebugTrace( 0, Dbg, "No holes, and continues none\n", 0); (Mcb->Mapping)[Index].Lbn = Lbn; try_return (Result = TRUE); } // // We tried to overwrite an existing mapping so we'll have to // tell our caller that it's not possible // Result = FALSE; try_exit: NOTHING; } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlAddLargeMcbEntry -> %08lx\n", Result ); } return Result; }

NTKERNELAPI BOOLEAN FsRtlAddMcbEntry (  IN PMCB  Mcb, IN VBN  Vbn, IN LBN  Lbn, IN ULONG  SectorCount )

Definition at line 375 of file largemcb.c. References FsRtlAddLargeMcbEntry(), and PAGED_CODE. Referenced by UdfAddVmcbMapping(). { PAGED_CODE(); return FsRtlAddLargeMcbEntry( (PLARGE_MCB)Mcb, (LONGLONG)(Vbn), (LONGLONG)(Lbn), (LONGLONG)(SectorCount) ); }

NTKERNELAPI VOID FsRtlAddToTunnelCache (  IN TUNNEL *  Cache, IN ULONGLONG  DirectoryKey, IN UNICODE_STRING *  ShortName, IN UNICODE_STRING *  LongName, IN BOOLEAN  KeyByShortName, IN ULONG  DataLength, IN VOID *  Data )

PFILE_LOCK FsRtlAllocateFileLock (  IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine  OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine  OPTIONAL )

Definition at line 1141 of file filelock.c. References ExAllocateFromPagedLookasideList(), FsRtlFileLockLookasideList, FsRtlInitializeFileLock(), and NULL. Referenced by UdfCreateFileLock(). { PFILE_LOCK FileLock; FileLock = ExAllocateFromPagedLookasideList( &FsRtlFileLockLookasideList ); if (FileLock != NULL) { FsRtlInitializeFileLock( FileLock, CompleteLockIrpRoutine, UnlockRoutine ); } return FileLock; }

NTKERNELAPI PERESOURCE FsRtlAllocateResource (   )

Definition at line 293 of file fsrtlpc.c. References FSRTL_NUMBER_OF_RESOURCES, FsRtlPagingIoResources, FsRtlPagingIoResourceSelector, and PAGED_CODE. : This routine is used to allocate a resource from the FsRtl pool. Arguments: Return Value: PERESOURCE - A pointer to the provided resource. --*/ { PAGED_CODE(); return &FsRtlPagingIoResources[ FsRtlPagingIoResourceSelector++ % FSRTL_NUMBER_OF_RESOURCES]; }

NTKERNELAPI BOOLEAN FsRtlAreNamesEqual (  PCUNICODE_STRING  ConstantNameA, PCUNICODE_STRING  ConstantNameB, IN BOOLEAN  IgnoreCase, IN PCWCH UpcaseTable  OPTIONAL )

Definition at line 288 of file name.c. References ExRaiseStatus(), FALSE, Index, NT_SUCCESS, NTSTATUS(), PAGED_CODE, RtlFreeUnicodeString(), RtlUpcaseUnicodeString(), Status, and TRUE. 00297 : 00298 00299 This routine simple returns whether the two names are exactly equal. 00300 If the two names are known to be constant, this routine is much 00301 faster than FsRtlIsNameInExpression. 00302 00303 Arguments: 00304 00305 ConstantNameA - Constant name. 00306 00307 ConstantNameB - Constant name. 00308 00309 IgnoreCase - TRUE if the Names should be Upcased before comparing. 00310 00311 UpcaseTable - If supplied, use this table for case insensitive compares, 00312 otherwise, use the default system upcase table. 00313 00314 Return Value: 00315 00316 BOOLEAN - TRUE if the two names are lexically equal. 00317 00318 --*/ 00319 00320 { 00321 ULONG Index; 00322 ULONG NameLength; 00323 BOOLEAN FreeStrings = FALSE; 00324 00325 UNICODE_STRING LocalNameA; 00326 UNICODE_STRING LocalNameB; 00327 00328 PAGED_CODE(); 00329 00330 // 00331 // If the names aren't even the same size, then return FALSE right away. 00332 // 00333 00334 if ( ConstantNameA->Length != ConstantNameB->Length ) { 00335 00336 return FALSE; 00337 } 00338 00339 NameLength = ConstantNameA->Length / sizeof(WCHAR); 00340 00341 // 00342 // If we weren't given an upcase table, we have to upcase the names 00343 // ourselves. 00344 // 00345 00346 if ( IgnoreCase && !ARGUMENT_PRESENT(UpcaseTable) ) { 00347 00348 NTSTATUS Status; 00349 00350 Status = RtlUpcaseUnicodeString( &LocalNameA, ConstantNameA, TRUE ); 00351 00352 if ( !NT_SUCCESS(Status) ) { 00353 00354 ExRaiseStatus( Status ); 00355 } 00356 00357 Status = RtlUpcaseUnicodeString( &LocalNameB, ConstantNameB, TRUE ); 00358 00359 if ( !NT_SUCCESS(Status) ) { 00360 00361 RtlFreeUnicodeString( &LocalNameA ); 00362 00363 ExRaiseStatus( Status ); 00364 } 00365 00366 ConstantNameA = &LocalNameA; 00367 ConstantNameB = &LocalNameB; 00368 00369 IgnoreCase = FALSE; 00370 FreeStrings = TRUE; 00371 } 00372 00373 // 00374 // Do either case sensitive or insensitive compare. 00375 // 00376 00377 if ( !IgnoreCase ) { 00378 00379 BOOLEAN BytesEqual; 00380 00381 BytesEqual = (BOOLEAN) RtlEqualMemory( ConstantNameA->Buffer, 00382 ConstantNameB->Buffer, 00383 ConstantNameA->Length ); 00384 00385 if ( FreeStrings ) { 00386 00387 RtlFreeUnicodeString( &LocalNameA ); 00388 RtlFreeUnicodeString( &LocalNameB ); 00389 } 00390 00391 return BytesEqual; 00392 00393 } else { 00394 00395 for (Index = 0; Index < NameLength; Index += 1) { 00396 00397 if ( UpcaseTable[ConstantNameA->Buffer[Index]] != 00398 UpcaseTable[ConstantNameB->Buffer[Index]] ) { 00399 00400 return FALSE; 00401 } 00402 } 00403 00404 return TRUE; 00405 } 00406 }

NTKERNELAPI NTSTATUS FsRtlBalanceReads (  IN PDEVICE_OBJECT  TargetDevice  )

Definition at line 31 of file faulttol.c. References ASSERT, Event(), Executive, FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, Irp, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NTSTATUS(), NULL, and Status. 00037 : 00038 00039 This routine signals a device driver that it is now OK to start 00040 balancing reads from a mirrored drive. This is typically called 00041 after the file system determines that a volume is clean. 00042 00043 Arguments: 00044 00045 TargetDevice - Supplies the device to start balanced read from. 00046 00047 Return Value: 00048 00049 NTSTATUS - The result of the operation. This will be 00050 STATUS_INVALID_DEVICE_REQUEST is the volume is not a mirror. 00051 00052 --*/ 00053 00054 { 00055 PIRP Irp; 00056 KEVENT Event; 00057 IO_STATUS_BLOCK Iosb; 00058 NTSTATUS Status; 00059 00060 KeInitializeEvent( &Event, NotificationEvent, FALSE ); 00061 00062 Irp = IoBuildDeviceIoControlRequest( FT_BALANCED_READ_MODE, 00063 TargetDevice, 00064 NULL, 00065 0, 00066 NULL, 00067 0, 00068 FALSE, 00069 &Event, 00070 &Iosb ); 00071 00072 if ( Irp == NULL ) { 00073 00074 return STATUS_INSUFFICIENT_RESOURCES; 00075 } 00076 00077 Status = IoCallDriver( TargetDevice, Irp ); 00078 00079 00080 if (Status == STATUS_PENDING) { 00081 Status = KeWaitForSingleObject( &Event, 00082 Executive, 00083 KernelMode, 00084 FALSE, 00085 NULL ); 00086 00087 ASSERT( Status == STATUS_SUCCESS ); 00088 00089 Status = Iosb.Status; 00090 } 00091 00092 return Status; 00093 }

NTKERNELAPI BOOLEAN FsRtlCheckLockForReadAccess (  IN PFILE_LOCK  FileLock, IN PIRP  Irp )

Definition at line 1315 of file filelock.c. References Dbg, DebugTrace, _LOCK_QUEUE::ExclusiveLockTree, _IO_STACK_LOCATION::FileObject, FsRtlFastCheckLockForRead(), IoGetCurrentIrpStackLocation, IoGetRequestorProcess(), Irp, Key, _LOCK_INFO::LockQueue, _LOCK_INFO::LowestLockOffset, NULL, _IO_STACK_LOCATION::Parameters, PLOCK_INFO, and TRUE. Referenced by UdfCommonRead(). : This routine checks to see if the caller has read access to the range indicated in the IRP due to file locks. This call does not complete the Irp it only uses it to get the lock information and read information. The IRP must be for a read operation. Arguments: FileLock - Supplies the File Lock to check. Irp - Supplies the Irp being processed. Return Value: BOOLEAN - TRUE if the indicated user/request has read access to the entire specified byte range, and FALSE otherwise --*/ { BOOLEAN Result; PIO_STACK_LOCATION IrpSp; PLOCK_INFO LockInfo; LARGE_INTEGER StartingByte; LARGE_INTEGER Length; ULONG Key; PFILE_OBJECT FileObject; PVOID ProcessId; LARGE_INTEGER BeyondLastByte; DebugTrace(+1, Dbg, "FsRtlCheckLockForReadAccess, FileLock = %08lx\n", FileLock); if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { DebugTrace(-1, Dbg, "FsRtlCheckLockForReadAccess (No current lock info) -> TRUE\n", 0); return TRUE; } // // Do a really fast test to see if there are any exclusive locks to start with // if (LockInfo->LockQueue.ExclusiveLockTree == NULL) { DebugTrace(-1, Dbg, "FsRtlCheckLockForReadAccess (No current locks) -> TRUE\n", 0); return TRUE; } // // Get the read offset and compare it to the lowest existing lock. // IrpSp = IoGetCurrentIrpStackLocation( Irp ); StartingByte = IrpSp->Parameters.Read.ByteOffset; (ULONGLONG)Length.QuadPart = (ULONGLONG)IrpSp->Parameters.Read.Length; (ULONGLONG)BeyondLastByte.QuadPart = (ULONGLONG)StartingByte.QuadPart + Length.LowPart; if ( (ULONGLONG)BeyondLastByte.QuadPart <= (ULONGLONG)LockInfo->LowestLockOffset ) { DebugTrace(-1, Dbg, "FsRtlCheckLockForReadAccess (Below lowest lock) -> TRUE\n", 0); return TRUE; } // // Get remaining parameters. // Key = IrpSp->Parameters.Read.Key; FileObject = IrpSp->FileObject; ProcessId = IoGetRequestorProcess( Irp ); // // Call our private work routine to do the real check // Result = FsRtlFastCheckLockForRead( FileLock, &StartingByte, &Length, Key, FileObject, ProcessId ); // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlCheckLockForReadAccess -> %08lx\n", Result); return Result; }

NTKERNELAPI BOOLEAN FsRtlCheckLockForWriteAccess (  IN PFILE_LOCK  FileLock, IN PIRP  Irp )

Definition at line 1416 of file filelock.c. References Dbg, DebugTrace, _LOCK_QUEUE::ExclusiveLockTree, _IO_STACK_LOCATION::FileObject, FsRtlFastCheckLockForWrite(), IoGetCurrentIrpStackLocation, IoGetRequestorProcess(), Irp, Key, _LOCK_INFO::LockQueue, _LOCK_INFO::LowestLockOffset, NULL, _IO_STACK_LOCATION::Parameters, PLOCK_INFO, _LOCK_QUEUE::SharedLockTree, and TRUE. : This routine checks to see if the caller has write access to the indicated range due to file locks. This call does not complete the Irp it only uses it to get the lock information and write information. The IRP must be for a write operation. Arguments: FileLock - Supplies the File Lock to check. Irp - Supplies the Irp being processed. Return Value: BOOLEAN - TRUE if the indicated user/request has write access to the entire specified byte range, and FALSE otherwise --*/ { BOOLEAN Result; PIO_STACK_LOCATION IrpSp; PLOCK_INFO LockInfo; LARGE_INTEGER StartingByte; LARGE_INTEGER Length; ULONG Key; PFILE_OBJECT FileObject; PVOID ProcessId; LARGE_INTEGER BeyondLastByte; DebugTrace(+1, Dbg, "FsRtlCheckLockForWriteAccess, FileLock = %08lx\n", FileLock); if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { DebugTrace(-1, Dbg, "FsRtlCheckLockForWriteAccess (No current lock info) -> TRUE\n", 0); return TRUE; } // // Do a really fast test to see if there are any locks to start with // if (LockInfo->LockQueue.ExclusiveLockTree == NULL && LockInfo->LockQueue.SharedLockTree == NULL) { DebugTrace(-1, Dbg, "FsRtlCheckLockForWriteAccess (No current locks) -> TRUE\n", 0); return TRUE; } // // Get the write offset and compare it to the lowest existing lock. // IrpSp = IoGetCurrentIrpStackLocation( Irp ); StartingByte = IrpSp->Parameters.Write.ByteOffset; (ULONGLONG)Length.QuadPart = (ULONGLONG)IrpSp->Parameters.Write.Length; (ULONGLONG)BeyondLastByte.QuadPart = (ULONGLONG)StartingByte.QuadPart + Length.LowPart; if ( (ULONGLONG)BeyondLastByte.QuadPart <= (ULONGLONG)LockInfo->LowestLockOffset ) { DebugTrace(-1, Dbg, "FsRtlCheckLockForWriteAccess (Below lowest lock) -> TRUE\n", 0); return TRUE; } // // Get remaining parameters. // Key = IrpSp->Parameters.Write.Key; FileObject = IrpSp->FileObject; ProcessId = IoGetRequestorProcess( Irp ); // // Call our private work routine to do the real work // Result = FsRtlFastCheckLockForWrite( FileLock, &StartingByte, &Length, Key, FileObject, ProcessId ); // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlCheckLockForWriteAccess -> %08lx\n", Result); return Result; }

NTKERNELAPI NTSTATUS FsRtlCheckOplock (  IN POPLOCK  Oplock, IN PIRP  Irp, IN PVOID  Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine  OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine  OPTIONAL )

Definition at line 823 of file oplock.c. References BATCH_OPLOCK, Dbg, DebugTrace, FALSE, _IO_STACK_LOCATION::FileObject, _NONOPAQUE_OPLOCK::FileObject, FILTER_OPLOCK, FILTER_OPLOCK_VALID_FLAGS, FlagOn, _IRP::Flags, FsRtlOplockBreakToII(), FsRtlOplockBreakToNone(), FsRtlOplockCleanup(), IoGetCurrentIrpStackLocation, Irp, IRP_MJ_CLEANUP, IRP_MJ_CREATE, IRP_MJ_FILE_SYSTEM_CONTROL, IRP_MJ_FLUSH_BUFFERS, IRP_MJ_LOCK_CONTROL, IRP_MJ_READ, IRP_MJ_SET_INFORMATION, IRP_MJ_WRITE, IRP_PAGING_IO, _IO_STACK_LOCATION::MajorFunction, NoOplocksHeld, NTSTATUS(), NULL, OPLOCK_STATE, OplockIIGranted, _NONOPAQUE_OPLOCK::OplockState, _IO_STACK_LOCATION::Parameters, PNONOPAQUE_OPLOCK, Status, and TRUE. Referenced by UdfCommonCleanup(), UdfCommonLockControl(), UdfCommonRead(), and UdfCompleteFcbOpen(). : This routine is called as a support routine from a file system. It is used to synchronize I/O requests with the current Oplock state of a file. If the I/O operation will cause the Oplock to break, that action is initiated. If the operation cannot continue until the Oplock break is complete, STATUS_PENDING is returned and the caller supplied routine is called. Arguments: Oplock - Supplies a pointer to the non-opaque oplock structure for this file. Irp - Supplies a pointer to the Irp which declares the requested operation. Context - This value is passed as a parameter to the completion routine. CompletionRoutine - This is the routine which is called if this Irp must wait for an Oplock to break. This is a synchronous operation if not specified and we block in this thread waiting on an event. PostIrpRoutine - This is the routine to call before we put anything on our waiting Irp queue. Return Value: STATUS_SUCCESS if we can complete the operation on exiting this thread. STATUS_PENDING if we return here but hold the Irp. STATUS_CANCELLED if the Irp is cancelled before we return. --*/ { NTSTATUS Status = STATUS_SUCCESS; PNONOPAQUE_OPLOCK ThisOplock = *Oplock; PIO_STACK_LOCATION IrpSp; DebugTrace( +1, Dbg, "FsRtlCheckOplock: Entered\n", 0 ); DebugTrace( 0, Dbg, "Oplock -> %08lx\n", Oplock ); DebugTrace( 0, Dbg, "Irp -> %08lx\n", Irp ); // // If there is no oplock structure or this is system I/O, we allow // the operation to continue. Otherwise we check the major function code. // if ((ThisOplock != NULL) && !FlagOn( Irp->Flags, IRP_PAGING_IO )) { OPLOCK_STATE OplockState; PFILE_OBJECT OplockFileObject; BOOLEAN BreakToII; BOOLEAN BreakToNone; ULONG CreateDisposition; // // Capture the file object first and then the oplock state to perform // the unsafe checks below. We capture the file object first in case // there is an exclusive oplock break in progress. Otherwise the oplock // state may indicate break in progress but it could complete by // the time we snap the file object. // OplockFileObject = ThisOplock->FileObject; OplockState = ThisOplock->OplockState; // // Examine the Irp for the appropriate action provided there are // current oplocks on the file. // if (OplockState != NoOplocksHeld) { BreakToII = FALSE; BreakToNone = FALSE; IrpSp = IoGetCurrentIrpStackLocation( Irp ); // // Determine whether we are going to BreakToII or BreakToNone. // switch (IrpSp->MajorFunction) { case IRP_MJ_CREATE : // // If we are opening for attribute access only, we // return status success. Always break the oplock if this caller // wants a filter oplock. // if (!FlagOn( IrpSp->Parameters.Create.SecurityContext->DesiredAccess, ~(FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE) ) && !FlagOn( IrpSp->Parameters.Create.Options, FILE_RESERVE_OPFILTER )) { break; } // // If there is a filter oplock granted and this create iS reading // the file then don't break the oplock as long as we share // for reads. // if (FlagOn( OplockState, FILTER_OPLOCK ) && !FlagOn( IrpSp->Parameters.Create.SecurityContext->DesiredAccess, ~FILTER_OPLOCK_VALID_FLAGS ) && FlagOn( IrpSp->Parameters.Create.ShareAccess, FILE_SHARE_READ )) { break; } // // We we are superseding or overwriting, then break to none. // CreateDisposition = (IrpSp->Parameters.Create.Options >> 24) & 0x000000ff; if ((CreateDisposition == FILE_SUPERSEDE) || (CreateDisposition == FILE_OVERWRITE) || (CreateDisposition == FILE_OVERWRITE_IF) || FlagOn( IrpSp->Parameters.Create.Options, FILE_RESERVE_OPFILTER )) { BreakToNone = TRUE; } else { BreakToII = TRUE; } break; case IRP_MJ_READ : // // If a filter oplock has been granted then do nothing. // We will assume the oplock will have been broken // if this create needed to do that. // if (!FlagOn( OplockState, FILTER_OPLOCK )) { BreakToII = TRUE; } break; case IRP_MJ_FLUSH_BUFFERS : BreakToII = TRUE; break; case IRP_MJ_CLEANUP : FsRtlOplockCleanup( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp ); break; case IRP_MJ_LOCK_CONTROL : // // If a filter oplock has been granted then do nothing. // We will assume the oplock will have been broken // if this create needed to do that. // if (FlagOn( OplockState, FILTER_OPLOCK )) { break; } case IRP_MJ_WRITE : BreakToNone = TRUE; break; case IRP_MJ_SET_INFORMATION : // // We are only interested in calls that shrink the file size // or breaking batch oplocks for the rename case. // switch (IrpSp->Parameters.SetFile.FileInformationClass) { case FileEndOfFileInformation : // // Break immediately if this is the lazy writer callback. // if (IrpSp->Parameters.SetFile.AdvanceOnly) { break; } case FileAllocationInformation : BreakToNone = TRUE; break; case FileRenameInformation : case FileLinkInformation : if (FlagOn( OplockState, BATCH_OPLOCK | FILTER_OPLOCK )) { BreakToNone = TRUE; } break; } case IRP_MJ_FILE_SYSTEM_CONTROL : // // We need to break to none if this is a zeroing operation. // if (IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_SET_ZERO_DATA) { BreakToNone = TRUE; } } if (BreakToII) { // // If there are no outstanding oplocks or level II oplocks are held, // we can return immediately. If the first two tests fail then there // is an exclusive oplock. If the file objects match we allow the // operation to continue. // if ((OplockState != OplockIIGranted) && (OplockFileObject != IrpSp->FileObject)) { Status = FsRtlOplockBreakToII( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp, Context, CompletionRoutine, PostIrpRoutine ); } } else if (BreakToNone) { // // If there are no oplocks, we can return immediately. // Otherwise if there is no level 2 oplock and this file // object matches the owning file object then this write is // on behalf of the owner of the oplock. // if ((OplockState == OplockIIGranted) || (OplockFileObject != IrpSp->FileObject)) { Status = FsRtlOplockBreakToNone( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp, Context, CompletionRoutine, PostIrpRoutine ); } } } } DebugTrace( -1, Dbg, "FsRtlCheckOplock: Exit -> %08lx\n", Status ); return Status; }

NTKERNELAPI BOOLEAN FsRtlCopyRead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Wait, IN ULONG  LockKey, OUT PVOID  Buffer, OUT PIO_STATUS_BLOCK  IoStatus, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 54 of file fastio.c. References ASSERT, Buffer, CcCopyRead(), CcFastCopyRead(), CcFastReadNotPossible, CcFastReadNoWait, CcFastReadResourceMiss, CcFastReadWait, COMPUTE_PAGES_SPANNED, _DEVICE_OBJECT::DriverObject, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FO_FILE_FAST_IO_READ, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, HOT_STATISTIC, IoGetRelatedDeviceObject(), NULL, PAGED_CODE, PFAST_IO_DISPATCH, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by UdfInitializeGlobalData(). : This routine does a fast cached read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcCopyRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Wait - FALSE if caller may not block, TRUE otherwise Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if Wait was supplied as FALSE and the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN Status = TRUE; ULONG PageCount = COMPUTE_PAGES_SPANNED( FileOffset->QuadPart, Length ); LARGE_INTEGER BeyondLastByte; PDEVICE_OBJECT targetVdo; PAGED_CODE(); // // Special case a read of zero length // if (Length != 0) { // // Check for overflow. Returning false here will re-route this request through the // IRP based path, but this isn't performance critical. // if (MAXLONGLONG - FileOffset->QuadPart < (LONGLONG)Length) { IoStatus->Status = STATUS_INVALID_PARAMETER; IoStatus->Information = 0; return FALSE; } BeyondLastByte.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); // // Increment performance counters and get the resource // if (Wait) { HOT_STATISTIC(CcFastReadWait) += 1; // // Acquired shared on the common fcb header // (VOID)ExAcquireResourceShared( Header->Resource, TRUE ); } else { HOT_STATISTIC(CcFastReadNoWait) += 1; // // Acquired shared on the common fcb header, and return if we // don't get it // if (!ExAcquireResourceShared( Header->Resource, FALSE )) { FsRtlExitFileSystem(); CcFastReadResourceMiss += 1; return FALSE; } } // // Now that the File is acquired shared, we can safely test if it // is really cached and if we can do fast i/o and if not, then // release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible)) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); HOT_STATISTIC(CcFastReadNotPossible) += 1; return FALSE; } // // Check if fast I/O is questionable and if so then go ask the // file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch; ASSERT(!KeIsExecutingDpc()); targetVdo = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = targetVdo->DriverObject->FastIoDispatch; // // All file systems that set "Is Questionable" had better support // fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is // anything other than GoForIt then we cannot take the fast I/O // path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, Wait, LockKey, TRUE, // read operation IoStatus, targetVdo )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); HOT_STATISTIC(CcFastReadNotPossible) += 1; return FALSE; } } // // Check for read past file size. // if ( BeyondLastByte.QuadPart > Header->FileSize.QuadPart ) { if ( FileOffset->QuadPart >= Header->FileSize.QuadPart ) { IoStatus->Status = STATUS_END_OF_FILE; IoStatus->Information = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return TRUE; } Length = (ULONG)( Header->FileSize.QuadPart - FileOffset->QuadPart ); } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // copy read fails, then return FALSE to our caller. // // Also mark this as the top level "Irp" so that lower file system // levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { if (Wait && ((BeyondLastByte.HighPart | Header->FileSize.HighPart) == 0)) { CcFastCopyRead( FileObject, FileOffset->LowPart, Length, PageCount, Buffer, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; ASSERT( (IoStatus->Status == STATUS_END_OF_FILE) || ((FileOffset->LowPart + IoStatus->Information) <= Header->FileSize.LowPart)); } else { Status = CcCopyRead( FileObject, FileOffset, Length, Wait, Buffer, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; ASSERT( !Status || (IoStatus->Status == STATUS_END_OF_FILE) || ((LONGLONG)(FileOffset->QuadPart + IoStatus->Information) <= Header->FileSize.QuadPart)); } if (Status) { FileObject->CurrentByteOffset.QuadPart = FileOffset->QuadPart + IoStatus->Information; } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; } else { // // A zero length transfer was requested. // IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = 0; return TRUE; } }

NTKERNELAPI BOOLEAN FsRtlCopyWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Wait, IN ULONG  LockKey, IN PVOID  Buffer, OUT PIO_STATUS_BLOCK  IoStatus, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 330 of file fastio.c. References ASSERT, Buffer, CcCanIWrite(), CcCopyWrite(), CcCopyWriteWontFlush, CcFastCopyWrite(), CcGetFileSizePointer, CcZeroData(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FlagOn, FO_FILE_MODIFIED, FO_FILE_SIZE_CHANGED, FO_WRITE_THROUGH, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, Offset, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). : This routine does a fast cached write bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy write of a cached file object. For a complete description of the arguments see CcCopyWrite. Arguments: FileObject - Pointer to the file object being write. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Wait - FALSE if caller may not block, TRUE otherwise Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if Wait was supplied as FALSE and the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN AcquiredShared = FALSE; BOOLEAN Status = TRUE; BOOLEAN FileSizeChanged = FALSE; BOOLEAN WriteToEndOfFile = (BOOLEAN)((FileOffset->LowPart == FILE_WRITE_TO_END_OF_FILE) && (FileOffset->HighPart == -1)); PAGED_CODE(); // // Get a real pointer to the common fcb header // Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Do we need to verify the volume? If so, we must go to the file // system. Also return FALSE if FileObject is write through, the // File System must do that. // if (CcCanIWrite( FileObject, Length, Wait, FALSE ) && !FlagOn(FileObject->Flags, FO_WRITE_THROUGH) && CcCopyWriteWontFlush(FileObject, FileOffset, Length)) { // // Assume our transfer will work // IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = Length; // // Special case the zero byte length // if (Length != 0) { // // Enter the file system // FsRtlEnterFileSystem(); // // Split into separate paths for increased performance. First // we have the faster path which only supports Wait == TRUE and // 32 bits. We will make an unsafe test on whether the fast path // is ok, then just return FALSE later if we were wrong. This // should virtually never happen. // // IMPORTANT NOTE: It is very important that any changes made to // this path also be applied to the 64-bit path // which is the else of this test! // if (Wait && (Header->AllocationSize.HighPart == 0)) { ULONG Offset, NewFileSize; ULONG OldFileSize; ULONG OldValidDataLength; BOOLEAN Wrapped; // // Make our best guess on whether we need the file exclusive // or shared. Note that we do not check FileOffset->HighPart // until below. // NewFileSize = FileOffset->LowPart + Length; if (WriteToEndOfFile || (NewFileSize > Header->ValidDataLength.LowPart)) { // // Acquired shared on the common fcb header // ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { // // Acquired shared on the common fcb header // ExAcquireResourceShared( Header->Resource, TRUE ); AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o // and if the file space is allocated, and if not then // release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize.LowPart; NewFileSize = Header->FileSize.LowPart + Length; Wrapped = NewFileSize < Header->FileSize.LowPart; } else { Offset = FileOffset->LowPart; NewFileSize = FileOffset->LowPart + Length; Wrapped = (NewFileSize < FileOffset->LowPart) || (FileOffset->HighPart != 0); } // // Now that the File is acquired shared, we can safely test // if it is really cached and if we can do fast i/o and we // do not have to extend. If not then release the fcb and // return. // // Get out if we have too much to zero. This case is not important // for performance, and a file system supporting sparseness may have // a way to do this more efficiently. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (NewFileSize > Header->AllocationSize.LowPart) || (Offset >= (Header->ValidDataLength.LowPart + 0x2000)) || (Header->AllocationSize.HighPart != 0) || Wrapped) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to // get the Fcb exclusive, and make sure that FastIo is still // possible. We should only execute this block of code very // rarely, when the unsafe test for ValidDataLength failed // above. // if (AcquiredShared && (NewFileSize > Header->ValidDataLength.LowPart)) { ExReleaseResource( Header->Resource ); ExAcquireResourceExclusive( Header->Resource, TRUE ); // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize.LowPart; NewFileSize = Header->FileSize.LowPart + Length; Wrapped = NewFileSize < Header->FileSize.LowPart; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (NewFileSize > Header->AllocationSize.LowPart) || (Header->AllocationSize.HighPart != 0) || Wrapped) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask // the file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PDEVICE_OBJECT targetVdo = IoGetRelatedDeviceObject( FileObject ); PFAST_IO_DISPATCH FastIoDispatch = targetVdo->DriverObject->FastIoDispatch; IO_STATUS_BLOCK IoStatus; // // All file system then set "Is Questionable" had better // support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the // answer is anything other than GoForIt then we cannot // take the fast I/O path. // ASSERT(FILE_WRITE_TO_END_OF_FILE == 0xffffffff); if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset->QuadPart != (LONGLONG)-1 ? FileOffset : &Header->FileSize, Length, TRUE, LockKey, FALSE, // write operation &IoStatus, targetVdo )) { // // Fast I/O is not possible so release the Fcb and // return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now // so that our reads are not nooped. // if (NewFileSize > Header->FileSize.LowPart) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize.LowPart; OldValidDataLength = Header->ValidDataLength.LowPart; Header->FileSize.LowPart = NewFileSize; } // // We can do fast i/o so call the cc routine to do the work // and then release the fcb when we've done. If for whatever // reason the copy write fails, then return FALSE to our // caller. // // Also mark this as the top level "Irp" so that lower file // system levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if (Offset > Header->ValidDataLength.LowPart) { LARGE_INTEGER ZeroEnd; ZeroEnd.LowPart = Offset; ZeroEnd.HighPart = 0; CcZeroData( FileObject, &Header->ValidDataLength, &ZeroEnd, TRUE ); } CcFastCopyWrite( FileObject, Offset, Length, Buffer ); } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or // ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to // check again since we did not do this when we acquired // the resource exclusive. // if (NewFileSize > Header->ValidDataLength.LowPart) { Header->ValidDataLength.LowPart = NewFileSize; } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { CcGetFileSizePointer(FileObject)->LowPart = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // Also update the file position pointer // FileObject->CurrentByteOffset.LowPart = Offset + Length; FileObject->CurrentByteOffset.HighPart = 0; // // If we did not succeed, then we must restore the original // FileSize while holding the PagingIoResource exclusive if // it exists. // } else if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize.LowPart = OldFileSize; Header->ValidDataLength.LowPart = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize.LowPart = OldFileSize; Header->ValidDataLength.LowPart = OldValidDataLength; } } // // Here is the 64-bit or no-wait path. // } else { LARGE_INTEGER Offset, NewFileSize; LARGE_INTEGER OldFileSize; LARGE_INTEGER OldValidDataLength; ASSERT(!KeIsExecutingDpc()); // // Make our best guess on whether we need the file exclusive // or shared. // NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; if (WriteToEndOfFile || (NewFileSize.QuadPart > Header->ValidDataLength.QuadPart)) { // // Acquired shared on the common fcb header, and return // if we don't get it. // if (!ExAcquireResourceExclusive( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } } else { // // Acquired shared on the common fcb header, and return // if we don't get it. // if (!ExAcquireResourceShared( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o // and if the file space is allocated, and if not then // release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } else { Offset = *FileOffset; NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; } // // Now that the File is acquired shared, we can safely test // if it is really cached and if we can do fast i/o and we // do not have to extend. If not then release the fcb and // return. // // Get out if we are about to zero too much as well, as commented above. // Likewise, for NewFileSizes that exceed MAXLONGLONG. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (Offset.QuadPart >= (Header->ValidDataLength.QuadPart + 0x2000)) || (MAXLONGLONG - Offset.QuadPart < (LONGLONG)Length) || (NewFileSize.QuadPart > Header->AllocationSize.QuadPart) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to // get the Fcb exclusive, and make sure that FastIo is still // possible. We should only execute this block of code very // rarely, when the unsafe test for ValidDataLength failed // above. // if (AcquiredShared && ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart )) { ExReleaseResource( Header->Resource ); if (!ExAcquireResourceExclusive( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart ) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask // the file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; IO_STATUS_BLOCK IoStatus; // // All file system then set "Is Questionable" had better // support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the // answer is anything other than GoForIt then we cannot // take the fast I/O path. // ASSERT(FILE_WRITE_TO_END_OF_FILE == 0xffffffff); if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset->QuadPart != (LONGLONG)-1 ? FileOffset : &Header->FileSize, Length, Wait, LockKey, FALSE, // write operation &IoStatus, DeviceObject )) { // // Fast I/O is not possible so release the Fcb and // return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now // so that our reads are not nooped. // if ( NewFileSize.QuadPart > Header->FileSize.QuadPart ) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize; OldValidDataLength = Header->ValidDataLength; // // Deal with an extremely rare pathalogical case here the // file size wraps. // if ( (Header->FileSize.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = NewFileSize; } } // // We can do fast i/o so call the cc routine to do the work // and then release the fcb when we've done. If for whatever // reason the copy write fails, then return FALSE to our // caller. // // Also mark this as the top level "Irp" so that lower file // system levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if ( Offset.QuadPart > Header->ValidDataLength.QuadPart ) { Status = CcZeroData( FileObject, &Header->ValidDataLength, &Offset, Wait ); } if (Status) { Status = CcCopyWrite( FileObject, &Offset, Length, Wait, Buffer ); } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or // ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to // check again since we did not do this when we acquired // the resource exclusive. // if ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart ) { // // Deal with an extremely rare pathalogical case here // the ValidDataLength wraps. // if ( (Header->ValidDataLength.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->ValidDataLength = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->ValidDataLength = NewFileSize; } } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { *CcGetFileSizePointer(FileObject) = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // Also update the current file position pointer // FileObject->CurrentByteOffset.QuadPart = Offset.QuadPart + Length; // // If we did not succeed, then we must restore the original // FileSize while holding the PagingIoResource exclusive if // it exists. // } else if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; } } } ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; } else { // // A zero length transfer was requested. // return TRUE; } } else { // // The volume must be verified or the file is write through. // return FALSE; } }

NTKERNELAPI BOOLEAN FsRtlCurrentBatchOplock (  IN POPLOCK  Oplock  )

Definition at line 1169 of file oplock.c. References BATCH_OPLOCK, Dbg, DebugTrace, FALSE, FILTER_OPLOCK, FlagOn, NULL, PAGED_CODE, PNONOPAQUE_OPLOCK, and TRUE. Referenced by UdfCompleteFcbOpen(). : This routines indicates whether there are current outstanding batch oplocks. Arguments: OpLock - Supplies the oplock being queried Return Value: BOOLEAN - TRUE if there are outstanding batch oplocks and FALSE otherwise --*/ { BOOLEAN BatchOplocks = FALSE; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlCurrentBatchOplock: Oplock -> %08lx\n", *Oplock); // // There are not any current oplocks if the variable is null or // the state is no oplocks held. We check whether there are batch // oplocks or filter oplocks which have not been broken. // if ((*Oplock != NULL) && FlagOn( ((PNONOPAQUE_OPLOCK) *Oplock)->OplockState, BATCH_OPLOCK | FILTER_OPLOCK )) { BatchOplocks = TRUE; } DebugTrace(-1, Dbg, "FsRtlCurrentBatchOplock: Exit -> %08lx\n", BatchOplocks); return BatchOplocks; }

NTKERNELAPI VOID FsRtlDeleteKeyFromTunnelCache (  IN TUNNEL *  Cache, IN ULONGLONG  DirectoryKey )

NTKERNELAPI VOID FsRtlDeleteTunnelCache (  IN TUNNEL *  Cache  )

NTKERNELAPI VOID FsRtlDeregisterUncProvider (  IN HANDLE  Handle  )

Definition at line 418 of file unc.c. References ASSERT, Executive, ExFreePool(), FALSE, FsRtlpDRD, FsRtlpRedirs, FsRtlpSetSymbolicLink(), FsRtlpUncSemaphore, Handle, KeReleaseSemaphore(), KernelMode, KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, and PAGED_CODE. : This routine deregisters a redir as a UNC provider. Arguments: Handle - A handle to the Multiple UNC router, returned by the registration call. Return Value: None. --*/ { NTSTATUS status; PAGED_CODE(); if( Handle == (HANDLE)-1 || Handle == NULL ) return; status = ZwClose( Handle ); if( !NT_SUCCESS( status ) ) { return; } KeWaitForSingleObject(&FsRtlpUncSemaphore, Executive, KernelMode, FALSE, NULL ); ASSERT( FsRtlpRedirs > 0 ); if( Handle == FsRtlpDRD.ReturnedHandle ) { // // The first redir in the system is closing. Release the state we saved // for it, and pass the close on to the MUP if necessary // if( FsRtlpDRD.RedirDevName.Buffer != NULL ) { ExFreePool( FsRtlpDRD.RedirDevName.Buffer ); FsRtlpDRD.RedirDevName.Buffer = NULL; } if( FsRtlpDRD.MupHandle != (HANDLE)-1 ) { ZwClose( FsRtlpDRD.MupHandle ); FsRtlpDRD.MupHandle = (HANDLE)-1; } FsRtlpDRD.ReturnedHandle = (HANDLE)-1; } if( --FsRtlpRedirs == 0 ) { FsRtlpSetSymbolicLink( (PUNICODE_STRING)NULL ); } KeReleaseSemaphore(&FsRtlpUncSemaphore, 0, 1, FALSE ); }

NTKERNELAPI VOID FsRtlDissectDbcs (  IN ANSI_STRING  InputName, OUT PANSI_STRING  FirstPart, OUT PANSI_STRING  RemainingPart )

Definition at line 542 of file dbcsname.c. References FsRtlIsLeadDbcsCharacter, NULL, PAGED_CODE, and USHORT. Referenced by FsRtlIsFatDbcsLegal(), and FsRtlIsHpfsDbcsLegal(). : This routine takes an input Dbcs string and dissects it into two substrings. The first output string contains the name that appears at the beginning of the input string, the second output string contains the remainder of the input string. In the input string backslashes are used to separate names. The input string must not start with a backslash. Both output strings will not begin with a backslash. If the input string does not contain any names then both output strings are empty. If the input string contains only one name then the first output string contains the name and the second string is empty. Note that both output strings use the same string buffer memory of the input string. Example of its results are: //. . InputString FirstPart RemainingPart // //. . empty empty empty // //. . A A empty // //. . A\B\C\D\E A B\C\D\E // //. . *A? *A? empty // //. . \A A empty // //. . A[,] A[,] empty // //. . A\\B+;\C A \B+;\C Arguments: InputName - Supplies the input string being dissected Is8dot3 - Indicates if the first part of the input name must be 8.3 or can be long file name. FirstPart - Receives the first name in the input string RemainingPart - Receives the remaining part of the input string Return Value: NONE --*/ { ULONG i = 0; ULONG PathLength; ULONG FirstNameStart; PAGED_CODE(); // // Make both output strings empty for now // FirstName->Length = 0; FirstName->MaximumLength = 0; FirstName->Buffer = NULL; RemainingName->Length = 0; RemainingName->MaximumLength = 0; RemainingName->Buffer = NULL; PathLength = Path.Length; // // Check for an empty input string // if (PathLength == 0) { return; } // // Skip over a starting backslash, and make sure there is more. // if ( Path.Buffer[0] == '\\' ) { i = 1; } // // Now run down the input string until we hit a backslash or the end // of the string, remembering where we started; // for ( FirstNameStart = i; (i < PathLength) && (Path.Buffer[i] != '\\'); i += 1 ) { // // If this is the first byte of a Dbcs character, skip over the // next byte as well. // if ( FsRtlIsLeadDbcsCharacter( Path.Buffer[i] ) ) { i += 1; } } // // At this point all characters up to (but not including) i are // in the first part. So setup the first name // FirstName->Length = (USHORT)(i - FirstNameStart); FirstName->MaximumLength = FirstName->Length; FirstName->Buffer = &Path.Buffer[FirstNameStart]; // // Now the remaining part needs a string only if the first part didn't // exhaust the entire input string. We know that if anything is left // that is must start with a backslash. Note that if there is only // a trailing backslash, the length will get correctly set to zero. // if (i < PathLength) { RemainingName->Length = (USHORT)(PathLength - (i + 1)); RemainingName->MaximumLength = RemainingName->Length; RemainingName->Buffer = &Path.Buffer[i + 1]; } // // And return to our caller // return; }

NTKERNELAPI VOID FsRtlDissectName (  IN UNICODE_STRING  Path, OUT PUNICODE_STRING  FirstName, OUT PUNICODE_STRING  RemainingName )

Definition at line 93 of file name.c. References L, NULL, PAGED_CODE, and USHORT. 00101 : 00102 00103 This routine cracks a path. It picks off the first element in the 00104 given path name and provides both it and the remaining part. A path 00105 is a set of file names separated by backslashes. If a name begins 00106 with a backslash, the FirstName is the string immediately following 00107 the backslash. Here are some examples: 00108 00109 Path FirstName RemainingName 00110 ---- --------- ------------- 00111 empty empty empty 00112 00113 \ empty empty 00114 00115 A A empty 00116 00117 \A A empty 00118 00119 A\B\C\D\E A B\C\D\E 00120 00121 *A? *A? empty 00122 00123 00124 Note that both output strings use the same string buffer memory of the 00125 input string, and are not necessarily null terminated. 00126 00127 Also, this routine makes no judgement as to the legality of each 00128 file name componant. This must be done separatly when each file name 00129 is extracted. 00130 00131 Arguments: 00132 00133 Path - The full path name to crack. 00134 00135 FirstName - The first name in the path. Don't allocate a buffer for 00136 this string. 00137 00138 RemainingName - The rest of the path. Don't allocate a buffer for this 00139 string. 00140 00141 Return Value: 00142 00143 None. 00144 00145 --*/ 00146 00147 { 00148 ULONG i = 0; 00149 ULONG PathLength; 00150 ULONG FirstNameStart; 00151 00152 PAGED_CODE(); 00153 00154 // 00155 // Make both output strings empty for now 00156 // 00157 00158 FirstName->Length = 0; 00159 FirstName->MaximumLength = 0; 00160 FirstName->Buffer = NULL; 00161 00162 RemainingName->Length = 0; 00163 RemainingName->MaximumLength = 0; 00164 RemainingName->Buffer = NULL; 00165 00166 PathLength = Path.Length / sizeof(WCHAR); 00167 00168 // 00169 // Check for an empty input string 00170 // 00171 00172 if (PathLength == 0) { 00173 00174 return; 00175 } 00176 00177 // 00178 // Skip over a starting backslash, and make sure there is more. 00179 // 00180 00181 if ( Path.Buffer[0] == L'\\' ) { 00182 00183 i = 1; 00184 } 00185 00186 // 00187 // Now run down the input string until we hit a backslash or the end 00188 // of the string, remembering where we started; 00189 // 00190 00191 for ( FirstNameStart = i; 00192 (i < PathLength) && (Path.Buffer[i] != L'\\'); 00193 i += 1 ) { 00194 00195 NOTHING; 00196 } 00197 00198 // 00199 // At this point all characters up to (but not including) i are 00200 // in the first part. So setup the first name 00201 // 00202 00203 FirstName->Length = (USHORT)((i - FirstNameStart) * sizeof(WCHAR)); 00204 FirstName->MaximumLength = FirstName->Length; 00205 FirstName->Buffer = &Path.Buffer[FirstNameStart]; 00206 00207 // 00208 // Now the remaining part needs a string only if the first part didn't 00209 // exhaust the entire input string. We know that if anything is left 00210 // that is must start with a backslash. Note that if there is only 00211 // a trailing backslash, the length will get correctly set to zero. 00212 // 00213 00214 if (i < PathLength) { 00215 00216 RemainingName->Length = (USHORT)((PathLength - (i + 1)) * sizeof(WCHAR)); 00217 RemainingName->MaximumLength = RemainingName->Length; 00218 RemainingName->Buffer = &Path.Buffer[i + 1]; 00219 } 00220 00221 // 00222 // And return to our caller 00223 // 00224 00225 return; 00226 }

NTKERNELAPI BOOLEAN FsRtlDoesDbcsContainWildCards (  IN PANSI_STRING  Name  )

Definition at line 694 of file dbcsname.c. References FALSE, FsRtlIsAnsiCharacterWild, FsRtlIsLeadDbcsCharacter, Name, PAGED_CODE, and TRUE. Referenced by FsRtlIsDbcsInExpression(), and FsRtlIsFatDbcsLegal(). 00700 : 00701 00702 This routine checks if the input Dbcs name contains any wild card 00703 characters (i.e., *, ?, ANSI_DOS_STAR, or ANSI_DOS_QM). 00704 00705 Arguments: 00706 00707 Name - Supplies the name to examine 00708 00709 Return Value: 00710 00711 BOOLEAN - TRUE if the input name contains any wildcard characters and 00712 FALSE otherwise. 00713 00714 --*/ 00715 00716 { 00717 CLONG i; 00718 00719 PAGED_CODE(); 00720 00721 // 00722 // Check each character in the name to see if it's a wildcard 00723 // character 00724 // 00725 00726 for (i = 0; i < Name->Length; i += 1) { 00727 00728 // 00729 // check for dbcs character because we'll just skip over those 00730 // 00731 00732 if (FsRtlIsLeadDbcsCharacter( Name->Buffer[i] )) { 00733 00734 i += 1; 00735 00736 // 00737 // else check for a wild card character 00738 // 00739 00740 } else if (FsRtlIsAnsiCharacterWild( Name->Buffer[i] )) { 00741 00742 // 00743 // Tell caller that this name contains wild cards 00744 // 00745 00746 return TRUE; 00747 } 00748 } 00749 00750 // 00751 // No wildcard characters were found, so return to our caller 00752 // 00753 00754 return FALSE; 00755 }

NTKERNELAPI BOOLEAN FsRtlDoesNameContainWildCards (  IN PUNICODE_STRING  Name  )

Definition at line 229 of file name.c. References FALSE, FsRtlIsUnicodeCharacterWild, L, Name, PAGED_CODE, PUSHORT, and TRUE. Referenced by FsRtlIsNameInExpressionPrivate(), UdfInitializeEnumeration(), and UdfNormalizeFileNames(). : This routine simply scans the input Name string looking for any Nt wild card characters. Arguments: Name - The string to check. Return Value: BOOLEAN - TRUE if one or more wild card characters was found. --*/ { PUSHORT p; PAGED_CODE(); // // Check each character in the name to see if it's a wildcard // character. // if( Name->Length ) { for( p = Name->Buffer + (Name->Length / sizeof(WCHAR)) - 1; p >= Name->Buffer && *p != L'\\' ; p-- ) { // // check for a wild card character // if (FsRtlIsUnicodeCharacterWild( *p )) { // // Tell caller that this name contains wild cards // return TRUE; } } } // // No wildcard characters were found, so return to our caller // return FALSE; }

NTKERNELAPI BOOLEAN FsRtlFastCheckLockForRead (  IN PFILE_LOCK  FileLock, IN PLARGE_INTEGER  StartingByte, IN PLARGE_INTEGER  Length, IN ULONG  Key, IN PFILE_OBJECT  FileObject, IN PVOID  ProcessId )

Definition at line 2582 of file filelock.c. References Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _LOCK_QUEUE::ExclusiveLockTree, FsRtlCheckNoExclusiveConflict(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, Key, _FILE_LOCK_INFO::Key, _LOCK_INFO::LockQueue, _LOCK_INFO::LowestLockOffset, NULL, PLOCK_INFO, PLOCK_QUEUE, _FILE_LOCK_INFO::ProcessId, _FILE_LOCK_INFO::StartingByte, Status, and TRUE. Referenced by FsRtlCheckLockForReadAccess(). : This routine checks to see if the caller has read access to the indicated range due to file locks. Arguments: FileLock - Supplies the File Lock to check StartingByte - Supplies the first byte (zero based) to check Length - Supplies the length, in bytes, to check Key - Supplies the to use in the check FileObject - Supplies the file object to use in the check ProcessId - Supplies the Process Id to use in the check Return Value: BOOLEAN - TRUE if the indicated user/request has read access to the entire specified byte range, and FALSE otherwise --*/ { LARGE_INTEGER Starting; LARGE_INTEGER Ending; PLOCK_INFO LockInfo; PLOCK_QUEUE LockQueue; KIRQL OldIrql; PFILE_LOCK_INFO LastLock; BOOLEAN Status; if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { // // No lock information on this FileLock // DebugTrace(0, Dbg, "FsRtlFastCheckLockForRead, No lock info\n", 0); return TRUE; } // // If there isn't an exclusive lock then we can immediately grant access // if (LockInfo->LockQueue.ExclusiveLockTree == NULL) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForRead, No exlocks present\n", 0); return TRUE; } // // If length is zero then automatically give grant access // if ((ULONGLONG)Length->QuadPart == 0) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForRead, Length == 0\n", 0); return TRUE; } // // Get our starting and ending byte position // Starting = *StartingByte; (ULONGLONG)Ending.QuadPart = (ULONGLONG)Starting.QuadPart + (ULONGLONG)Length->QuadPart - 1; // // Now check lock queue // LockQueue = &LockInfo->LockQueue; // // Grab the waiting lock queue spinlock to exclude anyone from messing // with the queue while we're using it // FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); // // If the range ends below the lowest existing lock, this read is OK. // if ( ((ULONGLONG)Ending.QuadPart < (ULONGLONG)LockInfo->LowestLockOffset) ) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForRead (below lowest lock)\n", 0); FsRtlReleaseLockQueue(LockQueue, OldIrql); return TRUE; } // // If the caller just locked this range, he can read it. // LastLock = (PFILE_LOCK_INFO)FileObject->LastLock; if ((LastLock != NULL) && ((ULONGLONG)Starting.QuadPart >= (ULONGLONG)LastLock->StartingByte.QuadPart) && ((ULONGLONG)Ending.QuadPart <= (ULONGLONG)LastLock->EndingByte.QuadPart) && (LastLock->Key == Key) && (LastLock->ProcessId == ProcessId)) { FsRtlReleaseLockQueue(LockQueue, OldIrql); return TRUE; } // // Check the exclusive locks for a conflict. It is impossible to have // a read conflict with any shared lock. // Status = FsRtlCheckNoExclusiveConflict(LockQueue, &Starting, &Ending, Key, FileObject, ProcessId); FsRtlReleaseLockQueue(LockQueue, OldIrql); return Status; }

NTKERNELAPI BOOLEAN FsRtlFastCheckLockForWrite (  IN PFILE_LOCK  FileLock, IN PLARGE_INTEGER  StartingByte, IN PLARGE_INTEGER  Length, IN ULONG  Key, IN PVOID  FileObject, IN PVOID  ProcessId )

Definition at line 2718 of file filelock.c. References Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _FILE_LOCK_INFO::ExclusiveLock, _LOCK_QUEUE::ExclusiveLockTree, FsRtlCheckNoExclusiveConflict(), FsRtlCheckNoSharedConflict(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, Key, _FILE_LOCK_INFO::Key, _LOCK_INFO::LockQueue, _LOCK_INFO::LowestLockOffset, NULL, PLOCK_INFO, PLOCK_QUEUE, _FILE_LOCK_INFO::ProcessId, _LOCK_QUEUE::SharedLockTree, _FILE_LOCK_INFO::StartingByte, Status, and TRUE. Referenced by FsRtlCheckLockForWriteAccess(). : This routine checks to see if the caller has write access to the indicated range due to file locks Arguments: FileLock - Supplies the File Lock to check StartingByte - Supplies the first byte (zero based) to check Length - Supplies the length, in bytes, to check Key - Supplies the to use in the check FileObject - Supplies the file object to use in the check ProcessId - Supplies the Process Id to use in the check Return Value: BOOLEAN - TRUE if the indicated user/request has write access to the entire specified byte range, and FALSE otherwise --*/ { LARGE_INTEGER Starting; LARGE_INTEGER Ending; PLOCK_INFO LockInfo; PLOCK_QUEUE LockQueue; KIRQL OldIrql; PFILE_LOCK_INFO LastLock; BOOLEAN Status; if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { // // No lock information on this FileLock // DebugTrace(0, Dbg, "FsRtlFastCheckLockForRead, No lock info\n", 0); return TRUE; } // // If there isn't a lock then we can immediately grant access // if (LockInfo->LockQueue.SharedLockTree == NULL && LockInfo->LockQueue.ExclusiveLockTree == NULL) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForWrite, No locks present\n", 0); return TRUE; } // // If length is zero then automatically grant access // if ((ULONGLONG)Length->QuadPart == 0) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForWrite, Length == 0\n", 0); return TRUE; } // // Get our starting and ending byte position // Starting = *StartingByte; (ULONGLONG)Ending.QuadPart = (ULONGLONG)Starting.QuadPart + (ULONGLONG)Length->QuadPart - 1; // // Now check lock queue // LockQueue = &LockInfo->LockQueue; // // Grab the waiting lock queue spinlock to exclude anyone from messing // with the queue while we're using it // FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); // // If the range ends below the lowest existing lock, this write is OK. // if ( ((ULONGLONG)Ending.QuadPart < (ULONGLONG)LockInfo->LowestLockOffset) ) { DebugTrace(0, Dbg, "FsRtlFastCheckLockForWrite (below lowest lock)\n", 0); FsRtlReleaseLockQueue(LockQueue, OldIrql); return TRUE; } // // If the caller just locked this range exclusively, he can write it. // LastLock = (PFILE_LOCK_INFO)((PFILE_OBJECT)FileObject)->LastLock; if ((LastLock != NULL) && ((ULONGLONG)Starting.QuadPart >= (ULONGLONG)LastLock->StartingByte.QuadPart) && ((ULONGLONG)Ending.QuadPart <= (ULONGLONG)LastLock->EndingByte.QuadPart) && (LastLock->Key == Key) && (LastLock->ProcessId == ProcessId) && LastLock->ExclusiveLock) { FsRtlReleaseLockQueue(LockQueue, OldIrql); return TRUE; } // // Check the shared locks for overlap. Any overlap in the shared locks is fatal. // Status = FsRtlCheckNoSharedConflict(LockQueue, &Starting, &Ending); if (Status == TRUE) { // // No overlap in the shared locks, so check the exclusive locks for overlap. // Status = FsRtlCheckNoExclusiveConflict(LockQueue, &Starting, &Ending, Key, FileObject, ProcessId); } FsRtlReleaseLockQueue(LockQueue, OldIrql); return Status; }

NTKERNELAPI NTSTATUS FsRtlFastUnlockAll (  IN PFILE_LOCK  FileLock, IN PFILE_OBJECT  FileObject, IN PEPROCESS  ProcessId, IN PVOID Context  OPTIONAL )

Definition at line 3770 of file filelock.c. References FALSE, and FsRtlPrivateFastUnlockAll(). Referenced by FsRtlProcessFileLock(), UdfCommonCleanup(), and UdfFastUnlockAll(). : This routine performs an Unlock all operation on the current locks associated with the specified file lock. Only those locks with a matching file object and process id are freed. Arguments: FileLock - Supplies the file lock being freed. FileObject - Supplies the file object associated with the file lock ProcessId - Supplies the Process Id assoicated with the locks to be freed Context - Supplies an optional context to use when completing waiting lock irps. Return Value: None --*/ { return FsRtlPrivateFastUnlockAll( FileLock, FileObject, ProcessId, 0, FALSE, // No Key Context ); }

NTKERNELAPI NTSTATUS FsRtlFastUnlockAllByKey (  IN PFILE_LOCK  FileLock, IN PFILE_OBJECT  FileObject, IN PEPROCESS  ProcessId, IN ULONG  Key, IN PVOID Context  OPTIONAL )

Definition at line 3814 of file filelock.c. References FsRtlPrivateFastUnlockAll(), Key, and TRUE. Referenced by FsRtlProcessFileLock(), and UdfFastUnlockAllByKey(). : This routine performs an Unlock All by Key operation on the current locks associated with the specified file lock. Only those locks with a matching file object, process id, and key are freed. The input Irp is completed by this procedure Arguments: FileLock - Supplies the file lock being freed. FileObject - Supplies the file object associated with the file lock ProcessId - Supplies the Process Id assoicated with the locks to be freed Key - Supplies the Key to use in this operation Context - Supplies an optional context to use when completing waiting lock irps. Return Value: NTSTATUS - The return status for the operation. --*/ { return FsRtlPrivateFastUnlockAll( FileLock, FileObject, ProcessId, Key, TRUE, Context ); }

NTKERNELAPI NTSTATUS FsRtlFastUnlockSingle (  IN PFILE_LOCK  FileLock, IN PFILE_OBJECT  FileObject, IN LARGE_INTEGER UNALIGNED *  FileOffset, IN PLARGE_INTEGER  Length, IN PEPROCESS  ProcessId, IN ULONG  Key, IN PVOID Context  OPTIONAL, IN BOOLEAN  AlreadySynchronized )

Definition at line 3241 of file filelock.c. References FALSE, FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), Key, NTSTATUS(), NULL, Status, and TRUE. Referenced by FsRtlProcessFileLock(), and UdfFastUnlockSingle(). : This routine performs an Unlock Single operation on the current locks associated with the specified file lock. Only the lock with a matching file object, process id, key, and range is freed. Arguments: FileLock - Supplies the file lock being freed. FileObject - Supplies the file object holding the locks FileOffset - Supplies the offset to be unlocked Length - Supplies the length in bytes to be unlocked ProcessId - Supplies the process Id to use in this operation Key - Supplies the key to use in this operation Context - Optionally supplies context to use when completing Irps AlreadySynchronized - Indicates that the caller has already synchronized access to the file lock so the fields in the file lock and be updated without further locking, but not the queues. Return Value: NTSTATUS - The completion status for this operation --*/ { NTSTATUS Status; // // XXX AlreadySynchronized is obsolete. It was apparently added for the dead // XXX SoloLock code. // if (FileLock->LockInformation == NULL) { // // Fast exit - no locks are applied // return STATUS_RANGE_NOT_LOCKED; } Status = FsRtlFastUnlockSingleExclusive( FileLock->LockInformation, FileObject, FileOffset, Length, ProcessId, Key, Context, FALSE, TRUE ); if (Status == STATUS_SUCCESS) { // // Found and unlocked in the exclusive tree, so we're done // return Status; } Status = FsRtlFastUnlockSingleShared( FileLock->LockInformation, FileObject, FileOffset, Length, ProcessId, Key, Context, FALSE, TRUE ); return Status; }

NTKERNELAPI BOOLEAN FsRtlFindInTunnelCache (  IN TUNNEL *  Cache, IN ULONGLONG  DirectoryKey, IN UNICODE_STRING *  Name, OUT UNICODE_STRING *  ShortName, OUT UNICODE_STRING *  LongName, IN OUT ULONG *  DataLength, OUT VOID *  Data )

VOID FsRtlFreeFileLock (  IN PFILE_LOCK  FileLock  )

Definition at line 1162 of file filelock.c. References ExFreeToPagedLookasideList(), FsRtlFileLockLookasideList, and FsRtlUninitializeFileLock(). Referenced by UdfDeleteFcb(). { FsRtlUninitializeFileLock( FileLock ); ExFreeToPagedLookasideList( &FsRtlFileLockLookasideList, FileLock ); }

NTSTATUS FsRtlGetFileSize (  IN PFILE_OBJECT  FileObject, IN OUT PLARGE_INTEGER  FileSize )

Definition at line 2691 of file fastio.c. References _IRP::AssociatedIrp, _IO_STACK_LOCATION::DeviceObject, _DEVICE_OBJECT::DriverObject, Event(), Executive, FALSE, _DRIVER_OBJECT::FastIoDispatch, _FAST_IO_DISPATCH::FastIoQueryStandardInfo, _IO_STACK_LOCATION::FileObject, _IRP::Flags, IoAllocateIrp(), IoCallDriver, IoGetNextIrpStackLocation, IoGetRelatedDeviceObject(), Irp, IRP_MJ_QUERY_INFORMATION, IRP_PAGING_IO, IRP_SYNCHRONOUS_PAGING_IO, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), _IO_STACK_LOCATION::MajorFunction, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _IO_STACK_LOCATION::Parameters, PsGetCurrentThread, _IRP::RequestorMode, _DEVICE_OBJECT::StackSize, Status, _IRP::Tail, TRUE, _IRP::UserEvent, and _IRP::UserIosb. Referenced by MiCreateDataFileMap(), MiCreateImageFileMap(), MmCreateSection(), and MmExtendSection(). 02698 : 02699 02700 This routine is used to call the File System to get the FileSize 02701 for a file. 02702 02703 It does this without acquiring the file object lock on synchronous file 02704 objects. This routine is therefore safe to call if you already own 02705 file system resources, while IoQueryFileInformation could (and does) 02706 lead to deadlocks. 02707 02708 Arguments: 02709 02710 FileObject - The file to query 02711 FileSize - Receives the file size. 02712 02713 Return Value: 02714 02715 NTSTATUS - The final I/O status of the operation. If the FileObject 02716 refers to a directory, STATUS_FILE_IS_A_DIRECTORY is returned. 02717 02718 --*/ 02719 { 02720 IO_STATUS_BLOCK IoStatus; 02721 PDEVICE_OBJECT DeviceObject; 02722 PFAST_IO_DISPATCH FastIoDispatch; 02723 FILE_STANDARD_INFORMATION FileInformation; 02724 02725 PAGED_CODE(); 02726 02727 // 02728 // Get the address of the target device object. 02729 // 02730 02731 DeviceObject = IoGetRelatedDeviceObject( FileObject ); 02732 02733 // 02734 // Try the fast query call if it exists. 02735 // 02736 02737 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; 02738 02739 if (FastIoDispatch && 02740 FastIoDispatch->FastIoQueryStandardInfo && 02741 FastIoDispatch->FastIoQueryStandardInfo( FileObject, 02742 TRUE, 02743 &FileInformation, 02744 &IoStatus, 02745 DeviceObject )) { 02746 // 02747 // Cool, it worked. 02748 // 02749 02750 } else { 02751 02752 // 02753 // Life's tough, take the long path. 02754 // 02755 02756 PIRP Irp; 02757 KEVENT Event; 02758 NTSTATUS Status; 02759 PIO_STACK_LOCATION IrpSp; 02760 02761 // 02762 // Initialize the event. 02763 // 02764 02765 KeInitializeEvent( &Event, NotificationEvent, FALSE ); 02766 02767 // 02768 // Allocate an I/O Request Packet (IRP) for this in-page operation. 02769 // 02770 02771 Irp = IoAllocateIrp( DeviceObject->StackSize, FALSE ); 02772 if (Irp == NULL) { 02773 02774 return STATUS_INSUFFICIENT_RESOURCES; 02775 } 02776 02777 // 02778 // Get a pointer to the first stack location in the packet. This location 02779 // will be used to pass the function codes and parameters to the first 02780 // driver. 02781 // 02782 02783 IrpSp = IoGetNextIrpStackLocation( Irp ); 02784 02785 // 02786 // Fill in the IRP according to this request, setting the flags to 02787 // just cause IO to set the event and deallocate the Irp. 02788 // 02789 02790 Irp->Flags = IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO; 02791 Irp->RequestorMode = KernelMode; 02792 Irp->UserIosb = &IoStatus; 02793 Irp->UserEvent = &Event; 02794 Irp->Tail.Overlay.OriginalFileObject = FileObject; 02795 Irp->Tail.Overlay.Thread = PsGetCurrentThread(); 02796 Irp->AssociatedIrp.SystemBuffer = &FileInformation; 02797 02798 // 02799 // Fill in the normal query parameters. 02800 // 02801 02802 IrpSp->MajorFunction = IRP_MJ_QUERY_INFORMATION; 02803 IrpSp->FileObject = FileObject; 02804 IrpSp->DeviceObject = DeviceObject; 02805 IrpSp->Parameters.SetFile.Length = sizeof(FILE_STANDARD_INFORMATION); 02806 IrpSp->Parameters.SetFile.FileInformationClass = FileStandardInformation; 02807 02808 // 02809 // Queue the packet to the appropriate driver based. This routine 02810 // should not raise. 02811 // 02812 02813 Status = IoCallDriver( DeviceObject, Irp ); 02814 02815 // 02816 // If pending is returned (which is a successful status), 02817 // we must wait for the request to complete. 02818 // 02819 02820 if (Status == STATUS_PENDING) { 02821 KeWaitForSingleObject( &Event, 02822 Executive, 02823 KernelMode, 02824 FALSE, 02825 (PLARGE_INTEGER)NULL); 02826 } 02827 02828 // 02829 // If we got an error back in Status, then the Iosb 02830 // was not written, so we will just copy the status 02831 // there, then test the final status after that. 02832 // 02833 02834 if (!NT_SUCCESS(Status)) { 02835 IoStatus.Status = Status; 02836 } 02837 } 02838 02839 // 02840 // If the call worked, check to make sure it wasn't a directory and 02841 // if not, fill in the FileSize parameter. 02842 // 02843 02844 if (NT_SUCCESS(IoStatus.Status)) { 02845 02846 if (FileInformation.Directory) { 02847 02848 // 02849 // Can't get file size for a directory. Return error. 02850 // 02851 02852 IoStatus.Status = STATUS_FILE_IS_A_DIRECTORY; 02853 02854 } else { 02855 02856 *FileSize = FileInformation.EndOfFile; 02857 } 02858 } 02859 02860 return IoStatus.Status; 02861 }

NTKERNELAPI PFILE_LOCK_INFO FsRtlGetNextFileLock (  IN PFILE_LOCK  FileLock, IN BOOLEAN  Restart )

Definition at line 1951 of file filelock.c. References Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _FILE_LOCK_INFO::ExclusiveLock, _LOCK_QUEUE::ExclusiveLockTree, FALSE, _FILE_LOCK_INFO::FileObject, FsRtlAcquireLockQueue, FsRtlFindFirstOverlappingExclusiveNode(), FsRtlFindFirstOverlappingSharedNode(), FsRtlReleaseLockQueue, GreaterThan, _FILE_LOCK_INFO::Key, _FILE_LOCK_INFO::Length, _SH_LOCK::LockInfo, _EX_LOCK::LockInfo, _LOCK_INFO::LockQueue, _LOCKTREE_NODE::Locks, NULL, PEX_LOCK, PLOCK_INFO, PLOCKTREE_NODE, _FILE_LOCK_INFO::ProcessId, PSH_LOCK, RtlRealSuccessor(), _LOCK_QUEUE::SharedLockTree, _FILE_LOCK_INFO::StartingByte, and TRUE. : This routine enumerates the individual file locks denoted by the input file lock variable. It returns a pointer to the file lock information stored for each lock. The caller is responsible for synchronizing call to this procedure and for not altering any of the data returned by this procedure. If the caller does not synchronize the enumeration will not be reliably complete. The way a programmer will use this procedure to enumerate all of the locks is as follows: for (p = FsRtlGetNextFileLock( FileLock, TRUE ); p != NULL; p = FsRtlGetNextFileLock( FileLock, FALSE )) { // Process the lock information referenced by p } Order is *not* guaranteed. Arguments: FileLock - Supplies the File Lock to enumerate. The current enumeration state is stored in the file lock variable so if multiple threads are enumerating the lock at the same time the results will be unpredictable. Restart - Indicates if the enumeration is to start at the beginning of the file lock tree or if we are continuing from a previous call. Return Value: PFILE_LOCK_INFO - Either it returns a pointer to the next file lock record for the input file lock or it returns NULL if there are not more locks. --*/ { FILE_LOCK_INFO FileLockInfo; PVOID ContinuationPointer; PLOCK_INFO LockInfo; PLOCKTREE_NODE Node; PSINGLE_LIST_ENTRY Link; PRTL_SPLAY_LINKS SplayLinks, LastSplayLinks; PSH_LOCK ShLock; PEX_LOCK ExLock; BOOLEAN FoundReturnable, GreaterThan; KIRQL OldIrql; DebugTrace(+1, Dbg, "FsRtlGetNextFileLock, FileLock = %08lx\n", FileLock); if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { // // No lock information on this FileLock // return NULL; } FoundReturnable = FALSE; // // Before getting the spinlock, copy pagable info onto stack // FileLockInfo = FileLock->LastReturnedLockInfo; ContinuationPointer = FileLock->LastReturnedLock; FsRtlAcquireLockQueue (&LockInfo->LockQueue, &OldIrql); if (!Restart) { // // Given the last returned lock, find its current successor in the tree. // Previous implementations would reset the enumeration if the last returned // lock had been removed from the tree but I think we can be better in that // case since every other structure modifying event (add new locks, delete // other locks) would *not* have caused the reset. Possible minor performance // enhancement. // // // Find the node which could contain the last returned lock. We enumerate the // exclusive lock tree, then the shared lock tree. Find the one we're enumerating. // if (FileLockInfo.ExclusiveLock) { // // Continue enumeration in the exclusive lock tree // ExLock = NULL; SplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockInfo->LockQueue.ExclusiveLockTree, &FileLockInfo.StartingByte, &FileLockInfo.EndingByte, &LastSplayLinks, &GreaterThan ); if (SplayLinks == NULL) { // // No overlapping nodes were found, try to find successor // if (GreaterThan) { // // Last node looked at was greater than the lock so it is // the place to pick up the enumeration // SplayLinks = LastSplayLinks; } else { // // Last node looked at was less than the lock so grab its successor // if (LastSplayLinks) { SplayLinks = RtlRealSuccessor(LastSplayLinks); } } } else { // // Found an overlapping lock, see if it is the last returned // for (; SplayLinks; SplayLinks = RtlRealSuccessor(SplayLinks)) { ExLock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); if (ContinuationPointer == ExLock && (ULONGLONG)FileLockInfo.StartingByte.QuadPart == (ULONGLONG)ExLock->LockInfo.StartingByte.QuadPart && (ULONGLONG)FileLockInfo.Length.QuadPart == (ULONGLONG)ExLock->LockInfo.Length.QuadPart && FileLockInfo.Key == ExLock->LockInfo.Key && FileLockInfo.FileObject == ExLock->LockInfo.FileObject && FileLockInfo.ProcessId == ExLock->LockInfo.ProcessId) { // // Found last returned, dig up its successor // SplayLinks = RtlRealSuccessor(SplayLinks); // // Got the node cold, so we're done // break; } // // This lock overlapped and was not the last returned. In fact, since this lock would // have conflicted with the last returned we know it could not have been returned // before, so this should be returned to the caller. // // However, if it is a zero length lock we are looking for and a zero length lock we hit, // we are at the beginning of a run we need to inspect. If we cannot find the last lock // we returned, resume the enumeration at the beginning of the run. // if (ExLock->LockInfo.Length.QuadPart != 0 || FileLockInfo.Length.QuadPart != 0) { break; } // // Keep wandering down the run // } } // // Were we able to find a lock to return? // if (SplayLinks == NULL) { // // There aren't any more exclusive locks, fall over to the shared tree // SplayLinks = LockInfo->LockQueue.SharedLockTree; if (SplayLinks) { while (RtlLeftChild(SplayLinks)) { SplayLinks = RtlLeftChild(SplayLinks); } Node = CONTAINING_RECORD(SplayLinks, LOCKTREE_NODE, Links); ShLock = CONTAINING_RECORD(Node->Locks.Next, SH_LOCK, Link); FileLockInfo = ShLock->LockInfo; ContinuationPointer = ShLock; FoundReturnable = TRUE; } } else { // // This is the lock to return // ExLock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); FileLockInfo = ExLock->LockInfo; ContinuationPointer = ExLock; FoundReturnable = TRUE; } } else { // // Continue enumeration in the shared lock tree // Node = NULL; SplayLinks = FsRtlFindFirstOverlappingSharedNode( LockInfo->LockQueue.SharedLockTree, &FileLockInfo.StartingByte, &FileLockInfo.EndingByte, &LastSplayLinks, &GreaterThan ); if (SplayLinks == NULL) { // // No overlapping nodes were found // if (GreaterThan) { // // Last node looked at was greater than the lock so it is // the place to pick up the enumeration // if (LastSplayLinks) { SplayLinks = LastSplayLinks; Node = CONTAINING_RECORD( LastSplayLinks, LOCKTREE_NODE, Links ); } } else { // // Last node looked at was less than the lock so grab its successor // if (LastSplayLinks) { SplayLinks = RtlRealSuccessor(LastSplayLinks); if (SplayLinks) { Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); } } } } else { // // Grab the node we found // Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); } // // If we have a node to look at, it may still not contain the the last returned lock // if this isn't synchronized. // if (Node != NULL) { // // Walk down the locks at this node looking for the last returned lock // for (Link = Node->Locks.Next; Link; Link = Link->Next) { // // Get a pointer to the current lock record // ShLock = CONTAINING_RECORD( Link, SH_LOCK, Link ); // // See if it's a match // if (ContinuationPointer == ShLock && (ULONGLONG)FileLockInfo.StartingByte.QuadPart == (ULONGLONG)ShLock->LockInfo.StartingByte.QuadPart && (ULONGLONG)FileLockInfo.Length.QuadPart == (ULONGLONG)ShLock->LockInfo.Length.QuadPart && FileLockInfo.Key == ShLock->LockInfo.Key && FileLockInfo.FileObject == ShLock->LockInfo.FileObject && FileLockInfo.ProcessId == ShLock->LockInfo.ProcessId) { Link = Link->Next; break; } // // See if we passed by its slot // if ((ULONGLONG)FileLockInfo.StartingByte.QuadPart < (ULONGLONG)ShLock->LockInfo.StartingByte.QuadPart) { break; } } if (Link == NULL) { // // This node doesn't contain the successor, so move // up to the successor node in the tree and return the // first lock. If we're actually at the end of the tree // we just fall off the end correctly. // SplayLinks = RtlRealSuccessor(SplayLinks); if (SplayLinks) { Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); Link = Node->Locks.Next; } } if (Link) { // // Found a Lock to return, copy it to the stack // ShLock = CONTAINING_RECORD( Link, SH_LOCK, Link ); FileLockInfo = ShLock->LockInfo; ContinuationPointer = ShLock; FoundReturnable = TRUE; } } } } else { // // Restarting the enumeration. Find leftmost node in the exclusive tree and hand back // the first lock, falling over to the shared if no exlcusive locks are applied // if (LockInfo->LockQueue.ExclusiveLockTree) { SplayLinks = LockInfo->LockQueue.ExclusiveLockTree; while (RtlLeftChild(SplayLinks) != NULL) { SplayLinks = RtlLeftChild(SplayLinks); } ExLock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); FileLockInfo = ExLock->LockInfo; ContinuationPointer = ExLock; FoundReturnable = TRUE; } else { if (LockInfo->LockQueue.SharedLockTree) { SplayLinks = LockInfo->LockQueue.SharedLockTree; while (RtlLeftChild(SplayLinks) != NULL) { SplayLinks = RtlLeftChild(SplayLinks); } Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); ShLock = CONTAINING_RECORD( Node->Locks.Next, SH_LOCK, Link ); FileLockInfo = ShLock->LockInfo; ContinuationPointer = ShLock; FoundReturnable = TRUE; } } } // // Release all the lock queues // FsRtlReleaseLockQueue (&LockInfo->LockQueue, OldIrql); if (!FoundReturnable) { // // No returnable lock was found, end of list // return NULL; } // // Update current enum location information // FileLock->LastReturnedLockInfo = FileLockInfo; FileLock->LastReturnedLock = ContinuationPointer; // // Return lock record to caller // return &FileLock->LastReturnedLockInfo; }

NTKERNELAPI BOOLEAN FsRtlGetNextLargeMcbEntry (  IN PLARGE_MCB  Mcb, IN ULONG  RunIndex, OUT PLONGLONG  Vbn, OUT PLONGLONG  Lbn, OUT PLONGLONG  SectorCount )

Definition at line 1970 of file largemcb.c. References Dbg, DebugTrace, FALSE, _NONOPAQUE_MCB::FastMutex, PAGED_CODE, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, SectorsWithinRun, StartingLbn, StartingVbn, TRUE, try_return, and UNUSED_LBN. Referenced by FsRtlGetNextMcbEntry(). : This routine returns to its caller the Vbn, Lbn, and SectorCount for distinct runs mapped by an Mcb. Holes are counted as runs. For example, to construct to print out all of the runs in a a file is: //. . for (i = 0; FsRtlGetNextLargeMcbEntry(Mcb,i,&Vbn,&Lbn,&Count); i++) { // //. . // print out vbn, lbn, and count // //. . } Arguments: OpaqueMcb - Supplies the Mcb being examined. RunIndex - Supplies the index of the run (zero based) to return to the caller. Vbn - Receives the starting Vbn of the returned run, or zero if the run does not exist. Lbn - Recieves the starting Lbn of the returned run, or zero if the run does not exist. SectorCount - Receives the number of sectors within the returned run, or zero if the run does not exist. Return Value: BOOLEAN - TRUE if the specified run (i.e., RunIndex) exists in the Mcb, and FALSE otherwise. If FALSE is returned then the Vbn, Lbn, and SectorCount parameters receive zero. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; BOOLEAN Result; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlGetNextLargeMcbEntry, Mcb = %08lx\n", Mcb ); DebugTrace( 0, Dbg, " RunIndex = %08lx\n", RunIndex ); ExAcquireFastMutex( Mcb->FastMutex ); try { // // Make sure the run index is within range // if (RunIndex >= Mcb->PairCount) { try_return (Result = FALSE); } // // Set the return variables // *((PULONG)LargeVbn) = StartingVbn(Mcb,RunIndex); *((PULONG)LargeLbn) = StartingLbn(Mcb,RunIndex); *((PULONG)LargeSectorCount) = SectorsWithinRun(Mcb,RunIndex); Result = TRUE; try_exit: NOTHING; } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlGetNextLargeMcbEntry -> %08lx\n", Result ); } ((PLARGE_INTEGER)LargeVbn)->HighPart = (*((PULONG)LargeVbn) == UNUSED_LBN ? UNUSED_LBN : 0); ((PLARGE_INTEGER)LargeLbn)->HighPart = (*((PULONG)LargeLbn) == UNUSED_LBN ? UNUSED_LBN : 0); ((PLARGE_INTEGER)LargeSectorCount)->HighPart = 0; return Result; }

NTKERNELAPI BOOLEAN FsRtlGetNextMcbEntry (  IN PMCB  Mcb, IN ULONG  RunIndex, OUT PVBN  Vbn, OUT PLBN  Lbn, OUT PULONG  SectorCount )

Definition at line 490 of file largemcb.c. References FsRtlGetNextLargeMcbEntry(), and PAGED_CODE. { BOOLEAN Results; LONGLONG LiVbn; LONGLONG LiLbn; LONGLONG LiSectorCount; PAGED_CODE(); Results = FsRtlGetNextLargeMcbEntry( (PLARGE_MCB)Mcb, RunIndex, &LiVbn, &LiLbn, &LiSectorCount ); *Vbn = ((ULONG)LiVbn); *Lbn = (((ULONG)LiLbn) == -1 ? 0 : ((ULONG)LiLbn)); *SectorCount = ((ULONG)LiSectorCount); return Results; }

NTKERNELAPI VOID FsRtlInitializeFileLock (  IN PFILE_LOCK  FileLock, IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine  OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine  OPTIONAL )

Definition at line 829 of file filelock.c. References Dbg, DebugTrace, FALSE, NULL, and PUNLOCK_ROUTINE. Referenced by FsRtlAllocateFileLock(). : This routine initializes a new FILE_LOCK structure. The caller must supply the memory for the structure. This call must precede all other calls that utilize the FILE_LOCK variable. Arguments: FileLock - Supplies a pointer to the FILE_LOCK structure to initialize. CompleteLockIrpRoutine - Optionally supplies an alternate routine to call for completing IRPs. FsRtlProcessFileLock by default will call IoCompleteRequest to finish up an IRP; however if the caller want to process the completion itself then it needs to specify a completion routine here. This routine will then be called in place of IoCompleteRequest. UnlockRoutine - Optionally supplies a routine to call when removing a lock. Return Value: None. --*/ { DebugTrace(+1, Dbg, "FsRtlInitializeFileLock, FileLock = %08lx\n", FileLock); // // Clear non-paged pool pointer // FileLock->LockInformation = NULL; FileLock->CompleteLockIrpRoutine = CompleteLockIrpRoutine; FileLock->UnlockRoutine = UnlockRoutine; FileLock->FastIoIsQuestionable = FALSE; // // and return to our caller // DebugTrace(-1, Dbg, "FsRtlInitializeFileLock -> VOID\n", 0 ); return; }

NTKERNELAPI VOID FsRtlInitializeLargeMcb (  IN PLARGE_MCB  Mcb, IN POOL_TYPE  PoolType )

Definition at line 572 of file largemcb.c. References Dbg, DebugTrace, ExInitializeFastMutex, _NONOPAQUE_MCB::FastMutex, FsRtlAllocateFastMutex, FsRtlAllocateFirstMapping, FsRtlFreeFastMutex, FsRtlpAllocatePool, INITIAL_MAXIMUM_PAIR_COUNT, _NONOPAQUE_MCB::Mapping, _NONOPAQUE_MCB::MaximumPairCount, NULL, PagedPool, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, and _NONOPAQUE_MCB::PoolType. Referenced by FsRtlInitializeMcb(), UdfInitializeFcbMcb(), and UdfLoadSparingTables(). : This routine initializes a new Mcb structure. The caller must supply the memory for the Mcb structure. This call must precede all other calls that set/query the Mcb structure. If pool is not available this routine will raise a status value indicating insufficient resources. Arguments: OpaqueMcb - Supplies a pointer to the Mcb structure to initialize. PoolType - Supplies the pool type to use when allocating additional internal Mcb memory. Return Value: None. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; DebugTrace(+1, Dbg, "FsRtlInitializeLargeMcb, Mcb = %08lx\n", Mcb ); // // Preset the following fields to null so we know to deallocate them // during an abnormal termination // Mcb->FastMutex = NULL; Mcb->Mapping = NULL; try { // // Initialize the fields in the Mcb // Mcb->FastMutex = FsRtlAllocateFastMutex(); ExInitializeFastMutex( Mcb->FastMutex ); Mcb->PairCount = 0; Mcb->PoolType = PoolType; // // Allocate a new buffer an initial size is one that will hold // 16 runs // if (PoolType == PagedPool) { Mcb->Mapping = FsRtlAllocateFirstMapping(); } else { Mcb->Mapping = FsRtlpAllocatePool( Mcb->PoolType, sizeof(MAPPING) * INITIAL_MAXIMUM_PAIR_COUNT ); } //**** RtlZeroMemory( Mcb->Mapping, sizeof(MAPPING) * INITIAL_MAXIMUM_PAIR_COUNT ); Mcb->MaximumPairCount = INITIAL_MAXIMUM_PAIR_COUNT; } finally { // // If this is an abnormal termination then we need to deallocate // the FastMutex and/or mapping (but once the mapping is allocated, // we can't raise). // if (AbnormalTermination()) { if (Mcb->FastMutex != NULL) { FsRtlFreeFastMutex( Mcb->FastMutex ); } } DebugTrace(-1, Dbg, "FsRtlInitializeLargeMcb -> VOID\n", 0 ); } // // And return to our caller // return; }

NTKERNELAPI VOID FsRtlInitializeMcb (  IN PMCB  Mcb, IN POOL_TYPE  PoolType )

Definition at line 334 of file largemcb.c. References FsRtlInitializeLargeMcb(), and PAGED_CODE. Referenced by UdfInitializeVmcb(). { PAGED_CODE(); FsRtlInitializeLargeMcb( (PLARGE_MCB)Mcb, PoolType ); return; }

NTKERNELAPI VOID FsRtlInitializeOplock (  IN OUT POPLOCK  Oplock  )

Definition at line 373 of file oplock.c. References Dbg, DebugTrace, and PAGED_CODE. : This routine initializes a new OPLOCK structure. This call must precede any other call to this entry point with this OPLOCK structure. In addition, this routine will have exclusive access to the Oplock structure. Arguments: Oplock - Supplies the address of an opaque OPLOCK structure. Return Value: None. --*/ { UNREFERENCED_PARAMETER( Oplock ); PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlInitializeOplock: Oplock -> %08lx\n", *Oplock ); // // No action is taken at this time. // DebugTrace(-1, Dbg, "FsRtlInitializeOplock: Exit\n", 0); return; }

NTKERNELAPI VOID FsRtlInitializeTunnelCache (  IN TUNNEL *  Cache  )

NTKERNELAPI BOOLEAN FsRtlInitSystem (   )

Definition at line 215 of file fsrtlpc.c. References COMPATIBILITY_MODE_VALUE_NAME, ExInitializeResource, FALSE, FSRTL_NUMBER_OF_RESOURCES, FsRtlAllocatePool, FsRtlGetCompatibilityModeValue(), FsRtlInitializeFileLocks(), FsRtlInitializeLargeMcbs(), FsRtlInitializeTunnels(), FsRtlInitializeWorkerThread(), FsRtlPagingIoResources, FsRtlpUncSemaphore, FsRtlSafeExtensions, KeInitializeSemaphore(), NonPagedPool, NT_SUCCESS, PAGED_CODE, TRUE, and ValueName. { ULONG i; ULONG Value; UNICODE_STRING ValueName; extern KSEMAPHORE FsRtlpUncSemaphore; PAGED_CODE(); // // Allocate and initialize all the paging Io resources // FsRtlPagingIoResources = FsRtlAllocatePool( NonPagedPool, FSRTL_NUMBER_OF_RESOURCES * sizeof(ERESOURCE) ); for (i=0; i < FSRTL_NUMBER_OF_RESOURCES; i++) { ExInitializeResource( &FsRtlPagingIoResources[i] ); } // // Initialize the global tunneling structures. // FsRtlInitializeTunnels(); // // Initialize the global filelock structures. // FsRtlInitializeFileLocks(); // // Initialize the global largemcb structures. // FsRtlInitializeLargeMcbs(); // // Initialize the semaphore used to guard loading of the MUP // KeInitializeSemaphore( &FsRtlpUncSemaphore, 1, MAXLONG ); // // Pull the bit from the registry telling us whether to do a safe // or dangerous extension truncation. // ValueName.Buffer = COMPATIBILITY_MODE_VALUE_NAME; ValueName.Length = sizeof(COMPATIBILITY_MODE_VALUE_NAME) - sizeof(WCHAR); ValueName.MaximumLength = sizeof(COMPATIBILITY_MODE_VALUE_NAME); if (NT_SUCCESS(FsRtlGetCompatibilityModeValue( &ValueName, &Value )) && (Value != 0)) { FsRtlSafeExtensions = FALSE; } // // Initialize the FsRtl stack overflow work QueueObject and thread. // if (!NT_SUCCESS(FsRtlInitializeWorkerThread())) { return FALSE; } return TRUE; }

NTKERNELAPI NTSTATUS FsRtlInsertFilterContext (  IN PFILE_OBJECT  FileObject, IN PFSRTL_FILTER_CONTEXT  Ptr )

Definition at line 58 of file filtrctx.c. References ASSERT, FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS, Header, PFSRTL_FILTER_CONTEXT, and Ptr. : This routine associates filter driver context with a stream. Arguments: FileObject - Specifies the stream of interest. Ptr - Pointer to the filter-specific context structure. The common header fields OwnerId and InstanceId should be filled in by the filter driver before calling. Return Value: STATUS_SUCCESS - operation succeeded. STATUS_INVALID_DEVICE_REQUEST - underlying filesystem does not support filter contexts. --*/ { PFSRTL_COMMON_FCB_HEADER Header; ASSERT(FileObject); ASSERT(FileObject->FsContext); Header = FileObject->FsContext; if (! (Header->Flags2 & FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS) ) { return STATUS_INVALID_DEVICE_REQUEST; } ExAcquireFastMutex (Header->FastMutex); InsertHeadList (&Header->FilterContexts, &Ptr->Links); ExReleaseFastMutex(Header->FastMutex); return STATUS_SUCCESS; }

NTKERNELAPI BOOLEAN FsRtlIsDbcsInExpression (  IN PANSI_STRING  Expression, IN PANSI_STRING  Name )

Definition at line 771 of file dbcsname.c. References ASSERT, Dbg, DebugTrace, ExFreePool(), FALSE, FsRtlDoesDbcsContainWildCards(), FsRtlIsLeadDbcsCharacter, FsRtlpAllocatePool, GetDbcs, MATCHES_ARRAY_SIZE, Name, NlsMbOemCodePageTag, NULL, Offset, PAGED_CODE, PagedPool, TRUE, and USHORT. 00778 : 00779 00780 This routine compares a Dbcs name and an expression and tells the caller 00781 if the name is in the language defined by the expression. The input name 00782 cannot contain wildcards, while the expression may contain wildcards. 00783 00784 Expression wild cards are evaluated as shown in the nondeterministic 00785 finite automatons below. Note that ~* and ~? are DOS_STAR and DOS_QM. 00786 00787 00788 ~* is DOS_STAR, ~? is DOS_QM, and ~. is DOS_DOT 00789 00790 00791 S 00792 <-----< 00793 X | | e Y 00794 X * Y == (0)----->-(1)->-----(2)-----(3) 00795 00796 00797 S-. 00798 <-----< 00799 X | | e Y 00800 X ~* Y == (0)----->-(1)->-----(2)-----(3) 00801 00802 00803 00804 X S S Y 00805 X ?? Y == (0)---(1)---(2)---(3)---(4) 00806 00807 00808 00809 X . . Y 00810 X ~.~. Y == (0)---(1)----(2)------(3)---(4) 00811 | |________| 00812 | ^ | 00813 |_______________| 00814 ^EOF or .^ 00815 00816 00817 X S-. S-. Y 00818 X ~?~? Y == (0)---(1)-----(2)-----(3)---(4) 00819 | |________| 00820 | ^ | 00821 |_______________| 00822 ^EOF or .^ 00823 00824 00825 00826 where S is any single character 00827 00828 S-. is any single character except the final . 00829 00830 e is a null character transition 00831 00832 EOF is the end of the name string 00833 00834 In words: 00835 00836 * matches 0 or more characters. 00837 00838 ? matches exactly 1 character. 00839 00840 DOS_STAR matches 0 or more characters until encountering and matching 00841 the final . in the name. 00842 00843 DOS_QM matches any single character, or upon encountering a period or 00844 end of name string, advances the expression to the end of the 00845 set of contiguous DOS_QMs. 00846 00847 DOS_DOT matches either a . or zero characters beyond name string. 00848 00849 Arguments: 00850 00851 Expression - Supplies the input expression to check against 00852 00853 Name - Supplies the input name to check for. 00854 00855 Return Value: 00856 00857 BOOLEAN - TRUE if Name is an element in the set of strings denoted 00858 by the input Expression and FALSE otherwise. 00859 00860 --*/ 00861 00862 { 00863 USHORT NameOffset; 00864 USHORT ExprOffset; 00865 USHORT Length; 00866 00867 ULONG SrcCount; 00868 ULONG DestCount; 00869 ULONG PreviousDestCount; 00870 ULONG MatchesCount; 00871 00872 WCHAR NameChar, ExprChar; 00873 00874 USHORT LocalBuffer[MATCHES_ARRAY_SIZE * 2]; 00875 00876 USHORT *AuxBuffer = NULL; 00877 USHORT *PreviousMatches; 00878 USHORT *CurrentMatches; 00879 00880 USHORT MaxState; 00881 USHORT CurrentState; 00882 00883 BOOLEAN NameFinished = FALSE; 00884 00885 // 00886 // The idea behind the algorithm is pretty simple. We keep track of 00887 // all possible locations in the regular expression that are matching 00888 // the name. If when the name has been exhausted one of the locations 00889 // in the expression is also just exhausted, the name is in the language 00890 // defined by the regular expression. 00891 // 00892 00893 PAGED_CODE(); 00894 00895 DebugTrace(+1, Dbg, "FsRtlIsDbcsInExpression\n", 0); 00896 DebugTrace( 0, Dbg, " Expression = %Z\n", Expression ); 00897 DebugTrace( 0, Dbg, " Name = %Z\n", Name ); 00898 00899 ASSERT( Name->Length != 0 ); 00900 ASSERT( Expression->Length != 0 ); 00901 00902 // 00903 // If one string is empty return FALSE. If both are empty return TRUE. 00904 // 00905 00906 if ( (Name->Length == 0) || (Expression->Length == 0) ) { 00907 00908 return (BOOLEAN)(!(Name->Length + Expression->Length)); 00909 } 00910  00911 // 00912 // Special case by far the most common wild card search of * 00913 // 00914 00915 if ((Expression->Length == 1) && (Expression->Buffer[0] == '*')) { 00916 00917 return TRUE; 00918 } 00919 00920 ASSERT( FsRtlDoesDbcsContainWildCards( Expression ) ); 00921 00922 // 00923 // Also special case expressions of the form *X. With this and the prior 00924 // case we have covered virtually all normal queries. 00925 // 00926 00927 if (Expression->Buffer[0] == '*') { 00928 00929 ANSI_STRING LocalExpression; 00930 00931 LocalExpression = *Expression; 00932 00933 LocalExpression.Buffer += 1; 00934 LocalExpression.Length -= 1; 00935 00936 // 00937 // Only special case an expression with a single * 00938 // 00939 00940 if ( !FsRtlDoesDbcsContainWildCards( &LocalExpression ) ) { 00941 00942 ULONG StartingNameOffset; 00943 00944 if (Name->Length < (USHORT)(Expression->Length - 1)) { 00945 00946 return FALSE; 00947 } 00948 00949 StartingNameOffset = Name->Length - LocalExpression.Length; 00950 00951 // 00952 // FsRtlIsDbcsInExpression(): bug fix "expression[0] == *" case 00953 // 00954 // StatingNameOffset must not bisect DBCS characters. 00955 // 00956 00957 if (NlsMbOemCodePageTag) { 00958 00959 ULONG i = 0; 00960 00961 while ( i < StartingNameOffset ) { 00962 00963 i += FsRtlIsLeadDbcsCharacter( Name->Buffer[i] ) ? 2 : 1; 00964 } 00965 00966 if ( i > StartingNameOffset ) { 00967 00968 return FALSE; 00969 } 00970 } 00971 00972 // 00973 // Do a simple memory compare if case sensitive, otherwise 00974 // we have got to check this one character at a time. 00975 // 00976 00977 return (BOOLEAN) RtlEqualMemory( LocalExpression.Buffer, 00978 Name->Buffer + StartingNameOffset, 00979 LocalExpression.Length ); 00980 } 00981 } 00982  00983 // 00984 // Walk through the name string, picking off characters. We go one 00985 // character beyond the end because some wild cards are able to match 00986 // zero characters beyond the end of the string. 00987 // 00988 // With each new name character we determine a new set of states that 00989 // match the name so far. We use two arrays that we swap back and forth 00990 // for this purpose. One array lists the possible expression states for 00991 // all name characters up to but not including the current one, and other 00992 // array is used to build up the list of states considering the current 00993 // name character as well. The arrays are then switched and the process 00994 // repeated. 00995 // 00996 // There is not a one-to-one correspondence between state number and 00997 // offset into the expression. This is evident from the NFAs in the 00998 // initial comment to this function. State numbering is not continuous. 00999 // This allows a simple conversion between state number and expression 01000 // offset. Each character in the expression can represent one or two 01001 // states. * and DOS_STAR generate two states: ExprOffset*2 and 01002 // ExprOffset*2 + 1. All other expreesion characters can produce only 01003 // a single state. Thus ExprOffset = State/2. 01004 // 01005 // 01006 // Here is a short description of the variables involved: 01007 // 01008 // NameOffset - The offset of the current name char being processed. 01009 // 01010 // ExprOffset - The offset of the current expression char being processed. 01011 // 01012 // SrcCount - Prior match being investigated with current name char 01013 // 01014 // DestCount - Next location to put a matching assuming current name char 01015 // 01016 // NameFinished - Allows one more itteration through the Matches array 01017 // after the name is exhusted (to come *s for example) 01018 // 01019 // PreviousDestCount - This is used to prevent entry duplication, see coment 01020 // 01021 // PreviousMatches - Holds the previous set of matches (the Src array) 01022 // 01023 // CurrentMatches - Holds the current set of matches (the Dest array) 01024 // 01025 // AuxBuffer, LocalBuffer - the storage for the Matches arrays 01026 // 01027 01028 // 01029 // Set up the initial variables 01030 // 01031 01032 PreviousMatches = &LocalBuffer[0]; 01033 CurrentMatches = &LocalBuffer[MATCHES_ARRAY_SIZE]; 01034 01035 PreviousMatches[0] = 0; 01036 MatchesCount = 1; 01037 01038 NameOffset = 0; 01039 01040 MaxState = (USHORT)(Expression->Length * 2); 01041 01042 while ( !NameFinished ) { 01043 01044 if ( NameOffset < Name->Length ) { 01045 01046 GetDbcs( Name->Buffer, NameOffset, &NameChar, &Length ); 01047 NameOffset += Length; 01048 01049 } else { 01050 01051 NameFinished = TRUE; 01052 01053 // 01054 // if we have already exhasted the expression, cool. Don't 01055 // continue. 01056 // 01057 01058 if ( PreviousMatches[MatchesCount-1] == MaxState ) { 01059 01060 break; 01061 } 01062 } 01063 01064 01065 // 01066 // Now, for each of the previous stored expression matches, see what 01067 // we can do with this name character. 01068 // 01069 01070 SrcCount = 0; 01071 DestCount = 0; 01072 PreviousDestCount = 0; 01073 01074 while ( SrcCount < MatchesCount ) { 01075 01076 // 01077 // We have to carry on our expression analysis as far as possible 01078 // for each character of name, so we loop here until the 01079 // expression stops matching. A clue here is that expression 01080 // cases that can match zero or more characters end with a 01081 // continue, while those that can accept only a single character 01082 // end with a break. 01083 // 01084 01085 ExprOffset = (USHORT)((PreviousMatches[SrcCount++] + 1) / 2); 01086 01087 Length = 0; 01088 01089 01090 while ( TRUE ) { 01091 01092 if ( ExprOffset == Expression->Length ) { 01093 01094 break; 01095 } 01096 01097 // 01098 // The first time through the loop we don't want 01099 // to increment ExprOffset. 01100 // 01101 01102 ExprOffset += Length; 01103 01104 CurrentState = (USHORT)(ExprOffset * 2); 01105 01106 if ( ExprOffset == Expression->Length ) { 01107 01108 CurrentMatches[DestCount++] = MaxState; 01109 break; 01110 } 01111 01112 GetDbcs(Expression->Buffer, ExprOffset, &ExprChar, &Length); 01113 01114 ASSERT( !((ExprChar >= 'a') && (ExprChar <= 'z')) ); 01115 01116 // 01117 // Before we get started, we have to check for something 01118 // really gross. We may be about to exhaust the local 01119 // space for ExpressionMatches[][], so we have to allocate 01120 // some pool if this is the case. Yuk! 01121 // 01122 01123 if ( (DestCount >= MATCHES_ARRAY_SIZE - 2) && 01124 (AuxBuffer == NULL) ) { 01125 01126 AuxBuffer = FsRtlpAllocatePool( PagedPool, 01127 (Expression->Length+1) * 01128 sizeof(USHORT)*2*2 ); 01129 01130 RtlCopyMemory( AuxBuffer, 01131 CurrentMatches, 01132 MATCHES_ARRAY_SIZE * sizeof(USHORT) ); 01133 01134 CurrentMatches = AuxBuffer; 01135 01136 RtlCopyMemory( AuxBuffer + (Expression->Length+1)*2, 01137 PreviousMatches, 01138 MATCHES_ARRAY_SIZE * sizeof(USHORT) ); 01139 01140 PreviousMatches = AuxBuffer + (Expression->Length+1)*2; 01141 01142 } 01143 01144 // 01145 // * matches any character zero or more times. 01146 // 01147 01148 if (ExprChar == '*') { 01149 01150 CurrentMatches[DestCount++] = CurrentState; 01151 CurrentMatches[DestCount++] = CurrentState + 1; 01152 continue; 01153 } 01154 01155 // 01156 // DOS_STAR matches any character except . zero or more times. 01157 // 01158 01159 if (ExprChar == ANSI_DOS_STAR) { 01160 01161 BOOLEAN ICanEatADot = FALSE; 01162 01163 // 01164 // If we are at a period, determine if we are allowed to 01165 // consume it, ie. make sure it is not the last one. 01166 // 01167 01168 if ( !NameFinished && (NameChar == '.') ) { 01169 01170 WCHAR NameChar; 01171 USHORT Offset; 01172 USHORT Length; 01173 01174 for ( Offset = NameOffset; 01175 Offset < Name->Length; 01176 Offset += Length ) { 01177 01178 GetDbcs( Name->Buffer, Offset, &NameChar, &Length ); 01179 01180 if (NameChar == '.') { 01181 01182 ICanEatADot = TRUE; 01183 break; 01184 } 01185 } 01186 } 01187 01188 if (NameFinished || (NameChar != '.') || ICanEatADot) { 01189 01190 CurrentMatches[DestCount++] = CurrentState; 01191 CurrentMatches[DestCount++] = CurrentState + 1; 01192 continue; 01193 01194 } else { 01195 01196 // 01197 // We are at a period. We can only match zero 01198 // characters (ie. the epsilon transition). 01199 // 01200 01201 CurrentMatches[DestCount++] = CurrentState + 1; 01202 continue; 01203 } 01204 } 01205 01206 // 01207 // The following expreesion characters all match by consuming 01208 // a character, thus force the expression, and thus state 01209 // forward. 01210 // 01211 01212 CurrentState += (USHORT)(Length * 2); 01213 01214 // 01215 // DOS_QM is the most complicated. If the name is finished, 01216 // we can match zero characters. If this name is a '.', we 01217 // don't match, but look at the next expression. Otherwise 01218 // we match a single character. 01219 // 01220 01221 if ( ExprChar == ANSI_DOS_QM ) { 01222 01223 if ( NameFinished || (NameChar == '.') ) { 01224 01225 continue; 01226 } 01227 01228 CurrentMatches[DestCount++] = CurrentState; 01229 break; 01230 } 01231 01232 // 01233 // A DOS_DOT can match either a period, or zero characters 01234 // beyond the end of name. 01235 // 01236 01237 if (ExprChar == DOS_DOT) { 01238 01239 if ( NameFinished ) { 01240 01241 continue; 01242 } 01243 01244 if (NameChar == '.') { 01245 01246 CurrentMatches[DestCount++] = CurrentState; 01247 break; 01248 } 01249 } 01250 01251 // 01252 // From this point on a name character is required to even 01253 // continue, let alone make a match. 01254 // 01255 01256 if ( NameFinished ) { 01257 01258 break; 01259 } 01260 01261 // 01262 // If this expression was a '?' we can match it once. 01263 // 01264 01265 if (ExprChar == '?') { 01266 01267 CurrentMatches[DestCount++] = CurrentState; 01268 break; 01269 } 01270 01271 // 01272 // Finally, check if the expression char matches the name char 01273 // 01274 01275 if (ExprChar == NameChar) { 01276 01277 CurrentMatches[DestCount++] = CurrentState; 01278 break; 01279 } 01280 01281 // 01282 // The expression didn't match so go look at the next 01283 // previous match. 01284 // 01285 01286 break; 01287 } 01288 01289 01290 // 01291 // Prevent duplication in the destination array. 01292 // 01293 // Each of the arrays is montonically increasing and non- 01294 // duplicating, thus we skip over any source element in the src 01295 // array if we just added the same element to the destination 01296 // array. This guarentees non-duplication in the dest. array. 01297 // 01298 01299 if ((SrcCount < MatchesCount) && 01300 (PreviousDestCount < DestCount) ) { 01301 01302 while (PreviousDestCount < DestCount) { 01303 01304 while ( PreviousMatches[SrcCount] < 01305 CurrentMatches[PreviousDestCount] ) { 01306 01307 01308 SrcCount += 1; 01309 } 01310 01311 PreviousDestCount += 1; 01312 } 01313 } 01314 } 01315 01316 // 01317 // If we found no matches in the just finished itteration, it's time 01318 // to bail. 01319 // 01320 01321 if ( DestCount == 0 ) { 01322 01323 01324 if (AuxBuffer != NULL) { ExFreePool( AuxBuffer ); } 01325 01326 return FALSE; 01327 } 01328 01329 // 01330 // Swap the meaning the two arrays 01331 // 01332 01333 { 01334 USHORT *Tmp; 01335 01336 Tmp = PreviousMatches; 01337 01338 PreviousMatches = CurrentMatches; 01339 01340 CurrentMatches = Tmp; 01341 } 01342 01343 MatchesCount = DestCount; 01344 } 01345 01346 01347 CurrentState = PreviousMatches[MatchesCount-1]; 01348 01349 if (AuxBuffer != NULL) { ExFreePool( AuxBuffer ); } 01350 01351 01352 return (BOOLEAN)(CurrentState == MaxState); 01353 } }

NTKERNELAPI BOOLEAN FsRtlIsFatDbcsLegal (  IN ANSI_STRING  DbcsName, IN BOOLEAN  WildCardsPermissible, IN BOOLEAN  PathNamePermissible, IN BOOLEAN  LeadingBackslashPermissible )

Definition at line 81 of file dbcsname.c. References ASSERT, FALSE, FsRtlDissectDbcs(), FsRtlDoesDbcsContainWildCards(), FsRtlIsAnsiCharacterLegalFat, FsRtlIsLeadDbcsCharacter, Index, PAGED_CODE, and TRUE. Referenced by UdfIs8dot3Name(). 00090 : 00091 00092 This routine simple returns whether the specified file names conforms 00093 to the file system specific rules for legal file names. This routine 00094 will check the single name, or if PathNamePermissible is specified as 00095 TRUE, whether the whole path is a legal name. 00096 00097 For FAT, the following rules apply: 00098 00099 A. A Fat file name may not contain any of the following characters: 00100 00101 0x00-0x1F " / : | + , ; = [ ] 00102 00103 B. A Fat file name is either of the form N.E or just N, where N is a 00104 string of 1-8 bytes and E is a string of 1-3 bytes conformant to 00105 rule A above. In addition, neither N nor E may contain a period 00106 character or end with a space character. 00107 00108 Incidently, N corresponds to name and E to extension. 00109 00110 Case: Lower case characters are taken as valid, but are up-shifted upon 00111 receipt, ie. Fat only deals with upper case file names. 00112 00113 For example, the files ".foo", "foo.", and "foo .b" are illegal, while 00114 "foo. b" and " bar" are legal. 00115 00116 Arguments: 00117 00118 DbcsName - Supllies the name/path to check. 00119 00120 WildCardsPermissible - Specifies if Nt wild card characters are to be 00121 considered considered legal. 00122 00123 PathNamePermissible - Spcifes if Name may be a path name separated by 00124 backslash characters, or just a simple file name. 00125 00126 LeadingBackSlashPermissible - Specifies if a single leading backslash 00127 is permissible in the file/path name. 00128 00129 Return Value: 00130 00131 BOOLEAN - TRUE if the name is legal, FALSE otherwise. 00132 00133 --*/ 00134 { 00135 BOOLEAN ExtensionPresent = FALSE; 00136 00137 ULONG Index; 00138 00139 UCHAR Char; 00140 00141 PAGED_CODE(); 00142 00143 // 00144 // Empty names are not valid. 00145 // 00146 00147 if ( DbcsName.Length == 0 ) { return FALSE; } 00148 00149 // 00150 // If Wild Cards are OK, then for directory enumeration to work 00151 // correctly we have to accept . and .. 00152 // 00153 00154 if ( WildCardsPermissible && 00155 ( ( (DbcsName.Length == 1) && 00156 ((DbcsName.Buffer[0] == '.') || 00157 (DbcsName.Buffer[0] == ANSI_DOS_DOT)) ) 00158 || 00159 ( (DbcsName.Length == 2) && 00160 ( ((DbcsName.Buffer[0] == '.') && 00161 (DbcsName.Buffer[1] == '.')) || 00162 ((DbcsName.Buffer[0] == ANSI_DOS_DOT) && 00163 (DbcsName.Buffer[1] == ANSI_DOS_DOT)) ) ) ) ) { 00164 00165 return TRUE; 00166 } 00167 00168 // 00169 // If a leading \ is OK, skip over it (if there's more) 00170 // 00171 00172 if ( DbcsName.Buffer[0] == '\\' ) { 00173 00174 if ( LeadingBackslashPermissible ) { 00175 00176 if ( (DbcsName.Length > 1) ) { 00177 00178 DbcsName.Buffer += 1; 00179 DbcsName.Length -= 1; 00180 00181 } else { return TRUE; } 00182 00183 } else { return FALSE; } 00184 } 00185 00186 // 00187 // If we got a path name, check each componant. 00188 // 00189 00190 if ( PathNamePermissible ) { 00191 00192 ANSI_STRING FirstName; 00193 ANSI_STRING RemainingName; 00194 00195 RemainingName = DbcsName; 00196 00197 while ( RemainingName.Length != 0 ) { 00198 00199 // 00200 // This will catch the case of an illegal double backslash. 00201 // 00202 00203 if ( RemainingName.Buffer[0] == '\\' ) { return FALSE; } 00204 00205 FsRtlDissectDbcs(RemainingName, &FirstName, &RemainingName); 00206 00207 if ( !FsRtlIsFatDbcsLegal( FirstName, 00208 WildCardsPermissible, 00209 FALSE, 00210 FALSE) ) { 00211 00212 return FALSE; 00213 } 00214 } 00215 00216 // 00217 // All the componants were OK, so the path is OK. 00218 // 00219 00220 return TRUE; 00221 } 00222 00223 // 00224 // If this name contains wild cards, just check for invalid characters. 00225 // 00226 00227 if ( WildCardsPermissible && FsRtlDoesDbcsContainWildCards(&DbcsName) ) { 00228 00229 for ( Index = 0; Index < DbcsName.Length; Index += 1 ) { 00230 00231 Char = DbcsName.Buffer[ Index ]; 00232 00233 // 00234 // Skip over any Dbcs chacters 00235 // 00236 00237 if ( FsRtlIsLeadDbcsCharacter( Char ) ) { 00238 00239 ASSERT( Index != (ULONG)(DbcsName.Length - 1) ); 00240 Index += 1; 00241 continue; 00242 } 00243 00244 // 00245 // Make sure this character is legal, and if a wild card, that 00246 // wild cards are permissible. 00247 // 00248 00249 if ( !FsRtlIsAnsiCharacterLegalFat(Char, WildCardsPermissible) ) { 00250 return FALSE; 00251 } 00252 } 00253 00254 return TRUE; 00255 } 00256 00257 00258 // 00259 // At this point we should only have a single name, which can't have 00260 // more than 12 characters (including a single period) 00261 // 00262 00263 if ( DbcsName.Length > 12 ) { return FALSE; } 00264 00265 for ( Index = 0; Index < DbcsName.Length; Index += 1 ) { 00266 00267 Char = DbcsName.Buffer[ Index ]; 00268 00269 // 00270 // Skip over and Dbcs chacters 00271 // 00272 00273 if ( FsRtlIsLeadDbcsCharacter( Char ) ) { 00274 00275 // 00276 // FsRtlIsFatDbcsLegal(): fat name part and extension part dbcs check 00277 // 00278 // 1) if we're looking at base part ( !ExtensionPresent ) and the 8th byte 00279 // is in the dbcs leading byte range, it's error ( Index == 7 ). If the 00280 // length of base part is more than 8 ( Index > 7 ), it's definitely error. 00281 // 00282 // 2) if the last byte ( Index == DbcsName.Length - 1 ) is in the dbcs leading 00283 // byte range, it's error 00284 // 00285 00286 if ( (!ExtensionPresent && (Index >= 7)) || 00287 ( Index == (ULONG)(DbcsName.Length - 1) ) ) { 00288 return FALSE; 00289 } 00290 00291 Index += 1; 00292 00293 continue; 00294 } 00295 00296 // 00297 // Make sure this character is legal, and if a wild card, that 00298 // wild cards are permissible. 00299 // 00300 00301 if ( !FsRtlIsAnsiCharacterLegalFat(Char, WildCardsPermissible) ) { 00302 00303 return FALSE; 00304 } 00305 00306 if ( (Char == '.') || (Char == ANSI_DOS_DOT) ) { 00307 00308 // 00309 // We stepped onto a period. We require the following things: 00310 // 00311 // - It can't be the first character 00312 // - There can only be one 00313 // - There can't be more than three characters following 00314 // - The previous character can't be a space. 00315 // 00316 00317 if ( (Index == 0) || 00318 ExtensionPresent || 00319 (DbcsName.Length - (Index + 1) > 3) || 00320 (DbcsName.Buffer[Index - 1] == ' ') ) { 00321 00322 return FALSE; 00323 } 00324 00325 ExtensionPresent = TRUE; 00326 } 00327 00328 // 00329 // The base part of the name can't be more than 8 characters long. 00330 // 00331 00332 if ( (Index >= 8) && !ExtensionPresent ) { return FALSE; } 00333 } 00334 00335 // 00336 // The name cannot end in a space or a period. 00337 // 00338 00339 if ( (Char == ' ') || (Char == '.') || (Char == ANSI_DOS_DOT)) { return FALSE; } 00340 00341 return TRUE; 00342 }

NTKERNELAPI BOOLEAN FsRtlIsHpfsDbcsLegal (  IN ANSI_STRING  DbcsName, IN BOOLEAN  WildCardsPermissible, IN BOOLEAN  PathNamePermissible, IN BOOLEAN  LeadingBackslashPermissible )

Definition at line 345 of file dbcsname.c. References FALSE, FsRtlDissectDbcs(), FsRtlIsAnsiCharacterLegalHpfs, FsRtlIsLeadDbcsCharacter, Index, PAGED_CODE, and TRUE. : This routine simple returns whether the specified file names conforms to the file system specific rules for legal file names. This routine will check the single name, or if PathNamePermissible is specified as TRUE, whether the whole path is a legal name. For HPFS, the following rules apply: A. An HPFS file name may not contain any of the following characters: 0x0000 - 0x001F " / : < > ? | * B. An HPFS file name may not end in a period or a space. C. An HPFS file name must contain no more than 255 bytes. Case: HPFS is case preserving, but not case sensitive. Case is preserved on creates, but not checked for on file name compares. For example, the files "foo " and "foo." are illegal, while ".foo", " foo" and "foo.bar.foo" are legal. Arguments: DbcsName - Supllies the name/path to check. WildCardsPermissible - Specifies if Nt wild card characters are to be considered considered legal. PathNamePermissible - Spcifes if Name may be a path name separated by backslash characters, or just a simple file name. LeadingBackSlashPermissible - Specifies if a single leading backslash is permissible in the file/path name. Return Value: BOOLEAN - TRUE if the name is legal, FALSE otherwise. --*/ { BOOLEAN ExtensionPresent = FALSE; ULONG Index; UCHAR Char; PAGED_CODE(); // // Empty names are not valid. // if ( DbcsName.Length == 0 ) { return FALSE; } // // If Wild Cards are OK, then for directory enumeration to work // correctly we have to accept . and .. // if ( WildCardsPermissible && ( ( (DbcsName.Length == 1) && ((DbcsName.Buffer[0] == '.') || (DbcsName.Buffer[0] == ANSI_DOS_DOT)) ) || ( (DbcsName.Length == 2) && ( ((DbcsName.Buffer[0] == '.') && (DbcsName.Buffer[1] == '.')) || ((DbcsName.Buffer[0] == ANSI_DOS_DOT) && (DbcsName.Buffer[1] == ANSI_DOS_DOT)) ) ) ) ) { return TRUE; } // // If a leading \ is OK, skip over it (if there's more) // if ( DbcsName.Buffer[0] == '\\' ) { if ( LeadingBackslashPermissible ) { if ( (DbcsName.Length > 1) ) { DbcsName.Buffer += 1; DbcsName.Length -= 1; } else { return TRUE; } } else { return FALSE; } } // // If we got a path name, check each componant. // if ( PathNamePermissible ) { ANSI_STRING FirstName; ANSI_STRING RemainingName; RemainingName = DbcsName; while ( RemainingName.Length != 0 ) { // // This will catch the case of an illegal double backslash. // if ( RemainingName.Buffer[0] == '\\' ) { return FALSE; } FsRtlDissectDbcs(RemainingName, &FirstName, &RemainingName); if ( !FsRtlIsHpfsDbcsLegal( FirstName, WildCardsPermissible, FALSE, FALSE) ) { return FALSE; } } // // All the componants were OK, so the path is OK. // return TRUE; } // // At this point we should only have a single name, which can't have // more than 255 characters // if ( DbcsName.Length > 255 ) { return FALSE; } for ( Index = 0; Index < DbcsName.Length; Index += 1 ) { Char = DbcsName.Buffer[ Index ]; // // Skip over and Dbcs chacters // if ( FsRtlIsLeadDbcsCharacter( Char ) ) { // // FsRtlIsHpfsDbcsLegal () hpfs dbcs check // // If the last byte ( Index == DbcsName.Length - 1 ) is in the // dbcs leading byte range, it's error. // if ( Index == (ULONG)(DbcsName.Length - 1) ) { return FALSE; } Index += 1; continue; } // // Make sure this character is legal, and if a wild card, that // wild cards are permissible. // if ( !FsRtlIsAnsiCharacterLegalHpfs(Char, WildCardsPermissible) ) { return FALSE; } } // // The name cannot end in a space or a period. // if ( (Char == ' ') || (Char == '.') || (Char == ANSI_DOS_DOT) ) { return FALSE; } return TRUE; }

NTKERNELAPI BOOLEAN FsRtlIsNameInExpression (  IN PUNICODE_STRING  Expression, IN PUNICODE_STRING  Name, IN BOOLEAN  IgnoreCase, IN PWCH UpcaseTable  OPTIONAL )

Definition at line 415 of file name.c. References ExRaiseStatus(), FALSE, FsRtlIsNameInExpressionPrivate(), Name, NT_SUCCESS, NTSTATUS(), NULL, RtlFreeUnicodeString(), RtlUpcaseUnicodeString(), Status, and TRUE. Referenced by UdfIsNameInExpression(). { BOOLEAN Result; UNICODE_STRING LocalName; // // If we weren't given an upcase table, we have to upcase the names // ourselves. // if ( IgnoreCase && !ARGUMENT_PRESENT(UpcaseTable) ) { NTSTATUS Status; Status = RtlUpcaseUnicodeString( &LocalName, Name, TRUE ); if ( !NT_SUCCESS(Status) ) { ExRaiseStatus( Status ); } Name = &LocalName; IgnoreCase = FALSE; } else { LocalName.Buffer = NULL; } // // Now call the main routine, remembering to free the upcased string // if we allocated one. // try { Result = FsRtlIsNameInExpressionPrivate( Expression, Name, IgnoreCase, UpcaseTable ); } finally { if (LocalName.Buffer != NULL) { RtlFreeUnicodeString( &LocalName ); } } return Result; }

NTKERNELAPI BOOLEAN FsRtlIsNtstatusExpected (  IN NTSTATUS  Exception  )

Definition at line 82 of file fsrtl/filter.c. References FALSE, and TRUE. Referenced by CcExceptionFilter(), FsRtlCancelNotify(), FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), FsRtlNormalizeNtstatus(), FsRtlNotifyFullReportChange(), FsRtlPrepareMdlWriteDev(), LfsExceptionFilter(), UdfCreateUserMdl(), UdfExceptionFilter(), and UdfQueryDirectory(). : This routine is used to decide if a status is within the set of values handled by the exception filter. Arguments: Exception - Supplies the exception being queried Return Value: BOOLEAN - Returns TRUE if the value is handled by the filter, and FALSE otherwise. --*/ { switch (Exception) { case STATUS_DATATYPE_MISALIGNMENT: case STATUS_ACCESS_VIOLATION: case STATUS_ILLEGAL_INSTRUCTION: case STATUS_INSTRUCTION_MISALIGNMENT: return FALSE; default: return TRUE; } }

NTKERNELAPI BOOLEAN FsRtlIsTotalDeviceFailure (  IN NTSTATUS  Status  )

Definition at line 304 of file fsrtl/filter.c. References FALSE, NT_SUCCESS, Status, and TRUE. Referenced by IopMountVolume(). 00310 : 00311 00312 This routine is given an NTSTATUS value and make a determination as to 00313 if this value indicates that the complete device has failed and therefore 00314 should no longer be used, or if the failure is one that indicates that 00315 continued use of the device is ok (i.e. a sector failure). 00316 00317 Arguments: 00318 00319 Status - the NTSTATUS value to test. 00320 00321 Return Value: 00322 00323 TRUE - The status value given is believed to be a fatal device error. 00324 FALSE - The status value given is believed to be a sector failure, but not 00325 a complete device failure. 00326 --*/ 00327 00328 { 00329 if (NT_SUCCESS(Status)) { 00330 00331 // 00332 // All warning and informational errors will be resolved here. 00333 // 00334 00335 return FALSE; 00336 } 00337 00338 switch (Status) { 00339 case STATUS_CRC_ERROR: 00340 case STATUS_DEVICE_DATA_ERROR: 00341 return FALSE; 00342 default: 00343 return TRUE; 00344 } 00345 } }

NTKERNELAPI PFSRTL_FILTER_CONTEXT FsRtlLookupFilterContextInternal (  IN PFILE_OBJECT  FileObject, IN PVOID OwnerId  OPTIONAL, IN PVOID InstanceId  OPTIONAL )

Definition at line 108 of file filtrctx.c. References ASSERT, FSRTL_FILTER_CONTEXT, FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS, Header, _FSRTL_FILTER_CONTEXT::InstanceId, List, MySearchList, NULL, and _FSRTL_FILTER_CONTEXT::OwnerId. : This routine lookups filter driver context associated with a stream. The macro FsRtlLookupFilterContext should be used instead of calling this routine directly. The macro optimizes for the common case of an empty list. Arguments: FileObject - Specifies the stream of interest. OwnerId - Used to identify context information belonging to a particular filter driver. InstanceId - Used to search for a particular instance of a filter driver context. If not provided, any of the contexts owned by the filter driver is returned. If neither the OwnerId nor the InstanceId is provided, any associated filter context will be returned. Return Value: A pointer to the filter context, or NULL if no match found. --*/ { PFSRTL_COMMON_FCB_HEADER Header; PFSRTL_FILTER_CONTEXT Ctx, RtnCtx; PLIST_ENTRY List; ASSERT(FileObject); ASSERT(FileObject->FsContext); Header = FileObject->FsContext; ASSERT (Header->Flags2 & FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS); ExAcquireFastMutex (Header->FastMutex); RtnCtx = NULL; // Use different loops depending on whether we are comparing both Ids or not. if ( ARGUMENT_PRESENT(InstanceId) ) { MySearchList (&Header->FilterContexts, List) { Ctx = CONTAINING_RECORD (List, FSRTL_FILTER_CONTEXT, Links); if (Ctx->OwnerId == OwnerId && Ctx->InstanceId == InstanceId) { RtnCtx = Ctx; break; } } } else if ( ARGUMENT_PRESENT(OwnerId) ) { MySearchList (&Header->FilterContexts, List) { Ctx = CONTAINING_RECORD (List, FSRTL_FILTER_CONTEXT, Links); if (Ctx->OwnerId == OwnerId) { RtnCtx = Ctx; break; } } } else if (!IsListEmpty(&Header->FilterContexts)) { RtnCtx = (PFSRTL_FILTER_CONTEXT) Header->FilterContexts.Flink; } ExReleaseFastMutex(Header->FastMutex); return RtnCtx; }

NTKERNELAPI BOOLEAN FsRtlLookupLargeMcbEntry (  IN PLARGE_MCB  Mcb, IN LONGLONG  Vbn, OUT PLONGLONG Lbn  OPTIONAL, OUT PLONGLONG SectorCountFromLbn  OPTIONAL, OUT PLONGLONG StartingLbn  OPTIONAL, OUT PLONGLONG SectorCountFromStartingLbn  OPTIONAL, OUT PULONG Index  OPTIONAL )

Referenced by FsRtlLookupMcbEntry(), UdfDvdReadStructure(), UdfDvdTransferKey(), UdfLookupAllocation(), UdfReadSectors(), and UdfVmcbLookupMcbEntry().

NTKERNELAPI BOOLEAN FsRtlLookupLastLargeMcbEntry (  IN PLARGE_MCB  Mcb, OUT PLONGLONG  Vbn, OUT PLONGLONG  Lbn )

Definition at line 1763 of file largemcb.c. References Dbg, DebugTrace, EndingLbn, EndingVbn, FALSE, _NONOPAQUE_MCB::FastMutex, PAGED_CODE, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, TRUE, try_return, and UNUSED_LBN. Referenced by FsRtlLookupLastMcbEntry(). : This routine retrieves the last Vbn to Lbn mapping stored in the Mcb. It returns the mapping for the last sector or the last run in the Mcb. The results of this function is useful when extending an existing file and needing to a hint on where to try and allocate sectors on the disk. Arguments: OpaqueMcb - Supplies the Mcb being examined. Vbn - Receives the last Vbn value mapped. Lbn - Receives the Lbn corresponding to the Vbn. Return Value: BOOLEAN - TRUE if there is a mapping within the Mcb and FALSE otherwise (i.e., the Mcb does not contain any mapping). --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; BOOLEAN Result; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlLookupLastLargeMcbEntry, Mcb = %08lx\n", Mcb ); ExAcquireFastMutex( Mcb->FastMutex ); try { // // Check to make sure there is at least one run in the mcb // if (Mcb->PairCount <= 0) { try_return (Result = FALSE); } // // Return the last mapping of the last run // *((PULONG)LargeLbn) = EndingLbn(Mcb,Mcb->PairCount-1); *((PULONG)LargeVbn) = EndingVbn(Mcb,Mcb->PairCount-1); Result = TRUE; try_exit: NOTHING; } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlLookupLastLargeMcbEntry -> %08lx\n", Result ); } ((PLARGE_INTEGER)LargeVbn)->HighPart = (*((PULONG)LargeVbn) == UNUSED_LBN ? UNUSED_LBN : 0); ((PLARGE_INTEGER)LargeLbn)->HighPart = (*((PULONG)LargeLbn) == UNUSED_LBN ? UNUSED_LBN : 0); return Result; }

NTKERNELAPI BOOLEAN FsRtlLookupLastLargeMcbEntryAndIndex (  IN PLARGE_MCB  OpaqueMcb, OUT PLONGLONG  LargeVbn, OUT PLONGLONG  LargeLbn, OUT PULONG  Index )

Definition at line 1841 of file largemcb.c. References Dbg, DebugTrace, EndingLbn, EndingVbn, FALSE, _NONOPAQUE_MCB::FastMutex, Index, PAGED_CODE, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, TRUE, try_return, and UNUSED_LBN. : This routine retrieves the last Vbn to Lbn mapping stored in the Mcb. It returns the mapping for the last sector or the last run in the Mcb. The results of this function is useful when extending an existing file and needing to a hint on where to try and allocate sectors on the disk. Arguments: OpaqueMcb - Supplies the Mcb being examined. Vbn - Receives the last Vbn value mapped. Lbn - Receives the Lbn corresponding to the Vbn. Index - Receives the index of the last run. Return Value: BOOLEAN - TRUE if there is a mapping within the Mcb and FALSE otherwise (i.e., the Mcb does not contain any mapping). --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; BOOLEAN Result; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlLookupLastLargeMcbEntryAndIndex, Mcb = %08lx\n", Mcb ); ExAcquireFastMutex( Mcb->FastMutex ); try { // // Check to make sure there is at least one run in the mcb // if (Mcb->PairCount <= 0) { try_return (Result = FALSE); } // // Return the last mapping of the last run // *((PULONG)LargeLbn) = EndingLbn(Mcb,Mcb->PairCount-1); *((PULONG)LargeVbn) = EndingVbn(Mcb,Mcb->PairCount-1); *Index = Mcb->PairCount - 1; Result = TRUE; try_exit: NOTHING; } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlLookupLastLargeMcbEntryAndIndex -> %08lx\n", Result ); } ((PLARGE_INTEGER)LargeVbn)->HighPart = (*((PULONG)LargeVbn) == UNUSED_LBN ? UNUSED_LBN : 0); ((PLARGE_INTEGER)LargeLbn)->HighPart = (*((PULONG)LargeLbn) == UNUSED_LBN ? UNUSED_LBN : 0); return Result; }

NTKERNELAPI BOOLEAN FsRtlLookupLastMcbEntry (  IN PMCB  Mcb, OUT PVBN  Vbn, OUT PLBN  Lbn )

Definition at line 455 of file largemcb.c. References FsRtlLookupLastLargeMcbEntry(), and PAGED_CODE. Referenced by UdfAddVmcbMapping(). { BOOLEAN Results; LONGLONG LiVbn; LONGLONG LiLbn; PAGED_CODE(); Results = FsRtlLookupLastLargeMcbEntry( (PLARGE_MCB)Mcb, &LiVbn, &LiLbn ); *Vbn = ((ULONG)LiVbn); *Lbn = (((ULONG)LiLbn) == -1 ? 0 : ((ULONG)LiLbn)); return Results; }

NTKERNELAPI BOOLEAN FsRtlLookupMcbEntry (  IN PMCB  Mcb, IN VBN  Vbn, OUT PLBN  Lbn, OUT PULONG SectorCount  OPTIONAL, OUT PULONG  Index )

Definition at line 426 of file largemcb.c. References FsRtlLookupLargeMcbEntry(), Index, and NULL. { BOOLEAN Results; LONGLONG LiLbn; LONGLONG LiSectorCount; Results = FsRtlLookupLargeMcbEntry( (PLARGE_MCB)Mcb, (LONGLONG)(Vbn), &LiLbn, ARGUMENT_PRESENT(SectorCount) ? &LiSectorCount : NULL, NULL, NULL, Index ); *Lbn = (((ULONG)LiLbn) == -1 ? 0 : ((ULONG)LiLbn)); if (ARGUMENT_PRESENT(SectorCount)) { *SectorCount = ((ULONG)LiSectorCount); } return Results; }

NTKERNELAPI BOOLEAN FsRtlMdlRead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  LockKey, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 1277 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, FAST_IO_DISPATCH, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlReadDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlRead, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlRead)) && (FastIoDispatch->MdlRead != NULL)) { return FastIoDispatch->MdlRead( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlRead)) && (FastIoDispatch->MdlRead != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlReadDev( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } } }

BOOLEAN FsRtlMdlReadComplete (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain )

Definition at line 1367 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlReadCompleteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlReadComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlRead. Return Value: None --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlReadComplete)) && (FastIoDispatch->MdlReadComplete != NULL)) { return FastIoDispatch->MdlReadComplete( FileObject, MdlChain, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlReadComplete)) && (FastIoDispatch->MdlReadComplete != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlReadCompleteDev( FileObject, MdlChain, DeviceObject ); } } }

NTKERNELAPI BOOLEAN FsRtlMdlReadCompleteDev (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 1438 of file fastio.c. References CcMdlReadComplete2(), and TRUE. Referenced by FsRtlMdlReadComplete(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlRead. DeviceObject - Supplies the DeviceObject for the callee. Return Value: None --*/ { CcMdlReadComplete2( FileObject, MdlChain ); return TRUE; }

NTKERNELAPI BOOLEAN FsRtlMdlReadDev (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  LockKey, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 1064 of file fastio.c. References ASSERT, CcFastMdlReadNotPossible, CcFastMdlReadWait, CcMdlRead(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FO_FILE_FAST_IO_READ, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by FsRtlMdlRead(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. DeviceObject - Supplies DeviceObject for callee. Return Value: FALSE - if the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN Status = TRUE; LARGE_INTEGER BeyondLastByte; PAGED_CODE(); // // Special case a read of zero length // if (Length == 0) { IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = 0; return TRUE; } // // Overflows should've been handled by caller. // ASSERT(MAXLONGLONG - FileOffset->QuadPart >= (LONGLONG)Length); // // Get a real pointer to the common fcb header // BeyondLastByte.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); CcFastMdlReadWait += 1; // // Acquired shared on the common fcb header // (VOID)ExAcquireResourceShared( Header->Resource, TRUE ); // // Now that the File is acquired shared, we can safely test if it is // really cached and if we can do fast i/o and if not // then release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible)) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); CcFastMdlReadNotPossible += 1; return FALSE; } // // Check if fast I/O is questionable and if so then go ask the file system // the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch; ASSERT(!KeIsExecutingDpc()); FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; // // All file system then set "Is Questionable" had better support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is anything // other than GoForIt then we cannot take the fast I/O path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, TRUE, LockKey, TRUE, // read operation IoStatus, IoGetRelatedDeviceObject( FileObject ) )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); CcFastMdlReadNotPossible += 1; return FALSE; } } // // Check for read past file size. // if ( BeyondLastByte.QuadPart > Header->FileSize.QuadPart ) { if ( FileOffset->QuadPart >= Header->FileSize.QuadPart ) { IoStatus->Status = STATUS_END_OF_FILE; IoStatus->Information = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return TRUE; } Length = (ULONG)( Header->FileSize.QuadPart - FileOffset->QuadPart ); } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // mdl read fails, then return FALSE to our caller. // // // Also mark this as the top level "Irp" so that lower file system levels // will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { CcMdlRead( FileObject, FileOffset, Length, MdlChain, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; }

BOOLEAN FsRtlMdlWriteComplete (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN PMDL  MdlChain )

Definition at line 1950 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlWriteCompleteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlWriteComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine completes an Mdl write. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlPrepareMdlWrite. Return Value: --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlWriteComplete != NULL)) { return FastIoDispatch->MdlWriteComplete( FileObject, FileOffset, MdlChain, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlWriteComplete != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlWriteCompleteDev( FileObject, FileOffset, MdlChain, DeviceObject ); } } }

NTKERNELAPI BOOLEAN FsRtlMdlWriteCompleteDev (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN PMDL  MdlChain, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 2020 of file fastio.c. References CcMdlWriteComplete2(), FALSE, FlagOn, FO_WRITE_THROUGH, and TRUE. Referenced by FsRtlMdlWriteComplete(). : This routine completes an Mdl write. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlPrepareMdlWrite. DeviceObject - Supplies the DeviceObject for the callee. Return Value: --*/ { // // Do not support WRITE_THROUGH in the fast path call. // if (FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { return FALSE; } CcMdlWriteComplete2( FileObject, FileOffset, MdlChain ); return TRUE; }

NTKERNELAPI NTSTATUS FsRtlNormalizeNtstatus (  IN NTSTATUS  Exception, IN NTSTATUS  GenericException )

Definition at line 49 of file fsrtl/filter.c. References FsRtlIsNtstatusExpected(). Referenced by CcCopyRead(), CcCopyWrite(), CcFastCopyRead(), CcFastCopyWrite(), CcGetVacbMiss(), CcInitializeCacheMap(), CcMapAndCopy(), CcMdlWriteComplete2(), CcSetFileSizes(), UdfCommonRead(), and UdfNormalizeAndRaiseStatus(). : This routine is used to normalize an NTSTATUS into a status that is handled by the file system's top level exception handlers. Arguments: Exception - Supplies the exception being normalized GenericException - Supplies a second exception to translate to if the first exception is not within the set of exceptions handled by the filter Return Value: NTSTATUS - Returns Exception if the value is already handled by the filter, and GenericException otherwise. --*/ { return (FsRtlIsNtstatusExpected(Exception) ? Exception : GenericException); }

NTKERNELAPI VOID FsRtlNotifyChangeDirectory (  IN PNOTIFY_SYNC  NotifySync, IN PVOID  FsContext, IN PSTRING  FullDirectoryName, IN PLIST_ENTRY  NotifyList, IN BOOLEAN  WatchTree, IN ULONG  CompletionFilter, IN PIRP  NotifyIrp )

Definition at line 469 of file notify.c. References Dbg, DebugTrace, FsRtlNotifyFullChangeDirectory(), NULL, PAGED_CODE, TRUE, and WatchTree. : This routine is called by a file system which has received a NotifyChange request. This routine checks if there is already a notify structure and inserts one if not present. With a notify structure in hand, we check whether we already have a pending notify and report it if so. If there is no pending notify, we check if this Irp has already been cancelled and completes it if so. Otherwise we add this to the list of Irps waiting for notification. Arguments: NotifySync - This is the controlling fast mutex for this notify list. It is stored here so that it can be found for an Irp which is being cancelled. FsContext - This is supplied by the file system so that this notify structure can be uniquely identified. FullDirectoryName - Points to the full name for the directory associated with this notify structure. NotifyList - This is the start of the notify list to add this structure to. WatchTree - This indicates whether all subdirectories for this directory should be watched, or just the directory itself. CompletionFilter - This provides the mask to determine which operations will trigger the notify operations. NotifyIrp - This is the Irp to complete on notify change. Return Value: None. --*/ { PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyChangeDirectory: Entered\n", 0 ); // // We will simply call the full notify routine to do the real work. // FsRtlNotifyFullChangeDirectory( NotifySync, NotifyList, FsContext, FullDirectoryName, WatchTree, TRUE, CompletionFilter, NotifyIrp, NULL, NULL ); DebugTrace( -1, Dbg, "FsRtlNotifyChangeDirectory: Exit\n", 0 ); return; }

NTKERNELAPI VOID FsRtlNotifyCleanup (  IN PNOTIFY_SYNC  NotifySync, IN PLIST_ENTRY  NotifyList, IN PVOID  FsContext )

Definition at line 1795 of file notify.c. References AcquireNotifySync, _NOTIFY_CHANGE::AllocatedBuffer, Dbg, DebugTrace, ExFreePool(), _NOTIFY_CHANGE::Flags, FsRtlIsNotifyOnList(), FsRtlNotifyCompleteIrpList(), _NOTIFY_CHANGE::FullDirectoryName, NOTIFY_CLEANUP_CALLED, _NOTIFY_CHANGE::NotifyIrps, _NOTIFY_CHANGE::NotifyList, NULL, _NOTIFY_CHANGE::OwningProcess, PAGED_CODE, PagedPool, PNOTIFY_CHANGE, PsReturnPoolQuota(), _NOTIFY_CHANGE::ReferenceCount, ReleaseNotifySync, SeReleaseSubjectContext(), SetFlag, _NOTIFY_CHANGE::SubjectContext, and _NOTIFY_CHANGE::ThisBufferLength. Referenced by UdfCommonCleanup(). : This routine is called for a cleanup of a user directory handle. We walk through our notify structures looking for a matching context field. We complete all the pending notify Irps for this Notify structure, remove the notify structure and deallocate it. Arguments: NotifySync - This is the controlling fast mutex for this notify list. It is stored here so that it can be found for an Irp which is being cancelled. NotifyList - This is the start of the notify list to add this structure to. FsContext - This is a unique value assigned by the file system to identify a particular notify structure. Return Value: None. --*/ { PNOTIFY_CHANGE Notify; PSECURITY_SUBJECT_CONTEXT SubjectContext = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyCleanup: Entered\n", 0 ); DebugTrace( 0, Dbg, "Mutex -> %08lx\n", Mutex ); DebugTrace( 0, Dbg, "Notify List -> %08lx\n", NotifyList ); DebugTrace( 0, Dbg, "FsContext -> %08lx\n", FsContext ); // // Acquire exclusive access to the list by acquiring the mutex. // AcquireNotifySync( NotifySync ); // // Use a try-finally to facilitate cleanup. // try { // // Search for a match on the list. // Notify = FsRtlIsNotifyOnList( NotifyList, FsContext ); // // If found, then complete all the Irps with STATUS_NOTIFY_CLEANUP // if (Notify != NULL) { // // Set the flag to indicate that we have been called with cleanup. // SetFlag( Notify->Flags, NOTIFY_CLEANUP_CALLED ); if (!IsListEmpty( &Notify->NotifyIrps )) { FsRtlNotifyCompleteIrpList( Notify, STATUS_NOTIFY_CLEANUP ); } RemoveEntryList( &Notify->NotifyList ); InterlockedDecrement( &Notify->ReferenceCount ); if (Notify->ReferenceCount == 0) { if (Notify->AllocatedBuffer != NULL) { PsReturnPoolQuota( Notify->OwningProcess, PagedPool, Notify->ThisBufferLength ); ExFreePool( Notify->AllocatedBuffer ); } if (Notify->FullDirectoryName != NULL) { SubjectContext = Notify->SubjectContext; } ExFreePool( Notify ); } } } finally { ReleaseNotifySync( NotifySync ); if (SubjectContext != NULL) { SeReleaseSubjectContext( SubjectContext ); ExFreePool( SubjectContext ); } DebugTrace( -1, Dbg, "FsRtlNotifyCleanup: Exit\n", 0 ); } return; }

NTKERNELAPI VOID FsRtlNotifyFullChangeDirectory (  IN PNOTIFY_SYNC  NotifySync, IN PLIST_ENTRY  NotifyList, IN PVOID  FsContext, IN PSTRING  FullDirectoryName, IN BOOLEAN  WatchTree, IN BOOLEAN  IgnoreBuffer, IN ULONG  CompletionFilter, IN PIRP  NotifyIrp, IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback  OPTIONAL, IN PSECURITY_SUBJECT_CONTEXT SubjectContext  OPTIONAL )

Definition at line 547 of file notify.c. References AcquireNotifySync, _NOTIFY_CHANGE::BufferLength, CHAR, _NOTIFY_CHANGE::CharacterSize, ClearFlag, _NOTIFY_CHANGE::CompletionFilter, _NOTIFY_CHANGE::DataLength, Dbg, DebugTrace, ExFreePool(), FALSE, _IO_STACK_LOCATION::FileObject, FlagOn, _NOTIFY_CHANGE::Flags, _FILE_OBJECT::Flags, FO_CLEANUP_COMPLETE, _FILE_OBJECT::FsContext, _NOTIFY_CHANGE::FsContext, FsRtlCheckNotifyForDelete(), FsRtlCompleteRequest, FsRtlIsNotifyOnList(), FsRtlNotifyCompleteIrp(), FsRtlNotifySetCancelRoutine(), FsRtlpAllocatePool, _NOTIFY_CHANGE::FullDirectoryName, IoGetCurrentIrpStackLocation, IoMarkIrpPending, _NOTIFY_CHANGE::LastEntry, NOTIFY_CHANGE, NOTIFY_CLEANUP_CALLED, NOTIFY_DEFER_NOTIFY, NOTIFY_DIR_IS_ROOT, NOTIFY_IMMEDIATE_NOTIFY, NOTIFY_STREAM_IS_DELETED, NOTIFY_WATCH_TREE, _NOTIFY_CHANGE::NotifyIrps, _NOTIFY_CHANGE::NotifyList, _NOTIFY_CHANGE::NotifySync, NULL, _NOTIFY_CHANGE::OwningProcess, PAGED_CODE, PagedPool, _IO_STACK_LOCATION::Parameters, PNOTIFY_CHANGE, PREAL_NOTIFY_SYNC, _NOTIFY_CHANGE::ReferenceCount, ReleaseNotifySync, SeReleaseSubjectContext(), SetFlag, _NOTIFY_CHANGE::StreamID, _NOTIFY_CHANGE::SubjectContext, THREAD_TO_PROCESS, _NOTIFY_CHANGE::TraverseCallback, try_return, and WatchTree. Referenced by FsRtlNotifyChangeDirectory(), and UdfNotifyChangeDirectory(). : This routine is called by a file system which has received a NotifyChange request. This routine checks if there is already a notify structure and inserts one if not present. With a notify structure in hand, we check whether we already have a pending notify and report it if so. If there is no pending notify, we check if this Irp has already been cancelled and completes it if so. Otherwise we add this to the list of Irps waiting for notification. This is the version of this routine which understands about the user's buffer and will fill it in on a reported change. Arguments: NotifySync - This is the controlling fast mutex for this notify list. It is stored here so that it can be found for an Irp which is being cancelled. NotifyList - This is the start of the notify list to add this structure to. FsContext - This is supplied by the file system so that this notify structure can be uniquely identified. If the NotifyIrp is not specified then this is used to identify the stream and it will match the FsContext field in the file object of a stream being deleted. FullDirectoryName - Points to the full name for the directory associated with this notify structure. Ignored if the NotifyIrp is not specified. WatchTree - This indicates whether all subdirectories for this directory should be watched, or just the directory itself. Ignored if the NotifyIrp is not specified. IgnoreBuffer - Indicates whether we will always ignore any user buffer and force the directory to be reenumerated. This will speed up the operation. Ignored if the NotifyIrp is not specified. CompletionFilter - This provides the mask to determine which operations will trigger the notify operations. Ignored if the NotifyIrp is not specified. NotifyIrp - This is the Irp to complete on notify change. If this irp is not specified it means that the stream represented by this file object is being deleted. TraverseCallback - If specified we must call this routine when a change has occurred in a subdirectory being watched in a tree. This will let the filesystem check if the watcher has traverse access to that directory. Ignored if the NotifyIrp is not specified. SubjectContext - If there is a traverse callback routine then we will pass this subject context as a parameter to the call. We will release the context and free the structure when done with it. Ignored if the NotifyIrp is not specified. Return Value: None. --*/ { PNOTIFY_CHANGE Notify; PIO_STACK_LOCATION IrpSp; PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyFullChangeDirectory: Entered\n", 0 ); // // Acquire exclusive access to the list by acquiring the mutex. // AcquireNotifySync( NotifySync ); // // Use a try-finally to facilitate cleanup. // try { // // If there is no Irp then find all of the pending Irps whose file objects // refer to the same stream and complete them with STATUS_DELETE_PENDING. // if (NotifyIrp == NULL) { FsRtlCheckNotifyForDelete( NotifyList, FsContext ); try_return( NOTHING ); } // // Get the current Stack location // IrpSp = IoGetCurrentIrpStackLocation( NotifyIrp ); // // Clear the Iosb in the Irp. // NotifyIrp->IoStatus.Status = STATUS_SUCCESS; NotifyIrp->IoStatus.Information = 0; // // If the file object has already gone through cleanup, then complete // the request immediately. // if (FlagOn( IrpSp->FileObject->Flags, FO_CLEANUP_COMPLETE )) { // // Always mark this Irp as pending returned. // IoMarkIrpPending( NotifyIrp ); FsRtlCompleteRequest( NotifyIrp, STATUS_NOTIFY_CLEANUP ); try_return( NOTHING ); } // // If the notify structure is not already in the list, add it // now. // Notify = FsRtlIsNotifyOnList( NotifyList, FsContext ); if (Notify == NULL) { // // Allocate and initialize the structure. // Notify = FsRtlpAllocatePool( PagedPool, sizeof( NOTIFY_CHANGE )); RtlZeroMemory( Notify, sizeof( NOTIFY_CHANGE )); Notify->NotifySync = (PREAL_NOTIFY_SYNC) NotifySync; Notify->FsContext = FsContext; Notify->StreamID = IrpSp->FileObject->FsContext; Notify->TraverseCallback = TraverseCallback; Notify->SubjectContext = SubjectContext; SubjectContext = NULL; Notify->FullDirectoryName = FullDirectoryName; InitializeListHead( &Notify->NotifyIrps ); if (WatchTree) { SetFlag( Notify->Flags, NOTIFY_WATCH_TREE ); } if (FullDirectoryName == NULL) { // // In the view index we aren't using this buffer to hold a // unicode string. // Notify->CharacterSize = sizeof( CHAR ); } else { // // We look at the directory name to decide if we have a unicode // name. // if (FullDirectoryName->Length >= 2 && FullDirectoryName->Buffer[1] == '\0') { Notify->CharacterSize = sizeof( WCHAR ); } else { Notify->CharacterSize = sizeof( CHAR ); } if (FullDirectoryName->Length == Notify->CharacterSize) { SetFlag( Notify->Flags, NOTIFY_DIR_IS_ROOT ); } } Notify->CompletionFilter = CompletionFilter; // // If we are to return data to the user then look for the length // of the original buffer in the IrpSp. // if (!IgnoreBuffer) { Notify->BufferLength = IrpSp->Parameters.NotifyDirectory.Length; } Notify->OwningProcess = THREAD_TO_PROCESS( NotifyIrp->Tail.Overlay.Thread ); InsertTailList( NotifyList, &Notify->NotifyList ); Notify->ReferenceCount = 1; // // If we have already been called with cleanup then complete // the request immediately. // } else if (FlagOn( Notify->Flags, NOTIFY_CLEANUP_CALLED )) { // // Always mark this Irp as pending returned. // IoMarkIrpPending( NotifyIrp ); FsRtlCompleteRequest( NotifyIrp, STATUS_NOTIFY_CLEANUP ); try_return( NOTHING ); // // If this file has been deleted then complete with STATUS_DELETE_PENDING. // } else if (FlagOn( Notify->Flags, NOTIFY_STREAM_IS_DELETED )) { // // Always mark this Irp as pending returned. // IoMarkIrpPending( NotifyIrp ); FsRtlCompleteRequest( NotifyIrp, STATUS_DELETE_PENDING ); try_return( NOTHING ); // // If the notify pending flag is set or there is data in an internal buffer // we complete this Irp immediately and exit. // } else if (FlagOn( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ) && !FlagOn( Notify->Flags, NOTIFY_DEFER_NOTIFY )) { DebugTrace( 0, Dbg, "Notify has been pending\n", 0 ); // // Clear the flag in our notify structure before completing the // Irp. This will prevent a caller who reposts in his completion // routine from looping in the completion routine. // ClearFlag( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ); // // Always mark this Irp as pending returned. // IoMarkIrpPending( NotifyIrp ); FsRtlCompleteRequest( NotifyIrp, STATUS_NOTIFY_ENUM_DIR ); try_return( NOTHING ); } else if (Notify->DataLength != 0 && !FlagOn( Notify->Flags, NOTIFY_DEFER_NOTIFY )) { ULONG ThisDataLength = Notify->DataLength; // // Now set our buffer pointers back to indicate an empty buffer. // Notify->DataLength = 0; Notify->LastEntry = 0; FsRtlNotifyCompleteIrp( NotifyIrp, Notify, ThisDataLength, STATUS_SUCCESS, FALSE ); try_return( NOTHING ); } // // Add the Irp to the tail of the notify queue. // NotifyIrp->IoStatus.Information = (ULONG_PTR) Notify; IoMarkIrpPending( NotifyIrp ); InsertTailList( &Notify->NotifyIrps, &NotifyIrp->Tail.Overlay.ListEntry ); // // Increment the reference count to indicate that Irp might go through cancel. // InterlockedIncrement( &Notify->ReferenceCount ); // // Call the routine to set the cancel routine. // FsRtlNotifySetCancelRoutine( NotifyIrp, NULL ); try_exit: NOTHING; } finally { // // Release the mutex. // ReleaseNotifySync( NotifySync ); // // If there is still a subject context then release it and deallocate // the structure. Remember that if FullDirectoryName is null, it means // this is a view index, not a directory index, and the SubjectContext // is really a piece of file system context information. // if ((SubjectContext != NULL) && (Notify->FullDirectoryName != NULL)) { SeReleaseSubjectContext( SubjectContext ); ExFreePool( SubjectContext ); } DebugTrace( -1, Dbg, "FsRtlNotifyFullChangeDirectory: Exit\n", 0 ); } return; }

NTKERNELAPI VOID FsRtlNotifyFullReportChange (  IN PNOTIFY_SYNC  NotifySync, IN PLIST_ENTRY  NotifyList, IN PSTRING  FullTargetName, IN USHORT  TargetNameOffset, IN PSTRING StreamName  OPTIONAL, IN PSTRING NormalizedParentName  OPTIONAL, IN ULONG  FilterMatch, IN ULONG  Action, IN PVOID  TargetContext )

Definition at line 973 of file notify.c. References AcquireNotifySync, Action, Add2Ptr, _NOTIFY_CHANGE::AllocatedBuffer, ASSERT, ASSERTMSG, _IRP::AssociatedIrp, _NOTIFY_CHANGE::Buffer, _NOTIFY_CHANGE::BufferLength, CHAR, _NOTIFY_CHANGE::CharacterSize, ClearFlag, _NOTIFY_CHANGE::CompletionFilter, _NOTIFY_CHANGE::DataLength, Dbg, DebugTrace, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), FALSE, FileName, FlagOn, _NOTIFY_CHANGE::Flags, _NOTIFY_CHANGE::FsContext, FsRtlIsNtstatusExpected(), FsRtlNotifyCompleteIrpList(), FsRtlNotifyUpdateBuffer(), FsRtlpAllocatePool, _NOTIFY_CHANGE::FullDirectoryName, IoGetCurrentIrpStackLocation, L, _NOTIFY_CHANGE::LastEntry, LongAlign, _IRP::MdlAddress, MmGetSystemAddressForMdl, NOTIFY_DEFER_NOTIFY, NOTIFY_DIR_IS_ROOT, NOTIFY_IMMEDIATE_NOTIFY, NOTIFY_WATCH_TREE, _NOTIFY_CHANGE::NotifyIrps, NULL, _NOTIFY_CHANGE::OwningProcess, PAGED_CODE, PagedPool, _IO_STACK_LOCATION::Parameters, PNOTIFY_CHANGE, PsChargePoolQuota(), PsReturnPoolQuota(), ReleaseNotifySync, SetFlag, _NOTIFY_CHANGE::SubjectContext, _NOTIFY_CHANGE::ThisBufferLength, _NOTIFY_CHANGE::TraverseCallback, TRUE, and USHORT. Referenced by FsRtlNotifyReportChange(). : This routine is called by a file system when a file has been modified in such a way that it will cause a notify change Irp to complete. We walk through all the notify structures looking for those structures which would be associated with an ancestor directory of the target file name. We look for all the notify structures which have a filter match and then check that the directory name in the notify structure is a proper prefix of the full target name. If we find a notify structure which matches the above conditions, we complete all the Irps for the notify structure. If the structure has no Irps, we mark the notify pending field. Arguments: NotifySync - This is the controlling fast mutex for this notify list. It is stored here so that it can be found for an Irp which is being cancelled. NotifyList - This is the start of the notify list to add this structure to. FullTargetName - This is the full name of the file from the root of the volume. TargetNameOffset - This is the offset in the full name of the final component of the name. StreamName - If present then this is the stream name to store with the filename. NormalizedParentName - If present this is the same path as the parent name but the DOS-ONLY names have been replaced with the associated long name. FilterMatch - This flag field is compared with the completion filter in the notify structure. If any of the corresponding bits in the completion filter are set, then a notify condition exists. Action - This is the action code to store in the user's buffer if present. TargetContext - This is one of the context pointers to pass to the file system if performing a traverse check in the case of a tree being watched. Return Value: None. --*/ { PLIST_ENTRY NotifyLinks; STRING NormalizedParent; STRING ParentName; STRING TargetName; PNOTIFY_CHANGE Notify; STRING TargetParent; PIRP NotifyIrp; BOOLEAN NotifyIsParent; BOOLEAN ViewIndex = FALSE; UCHAR ComponentCount; ULONG SizeOfEntry; ULONG CurrentOffset; ULONG NextEntryOffset; ULONG ExceptionCode; PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyFullReportChange: Entered\n", 0 ); // // If this is a change to the root directory then return immediately. // if ((TargetNameOffset == 0) && (FullTargetName != NULL)) { DebugTrace( -1, Dbg, "FsRtlNotifyFullReportChange: Exit\n", 0 ); return; } ParentName.Buffer = NULL; TargetName.Buffer = NULL; // // Acquire exclusive access to the list by acquiring the mutex. // AcquireNotifySync( NotifySync ); // // Use a try-finally to facilitate cleanup. // try { // // Walk through all the notify blocks. // for (NotifyLinks = NotifyList->Flink; NotifyLinks != NotifyList; NotifyLinks = NotifyLinks->Flink) { // // Obtain the Notify structure from the list entry. // Notify = CONTAINING_RECORD( NotifyLinks, NOTIFY_CHANGE, NotifyList ); // // The rules for deciding whether this notification applies are // different for view indices versus file name indices (directories). // if (FullTargetName == NULL) { ASSERTMSG( "Directory notify handle in view index notify list!", Notify->FullDirectoryName == NULL); // // Make sure this is the Fcb being watched. // if (TargetContext != Notify->SubjectContext) { continue; } TargetParent.Buffer = NULL; TargetParent.Length = 0; ViewIndex = TRUE; // // Handle the directory case. // } else { ASSERTMSG( "View index notify handle in directory notify list!", Notify->FullDirectoryName != NULL); // // If the length of the name in the notify block is currently zero then // someone is doing a rename and we can skip this block. // if (Notify->FullDirectoryName->Length == 0) { continue; } // // If this filter match is not part of the completion filter then continue. // if (!(FilterMatch & Notify->CompletionFilter)) { continue; } // // If there is no normalized name then set its value from the full // file name. // if (!ARGUMENT_PRESENT( NormalizedParentName )) { NormalizedParent.Buffer = FullTargetName->Buffer; NormalizedParent.Length = TargetNameOffset; if (NormalizedParent.Length != Notify->CharacterSize) { NormalizedParent.Length -= Notify->CharacterSize; } NormalizedParent.MaximumLength = NormalizedParent.Length; NormalizedParentName = &NormalizedParent; } // // If the length of the directory being watched is longer than the // parent of the modified file then it can't be an ancestor of the // modified file. // if (Notify->FullDirectoryName->Length > NormalizedParentName->Length) { continue; } // // If the lengths match exactly then this can only be the parent of // the modified file. // if (NormalizedParentName->Length == Notify->FullDirectoryName->Length) { NotifyIsParent = TRUE; // // If we are not watching the subtree of this directory then continue. // } else if (!FlagOn( Notify->Flags, NOTIFY_WATCH_TREE )) { continue; // // The watched directory can only be an ancestor of the modified // file. Make sure that there is legal pathname separator immediately // after the end of the watched directory name within the normalized name. // If the watched directory is the root then we know this condition is TRUE. // } else { if (!FlagOn( Notify->Flags, NOTIFY_DIR_IS_ROOT )) { // // Check for the character size. // if (Notify->CharacterSize == sizeof( CHAR )) { if (*(Add2Ptr( NormalizedParentName->Buffer, Notify->FullDirectoryName->Length, PCHAR )) != '\\') { continue; } } else if (*(Add2Ptr( NormalizedParentName->Buffer, Notify->FullDirectoryName->Length, PWCHAR )) != L'\\') { continue; } } NotifyIsParent = FALSE; } // // We now have a correct match of the name lengths. Now verify that the // characters match exactly. // if (!RtlEqualMemory( Notify->FullDirectoryName->Buffer, NormalizedParentName->Buffer, Notify->FullDirectoryName->Length )) { continue; } // // The characters are correct. Now check in the case of a non-parent // notify that we have traverse callback. // if (!NotifyIsParent && Notify->TraverseCallback != NULL && !Notify->TraverseCallback( Notify->FsContext, TargetContext, Notify->SubjectContext )) { continue; } } // // If this entry is going into a buffer then check that // it will fit. // if (!FlagOn( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ) && Notify->BufferLength != 0) { ULONG AllocationLength; AllocationLength = 0; NotifyIrp = NULL; // // If we don't already have a buffer then check to see // if we have any Irps in the list and use the buffer // length in the Irp. // if (Notify->ThisBufferLength == 0) { // // If there is an entry in the list then get the length. // if (!IsListEmpty( &Notify->NotifyIrps )) { PIO_STACK_LOCATION IrpSp; NotifyIrp = CONTAINING_RECORD( Notify->NotifyIrps.Flink, IRP, Tail.Overlay.ListEntry ); IrpSp = IoGetCurrentIrpStackLocation( NotifyIrp ); AllocationLength = IrpSp->Parameters.NotifyDirectory.Length; // // Otherwise use the caller's last buffer size. // } else { AllocationLength = Notify->BufferLength; } // // Otherwise use the length of the current buffer. // } else { AllocationLength = Notify->ThisBufferLength; } // // Build the strings for the relative name. This includes // the strings for the parent name, file name and stream // name. // if (!NotifyIsParent) { // // We need to find the string for the ancestor of this // file from the watched directory. If the normalized parent // name is the same as the parent name then we can use // the tail of the parent directly. Otherwise we need to // count the matching name components and capture the // final components. // if (!ViewIndex) { // // If the watched directory is the root then we just use the full // parent name. // if (FlagOn( Notify->Flags, NOTIFY_DIR_IS_ROOT ) || NormalizedParentName->Buffer != FullTargetName->Buffer) { // // If we don't have a string for the parent then construct // it now. // if (ParentName.Buffer == NULL) { ParentName.Buffer = FullTargetName->Buffer; ParentName.Length = TargetNameOffset; if (ParentName.Length != Notify->CharacterSize) { ParentName.Length -= Notify->CharacterSize; } ParentName.MaximumLength = ParentName.Length; } // // Count through the components of the parent until we have // swallowed the same number of name components as in the // watched directory name. We have the unicode version and // the Ansi version to watch for. // ComponentCount = 0; CurrentOffset = 0; // // If this is the root then there is no more to do. // if (FlagOn( Notify->Flags, NOTIFY_DIR_IS_ROOT )) { NOTHING; } else { ULONG ParentComponentCount; ULONG ParentOffset; ParentComponentCount = 1; ParentOffset = 0; if (Notify->CharacterSize == sizeof( CHAR )) { // // Find the number of components in the parent. We // have to do this for each one because this name and // the number of components could have changed. // while (ParentOffset < Notify->FullDirectoryName->Length) { if (*((PCHAR) Notify->FullDirectoryName->Buffer + ParentOffset) == '\\') { ParentComponentCount += 1; } ParentOffset += 1; } while (TRUE) { if (*((PCHAR) ParentName.Buffer + CurrentOffset) == '\\') { ComponentCount += 1; if (ComponentCount == ParentComponentCount) { break; } } CurrentOffset += 1; } } else { // // Find the number of components in the parent. We // have to do this for each one because this name and // the number of components could have changed. // while (ParentOffset < Notify->FullDirectoryName->Length / sizeof( WCHAR )) { if (*((PWCHAR) Notify->FullDirectoryName->Buffer + ParentOffset) == '\\') { ParentComponentCount += 1; } ParentOffset += 1; } while (TRUE) { if (*((PWCHAR) ParentName.Buffer + CurrentOffset) == L'\\') { ComponentCount += 1; if (ComponentCount == ParentComponentCount) { break; } } CurrentOffset += 1; } // // Convert characters to bytes. // CurrentOffset *= Notify->CharacterSize; } } // // We now know the offset into the parent name of the separator // immediately preceding the relative parent name. Construct the // target parent name for the buffer. // CurrentOffset += Notify->CharacterSize; TargetParent.Buffer = Add2Ptr( ParentName.Buffer, CurrentOffset, PCHAR ); TargetParent.MaximumLength = TargetParent.Length = ParentName.Length - (USHORT) CurrentOffset; // // If the normalized is the same as the parent name use the portion // after the match with the watched directory. // } else { TargetParent.Buffer = Add2Ptr( NormalizedParentName->Buffer, (Notify->FullDirectoryName->Length + Notify->CharacterSize), PCHAR ); TargetParent.MaximumLength = TargetParent.Length = NormalizedParentName->Length - Notify->FullDirectoryName->Length - Notify->CharacterSize; } } } else { // // The length of the target parent is zero. // TargetParent.Length = 0; } // // Compute how much buffer space this report will take. // SizeOfEntry = FIELD_OFFSET( FILE_NOTIFY_INFORMATION, FileName ); if (ViewIndex) { // // In the view index case, the information to copy to the // buffer comes to us in the stream name, and that is all // the room we need to worry about having. // ASSERT(ARGUMENT_PRESENT( StreamName )); SizeOfEntry += StreamName->Length; } else { // // If there is a parent to report, find the size and include a separator // character. // if (!NotifyIsParent) { if (Notify->CharacterSize == sizeof( CHAR )) { SizeOfEntry += RtlOemStringToCountedUnicodeSize( &TargetParent ); } else { SizeOfEntry += TargetParent.Length; } // // Include the separator. This is always a unicode character. // SizeOfEntry += sizeof( WCHAR ); } // // If we don't have the string for the target then construct it now. // if (TargetName.Buffer == NULL) { TargetName.Buffer = Add2Ptr( FullTargetName->Buffer, TargetNameOffset, PCHAR ); TargetName.MaximumLength = TargetName.Length = FullTargetName->Length - TargetNameOffset; } if (Notify->CharacterSize == sizeof( CHAR )) { SizeOfEntry += RtlOemStringToCountedUnicodeSize( &TargetName ); } else { SizeOfEntry += TargetName.Length; } // // If there is a stream name then add the bytes needed // for that. // if (ARGUMENT_PRESENT( StreamName )) { // // Add the space needed for the ':' separator. // if (Notify->CharacterSize == sizeof( WCHAR )) { SizeOfEntry += (StreamName->Length + sizeof( WCHAR )); } else { SizeOfEntry += (RtlOemStringToCountedUnicodeSize( StreamName ) + sizeof( CHAR )); } } } // // Remember if this report would overflow the buffer. // NextEntryOffset = (ULONG)LongAlign( Notify->DataLength ); if (SizeOfEntry <= AllocationLength && (NextEntryOffset + SizeOfEntry) <= AllocationLength) { PFILE_NOTIFY_INFORMATION NotifyInfo = NULL; // // If there is already a notify buffer, we append this // data to it. // if (Notify->Buffer != NULL) { NotifyInfo = Add2Ptr( Notify->Buffer, Notify->LastEntry, PFILE_NOTIFY_INFORMATION ); NotifyInfo->NextEntryOffset = NextEntryOffset - Notify->LastEntry; Notify->LastEntry = NextEntryOffset; NotifyInfo = Add2Ptr( Notify->Buffer, Notify->LastEntry, PFILE_NOTIFY_INFORMATION ); // // If there is an Irp list we check whether we will need // to allocate a new buffer. // } else if (NotifyIrp != NULL) { if (NotifyIrp->AssociatedIrp.SystemBuffer != NULL) { Notify->Buffer = NotifyInfo = NotifyIrp->AssociatedIrp.SystemBuffer; Notify->ThisBufferLength = AllocationLength; } else if (NotifyIrp->MdlAddress != NULL) { Notify->Buffer = NotifyInfo = MmGetSystemAddressForMdl( NotifyIrp->MdlAddress ); Notify->ThisBufferLength = AllocationLength; } } // // If we need to allocate a buffer, we will charge quota // to the original process and allocate paged pool. // if (Notify->Buffer == NULL) { BOOLEAN ChargedQuota = FALSE; try { PsChargePoolQuota( Notify->OwningProcess, PagedPool, AllocationLength ); ChargedQuota = TRUE; Notify->AllocatedBuffer = Notify->Buffer = FsRtlpAllocatePool( PagedPool, AllocationLength ); Notify->ThisBufferLength = AllocationLength; NotifyInfo = Notify->Buffer; } except(( ExceptionCode = GetExceptionCode(), FsRtlIsNtstatusExpected(ExceptionCode)) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { ASSERT( (ExceptionCode == STATUS_INSUFFICIENT_RESOURCES) || (ExceptionCode == STATUS_QUOTA_EXCEEDED) ); // // Return quota if we allocated the buffer. // if (ChargedQuota) { PsReturnPoolQuota( Notify->OwningProcess, PagedPool, AllocationLength ); } // // Forget any current buffer and resort to immediate // notify. // SetFlag( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ); } } // // If we have a buffer then fill in the results // from this operation. Otherwise we remember // to simply alert the caller. // if (NotifyInfo != NULL) { // // Update the buffer with the current data. // if (FsRtlNotifyUpdateBuffer( NotifyInfo, Action, &TargetParent, &TargetName, StreamName, (BOOLEAN) (Notify->CharacterSize == sizeof( WCHAR )), SizeOfEntry )) { // // Update the buffer data length. // Notify->DataLength = NextEntryOffset + SizeOfEntry; // // We couldn't copy the data into the buffer. Just // notify without any additional information. // } else { SetFlag( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ); } } } else { SetFlag( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ); } // // If we have a buffer but can't use it then clear all of the // buffer related fields. Also deallocate any buffer allocated // by us. // if (FlagOn( Notify->Flags, NOTIFY_IMMEDIATE_NOTIFY ) && Notify->Buffer != NULL) { if (Notify->AllocatedBuffer != NULL) { PsReturnPoolQuota( Notify->OwningProcess, PagedPool, Notify->ThisBufferLength ); ExFreePool( Notify->AllocatedBuffer ); } Notify->AllocatedBuffer = Notify->Buffer = NULL; Notify->ThisBufferLength = Notify->DataLength = Notify->LastEntry = 0; } } // // Complete the next entry on the list if we aren't holding // up notification. // if (Action == FILE_ACTION_RENAMED_OLD_NAME) { SetFlag( Notify->Flags, NOTIFY_DEFER_NOTIFY ); } else { ClearFlag( Notify->Flags, NOTIFY_DEFER_NOTIFY ); if (!IsListEmpty( &Notify->NotifyIrps )) { FsRtlNotifyCompleteIrpList( Notify, STATUS_SUCCESS ); } } } } finally { ReleaseNotifySync( NotifySync ); DebugTrace( -1, Dbg, "FsRtlNotifyFullReportChange: Exit\n", 0 ); } return; }

NTKERNELAPI VOID FsRtlNotifyInitializeSync (  IN PNOTIFY_SYNC *  NotifySync  )

Definition at line 371 of file notify.c. References Dbg, DebugTrace, ERESOURCE_THREAD, ExInitializeFastMutex, _REAL_NOTIFY_SYNC::FastMutex, FsRtlpAllocatePool, NonPagedPool, NULL, _REAL_NOTIFY_SYNC::OwnerCount, _REAL_NOTIFY_SYNC::OwningThread, PAGED_CODE, PNOTIFY_SYNC, and PREAL_NOTIFY_SYNC. Referenced by UdfInitializeVcb(). : This routine is called to allocate and initialize the synchronization object for this notify list. Arguments: NotifySync - This is the address to store the structure we allocate. Return Value: None. --*/ { PREAL_NOTIFY_SYNC RealSync; PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyInitializeSync: Entered\n", 0 ); // // Clear the pointer and then attempt to allocate a non-paged // structure. // *NotifySync = NULL; RealSync = (PREAL_NOTIFY_SYNC) FsRtlpAllocatePool( NonPagedPool, sizeof( REAL_NOTIFY_SYNC )); // // Initialize the structure. // ExInitializeFastMutex( &RealSync->FastMutex ); RealSync->OwningThread = (ERESOURCE_THREAD) 0; RealSync->OwnerCount = 0; *NotifySync = (PNOTIFY_SYNC) RealSync; DebugTrace( -1, Dbg, "FsRtlNotifyInitializeSync: Exit\n", 0 ); return; }

NTKERNELAPI VOID FsRtlNotifyReportChange (  IN PNOTIFY_SYNC  NotifySync, IN PLIST_ENTRY  NotifyList, IN PSTRING  FullTargetName, IN PSTRING  TargetName, IN ULONG  FilterMatch )

Definition at line 897 of file notify.c. References Dbg, DebugTrace, FsRtlNotifyFullReportChange(), NULL, PAGED_CODE, and USHORT. : This routine is called by a file system when a file has been modified in such a way that it will cause a notify change Irp to complete. We walk through all the notify structures looking for those structures which would be associated with an ancestor directory of the target file name. We look for all the notify structures which have a filter match and then check that the directory name in the notify structure is a proper prefix of the full target name. If we find a notify structure which matches the above conditions, we complete all the Irps for the notify structure. If the structure has no Irps, we mark the notify pending field. Arguments: NotifySync - This is the controlling fast mutex for this notify list. It is stored here so that it can be found for an Irp which is being cancelled. NotifyList - This is the start of the notify list to add this structure to. FullTargetName - This is the full name of the file which has been changed. TargetName - This is the final component of the modified file. FilterMatch - This flag field is compared with the completion filter in the notify structure. If any of the corresponding bits in the completion filter are set, then a notify condition exists. Return Value: None. --*/ { PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyReportChange: Entered\n", 0 ); // // Call the full notify routine to do the actual work. // FsRtlNotifyFullReportChange( NotifySync, NotifyList, FullTargetName, (USHORT) (FullTargetName->Length - TargetName->Length), NULL, NULL, FilterMatch, 0, NULL ); DebugTrace( -1, Dbg, "FsRtlNotifyReportChange: Exit\n", 0 ); return; }

NTKERNELAPI VOID FsRtlNotifyUninitializeSync (  IN PNOTIFY_SYNC *  NotifySync  )

Definition at line 426 of file notify.c. References Dbg, DebugTrace, ExFreePool(), NULL, and PAGED_CODE. Referenced by UdfDeleteVcb(). : This routine is called to uninitialize the synchronization object for this notify list. Arguments: NotifySync - This is the address containing the pointer to our synchronization object. Return Value: None. --*/ { PAGED_CODE(); DebugTrace( +1, Dbg, "FsRtlNotifyUninitializeSync: Entered\n", 0 ); // // Free the structure if present and clear the pointer. // if (*NotifySync != NULL) { ExFreePool( *NotifySync ); *NotifySync = NULL; } DebugTrace( -1, Dbg, "FsRtlNotifyUninitializeSync: Exit\n", 0 ); return; }

NTKERNELAPI NTSTATUS FsRtlNotifyVolumeEvent (  IN PFILE_OBJECT  FileObject, IN ULONG  EventCode )

Definition at line 41 of file fsrtl/pnp.c. References ASSERT, Event(), FSRTL_VOLUME_DISMOUNT, FSRTL_VOLUME_DISMOUNT_FAILED, FSRTL_VOLUME_LOCK, FSRTL_VOLUME_LOCK_FAILED, FSRTL_VOLUME_MOUNT, FSRTL_VOLUME_UNLOCK, IoGetRelatedTargetDevice(), IoReportTargetDeviceChange(), IoReportTargetDeviceChangeAsynchronous(), NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, Status, TARGET_DEVICE_CUSTOM_NOTIFICATION, and USHORT. Referenced by UdfCommonCleanup(), UdfDismountVolume(), UdfLockVolume(), UdfMountVolume(), UdfUnlockVolume(), and UdfVerifyVolume(). : This routine notifies any registered applications that a volume is being locked, unlocked, etc. Arguments: FileeObject - Supplies a file object for the volume being locked. EventCode - Which event is occuring -- e.g. FSRTL_VOLUME_LOCK Return Value: Status of the notification. --*/ { NTSTATUS Status = STATUS_SUCCESS; TARGET_DEVICE_CUSTOM_NOTIFICATION Event; PDEVICE_OBJECT Pdo; // // Retrieve the device object associated with this file object. // Status = IoGetRelatedTargetDevice( FileObject, &Pdo ); if (NT_SUCCESS( Status )) { ASSERT(Pdo != NULL); Event.Version = 1; Event.FileObject = NULL; Event.NameBufferOffset = -1; Event.Size = (USHORT)FIELD_OFFSET( TARGET_DEVICE_CUSTOM_NOTIFICATION, CustomDataBuffer ); switch (EventCode) { case FSRTL_VOLUME_DISMOUNT: RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_DISMOUNT, sizeof( GUID )); break; case FSRTL_VOLUME_DISMOUNT_FAILED: RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_DISMOUNT_FAILED, sizeof( GUID )); break; case FSRTL_VOLUME_LOCK: RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_LOCK, sizeof( GUID )); break; case FSRTL_VOLUME_LOCK_FAILED: RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_LOCK_FAILED, sizeof( GUID )); break; case FSRTL_VOLUME_MOUNT: // // Mount notification is asynchronous to avoid deadlocks when someone // unwittingly causes a mount in the course of handling some other // PnP notification, e.g. MountMgr's device arrival code. // RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_MOUNT, sizeof( GUID )); IoReportTargetDeviceChangeAsynchronous( Pdo, &Event, NULL, NULL ); ObDereferenceObject( Pdo ); return STATUS_SUCCESS; break; case FSRTL_VOLUME_UNLOCK: RtlCopyMemory( &Event.Event, &GUID_IO_VOLUME_UNLOCK, sizeof( GUID )); break; default: ObDereferenceObject( Pdo ); return STATUS_INVALID_PARAMETER; } IoReportTargetDeviceChange( Pdo, &Event ); ObDereferenceObject( Pdo ); } return Status; }

NTKERNELAPI ULONG FsRtlNumberOfRunsInLargeMcb (  IN PLARGE_MCB  Mcb  )

Definition at line 1924 of file largemcb.c. References Count, Dbg, DebugTrace, _NONOPAQUE_MCB::FastMutex, PAGED_CODE, _NONOPAQUE_MCB::PairCount, and PNONOPAQUE_MCB. Referenced by FsRtlNumberOfRunsInMcb(). : This routine returns to the its caller the number of distinct runs mapped by an Mcb. Holes (i.e., Vbns that map to Lbn=UNUSED_LBN) are counted as runs. For example, an Mcb containing a mapping for only Vbns 0 and 3 will have 3 runs, one for the first mapped sector, a second for the hole covering Vbns 1 and 2, and a third for Vbn 3. Arguments: OpaqueMcb - Supplies the Mcb being examined. Return Value: ULONG - Returns the number of distinct runs mapped by the input Mcb. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; ULONG Count; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlNumberOfRunsInLargeMcb, Mcb = %08lx\n", Mcb ); ExAcquireFastMutex( Mcb->FastMutex ); Count = Mcb->PairCount; ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlNumberOfRunsInLargeMcb -> %08lx\n", Count ); return Count; }

NTKERNELAPI ULONG FsRtlNumberOfRunsInMcb (  IN PMCB  Mcb  )

Definition at line 479 of file largemcb.c. References FsRtlNumberOfRunsInLargeMcb(), and PAGED_CODE. { PAGED_CODE(); return FsRtlNumberOfRunsInLargeMcb( (PLARGE_MCB)Mcb ); }

NTKERNELAPI NTSTATUS FsRtlOplockFsctrl (  IN POPLOCK  Oplock, IN PIRP  Irp, IN ULONG  OpenCount )

Definition at line 581 of file oplock.c. References Dbg, DebugTrace, EXCLUSIVE, FALSE, _IO_STACK_LOCATION::FileObject, FlagOn, _FILE_OBJECT::Flags, _IRP::Flags, FO_CLEANUP_COMPLETE, FsRtlAcknowledgeOplockBreak(), FsRtlCompleteRequest, FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakNotify(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), IoGetCurrentIrpStackLocation, IoIsOperationSynchronous(), Irp, IRP_INPUT_OPERATION, IRP_MJ_CREATE, LEVEL_I_OPLOCK, _IO_STACK_LOCATION::MajorFunction, NTSTATUS(), NULL, OpFilterReqPending, OPLOCK_STATE, PAGED_CODE, _IO_STACK_LOCATION::Parameters, PNONOPAQUE_OPLOCK, SetFlag, Status, and TRUE. Referenced by UdfOplockRequest(). : This is the interface with the filesystems for Fsctl calls, it handles oplock requests, break acknowledgement and break notify. Arguments: Oplock - Supplies the address of the opaque OPLOCK structure. Irp - Supplies a pointer to the Irp which declares the requested operation. OpenCount - This is the number of user handles on the file if we are requsting an exclusive oplock. A non-zero value for a level II request indicates that there are locks on the file. Return Value: NTSTATUS - Returns the result of this operation. If this is an Oplock request which is granted, then STATUS_PENDING is returned. If the Oplock isn't granted then STATUS_OPLOCK_NOT_GRANTED is returned. If this is an Oplock I break to no oplock, then STATUS_SUCCESS. If this is an Oplock I break to Oplock II then STATUS_PENDING is returned. Other error codes returned depend on the nature of the error. STATUS_CANCELLED is returned if the Irp is cancelled during this operation. STATUS_SUCCESS is returned if this is a create asking for a filter oplock. --*/ { NTSTATUS Status; PIO_STACK_LOCATION IrpSp; OPLOCK_STATE OplockState; PAGED_CODE(); // // Get the current IRP stack location // IrpSp = IoGetCurrentIrpStackLocation( Irp ); DebugTrace(+1, Dbg, "FsRtlOplockFsctrl: Entered\n", 0); DebugTrace( 0, Dbg, "FsRtlOplockFsctrl: Oplock -> %08lx\n", *Oplock ); DebugTrace( 0, Dbg, "FsRtlOplockFsctrl: Irp -> %08lx\n", Irp ); // // Check if this is the create case where the user is requesting a pending // filter oplock. // if (IrpSp->MajorFunction == IRP_MJ_CREATE) { // // Check that all the conditions hold to grant this oplock. // The conditions that must hold are: // // - This is the only opener of the file. // - Desired Access must be exactly FILE_READ_ATTRIBUTES. // This will insure an asynch open since the SYNCHRONIZE // flag can't be set. // - Share access is precisely // (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) // if ((OpenCount != 1) || (FlagOn( IrpSp->Parameters.Create.SecurityContext->DesiredAccess, ~(FILE_READ_ATTRIBUTES))) || ((IrpSp->Parameters.Create.ShareAccess & (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)) != (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE))) { Status = STATUS_OPLOCK_NOT_GRANTED; } else { Status = FsRtlRequestExclusiveOplock( (PNONOPAQUE_OPLOCK *) Oplock, IrpSp, NULL, OpFilterReqPending ); } // // Case on the FsControlFile code control code. // } else { // // Assume this is an OplockLevel I. // // NOTE - This code depends on the defined bits for these oplock types. // FILTER_OPLOCK = 4 * LEVEL_I_OPLOCK // BATCH_OPLOCK = 2 * LEVEL_I_OPLOCK // OplockState = LEVEL_I_OPLOCK; switch (IrpSp->Parameters.FileSystemControl.FsControlCode) { case FSCTL_REQUEST_FILTER_OPLOCK : OplockState *= 2; case FSCTL_REQUEST_BATCH_OPLOCK : OplockState *= 2; case FSCTL_REQUEST_OPLOCK_LEVEL_1 : // // Set the other flags for an exclusive oplock. // SetFlag( OplockState, EXCLUSIVE ); // // We short circuit the request if this request is treated // synchronously or the open count is not 1. Otherwise the Io system // will hold the return code until the Irp is completed. // // Also fail this if the flag is set which indicates that // the IO system should copy data back to a user's buffer. // // If cleanup has occurrred on this file, then we refuse // the oplock request. // if ((OpenCount != 1) || IoIsOperationSynchronous( Irp ) || FlagOn( Irp->Flags, IRP_INPUT_OPERATION ) || FlagOn( IrpSp->FileObject->Flags, FO_CLEANUP_COMPLETE )) { FsRtlCompleteRequest( Irp, STATUS_OPLOCK_NOT_GRANTED ); Status = STATUS_OPLOCK_NOT_GRANTED; } else { Status = FsRtlRequestExclusiveOplock( (PNONOPAQUE_OPLOCK *) Oplock, IrpSp, Irp, OplockState ); } break; case FSCTL_REQUEST_OPLOCK_LEVEL_2 : // // We short circuit the request if this request is treated // synchronously. Otherwise the Io system will hold the return // code until the Irp is completed. // // If cleanup has occurrred on this file, then we refuse // the oplock request. // // Also fail this if the flag is set which indicates that // the IO system should copy data back to a user's buffer. // // A non-zero open count in this case indicates that there are // file locks on the file. We will also fail the request in // this case. // if ((OpenCount != 0) || IoIsOperationSynchronous( Irp ) || FlagOn( Irp->Flags, IRP_INPUT_OPERATION ) || FlagOn( IrpSp->FileObject->Flags, FO_CLEANUP_COMPLETE )) { FsRtlCompleteRequest( Irp, STATUS_OPLOCK_NOT_GRANTED ); Status = STATUS_OPLOCK_NOT_GRANTED; } else { Status = FsRtlRequestOplockII( (PNONOPAQUE_OPLOCK *) Oplock, IrpSp, Irp ); } break; case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE : Status = FsRtlAcknowledgeOplockBreak( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp, TRUE ); break; case FSCTL_OPLOCK_BREAK_ACK_NO_2 : Status = FsRtlAcknowledgeOplockBreak( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp, FALSE ); break; case FSCTL_OPBATCH_ACK_CLOSE_PENDING : Status = FsRtlOpBatchBreakClosePending( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp ); break; case FSCTL_OPLOCK_BREAK_NOTIFY : Status = FsRtlOplockBreakNotify( (PNONOPAQUE_OPLOCK) *Oplock, IrpSp, Irp ); break; default : DebugTrace( 0, Dbg, "Invalid Control Code\n", 0); FsRtlCompleteRequest( Irp, STATUS_INVALID_PARAMETER ); Status = STATUS_INVALID_PARAMETER; } } DebugTrace(-1, Dbg, "FsRtlOplockFsctrl: Exit -> %08lx\n", Status ); return Status; }

NTKERNELAPI BOOLEAN FsRtlOplockIsFastIoPossible (  IN POPLOCK  Oplock  )

Definition at line 1116 of file oplock.c. References Dbg, DebugTrace, FALSE, FlagOn, LEVEL_II_OPLOCK, NULL, OPLOCK_BREAK_MASK, OPLOCK_STATE, PAGED_CODE, PNONOPAQUE_OPLOCK, and TRUE. Referenced by UdfFastLock(), UdfFastUnlockAll(), UdfFastUnlockAllByKey(), and UdfFastUnlockSingle(). : This routine indicates to the caller where there are any outstanding oplocks which prevent fast Io from happening. Arguments: OpLock - Supplies the oplock being queried Return Value: BOOLEAN - TRUE if there are outstanding oplocks and FALSE otherwise --*/ { BOOLEAN FastIoPossible = TRUE; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlOplockIsFastIoPossible: Oplock -> %08lx\n", *Oplock); // // There are not any current oplocks if the variable is null or // the state is no oplocks held. If an exclusive oplock was granted // but no break is in progress then allow the Fast IO. // if (*Oplock != NULL) { OPLOCK_STATE OplockState; OplockState = ((PNONOPAQUE_OPLOCK) *Oplock)->OplockState; if (FlagOn( OplockState, LEVEL_II_OPLOCK | OPLOCK_BREAK_MASK )) { FastIoPossible = FALSE; } } DebugTrace(-1, Dbg, "FsRtlOplockIsFastIoPossible: Exit -> %08lx\n", FastIoPossible); return FastIoPossible; }

NTKERNELAPI VOID FsRtlPostPagingFileStackOverflow (  IN PVOID  Context, IN PKEVENT  Event, IN PFSRTL_STACK_OVERFLOW_ROUTINE  StackOverflowRoutine )

Definition at line 177 of file stackovf.c. References Event(), FsRtlpPostStackOverflow(), and TRUE. : This routines posts a stack overflow item to the stack overflow thread and returns. Arguments: Context - Supplies the context to pass to the stack overflow call back routine. If the low order bit is set, then this overflow was a read to a paging file. Event - Supplies a pointer to an event to pass to the stack overflow call back routine. StackOverflowRoutine - Supplies the call back to use when processing the request in the overflow thread. Return Value: None. --*/ { FsRtlpPostStackOverflow( Context, Event, StackOverflowRoutine, TRUE ); return; }

NTKERNELAPI VOID FsRtlPostStackOverflow (  IN PVOID  Context, IN PKEVENT  Event, IN PFSRTL_STACK_OVERFLOW_ROUTINE  StackOverflowRoutine )

Definition at line 139 of file stackovf.c. References Event(), FALSE, and FsRtlpPostStackOverflow(). : This routines posts a stack overflow item to the stack overflow thread and returns. Arguments: Context - Supplies the context to pass to the stack overflow call back routine. If the low order bit is set, then this overflow was a read to a paging file. Event - Supplies a pointer to an event to pass to the stack overflow call back routine. StackOverflowRoutine - Supplies the call back to use when processing the request in the overflow thread. Return Value: None. --*/ { FsRtlpPostStackOverflow( Context, Event, StackOverflowRoutine, FALSE ); return; }

NTKERNELAPI BOOLEAN FsRtlPrepareMdlWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  LockKey, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 1860 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlPrepareMdlWriteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), NULL, _FAST_IO_DISPATCH::PrepareMdlWrite, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if the data was not written, or if there is an I/O error. TRUE - if the data is being written --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, PrepareMdlWrite)) && (FastIoDispatch->PrepareMdlWrite != NULL)) { return FastIoDispatch->PrepareMdlWrite( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, PrepareMdlWrite)) && (FastIoDispatch->PrepareMdlWrite != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlPrepareMdlWriteDev( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } } }

NTKERNELAPI BOOLEAN FsRtlPrepareMdlWriteDev (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  LockKey, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 1474 of file fastio.c. References ASSERT, CcCanIWrite(), CcGetFileSizePointer, CcPrepareMdlWrite(), CcZeroData(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FlagOn, FO_FILE_MODIFIED, FO_FILE_SIZE_CHANGED, FO_WRITE_THROUGH, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, Offset, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by FsRtlPrepareMdlWrite(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. DeviceObject - Supplies the DeviceObject for the callee. Return Value: FALSE - if the data was not written, or if there is an I/O error. TRUE - if the data is being written --*/ { PFSRTL_COMMON_FCB_HEADER Header; LARGE_INTEGER Offset, NewFileSize; LARGE_INTEGER OldFileSize; LARGE_INTEGER OldValidDataLength; BOOLEAN Status = TRUE; BOOLEAN AcquiredShared = FALSE; BOOLEAN FileSizeChanged = FALSE; BOOLEAN WriteToEndOfFile = (BOOLEAN)((FileOffset->LowPart == FILE_WRITE_TO_END_OF_FILE) && (FileOffset->HighPart == -1)); PAGED_CODE(); // // Call CcCanIWrite. Also return FALSE if FileObject is write through, // the File System must do that. // if ( !CcCanIWrite( FileObject, Length, TRUE, FALSE ) || FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { return FALSE; } // // Assume our transfer will work // IoStatus->Status = STATUS_SUCCESS; // // Special case the zero byte length // if (Length == 0) { return TRUE; } // // Get a real pointer to the common fcb header // Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); // // Make our best guess on whether we need the file exclusive or // shared. // NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; if (WriteToEndOfFile || (NewFileSize.QuadPart > Header->ValidDataLength.QuadPart)) { // // Acquired exclusive on the common fcb header, and return if we don't // get it. // ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { // // Acquired shared on the common fcb header, and return if we don't // get it. // ExAcquireResourceShared( Header->Resource, TRUE ); AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o and if the file // space is allocated, and if not then release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } else { Offset = *FileOffset; NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; } // // Now that the File is acquired shared, we can safely test if it is // really cached and if we can do fast i/o and we do not have to extend. // If not then release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (MAXLONGLONG - Offset.QuadPart < (LONGLONG)Length) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart ) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to get the // Fcb exclusive, and make sure that FastIo is still possible. // if (AcquiredShared && ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart )) { ExReleaseResource( Header->Resource ); ExAcquireResourceExclusive( Header->Resource, TRUE ); AcquiredShared = FALSE; // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart )) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask the file system // the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; // // All file system then set "Is Questionable" had better support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is anything // other than GoForIt then we cannot take the fast I/O path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, TRUE, LockKey, FALSE, // write operation IoStatus, IoGetRelatedDeviceObject( FileObject ) )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now so that our // reads are not nooped. // if ( NewFileSize.QuadPart > Header->FileSize.QuadPart ) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize; OldValidDataLength = Header->ValidDataLength; // // Deal with an extremely rare pathalogical case here the file // size wraps. // if ( (Header->FileSize.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = NewFileSize; } } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // copy write fails, then return FALSE to our caller. // // // Also mark this as the top level "Irp" so that lower file system levels // will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if ( Offset.QuadPart > Header->ValidDataLength.QuadPart ) { Status = CcZeroData( FileObject, &Header->ValidDataLength, &Offset, TRUE ); } if (Status) { CcPrepareMdlWrite( FileObject, &Offset, Length, MdlChain, IoStatus ); } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to check again // since we did not do this when we acquired the resource exclusive. // if ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart ) { // // Deal with an extremely rare pathalogical case here the // ValidDataLength wraps. // if ( (Header->ValidDataLength.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->ValidDataLength = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->ValidDataLength = NewFileSize; } } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { *CcGetFileSizePointer(FileObject) = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // If we did not succeed, then we must restore the original FileSize // and release the resource. In the success path, the cache manager // will release the resource. // } else { if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; } } } // // Now we can release the resource. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; }

NTKERNELAPI BOOLEAN FsRtlPrivateLock (  IN PFILE_LOCK  FileLock, IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN PLARGE_INTEGER  Length, IN PEPROCESS  ProcessId, IN ULONG  Key, IN BOOLEAN  FailImmediately, IN BOOLEAN  ExclusiveLock, OUT PIO_STATUS_BLOCK  Iosb, IN PIRP  Irp, IN PVOID  Context, IN BOOLEAN  AlreadySynchronized )

Definition at line 3867 of file filelock.c. References _IRP::Cancel, _IRP::CancelIrql, _WAITING_LOCK::Context, Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _FILE_LOCK_INFO::ExclusiveLock, ExRaiseStatus(), FALSE, _FILE_LOCK_INFO::FileObject, FsRtlAcquireLockQueue, FsRtlAllocateWaitingLock(), FsRtlCompleteLockIrp, FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateCheckForSharedLockAccess(), FsRtlPrivateInitializeFileLock(), FsRtlPrivateInsertLock(), FsRtlPrivateRemoveLock(), FsRtlReleaseLockQueue, IoMarkIrpPending, IoSetCancelRoutine, _IRP::IoStatus, _WAITING_LOCK::Irp, Irp, Key, _FILE_LOCK_INFO::Key, _FILE_LOCK_INFO::Length, _WAITING_LOCK::Link, _LOCK_INFO::LockQueue, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObject, PLOCK_INFO, PLOCK_QUEUE, _FILE_LOCK_INFO::ProcessId, PWAITING_LOCK, _FILE_LOCK_INFO::StartingByte, TRUE, try_return, _LOCK_QUEUE::WaitingLocks, and _LOCK_QUEUE::WaitingLocksTail. Referenced by FsRtlProcessFileLock(). : This routine preforms a lock operation request. This handles both the fast get lock and the Irp based get lock. If the Irp is supplied then this routine will either complete the Irp or enqueue it as a waiting lock request. Arguments: FileLock - Supplies the File Lock to work against FileObject - Supplies the file object used in this operation FileOffset - Supplies the file offset used in this operation Length - Supplies the length used in this operation ProcessId - Supplies the process ID used in this operation Key - Supplies the key used in this operation FailImmediately - Indicates if the request should fail immediately if the lock cannot be granted. ExclusiveLock - Indicates if this is a request for an exclusive or shared lock Iosb - Receives the Status if this operation is successful Context - Supplies the context with which to complete Irp with AlreadySynchronized - Indicates that the caller has already synchronized access to the file lock so the fields in the file lock and be updated without further locking, but not the queues. Return Value: BOOLEAN - TRUE if this operation completed and FALSE otherwise. --*/ { BOOLEAN Results; BOOLEAN AccessGranted; BOOLEAN ViaFastCall; BOOLEAN ReleaseQueue = FALSE; PLOCK_INFO LockInfo; PLOCK_QUEUE LockQueue; KIRQL OldIrql; FILE_LOCK_INFO FileLockInfo; DebugTrace(+1, Dbg, "FsRtlPrivateLock, FileLock = %08lx\n", FileLock); // // If the irp is null then this is being called via the fast call method. // ViaFastCall = (BOOLEAN) !ARGUMENT_PRESENT( Irp ); if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { DebugTrace(+2, Dbg, "FsRtlPrivateLock, New LockInfo required\n", 0); // // No lock information on this FileLock, create the structure. // // if (!FsRtlPrivateInitializeFileLock (FileLock, ViaFastCall)) { return FALSE; } // // Set flag so file locks will be checked on the fast io // code paths // FileLock->FastIoIsQuestionable = TRUE; // // Pickup allocated lockinfo structure // LockInfo = (PLOCK_INFO) FileLock->LockInformation; } // // Assume success and build LockData structure prior to acquiring // the lock queue spinlock. (mp perf enhancement) // FileLockInfo.StartingByte = *FileOffset; FileLockInfo.Length = *Length; (ULONGLONG)FileLockInfo.EndingByte.QuadPart = (ULONGLONG)FileLockInfo.StartingByte.QuadPart + (ULONGLONG)FileLockInfo.Length.QuadPart - 1; FileLockInfo.Key = Key; FileLockInfo.FileObject = FileObject; FileLockInfo.ProcessId = ProcessId; FileLockInfo.ExclusiveLock = ExclusiveLock; LockQueue = &LockInfo->LockQueue; // // Now we need to actually run through our current lock queue. // FsRtlAcquireLockQueue(LockQueue, &OldIrql); ReleaseQueue = TRUE; try { // // Case on whether we're trying to take out an exclusive lock or // a shared lock. And in both cases try to get appropriate access. // if (ExclusiveLock) { DebugTrace(0, Dbg, "Check for write access\n", 0); AccessGranted = FsRtlPrivateCheckForExclusiveLockAccess( LockQueue, &FileLockInfo ); } else { DebugTrace(0, Dbg, "Check for read access\n", 0); AccessGranted = FsRtlPrivateCheckForSharedLockAccess( LockQueue, &FileLockInfo ); } // // Now AccessGranted tells us whether we can really get the access // for the range we want // if (!AccessGranted) { DebugTrace(0, Dbg, "We do not have access\n", 0); // // We cannot read/write to the range, so we cannot take out // the lock. Now if the user wanted to fail immediately then // we'll complete the Irp, otherwise we'll enqueue this Irp // to the waiting lock queue // if (FailImmediately) { // // Set our status and return, the finally clause will // complete the request // DebugTrace(0, Dbg, "And we fail immediately\n", 0); Iosb->Status = STATUS_LOCK_NOT_GRANTED; try_return( Results = TRUE ); } else if (ARGUMENT_PRESENT(Irp)) { PWAITING_LOCK WaitingLock; DebugTrace(0, Dbg, "And we enqueue the Irp for later\n", 0); // // Allocate a new waiting record, set it to point to the // waiting Irp, and insert it in the tail of the waiting // locks queue // WaitingLock = FsRtlAllocateWaitingLock(); // // Simply raise out if we can't allocate. // if (WaitingLock == NULL) { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } WaitingLock->Irp = Irp; WaitingLock->Context = Context; IoMarkIrpPending( Irp ); // // Add WaitingLock WaitingLockQueue // WaitingLock->Link.Next = NULL; if (LockQueue->WaitingLocks.Next == NULL) { // // Create new list // LockQueue->WaitingLocks.Next = &WaitingLock->Link; LockQueue->WaitingLocksTail.Next = &WaitingLock->Link; } else { // // Add waiter to tail of list // LockQueue->WaitingLocksTail.Next->Next = &WaitingLock->Link; LockQueue->WaitingLocksTail.Next = &WaitingLock->Link; } // // Setup IRP in case it's canceled - then set the // IRP's cancel routine // Irp->IoStatus.Information = (ULONG_PTR)LockInfo; IoSetCancelRoutine( Irp, FsRtlPrivateCancelFileLockIrp ); if (Irp->Cancel) { // // Pull the cancel routine off of the IRP - if it is not // NULL, this means we won the race with IoCancelIrp and // will be responsible for cancelling the IRP synchronously. // If NULL, we lost and our cancel routine is already being // called for us. // // This must be done while holding the lock queue down since // this is how we synchronize with the cancel. // if (IoSetCancelRoutine( Irp, NULL )) { // // Irp's cancel routine was not called, do it ourselves. // Indicate to the cancel routine that he does not need // to release the cancel spinlock by passing a NULL DO. // // The queue will be dropped in order to complete the Irp. // We communicate the previous IRQL through the Irp itself. // Irp->CancelIrql = OldIrql; FsRtlPrivateCancelFileLockIrp( NULL, Irp ); ReleaseQueue = FALSE; } } Iosb->Status = STATUS_PENDING; try_return( Results = TRUE ); } else { try_return( Results = FALSE ); } } DebugTrace(0, Dbg, "We have access\n", 0); if (!FsRtlPrivateInsertLock( LockInfo, FileObject, &FileLockInfo )) { // // Resource exhaustion will cause us to fail here. Via the fast call, indicate // that it may be worthwhile to go around again via the Irp based path. If we // are already there, simply raise out. // if (ViaFastCall) { try_return( Results = FALSE ); } else { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } } else { Iosb->Status = STATUS_SUCCESS; } // // At long last, we're done. // Results = TRUE; try_exit: NOTHING; } finally { if (ReleaseQueue) { FsRtlReleaseLockQueue(LockQueue, OldIrql); } // // Complete the request provided we were given one and it is not a pending status // if (!AbnormalTermination() && ARGUMENT_PRESENT(Irp) && (Iosb->Status != STATUS_PENDING)) { NTSTATUS NewStatus; // // We must reference the fileobject for the case that the IRP completion // fails and we need to lift the lock. Although the only reason we have // to touch the fileobject in the remove case is to unset the LastLock field, // we have no way of knowing if we will race with a reference count drop // and lose. // ObReferenceObject( FileObject ); // // Complete the request, if the don't get back success then // we need to possibly remove the lock that we just // inserted. // FsRtlCompleteLockIrp( LockInfo, Context, Irp, Iosb->Status, &NewStatus, FileObject ); if (!NT_SUCCESS(NewStatus) && NT_SUCCESS(Iosb->Status) ) { // // Irp failed, remove the lock which was added // FsRtlPrivateRemoveLock ( LockInfo, &FileLockInfo, TRUE ); } // // Lift our private reference to the fileobject. This may induce deletion. // ObDereferenceObject( FileObject ); Iosb->Status = NewStatus; } DebugTrace(-1, Dbg, "FsRtlPrivateLock -> %08lx\n", Results); } // // and return to our caller // return Results; }

NTKERNELAPI NTSTATUS FsRtlProcessFileLock (  IN PFILE_LOCK  FileLock, IN PIRP  Irp, IN PVOID Context  OPTIONAL )

Definition at line 1173 of file filelock.c. References ASSERT, BooleanFlagOn, Dbg, DebugTrace, FALSE, _IO_STACK_LOCATION::FileObject, _IO_STACK_LOCATION::Flags, FsRtlCompleteLockIrp, FsRtlCompleteRequest, FsRtlFastUnlockAll(), FsRtlFastUnlockAllByKey(), FsRtlFastUnlockSingle(), FsRtlPrivateLock(), IoGetCurrentIrpStackLocation, IoGetRequestorProcess(), Irp, IRP_MJ_LOCK_CONTROL, IRP_MN_LOCK, IRP_MN_UNLOCK_ALL, IRP_MN_UNLOCK_ALL_BY_KEY, IRP_MN_UNLOCK_SINGLE, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NTSTATUS(), NULL, _IO_STACK_LOCATION::Parameters, SL_EXCLUSIVE_LOCK, SL_FAIL_IMMEDIATELY, Status, and VOID(). Referenced by UdfCommonLockControl(). : This routine processes a file lock IRP it does either a lock request, or an unlock request. It also completes the IRP. Once called the user (i.e., File System) has relinquished control of the input IRP. If pool is not available to store the information this routine will raise a status value indicating insufficient resources. Arguments: FileLock - Supplies the File lock being modified/queried. Irp - Supplies the Irp being processed. Context - Optionally supplies a context to use when calling the user alternate IRP completion routine. Return Value: NTSTATUS - The return status for the operation. --*/ { PIO_STACK_LOCATION IrpSp; IO_STATUS_BLOCK Iosb; NTSTATUS Status; LARGE_INTEGER ByteOffset; DebugTrace(+1, Dbg, "FsRtlProcessFileLock, FileLock = %08lx\n", FileLock); Iosb.Information = 0; // // Get a pointer to the current Irp stack location and assert that // the major function code is for a lock operation // IrpSp = IoGetCurrentIrpStackLocation( Irp ); ASSERT( IrpSp->MajorFunction == IRP_MJ_LOCK_CONTROL ); // // Now process the different minor lock operations // switch (IrpSp->MinorFunction) { case IRP_MN_LOCK: ByteOffset = IrpSp->Parameters.LockControl.ByteOffset; (VOID) FsRtlPrivateLock( FileLock, IrpSp->FileObject, &ByteOffset, IrpSp->Parameters.LockControl.Length, IoGetRequestorProcess(Irp), IrpSp->Parameters.LockControl.Key, BooleanFlagOn(IrpSp->Flags, SL_FAIL_IMMEDIATELY), BooleanFlagOn(IrpSp->Flags, SL_EXCLUSIVE_LOCK), &Iosb, Irp, Context, FALSE ); break; case IRP_MN_UNLOCK_SINGLE: ByteOffset = IrpSp->Parameters.LockControl.ByteOffset; Iosb.Status = FsRtlFastUnlockSingle( FileLock, IrpSp->FileObject, &ByteOffset, IrpSp->Parameters.LockControl.Length, IoGetRequestorProcess(Irp), IrpSp->Parameters.LockControl.Key, Context, FALSE ); FsRtlCompleteLockIrp( FileLock, Context, Irp, Iosb.Status, &Status, NULL ); break; case IRP_MN_UNLOCK_ALL: Iosb.Status = FsRtlFastUnlockAll( FileLock, IrpSp->FileObject, IoGetRequestorProcess(Irp), Context ); FsRtlCompleteLockIrp( FileLock, Context, Irp, Iosb.Status, &Status, NULL ); break; case IRP_MN_UNLOCK_ALL_BY_KEY: Iosb.Status = FsRtlFastUnlockAllByKey( FileLock, IrpSp->FileObject, IoGetRequestorProcess(Irp), IrpSp->Parameters.LockControl.Key, Context ); FsRtlCompleteLockIrp( FileLock, Context, Irp, Iosb.Status, &Status, NULL ); break; default: // // For all other minor function codes we say they're invalid and // complete the request. Note that the IRP has not been marked // pending so this error will be returned directly to the caller. // DebugTrace(0, 1, "Invalid LockFile Minor Function Code %08lx\n", IrpSp->MinorFunction); FsRtlCompleteRequest( Irp, STATUS_INVALID_DEVICE_REQUEST ); Iosb.Status = STATUS_INVALID_DEVICE_REQUEST; break; } // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlProcessFileLock -> %08lx\n", Iosb.Status); return Iosb.Status; }

NTKERNELAPI NTSTATUS FsRtlRegisterUncProvider (  IN OUT PHANDLE  MupHandle, IN PUNICODE_STRING  RedirectorDeviceName, IN BOOLEAN  MailslotsSupported )

Definition at line 247 of file unc.c. References DevMup, DevNull, ExAllocatePoolWithTag, Executive, ExFreePool(), FALSE, FsRtlpDRD, FsRtlpIsDfsEnabled(), FsRtlpOpenDev(), FsRtlpRedirs, FsRtlpRegisterProviderWithMUP(), FsRtlpSetSymbolicLink(), FsRtlpUncSemaphore, KeReleaseSemaphore(), KernelMode, KeWaitForSingleObject(), MailslotsSupported, MODULE_POOL_TAG, MupHandle, MupRegKey, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, RedirDevName, RtlInitUnicodeString(), VOID(), and ZwLoadDriver(). : This routine registers a redir as a UNC provider. Arguments: Handle - Pointer to a handle. The handle is returned by the routine to be used when calling FsRtlDeregisterUncProvider. It is valid only if the routines returns STATUS_SUCCESS. RedirDevName - The device name of the redir. MailslotsSupported - If TRUE, this redir supports mailslots. Return Value: NTSTATUS - The status of the operation. --*/ { NTSTATUS status; HANDLE mupHandle = (HANDLE)-1; UNICODE_STRING mupDriverName; BOOLEAN dfsEnabled; PAGED_CODE(); KeWaitForSingleObject(&FsRtlpUncSemaphore, Executive, KernelMode, FALSE, NULL ); if (FsRtlpRedirs == 0) { dfsEnabled = FsRtlpIsDfsEnabled(); if (dfsEnabled) { FsRtlpRedirs = 1; RtlZeroMemory((PVOID) &FsRtlpDRD, sizeof(FsRtlpDRD)); } } switch( FsRtlpRedirs ) { case 0: // // Ok, the MUP isn't there and we don't need to use the // MUP for the first redir. // // We need to return a handle, but we're not really using the MUP yet. // And we may never use it (if there's only 1 redir). Return // a handle to the NULL device object, since we're committed to returning // a handle to our caller. Our caller isn't supposed to do anything with // the handle except to call FsRtlDeregisterUncProvider() with it. // status = FsRtlpOpenDev( &mupHandle, DevNull ); if( !NT_SUCCESS( status ) ) break; // // Save up enough state to allow us to call the MUP later with // this registration info if necessary. // FsRtlpDRD.RedirDevName.Buffer = ExAllocatePoolWithTag( NonPagedPool, RedirDevName->MaximumLength, MODULE_POOL_TAG ); if( FsRtlpDRD.RedirDevName.Buffer == NULL ) { status = STATUS_INSUFFICIENT_RESOURCES; break; } FsRtlpDRD.RedirDevName.Length = RedirDevName->Length; FsRtlpDRD.RedirDevName.MaximumLength = RedirDevName->MaximumLength; RtlMoveMemory( (PCHAR)FsRtlpDRD.RedirDevName.Buffer, RedirDevName->Buffer, RedirDevName->MaximumLength ); FsRtlpDRD.MailslotsSupported = MailslotsSupported; FsRtlpDRD.ReturnedHandle = mupHandle; FsRtlpDRD.MupHandle = (HANDLE)-1; // // Set the UNC symbolic link to point to the redir we just loaded // FsRtlpSetSymbolicLink( RedirDevName ); break; default: // // This is the second or later redir load -- MUST use the MUP // status = FsRtlpOpenDev( &mupHandle, DevMup ); if( !NT_SUCCESS( status ) ) { RtlInitUnicodeString( &mupDriverName, MupRegKey ); (VOID)ZwLoadDriver( &mupDriverName ); status = FsRtlpOpenDev( &mupHandle, DevMup ); if( !NT_SUCCESS( status ) ) break; } // // See if we need to tell the MUP about the first redir that registered // if( FsRtlpDRD.RedirDevName.Buffer ) { status = FsRtlpRegisterProviderWithMUP( mupHandle, &FsRtlpDRD.RedirDevName, FsRtlpDRD.MailslotsSupported ); if( !NT_SUCCESS( status ) ) break; FsRtlpDRD.MupHandle = mupHandle; ExFreePool( FsRtlpDRD.RedirDevName.Buffer ); FsRtlpDRD.RedirDevName.Buffer = NULL; // // Set the UNC symbolic link to point to the MUP // RtlInitUnicodeString( &mupDriverName, DevMup ); FsRtlpSetSymbolicLink( &mupDriverName ); status = FsRtlpOpenDev( &mupHandle, DevMup ); if( !NT_SUCCESS( status ) ) break; } // // Pass the request to the MUP for this redir // status = FsRtlpRegisterProviderWithMUP( mupHandle, RedirDevName, MailslotsSupported ); break; } if( NT_SUCCESS( status ) ) { FsRtlpRedirs++; *MupHandle = mupHandle; } else { if( mupHandle != (HANDLE)-1 && mupHandle != NULL ) { ZwClose( mupHandle ); } *MupHandle = (HANDLE)-1; } KeReleaseSemaphore(&FsRtlpUncSemaphore, 0, 1, FALSE ); return status; }

NTKERNELAPI VOID FsRtlReleaseFile (  IN PFILE_OBJECT  FileObject  )

Definition at line 2628 of file fastio.c. References _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, FsRtlExitFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseFileForNtCreateSection, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. Referenced by CcDeleteSharedCacheMap(), CcWriteBehind(), CcZeroEndOfLastPage(), and MmCreateSection(). 02634 : 02635 02636 This routine releases resources acquired by FsRtlAcquireFileExclusive. 02637 02638 Arguments: 02639 02640 FileObject - Pointer to the file object being written. 02641 02642 Return Value: 02643 02644 None. 02645 02646 --*/ 02647 02648 { 02649 PDEVICE_OBJECT DeviceObject; 02650 PFAST_IO_DISPATCH FastIoDispatch; 02651 PFSRTL_COMMON_FCB_HEADER Header; 02652 02653 PAGED_CODE(); 02654 02655 // 02656 // First see if we have to call the file system. 02657 // 02658 02659 DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); 02660 02661 if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && 02662 (FastIoDispatch->SizeOfFastIoDispatch > 02663 FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseFileForNtCreateSection )) && 02664 (FastIoDispatch->ReleaseFileForNtCreateSection != NULL)) { 02665 02666 FastIoDispatch->ReleaseFileForNtCreateSection( FileObject ); 02667 FsRtlExitFileSystem(); 02668 return; 02669 } 02670 02671 // 02672 // If there is a main file resource, release that. 02673 // 02674 02675 if ((Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext) && 02676 (Header->Resource != NULL)) { 02677 02678 ExReleaseResource( Header->Resource ); 02679 FsRtlExitFileSystem(); 02680 return; 02681 } 02682 02683 // 02684 // Nothing to release. 02685 // 02686 02687 return; 02688 }

NTKERNELAPI VOID FsRtlReleaseFileForCcFlush (  IN PFILE_OBJECT  FileObject  )

Definition at line 2483 of file fastio.c. References ASSERT, _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, FsRtlExitFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseForCcFlush, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and Status. Referenced by MiRemoveUnusedSegments(), MmFlushSection(), and MmFlushVirtualMemory(). : This routine releases a file system resource previously acquired for the CcFlush. Arguments: FileObject - Pointer to the file object being written. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseForCcFlush )) && (FastIoDispatch->ReleaseForCcFlush != NULL)) { Status = FastIoDispatch->ReleaseForCcFlush( FileObject, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { PFSRTL_COMMON_FCB_HEADER Header = FileObject->FsContext; // // Free whatever we acquired. // if (Header->PagingIoResource != NULL) { ExReleaseResource( Header->PagingIoResource ); } if (Header->Resource != NULL) { ExReleaseResource( Header->Resource ); } } FsRtlExitFileSystem(); }

NTKERNELAPI VOID FsRtlReleaseFileForModWrite (  IN PFILE_OBJECT  FileObject, IN PERESOURCE  ResourceToRelease )

Definition at line 2342 of file fastio.c. References ASSERT, _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseForModWrite, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and Status. Referenced by MiWriteComplete(). : This routine releases a file system resource previously acquired for the modified page writer. Arguments: FileObject - Pointer to the file object being written. ResourceToRelease - Supplies the resource to release. Not defined if FALSE is returned. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseForModWrite )) && (FastIoDispatch->ReleaseForModWrite != NULL)) { Status = FastIoDispatch->ReleaseForModWrite( FileObject, ResourceToRelease, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { ExReleaseResource( ResourceToRelease ); } }

NTKERNELAPI PFSRTL_FILTER_CONTEXT FsRtlRemoveFilterContext (  IN PFILE_OBJECT  FileObject, IN PVOID OwnerId  OPTIONAL, IN PVOID InstanceId  OPTIONAL )

Definition at line 189 of file filtrctx.c. References ASSERT, FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS, Header, _FSRTL_FILTER_CONTEXT::InstanceId, _FSRTL_FILTER_CONTEXT::Links, List, MySearchList, NULL, and _FSRTL_FILTER_CONTEXT::OwnerId. : This routine deletes filter driver context associated with a stream. Filter drivers must explicitly remove all context they associate with a stream (otherwise the underlying filesystem will BugCheck at close). FsRtlRemoveFilterContext functions identically to FsRtlLookupFilterContext, except that the returned context has been removed from the list. Arguments: FileObject - Specifies the stream of interest. OwnerId - Used to identify context information belonging to a particular filter driver. InstanceId - Used to search for a particular instance of a filter driver context. If not provided, any of the contexts owned by the filter driver is removed and returned. If neither the OwnerId nor the InstanceId is provided, any associated filter context will be removed and returned. Return Value: A pointer to the filter context, or NULL if no match found. --*/ { PFSRTL_COMMON_FCB_HEADER Header; PFSRTL_FILTER_CONTEXT Ctx, RtnCtx; PLIST_ENTRY List; ASSERT(FileObject); Header = FileObject->FsContext; if ( !Header || !(Header->Flags2 & FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS) ) { return NULL; } ExAcquireFastMutex (Header->FastMutex); RtnCtx = NULL; // Use different loops depending on whether we are comparing both Ids or not. if ( ARGUMENT_PRESENT(InstanceId) ) { MySearchList (&Header->FilterContexts, List) { Ctx = CONTAINING_RECORD (List, FSRTL_FILTER_CONTEXT, Links); if (Ctx->OwnerId == OwnerId && Ctx->InstanceId == InstanceId) { RtnCtx = Ctx; break; } } } else if ( ARGUMENT_PRESENT(OwnerId) ) { MySearchList (&Header->FilterContexts, List) { Ctx = CONTAINING_RECORD (List, FSRTL_FILTER_CONTEXT, Links); if (Ctx->OwnerId == OwnerId) { RtnCtx = Ctx; break; } } } else if (!IsListEmpty(&Header->FilterContexts)) { RtnCtx = (PFSRTL_FILTER_CONTEXT) Header->FilterContexts.Flink; } if (RtnCtx) { RemoveEntryList(&RtnCtx->Links); // remove the matched entry } ExReleaseFastMutex(Header->FastMutex); return RtnCtx; }

NTKERNELAPI VOID FsRtlRemoveLargeMcbEntry (  IN PLARGE_MCB  Mcb, IN LONGLONG  Vbn, IN LONGLONG  SectorCount )

Definition at line 1528 of file largemcb.c. References ASSERTMSG, Dbg, DebugTrace, _NONOPAQUE_MCB::FastMutex, FsRtlRemoveMcbEntryPrivate(), PAGED_CODE, PNONOPAQUE_MCB, and VBN. : This routine removes a mapping of VBNs to LBNs from an Mcb. The mappings removed are for Vbn, Vbn+1, to Vbn+(SectorCount-1). The operation works even if the mapping for a Vbn in the specified range does not already exist in the Mcb. If the specified range of Vbn includes the last mapped Vbn in the Mcb then the Mcb mapping shrinks accordingly. If pool is not available to store the information this routine will raise a status value indicating insufficient resources. Arguments: OpaqueMcb - Supplies the Mcb from which to remove the mapping. Vbn - Supplies the starting Vbn of the mappings to remove. SectorCount - Supplies the size of the mappings to remove (in sectors). Return Value: None. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; VBN Vbn = ((ULONG)LargeVbn); ULONG SectorCount = ((ULONG)LargeSectorCount); PAGED_CODE(); ASSERTMSG("LargeInteger not supported yet ", ((PLARGE_INTEGER)&LargeVbn)->HighPart == 0); DebugTrace(+1, Dbg, "FsRtlRemoveLargeMcbEntry, Mcb = %08lx\n", Mcb ); DebugTrace( 0, Dbg, " Vbn = %08lx\n", Vbn ); DebugTrace( 0, Dbg, " SectorCount = %08lx\n", SectorCount ); ExAcquireFastMutex( Mcb->FastMutex ); try { FsRtlRemoveMcbEntryPrivate( Mcb, Vbn, SectorCount ); } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlRemoveLargeMcbEntry -> VOID\n", 0 ); } return; }

NTKERNELAPI VOID FsRtlRemoveMcbEntry (  IN PMCB  Mcb, IN VBN  Vbn, IN ULONG  SectorCount )

Definition at line 392 of file largemcb.c. References Dbg, DebugTrace, _NONOPAQUE_MCB::FastMutex, FsRtlRemoveMcbEntryPrivate(), PAGED_CODE, and PNONOPAQUE_MCB. Referenced by UdfAddVmcbMapping(), and UdfRemoveVmcbMapping(). { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlRemoveMcbEntry, Mcb = %08lx\n", Mcb ); DebugTrace( 0, Dbg, " Vbn = %08lx\n", Vbn ); DebugTrace( 0, Dbg, " SectorCount = %08lx\n", SectorCount ); ExAcquireFastMutex( Mcb->FastMutex ); try { FsRtlRemoveMcbEntryPrivate( Mcb, Vbn, SectorCount ); } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlRemoveMcbEntry -> VOID\n", 0 ); } return; }

NTKERNELAPI VOID FsRtlResetLargeMcb (  IN PLARGE_MCB  Mcb, IN BOOLEAN  SelfSynchronized )

Definition at line 922 of file largemcb.c. References _NONOPAQUE_MCB::FastMutex, _NONOPAQUE_MCB::PairCount, and PNONOPAQUE_MCB. Referenced by UdfInitializeFcbMcb(), and UdfResetVmcb(). : This routine truncates an Mcb structure to contain zero mapping pairs. It does not shrink the mapping pairs array. Arguments: OpaqueMcb - Supplies a pointer to the Mcb structure to truncate. SelfSynchronized - Indicates whether the caller is already synchronized with respect to the Mcb. Return Value: None. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; if (SelfSynchronized) { // // If we are self-synchronized, then all we do is clear out the // current mapping pair count. // Mcb->PairCount = 0; } else { // // Since we are not self-synchronized, we must serialize access to // the Mcb before clearing the pair count // ExAcquireFastMutex( Mcb->FastMutex ); Mcb->PairCount = 0; ExReleaseFastMutex( Mcb->FastMutex ); } return; }

NTSTATUS FsRtlSetFileSize (  IN PFILE_OBJECT  FileObject, IN OUT PLARGE_INTEGER  FileSize )

Definition at line 2864 of file fastio.c. References _IRP::AssociatedIrp, Buffer, _IO_STACK_LOCATION::DeviceObject, Event(), Executive, FALSE, _IO_STACK_LOCATION::FileObject, _IRP::Flags, IoAllocateIrp(), IoCallDriver, IoGetNextIrpStackLocation, IoGetRelatedDeviceObject(), Irp, IRP_MJ_SET_INFORMATION, IRP_PAGING_IO, IRP_SYNCHRONOUS_PAGING_IO, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), _IO_STACK_LOCATION::MajorFunction, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _IO_STACK_LOCATION::Parameters, PsGetCurrentThread, _IRP::RequestorMode, _DEVICE_OBJECT::StackSize, Status, _IRP::Tail, _IRP::UserEvent, and _IRP::UserIosb. Referenced by MiCreateDataFileMap(), and MmExtendSection(). 02871 : 02872 02873 This routine is used to call the File System to update FileSize 02874 for a file. 02875 02876 It does this without acquiring the file object lock on synchronous file 02877 objects. This routine is therefore safe to call if you already own 02878 file system resources, while IoSetInformation could (and does) lead 02879 to deadlocks. 02880 02881 Arguments: 02882 02883 FileObject - A pointer to a referenced file object. 02884 02885 ValidDataLength - Pointer to new FileSize. 02886 02887 Return Value: 02888 02889 Status of operation. 02890 02891 --*/ 02892 02893 { 02894 PIO_STACK_LOCATION IrpSp; 02895 PDEVICE_OBJECT DeviceObject; 02896 NTSTATUS Status; 02897 FILE_END_OF_FILE_INFORMATION Buffer; 02898 IO_STATUS_BLOCK IoStatus; 02899 KEVENT Event; 02900 PIRP Irp; 02901 02902 PAGED_CODE(); 02903 02904 // 02905 // Copy FileSize to our buffer. 02906 // 02907 02908 Buffer.EndOfFile = *FileSize; 02909 02910 // 02911 // Initialize the event. 02912 // 02913 02914 KeInitializeEvent( &Event, NotificationEvent, FALSE ); 02915 02916 // 02917 // Begin by getting a pointer to the device object that the file resides 02918 // on. 02919 // 02920 02921 DeviceObject = IoGetRelatedDeviceObject( FileObject ); 02922 02923 // 02924 // Allocate an I/O Request Packet (IRP) for this in-page operation. 02925 // 02926 02927 Irp = IoAllocateIrp( DeviceObject->StackSize, FALSE ); 02928 if (Irp == NULL) { 02929 02930 return STATUS_INSUFFICIENT_RESOURCES; 02931 } 02932 02933 // 02934 // Get a pointer to the first stack location in the packet. This location 02935 // will be used to pass the function codes and parameters to the first 02936 // driver. 02937 // 02938 02939 IrpSp = IoGetNextIrpStackLocation( Irp ); 02940 02941 // 02942 // Fill in the IRP according to this request, setting the flags to 02943 // just cause IO to set the event and deallocate the Irp. 02944 // 02945 02946 Irp->Flags = IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO; 02947 Irp->RequestorMode = KernelMode; 02948 Irp->UserIosb = &IoStatus; 02949 Irp->UserEvent = &Event; 02950 Irp->Tail.Overlay.OriginalFileObject = FileObject; 02951 Irp->Tail.Overlay.Thread = PsGetCurrentThread(); 02952 Irp->AssociatedIrp.SystemBuffer = &Buffer; 02953 02954 // 02955 // Fill in the normal set file parameters. 02956 // 02957 02958 IrpSp->MajorFunction = IRP_MJ_SET_INFORMATION; 02959 IrpSp->FileObject = FileObject; 02960 IrpSp->DeviceObject = DeviceObject; 02961 IrpSp->Parameters.SetFile.Length = sizeof(FILE_END_OF_FILE_INFORMATION); 02962 IrpSp->Parameters.SetFile.FileInformationClass = FileEndOfFileInformation; 02963 02964 // 02965 // Queue the packet to the appropriate driver based on whether or not there 02966 // is a VPB associated with the device. This routine should not raise. 02967 // 02968 02969 Status = IoCallDriver( DeviceObject, Irp ); 02970 02971 // 02972 // If pending is returned (which is a successful status), 02973 // we must wait for the request to complete. 02974 // 02975 02976 if (Status == STATUS_PENDING) { 02977 KeWaitForSingleObject( &Event, 02978 Executive, 02979 KernelMode, 02980 FALSE, 02981 (PLARGE_INTEGER)NULL); 02982 } 02983 02984 // 02985 // If we got an error back in Status, then the Iosb 02986 // was not written, so we will just copy the status 02987 // there, then test the final status after that. 02988 // 02989 02990 if (!NT_SUCCESS(Status)) { 02991 IoStatus.Status = Status; 02992 } 02993 02994 return IoStatus.Status; 02995 } }

NTKERNELAPI BOOLEAN FsRtlSplitLargeMcb (  IN PLARGE_MCB  Mcb, IN LONGLONG  Vbn, IN LONGLONG  Amount )

Definition at line 2066 of file largemcb.c. References ASSERTMSG, Dbg, DebugTrace, FALSE, _NONOPAQUE_MCB::FastMutex, FsRtlAddLargeEntry(), FsRtlFindLargeIndex(), Index, LBN, _NONOPAQUE_MCB::Mapping, PAGED_CODE, _NONOPAQUE_MCB::PairCount, PNONOPAQUE_MCB, PreviousEndingLbn, StartingLbn, StartingVbn, TRUE, try_return, UNUSED_LBN, and VBN. : This routine is used to create a hole within an MCB, by shifting the mapping of Vbns. All mappings above the input vbn are shifted by the amount specified and while keeping their current lbn value. Pictorially we have as input the following MCB VBN : LargeVbn-1 LargeVbn N +-----------------+------------------+ LBN : X Y And after the split we have VBN : LargeVbn-1 LargeVbn+Amount N+Amount +-----------------+.............+---------------------------+ LBN : X UnusedLbn Y When doing the split we have a few cases to consider. They are: 1. The input Vbn is beyond the last run. In this case this operation is a noop. 2. The input Vbn is within or adjacent to a existing run of unused Lbns. In this case we simply need to extend the size of the existing hole and shift succeeding runs. 3. The input Vbn is between two existing runs, including the an input vbn value of zero. In this case we need to add a new entry for the hole and shift succeeding runs. 4. The input Vbn is within an existing run. In this case we need to add two new entries to contain the split run and the hole. If pool is not available to store the information this routine will raise a status value indicating insufficient resources. Arguments: OpaqueMcb - Supplies the Mcb in which to add the new mapping. Vbn - Supplies the starting Vbn that is to be shifted. Amount - Supplies the amount to shift by. Return Value: BOOLEAN - TRUE if the mapping was successfully shifted, and FALSE otherwise. If FALSE is returned then the Mcb is not changed. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; VBN Vbn = ((ULONG)LargeVbn); ULONG Amount = ((ULONG)LargeAmount); ULONG Index; BOOLEAN Result; ULONG i; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlSplitLargeMcb, Mcb = %08lx\n", Mcb ); DebugTrace( 0, Dbg, " Vbn = %08lx\n", Vbn ); DebugTrace( 0, Dbg, " Amount = %08lx\n", Amount ); ExAcquireFastMutex( Mcb->FastMutex ); ASSERTMSG("LargeInteger not supported yet ", ((((PLARGE_INTEGER)&LargeVbn)->HighPart == 0) || (Mcb->PairCount == 0))); ASSERTMSG("LargeInteger not supported yet ", ((((PLARGE_INTEGER)&LargeAmount)->HighPart == 0) || (Mcb->PairCount == 0))); try { // // First lookup the index for the entry that we are going to split. // If we can't find the entry then there is nothing to split. This // takes care of the case where the input vbn is beyond the last run // in the mcb // if (!FsRtlFindLargeIndex( Mcb, Vbn, &Index)) { try_return(Result = FALSE); } // // Now check if the input Vbn is within a hole // if (StartingLbn(Mcb,Index) == UNUSED_LBN) { // // Before: --PreviousRun--||--IndexHole--||--FollowingRun-- // After: --PreviousRun--||----IndexHole----||--FollowingRun-- // // In this case the vbn is somewhere within the hole and we // simply need to added the amount of each existing run // beyond the hole. // // // In this case there is really nothing to do here because the // ending code will already shift the runs by proper amount // starting at index // NOTHING; // // Now check if the input vbn is between a hole and an existing run. // } else if ((StartingVbn(Mcb,Index) == Vbn) && (Index != 0) && (PreviousEndingLbn(Mcb,Index) == UNUSED_LBN)) { // // Before: --Hole--||--IndexRun-- // After: --Hole------||--IndexRun-- // // In this case the vbn points to the start of the existing // run and we need to do the split between the hole and the // existing run by simply adding the amount to each existing // run beyond the hole. // // // In this case we need to decement the index by 1 and then // fall to the bottom code which will do the shifting for us // Index -= 1; // // Now check if the input vbn is between two existing runs // } else if (StartingVbn(Mcb,Index) == Vbn) { // // Before: --PreviousRun--||--IndexRun-- // After: --PreviousRun--||--NewHole--||--IndexRun-- // // Before: 0:|--IndexRun-- // After: 0:|--NewHole--||--IndexRun-- // // In this case the vbn points to the start of an existing // run and the preceeding is either a real run or the start // of mapping pairs We simply add a new entry for the hole // and shift succeeding runs. // FsRtlAddLargeEntry( Mcb, Index, 1 ); (Mcb->Mapping)[Index].Lbn = (LBN)UNUSED_LBN; (Mcb->Mapping)[Index].NextVbn = Vbn + Amount; Index += 1; // // Otherwise the input vbn is inside an existing run // } else { // // Before: --IndexRun-- // After: --SplitRun--||--NewHole--||--SplitRun-- // // In this case the vbn points within an existing run // we need to add two new extries for hole and split // run and shift succeeding runs // FsRtlAddLargeEntry( Mcb, Index, 2 ); (Mcb->Mapping)[Index].Lbn = (Mcb->Mapping)[Index+2].Lbn; (Mcb->Mapping)[Index].NextVbn = Vbn; (Mcb->Mapping)[Index+1].Lbn = (LBN)UNUSED_LBN; (Mcb->Mapping)[Index+1].NextVbn = Vbn + Amount; (Mcb->Mapping)[Index+2].Lbn = (Mcb->Mapping)[Index+2].Lbn + StartingVbn(Mcb, Index+1) - StartingVbn(Mcb, Index); Index += 2; } // // At this point we have completed most of the work we now need to // shift existing runs from the index to the end of the mappings // by the specified amount // for (i = Index; i < Mcb->PairCount; i += 1) { (Mcb->Mapping)[i].NextVbn += Amount; } Result = TRUE; try_exit: NOTHING; } finally { ExReleaseFastMutex( Mcb->FastMutex ); DebugTrace(-1, Dbg, "FsRtlSplitLargeMcb -> %08lx\n", Result ); } return Result; }

NTKERNELAPI NTSTATUS FsRtlSyncVolumes (  IN PDEVICE_OBJECT  TargetDevice, IN PLARGE_INTEGER ByteOffset  OPTIONAL, IN PLARGE_INTEGER  ByteCount )

Definition at line 96 of file faulttol.c. References ASSERT, Event(), Executive, FALSE, IoBuildDeviceIoControlRequest(), IoCallDriver, Irp, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), NTSTATUS(), NULL, Status, and TRUE. : This routine signals a device driver that it must sync redundant members of a mirror from the primary member. This is typically called after the file system determines that a volume is dirty. Arguments: TargetDevice - Supplies the device to sync. ByteOffset - If specified, gives the location to start syncing ByteCount - Gives the byte count to sync. Ignored if StartingOffset not specified. Return Value: NTSTATUS - The result of the operation. This will be STATUS_INVALID_DEVICE_REQUEST is the volume is not a mirror. --*/ { #if 0 // Mike Glass says we no longer need to do this. 3/3/94 PIRP Irp; KEVENT Event; IO_STATUS_BLOCK Iosb; NTSTATUS Status; BOOLEAN RangeSpecified; FT_SYNC_INFORMATION SyncInfo; KeInitializeEvent( &Event, NotificationEvent, FALSE ); // // If the user specified a range, capture it. // if (ARGUMENT_PRESENT(ByteOffset)) { SyncInfo.ByteOffset = *ByteOffset; SyncInfo.ByteCount = *ByteCount; RangeSpecified = TRUE; } else { RangeSpecified = FALSE; } Irp = IoBuildDeviceIoControlRequest( FT_SYNC_REDUNDANT_COPY, TargetDevice, RangeSpecified ? &SyncInfo : NULL, RangeSpecified ? sizeof(FT_SYNC_INFORMATION) : 0, NULL, 0, FALSE, &Event, &Iosb ); if ( Irp == NULL ) { return STATUS_INSUFFICIENT_RESOURCES; } Status = IoCallDriver( TargetDevice, Irp ); if (Status == STATUS_PENDING) { Status = KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL ); ASSERT( Status == STATUS_SUCCESS ); Status = Iosb.Status; } return Status; #else return STATUS_SUCCESS; #endif //0 }

NTKERNELAPI VOID FsRtlTeardownFilterContexts (  IN PLIST_ENTRY  FilterContexts  )

Definition at line 276 of file filtrctx.c. References _FSRTL_FILTER_CONTEXT::FreeCallback. : This routine is called by filesystems to free the filter contexts associated with an FSRTL_COMMON_FCB_HEADER by calling the FreeCallback routine for each FilterContext. It is assumed that we do not need to acquire the FastMutex. Arguments: FilterContexts - the address of the FilterContexts field within the FSRTL_COMMON_FCB_HEADER of the structure being torn down by the filesystem. Return Value: None. --*/ { PFSRTL_FILTER_CONTEXT ctx; PLIST_ENTRY ptr; ptr = FilterContexts->Flink; while ( ptr != FilterContexts ) { ctx = CONTAINING_RECORD (ptr, FSRTL_FILTER_CONTEXT, Links); ptr = ptr->Flink; (*ctx->FreeCallback)(ctx); } InitializeListHead( FilterContexts ); return; }

NTKERNELAPI VOID FsRtlTruncateLargeMcb (  IN PLARGE_MCB  Mcb, IN LONGLONG  Vbn )

Definition at line 743 of file largemcb.c. References ASSERTMSG, Dbg, DebugTrace, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), _NONOPAQUE_MCB::FastMutex, FsRtlAllocateFirstMapping, FsRtlFindLargeIndex(), FsRtlpAllocatePool, Index, INITIAL_MAXIMUM_PAIR_COUNT, _NONOPAQUE_MCB::Mapping, _NONOPAQUE_MCB::MaximumPairCount, NextStartingVbn, NULL, PAGED_CODE, PagedPool, _NONOPAQUE_MCB::PairCount, PMAPPING, PNONOPAQUE_MCB, _NONOPAQUE_MCB::PoolType, StartingLbn, UNUSED_LBN, and VBN. Referenced by FsRtlTruncateMcb(). : This routine truncates an Mcb structure to the specified Vbn. After calling this routine the Mcb will only contain mappings up to and not including the input vbn. Arguments: OpaqueMcb - Supplies a pointer to the Mcb structure to truncate. LargeVbn - Specifies the last Vbn at which is no longer to be mapped. Return Value: None. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; VBN Vbn = ((ULONG)LargeVbn); ULONG Index; PAGED_CODE(); DebugTrace(+1, Dbg, "FsRtlTruncateLargeMcb, Mcb = %08lx\n", Mcb ); ExAcquireFastMutex( Mcb->FastMutex ); ASSERTMSG("LargeInteger not supported yet ", ((((PLARGE_INTEGER)&LargeVbn)->HighPart == 0) || (Mcb->PairCount == 0) || ((((PLARGE_INTEGER)&LargeVbn)->HighPart == 0x7FFFFFFF) && (((ULONG)LargeVbn) == 0xFFFFFFFF)))); try { // // Do a quick test to see if we are truncating the entire Mcb. // if (Vbn == 0) { Mcb->PairCount = 0; } else if (Mcb->PairCount > 0) { // // Find the index for the entry with the last Vcn we want to keep. // There is nothing to do if the Mcb already ends prior to // this point. // if (FsRtlFindLargeIndex(Mcb, Vbn - 1, &Index)) { // // If this entry currently describes a hole then // truncate to the previous entry. // if (StartingLbn(Mcb, Index) == UNUSED_LBN) { Mcb->PairCount = Index; // // Otherwise we will truncate the Mcb to this point. Truncate // the number of Vbns of this run if necessary. // } else { Mcb->PairCount = Index + 1; if (NextStartingVbn(Mcb, Index) > Vbn) { (Mcb->Mapping)[Index].NextVbn = Vbn; } } } } // // Now see if we can shrink the allocation for the mapping pairs. // We'll shrink the mapping pair buffer if the new pair count will // fit within a quarter of the current maximum pair count and the // current maximum is greater than the initial pair count. // if ((Mcb->PairCount < (Mcb->MaximumPairCount / 4)) && (Mcb->MaximumPairCount > INITIAL_MAXIMUM_PAIR_COUNT)) { ULONG NewMax; PMAPPING Mapping; // // We need to allocate a new mapping so compute a new maximum pair // count. We'll allocate double the current pair count, but never // less than the initial pair count. // NewMax = Mcb->PairCount * 2; if (NewMax < INITIAL_MAXIMUM_PAIR_COUNT) { NewMax = INITIAL_MAXIMUM_PAIR_COUNT; } // // Be careful to trap failures due to resource exhaustion. // try { if (NewMax == INITIAL_MAXIMUM_PAIR_COUNT && Mcb->PoolType == PagedPool) { Mapping = FsRtlAllocateFirstMapping(); } else { Mapping = FsRtlpAllocatePool( Mcb->PoolType, sizeof(MAPPING) * NewMax ); } } except (EXCEPTION_EXECUTE_HANDLER) { Mapping = NULL; } // // Now check if we really got a new buffer // if (Mapping != NULL) { // // Now copy over the old mapping to the new buffer // RtlCopyMemory( Mapping, Mcb->Mapping, sizeof(MAPPING) * Mcb->PairCount ); // // Deallocate the old buffer. This should never be the size of an // initial mapping ... // ExFreePool( Mcb->Mapping ); // // And set up the new buffer in the Mcb // Mcb->Mapping = Mapping; Mcb->MaximumPairCount = NewMax; } } } finally { ExReleaseFastMutex( Mcb->FastMutex ); } // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlTruncateLargeMcb -> VOID\n", 0 ); return; }

NTKERNELAPI VOID FsRtlTruncateMcb (  IN PMCB  Mcb, IN VBN  Vbn )

Definition at line 361 of file largemcb.c. References FsRtlTruncateLargeMcb(), and PAGED_CODE. { PAGED_CODE(); FsRtlTruncateLargeMcb( (PLARGE_MCB)Mcb, (LONGLONG)(Vbn) ); return; }

NTKERNELAPI VOID FsRtlUninitializeFileLock (  IN PFILE_LOCK  FileLock  )

Definition at line 995 of file filelock.c. References _IRP::CancelIrql, _WAITING_LOCK::Context, Dbg, DebugTrace, _LOCK_QUEUE::ExclusiveLockTree, FsRtlAcquireLockQueue, FsRtlCompleteLockIrp, FsRtlFreeExclusiveLock(), FsRtlFreeLockInfo(), FsRtlFreeLockTreeNode(), FsRtlFreeSharedLock(), FsRtlFreeWaitingLock(), FsRtlReleaseLockQueue, IoAcquireCancelSpinLock(), IoReleaseCancelSpinLock(), IoSetCancelRoutine, _IRP::IoStatus, _WAITING_LOCK::Irp, Irp, _EX_LOCK::Links, _LOCKTREE_NODE::Links, _LOCK_INFO::LockQueue, _LOCKTREE_NODE::Locks, NTSTATUS(), NULL, PEX_LOCK, PLOCK_INFO, PLOCKTREE_NODE, PSH_LOCK, PWAITING_LOCK, RtlDeleteNoSplay(), _LOCK_QUEUE::SharedLockTree, and _LOCK_QUEUE::WaitingLocks. Referenced by FsRtlFreeFileLock(). : This routine uninitializes a FILE_LOCK structure. After calling this routine the File lock must be reinitialized before being used again. This routine will free all files locks and completes any outstanding lock requests as a result of cleaning itself up. Arguments: FileLock - Supplies a pointer to the FILE_LOCK struture being decommissioned. Return Value: None. --*/ { PLOCK_INFO LockInfo; PSH_LOCK ShLock; PEX_LOCK ExLock; PSINGLE_LIST_ENTRY Link; PWAITING_LOCK WaitingLock; PLOCKTREE_NODE LockTreeNode; PIRP Irp; NTSTATUS NewStatus; KIRQL OldIrql; PKPRCB Prcb; DebugTrace(+1, Dbg, "FsRtlUninitializeFileLock, FileLock = %08lx\n", FileLock); if ((LockInfo = (PLOCK_INFO) FileLock->LockInformation) == NULL) { return ; } // // Lock the queue // FsRtlAcquireLockQueue(&LockInfo->LockQueue, &OldIrql); // // Free lock trees // while (LockInfo->LockQueue.SharedLockTree != NULL) { LockTreeNode = CONTAINING_RECORD(LockInfo->LockQueue.SharedLockTree, LOCKTREE_NODE, Links); // // Remove all locks associated with the root node // while (LockTreeNode->Locks.Next != NULL) { Link = PopEntryList (&LockTreeNode->Locks); ShLock = CONTAINING_RECORD( Link, SH_LOCK, Link ); FsRtlFreeSharedLock(ShLock); } // // Slice off the root node of the tree // RtlDeleteNoSplay(&LockTreeNode->Links, &LockInfo->LockQueue.SharedLockTree); FsRtlFreeLockTreeNode(LockTreeNode); } while (LockInfo->LockQueue.ExclusiveLockTree != NULL) { ExLock = CONTAINING_RECORD(LockInfo->LockQueue.ExclusiveLockTree, EX_LOCK, Links); RtlDeleteNoSplay(&ExLock->Links, &LockInfo->LockQueue.ExclusiveLockTree); FsRtlFreeExclusiveLock(ExLock); } // // Free WaitingLockQueue // while (LockInfo->LockQueue.WaitingLocks.Next != NULL) { Link = PopEntryList( &LockInfo->LockQueue.WaitingLocks ); WaitingLock = CONTAINING_RECORD( Link, WAITING_LOCK, Link ); Irp = WaitingLock->Irp; // // To complete an irp in the waiting queue we need to // void the cancel routine (protected by a spinlock) before // we can complete the irp // FsRtlReleaseLockQueue (&LockInfo->LockQueue, OldIrql); IoAcquireCancelSpinLock( &Irp->CancelIrql ); IoSetCancelRoutine( Irp, NULL ); IoReleaseCancelSpinLock( Irp->CancelIrql ); Irp->IoStatus.Information = 0; FsRtlCompleteLockIrp( LockInfo, WaitingLock->Context, Irp, STATUS_RANGE_NOT_LOCKED, &NewStatus, NULL ); FsRtlAcquireLockQueue(&LockInfo->LockQueue, &OldIrql); FsRtlFreeWaitingLock( WaitingLock ); } // // Free pool used to track the lock info on this file // FsRtlReleaseLockQueue( &LockInfo->LockQueue, OldIrql ); FsRtlFreeLockInfo( LockInfo ); // // Unlink LockInfo from FileLock // FileLock->LockInformation = NULL; // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlUninitializeFileLock -> VOID\n", 0 ); return; }

NTKERNELAPI VOID FsRtlUninitializeLargeMcb (  IN PLARGE_MCB  Mcb  )

Definition at line 670 of file largemcb.c. References Dbg, DebugTrace, ExFreePool(), _NONOPAQUE_MCB::FastMutex, FsRtlFreeFastMutex, FsRtlFreeFirstMapping, INITIAL_MAXIMUM_PAIR_COUNT, _NONOPAQUE_MCB::Mapping, _NONOPAQUE_MCB::MaximumPairCount, NULL, PagedPool, PNONOPAQUE_MCB, and _NONOPAQUE_MCB::PoolType. Referenced by FsRtlUninitializeMcb(), UdfDeletePcb(), and UdfUninitializeFcbMcb(). : This routine uninitializes an Mcb structure. After calling this routine the input Mcb structure must be re-initialized before being used again. Arguments: OpaqueMcb - Supplies a pointer to the Mcb structure to uninitialize. Return Value: None. --*/ { PNONOPAQUE_MCB Mcb = (PNONOPAQUE_MCB)OpaqueMcb; DebugTrace(+1, Dbg, "FsRtlUninitializeLargeMcb, Mcb = %08lx\n", Mcb ); // // Protect against some user calling us to uninitialize an mcb twice // if (Mcb->FastMutex == NULL) { // ASSERTMSG("Being called to uninitialize an Mcb that is already Uninitialized ", FALSE); return; } // // Deallocate the FastMutex and mapping buffer // FsRtlFreeFastMutex( Mcb->FastMutex ); Mcb->FastMutex = NULL; if ((Mcb->PoolType == PagedPool) && (Mcb->MaximumPairCount == INITIAL_MAXIMUM_PAIR_COUNT)) { FsRtlFreeFirstMapping( Mcb->Mapping ); } else { ExFreePool( Mcb->Mapping ); } // // Now zero our all of the fields in the Mcb // //**** Mcb->MaximumPairCount = 0; //**** Mcb->PairCount = 0; //**** Mcb->Mapping = NULL; // // And return to our caller // DebugTrace(-1, Dbg, "FsRtlUninitializeLargeMcb -> VOID\n", 0 ); return; }

NTKERNELAPI VOID FsRtlUninitializeMcb (  IN PMCB  Mcb  )

Definition at line 348 of file largemcb.c. References FsRtlUninitializeLargeMcb(), and PAGED_CODE. Referenced by UdfInitializeVmcb(), and UdfUninitializeVmcb(). { PAGED_CODE(); FsRtlUninitializeLargeMcb( (PLARGE_MCB)Mcb ); return; }

NTKERNELAPI VOID FsRtlUninitializeOplock (  IN OUT POPLOCK  Oplock  )

Definition at line 413 of file oplock.c. References _IRP::CancelIrql, _WAITING_IRP::CompletionRoutine, _WAITING_IRP::Context, Dbg, DebugTrace, ExAcquireFastMutexUnsafe(), ExFreePool(), ExReleaseFastMutexUnsafe(), _NONOPAQUE_OPLOCK::FastMutex, _NONOPAQUE_OPLOCK::FileObject, FsRtlCompleteRequest, IoAcquireCancelSpinLock(), IoGetCurrentIrpStackLocation, IoReleaseCancelSpinLock(), IoSetCancelRoutine, _IRP::IoStatus, _WAITING_IRP::Irp, Irp, _NONOPAQUE_OPLOCK::IrpExclusiveOplock, _NONOPAQUE_OPLOCK::IrpOplocksII, NULL, ObDereferenceObject, PNONOPAQUE_OPLOCK, PWAITING_IRP, and _NONOPAQUE_OPLOCK::WaitingIrps. Referenced by UdfDeleteFcb(). : This routine uninitializes an OPLOCK structure. After calling this routine, the OPLOCK structure must be reinitialized before being used again. Arguments: Oplock - Supplies the address of an opaque OPLOCK structure. Return Value: None. --*/ { PNONOPAQUE_OPLOCK ThisOplock; DebugTrace(+1, Dbg, "FsRtlUninitializeOplock: Oplock -> %08lx\n", *Oplock ); // // If the Oplock structure has not been allocated, there is no action // to take. // if (*Oplock != NULL) { // // Remove this from the user's structure. // ThisOplock = (PNONOPAQUE_OPLOCK) *Oplock; *Oplock = NULL; // // Grab the waiting lock queue mutex to exclude anyone from messing // with the queue while we're using it // ExAcquireFastMutexUnsafe( ThisOplock->FastMutex ); try { PIRP Irp; // // Release any waiting Irps held. // while (!IsListEmpty( &ThisOplock->WaitingIrps )) { PWAITING_IRP WaitingIrp; PIRP ThisIrp; WaitingIrp = CONTAINING_RECORD( ThisOplock->WaitingIrps.Flink, WAITING_IRP, Links ); RemoveHeadList( &ThisOplock->WaitingIrps ); ThisIrp = WaitingIrp->Irp; IoAcquireCancelSpinLock( &ThisIrp->CancelIrql ); IoSetCancelRoutine( ThisIrp, NULL ); IoReleaseCancelSpinLock( ThisIrp->CancelIrql ); ThisIrp->IoStatus.Information = 0; // // Call the completion routine in the Waiting Irp. // WaitingIrp->CompletionRoutine( WaitingIrp->Context, WaitingIrp->Irp ); ExFreePool( WaitingIrp ); } // // Release any oplock II irps held. // while (!IsListEmpty( &ThisOplock->IrpOplocksII )) { Irp = CONTAINING_RECORD( ThisOplock->IrpOplocksII.Flink, IRP, Tail.Overlay.ListEntry ); RemoveHeadList( &ThisOplock->IrpOplocksII ); IoAcquireCancelSpinLock( &Irp->CancelIrql ); IoSetCancelRoutine( Irp, NULL ); IoReleaseCancelSpinLock( Irp->CancelIrql ); // // Complete the oplock II Irp. // ObDereferenceObject( IoGetCurrentIrpStackLocation( Irp )->FileObject ); Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; FsRtlCompleteRequest( Irp, STATUS_SUCCESS ); } // // Release any exclusive oplock held. // if (ThisOplock->IrpExclusiveOplock != NULL) { Irp = ThisOplock->IrpExclusiveOplock; IoAcquireCancelSpinLock( &Irp->CancelIrql ); IoSetCancelRoutine( Irp, NULL ); IoReleaseCancelSpinLock( Irp->CancelIrql ); Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; FsRtlCompleteRequest( Irp, STATUS_SUCCESS ); ThisOplock->IrpExclusiveOplock = NULL; if (ThisOplock->FileObject != NULL) { ObDereferenceObject( ThisOplock->FileObject ); } } } finally { // // No matter how we complete the preceding statements we will // now release the waiting lock queue mutex // ExReleaseFastMutexUnsafe( ThisOplock->FastMutex ); } // // Deallocate the mutex. // ExFreePool( ThisOplock->FastMutex ); // // Deallocate the Oplock structure. // ExFreePool( ThisOplock ); } DebugTrace( -1, Dbg, "FsRtlUninitializeOplock: Exit\n", 0 ); return; }

---

Variable Documentation

PUCHAR LEGAL_ANSI_CHARACTER_ARRAY

Definition at line 928 of file fsrtl.h.

PUSHORT NLS_OEM_LEAD_BYTE_INFO

Definition at line 929 of file fsrtl.h.

---