#include <fxtagtracker.hpp>

Inheritance diagram for FxTagTracker:

Collaboration diagram for FxTagTracker:

[legend]

Public Member Functions
	~FxTagTracker ()

VOID	CheckForAbandondedTags (VOID)

VOID	UpdateTagHistory (__in PVOID Tag, __in LONG Line, __in_opt PSTR File, __in FxTagRefType RefType, __in ULONG RefCount)

Public Member Functions inherited from FxGlobalsStump
	FxGlobalsStump (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)

VOID	operator delete (__in PVOID pointer)

PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	operator delete[] (__in PVOID pointer)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS __inline	CreateAndInitialize (__out FxTagTracker *TagTracker, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxTagTrackerType Type, __in BOOLEAN CaptureStack, __in FxObject Owner, __in_opt PVOID CreateTag=NULL)

Protected Attributes
FxTagTrackerType	m_TrackerType

BOOLEAN	m_CaptureStack

FxObject *	m_OwningObject

LIST_ENTRY	m_TrackerEntry

LONG	m_FailedCount

MxLock	m_SpinLock

FxTagTrackingBlock *	m_Next

FxTagHistory	m_TagHistory [TAG_HISTORY_DEPTH]

LONG	m_CurRefHistory

Private Member Functions
	FxTagTracker (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxTagTrackerType Type, __in BOOLEAN CaptureStack, __in FxObject *Owner, __in_opt PVOID CreateTag=NULL)

VOID	CopyStackFrames (_Inout_ FxTagTrackingStackFrames *StackFrames, _In_ USHORT NumFrames, _In_reads_(NumFrames) PVOID Frames)

Additional Inherited Members
Protected Member Functions inherited from FxStump
	FxStump (VOID)

Detailed Description

Definition at line 151 of file fxtagtracker.hpp.

Constructor & Destructor Documentation

◆ FxTagTracker()

FxTagTracker::FxTagTracker	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxTagTrackerType	Type,
		__in BOOLEAN	CaptureStack,
		__in FxObject *	Owner,
		__in_opt PVOID	CreateTag = `NULL`
	)

inlineprivate

Definition at line 160 of file fxtagtracker.hpp.

          :
        FxGlobalsStump(FxDriverGlobals),
        m_TrackerType(Type),
        m_CaptureStack(CaptureStack),
        m_Next(NULL),
        m_FailedCount(0),
        m_CurRefHistory(0),
        m_OwningObject(Owner)
    {
        RtlZeroMemory(m_TagHistory, sizeof(m_TagHistory));
 
        //
        // We keep handle reference trackers in a list,
        // which wdfkd uses to identify potential handle leaks.
        //
        if (m_TrackerType == FxTagTrackerTypeHandle) {
            FxDriverGlobalsDebugExtension* pExtension;
            KIRQL irql;
 
            pExtension = GetDriverGlobals()->DebugExtension;
            ASSERT(pExtension != NULL);
 
            //
            // Insert the tag tracker into the list of allocated trackers
            //
            pExtension->AllocatedTagTrackersLock.Acquire(&irql);
            InsertTailList(&pExtension->AllocatedTagTrackersListHead,
                           &m_TrackerEntry);
            pExtension->AllocatedTagTrackersLock.Release(irql);
 
            //
            // Handle references default to 1 outstanding ref (the object creation ref)
            //
            m_Next = new(FxDriverGlobals) FxTagTrackingBlock(CreateTag, 0, NULL, TRUE);
            if (m_Next == NULL) {
                m_FailedCount = 1;
            }
        }
        else {
            ASSERT(m_TrackerType == FxTagTrackerTypePower);
        }
    }

◆ ~FxTagTracker()

FxTagTracker::~FxTagTracker ( )

Definition at line 53 of file fxtagtracker.cpp.

{
    KIRQL irql;
    FxTagTrackingBlock *current, *next;
 
    if (m_TrackerType == FxTagTrackerTypeHandle) {
        FxDriverGlobalsDebugExtension* pExtension;
 
        CheckForAbandondedTags();
 
        pExtension = GetDriverGlobals()->DebugExtension;
 
        //
        // Remove this tracker from the list of allocated trackers
        //
        pExtension->AllocatedTagTrackersLock.Acquire(&irql);
        RemoveEntryList(&m_TrackerEntry);
        pExtension->AllocatedTagTrackersLock.Release(irql);
    } else {
        ASSERT(m_TrackerType == FxTagTrackerTypePower);
    }
 
    //
    // Delete any outstanding tracking blocks.
    //
    m_SpinLock.Acquire(&irql);
 
    current = m_Next;
    m_Next = NULL;
 
    while (current != NULL) {
        next = current->Next;
        delete current;
        current = next;
    }
 
    m_SpinLock.Release(irql);
}

