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

Classes
struct	_THREAD_STRUCT

struct	_THREAD_REC_BLOCK

Macros
#define	DLDAllocatePool(size) MyAllocatePool__(NonPagedPool,size)

#define	DLDFreePool(addr) MyFreePool__((addr))

#define	DLDGetCurrentResourceThread() ((ERESOURCE_THREAD)PsGetCurrentThread())

#define	ResourceOwnedExclusive 0x80

#define	ResourceDisableBoost 0x08

Typedefs
typedef struct _THREAD_STRUCT	THREAD_STRUCT

typedef struct _THREAD_STRUCT *	PTHREAD_STRUCT

typedef struct _THREAD_REC_BLOCK	THREAD_REC_BLOCK

typedef struct _THREAD_REC_BLOCK *	PTHREAD_REC_BLOCK

Functions
VOID	DLDInit (ULONG MaxThrdCount)
	Initialize deadlock detector.

VOID	DLDAcquireExclusive (PERESOURCE Resource, ULONG BugCheckId, ULONG Line)

VOID	DLDAcquireShared (PERESOURCE Resource, ULONG BugCheckId, ULONG Line, BOOLEAN WaitForExclusive)

VOID	DLDAcquireSharedStarveExclusive (PERESOURCE Resource, ULONG BugCheckId, ULONG Line)

VOID	DLDUnblock (PERESOURCE Resource)

VOID	DLDFree (VOID)

Macro Definition Documentation

◆ DLDAllocatePool

#define DLDAllocatePool ( size ) MyAllocatePool__(NonPagedPool,size)

Definition at line 25 of file dldetect.h.

◆ DLDFreePool

#define DLDFreePool ( addr ) MyFreePool__((addr))

Definition at line 26 of file dldetect.h.

◆ DLDGetCurrentResourceThread

#define DLDGetCurrentResourceThread ( ) ((ERESOURCE_THREAD)PsGetCurrentThread())

Definition at line 28 of file dldetect.h.

◆ ResourceDisableBoost

#define ResourceDisableBoost 0x08

Definition at line 34 of file dldetect.h.

◆ ResourceOwnedExclusive

#define ResourceOwnedExclusive 0x80

Definition at line 32 of file dldetect.h.

Typedef Documentation

◆ PTHREAD_REC_BLOCK

typedef struct _THREAD_REC_BLOCK * PTHREAD_REC_BLOCK

◆ PTHREAD_STRUCT

typedef struct _THREAD_STRUCT * PTHREAD_STRUCT

◆ THREAD_REC_BLOCK

typedef struct _THREAD_REC_BLOCK THREAD_REC_BLOCK

◆ THREAD_STRUCT

typedef struct _THREAD_STRUCT THREAD_STRUCT

Function Documentation

◆ DLDAcquireExclusive()

VOID DLDAcquireExclusive	(	PERESOURCE	Resource,
		ULONG	BugCheckId,
		ULONG	Line
	)

Definition at line 313 of file dldetect.cpp.

  {
 
    KIRQL oldIrql;
 
    KeAcquireSpinLock(&Resource->SpinLock, &oldIrql);
 
    ERESOURCE_THREAD Thread = (ERESOURCE_THREAD)PsGetCurrentThread();
 
    if (!Resource->ActiveCount) goto SimpleAcquire;
    if ((Resource->Flag  & ResourceOwnedExclusive) && Resource->OwnerThreads[0].OwnerThread == Thread) {
        Resource->OwnerThreads[0].OwnerCount++;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        return;
    }
 
    DLDpAcquireResourceExclusiveLite(Resource, Thread, oldIrql,BugCheckId,Line);
    return;
 
SimpleAcquire:
 
    Resource->Flag |= ResourceOwnedExclusive;
    Resource->ActiveCount = 1;
    Resource->OwnerThreads[0].OwnerThread = Thread;
    Resource->OwnerThreads[0].OwnerCount = 1;
 
    KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
}

Referenced by DLDpAcquireResourceExclusiveLite().

◆ DLDAcquireShared()

VOID DLDAcquireShared	(	PERESOURCE	Resource,
		ULONG	BugCheckId,
		ULONG	Line,
		BOOLEAN	WaitForExclusive
	)

