fxpool.h File Reference

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

Go to the source code of this file.

Classes
struct	FX_POOL_HEADER
struct	FX_POOL

Macros
#define	FX_POOL_HEADER_SIZE   FIELD_OFFSET(FX_POOL_HEADER, AllocationStart)

Typedefs
typedef FX_POOL_HEADER *	PFX_POOL_HEADER
typedef FX_POOL *	PFX_POOL
typedef FX_POOL_TRACKER *	PFX_POOL_TRACKER

Functions
struct	DECLSPEC_ALIGN (MEMORY_ALLOCATION_ALIGNMENT) FX_POOL_TRACKER
_Must_inspect_result_ NTSTATUS	FxPoolInitialize (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
VOID	FxPoolDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
_Must_inspect_result_ PWDF_DRIVER_GLOBALS	FxAllocateDriverGlobals (VOID)
VOID	FxFreeDriverGlobals (__in PWDF_DRIVER_GLOBALS DriverGlobals)
BOOLEAN	FxIsPagedPoolType (__in POOL_TYPE Type)
PVOID	FxPoolAllocator (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool, __in POOL_TYPE Type, __in SIZE_T Size, __in ULONG Tag, __in PVOID CallersAddress)
void	FxPoolFree (__in_xcount(ptr is at an offset from AllocationStart) PVOID ptr)
NTSTATUS	FxPoolDump (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
_Must_inspect_result_ NTSTATUS	FxPoolPackageInitialize (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	FxPoolPackageDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

Macro Definition Documentation

FX_POOL_HEADER_SIZE

#define FX_POOL_HEADER_SIZE   FIELD_OFFSET(FX_POOL_HEADER, AllocationStart)

Definition at line 53 of file fxpool.h.

Typedef Documentation

PFX_POOL

typedef FX_POOL* PFX_POOL

Definition at line 85 of file fxpool.h.

PFX_POOL_HEADER

typedef FX_POOL_HEADER* PFX_POOL_HEADER

Definition at line 51 of file fxpool.h.

PFX_POOL_TRACKER

typedef FX_POOL_TRACKER* PFX_POOL_TRACKER

Definition at line 109 of file fxpool.h.

Function Documentation

DECLSPEC_ALIGN()

struct DECLSPEC_ALIGN

(

MEMORY_ALLOCATION_ALIGNMENT

)

Definition at line 85 of file fxpool.h.

                                                                   {
    LIST_ENTRY Link;
    PFX_POOL   Pool;
    ULONG      Tag;
    SIZE_T     Size;
    POOL_TYPE  PoolType;
    PVOID      CallersAddress;
};

FxAllocateDriverGlobals()

_Must_inspect_result_ PWDF_DRIVER_GLOBALS FxAllocateDriverGlobals

(

VOID

)

Definition at line 1052 of file globals.cpp.

{
    PFX_DRIVER_GLOBALS  pFxDriverGlobals;
    KIRQL               irql;
    NTSTATUS            status;
 
    pFxDriverGlobals = (PFX_DRIVER_GLOBALS)
        MxMemory::MxAllocatePoolWithTag(NonPagedPool, sizeof(FX_DRIVER_GLOBALS), FX_TAG);
 
    if (pFxDriverGlobals == NULL) {
        return NULL;
    }
 
    *pFxDriverGlobals = {};
 
    pFxDriverGlobals->Refcnt = 1;
 
    status = pFxDriverGlobals->DestroyEvent.Initialize(NotificationEvent, FALSE);
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
    if (!NT_SUCCESS(status)) {
        MxMemory::MxFreePool(pFxDriverGlobals);
        return NULL;
    }
#else
    UNREFERENCED_PARAMETER(status);
#endif
 
    //
    // Initialize this new FxDriverGlobals structure.
    //
    FxLibraryGlobals.FxDriverGlobalsListLock.Acquire(&irql);
    InsertHeadList(&FxLibraryGlobals.FxDriverGlobalsList,
                   &pFxDriverGlobals->Linkage);
    FxLibraryGlobals.FxDriverGlobalsListLock.Release(irql);
 
    pFxDriverGlobals->WdfHandleMask                  = FxHandleValueMask;
    pFxDriverGlobals->WdfVerifierAllocateFailCount   = (ULONG) -1;
    pFxDriverGlobals->Driver                         = NULL;
    pFxDriverGlobals->DebugExtension                 = NULL;
    pFxDriverGlobals->LibraryGlobals                 = &FxLibraryGlobals;
    pFxDriverGlobals->WdfLogHeader                   = NULL;
 
    //
    // Verifier settings.  Off by default.
    //
    pFxDriverGlobals->SetVerifierState(FALSE);
 
    //
    // By default don't apply latest-version restricted verifier checks
    // to downlevel version drivers.
    //
    pFxDriverGlobals->FxVerifyDownlevel              = FALSE;
 
    //
    // Verbose is separate knob
    //
    pFxDriverGlobals->FxVerboseOn                    = FALSE;
 
    //
    // Do not parent queue presented requests.
    // This performance optimization is on by default.
    //
    pFxDriverGlobals->FxRequestParentOptimizationOn  = TRUE;
 
    //
    // Enhanced verifier options. Off by default
    //
    pFxDriverGlobals->FxEnhancedVerifierOptions = 0;
 
    //
    // If FxVerifierDbgBreakOnError is true, WaitForSignal interrupts the
    // execution of the system after waiting for the specified number
    // of seconds. Developer will have an opportunity to validate the state
    // of the driver when breakpoint is hit. Developer can continue to wait
    // by entering 'g' in the debugger.
    //
    pFxDriverGlobals->FxVerifierDbgWaitForSignalTimeoutInSec = 60;
 
    //
    // Timeout used by the wake interrupt ISR in WaitForSignal to catch
    // scenarios where the interrupt ISR is blocked because the device stack
    // is taking too long to power up
    //
    pFxDriverGlobals->DbgWaitForWakeInterruptIsrTimeoutInSec = 60;
 
    //
    // Minidump log related settings.
    //
    pFxDriverGlobals->FxForceLogsInMiniDump          = FALSE;
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    // pFxDriverGlobals->FxTrackDriverForMiniDumpLog    = TRUE;
    pFxDriverGlobals->FxTrackDriverForMiniDumpLog    = FALSE; // __REACTOS__
    pFxDriverGlobals->IsUserModeDriver               = FALSE;
#else
    pFxDriverGlobals->FxTrackDriverForMiniDumpLog    = FALSE;
    pFxDriverGlobals->IsUserModeDriver               = TRUE;
#endif
 
#if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
    //
    // Minidump driver info related settings.
    //
    pFxDriverGlobals->BugCheckDriverInfoIndex        = 0;
#endif
 
    //
    // By default disable the support for device simulation framework (DSF).
    //
    pFxDriverGlobals->FxDsfOn  = FALSE;
 
    //
    // Allocate a telemetry context if a telemetry client is enabled, for any level/keyword.
    //
    pFxDriverGlobals->TelemetryContext = NULL;
#ifdef EVENT_TRACING // __REACTOS__
    if (TraceLoggingProviderEnabled(g_TelemetryProvider, 0 ,0)) {
        AllocAndInitializeTelemetryContext(&(pFxDriverGlobals->TelemetryContext));
    }
#endif
 
    return &pFxDriverGlobals->Public;
}

Referenced by FxLibraryCommonRegisterClient().

FxFreeDriverGlobals()

VOID FxFreeDriverGlobals

(

__in PWDF_DRIVER_GLOBALS

DriverGlobals

)

Definition at line 1179 of file globals.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    KIRQL irql;
 
    pFxDriverGlobals = GetFxDriverGlobals(DriverGlobals);
 
    FxLibraryGlobals.FxDriverGlobalsListLock.Acquire(&irql);
    RemoveEntryList(&pFxDriverGlobals->Linkage);
    InitializeListHead(&pFxDriverGlobals->Linkage);
    FxLibraryGlobals.FxDriverGlobalsListLock.Release(irql);
 
    if (pFxDriverGlobals->DebugExtension != NULL) {
 
        FxFreeAllocatedMdlsDebugInfo(pFxDriverGlobals->DebugExtension);
 
        if (pFxDriverGlobals->DebugExtension->ObjectDebugInfo != NULL) {
            MxMemory::MxFreePool(pFxDriverGlobals->DebugExtension->ObjectDebugInfo);
            pFxDriverGlobals->DebugExtension->ObjectDebugInfo = NULL;
        }
 
        pFxDriverGlobals->DebugExtension->AllocatedTagTrackersLock.Uninitialize();
 
        MxMemory::MxFreePool(pFxDriverGlobals->DebugExtension);
        pFxDriverGlobals->DebugExtension = NULL;
    }
 
    //
    // Cleanup event b/c d'tor is not called for MxAllocatePoolWithTag.
    //
    pFxDriverGlobals->DestroyEvent.Uninitialize();
 
    if (NULL != pFxDriverGlobals->TelemetryContext) {
        MxMemory::MxFreePool(pFxDriverGlobals->TelemetryContext);
        pFxDriverGlobals->TelemetryContext = NULL;
    }
 
    MxMemory::MxFreePool(pFxDriverGlobals);
}

Referenced by FxLibraryCommonUnregisterClient().

FxIsPagedPoolType()

BOOLEAN FxIsPagedPoolType

(

__in POOL_TYPE

Type

)

Definition at line 43 of file wdfpool.cpp.

{
    //
    // Cleaner than doing (Type & 0x01)
    //
    switch( Type & (~POOL_COLD_ALLOCATION) ) {
    case PagedPool:
    case PagedPoolCacheAligned:
        return TRUE;
 
    default:
        return FALSE;
    }
}

Referenced by FxMemoryObject::_Create(), FxMemoryBufferFromPool::_Create(), FxPoolAllocator(), FxPoolFree(), and FxMemoryBuffer::operator new().

FxPoolAllocator()

PVOID FxPoolAllocator	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PFX_POOL	Pool,
		__in POOL_TYPE	Type,
		__in SIZE_T	Size,
		__in ULONG	Tag,
		__in PVOID	CallersAddress
	)

Definition at line 76 of file wdfpool.cpp.

{
    PVOID ptr;
    PCHAR pTrueBase;
    PFX_POOL_TRACKER pTracker;
    PFX_POOL_HEADER pHeader;
    NTSTATUS status;
    SIZE_T allocationSize;
 
 
    ptr = NULL;
 
    //
    // Allocations of a zero request size are invalid.
    //
    // Besides, with a zero request size, special pool could place us
    // at the end of a page, and adding our header would give us a page
    // aligned address, which is ambiguous with large allocations.
    //
    if (Size == 0) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
                            "Invalid Allocation Size of 0 requested");
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return NULL;
    }
 
    if (FxDriverGlobals->IsPoolTrackingOn()) {
 
        if (FxDriverGlobals->FxVerifierOn &&
            (FxDriverGlobals->WdfVerifierAllocateFailCount != -1L)) {
 
            //
            // If the registry key VerifierAllocateFailCount is set, all allocations
            // after the specified count are failed.
            //
            // This is a brutal test, but also ensures the framework can cleanup
            // under low memory conditions as well.
            //
            if (FxDriverGlobals->WdfVerifierAllocateFailCount == 0) {
                DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
                                    "Allocation Fail Count exceeded");
                return NULL;
            }
 
            // Decrement the count
            InterlockedDecrement(&FxDriverGlobals->WdfVerifierAllocateFailCount);
        }
 
        //
        // (Kernel mode only) PAGE_SIZE or greater allocations can not have our
        // header since this would break the system allocators contract
        // that PAGE_SIZE or greater allocations start on a whole page boundary
        //
 
        //
        // For allocations less than a page size that will not fit with our
        // header, we round up to a non-tracked whole page allocation so
        // we don't burn two pages for this boundary condition.
        //
 
        // This if is the same as
        // Size + sizeof(FX_POOL_TRACKER) + FX_POOL_HEADER_SIZE >= PAGE_SIZE
        // BUT with no integer overflow
        if (Mx::IsKM() &&
            (Size >= PAGE_SIZE - sizeof(FX_POOL_TRACKER) - FX_POOL_HEADER_SIZE)
            ) {
 
            //
            // Ensure that we ask for at least a page to ensure the
            // allocation starts on a whole page.
            //
            if (Size < PAGE_SIZE) {
                Size = PAGE_SIZE;
            }
 
            ptr = MxMemory::MxAllocatePoolWithTag(Type, Size, Tag);
 
            //
            // The current system allocator returns paged aligned memory
            // in this case, which we rely on to detect whether our header
            // is present or not in FxPoolFree
            //
            ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0);
        }
        else {
 
            status = RtlSIZETAdd(Size,
                                 sizeof(FX_POOL_TRACKER) + FX_POOL_HEADER_SIZE,
                                 &allocationSize);
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
                    "overflow: allocation tracker (%d) + header (%d) + pool "
                    "request (%I64d)", sizeof(FX_POOL_TRACKER),
                    FX_POOL_HEADER_SIZE, Size);
 
                return NULL;
            }
 
            pTrueBase = (PCHAR) MxMemory::MxAllocatePoolWithTag(
                Type,
                allocationSize,
                Tag
                );
 
            if (pTrueBase == NULL) {
                return NULL;
            }
 
            pTracker = (PFX_POOL_TRACKER) pTrueBase;
            pHeader  = WDF_PTR_ADD_OFFSET_TYPE(pTrueBase,
                                               sizeof(FX_POOL_TRACKER),
                                               PFX_POOL_HEADER);
            pHeader->Base            = pTrueBase;
            pHeader->FxDriverGlobals = FxDriverGlobals;
 
            //
            // Adjust the pointer to what we return to the driver
            //
            ptr = &pHeader->AllocationStart[0];
 
            //
            // Ensure the pointer we are returning is aligned on the proper
            // boundary.
            //
            ASSERT( ((ULONG_PTR) ptr & (MEMORY_ALLOCATION_ALIGNMENT-1)) == 0);
 
            //
            // Ensure the pointer is still not page aligned after
            // our adjustment. Otherwise the pool free code will
            // get confused and call ExFreePool on the wrong ptr.
            //
            if (Mx::IsKM()) {
                ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) != 0 );
            }
 
            //
            // We must separate paged and non-paged pool since
            // the lock held differs as to whether we can accept
            // page faults and block in the allocator.
            //
            if (FxIsPagedPoolType(Type)) {
                //
                // Format and insert the Tracker in the PagedHeader list.
                //
                FxPoolInsertPagedAllocateTracker(Pool,
                                                 pTracker,
                                                 Size,
                                                 Tag,
                                                 Caller);
            }
            else {
                //
                // Format and insert the Tracker in the NonPagedHeader list.
                //
                FxPoolInsertNonPagedAllocateTracker(Pool,
                                                    pTracker,
                                                    Size,
                                                    Tag,
                                                    Caller);
            }
        }
    }
    else {
        //
        // No pool tracking...
        //
 
        if ((Size < PAGE_SIZE) || Mx::IsUM())
        {
            //
            // (Kernel mode only) See if adding our header promotes us past a
            // page boundary
            //
            status = RtlSIZETAdd(Size,
                                 FX_POOL_HEADER_SIZE,
                                 &allocationSize);
 
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
                    "overflow: header + pool request (%I64d)", Size);
 
                return NULL;
            }
 
        }
        else {
            //
            // Is the raw request for alloc >= PAGE_SIZE ?  Then just use it.
            //
            allocationSize = Size;
        }
 
        //
        // Is cooked size for alloc >= PAGE_SIZE ?  Then just do it.
        //
        if (allocationSize >= PAGE_SIZE && Mx::IsKM())
        {
            //
            // Important to use allocationSize so that we get a page aligned
            // allocation so that we know to just free the memory pointer as is
            // when it is freed.
            //
            ptr = MxMemory::MxAllocatePoolWithTag(Type, allocationSize, Tag);
            ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0);
        }
        else {
            pTrueBase = (PCHAR) MxMemory::MxAllocatePoolWithTag(Type,
                                                      allocationSize,
                                                      Tag);
 
            if (pTrueBase != NULL) {
 
                pHeader = (PFX_POOL_HEADER) pTrueBase;
                pHeader->Base            = pTrueBase;
                pHeader->FxDriverGlobals = FxDriverGlobals;
 
                ptr = &pHeader->AllocationStart[0];
 
                if (Mx::IsKM()) {
                    //
                    // Ensure the pointer is still not page aligned after
                    // our adjustment. Otherwise the pool free code will
                    // get confused and call ExFreePool on the wrong ptr.
                    //
                    ASSERT( ((ULONG_PTR)ptr & (PAGE_SIZE-1)) != 0 );
                }
            }
        }
    }
 
    return ptr;
}

