lock.c File Reference

#include "classp.h"
#include "debug.h"

Include dependency graph for lock.c:

Go to the source code of this file.

Classes
struct	_REMOVE_TRACKING_BLOCK

Typedefs
typedef struct _REMOVE_TRACKING_BLOCK	REMOVE_TRACKING_BLOCK
typedef struct _REMOVE_TRACKING_BLOCK *	PREMOVE_TRACKING_BLOCK

Functions
ULONG NTAPI	ClassAcquireRemoveLockEx (_In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID Tag, _In_ PCSTR File, _In_ ULONG Line)
VOID NTAPI	ClassReleaseRemoveLock (_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PIRP Tag)
VOID NTAPI	ClassCompleteRequest (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ CCHAR PriorityBoost)
RTL_GENERIC_COMPARE_RESULTS NTAPI	RemoveTrackingCompareRoutine (PRTL_GENERIC_TABLE Table, PVOID FirstStruct, PVOID SecondStruct)
PVOID NTAPI	RemoveTrackingAllocateRoutine (PRTL_GENERIC_TABLE Table, CLONG ByteSize)
VOID NTAPI	RemoveTrackingFreeRoutine (PRTL_GENERIC_TABLE Table, PVOID Buffer)
VOID	ClasspInitializeRemoveTracking (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClasspUninitializeRemoveTracking (_In_ PDEVICE_OBJECT DeviceObject)

Variables
LONG	LockHighWatermark = 0
LONG	LockLowWatermark = 0
LONG	MaxLockedMinutes = 5

Typedef Documentation

PREMOVE_TRACKING_BLOCK

typedef struct _REMOVE_TRACKING_BLOCK * PREMOVE_TRACKING_BLOCK

REMOVE_TRACKING_BLOCK

typedef struct _REMOVE_TRACKING_BLOCK REMOVE_TRACKING_BLOCK

Function Documentation

ClassAcquireRemoveLockEx()

ULONG NTAPI ClassAcquireRemoveLockEx	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PVOID	Tag,
		_In_ PCSTR	File,
		_In_ ULONG	Line
	)

Definition at line 115 of file lock.c.

                        :28104)
#endif
{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    BOOLEAN rundownAcquired;
    PEX_RUNDOWN_REF_CACHE_AWARE removeLockRundown = NULL;
 
    //
    // Grab the remove lock
    //
 
    #if DBG
 
        LONG lockValue;
 
        lockValue = InterlockedIncrement(&commonExtension->RemoveLock);
 
 
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_LOCK,  "ClassAcquireRemoveLock: "
                    "Acquired for Object %p & irp %p - count is %d\n",
                    DeviceObject, Tag, lockValue));
 
        NT_ASSERTMSG("ClassAcquireRemoveLock - lock value was negative : ",
                  (lockValue > 0));
 
        NT_ASSERTMSG("RemoveLock increased to meet LockHighWatermark",
                  ((LockHighWatermark == 0) ||
                   (lockValue != LockHighWatermark)));
 
        if (commonExtension->IsRemoved != REMOVE_COMPLETE) {
            PRTL_GENERIC_TABLE removeTrackingList = NULL;
            REMOVE_TRACKING_BLOCK trackingBlock;
            PREMOVE_TRACKING_BLOCK insertedTrackingBlock = NULL;
            BOOLEAN newElement = FALSE;
 
            KIRQL oldIrql;
 
            trackingBlock.Tag = Tag;
 
            trackingBlock.File = File;
            trackingBlock.Line = Line;
 
            KeQueryTickCount((&trackingBlock.TimeLocked));
 
            KeAcquireSpinLock(&commonExtension->RemoveTrackingSpinlock,
                              &oldIrql);
 
            removeTrackingList = commonExtension->RemoveTrackingList;
 
            if (removeTrackingList != NULL) {
                insertedTrackingBlock = RtlInsertElementGenericTable(removeTrackingList,
                                                                     &trackingBlock,
                                                                     sizeof(REMOVE_TRACKING_BLOCK),
                                                                     &newElement);
            }
 
            if (insertedTrackingBlock != NULL) {
                if (!newElement) {
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassAcquireRemoveLock: "
                                "already tracking Tag %p\n", Tag));
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassAcquireRemoveLock: "
                                "acquired in file %s on line %d\n",
                                insertedTrackingBlock->File, insertedTrackingBlock->Line));
