filelock.c File Reference

#include "FsRtlP.h"

Go to the source code of this file.

Classes
struct	_LOCKTREE_NODE
struct	_SH_LOCK
struct	_EX_LOCK
struct	_WAITING_LOCK
struct	_LOCK_QUEUE
struct	_LOCK_INFO
Defines
#define	Dbg   (0x20000000)
#define	INLINE   __inline
#define	TAG_EXCLUSIVE_LOCK   'xeLF'
#define	TAG_FILE_LOCK   'lfLF'
#define	TAG_LOCK_INFO   'ilLF'
#define	TAG_LOCKTREE_NODE   'nlLF'
#define	TAG_SHARED_LOCK   'hsLF'
#define	TAG_WAITING_LOCK   'lwLF'
#define	FsRtlAcquireLockQueue(a, b)   ExAcquireSpinLock(&(a)->QueueSpinLock, b);
#define	FsRtlReacquireLockQueue(a, b, c)   ExAcquireSpinLock(&(b)->QueueSpinLock, c);
#define	FsRtlReleaseLockQueue(a, b)   ExReleaseSpinLock(&(a)->QueueSpinLock, b);
#define	FsRtlCompleteLockIrp(A, B, C, D, E, F)
Typedefs
typedef _LOCKTREE_NODE	LOCKTREE_NODE
typedef _LOCKTREE_NODE *	PLOCKTREE_NODE
typedef _SH_LOCK	SH_LOCK
typedef _SH_LOCK *	PSH_LOCK
typedef _EX_LOCK	EX_LOCK
typedef _EX_LOCK *	PEX_LOCK
typedef _WAITING_LOCK	WAITING_LOCK
typedef _WAITING_LOCK *	PWAITING_LOCK
typedef _LOCK_QUEUE	LOCK_QUEUE
typedef _LOCK_QUEUE *	PLOCK_QUEUE
typedef _LOCK_INFO	LOCK_INFO
typedef _LOCK_INFO *	PLOCK_INFO
Functions
INLINE PSH_LOCK	FsRtlAllocateSharedLock (VOID)
INLINE PEX_LOCK	FsRtlAllocateExclusiveLock (VOID)
INLINE PWAITING_LOCK	FsRtlAllocateWaitingLock (VOID)
INLINE PLOCKTREE_NODE	FsRtlAllocateLockTreeNode (VOID)
INLINE PLOCK_INFO	FsRtlAllocateLockInfo (VOID)
INLINE VOID	FsRtlFreeSharedLock (IN PSH_LOCK C)
INLINE VOID	FsRtlFreeExclusiveLock (IN PEX_LOCK C)
INLINE VOID	FsRtlFreeWaitingLock (IN PWAITING_LOCK C)
INLINE VOID	FsRtlFreeLockTreeNode (IN PLOCKTREE_NODE C)
INLINE VOID	FsRtlFreeLockInfo (IN PLOCK_INFO C)
INLINE VOID	FsRtlCompleteLockIrpReal (IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine, IN PVOID Context, IN PIRP Irp, IN NTSTATUS Status, IN PNTSTATUS NewStatus, IN PFILE_OBJECT FileObject)
VOID	FsRtlSplitLocks (IN PLOCKTREE_NODE ParentNode, IN PSINGLE_LIST_ENTRY *pStartLink, IN PLARGE_INTEGER LastShadowedByte, IN PLARGE_INTEGER GlueOffset)
PRTL_SPLAY_LINKS	FsRtlFindFirstOverlappingSharedNode (IN PRTL_SPLAY_LINKS Tree, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER EndingByte, IN OUT PRTL_SPLAY_LINKS *LastEdgeNode, IN OUT PBOOLEAN GreaterThan)
PRTL_SPLAY_LINKS	FsRtlFindFirstOverlappingExclusiveNode (IN PRTL_SPLAY_LINKS Tree, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER EndingByte, IN OUT PRTL_SPLAY_LINKS *LastEdgeNode, IN OUT PBOOLEAN GreaterThan)
PSH_LOCK	FsRtlFindFirstOverlapInNode (IN PLOCKTREE_NODE Node, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER EndingByte)
BOOLEAN	FsRtlPrivateInsertLock (IN PLOCK_INFO LockInfo, IN PFILE_OBJECT FileObject, IN PFILE_LOCK_INFO FileLockInfo)
BOOLEAN	FsRtlPrivateInsertSharedLock (IN PLOCK_QUEUE LockQueue, IN PSH_LOCK NewLock)
VOID	FsRtlPrivateInsertExclusiveLock (IN PLOCK_QUEUE LockQueue, IN PEX_LOCK NewLock)
VOID	FsRtlPrivateCheckWaitingLocks (IN PLOCK_INFO LockInfo, IN PLOCK_QUEUE LockQueue, IN KIRQL OldIrql)
VOID	FsRtlPrivateCancelFileLockIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
BOOLEAN	FsRtlPrivateCheckForExclusiveLockAccess (IN PLOCK_QUEUE LockInfo, IN PFILE_LOCK_INFO FileLockInfo)
BOOLEAN	FsRtlPrivateCheckForSharedLockAccess (IN PLOCK_QUEUE LockInfo, IN PFILE_LOCK_INFO FileLockInfo)
NTSTATUS	FsRtlPrivateFastUnlockAll (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS ProcessId, IN ULONG Key, IN BOOLEAN MatchKey, IN PVOID Context OPTIONAL)
BOOLEAN	FsRtlPrivateInitializeFileLock (IN PFILE_LOCK FileLock, IN BOOLEAN ViaFastCall)
VOID	FsRtlPrivateRemoveLock (IN PLOCK_INFO LockInfo, IN PFILE_LOCK_INFO, IN BOOLEAN CheckForWaiters)
BOOLEAN	FsRtlCheckNoSharedConflict (IN PLOCK_QUEUE LockQueue, IN PLARGE_INTEGER Starting, IN PLARGE_INTEGER Ending)
BOOLEAN	FsRtlCheckNoExclusiveConflict (IN PLOCK_QUEUE LockQueue, IN PLARGE_INTEGER Starting, IN PLARGE_INTEGER Ending, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID ProcessId)
VOID	FsRtlPrivateResetLowestLockOffset (PLOCK_INFO LockInfo)
NTSTATUS	FsRtlFastUnlockSingleShared (IN PLOCK_INFO LockInfo, 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 IgnoreUnlockRoutine, IN BOOLEAN CheckForWaiters)
NTSTATUS	FsRtlFastUnlockSingleExclusive (IN PLOCK_INFO LockInfo, 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 IgnoreUnlockRoutine, IN BOOLEAN CheckForWaiters)
VOID	FsRtlInitializeFileLocks (VOID)
VOID	FsRtlInitializeFileLock (IN PFILE_LOCK FileLock, IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL)
VOID	FsRtlUninitializeFileLock (IN PFILE_LOCK FileLock)
PFILE_LOCK	FsRtlAllocateFileLock (IN PCOMPLETE_LOCK_IRP_ROUTINE CompleteLockIrpRoutine OPTIONAL, IN PUNLOCK_ROUTINE UnlockRoutine OPTIONAL)
VOID	FsRtlFreeFileLock (IN PFILE_LOCK FileLock)
NTSTATUS	FsRtlProcessFileLock (IN PFILE_LOCK FileLock, IN PIRP Irp, IN PVOID Context OPTIONAL)
BOOLEAN	FsRtlCheckLockForReadAccess (IN PFILE_LOCK FileLock, IN PIRP Irp)
BOOLEAN	FsRtlCheckLockForWriteAccess (IN PFILE_LOCK FileLock, IN PIRP Irp)
PFILE_LOCK_INFO	FsRtlGetNextFileLock (IN PFILE_LOCK FileLock, IN BOOLEAN Restart)
BOOLEAN	FsRtlFastCheckLockForRead (IN PFILE_LOCK FileLock, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER Length, IN ULONG Key, IN PFILE_OBJECT FileObject, IN PVOID ProcessId)
BOOLEAN	FsRtlFastCheckLockForWrite (IN PFILE_LOCK FileLock, IN PLARGE_INTEGER StartingByte, IN PLARGE_INTEGER Length, IN ULONG Key, IN PVOID FileObject, IN PVOID ProcessId)
VOID	FsRtlSplitLocks (IN PLOCKTREE_NODE ParentNode, IN PSINGLE_LIST_ENTRY *pStartLink OPTIONAL, IN PLARGE_INTEGER LastShadowedByte OPTIONAL, IN PLARGE_INTEGER GlueOffset OPTIONAL)
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)
NTSTATUS	FsRtlFastUnlockAll (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS ProcessId, IN PVOID Context OPTIONAL)
NTSTATUS	FsRtlFastUnlockAllByKey (IN PFILE_LOCK FileLock, IN PFILE_OBJECT FileObject, IN PEPROCESS ProcessId, IN ULONG Key, IN PVOID Context OPTIONAL)
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 OPTIONAL, IN PVOID Context, IN BOOLEAN AlreadySynchronized)
Variables
FAST_MUTEX	FsRtlCreateLockInfo
NPAGED_LOOKASIDE_LIST	FsRtlSharedLockLookasideList
NPAGED_LOOKASIDE_LIST	FsRtlExclusiveLockLookasideList
NPAGED_LOOKASIDE_LIST	FsRtlWaitingLockLookasideList
NPAGED_LOOKASIDE_LIST	FsRtlLockTreeNodeLookasideList
NPAGED_LOOKASIDE_LIST	FsRtlLockInfoLookasideList
PAGED_LOOKASIDE_LIST	FsRtlFileLockLookasideList

---

Define Documentation

#define Dbg   (0x20000000)

Definition at line 94 of file filelock.c.

#define FsRtlAcquireLockQueue (  a, b   )     ExAcquireSpinLock(&(a)->QueueSpinLock, b);

Definition at line 481 of file filelock.c. Referenced by FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), FsRtlGetNextFileLock(), FsRtlPrivateLock(), and FsRtlUninitializeFileLock().

#define FsRtlCompleteLockIrp (  A, B, C, D, E, F   )

Value: FsRtlCompleteLockIrpReal( (A)->CompleteLockIrpRoutine, \ B, \ C, \ D, \ E, \ F ) Definition at line 497 of file filelock.c. Referenced by FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateLock(), FsRtlProcessFileLock(), and FsRtlUninitializeFileLock().

#define FsRtlReacquireLockQueue (  a, b, c   )     ExAcquireSpinLock(&(b)->QueueSpinLock, c);

Definition at line 484 of file filelock.c. Referenced by FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckWaitingLocks(), and FsRtlPrivateFastUnlockAll().

#define FsRtlReleaseLockQueue (  a, b   )     ExReleaseSpinLock(&(a)->QueueSpinLock, b);

Definition at line 487 of file filelock.c. Referenced by FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), FsRtlGetNextFileLock(), FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateLock(), and FsRtlUninitializeFileLock().

#define INLINE   __inline

Definition at line 101 of file filelock.c.

#define TAG_EXCLUSIVE_LOCK   'xeLF'

Definition at line 104 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

#define TAG_FILE_LOCK   'lfLF'

Definition at line 105 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

#define TAG_LOCK_INFO   'ilLF'

Definition at line 106 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

#define TAG_LOCKTREE_NODE   'nlLF'

Definition at line 107 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

#define TAG_SHARED_LOCK   'hsLF'

Definition at line 108 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

#define TAG_WAITING_LOCK   'lwLF'

Definition at line 109 of file filelock.c. Referenced by FsRtlInitializeFileLocks().

---

Typedef Documentation

typedef struct _EX_LOCK EX_LOCK

typedef struct _LOCK_INFO LOCK_INFO

typedef struct _LOCK_QUEUE LOCK_QUEUE

typedef struct _LOCKTREE_NODE LOCKTREE_NODE

typedef struct _EX_LOCK * PEX_LOCK