FxPoolDestroy()

VOID FxPoolDestroy	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PFX_POOL	Pool
	)

Definition at line 627 of file wdfpool.cpp.

{
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPOOL,
                        "Destroying Pool 0x%p", Pool);
 
    if (FxDriverGlobals->IsPoolTrackingOn()) {
        FxPoolDump(FxDriverGlobals, Pool);
 
#if FX_CORE_MODE==FX_CORE_KERNEL_MODE
        FxMdlDump(FxDriverGlobals);
#endif
        //
        // We don't automatically free memory items since we don't
        // know what they contain, and who is still referencing them.
        //
    }
 
    Pool->PagedLock.Uninitialize();
    Pool->NonPagedLock.Uninitialize();
 
    return;
}

Referenced by FxPoolPackageDestroy().

FxPoolDump()

NTSTATUS FxPoolDump	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PFX_POOL	Pool
	)

Definition at line 459 of file wdfpool.cpp.

{
    PFX_POOL_TRACKER pTracker;
    PLIST_ENTRY ple;
    KIRQL oldIrql;
    BOOLEAN leak;
 
    //
    // Dump usage information
    //
    DoTraceLevelMessage(
        FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
        "FxPoolDump: "
        "NonPagedBytes %I64d, PagedBytes %I64d, "
        "NonPagedAllocations %d, PagedAllocations %d,"
        "PeakNonPagedBytes %I64d, PeakPagedBytes %I64d,"
        "FxPoolDump: PeakNonPagedAllocations %d, PeakPagedAllocations %d",
        Pool->NonPagedBytes, Pool->PagedBytes,
        Pool->NonPagedAllocations, Pool->PagedAllocations,
        Pool->PeakNonPagedBytes, Pool->PeakPagedBytes,
        Pool->PeakNonPagedAllocations, Pool->PeakPagedAllocations
        );
 
    leak = FALSE;
 
    //
    // Check paged pool for leaks
    //
    Pool->PagedLock.Acquire();
 
    for (ple = Pool->PagedHead.Flink; ple != &Pool->PagedHead; ple = ple->Flink) {
        pTracker = CONTAINING_RECORD(ple, FX_POOL_TRACKER, Link);
 
        // Leaker
        leak = TRUE;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "FX_POOL 0x%p leaked paged memory alloc 0x%p (tracking block %p)",
            Pool, pTracker + 1, pTracker);
    }
 
    Pool->PagedLock.Release();
 
    //
    // Check non-paged pool for leaks
    //
 
    Pool->NonPagedLock.Acquire(&oldIrql);
 
    for (ple = Pool->NonPagedHead.Flink;
         ple != &Pool->NonPagedHead;
         ple = ple->Flink) {
        pTracker = CONTAINING_RECORD(ple, FX_POOL_TRACKER, Link );
 
        // Leaker
        leak = TRUE;
 
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "FX_POOL 0x%p leaked non-paged memory alloc 0x%p (tracking block %p)",
            Pool, pTracker+1, pTracker);
    }
 
    Pool->NonPagedLock.Release(oldIrql);
 
    if (leak) {
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        return STATUS_MORE_ENTRIES;
    }
    else {
        return STATUS_SUCCESS;
    }
}