//                  NT_ASSERT(FALSE);
 
                }
            } else {
                commonExtension->RemoveTrackingUntrackedCount++;
 
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_LOCK, ">>>>>ClassAcquireRemoveLock: "
                            "Cannot track Tag %p - currently %d untracked requsts\n",
                            Tag, commonExtension->RemoveTrackingUntrackedCount));
            }
 
            KeReleaseSpinLock(&commonExtension->RemoveTrackingSpinlock, oldIrql);
        }
    #else
 
        UNREFERENCED_PARAMETER(Tag);
        UNREFERENCED_PARAMETER(File);
        UNREFERENCED_PARAMETER(Line);
 
    #endif
 
    removeLockRundown = (PEX_RUNDOWN_REF_CACHE_AWARE)
        ((PCHAR)commonExtension->PrivateCommonData + sizeof(CLASS_PRIVATE_COMMON_DATA));
    rundownAcquired = ExAcquireRundownProtectionCacheAware(removeLockRundown);
    if (!rundownAcquired) {
        InterlockedIncrement((volatile LONG*) &(commonExtension->PrivateCommonData->RemoveLockFailAcquire));
        TracePrint((TRACE_LEVEL_VERBOSE,
                    TRACE_FLAG_LOCK,
                    "ClassAcquireRemoveLockEx: RemoveLockRundown acquisition failed"
                    "RemoveLockFailAcquire = %d\n",
                    commonExtension->PrivateCommonData->RemoveLockFailAcquire));
    }
 
    return (commonExtension->IsRemoved);
}

ClassCompleteRequest()

VOID NTAPI ClassCompleteRequest	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ CCHAR	PriorityBoost
	)

Definition at line 401 of file lock.c.

{
    #if DBG
        PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
        PRTL_GENERIC_TABLE removeTrackingList = NULL;
        REMOVE_TRACKING_BLOCK searchDataBlock;
        PREMOVE_TRACKING_BLOCK foundTrackingBlock;
 
        KIRQL oldIrql;
 
        KeAcquireSpinLock(&commonExtension->RemoveTrackingSpinlock, &oldIrql);
 
        removeTrackingList = commonExtension->RemoveTrackingList;
 
        if (removeTrackingList != NULL)
        {
            searchDataBlock.Tag = Irp;
 
            foundTrackingBlock = RtlLookupElementGenericTable(removeTrackingList, &searchDataBlock);
 
            if(foundTrackingBlock != NULL) {
 
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassCompleteRequest: "
                            "Irp %p completed while still holding the remove lock\n", Irp));
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassCompleteRequest: "
                            "Lock acquired in file %s on line %d\n",
                            foundTrackingBlock->File, foundTrackingBlock->Line));
                NT_ASSERT(FALSE);
            }
        }
 
        KeReleaseSpinLock(&commonExtension->RemoveTrackingSpinlock, oldIrql);
    #endif
 
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    IoCompleteRequest(Irp, PriorityBoost);
    return;
} // end ClassCompleteRequest()

Referenced by _IRQL_requires_max_(), _Success_(), ClassCheckVerifyComplete(), ClassCreateClose(), ClassDeviceControl(), ClassDeviceControlDispatch(), ClassDeviceGetLBProvisioningResources(), ClassDeviceHwFirmwareActivateProcess(), ClassDeviceHwFirmwareDownloadProcess(), ClassDeviceHwFirmwareGetInfoProcess(), ClassDispatchPnp(), ClassDispatchPower(), ClassInternalIoControl(), ClassIoCompleteAssociated(), ClassMinimalPowerHandler(), ClasspAccessAlignmentProperty(), ClasspCompleteOffloadRequest(), ClasspDeviceGetLBAStatus(), ClasspDeviceLBProvisioningProperty(), ClasspDeviceMediaTypeProperty(), ClasspDeviceSeekPenaltyProperty(), ClasspDeviceTrimProcess(), ClasspDeviceTrimProperty(), ClasspDuidQueryProperty(), ClasspMcnControl(), ClasspPersistentReserve(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), ClasspPriorityHint(), ClasspStartIo(), ClasspStorageEventNotification(), ClasspWriteCacheProperty(), ClassReadWrite(), ClassShutdownFlush(), ClassSystemControl(), ClassWmiCompleteRequest(), DiskDeviceControl(), DiskFlushComplete(), DiskIoctlVerifyThread(), DiskShutdownFlush(), ScsiFlopDeviceControl(), and TransferPktComplete().

ClasspInitializeRemoveTracking()

VOID ClasspInitializeRemoveTracking

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 500 of file lock.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
    #if DBG
        KeInitializeSpinLock(&commonExtension->RemoveTrackingSpinlock);
 
        commonExtension->RemoveTrackingList = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(RTL_GENERIC_TABLE), CLASS_TAG_LOCK_TRACKING);
 
        if (commonExtension->RemoveTrackingList != NULL)
        {
            RtlInitializeGenericTable(commonExtension->RemoveTrackingList,
                                      RemoveTrackingCompareRoutine,
                                      RemoveTrackingAllocateRoutine,
                                      RemoveTrackingFreeRoutine,
                                      NULL);
        }
    #else
 
        UNREFERENCED_PARAMETER(DeviceObject);
 
        commonExtension->RemoveTrackingSpinlock = (ULONG_PTR) -1;
        commonExtension->RemoveTrackingList = NULL;
    #endif
}