Referenced by FsRtlAllocateExclusiveLock(), FsRtlCheckNoExclusiveConflict(), FsRtlFastUnlockSingleExclusive(), FsRtlFindFirstOverlappingExclusiveNode(), FsRtlGetNextFileLock(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateCheckForSharedLockAccess(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateInsertLock(), FsRtlPrivateResetLowestLockOffset(), and FsRtlUninitializeFileLock().

typedef struct _LOCK_INFO * PLOCK_INFO

Referenced by FsRtlAllocateLockInfo(), FsRtlCheckLockForReadAccess(), FsRtlCheckLockForWriteAccess(), FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), FsRtlGetNextFileLock(), FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateInitializeFileLock(), FsRtlPrivateLock(), and FsRtlUninitializeFileLock().

typedef struct _LOCK_QUEUE * PLOCK_QUEUE

Referenced by FsRtlFastCheckLockForRead(), FsRtlFastCheckLockForWrite(), FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateFastUnlockAll(), and FsRtlPrivateLock().

typedef struct _LOCKTREE_NODE * PLOCKTREE_NODE

Referenced by FsRtlAllocateLockTreeNode(), FsRtlCheckNoSharedConflict(), FsRtlFastUnlockSingleShared(), FsRtlFindFirstOverlappingSharedNode(), FsRtlGetNextFileLock(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateInsertSharedLock(), FsRtlPrivateResetLowestLockOffset(), FsRtlSplitLocks(), and FsRtlUninitializeFileLock().

typedef struct _SH_LOCK * PSH_LOCK

Referenced by FsRtlAllocateSharedLock(), FsRtlFastUnlockSingleShared(), FsRtlFindFirstOverlapInNode(), FsRtlFindFirstOverlappingSharedNode(), FsRtlGetNextFileLock(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateInsertLock(), FsRtlPrivateInsertSharedLock(), FsRtlPrivateResetLowestLockOffset(), FsRtlSplitLocks(), and FsRtlUninitializeFileLock().

typedef struct _WAITING_LOCK * PWAITING_LOCK

Referenced by FsRtlAllocateWaitingLock(), FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateLock(), and FsRtlUninitializeFileLock().

typedef struct _SH_LOCK SH_LOCK

typedef struct _WAITING_LOCK WAITING_LOCK

---

Function Documentation

INLINE PEX_LOCK FsRtlAllocateExclusiveLock (  VOID   )

Definition at line 400 of file filelock.c. References ExAllocateFromNPagedLookasideList(), FsRtlExclusiveLockLookasideList, and PEX_LOCK. Referenced by FsRtlPrivateInsertLock(). { return (PEX_LOCK) ExAllocateFromNPagedLookasideList( &FsRtlExclusiveLockLookasideList ); }

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; }

INLINE PLOCK_INFO FsRtlAllocateLockInfo (  VOID   )

Definition at line 427 of file filelock.c. References ExAllocateFromNPagedLookasideList(), FsRtlLockInfoLookasideList, and PLOCK_INFO. Referenced by FsRtlPrivateInitializeFileLock(). { return (PLOCK_INFO) ExAllocateFromNPagedLookasideList( &FsRtlLockInfoLookasideList ); }

INLINE PLOCKTREE_NODE FsRtlAllocateLockTreeNode (  VOID   )

Definition at line 418 of file filelock.c. References ExAllocateFromNPagedLookasideList(), FsRtlLockTreeNodeLookasideList, and PLOCKTREE_NODE. Referenced by FsRtlPrivateInsertSharedLock(), and FsRtlSplitLocks(). { return (PLOCKTREE_NODE) ExAllocateFromNPagedLookasideList( &FsRtlLockTreeNodeLookasideList ); }

INLINE PSH_LOCK FsRtlAllocateSharedLock (  VOID   )

Definition at line 391 of file filelock.c. References ExAllocateFromNPagedLookasideList(), FsRtlSharedLockLookasideList, and PSH_LOCK. Referenced by FsRtlPrivateInsertLock(). { return (PSH_LOCK) ExAllocateFromNPagedLookasideList( &FsRtlSharedLockLookasideList ); }

INLINE PWAITING_LOCK FsRtlAllocateWaitingLock (  VOID   )

Definition at line 409 of file filelock.c. References ExAllocateFromNPagedLookasideList(), FsRtlWaitingLockLookasideList, and PWAITING_LOCK. Referenced by FsRtlPrivateLock(). { return (PWAITING_LOCK) ExAllocateFromNPagedLookasideList( &FsRtlWaitingLockLookasideList ); }

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; }

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; }

BOOLEAN FsRtlCheckNoExclusiveConflict (  IN PLOCK_QUEUE  LockQueue, IN PLARGE_INTEGER  Starting, IN PLARGE_INTEGER  Ending, IN ULONG  Key, IN PFILE_OBJECT  FileObject, IN PVOID  ProcessId )

Definition at line 2469 of file filelock.c. References Dbg, DebugTrace, FALSE, FsRtlFindFirstOverlappingExclusiveNode(), Key, Lock, NULL, PEX_LOCK, RtlRealSuccessor(), RtlSplay(), Status, and TRUE. Referenced by FsRtlFastCheckLockForRead(), and FsRtlFastCheckLockForWrite(). : This routine checks to see if there is conflict in the exclusive locks with a given range and identifying tuple of key, fileobject and process. This is for part of the read access path. 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 key 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 doesn't conflict in entire specified byte range, and FALSE otherwise --*/ { PRTL_SPLAY_LINKS SplayLinks, BeginLinks; PEX_LOCK Lock; BOOLEAN Status = TRUE; // // Find the node to begin the search at and go // for (SplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockQueue->ExclusiveLockTree, Starting, Ending, &BeginLinks, NULL); SplayLinks; SplayLinks = RtlRealSuccessor(SplayLinks)) { Lock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); // // If the current lock is greater than the end of the range we're // looking for then the the user doesn't conflict // // if (Ending < Lock->StartingByte) ... // if ((ULONGLONG)Ending->QuadPart < (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart) { DebugTrace(0, Dbg, "FsRtlCheckForExclusiveConflict, Ending < Lock->StartingByte\n", 0); break; } // // Check for any overlap with the request. The test for // overlap is that starting byte is less than or equal to the locks // ending byte, and the ending byte is greater than or equal to the // locks starting byte. We already tested for this latter case in // the preceding statement. // // if (Starting <= Lock->StartingByte + Lock->Length - 1) ... // if ((ULONGLONG)Starting->QuadPart <= (ULONGLONG)Lock->LockInfo.EndingByte.QuadPart) { // // This request overlaps the lock. We cannot grant the request // if the file object, process id, and key do not match. Otherwise // we'll continue looping looking at locks // if ((Lock->LockInfo.FileObject != FileObject) || (Lock->LockInfo.ProcessId != ProcessId) || (Lock->LockInfo.Key != Key)) { DebugTrace(0, Dbg, "FsRtlCheckForExclusiveConflict, Range locked already\n", 0); Status = FALSE; break; } } } if (BeginLinks) { LockQueue->ExclusiveLockTree = RtlSplay(BeginLinks); } // // We searched the entire range without a conflict so we'll note no conflict // return Status; }

BOOLEAN FsRtlCheckNoSharedConflict (  IN PLOCK_QUEUE  LockQueue, IN PLARGE_INTEGER  Starting, IN PLARGE_INTEGER  Ending )

Definition at line 2392 of file filelock.c. References FALSE, FsRtlFindFirstOverlapInNode(), FsRtlFindFirstOverlappingSharedNode(), _LOCKTREE_NODE::HoleyNode, NULL, PLOCKTREE_NODE, RtlSplay(), and TRUE. Referenced by FsRtlFastCheckLockForWrite(). : This routine checks to see if there is overlap in the shared locks with the given range. It is intended for use in the write access check path so that a rebalance will occur. 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 key 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 doesn't conflict in entire specified byte range, and FALSE otherwise --*/ { PRTL_SPLAY_LINKS SplayLinks, BeginLinks; PLOCKTREE_NODE Node; SplayLinks = FsRtlFindFirstOverlappingSharedNode( LockQueue->SharedLockTree, Starting, Ending, &BeginLinks, NULL); if (BeginLinks) { LockQueue->SharedLockTree = RtlSplay(BeginLinks); } // // If this node is holey, we'll have to walk the whole thing. // if (SplayLinks) { Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); if (Node->HoleyNode) { return (BOOLEAN)(FsRtlFindFirstOverlapInNode( Node, Starting, Ending ) == NULL); } // // Overlapping non-holey node, so we do have shared lock conflict. // return FALSE; } // // No node overlaps. // return TRUE; }

INLINE VOID FsRtlCompleteLockIrpReal (  IN PCOMPLETE_LOCK_IRP_ROUTINE  CompleteLockIrpRoutine, IN PVOID  Context, IN PIRP  Irp, IN NTSTATUS  Status, IN PNTSTATUS  NewStatus, IN PFILE_OBJECT  FileObject )

Definition at line 507 of file filelock.c. References FsRtlCompleteRequest, _IRP::IoStatus, Irp, NTSTATUS(), NULL, PCOMPLETE_LOCK_IRP_ROUTINE, and Status. { // // This fools the compiler into generating the Status only once // if it is calculated from an expression. // NTSTATUS LocalStatus = Status; if (CompleteLockIrpRoutine != NULL) { if (FileObject != NULL) { FileObject->LastLock = NULL; } Irp->IoStatus.Status = LocalStatus; *NewStatus = CompleteLockIrpRoutine( Context, Irp ); } else { FsRtlCompleteRequest( Irp, LocalStatus ); *NewStatus = LocalStatus; } }

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, _FILE_LOCK_INFO::Key, 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; }

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, _FILE_LOCK_INFO::Key, 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; }

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 ); }

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 ); }

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; }

NTSTATUS FsRtlFastUnlockSingleExclusive (  IN PLOCK_INFO  LockInfo, 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  IgnoreUnlockRoutine, IN BOOLEAN  CheckForWaiters )