Member Function Documentation

◆ CheckForAbandondedTags()

VOID FxTagTracker::CheckForAbandondedTags ( VOID )

Definition at line 293 of file fxtagtracker.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxTagTrackingBlock *current, *next;
    LONG abandoned;
    KIRQL irql;
    BOOLEAN committed;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    committed = m_OwningObject->IsCommitted();
 
    //
    // If the object was not committed, then it was an FxObject derived
    // class that was *embedded* as a field in another structure or class.
    // As such, we are allowing one outstanding reference at this time.  We will
    // catch > 1 outstanding references below in the while loop.
    //
    if (committed) {
        if (m_Next != NULL || m_FailedCount != 0) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Dropped references on a tag tracker, "
                                "show references with: !wdftagtracker %p", this);
            //
            // If this ASSERT fails, look in the history .. you'll
            // likely find that you released more references than you had
            //
            ASSERT(m_Next == NULL && m_FailedCount == 0);
        }
    }
 
    m_SpinLock.Acquire(&irql);
 
    current = m_Next;
    abandoned = 0;
 
    while (current != NULL) {
        next = current->Next;
 
        if (committed) {
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Abandonded ref on object %p tag %p (%s @ %d)",
                                m_OwningObject, current->Tag, current->File, current->Line);
            abandoned++;
        }
 
        if (committed == FALSE) {
            //
            // The next time we encounter an abandoned reference, we will complain
            // about it...we have used up our allowance of one leaked reference
            // because the object is an embedded object.
            //
            // NOTE:  we might be eating the real outstanding reference here
            //        and not tracing it and then tracing the initial creation
            //        reference as the leaked reference which will be confusing.
            //        This is b/c there is no way to distinguish what is the
            //        tracking block used to track the creatio of the object.
            //
            committed = TRUE;
 
            DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_WARNING, TRACINGDEVICE,
                                "Possibly Abandonded ref on object %p tag %p (%s @ %d).  "
                                "Is benign unless there are other outstanding leaked references.",
                                m_OwningObject, current->Tag, current->File, current->Line);
        }
 
        current = next;
    }
 
    m_SpinLock.Release(irql);
 
    ASSERTMSG("Abandoned tags on ref\n", abandoned == 0);
}

Referenced by FxObject::ProcessDestroy(), and ~FxTagTracker().

◆ CopyStackFrames()

VOID FxTagTracker::CopyStackFrames	(	_Inout_ FxTagTrackingStackFrames **	StackFrames,
		_In_ USHORT	NumFrames,
		_In_reads_(NumFrames) PVOID *	Frames
	)

private

Definition at line 106 of file fxtagtracker.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxTagTrackingStackFrames* stackFrames;
 
    //
    // FxTagHistory structs are stored in a circular buffer and reused,
    // so we also reuse the FxTagTrackingStackFrames that each allocates.
    //
    stackFrames = *StackFrames;
    if (stackFrames == NULL) {
        pFxDriverGlobals = GetDriverGlobals();
        stackFrames = new(pFxDriverGlobals) FxTagTrackingStackFrames;
        if (stackFrames == NULL) {
            return;
        }
 
        *StackFrames = stackFrames;
    }
 
    stackFrames->NumFrames = NumFrames;
 
    for (int i = 0; i < NumFrames; i++) {
        stackFrames->Frames[i] = (ULONG64)Frames[i];
    }
}

Referenced by UpdateTagHistory().

◆ CreateAndInitialize()

static _Must_inspect_result_ NTSTATUS __inline FxTagTracker::CreateAndInitialize	(	__out FxTagTracker **	TagTracker,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxTagTrackerType	Type,
		__in BOOLEAN	CaptureStack,
		__in FxObject *	Owner,
		__in_opt PVOID	CreateTag = `NULL`
	)

inlinestatic

Definition at line 222 of file fxtagtracker.hpp.

    {
        NTSTATUS status;
 
        FxTagTracker * tagTracker = new(FxDriverGlobals)
            FxTagTracker(FxDriverGlobals, Type, CaptureStack, Owner, CreateTag);
 
        if (NULL == tagTracker) {
            status = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "Failed to allocate tag tracker, returning %!STATUS!", status);
 
            goto exit;
        }
 
        *TagTracker = tagTracker;
        status = STATUS_SUCCESS;
 
    exit:
        return status;
    }