Definition at line 398 of file dldetect.cpp.

{
 
    KIRQL oldIrql;
 
    ERESOURCE_THREAD Thread = (ERESOURCE_THREAD)PsGetCurrentThread();
    POWNER_ENTRY pOwnerEntry;
 
    KeAcquireSpinLock(&Resource->SpinLock, &oldIrql);
 
    if (!Resource->ActiveCount) {
        Resource->Flag &= ~ResourceOwnedExclusive;
        Resource->ActiveCount = 1;
        Resource->OwnerThreads[1].OwnerThread = Thread;
        Resource->OwnerThreads[1].OwnerCount = 1;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        return;
    }
 
    if (Resource->Flag & ResourceOwnedExclusive ) {
        if (Resource->OwnerThreads[0].OwnerThread == Thread) {
            Resource->OwnerThreads[0].OwnerCount++;
            KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
            return;
        }
 
        pOwnerEntry = DLDpFindCurrentThread(Resource, 0);
 
    } else {
        // owned shared by some thread(s)
 
        pOwnerEntry = DLDpFindCurrentThread(Resource, Thread);
 
        if (!WaitForExclusive && pOwnerEntry->OwnerThread == Thread) {
            pOwnerEntry->OwnerCount++;
            KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
            return;
        }
 
        if (!(Resource->NumberOfExclusiveWaiters)) {
 
            pOwnerEntry->OwnerThread = Thread;
            pOwnerEntry->OwnerCount  = 1;
            Resource->ActiveCount++;
            KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
 
            return;
        }
    }
 
    if (!(Resource->SharedWaiters)) {
        Resource->SharedWaiters = (PKSEMAPHORE)ExAllocatePoolWithTag(NonPagedPool, sizeof(KSEMAPHORE),RESOURCE_SEMAFORE_TAG);
        KeInitializeSemaphore(Resource->SharedWaiters,0,0x7fffffff);
    }
 
    Resource->NumberOfSharedWaiters++;
 
    PTHREAD_STRUCT ThrdStruct = DLDAllocFindThread(Thread);
 
 
    // Set WaitingResource for current thread
    ThrdStruct->WaitingResource = Resource;
    ThrdStruct->BugCheckId = BugCheckId;
    ThrdStruct->Line = Line;
 
    KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
 
    DLDpWaitForResource(Resource,&(Resource->SharedWaiters->Header),ThrdStruct);
 
    KeAcquireSpinLock(&Resource->SpinLock, &oldIrql);
 
    pOwnerEntry = DLDpFindCurrentThread(Resource, Thread);
    pOwnerEntry->OwnerThread    = Thread;
    pOwnerEntry->OwnerCount     = 1;
 
    ThrdStruct->WaitingResource = NULL;
    ThrdStruct->ThreadId        = 0;
    ThrdStruct->BugCheckId      = 0;
    ThrdStruct->Line            = 0;
 
    KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
 
    return;
 
}

◆ DLDAcquireSharedStarveExclusive()

VOID DLDAcquireSharedStarveExclusive	(	PERESOURCE	Resource,
		ULONG	BugCheckId,
		ULONG	Line
	)

◆ DLDFree()

VOID DLDFree ( VOID )

Definition at line 64 of file dldetect.cpp.

                   {
 
    DLDFreePool(DLDThreadTable);
 
}

Referenced by DriverEntry().

◆ DLDInit()

VOID DLDInit ( ULONG MaxThrdCount )

Initialize deadlock detector.

Parameters

MaxThrdCount Maximum supported number of threads

Definition at line 51 of file dldetect.cpp.

  {
    if (KeNumberProcessors>1) {
        UDFPrint(("Deadlock Detector is designed for uniprocessor machines only!\n"));
        BrutePoint();
    }
    DLDpTimeout.QuadPart = -40000000I64;
 
    MaxThreadCount = MaxThrdCount;
    DLDThreadTable = (PTHREAD_STRUCT) DLDAllocatePool(MaxThreadCount*sizeof(THREAD_STRUCT));
    RtlZeroMemory(DLDThreadTable, sizeof(THREAD_STRUCT)*MaxThreadCount);
}