ClasspUninitializeRemoveTracking()

VOID ClasspUninitializeRemoveTracking

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 529 of file lock.c.

{
    #if DBG
        PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
        PRTL_GENERIC_TABLE removeTrackingList = commonExtension->RemoveTrackingList;
 
        ASSERTMSG("Removing the device while still holding remove locks",
                   commonExtension->RemoveTrackingUntrackedCount == 0 &&
                   removeTrackingList != NULL ? RtlNumberGenericTableElements(removeTrackingList) == 0 : TRUE);
 
        if (removeTrackingList != NULL)
        {
            KIRQL oldIrql;
            KeAcquireSpinLock(&commonExtension->RemoveTrackingSpinlock, &oldIrql);
 
            FREE_POOL(removeTrackingList);
            commonExtension->RemoveTrackingList = NULL;
 
            KeReleaseSpinLock(&commonExtension->RemoveTrackingSpinlock, oldIrql);
        }
 
    #else
 
        UNREFERENCED_PARAMETER(DeviceObject);
    #endif
}

ClassReleaseRemoveLock()

VOID NTAPI ClassReleaseRemoveLock	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_opt_ PIRP	Tag
	)

Definition at line 251 of file lock.c.

                        :28103)
#endif
{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    LONG lockValue;
    LONG oldValue;
    PEX_RUNDOWN_REF_CACHE_AWARE removeLockRundown = NULL;
 
    #if DBG
        PRTL_GENERIC_TABLE removeTrackingList = NULL;
        REMOVE_TRACKING_BLOCK searchDataBlock;
 
        BOOLEAN found = FALSE;
 
        BOOLEAN isRemoved = (commonExtension->IsRemoved == REMOVE_COMPLETE);
 
        KIRQL oldIrql;
 
        if (isRemoved) {
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_LOCK, "ClassReleaseRemoveLock: REMOVE_COMPLETE set; this should never happen"));
            InterlockedDecrement(&(commonExtension->RemoveLock));
            return;
        }
 
        KeAcquireSpinLock(&commonExtension->RemoveTrackingSpinlock,
                          &oldIrql);
 
        removeTrackingList = commonExtension->RemoveTrackingList;
 
        if (removeTrackingList != NULL) {
            searchDataBlock.Tag = Tag;
            found = RtlDeleteElementGenericTable(removeTrackingList, &searchDataBlock);
        }
 
        if (!found) {
            if(commonExtension->RemoveTrackingUntrackedCount == 0) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassReleaseRemoveLock: "
                            "Couldn't find Tag %p in the lock tracking list\n", Tag));
                //
                // This might happen if the device is being removed and the tracking list
                // has already been freed. Don't assert if that is the case.
                //
                NT_ASSERT((removeTrackingList == NULL) && (commonExtension->IsRemoved != NO_REMOVE));
            } else {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_LOCK, ">>>>>ClassReleaseRemoveLock: "
                            "Couldn't find Tag %p in the lock tracking list - "
                            "may be one of the %d untracked requests still outstanding\n",
                            Tag, commonExtension->RemoveTrackingUntrackedCount));
 
                commonExtension->RemoveTrackingUntrackedCount--;
                NT_ASSERT(commonExtension->RemoveTrackingUntrackedCount >= 0);
            }
        }
 
        KeReleaseSpinLock(&commonExtension->RemoveTrackingSpinlock,
                          oldIrql);
 
        lockValue = InterlockedDecrement(&commonExtension->RemoveLock);
 
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_LOCK,  "ClassReleaseRemoveLock: "
                    "Released for Object %p & irp %p - count is %d\n",
                    DeviceObject, Tag, lockValue));
 
        NT_ASSERT(lockValue >= 0);
 
        NT_ASSERTMSG("RemoveLock decreased to meet LockLowWatermark",
                  ((LockLowWatermark == 0) || !(lockValue == LockLowWatermark)));
 
        if (lockValue == 0) {
 
            NT_ASSERT(commonExtension->IsRemoved);
 
            //
            // The device needs to be removed.  Signal the remove event
            // that it's safe to go ahead.
            //
 
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_LOCK,  "ClassReleaseRemoveLock: "
                        "Release for object %p & irp %p caused lock to go to zero\n",
                        DeviceObject, Tag));
 
        }
 
    #else
 
        UNREFERENCED_PARAMETER(Tag);
 
    #endif
 
    //
    // Decrement the RemoveLockFailAcquire by 1 when RemoveLockFailAcquire is non-zero.
    // Release the RemoveLockRundown only when RemoveLockFailAcquire is zero.
    //
 
    oldValue = 1;
    lockValue = commonExtension->PrivateCommonData->RemoveLockFailAcquire;
    while (lockValue != 0) {
        oldValue =
            InterlockedCompareExchange((volatile LONG *) &commonExtension->PrivateCommonData->RemoveLockFailAcquire,
            lockValue - 1,
            lockValue);
 
        if (oldValue == lockValue) {
            break;
        }
 
        lockValue = oldValue;
    }
 
    if (lockValue == 0) {
        removeLockRundown = (PEX_RUNDOWN_REF_CACHE_AWARE)
            ((PCHAR)commonExtension->PrivateCommonData + sizeof(CLASS_PRIVATE_COMMON_DATA));
        ExReleaseRundownProtectionCacheAware(removeLockRundown);
    }
 
    return;
}

