#include "fxobjectpch.hpp"

Include dependency graph for wdfpoolkm.cpp:

Functions
	__drv_maxIRQL (DISPATCH_LEVEL) NTKERNELAPI PMDL NTAPI IoAllocateMdl(__in_opt __drv_aliasesMem PVOID VirtualAddress

PMDL	FxMdlAllocateDebug (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Owner, __in PVOID VirtualAddress, __in ULONG Length, __in BOOLEAN SecondaryBuffer, __in BOOLEAN ChargeQuota, __in PVOID CallersAddress)

VOID	FxMdlFreeDebug (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PMDL Mdl)

VOID	FxMdlDump (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

Variables
__in ULONG	Length

__in ULONG __in BOOLEAN	SecondaryBuffer

__in ULONG __in BOOLEAN __in BOOLEAN	ChargeQuota

__in ULONG __in BOOLEAN __in BOOLEAN __inout_opt PIRP	Irp

Function Documentation

◆ __drv_maxIRQL()

__drv_maxIRQL ( DISPATCH_LEVEL )

◆ FxMdlAllocateDebug()

PMDL FxMdlAllocateDebug	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxObject *	Owner,
		__in PVOID	VirtualAddress,
		__in ULONG	Length,
		__in BOOLEAN	SecondaryBuffer,
		__in BOOLEAN	ChargeQuota,
		__in PVOID	CallersAddress
	)

Definition at line 81 of file wdfpoolkm.cpp.

{
    FxDriverGlobalsDebugExtension* pExtension;
    FxAllocatedMdls* pAllocated, **ppNext;
    ULONG i;
    PMDL pMdl;
    KIRQL irql;
 
    pExtension = FxDriverGlobals->DebugExtension;
    if (pExtension == NULL) {
        return IoAllocateMdl(VirtualAddress,
                             Length,
                             SecondaryBuffer,
                             ChargeQuota,
                             NULL);
    }
 
    pAllocated = &pExtension->AllocatedMdls;
    ppNext = NULL;
    pMdl = NULL;
 
    KeAcquireSpinLock(&pExtension->AllocatedMdlsLock, &irql);
 
    while (pAllocated != NULL && pAllocated->Count == NUM_MDLS_IN_INFO) {
        ppNext = &pAllocated->Next;
        pAllocated = pAllocated->Next;
    }
 
    if (pAllocated == NULL) {
        //
        // No more entries, allocate a new table
        //
        pAllocated = (FxAllocatedMdls*) ExAllocatePoolWithTag(
            NonPagedPool, sizeof(FxAllocatedMdls), FxDriverGlobals->Tag);
 
        if (pAllocated != NULL) {
            //
            // Zero out the new buffer and link it in to the list
            //
            RtlZeroMemory(pAllocated, sizeof(*pAllocated));
            *ppNext = pAllocated;
        }
        else {
            //
            // Could not allocate a new table, return error
            //
            KeReleaseSpinLock(&pExtension->AllocatedMdlsLock, irql);
 
            return NULL;
        }
    }
 
    for (i = 0; i < NUM_MDLS_IN_INFO; i++) {
        if (pAllocated->Info[i].Mdl != NULL) {
            continue;
        }
 
        pMdl =  IoAllocateMdl(VirtualAddress,
                              Length,
                              SecondaryBuffer,
                              ChargeQuota,
                              NULL);
 
        if (pMdl != NULL) {
            pAllocated->Info[i].Mdl = pMdl;
            pAllocated->Info[i].Owner = Owner;
            pAllocated->Info[i].Caller = CallersAddress;
            pAllocated->Count++;
        }
        break;
    }
 
    KeReleaseSpinLock(&pExtension->AllocatedMdlsLock, irql);
 
    return pMdl;
}

Referenced by FxMdlAllocate().

◆ FxMdlDump()

VOID FxMdlDump ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 239 of file wdfpoolkm.cpp.

{
    FxAllocatedMdls *pCur;
    BOOLEAN leak;
 
    if (FxDriverGlobals->DebugExtension == NULL) {
        return;
    }
 
    leak = FALSE;
 
    for (pCur = &FxDriverGlobals->DebugExtension->AllocatedMdls;
         pCur != NULL;
         pCur = pCur->Next) {
        ULONG i;
 
        for (i = 0; i < NUM_MDLS_IN_INFO; i++) {
            if (pCur->Info[i].Mdl != NULL) {
                leak = TRUE;
 
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "PMDL 0x%p leaked, FxObject owner %p, Callers Address %p",
                    pCur->Info[i].Mdl, pCur->Info[i].Owner,
                    pCur->Info[i].Caller);
            }
        }
    }
 
    if (leak) {
        FxVerifierDbgBreakPoint(FxDriverGlobals);
    }
}

Referenced by FxPoolDestroy().

◆ FxMdlFreeDebug()

VOID FxMdlFreeDebug	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PMDL	Mdl
	)

Definition at line 167 of file wdfpoolkm.cpp.

{
    FxDriverGlobalsDebugExtension* pExtension;
    FxAllocatedMdls* pAllocated, **ppNext;
    ULONG i;
    KIRQL irql;
    BOOLEAN found;
 
    pExtension = FxDriverGlobals->DebugExtension;
    if (pExtension == NULL) {
        IoFreeMdl(Mdl);
        return;
    }
 
    found = FALSE;
 
    pAllocated = &pExtension->AllocatedMdls;
    ppNext = NULL;
 
    KeAcquireSpinLock(&pExtension->AllocatedMdlsLock, &irql);
 
    while (pAllocated != NULL) {
        for (i = 0; i < NUM_MDLS_IN_INFO; i++) {
            if (pAllocated->Info[i].Mdl != Mdl) {
                continue;
            }
 
            RtlZeroMemory(&pAllocated->Info[i],
                          sizeof(pAllocated->Info[i]));
 
            pAllocated->Count--;
 
            if (pAllocated->Count == 0 &&
                pAllocated != &pExtension->AllocatedMdls) {
                //
                // Remove the current table from the chain
                //
                *ppNext = pAllocated->Next;
 
                //
                // And free it
                //
                ExFreePool(pAllocated);
            }
 
            IoFreeMdl(Mdl);
            found = TRUE;
            break;
        }
 
        if (found) {
            break;
        }
 
        ppNext = &pAllocated->Next;
        pAllocated = pAllocated->Next;
    }
 
    KeReleaseSpinLock(&pExtension->AllocatedMdlsLock, irql);
 
    if (found == FALSE) {
 
 
 
        FxVerifierDbgBreakPoint(FxDriverGlobals);
    }
}