Referenced by FxPoolDestroy().

FxPoolFree()

void FxPoolFree

(

__in_xcount(ptr is at an offset from AllocationStart) PVOID

ptr

)

Definition at line 361 of file wdfpool.cpp.

{
    PFX_POOL_HEADER pHeader;
    PVOID pTrueBase;
    PFX_POOL_TRACKER pTracker;
 
    //
    // Null pointers are always bad
    //
    if( ptr == NULL ) {
        ASSERTMSG("NULL pointer freed\n", FALSE);
        Mx::MxBugCheckEx(WDF_VIOLATION,
                     WDF_REQUIRED_PARAMETER_IS_NULL,
                     (ULONG_PTR)NULL,
                     (ULONG_PTR)_ReturnAddress(),
                     (ULONG_PTR)NULL
                     );
    }
 
    //
    // (Kernel mode only) If ptr is aligned on page boundry (indicates
    // it was > PAGE_SIZE allocation)
    // then there will be no common header...just free the memory without
    // further processing.
    //
    if( Mx::IsKM() && ( ((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0 ) ) {
        MxMemory::MxFreePool(ptr);
        return;
    }
 
    //
    // Ensure the pointer we are returning is aligned on the proper
    // boundary.
    //
    ASSERT( ((ULONG_PTR) ptr & (MEMORY_ALLOCATION_ALIGNMENT-1)) == 0);
 
    //
    // Dereference the Common header which all <PAGE_SIZE allcations will have.
    //
    pHeader = CONTAINING_RECORD(ptr, FX_POOL_HEADER, AllocationStart);
    pTrueBase = pHeader->Base;
 
    //
    // If PoolTracker is on then Base must point to it's header.
    // This is currently the only option for this area...may change later.
    //
    if (pHeader->FxDriverGlobals->IsPoolTrackingOn()) {
 
        pTracker = (PFX_POOL_TRACKER) pTrueBase;
 
        if (FxIsPagedPoolType(pTracker->PoolType)) {
            //
            // Decommission this Paged Allocation tracker
            //
            FxPoolRemovePagedAllocateTracker(pTracker);
        }
        else {
            //
            // Decommission this NonPaged Allocation tracker
            //
            FxPoolRemoveNonPagedAllocateTracker(pTracker);
        }
 
        //
        // Scrub the pool to zeros to catch destructed objects
        // by NULL'ing the v-table ptr
        //
        RtlZeroMemory(pTracker, pTracker->Size + sizeof(FX_POOL_TRACKER));
    }
 
    MxMemory::MxFreePool(pTrueBase);
}

Referenced by AddEventHooksWdfDeviceCreate(), AddEventHooksWdfIoQueueCreate(), FxUsbDeviceStringContext::AllocateDescriptor(), FxUsbInterface::CleanUpAndDelete(), FxIoTargetRemoveOpenParams::Clear(), FxIoContext::ClearBuffer(), FxDevice::CreateSymbolicLink(), FxDevice::DeleteSymbolicLink(), FxDevice::Destroy(), FxIoQueue::Dispose(), FxIoTarget::FormatIoctlRequest(), FxIoTarget::FormatIoRequest(), FxVerifierLock::FreeThreadTable(), FxDuplicateUnicodeString(), FxGetDevicePropertyString(), FxObjectAllocateContext(), GetImageName(), FxUsbDevice::GetString(), FxUsbInterface::MakeAndConfigurePipes(), FxIoTargetRemote::Open(), FxObject::operator delete(), FxCallback::operator delete(), FxRelatedDeviceList::operator delete(), FxStump::operator delete(), FxDeviceText::operator delete(), FxStump::operator delete[](), FxObject::ProcessDestroy(), FxUsbDevice::SelectConfig(), FxUsbDevice::SelectConfigDescriptor(), FxUsbDevice::SelectConfigInterfaces(), FxUsbDevice::SelectConfigMulti(), FxUsbDevice::SelectConfigSingle(), FxUsbInterface::SelectSetting(), FxUsbInterface::SelectSettingByDescriptor(), FxUsbInterface::SelectSettingByIndex(), FxIoContext::SetBufferAndLength(), VfAddContextToHandle(), FxAutoString::~FxAutoString(), FxDevice::~FxDevice(), FxDeviceInterface::~FxDeviceInterface(), FxDeviceText::~FxDeviceText(), FxDriver::~FxDriver(), FxPagedObject::~FxPagedObject(), FxPkgPdo::~FxPkgPdo(), FxQueryInterface::~FxQueryInterface(), FxString::~FxString(), FxUsbDevice::~FxUsbDevice(), FxUsbDeviceStringContext::~FxUsbDeviceStringContext(), FxUsbInterface::~FxUsbInterface(), and FxIrpPreprocessInfo::Info::~Info().

FxPoolInitialize()

_Must_inspect_result_ NTSTATUS FxPoolInitialize	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PFX_POOL	Pool
	)

Definition at line 554 of file wdfpool.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPOOL,
                        "Initializing Pool 0x%p, Tracking %d",
                        Pool, FxDriverGlobals->IsPoolTrackingOn());
 
    Pool->NonPagedLock.Initialize();
 
    InitializeListHead( &Pool->NonPagedHead );
 
    status = Pool->PagedLock.Initialize();
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
                            "Initializing paged lock failed for Pool 0x%p, "
                            "status %!STATUS!",
                            Pool, status);
        goto exit;
    }
 
    InitializeListHead( &Pool->PagedHead );
 
    // Pool usage information
    Pool->NonPagedBytes = 0;
    Pool->PagedBytes = 0;
 
    Pool->NonPagedAllocations = 0;
    Pool->PagedAllocations = 0;
 
    Pool->PeakNonPagedBytes = 0;
    Pool->PeakPagedBytes = 0;
 
    Pool->PeakNonPagedAllocations = 0;
    Pool->PeakPagedAllocations = 0;
 
exit:
    if (!NT_SUCCESS(status)) {
        //
        // We disable pool tracking if we could not initialize the locks needed
        //
        // If we don't do this we would need another flag to make FxPoolDestroy
        // not access the locks
        //
        FxDriverGlobals->FxPoolTrackingOn = FALSE;
    }
 
    //
    // FxPoolDestroy will always be called even if we fail FxPoolInitialize
    //
    // FxPoolDestroy will uninitialize locks both in success and failure
    // cases
    //
 
    return status;
}

Referenced by FxPoolPackageInitialize().

FxPoolPackageDestroy()

VOID FxPoolPackageDestroy

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 689 of file wdfpool.cpp.

{
    FxPoolDestroy(FxDriverGlobals, &FxDriverGlobals->FxPoolFrameworks);
    return;
}

Referenced by FxDestroy().

FxPoolPackageInitialize()

_Must_inspect_result_ NTSTATUS FxPoolPackageInitialize

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 667 of file wdfpool.cpp.

{
    return FxPoolInitialize(FxDriverGlobals, &FxDriverGlobals->FxPoolFrameworks);
}

Referenced by FxInitialize().