Referenced by FxObject::AllocateTagTracker(), and FxPowerIdleMachine::Reset().

◆ UpdateTagHistory()

VOID FxTagTracker::UpdateTagHistory	(	__in PVOID	Tag,
		__in LONG	Line,
		__in_opt PSTR	File,
		__in FxTagRefType	RefType,
		__in ULONG	RefCount
	)

Definition at line 138 of file fxtagtracker.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxTagHistory* pTagHistory;
    FxTagTrackingBlock* pBlock;
    LONG pos;
    KIRQL irql;
    USHORT numFrames = 0;
    PVOID frames[FRAMES_TO_CAPTURE];
 
    pFxDriverGlobals = GetDriverGlobals();
 
    pos = InterlockedIncrement(&m_CurRefHistory) - 1;
    pos %= TAG_HISTORY_DEPTH;
 
    //
    // Prefast reports that m_CurRefHistory can be negative which can lead to
    // underflow. But we know that m_CurRefHistory would never be negative.
    // Hence we assert for the condition below and assume that it would be true.
    //
    FX_ASSERT_AND_ASSUME_FOR_PREFAST(pos >= 0 && pos < TAG_HISTORY_DEPTH);
 
    pTagHistory = m_TagHistory + pos;
 
    pTagHistory->RefType = RefType;
    pTagHistory->RefCount = RefCount;
    pTagHistory->Line = Line;
    pTagHistory->Tag = Tag;
    pTagHistory->File = File;
 
    if (m_CaptureStack) {
        numFrames = RtlCaptureStackBackTrace(FRAMES_TO_SKIP,
                                             FRAMES_TO_CAPTURE,
                                             frames,
                                             NULL);
        if (numFrames > 0) {
            CopyStackFrames(&pTagHistory->StackFrames, numFrames, frames);
        }
    }
 
    //
    // We use the perf counter here and the tick count in the tracking block.
    // Use the tick count here as well until we decide that correlating the
    // perf counter to system time is not important.
    //
    // pTagHistory->Time = KeQueryPerformanceCounter(NULL);
    Mx::MxQueryTickCount(&pTagHistory->Time);
 
    if (RefType == TagAddRef) {
 
        //
        // Try to allocate some memory for the new block.  If unsuccessful,
        // fallback to a failed count increment.
        //
        pBlock = new(pFxDriverGlobals) FxTagTrackingBlock(Tag, Line, File);
 
        if (pBlock == NULL) {
            InterlockedIncrement(&m_FailedCount);
        }
        else {
            m_SpinLock.Acquire(&irql);
            pBlock->Next = m_Next;
            m_Next = pBlock;
            m_SpinLock.Release(irql);
 
            if (m_CaptureStack && numFrames > 0) {
                CopyStackFrames(&pBlock->StackFrames, numFrames, frames);
            }
        }
    }
    else {
        FxTagTrackingBlock **prev;
 
        //
        // Walk the list of current blocks and attempt to find the tag being
        // released.  If not found, decrement the failed count.  If no failed
        // tags exists, ASSERT immediately.
        //
 
        m_SpinLock.Acquire(&irql);
        prev = &m_Next;
        pBlock = *prev;
 
        while (pBlock != NULL) {
            if (pBlock->Tag == Tag) {
                *prev = pBlock->Next;
                break;
            }
 
            prev = &pBlock->Next;
            pBlock = pBlock->Next;
        }
 
        m_SpinLock.Release(irql);
 
        if (pBlock == NULL) {
            //
            // Check to see if we have any credits in our Low Memory Count.
            // In this fassion we can tell if we have acquired any locks without
            // the memory for adding tracking blocks.
            //
            if (InterlockedDecrement(&m_FailedCount) < 0) {
                //
                // We have just released a lock that neither had a corresponding
                // tracking block, nor a credit in LowMemoryCount.
                //
                InterlockedIncrement(&m_FailedCount);
 
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "releasing %s %p on object %p that was not acquired, !wdftagtracker %p",
                    m_TrackerType == FxTagTrackerTypePower ? "power tag" : "tag",
                    Tag,
                    m_OwningObject,
                    this);
 
                FxVerifierDbgBreakPoint(pFxDriverGlobals);
            }
        }
        else {
            delete pBlock;
            pBlock = NULL;
        }
    }
}