Referenced by _Function_class_(), _IRQL_requires_max_(), _Success_(), ClassAsynchronousCompletion(), ClassCheckVerifyComplete(), ClassCreateClose(), ClassDeviceControl(), ClassDeviceControlDispatch(), ClassDeviceGetLBProvisioningResources(), ClassDeviceHwFirmwareActivateProcess(), ClassDeviceHwFirmwareDownloadProcess(), ClassDeviceHwFirmwareGetInfoProcess(), ClassDispatchPnp(), ClassDispatchPower(), ClassInternalIoControl(), ClassIoComplete(), ClassIoCompleteAssociated(), ClassMinimalPowerHandler(), ClasspAccessAlignmentProperty(), ClasspCompleteOffloadRequest(), ClasspDeviceGetLBAStatus(), ClasspDeviceLBProvisioningProperty(), ClasspDeviceLockFailurePowerIrpCompletion(), ClasspDeviceMediaTypeProperty(), ClasspDeviceSeekPenaltyProperty(), ClasspDeviceTrimProcess(), ClasspDeviceTrimProperty(), ClasspDuidQueryProperty(), ClasspFailurePredict(), ClasspInitializeGesn(), ClasspMcnControl(), ClasspMediaChangeDetectionCompletion(), ClasspPersistentReserve(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), ClasspPrepareMcnIrp(), ClasspPriorityHint(), ClasspStartIo(), ClasspStorageEventNotification(), ClasspWriteCacheProperty(), ClassReadWrite(), ClassReleaseQueueCompletion(), ClassShutdownFlush(), ClassSystemControl(), ClassWmiCompleteRequest(), CleanupTransferPacketToWorkingSetSizeWorker(), DiskDeviceControl(), DiskFlushComplete(), DiskInfoExceptionCheck(), DiskInfoExceptionComplete(), DiskIoctlVerifyThread(), DiskReregWorker(), DiskShutdownFlush(), EnqueueFreeTransferPacket(), ScsiFlopDeviceControl(), and TransferPktComplete().

RemoveTrackingAllocateRoutine()

PVOID NTAPI RemoveTrackingAllocateRoutine	(	PRTL_GENERIC_TABLE	Table,
		CLONG	ByteSize
	)

Definition at line 477 of file lock.c.

{
    UNREFERENCED_PARAMETER(Table);
 
    return ExAllocatePoolWithTag(NonPagedPoolNx, ByteSize, CLASS_TAG_LOCK_TRACKING);
}

RemoveTrackingCompareRoutine()

RTL_GENERIC_COMPARE_RESULTS NTAPI RemoveTrackingCompareRoutine	(	PRTL_GENERIC_TABLE	Table,
		PVOID	FirstStruct,
		PVOID	SecondStruct
	)

Definition at line 450 of file lock.c.

{
    PVOID tag1, tag2;
 
    UNREFERENCED_PARAMETER(Table);
 
    tag1 = ((PREMOVE_TRACKING_BLOCK)FirstStruct)->Tag;
    tag2 = ((PREMOVE_TRACKING_BLOCK)SecondStruct)->Tag;
 
    if (tag1 < tag2)
    {
        return GenericLessThan;
    }
    else if (tag1 > tag2)
    {
        return GenericGreaterThan;
    }
 
    return GenericEqual;
}

RemoveTrackingFreeRoutine()

VOID NTAPI RemoveTrackingFreeRoutine	(	PRTL_GENERIC_TABLE	Table,
		PVOID	Buffer
	)

Definition at line 489 of file lock.c.

{
    UNREFERENCED_PARAMETER(Table);
 
    FREE_POOL(Buffer);
}

Variable Documentation

LockHighWatermark

LONG LockHighWatermark = 0

Definition at line 33 of file lock.c.

Referenced by ClassAcquireRemoveLockEx().

LockLowWatermark

LONG LockLowWatermark = 0

Definition at line 34 of file lock.c.

Referenced by ClassReleaseRemoveLock().

MaxLockedMinutes

LONG MaxLockedMinutes = 5

Definition at line 35 of file lock.c.

Referenced by IoInitializeRemoveLockEx(), and Mx::MxInitializeRemoveLock().