Definition at line 3589 of file filelock.c. References Dbg, DebugTrace, _LOCK_QUEUE::ExclusiveLockTree, FsRtlAcquireLockQueue, FsRtlFindFirstOverlappingExclusiveNode(), FsRtlFreeExclusiveLock(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateResetLowestLockOffset(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, Key, Lock, NULL, PEX_LOCK, PLOCK_QUEUE, RtlDelete(), RtlRealSuccessor(), and _LOCK_QUEUE::WaitingLocks. Referenced by FsRtlFastUnlockSingle(), and FsRtlPrivateRemoveLock(). : This routine performs an Unlock Single operation on the exclusive locks associated with the specified lock data. Only the lock with a matching file object, process id, key, and range is freed. Arguments: LockInfo - Supplies the lock data being operated on 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 IgnoreUnlockRoutine - inidicates that the filelock's unlock routine should not be called on lock removal (for removal of aborted locks) CheckForWaiters - If true check for possible waiting locks, caused by freeing the locked range Return Value: NTSTATUS - The completion status for this operation --*/ { KIRQL OldIrql; PLOCK_QUEUE LockQueue; PRTL_SPLAY_LINKS SplayLinks; LARGE_INTEGER EndingOffset; PEX_LOCK Lock; LARGE_INTEGER AlignedFileOffset; // // General case - search the outstanding lock queue for this lock // AlignedFileOffset = *FileOffset; LockQueue = &LockInfo->LockQueue; FsRtlAcquireLockQueue(LockQueue, &OldIrql); // // Check for the no locks currently held // if (LockQueue->ExclusiveLockTree == NULL) { FsRtlReleaseLockQueue( LockQueue, OldIrql ); return STATUS_RANGE_NOT_LOCKED; } // // Find the overlapping lock, if it exists. Note that this is usually // the only lock we need to check since we are assuming this is an // existing lock. However, if the lock is a zero length lock we will // have a run of locks to check. // EndingOffset.QuadPart = (ULONGLONG)AlignedFileOffset.QuadPart + (ULONGLONG)Length->QuadPart - 1; for (SplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockQueue->ExclusiveLockTree, &AlignedFileOffset, &EndingOffset, NULL, NULL ); SplayLinks; SplayLinks = RtlRealSuccessor(SplayLinks)) { Lock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); if ((Lock->LockInfo.FileObject == FileObject) && (Lock->LockInfo.ProcessId == ProcessId) && (Lock->LockInfo.Key == Key) && ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart == (ULONGLONG)AlignedFileOffset.QuadPart) && ((ULONGLONG)Lock->LockInfo.Length.QuadPart == (ULONGLONG)Length->QuadPart)) { DebugTrace(0, Dbg, "Ex Found one to unlock\n", 0); // // We have an exact match so now is the time to delete this // lock. Remove the lock from the list, then call the // optional unlock routine, then delete the lock. // if (FileObject->LastLock == &Lock->LockInfo) { FileObject->LastLock = NULL; } // // Snip the deleted lock // LockQueue->ExclusiveLockTree = RtlDelete(&Lock->Links); if (LockInfo->LowestLockOffset != 0xffffffff && LockInfo->LowestLockOffset == Lock->LockInfo.StartingByte.LowPart) { // // This was the lowest lock in the tree, so reset the lowest lock // offset // FsRtlPrivateResetLowestLockOffset(LockInfo); } if (!IgnoreUnlockRoutine && LockInfo->UnlockRoutine != NULL) { FsRtlReleaseLockQueue( LockQueue, OldIrql ); LockInfo->UnlockRoutine( Context, &Lock->LockInfo ); FsRtlReacquireLockQueue( LockInfo, LockQueue, &OldIrql ); } FsRtlFreeExclusiveLock( Lock ); // // See if there are additional waiting locks that we can // now release. // if (CheckForWaiters && LockQueue->WaitingLocks.Next) { FsRtlPrivateCheckWaitingLocks( LockInfo, LockQueue, OldIrql ); } FsRtlReleaseLockQueue( LockQueue, OldIrql ); return STATUS_SUCCESS; } if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)AlignedFileOffset.QuadPart) { // // The current lock begins at a byte offset greater than the range we are seeking // to unlock. This range must therefore not be locked. // break; } } // // Lock was not found, return to our caller // FsRtlReleaseLockQueue(LockQueue, OldIrql); return STATUS_RANGE_NOT_LOCKED; }

NTSTATUS FsRtlFastUnlockSingleShared (  IN PLOCK_INFO  LockInfo, 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  IgnoreUnlockRoutine, IN BOOLEAN  CheckForWaiters )

Definition at line 3337 of file filelock.c. References Dbg, DebugTrace, FsRtlAcquireLockQueue, FsRtlFindFirstOverlappingSharedNode(), FsRtlFreeLockTreeNode(), FsRtlFreeSharedLock(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateResetLowestLockOffset(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, FsRtlSplitLocks(), Key, Lock, _LOCKTREE_NODE::Locks, NULL, PLOCK_QUEUE, PLOCKTREE_NODE, PSH_LOCK, RtlDelete(), _LOCK_QUEUE::SharedLockTree, _LOCKTREE_NODE::Tail, and _LOCK_QUEUE::WaitingLocks. Referenced by FsRtlFastUnlockSingle(), and FsRtlPrivateRemoveLock(). : 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: LockInfo - Supplies the lock data being operated on 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 IgnoreUnlockRoutine - inidicates that the filelock's unlock routine should not be called on lock removal (for removal of aborted locks) CheckForWaiters - If true check for possible waiting locks, caused by freeing the locked range Return Value: NTSTATUS - The completion status for this operation --*/ { PSINGLE_LIST_ENTRY *pLink, Link; KIRQL OldIrql; PLOCK_QUEUE LockQueue; PRTL_SPLAY_LINKS SplayLinks; LARGE_INTEGER EndingOffset, MaxOffset; PLOCKTREE_NODE Node; LARGE_INTEGER AlignedFileOffset; // // General case - search the outstanding lock queue for this lock // AlignedFileOffset = *FileOffset; LockQueue = &LockInfo->LockQueue; FsRtlAcquireLockQueue(LockQueue, &OldIrql); // // Check for the no locks currently held // if (LockQueue->SharedLockTree == NULL) { FsRtlReleaseLockQueue( LockQueue, OldIrql ); return STATUS_RANGE_NOT_LOCKED; } // // Find the overlapping node, if it exists, to search. Note that // we don't have to go through more than one node in the tree // since we are assuming this is an existing lock. // EndingOffset.QuadPart = (ULONGLONG)AlignedFileOffset.QuadPart + (ULONGLONG)Length->QuadPart - 1; SplayLinks = FsRtlFindFirstOverlappingSharedNode( LockQueue->SharedLockTree, &AlignedFileOffset, &EndingOffset, NULL, NULL ); if (SplayLinks == NULL) { // // No node in the tree overlaps this range, so we're done // FsRtlReleaseLockQueue(LockQueue, OldIrql); return STATUS_RANGE_NOT_LOCKED; } Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); MaxOffset.QuadPart = 0; for (pLink = &Node->Locks.Next; (Link = *pLink) != NULL; pLink = &Link->Next) { PSH_LOCK Lock; Lock = CONTAINING_RECORD( Link, SH_LOCK, Link ); DebugTrace(0, Dbg, "Sh Top of Loop, Lock = %08lx\n", Lock ); if ((Lock->LockInfo.FileObject == FileObject) && (Lock->LockInfo.ProcessId == ProcessId) && (Lock->LockInfo.Key == Key) && ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart == (ULONGLONG)AlignedFileOffset.QuadPart) && ((ULONGLONG)Lock->LockInfo.Length.QuadPart == (ULONGLONG)Length->QuadPart)) { DebugTrace(0, Dbg, "Sh Found one to unlock\n", 0); // // We have an exact match so now is the time to delete this // lock. Remove the lock from the list, then call the // optional unlock routine, then delete the lock. // if (FileObject->LastLock == &Lock->LockInfo) { FileObject->LastLock = NULL; } if (*pLink == Node->Tail.Next) { // // Deleting the tail node of the list. Safe even if deleting the // first node since this implies we're also deleting the last node // in the node which means we'll delete the node ... // Node->Tail.Next = CONTAINING_RECORD( pLink, SINGLE_LIST_ENTRY, Next ); } // // Snip the deleted lock // *pLink = Link->Next; if (pLink == &Node->Locks.Next) { // // Deleted first lock in node // if (Node->Locks.Next == NULL) { // // Just deleted last lock on this node, so free it // LockQueue->SharedLockTree = RtlDelete(SplayLinks); FsRtlFreeLockTreeNode(Node); Node = NULL; } if (LockInfo->LowestLockOffset != 0xffffffff && LockInfo->LowestLockOffset == Lock->LockInfo.StartingByte.LowPart) { // // This was the lowest lock in the trees, reset the lowest lock offset // FsRtlPrivateResetLowestLockOffset(LockInfo); } } // // Now the fun begins. It may be the case that the lock just snipped from // the chain was gluing locks at this node together, so we need to // inspect the chain. // if (Node) { FsRtlSplitLocks(Node, pLink, &Lock->LockInfo.EndingByte, &MaxOffset); } if (!IgnoreUnlockRoutine && LockInfo->UnlockRoutine != NULL) { FsRtlReleaseLockQueue( LockQueue, OldIrql ); LockInfo->UnlockRoutine( Context, &Lock->LockInfo ); FsRtlReacquireLockQueue( LockInfo, LockQueue, &OldIrql ); } FsRtlFreeSharedLock( Lock ); // // See if there are additional waiting locks that we can // now release. // if (CheckForWaiters && LockQueue->WaitingLocks.Next) { FsRtlPrivateCheckWaitingLocks( LockInfo, LockQueue, OldIrql ); } FsRtlReleaseLockQueue( LockQueue, OldIrql ); return STATUS_SUCCESS; } if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)AlignedFileOffset.QuadPart) { // // The current lock begins at a byte offset greater than the range we are seeking // to unlock. This range must therefore not be locked. // break; } if ((ULONGLONG)MaxOffset.QuadPart < (ULONGLONG)Lock->LockInfo.EndingByte.QuadPart) { // // Maintain the maximum offset affected by locks up to this point. // MaxOffset.QuadPart = Lock->LockInfo.EndingByte.QuadPart; } } // // Lock was not found, return to our caller // FsRtlReleaseLockQueue(LockQueue, OldIrql); return STATUS_RANGE_NOT_LOCKED; }

PSH_LOCK FsRtlFindFirstOverlapInNode (  IN PLOCKTREE_NODE  Node, IN PLARGE_INTEGER  StartingByte, IN PLARGE_INTEGER  EndingByte )

Definition at line 1856 of file filelock.c. References ASSERT, FALSE, Lock, NULL, and PSH_LOCK. Referenced by FsRtlCheckNoSharedConflict(), and FsRtlPrivateCheckForExclusiveLockAccess(). : This routine examines a shared lock node, usually a node which is known to be composed of several non-overlapping lock segments (holey), for true overlap with the indicated range. This is not handled in the normal overlap check (..FindFirstOverlappingSharedLock) since the needs for holey checks are rather different than the full node check. Arguments: Node - the lock tree node to be examined for overlap StartingByte - supplies the first byte offset of the range to check EndingByte - supplies the last byte offset of the range to check Return Value: PSH_LOCK - the first lock which overlaps with the specified range. --*/ { PSH_LOCK Lock; PSINGLE_LIST_ENTRY Link; for (Link = Node->Locks.Next; Link; Link = Link->Next) { Lock = CONTAINING_RECORD( Link, SH_LOCK, Link ); // // Logic is the same as above checkers. If the ending byte of the lock is less than the // starting byte of the range, OR we have the weird [0, 0) case, then the lock is almost // certainly less than the range. // if ((ULONGLONG)Lock->LockInfo.EndingByte.QuadPart < (ULONGLONG)StartingByte->QuadPart || (Lock->LockInfo.StartingByte.QuadPart == 0 && Lock->LockInfo.Length.QuadPart == 0)) { // // ... except if the lock and range are equivalent, in which case we have discovered // zero lock/range overlap. // if ((ULONGLONG)Lock->LockInfo.EndingByte.QuadPart == (ULONGLONG)EndingByte->QuadPart && (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart == (ULONGLONG)StartingByte->QuadPart) { return Lock; } // // Look forward in the node. // continue; } // // No overlap at all if the lock begins at a higher byte than the last of the range. // We already covered zero length locks (where this is true, and overlap could still // occur). // if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)EndingByte->QuadPart) { return NULL; } // // Regular overlap has occured. Return this lock. // return Lock; } // // If we invoke this check and wander off the end of the node without determining what is // going on, something is terribly wrong. // ASSERT( FALSE ); return NULL; }

PRTL_SPLAY_LINKS FsRtlFindFirstOverlappingExclusiveNode (  IN PRTL_SPLAY_LINKS  Tree, IN PLARGE_INTEGER  StartingByte, IN PLARGE_INTEGER  EndingByte, IN OUT PRTL_SPLAY_LINKS *  LastEdgeNode, IN OUT PBOOLEAN  GreaterThan )

Definition at line 1687 of file filelock.c. References FALSE, GreaterThan, Lock, NULL, PEX_LOCK, and TRUE. Referenced by FsRtlCheckNoExclusiveConflict(), FsRtlFastUnlockSingleExclusive(), FsRtlGetNextFileLock(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateCheckForSharedLockAccess(), and FsRtlPrivateInsertExclusiveLock(). : This routine returns the first node in the exclusive lock tree which overlaps with the range given. No nodes given by RtlRealPredecessor() on the result overlap the range. Arguments: Tree - supplies the splay links of the root node of the exclusive tree to search StartingByte - supplies the first byte offset of the range to check EndingByte - supplies the last byte offset of the range to check LastEdgeNode - optional, will be set to the last node searched not including returned node (presumeably where a new node will be inserted if return is NULL). GreaterThan - optional, set according to whether LastEdgeNode is covering a range greater than the queried range. !GreaterThan == LessThan, since we would have returned this node in the "Equals" (overlap) case. Return Value: The splay links of the node, if such a node exists, NULL otherwise --*/ { PRTL_SPLAY_LINKS SplayLinks; PEX_LOCK Lock, LastOverlapNode; if (LastEdgeNode) *LastEdgeNode = NULL; if (GreaterThan) *GreaterThan = FALSE; LastOverlapNode = NULL; SplayLinks = Tree; while (SplayLinks) { Lock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); // // We may have to go right in the tree if this lock covers a range before the start of this // range we are looking for overlap on or this lock is [0, 0). This is important since a lock // on [0, 0) will look like the extent is from [0, ~0], which is the only case where the zero // length lock relation of End < Start does not hold. // if ((ULONGLONG)Lock->LockInfo.EndingByte.QuadPart < (ULONGLONG)StartingByte->QuadPart || (Lock->LockInfo.StartingByte.QuadPart == 0 && Lock->LockInfo.Length.QuadPart == 0)) { if ((ULONGLONG)Lock->LockInfo.EndingByte.QuadPart == (ULONGLONG)EndingByte->QuadPart && (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart == (ULONGLONG)StartingByte->QuadPart) { // // The extent of the lock is less than the starting position of the // range we are checking and the lock is equal to the range, which // implies that the range and the lock are zero length. // // This is a zero length lock node and we are searching for zero // length overlap. Since the exclusive tree is one lock per node, // we are in the potential middle of a run of zero length locks in // the tree. Go left to find the first zero length lock. // // This is actually the same logic we'd use for equivalent locks, // but the only time that can happen in this tree is for zero length // locks. // LastOverlapNode = Lock; if (LastEdgeNode) *LastEdgeNode = SplayLinks; if (GreaterThan) *GreaterThan = FALSE; SplayLinks = RtlLeftChild(SplayLinks); continue; } // // This lock is strictly less than this byterange, so go // right in the tree. // if (LastEdgeNode) *LastEdgeNode = SplayLinks; if (GreaterThan) *GreaterThan = FALSE; SplayLinks = RtlRightChild(SplayLinks); continue; } if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart <= (ULONGLONG)EndingByte->QuadPart) { // // We have an overlap, but we need to see if the byterange starts // before this node so that there is the guarantee that we start // the search at the correct point. There may be still be predecessor // nodes covering the byterange. // if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart <= (ULONGLONG)StartingByte->QuadPart) { // // This node begins at a byte offset prior to the byterange we // are checking, so it must be the correct starting position. // break; } // // Drop a marker at this node so that we can come back if it turns out // that the left subtree does not cover the range of bytes before this // node in the byterange. // LastOverlapNode = Lock; } // // It must now be the case this lock is strictly greater than the byterange, // or we have the candidate overlap case above, so go left in the tree. // if (LastEdgeNode) *LastEdgeNode = SplayLinks; if (GreaterThan) *GreaterThan = TRUE; SplayLinks = RtlLeftChild(SplayLinks); } if (SplayLinks == NULL) { // // We hit the edge of the tree. If the LastOverlapNode is set, it means that // we had kept searching left in the tree for a node that covered the starting // byte of the byterange, but didn't find it. If it isn't set, we'll do the // right thing anyway since Node <- NULL. // Lock = LastOverlapNode; } if (Lock == NULL) { // // No overlapping lock existed // return NULL; } // // Return the splay links of the first overlapping lock // return &Lock->Links; }

PRTL_SPLAY_LINKS FsRtlFindFirstOverlappingSharedNode (  IN PRTL_SPLAY_LINKS  Tree, IN PLARGE_INTEGER  StartingByte, IN PLARGE_INTEGER  EndingByte, IN OUT PRTL_SPLAY_LINKS *  LastEdgeNode, IN OUT PBOOLEAN  GreaterThan )

Definition at line 1517 of file filelock.c. References _LOCKTREE_NODE::Extent, FALSE, GreaterThan, _LOCKTREE_NODE::Links, Lock, _LOCKTREE_NODE::Locks, NULL, PLOCKTREE_NODE, PSH_LOCK, and TRUE. Referenced by FsRtlCheckNoSharedConflict(), FsRtlFastUnlockSingleShared(), FsRtlGetNextFileLock(), FsRtlPrivateCheckForExclusiveLockAccess(), and FsRtlPrivateInsertSharedLock(). : This routine returns the first node in the shared lock tree which overlaps with the range given. No nodes given by RtlRealPredecessor() on the result overlap the range. Arguments: Tree - supplies the splay links of the root node of the shared tree to search StartingByte - supplies the first byte offset of the range to check EndingByte - supplies the last byte offset of the range to check LastEdgeNode - optional, will be set to the last node searched in the not including returned node (presumeably where a new node will be inserted if return is NULL). GreaterThan - optional, set according to whether LastEdgeNode is covering a range greater than the queried range. !GreaterThan == LessThan, since we would have returned this node in the "Equals" (overlap) case. Return Value: The splay links of the node, if such a node exists, NULL otherwise --*/ { PLOCKTREE_NODE Node, LastOverlapNode; PRTL_SPLAY_LINKS SplayLinks; PSH_LOCK Lock; if (LastEdgeNode) *LastEdgeNode = NULL; if (GreaterThan) *GreaterThan = FALSE; LastOverlapNode = NULL; SplayLinks = Tree; while (SplayLinks) { Node = CONTAINING_RECORD( SplayLinks, LOCKTREE_NODE, Links ); // // Pull up the first lock on the chain at this node to check // the starting byte offset of locks at this node // Lock = CONTAINING_RECORD( Node->Locks.Next, SH_LOCK, Link ); // // We may have to go right in the tree if this lock covers a range before the start of this // range we are looking for overlap on or this lock is [0, 0). This is important since a lock // on [0, 0) will look like the extent is from [0, ~0], which is the only case where the zero // length lock relation of End < Start does not hold. // if (Node->Extent < (ULONGLONG)StartingByte->QuadPart || (Lock->LockInfo.StartingByte.QuadPart == 0 && Lock->LockInfo.Length.QuadPart == 0)) { if ((ULONGLONG)Lock->LockInfo.EndingByte.QuadPart == (ULONGLONG)EndingByte->QuadPart && (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart == (ULONGLONG)StartingByte->QuadPart) { // // The extent of the node is less than the starting position of the // range we are checking and the first lock on this node is equal to // the range, which implies that the range and the lock are zero // length. // // This is a zero length lock node and we are searching for zero // length overlap. This makes multiple zero length shared locks // occupy the same node, which is a win, but makes application of // zero length exclusive locks check the length of the overlapping // lock to see if they really conflict. // break; } // // All locks at this node are strictly less than this // byterange, so go right in the tree. // if (LastEdgeNode) *LastEdgeNode = SplayLinks; if (GreaterThan) *GreaterThan = FALSE; SplayLinks = RtlRightChild(SplayLinks); continue; } if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart <= (ULONGLONG)EndingByte->QuadPart) { // // We have an overlap, but we need to see if the byterange starts // before this node so that there is the guarantee that we start // the search at the correct point. There may be still be predecessor // nodes covering the byterange. // if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart <= (ULONGLONG)StartingByte->QuadPart) { // // This node begins at a byte offset prior to the byterange we // are checking, so it must be the correct starting position. // break; } // // Drop a marker at this node so that we can come back if it turns out // that the left subtree does not cover the range of bytes before this // node in the byterange. // LastOverlapNode = Node; } // // It must now be the case that all locks at this node are strictly greater // than the byterange, or we have the candidate overlap case above, // so go left in the tree. // if (LastEdgeNode) *LastEdgeNode = SplayLinks; if (GreaterThan) *GreaterThan = TRUE; SplayLinks = RtlLeftChild(SplayLinks); } if (SplayLinks == NULL) { // // We hit the edge of the tree. If the LastOverlapNode is set, it means that // we had kept searching left in the tree for a node that covered the starting // byte of the byterange, but didn't find it. If it isn't set, we'll do the // right thing anyway since Node <- NULL. // Node = LastOverlapNode; } if (Node == NULL) { // // No overlapping node existed // return NULL; } // // Return the splay links of the first overlapping node // return &Node->Links; }

INLINE VOID FsRtlFreeExclusiveLock (  IN PEX_LOCK  C  )

Definition at line 446 of file filelock.c. References ExFreeToNPagedLookasideList(), and FsRtlExclusiveLockLookasideList. Referenced by FsRtlFastUnlockSingleExclusive(), FsRtlPrivateFastUnlockAll(), and FsRtlUninitializeFileLock(). { ExFreeToNPagedLookasideList( &FsRtlExclusiveLockLookasideList, (PVOID)C ); }

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 ); }

INLINE VOID FsRtlFreeLockInfo (  IN PLOCK_INFO  C  )

Definition at line 473 of file filelock.c. References ExFreeToNPagedLookasideList(), and FsRtlLockInfoLookasideList. Referenced by FsRtlUninitializeFileLock(). { ExFreeToNPagedLookasideList( &FsRtlLockInfoLookasideList, (PVOID)C ); }

INLINE VOID FsRtlFreeLockTreeNode (  IN PLOCKTREE_NODE  C  )

Definition at line 464 of file filelock.c. References ExFreeToNPagedLookasideList(), and FsRtlLockTreeNodeLookasideList. Referenced by FsRtlFastUnlockSingleShared(), FsRtlPrivateFastUnlockAll(), FsRtlPrivateInsertSharedLock(), and FsRtlUninitializeFileLock(). { ExFreeToNPagedLookasideList( &FsRtlLockTreeNodeLookasideList, (PVOID)C ); }

INLINE VOID FsRtlFreeSharedLock (  IN PSH_LOCK  C  )

Definition at line 437 of file filelock.c. References ExFreeToNPagedLookasideList(), and FsRtlSharedLockLookasideList. Referenced by FsRtlFastUnlockSingleShared(), FsRtlPrivateFastUnlockAll(), and FsRtlUninitializeFileLock(). { ExFreeToNPagedLookasideList( &FsRtlSharedLockLookasideList, (PVOID)C ); }

INLINE VOID FsRtlFreeWaitingLock (  IN PWAITING_LOCK  C  )

Definition at line 455 of file filelock.c. References ExFreeToNPagedLookasideList(), and FsRtlWaitingLockLookasideList. Referenced by FsRtlPrivateCancelFileLockIrp(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateFastUnlockAll(), and FsRtlUninitializeFileLock(). { ExFreeToNPagedLookasideList( &FsRtlWaitingLockLookasideList, (PVOID)C ); }

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, _EX_LOCK::LockInfo, _SH_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; }

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; }

VOID FsRtlInitializeFileLocks (  VOID   )

Definition at line 744 of file filelock.c. References ExInitializeFastMutex, ExInitializeNPagedLookasideList(), ExInitializePagedLookasideList(), FILE_LOCK, FsRtlCreateLockInfo, FsRtlExclusiveLockLookasideList, FsRtlFileLockLookasideList, FsRtlLockInfoLookasideList, FsRtlLockTreeNodeLookasideList, FsRtlSharedLockLookasideList, FsRtlWaitingLockLookasideList, NULL, TAG_EXCLUSIVE_LOCK, TAG_FILE_LOCK, TAG_LOCK_INFO, TAG_LOCKTREE_NODE, TAG_SHARED_LOCK, and TAG_WAITING_LOCK. Referenced by FsRtlInitSystem(). : Initializes the global portion of the filelock package. Arguments: None Return Value: None. --*/ { #ifndef USERTEST // // Build the lookaside lists for our internal structures. // ExInitializeNPagedLookasideList( &FsRtlSharedLockLookasideList, NULL, NULL, 0, sizeof(SH_LOCK), TAG_SHARED_LOCK, 16 ); ExInitializeNPagedLookasideList( &FsRtlExclusiveLockLookasideList, NULL, NULL, 0, sizeof(EX_LOCK), TAG_EXCLUSIVE_LOCK, 16 ); ExInitializeNPagedLookasideList( &FsRtlWaitingLockLookasideList, NULL, NULL, 0, sizeof(WAITING_LOCK), TAG_WAITING_LOCK, 16 ); ExInitializeNPagedLookasideList( &FsRtlLockTreeNodeLookasideList, NULL, NULL, 0, sizeof(LOCKTREE_NODE), TAG_LOCKTREE_NODE, 16 ); ExInitializeNPagedLookasideList( &FsRtlLockInfoLookasideList, NULL, NULL, 0, sizeof(LOCK_INFO), TAG_LOCK_INFO, 8 ); ExInitializePagedLookasideList( &FsRtlFileLockLookasideList, NULL, NULL, 0, sizeof(FILE_LOCK), TAG_FILE_LOCK, 8 ); // // Initialize the LockInfo creation mutex // ExInitializeFastMutex(&FsRtlCreateLockInfo); #endif }

VOID FsRtlPrivateCancelFileLockIrp (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp )

Definition at line 5721 of file filelock.c. References _IRP::CancelIrql, _WAITING_LOCK::Context, Dbg, DebugTrace, FsRtlCompleteLockIrp, FsRtlFreeWaitingLock(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, IoReleaseCancelSpinLock(), _IRP::IoStatus, _WAITING_LOCK::Irp, Irp, _LOCK_INFO::LockQueue, NTSTATUS(), NULL, PLOCK_INFO, PLOCK_QUEUE, PWAITING_LOCK, _LOCK_QUEUE::WaitingLocks, and _LOCK_QUEUE::WaitingLocksTail. Referenced by FsRtlPrivateLock(). : This routine implements the cancel function for an irp saved in a waiting lock queue Arguments: DeviceObject - Ignored Irp - Supplies the Irp being cancelled. A pointer to the FileLock structure for the lock is stored in the information field of the irp's iosb. Return Value: none. --*/ { PSINGLE_LIST_ENTRY *pLink, Link; PLOCK_INFO LockInfo; PLOCK_QUEUE LockQueue; KIRQL OldIrql; NTSTATUS NewStatus; UNREFERENCED_PARAMETER( DeviceObject ); // // The information field is used to store a pointer to the file lock // containing the irp // LockInfo = (PLOCK_INFO) (Irp->IoStatus.Information); // // Iterate through the lock queue. // LockQueue = &LockInfo->LockQueue; // // Release the cancel spinlock and lock the waiting queue if this // is initiated by Io. We already have the lock queue if this is // the race fixup. // // If this is from ourselves, we have the cancel Irql in the Irp. // if (DeviceObject) { IoReleaseCancelSpinLock( Irp->CancelIrql ); FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); } else { OldIrql = Irp->CancelIrql; } // // Iterate through all of the waiting locks looking for a canceled one. pLink = &LockQueue->WaitingLocks.Next; while ((Link = *pLink) != NULL) { PWAITING_LOCK WaitingLock; // // Get a pointer to the waiting lock record // WaitingLock = CONTAINING_RECORD( Link, WAITING_LOCK, Link ); DebugTrace(0, Dbg, "FsRtlPrivateCancelFileLockIrp, Loop top, WaitingLock = %08lx\n", WaitingLock); if( WaitingLock->Irp != Irp ) { pLink = &Link->Next; continue; } // // We've found it -- remove it from the list // *pLink = Link->Next; if (Link == LockQueue->WaitingLocksTail.Next) { LockQueue->WaitingLocksTail.Next = (PSINGLE_LIST_ENTRY) pLink; } Irp->IoStatus.Information = 0; // // Release LockQueue and complete this waiter // FsRtlReleaseLockQueue(LockQueue, OldIrql); // // Complete this waiter // FsRtlCompleteLockIrp( LockInfo, WaitingLock->Context, Irp, STATUS_CANCELLED, &NewStatus, NULL ); // // Free up pool // FsRtlFreeWaitingLock( WaitingLock ); // // Our job is done! // return; } // // Release lock queue // FsRtlReleaseLockQueue(LockQueue, OldIrql); return; }

BOOLEAN FsRtlPrivateCheckForExclusiveLockAccess (  IN PLOCK_QUEUE  LockInfo, IN PFILE_LOCK_INFO  FileLockInfo )

Definition at line 4934 of file filelock.c. References FALSE, FsRtlFindFirstOverlapInNode(), FsRtlFindFirstOverlappingExclusiveNode(), FsRtlFindFirstOverlappingSharedNode(), _LOCKTREE_NODE::HoleyNode, _FILE_LOCK_INFO::Length, _EX_LOCK::LockInfo, _SH_LOCK::LockInfo, _LOCKTREE_NODE::Locks, NULL, PEX_LOCK, PLOCKTREE_NODE, PSH_LOCK, RtlSplay(), and TRUE. Referenced by FsRtlPrivateCheckWaitingLocks(), and FsRtlPrivateLock(). : This routine checks to see if the caller can get an exclusive lock on the indicated range due to file locks in the passed in lock queue. Assumes Lock queue is held by caller Arguments: LockQueue - Queue which needs to be checked for collision FileLockInfo - Lock which is being checked Return Value: BOOLEAN - TRUE if the indicated user can place the exclusive lock over the entire specified byte range, and FALSE otherwise --*/ { PRTL_SPLAY_LINKS SplayLinks, LastSplayLinks = NULL; PLOCKTREE_NODE Node; PSH_LOCK ShLock; PEX_LOCK ExLock; if (LockQueue->SharedLockTree && (SplayLinks = FsRtlFindFirstOverlappingSharedNode( LockQueue->SharedLockTree, &FileLockInfo->StartingByte, &FileLockInfo->EndingByte, &LastSplayLinks, NULL))) { Node = CONTAINING_RECORD(SplayLinks, LOCKTREE_NODE, Links); // // If this node is holey, we'll have to walk the whole thing. // if (Node->HoleyNode) { ShLock = FsRtlFindFirstOverlapInNode( Node, &FileLockInfo->StartingByte, &FileLockInfo->EndingByte ); } else { ShLock = CONTAINING_RECORD(Node->Locks.Next, SH_LOCK, Link); } // // Look for overlap that we care about. Perhaps no overlap existed in the holey case. // if (ShLock && (FileLockInfo->Length.QuadPart || ShLock->LockInfo.Length.QuadPart)) { // // If we are checking a nonzero extent and overlapped, it is fatal. If we // are checking a zero extent and overlapped a nonzero extent, it is fatal. // return FALSE; } } if (LastSplayLinks) { LockQueue->SharedLockTree = RtlSplay(LastSplayLinks); LastSplayLinks = NULL; } if (LockQueue->ExclusiveLockTree && (SplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockQueue->ExclusiveLockTree, &FileLockInfo->StartingByte, &FileLockInfo->EndingByte, &LastSplayLinks, NULL))) { ExLock = CONTAINING_RECORD(SplayLinks, EX_LOCK, Links); if (FileLockInfo->Length.QuadPart || ExLock->LockInfo.Length.QuadPart) { // // If we are checking a nonzero extent and overlapped, it is fatal. If we // are checking a zero extent and overlapped a nonzero extent, it is fatal. // return FALSE; } } if (LastSplayLinks) { LockQueue->ExclusiveLockTree = RtlSplay(LastSplayLinks); } // // We searched the entire range without a conflict so we can grant // the exclusive lock // return TRUE; }

BOOLEAN FsRtlPrivateCheckForSharedLockAccess (  IN PLOCK_QUEUE  LockInfo, IN PFILE_LOCK_INFO  FileLockInfo )

Definition at line 5046 of file filelock.c. References FALSE, FsRtlFindFirstOverlappingExclusiveNode(), Lock, NULL, PEX_LOCK, RtlRealSuccessor(), RtlSplay(), Status, and TRUE. Referenced by FsRtlPrivateCheckWaitingLocks(), and FsRtlPrivateLock(). : This routine checks to see if the caller can get a shared lock on the indicated range due to file locks in the passed in lock queue. Assumes Lock queue is held by caller Arguments: LockQueue - Queue which needs to be checked for collision FileLockInfo - Lock which is being checked Arguments: Return Value: BOOLEAN - TRUE if the indicated user can place the shared lock over entire specified byte range, and FALSE otherwise --*/ { PEX_LOCK Lock; PRTL_SPLAY_LINKS SplayLinks, LastSplayLinks; BOOLEAN Status = TRUE; // // If there are no exclusive locks, this is quick ... // if (LockQueue->ExclusiveLockTree == NULL) { return TRUE; } // // No lock in the shared lock tree can prevent access, so just search the exclusive // tree for conflict. // for (SplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockQueue->ExclusiveLockTree, &FileLockInfo->StartingByte, &FileLockInfo->EndingByte, &LastSplayLinks, NULL); SplayLinks; SplayLinks = RtlRealSuccessor(SplayLinks)) { Lock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)FileLockInfo->EndingByte.QuadPart) { // // This node is covering a range greater than the range we care about, // so we're done // break; } // // We may not be able to grant the request if the fileobject, processid, // and key do not match. // if ((Lock->LockInfo.FileObject != FileLockInfo->FileObject) || (Lock->LockInfo.ProcessId != FileLockInfo->ProcessId) || (Lock->LockInfo.Key != FileLockInfo->Key)) { // // We have a mismatch between caller and owner. It is ok not to conflict // if the caller and owner will have/have zero length locks (zero length // locks cannot conflict). // if (FileLockInfo->Length.QuadPart || Lock->LockInfo.Length.QuadPart) { Status = FALSE; break; } } } if (LastSplayLinks) { LockQueue->ExclusiveLockTree = RtlSplay(LastSplayLinks); } // // We searched the entire range without a conflict so we can grant // the shared lock // return Status; }

VOID FsRtlPrivateCheckWaitingLocks (  IN PLOCK_INFO  LockInfo, IN PLOCK_QUEUE  LockQueue, IN KIRQL  OldIrql )

Definition at line 4722 of file filelock.c. References BooleanFlagOn, _WAITING_LOCK::Context, Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _FILE_LOCK_INFO::ExclusiveLock, FALSE, _IO_STACK_LOCATION::FileObject, _FILE_LOCK_INFO::FileObject, _IO_STACK_LOCATION::Flags, FsRtlCompleteLockIrp, FsRtlFreeWaitingLock(), FsRtlPrivateCheckForExclusiveLockAccess(), FsRtlPrivateCheckForSharedLockAccess(), FsRtlPrivateInsertLock(), FsRtlPrivateRemoveLock(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, IoGetCurrentIrpStackLocation, IoGetRequestorProcess(), IoSetCancelRoutine, _WAITING_LOCK::Irp, Irp, _FILE_LOCK_INFO::Key, _FILE_LOCK_INFO::Length, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObject, _IO_STACK_LOCATION::Parameters, _FILE_LOCK_INFO::ProcessId, PWAITING_LOCK, SL_EXCLUSIVE_LOCK, and _FILE_LOCK_INFO::StartingByte. Referenced by FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), and FsRtlPrivateFastUnlockAll(). : This routine checks to see if any of the current waiting locks are now be satisfied, and if so it completes their IRPs. Arguments: LockInfo - LockInfo which LockQueue is member of LockQueue - Supplies queue which needs to be checked OldIrql - Irql to restore when LockQueue is released Return Value: None. --*/ { PSINGLE_LIST_ENTRY *pLink, Link; NTSTATUS NewStatus; BOOLEAN Result; pLink = &LockQueue->WaitingLocks.Next; while ((Link = *pLink) != NULL) { PWAITING_LOCK WaitingLock; PIRP Irp; PIO_STACK_LOCATION IrpSp; BOOLEAN AccessGranted; FILE_LOCK_INFO FileLockInfo; // // Get a pointer to the waiting lock record // WaitingLock = CONTAINING_RECORD( Link, WAITING_LOCK, Link ); DebugTrace(0, Dbg, "FsRtlCheckWaitingLocks, Loop top, WaitingLock = %08lx\n", WaitingLock); // // Get a local copy of the necessary fields we'll need to use // Irp = WaitingLock->Irp; IrpSp = IoGetCurrentIrpStackLocation( Irp ); FileLockInfo.StartingByte = IrpSp->Parameters.LockControl.ByteOffset; FileLockInfo.Length = *IrpSp->Parameters.LockControl.Length; (ULONGLONG)FileLockInfo.EndingByte.QuadPart = (ULONGLONG)FileLockInfo.StartingByte.QuadPart + (ULONGLONG)FileLockInfo.Length.QuadPart - 1; FileLockInfo.FileObject = IrpSp->FileObject; FileLockInfo.ProcessId = IoGetRequestorProcess( Irp ); FileLockInfo.Key = IrpSp->Parameters.LockControl.Key; FileLockInfo.ExclusiveLock = BooleanFlagOn(IrpSp->Flags, SL_EXCLUSIVE_LOCK); // // Now case on whether we're trying to take out an exclusive lock or // a shared lock. And in both cases try to get the appropriate access // For the exclusive case we send in a NULL file object and process // id, this will ensure that the lookup does not give us write // access through an exclusive lock. // if (FileLockInfo.ExclusiveLock) { DebugTrace(0, Dbg, "FsRtlCheckWaitingLocks do we have write access?\n", 0); AccessGranted = FsRtlPrivateCheckForExclusiveLockAccess( LockQueue, &FileLockInfo ); } else { DebugTrace(0, Dbg, "FsRtlCheckWaitingLocks do we have read access?\n", 0); AccessGranted = FsRtlPrivateCheckForSharedLockAccess( LockQueue, &FileLockInfo ); } // // Now AccessGranted tells us whether we can really get the access for // the range we want. // // No matter what happens, this Irp must be completed now - even if we // are resource starved. User mode deadlock could be induced since there // may no longer be a pending unlock to cause a rescan of the waiting // list. // if (AccessGranted) { DebugTrace(0, Dbg, "FsRtlCheckWaitingLocks now has access\n", 0); // // Clear the cancel routine // IoSetCancelRoutine( Irp, NULL ); Result = FsRtlPrivateInsertLock( LockInfo, IrpSp->FileObject, &FileLockInfo ); // // Now we need to remove this granted waiter and complete // it's irp. // *pLink = Link->Next; if (Link == LockQueue->WaitingLocksTail.Next) { LockQueue->WaitingLocksTail.Next = (PSINGLE_LIST_ENTRY) pLink; } // // Release LockQueue and complete this waiter // FsRtlReleaseLockQueue(LockQueue, OldIrql); // // Reference the fileobject over the completion attempt so we can have a // chance to cleanup safely if we fail // ObReferenceObject( FileLockInfo.FileObject ); // // Now we can complete the IRP, if we don't get back success // from the completion routine then we remove the lock we just // inserted. // FsRtlCompleteLockIrp( LockInfo, WaitingLock->Context, Irp, (Result? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES), &NewStatus, FileLockInfo.FileObject ); if (Result && !NT_SUCCESS(NewStatus)) { // // Irp was not sucessfull, remove lock if it was added. // FsRtlPrivateRemoveLock ( LockInfo, &FileLockInfo, FALSE ); } // // Drop our private reference to the fileobject // ObDereferenceObject( FileLockInfo.FileObject ); // // Re-acquire queue lock // FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); // // Start scan over from begining // pLink = &LockQueue->WaitingLocks.Next; // // Free up pool // FsRtlFreeWaitingLock( WaitingLock ); } else { DebugTrace( 0, Dbg, "FsRtlCheckWaitingLocks still no access\n", 0); // // Move to next lock // pLink = &Link->Next; } } // // And return to our caller // return; }

NTSTATUS FsRtlPrivateFastUnlockAll (  IN PFILE_LOCK  FileLock, IN PFILE_OBJECT  FileObject, IN PEPROCESS  ProcessId, IN ULONG  Key, IN BOOLEAN  MatchKey, IN PVOID Context  OPTIONAL )

Definition at line 5254 of file filelock.c. References _WAITING_LOCK::Context, Dbg, DebugTrace, _FILE_LOCK_INFO::EndingByte, _LOCK_QUEUE::ExclusiveLockTree, FALSE, _IO_STACK_LOCATION::FileObject, _FILE_LOCK_INFO::FileObject, FsRtlCompleteLockIrp, FsRtlFreeExclusiveLock(), FsRtlFreeLockTreeNode(), FsRtlFreeSharedLock(), FsRtlFreeWaitingLock(), FsRtlPrivateCheckWaitingLocks(), FsRtlPrivateResetLowestLockOffset(), FsRtlReacquireLockQueue, FsRtlReleaseLockQueue, FsRtlSplitLocks(), IoGetCurrentIrpStackLocation, IoGetRequestorProcess(), IoSetCancelRoutine, _IRP::IoStatus, _WAITING_LOCK::Irp, Key, _FILE_LOCK_INFO::Key, _EX_LOCK::Links, _EX_LOCK::LockInfo, _SH_LOCK::LockInfo, _LOCK_INFO::LockQueue, _LOCKTREE_NODE::Locks, NTSTATUS(), NULL, _IO_STACK_LOCATION::Parameters, PEX_LOCK, PLOCK_INFO, PLOCK_QUEUE, PLOCKTREE_NODE, _FILE_LOCK_INFO::ProcessId, PSH_LOCK, PWAITING_LOCK, RtlDelete(), RtlRealSuccessor(), _LOCK_QUEUE::SharedLockTree, _LOCKTREE_NODE::Tail, TRUE, _LOCK_INFO::UnlockRoutine, _LOCK_QUEUE::WaitingLocks, and _LOCK_QUEUE::WaitingLocksTail. Referenced by FsRtlFastUnlockAll(), and FsRtlFastUnlockAllByKey(). : 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. Additionally, it is possible to free only those locks which also match a given key. 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 MatchKey - Whether or not the Key must also match for lock to be freed. Context - Supplies an optional context to use when completing waiting lock irps. Return Value: None --*/ { PLOCK_INFO LockInfo; PLOCK_QUEUE LockQueue; PSINGLE_LIST_ENTRY *pLink, *SavepLink, Link; NTSTATUS NewStatus; KIRQL OldIrql; LARGE_INTEGER MaxOffset, SaveEndingByte; BOOLEAN UnlockRoutine; PSH_LOCK ShLock; PEX_LOCK ExLock; PRTL_SPLAY_LINKS SplayLinks, SuccessorLinks; PLOCKTREE_NODE Node; DebugTrace(+1, Dbg, "FsRtlPrivateFastUnlockAll, FileLock = %08lx\n", FileLock); if ((LockInfo = FileLock->LockInformation) == NULL) { // // No lock information on this FileLock // DebugTrace(+1, Dbg, "FsRtlPrivateFastUnlockAll, No LockInfo\n", FileLock); return STATUS_RANGE_NOT_LOCKED; } FileObject->LastLock = NULL; 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 (LockQueue->SharedLockTree == NULL && LockQueue->ExclusiveLockTree == NULL) { // // No locks on this FileLock // DebugTrace(+1, Dbg, "FsRtlPrivateFastUnlockAll, No LockTrees\n", FileLock); FsRtlReleaseLockQueue(LockQueue, OldIrql); return STATUS_RANGE_NOT_LOCKED; } // // Remove all matching locks in the shared lock tree // if (LockQueue->SharedLockTree != NULL) { // // Grab the lowest node in the tree // SplayLinks = LockQueue->SharedLockTree; while (RtlLeftChild(SplayLinks) != NULL) { SplayLinks = RtlLeftChild(SplayLinks); } // // Walk all nodes in the tree // UnlockRoutine = FALSE; for (; SplayLinks; SplayLinks = SuccessorLinks) { Node = CONTAINING_RECORD(SplayLinks, LOCKTREE_NODE, Links ); // // Save the next node because we may split this node apart in the process // of deleting locks. It would be a waste of time to traverse those split // nodes. The only case in which we will not have traversed the entire list // before doing the split will be if there is an unlock routine attached // to this FileLock in which case we will be restarting the entire scan // anyway. // SuccessorLinks = RtlRealSuccessor(SplayLinks); // // Search down the current lock queue looking for a match on // the file object and process id // SavepLink = NULL; SaveEndingByte.QuadPart = 0; pLink = &Node->Locks.Next; while ((Link = *pLink) != NULL) { ShLock = CONTAINING_RECORD( Link, SH_LOCK, Link ); DebugTrace(0, Dbg, "Top of ShLock Loop, Lock = %08lx\n", ShLock ); if ((ShLock->LockInfo.FileObject == FileObject) && (ShLock->LockInfo.ProcessId == ProcessId) && (!MatchKey || ShLock->LockInfo.Key == Key)) { DebugTrace(0, Dbg, "Found one to unlock\n", 0); // // We have a match so now is the time to delete this lock. // Save the neccesary information to do the split node check. // Remove the lock from the list, then call the // optional unlock routine, then delete the lock. // if (SavepLink == NULL) { // // Need to remember where the first lock was deleted // SavepLink = pLink; } if ((ULONGLONG)ShLock->LockInfo.EndingByte.QuadPart > (ULONGLONG)SaveEndingByte.QuadPart) { // // Need to remember where the last offset affected by deleted locks is // SaveEndingByte.QuadPart = ShLock->LockInfo.EndingByte.QuadPart; } if (*pLink == Node->Tail.Next) { // // Deleting the tail node of the list. Safe even if deleting the // first node since this implies we're also deleting the last node // in the node which means we'll delete the node ... // Node->Tail.Next = CONTAINING_RECORD( pLink, SINGLE_LIST_ENTRY, Next ); } *pLink = Link->Next; if (LockInfo->UnlockRoutine != NULL) { // // Signal a lock that needs to have a special unlock routine // called on it. This is complex to deal with since we'll have // to release the queue, call it, and reacquire - meaning we // also have to restart. But we still need to reorder the node // first ... // UnlockRoutine = TRUE; break; } FsRtlFreeSharedLock( ShLock ); } else { // // Move to next lock // pLink = &Link->Next; } if (SavepLink == NULL && (ULONGLONG)ShLock->LockInfo.EndingByte.QuadPart > (ULONGLONG)MaxOffset.QuadPart) { // // Save the max offset until we have deleted our first node // MaxOffset.QuadPart = ShLock->LockInfo.EndingByte.QuadPart; } } if (SavepLink) { // // Locks were actually deleted here, so we have to check the state of the node // if (Node->Locks.Next == NULL) { // // We have just deleted everything at this node // LockQueue->SharedLockTree = RtlDelete(SplayLinks); FsRtlFreeLockTreeNode(Node); } else { // // Now that we have deleted all matching locks in this node, we do the // check on the node to split out any now non-overlapping locks. Conceptually, // we have deleted just one big lock that starts at the starting byte of the // first deleted lock and extends to the last byte of the last deleted lock. // FsRtlSplitLocks(Node, SavepLink, &SaveEndingByte, &MaxOffset); } } if (UnlockRoutine) { // // We dropped out of the node scan because we had a lock that needs extra // processing during unlock. Do it. // FsRtlReleaseLockQueue(LockQueue, OldIrql); LockInfo->UnlockRoutine(Context, &ShLock->LockInfo); FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); FsRtlFreeSharedLock(ShLock); UnlockRoutine = FALSE; // // We have to restart the scan, because the list may have changed while // we were in the unlock routine. Careful, because the tree may be empty. // if (SuccessorLinks = LockQueue->SharedLockTree) { while (RtlLeftChild(SuccessorLinks) != NULL) { SuccessorLinks = RtlLeftChild(SuccessorLinks); } } } } } // // Remove all matching locks in the exclusive lock tree // if (LockQueue->ExclusiveLockTree != NULL) { SplayLinks = LockQueue->ExclusiveLockTree; while (RtlLeftChild(SplayLinks) != NULL) { SplayLinks = RtlLeftChild(SplayLinks); } // // Walk all nodes in the tree // UnlockRoutine = FALSE; for (; SplayLinks; SplayLinks = SuccessorLinks ) { SuccessorLinks = RtlRealSuccessor(SplayLinks); ExLock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); DebugTrace(0, Dbg, "Top of ExLock Loop, Lock = %08lx\n", ExLock ); if ((ExLock->LockInfo.FileObject == FileObject) && (ExLock->LockInfo.ProcessId == ProcessId) && (!MatchKey || ExLock->LockInfo.Key == Key)) { LockQueue->ExclusiveLockTree = RtlDelete(&ExLock->Links); if (LockInfo->UnlockRoutine != NULL) { // // We're dropping out of the node scan because we have a lock // that needs extra processing during unlock. Do it. // FsRtlReleaseLockQueue(LockQueue, OldIrql); LockInfo->UnlockRoutine(Context, &ExLock->LockInfo); FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); // // We have to restart the scan, because the list may have changed while // we were in the unlock routine. Careful, because the tree may be empty. // if (SuccessorLinks = LockQueue->ExclusiveLockTree) { while (RtlLeftChild(SuccessorLinks) != NULL) { SuccessorLinks = RtlLeftChild(SuccessorLinks); } } } FsRtlFreeExclusiveLock(ExLock); } } } // // Search down the waiting lock queue looking for a match on the // file object and process id. // pLink = &LockQueue->WaitingLocks.Next; while ((Link = *pLink) != NULL) { PWAITING_LOCK WaitingLock; PIRP WaitingIrp; PIO_STACK_LOCATION WaitingIrpSp; WaitingLock = CONTAINING_RECORD( Link, WAITING_LOCK, Link ); DebugTrace(0, Dbg, "Top of Waiting Loop, WaitingLock = %08lx\n", WaitingLock); // // Get a copy of the necessary fields we'll need to use // WaitingIrp = WaitingLock->Irp; WaitingIrpSp = IoGetCurrentIrpStackLocation( WaitingIrp ); if ((FileObject == WaitingIrpSp->FileObject) && (ProcessId == IoGetRequestorProcess( WaitingIrp )) && (!MatchKey || Key == WaitingIrpSp->Parameters.LockControl.Key)) { DebugTrace(0, Dbg, "Found a waiting lock to abort\n", 0); // // We now void the cancel routine in the irp // IoSetCancelRoutine( WaitingIrp, NULL ); WaitingIrp->IoStatus.Information = 0; // // We have a match so now is the time to delete this waiter // But we must not mess up our link iteration variable. We // do this by simply starting the iteration over again, // after we delete ourselves. We also will deallocate the // lock after we delete it. // *pLink = Link->Next; if (Link == LockQueue->WaitingLocksTail.Next) { LockQueue->WaitingLocksTail.Next = (PSINGLE_LIST_ENTRY) pLink; } FsRtlReleaseLockQueue(LockQueue, OldIrql); // // And complete this lock request Irp // FsRtlCompleteLockIrp( LockInfo, WaitingLock->Context, WaitingIrp, STATUS_SUCCESS, &NewStatus, NULL ); // // Reaqcuire lock queue spinlock and start over // FsRtlReacquireLockQueue(LockInfo, LockQueue, &OldIrql); // // Start over // pLink = &LockQueue->WaitingLocks.Next; // // Put memory onto free list // FsRtlFreeWaitingLock( WaitingLock ); continue; } // // Move to next lock // pLink = &Link->Next; } // // At this point we've gone through unlocking everything. So // now try and release any waiting locks. // FsRtlPrivateCheckWaitingLocks( LockInfo, LockQueue, OldIrql ); // // We deleted a (possible) bunch of locks, go repair the lowest lock offset // FsRtlPrivateResetLowestLockOffset( LockInfo ); FsRtlReleaseLockQueue( LockQueue, OldIrql ); // // and return to our caller // DebugTrace(-1, Dbg, "FsRtlFastUnlockAll -> VOID\n", 0); return STATUS_SUCCESS; }

BOOLEAN FsRtlPrivateInitializeFileLock (  IN PFILE_LOCK  FileLock, IN BOOLEAN  ViaFastCall )

Definition at line 888 of file filelock.c. References _LOCK_INFO::CompleteLockIrpRoutine, _LOCK_QUEUE::ExclusiveLockTree, ExRaiseStatus(), FALSE, FsRtlAllocateLockInfo(), FsRtlCreateLockInfo, KeInitializeSpinLock(), _LOCK_INFO::LockQueue, _LOCK_INFO::LowestLockOffset, NULL, PLOCK_INFO, _LOCK_QUEUE::QueueSpinLock, _LOCK_QUEUE::SharedLockTree, TRUE, try_return, _LOCK_INFO::UnlockRoutine, _LOCK_QUEUE::WaitingLocks, and _LOCK_QUEUE::WaitingLocksTail. Referenced by FsRtlPrivateLock(). : This routine initializes a new LOCK_INFO structure in non-paged pool for the FILE_LOCK. This routines only occurs once for a given FILE_LOCK and it only occurs if any locks are applied to that file. Arguments: FileLock - Supplies a pointer to the FILE_LOCK structure to initialize. ViaFastCall - Indicates if we are being invoked via a fast call or via the slow irp based method. Return Value: TRUE - If LockInfo structure was allocated and initialized --*/ { PLOCK_INFO LockInfo; BOOLEAN Results = FALSE; ExAcquireFastMutex( &FsRtlCreateLockInfo ); try { if (FileLock->LockInformation != NULL) { // // Structure is already allocated, just return // try_return( Results = TRUE ); } // // Allocate pool for lock structures. If we fail then we will either return false or // raise based on if we know the caller has an try-except to handle a raise. // LockInfo = FsRtlAllocateLockInfo(); if (LockInfo == NULL) { if (ViaFastCall) { try_return( Results = FALSE ); } else { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } } // // Allocate and initialize the waiting lock queue // spinlock, and initialize the queues // LockInfo->LowestLockOffset = 0xffffffff; KeInitializeSpinLock( &LockInfo->LockQueue.QueueSpinLock ); LockInfo->LockQueue.SharedLockTree = NULL; LockInfo->LockQueue.ExclusiveLockTree = NULL; LockInfo->LockQueue.WaitingLocks.Next = NULL; LockInfo->LockQueue.WaitingLocksTail.Next = NULL; // // Copy Irp & Unlock routines from pagable FileLock structure // to non-pagable LockInfo structure // LockInfo->CompleteLockIrpRoutine = FileLock->CompleteLockIrpRoutine; LockInfo->UnlockRoutine = FileLock->UnlockRoutine; // // Clear continuation info for enum routine // FileLock->LastReturnedLockInfo.FileObject = NULL; FileLock->LastReturnedLock = NULL; // // Link LockInfo into FileLock // FileLock->LockInformation = (PVOID) LockInfo; Results = TRUE; try_exit: NOTHING; } finally { ExReleaseFastMutex( &FsRtlCreateLockInfo ); } return Results; }

VOID FsRtlPrivateInsertExclusiveLock (  IN PLOCK_QUEUE  LockQueue, IN PEX_LOCK  NewLock )

Definition at line 4605 of file filelock.c. References ASSERT, FsRtlFindFirstOverlappingExclusiveNode(), GreaterThan, NULL, and RtlRealSuccessor(). Referenced by FsRtlPrivateInsertLock(). : This routine adds a new exclusive lock record to the File lock's current lock queue. Arguments: LockQueue - Supplies the lock queue being modified NewLock - Supplies the new exclusive lock to add to the lock queue Return Value: None. --*/ { PRTL_SPLAY_LINKS OverlappedSplayLinks, ParentSplayLinks; BOOLEAN GreaterThan; OverlappedSplayLinks = FsRtlFindFirstOverlappingExclusiveNode( LockQueue->ExclusiveLockTree, &NewLock->LockInfo.StartingByte, &NewLock->LockInfo.EndingByte, &ParentSplayLinks, &GreaterThan ); // // This is the exclusive tree. Nothing can overlap (caller is supposed to insure this) unless // the lock is a zero length lock, in which case we just insert it - still. // ASSERT(!OverlappedSplayLinks || NewLock->LockInfo.Length.QuadPart == 0); // // Simple insert ... // RtlInitializeSplayLinks(&NewLock->Links); if (OverlappedSplayLinks) { // // With zero length locks we have OverlappedSplayLinks at the starting point // of a run of zero length locks, so we have to e flexible about where the new // node is inserted. // if (RtlRightChild(OverlappedSplayLinks)) { // // Right slot taken. We can use the left slot or go to the sucessor's left slot // if (RtlLeftChild(OverlappedSplayLinks)) { ASSERT(RtlLeftChild(RtlRealSuccessor(OverlappedSplayLinks)) == NULL); RtlInsertAsLeftChild(RtlRealSuccessor(OverlappedSplayLinks), &NewLock->Links); } else { RtlInsertAsLeftChild(OverlappedSplayLinks, &NewLock->Links); } } else { RtlInsertAsRightChild(OverlappedSplayLinks, &NewLock->Links); } } else if (ParentSplayLinks) { // // We have a real parent node in the tree, and must be at a leaf since // there was no overlap // if (GreaterThan) { ASSERT(RtlLeftChild(ParentSplayLinks) == NULL); RtlInsertAsLeftChild(ParentSplayLinks, &NewLock->Links); } else { ASSERT(RtlRightChild(ParentSplayLinks) == NULL); RtlInsertAsRightChild(ParentSplayLinks, &NewLock->Links); } } else { // // First node in the tree // LockQueue->ExclusiveLockTree = &NewLock->Links; } // // And return to our caller // return; }

BOOLEAN FsRtlPrivateInsertLock (  IN PLOCK_INFO  LockInfo, IN PFILE_OBJECT  FileObject, IN PFILE_LOCK_INFO  FileLockInfo )

Definition at line 4253 of file filelock.c. References ASSERT, FALSE, FsRtlAllocateExclusiveLock(), FsRtlAllocateSharedLock(), FsRtlPrivateInsertExclusiveLock(), FsRtlPrivateInsertSharedLock(), _SH_LOCK::LockInfo, _EX_LOCK::LockInfo, NULL, PEX_LOCK, PSH_LOCK, and TRUE. Referenced by FsRtlPrivateCheckWaitingLocks(), and FsRtlPrivateLock(). : This routine fills in a new lock record of the appropriate type and inserts it into the lock information. Arguments: LockInfo - Supplies the lock being modified FileObject - The associated file object to update hints in FileLockInfo - Supplies the new lock data to add to the lock queue Return Value: BOOLEAN - True if the insert was successful, False if no resources were avaliable to complete the operation. --*/ { // // Now add the lock to the appropriate tree. // if (FileLockInfo->ExclusiveLock) { PEX_LOCK ExLock; ExLock = FsRtlAllocateExclusiveLock(); if (ExLock == NULL) { return FALSE; } ExLock->LockInfo = *FileLockInfo; FsRtlPrivateInsertExclusiveLock( &LockInfo->LockQueue, ExLock ); FileObject->LastLock = &ExLock->LockInfo; } else { PSH_LOCK ShLock; ShLock = FsRtlAllocateSharedLock(); if (ShLock == NULL) { return FALSE; } ShLock->LockInfo = *FileLockInfo; if (!FsRtlPrivateInsertSharedLock( &LockInfo->LockQueue, ShLock )) { return FALSE; } FileObject->LastLock = &ShLock->LockInfo; } // // Fix up the lowest lock offset if need be // if ((ULONGLONG)FileLockInfo->StartingByte.QuadPart < (ULONGLONG)LockInfo->LowestLockOffset) { ASSERT( FileLockInfo->StartingByte.HighPart == 0 ); LockInfo->LowestLockOffset = FileLockInfo->StartingByte.LowPart; } return TRUE; }

BOOLEAN FsRtlPrivateInsertSharedLock (  IN PLOCK_QUEUE  LockQueue, IN PSH_LOCK  NewLock )

Definition at line 4343 of file filelock.c. References ASSERT, Dbg, DebugTrace, _LOCKTREE_NODE::Extent, FALSE, FsRtlAllocateLockTreeNode(), FsRtlFindFirstOverlappingSharedNode(), FsRtlFreeLockTreeNode(), FsRtlSplitLocks(), GreaterThan, _LOCKTREE_NODE::HoleyNode, _LOCKTREE_NODE::Links, Lock, _SH_LOCK::LockInfo, _LOCKTREE_NODE::Locks, NULL, PLOCKTREE_NODE, PSH_LOCK, RtlDeleteNoSplay(), RtlRealSuccessor(), RtlSplay(), _FILE_LOCK_INFO::StartingByte, _LOCKTREE_NODE::Tail, and TRUE. Referenced by FsRtlPrivateInsertLock(). : This routine adds a new shared lock record to the File lock's current lock queue. Locks are inserted into nodes ordered by their starting byte. Arguments: LockQueue - Supplies the lock queue being modified NewLock - Supplies the new shared lock to add to the lock queue Return Value: BOOLEAN - True if the insert was successful, False if no resources were avaliable to complete the operation. --*/ { PSINGLE_LIST_ENTRY pLink, Link; PRTL_SPLAY_LINKS OverlappedSplayLinks, ParentSplayLinks; PLOCKTREE_NODE Node, NextNode; PSH_LOCK NextLock; BOOLEAN GreaterThan; OverlappedSplayLinks = FsRtlFindFirstOverlappingSharedNode( LockQueue->SharedLockTree, &NewLock->LockInfo.StartingByte, &NewLock->LockInfo.EndingByte, &ParentSplayLinks, &GreaterThan ); if (OverlappedSplayLinks == NULL) { // // Simple insert case, build a new node // NextNode = FsRtlAllocateLockTreeNode(); // // If no resources are avaliable, simply fail now. // if (NextNode == NULL) { return FALSE; } RtlInitializeSplayLinks(&NextNode->Links); NextNode->HoleyNode = FALSE; NextNode->Locks.Next = NextNode->Tail.Next = &NewLock->Link; NextNode->Extent = (ULONGLONG)NewLock->LockInfo.EndingByte.QuadPart; NewLock->Link.Next = NULL; if (ParentSplayLinks) { // // We have a real parent node in the tree // if (GreaterThan) { ASSERT(RtlLeftChild(ParentSplayLinks) == NULL); RtlInsertAsLeftChild(ParentSplayLinks, &NextNode->Links); } else { ASSERT(RtlRightChild(ParentSplayLinks) == NULL); RtlInsertAsRightChild(ParentSplayLinks, &NextNode->Links); } // // Splay all new nodes in the tree // LockQueue->SharedLockTree = RtlSplay(&NextNode->Links); } else { // // First node in the tree // LockQueue->SharedLockTree = &NextNode->Links; } return TRUE; } // // Now we examine the node to see if it is holey as a result of a resource-failed split. // If it is, we must complete the split before adding the new lock. // Node = CONTAINING_RECORD( OverlappedSplayLinks, LOCKTREE_NODE, Links ); // // Search down the overlapped node finding the position for the new lock // for (pLink = &Node->Locks; (Link = pLink->Next) != NULL; pLink = Link) { PSH_LOCK Lock; Lock = CONTAINING_RECORD( Link, SH_LOCK, Link ); // // We sort locks on this list first by starting byte, then by whether the length is zero or not. // This is important so that zero length locks appear prior to non-zero length locks, so that // they are split out of nodes into the tree in the correct order. // // if (NewLock->StartingByte <= Lock->StartingByte) ... // if (((ULONGLONG)NewLock->LockInfo.StartingByte.QuadPart < (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart) || ((ULONGLONG)NewLock->LockInfo.StartingByte.QuadPart == (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart && (NewLock->LockInfo.Length.QuadPart == 0 || Lock->LockInfo.Length.QuadPart != 0))) { break; } } // // At this point pLink points to the record that comes right after // the new lock that we're inserting so we can simply push the // newlock into the entrylist // DebugTrace(0, Dbg, "InsertSharedLock, Insert Before = %08lx\n", Link); if (pLink->Next == NULL) { // // Adding onto the tail of the list // Node->Tail.Next = &NewLock->Link; } NewLock->Link.Next = pLink->Next; pLink->Next = &NewLock->Link; // // And splay the node we inserted into // LockQueue->SharedLockTree = RtlSplay(OverlappedSplayLinks); if ((ULONGLONG)NewLock->LockInfo.EndingByte.QuadPart > Node->Extent) { // // The new lock extends the range of this node, so fix up the extent // Node->Extent = NewLock->LockInfo.EndingByte.QuadPart; // // Walk across the remainder of the tree integrating newly overlapping // nodes into the node we just inserted the new lock into. Note that // this isn't so much a walk as a repeated examination of our successor's // until one does not overlap (or we hit the end). // ParentSplayLinks = OverlappedSplayLinks; for (OverlappedSplayLinks = RtlRealSuccessor(ParentSplayLinks); OverlappedSplayLinks; OverlappedSplayLinks = RtlRealSuccessor(ParentSplayLinks)) { NextNode = CONTAINING_RECORD( OverlappedSplayLinks, LOCKTREE_NODE, Links ); NextLock = CONTAINING_RECORD( NextNode->Locks.Next, SH_LOCK, Link ); if ((ULONGLONG)NextLock->LockInfo.StartingByte.QuadPart > Node->Extent) { // // This node is not overlapped, so stop // break; } // // If we are intergrating a holey node into a non-holey node, try to split // the node first. It will be better to get this done with a smaller node // than a big, fully integrated one. Note that we are guaranteed that the // node will remain a candidate for integration since the first lock on the // node will still be there, and overlaps. // if (!Node->HoleyNode && NextNode->HoleyNode) { FsRtlSplitLocks( NextNode, NULL, NULL, NULL ); } // // Integrate the locks in this node into our list // Node->Tail.Next->Next = NextNode->Locks.Next; Node->Tail.Next = NextNode->Tail.Next; if (NextNode->Extent > Node->Extent) { // // If the node we just swallowed was (still!) holey, we perhaps made this // node holey too. The resolution of this is left to the lock split we will // perform after integration is complete. // // Note that if the extent of the node we are swallowing is interior // to the current node, we just covered whatever holes it contained. // if (NextNode->HoleyNode) { Node->HoleyNode = TRUE; } Node->Extent = NextNode->Extent; } // // Free the now empty node. // RtlDeleteNoSplay( OverlappedSplayLinks, &LockQueue->SharedLockTree ); FsRtlFreeLockTreeNode( NextNode ); } } // // Now, perhaps this node is still holey. For grins lets try one more time to split // this thing apart. // if (Node->HoleyNode) { FsRtlSplitLocks( Node, NULL, NULL, NULL ); } // // And return to our caller // return TRUE; }

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  OPTIONAL, 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, Irp, _WAITING_LOCK::Irp, _FILE_LOCK_INFO::Key, 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; }

VOID FsRtlPrivateRemoveLock (  IN PLOCK_INFO  LockInfo, IN  PFILE_LOCK_INFO, IN BOOLEAN  CheckForWaiters )

Definition at line 3162 of file filelock.c. References ASSERT, FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), NTSTATUS(), NULL, Status, and TRUE. Referenced by FsRtlPrivateCheckWaitingLocks(), and FsRtlPrivateLock(). : General purpose cleanup routine. Finds the given lock structure and removes it from the file lock list. Differs from UnlockSingle only in that it disables the UnlockRoutine of the FileLock and optionalizes walking the waiting locks list. Arguments: FileLock - Supplies the file's lock structure supposedly containing a stale lock FileLockInfo - Supplies file lock data being freed CheckForWaiters - If true check for possible waiting locks, caused by freeing the locked range Return Value: None. --*/ { NTSTATUS Status; if (FileLockInfo->ExclusiveLock) { // // We must find it in the exclusive lock tree // Status = FsRtlFastUnlockSingleExclusive( LockInfo, FileLockInfo->FileObject, &FileLockInfo->StartingByte, &FileLockInfo->Length, FileLockInfo->ProcessId, FileLockInfo->Key, NULL, TRUE, CheckForWaiters ); ASSERT( Status == STATUS_SUCCESS); } else { // // We must find it in the shared lock tree // Status = FsRtlFastUnlockSingleShared( LockInfo, FileLockInfo->FileObject, &FileLockInfo->StartingByte, &FileLockInfo->Length, FileLockInfo->ProcessId, FileLockInfo->Key, NULL, TRUE, CheckForWaiters ); ASSERT( Status == STATUS_SUCCESS); } return; }

VOID FsRtlPrivateResetLowestLockOffset (  PLOCK_INFO  LockInfo  )

Definition at line 5150 of file filelock.c. References _LOCK_QUEUE::ExclusiveLockTree, _SH_LOCK::LockInfo, _EX_LOCK::LockInfo, _LOCK_INFO::LockQueue, _LOCKTREE_NODE::Locks, _LOCK_INFO::LowestLockOffset, NULL, PEX_LOCK, PLOCKTREE_NODE, PSH_LOCK, _LOCK_QUEUE::SharedLockTree, and _FILE_LOCK_INFO::StartingByte. Referenced by FsRtlFastUnlockSingleExclusive(), FsRtlFastUnlockSingleShared(), and FsRtlPrivateFastUnlockAll(). : This routine resets the lowest lock offset hint in a LOCK_INFO to the lowest lock offset currently held by a lock inside of the LOCK_INFO. Arguments: LockInfo - the lock data to operate on Return Value: None --*/ { PEX_LOCK ExLock = NULL; PSH_LOCK ShLock = NULL; PFILE_LOCK_INFO LowestLockInfo = NULL; PRTL_SPLAY_LINKS SplayLinks; PLOCKTREE_NODE Node; // // Fix up the lowest lock offset if we have non-empty trees and there was // a lock in the low 32 bit region // if (LockInfo->LowestLockOffset != 0xffffffff && (LockInfo->LockQueue.SharedLockTree != NULL || LockInfo->LockQueue.ExclusiveLockTree != NULL)) { // // Grab the lowest nodes in the trees // 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 ); } if (LockInfo->LockQueue.ExclusiveLockTree) { SplayLinks = LockInfo->LockQueue.ExclusiveLockTree; while (RtlLeftChild(SplayLinks) != NULL) { SplayLinks = RtlLeftChild(SplayLinks); } ExLock = CONTAINING_RECORD( SplayLinks, EX_LOCK, Links ); } // // Figure out which of the lowest locks is actually lowest. We know that one of the lock // trees at least has a lock, so if we have don't have exclusive locks then we do know // we have shared locks ... // if (ExLock && (!ShLock || (ULONGLONG)ExLock->LockInfo.StartingByte.QuadPart < (ULONGLONG)ShLock->LockInfo.StartingByte.QuadPart)) { LowestLockInfo = &ExLock->LockInfo; } else { LowestLockInfo = &ShLock->LockInfo; } if (LowestLockInfo->StartingByte.HighPart == 0) { LockInfo->LowestLockOffset = LowestLockInfo->StartingByte.LowPart; } else { LockInfo->LowestLockOffset = 0xffffffff; } } else { // // If there are no locks, set the lock offset high // LockInfo->LowestLockOffset = 0xffffffff; } }

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; }

VOID FsRtlSplitLocks (  IN PLOCKTREE_NODE  ParentNode, IN PSINGLE_LIST_ENTRY *pStartLink  OPTIONAL, IN PLARGE_INTEGER LastShadowedByte  OPTIONAL, IN PLARGE_INTEGER GlueOffset  OPTIONAL )

Definition at line 2865 of file filelock.c. References ASSERT, _LOCKTREE_NODE::Extent, FALSE, FsRtlAllocateLockTreeNode(), _LOCKTREE_NODE::HoleyNode, _LOCKTREE_NODE::Links, Lock, _LOCKTREE_NODE::Locks, NULL, PLOCKTREE_NODE, PSH_LOCK, RtlRealSuccessor(), _LOCKTREE_NODE::Tail, and TRUE. Referenced by FsRtlFastUnlockSingleShared(), FsRtlPrivateFastUnlockAll(), and FsRtlPrivateInsertSharedLock(). : This routine examines and possibly splits off shared locks associated with a node into new nodes of the lock tree. Called from routines that have just deleted locks. The arguments that supply the initial conditions for the operation are optional if the node is known to be holey. Arguments: ParentNode- Supplies the node the locks are coming from pStartLink - Supplies the pointer to the link address of the start of the range of locks in the ParentNode's locklist that need to be checked LastShadowedByte - Supplies the last byte offset that needs to be checked GlueOffset - Supplies the maximum offset affected by locks prior to this point in the list Return Value: BOOLEAN - True if the split was successful, False otherwise. The node will be marked as Holey if the split could not occur. --*/ { PSH_LOCK Lock; PLOCKTREE_NODE NewNode; PSINGLE_LIST_ENTRY Link, *pLink, *NextpLink; LARGE_INTEGER MaxOffset, StartOffset, HaltOffset; BOOLEAN ExtentValid; BOOLEAN FailedHoleySplit = FALSE; // // There are two cases: the node is holey or not. If the node is holey, at some // point we failed to get resources to complete a split, so despite our caller's // good intentions we need to go over the entire node. // if (ParentNode->HoleyNode) { // // Just move the starting link back to the front. The maximum offset and // starting offset of the node will be initialized in the loop. We also turn // off the holey flag, which will be turned on again as appropriate. // pStartLink = &ParentNode->Locks.Next; ParentNode->HoleyNode = FALSE; HaltOffset.QuadPart = ParentNode->Extent; } else { HaltOffset = *LastShadowedByte; MaxOffset = *GlueOffset; StartOffset.QuadPart = 0; if (!ParentNode->Locks.Next || (ULONGLONG)HaltOffset.QuadPart <= (ULONGLONG)MaxOffset.QuadPart) { // // The parent node is not there, doesn't have links associated, or the // last possible byte that is affected by the operation our caller made // is interior to the max extent of all locks still in this node - in // which case there is nothing that needs to be done. // return; } } // // If the extent of the node is past the last byte affected by whatever // operations were done to this node, we can avoid the linear scan of // the list past that last affected byte since we already know the // extent of the entire list! If it is not (note that it would have to // be equal - by defintion) then we need to recalculate the extents of // all nodes we touch in this operation. // ExtentValid = (ParentNode->Extent > (ULONGLONG)HaltOffset.QuadPart); for (pLink = pStartLink; (Link = *pLink) != NULL; pLink = NextpLink) { NextpLink = &Link->Next; Lock = CONTAINING_RECORD( Link, SH_LOCK, Link ); if (ParentNode->Locks.Next == *pLink) { // // We're at the first lock in the node, and we know that we're going to leave // at least one lock here. Skip over that lock. We also know that the max // offset must be that locks's ending byte - make sure it is. Note that this // code is *exactly* the same as the update MaxOffset code at the bottom of // the loop. // MaxOffset.QuadPart = Lock->LockInfo.EndingByte.QuadPart; // // Set the starting offset of the node. This is only an issue for zero length // locks, so that we can figure out what is going on if we split a node and wind // up with some number of "overlapped" zero length locks at the front of the new // node. We must be able to notice this case, and not think that each needs to // be in a seperate node. // StartOffset.QuadPart = Lock->LockInfo.StartingByte.QuadPart; // // If extents are invalid we also need to set it in case this turns out to // be the only lock at this node. // if (!ExtentValid) { ParentNode->Extent = (ULONGLONG)MaxOffset.QuadPart; } continue; } // // If the lock begins at a byte offset greater than the maximum offset seen to this // point, AND this is not a zero length node starting at the beginning of this node, // break the node. The second half of the test keeps co-incident zero length locks // in the same node. (zero length lock ---> starting = ending + 1). // if ((ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)MaxOffset.QuadPart && !(Lock->LockInfo.Length.QuadPart == 0 && Lock->LockInfo.StartingByte.QuadPart == StartOffset.QuadPart)) { // // Break the node up here // NewNode = FsRtlAllocateLockTreeNode(); if (NewNode == NULL) { // // If we are out of resources, this node is now holey - we know that the locks at // this node do not completely cover the indicated range. Keep splitting for two // reasons: more resources may become avaliable, and we must keep updating the // node's extent if it is known to be invalid. // // // Now if this node was already holey it is not possible to state that, if we // manage to split if further as we keep walking, that the resulting "left" node // is not holey. See below. // if (ParentNode->HoleyNode) { FailedHoleySplit = TRUE; } ParentNode->HoleyNode = TRUE; } else { // // Initialize the node. // RtlInitializeSplayLinks(&NewNode->Links); NewNode->HoleyNode = FALSE; // // Find the spot in the tree to take the new node(s). If the current node has // a free right child, we use it, else find the successor node and use its // left child. One of these cases must be avaliable since we know there are // no nodes between this node and its successor. // if (RtlRightChild(&ParentNode->Links) == NULL) { RtlInsertAsRightChild(&ParentNode->Links, &NewNode->Links); } else { ASSERT(RtlLeftChild(RtlRealSuccessor(&ParentNode->Links)) == NULL); RtlInsertAsLeftChild(RtlRealSuccessor(&ParentNode->Links), &NewNode->Links); } // // Move the remaining locks over to the new node and fix up extents // NewNode->Locks.Next = *pLink; *pLink = NULL; NewNode->Tail.Next = ParentNode->Tail.Next; ParentNode->Tail.Next = CONTAINING_RECORD( pLink, SINGLE_LIST_ENTRY, Next ); // // This will cause us to fall into the first-lock clause above on the next pass // NextpLink = &NewNode->Locks.Next; // // The new node's extent is now copied from the parent. The old node's extent must be // the maximum offset we have seen to this point. // // Note that if ExtentValid is true, that must mean that the lock ending at that extent // is in the new node since if it was in the old node we wouldn't have been able to split. // NewNode->Extent = ParentNode->Extent; ParentNode->Extent = (ULONGLONG)MaxOffset.QuadPart; // // The parent node can no longer be holey if we have not failed a split in this node. // if (!FailedHoleySplit) { ParentNode->HoleyNode = FALSE; } else { // // So reset the failure flag for the new node. // FailedHoleySplit = FALSE; } // // Move over to the new node. // ParentNode = NewNode; continue; } } if (ExtentValid && (ULONGLONG)Lock->LockInfo.StartingByte.QuadPart > (ULONGLONG)HaltOffset.QuadPart) { // // Our extents are good and this lock is past the shadow, so we can stop // return; } if ((ULONGLONG)MaxOffset.QuadPart < (ULONGLONG)Lock->LockInfo.EndingByte.QuadPart) { // // Update maximum offset // MaxOffset.QuadPart = Lock->LockInfo.EndingByte.QuadPart; if (!ExtentValid) { // // Extents are not good so we must update the extent // ParentNode->Extent = (ULONGLONG)MaxOffset.QuadPart; } } } // // Reached the end of the list, so update the extent (case of all subsequent locks // having been interior to GlueOffset) // ParentNode->Extent = (ULONGLONG)MaxOffset.QuadPart; return; }

VOID FsRtlSplitLocks (  IN PLOCKTREE_NODE  ParentNode, IN PSINGLE_LIST_ENTRY *  pStartLink, IN PLARGE_INTEGER  LastShadowedByte, IN PLARGE_INTEGER  GlueOffset )

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, Irp, _WAITING_LOCK::Irp, _LOCKTREE_NODE::Links, _EX_LOCK::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; }

---

Variable Documentation

FAST_MUTEX FsRtlCreateLockInfo

Definition at line 119 of file filelock.c. Referenced by FsRtlInitializeFileLocks(), and FsRtlPrivateInitializeFileLock().

NPAGED_LOOKASIDE_LIST FsRtlExclusiveLockLookasideList

Definition at line 132 of file filelock.c. Referenced by FsRtlAllocateExclusiveLock(), FsRtlFreeExclusiveLock(), and FsRtlInitializeFileLocks().

PAGED_LOOKASIDE_LIST FsRtlFileLockLookasideList

Definition at line 137 of file filelock.c. Referenced by FsRtlAllocateFileLock(), FsRtlFreeFileLock(), and FsRtlInitializeFileLocks().

NPAGED_LOOKASIDE_LIST FsRtlLockInfoLookasideList

Definition at line 135 of file filelock.c. Referenced by FsRtlAllocateLockInfo(), FsRtlFreeLockInfo(), and FsRtlInitializeFileLocks().

NPAGED_LOOKASIDE_LIST FsRtlLockTreeNodeLookasideList

Definition at line 134 of file filelock.c. Referenced by FsRtlAllocateLockTreeNode(), FsRtlFreeLockTreeNode(), and FsRtlInitializeFileLocks().

NPAGED_LOOKASIDE_LIST FsRtlSharedLockLookasideList

Definition at line 131 of file filelock.c. Referenced by FsRtlAllocateSharedLock(), FsRtlFreeSharedLock(), and FsRtlInitializeFileLocks().

NPAGED_LOOKASIDE_LIST FsRtlWaitingLockLookasideList

Definition at line 133 of file filelock.c. Referenced by FsRtlAllocateWaitingLock(), FsRtlFreeWaitingLock(), and FsRtlInitializeFileLocks().

---