_FX_DRIVER_TRACKER_CACHE_AWARE Struct Reference

#include <fxglobalskm.h>

Collaboration diagram for _FX_DRIVER_TRACKER_CACHE_AWARE:

Classes
struct	_FX_DRIVER_TRACKER_ENTRY

Public Member Functions
_Must_inspect_result_ NTSTATUS	Initialize ()
VOID	Uninitialize ()
_Must_inspect_result_ NTSTATUS	Register (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	Deregister (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
__inline VOID	TrackDriver (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
_Must_inspect_result_ __inline PFX_DRIVER_GLOBALS	GetCurrentTrackedDriver ()

Private Types
typedef struct _FX_DRIVER_TRACKER_CACHE_AWARE::_FX_DRIVER_TRACKER_ENTRY	FX_DRIVER_TRACKER_ENTRY
typedef struct _FX_DRIVER_TRACKER_CACHE_AWARE::_FX_DRIVER_TRACKER_ENTRY *	PFX_DRIVER_TRACKER_ENTRY

Private Member Functions
__inline PFX_DRIVER_TRACKER_ENTRY	GetProcessorDriverEntryRef (__in ULONG Index)

Private Attributes
PFX_DRIVER_TRACKER_ENTRY	m_DriverUsage
PVOID	m_PoolToFree
ULONG	m_EntrySize
ULONG	m_Number

Detailed Description

Definition at line 348 of file fxglobalskm.h.

Member Typedef Documentation

FX_DRIVER_TRACKER_ENTRY

typedef struct _FX_DRIVER_TRACKER_CACHE_AWARE::_FX_DRIVER_TRACKER_ENTRY _FX_DRIVER_TRACKER_CACHE_AWARE::FX_DRIVER_TRACKER_ENTRY

private

PFX_DRIVER_TRACKER_ENTRY

typedef struct _FX_DRIVER_TRACKER_CACHE_AWARE::_FX_DRIVER_TRACKER_ENTRY * _FX_DRIVER_TRACKER_CACHE_AWARE::PFX_DRIVER_TRACKER_ENTRY

private

Member Function Documentation

Deregister()

VOID FX_DRIVER_TRACKER_CACHE_AWARE::Deregister

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 1183 of file fxbugcheckcallback.cpp.

{
    ULONG                     index       = 0;
    PFX_DRIVER_TRACKER_ENTRY  driverUsage = NULL;
 
    //
    // Cleanup any refs to this driver's globals.
    //
    if (m_PoolToFree != NULL) {
 
        ASSERT(m_DriverUsage != NULL && m_Number != 0);
 
        for (index = 0; index < m_Number; ++index) {
            driverUsage = GetProcessorDriverEntryRef(index);
            if (driverUsage->FxDriverGlobals == FxDriverGlobals) {
                driverUsage->FxDriverGlobals = NULL;
            }
        }
    }
}

Referenced by FxUnregisterBugCheckCallback().

GetCurrentTrackedDriver()

_Must_inspect_result_ __inline PFX_DRIVER_GLOBALS _FX_DRIVER_TRACKER_CACHE_AWARE::GetCurrentTrackedDriver ( )

inline

Definition at line 405 of file fxglobalskm.h.

    {
        PFX_DRIVER_GLOBALS fxDriverGlobals = NULL;
 
        ASSERT(m_PoolToFree != NULL);
 
        fxDriverGlobals = GetProcessorDriverEntryRef(
            KeGetCurrentProcessorIndex())->FxDriverGlobals;
 
        return fxDriverGlobals;
    }

Referenced by FxpBugCheckCallback().

GetProcessorDriverEntryRef()

__inline PFX_DRIVER_TRACKER_ENTRY _FX_DRIVER_TRACKER_CACHE_AWARE::GetProcessorDriverEntryRef ( __in ULONG  Index )

inlineprivate

Definition at line 427 of file fxglobalskm.h.

    {
        return ((PFX_DRIVER_TRACKER_ENTRY) (((PUCHAR)m_DriverUsage) +
                    Index * m_EntrySize));
    }

Referenced by Deregister(), GetCurrentTrackedDriver(), Register(), TrackDriver(), and Uninitialize().

Initialize()

NTSTATUS FX_DRIVER_TRACKER_CACHE_AWARE::Initialize

(

)

Definition at line 972 of file fxbugcheckcallback.cpp.

{
    //
    // Global initialization. It balances the global Uninitialize function.
    // The real init is actually done by the Register function the first time
    // a driver registers with the device tracker.
    //
    m_DriverUsage   = NULL;
    m_PoolToFree    = NULL;
    m_EntrySize     = 0;
    m_Number        = 0;
 
    return STATUS_SUCCESS;
}

Referenced by FxLibraryGlobalsCommission().

Register()

NTSTATUS FX_DRIVER_TRACKER_CACHE_AWARE::Register

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 1008 of file fxbugcheckcallback.cpp.

{
    NTSTATUS                    status      = STATUS_UNSUCCESSFUL;
    ULONG                       paddedSize  = 0;
    ULONG                       index       = 0;
    PFX_DRIVER_TRACKER_ENTRY    pool        = NULL;
    PFX_DRIVER_TRACKER_ENTRY    driverUsage = NULL;
    UNICODE_STRING              funcName;
    PVOID                       funcPtr     = NULL;
 
    //
    // Nothing to do if tracker is already initialized. No need for a lock
    // here since PnP already serializes driver initialization.
    //
    if (m_PoolToFree != NULL) {
        ASSERT(m_DriverUsage != NULL && m_Number != 0);
        status = STATUS_SUCCESS;
        goto Done;
    }
 
    //
    // Intialize the procgrp down level library.
    //
    // WdmlibProcgrpInitialize(); __REACTOS__ : haha we don't support ProcGrp
 
    //
    // Capture maximum number of processors.
    //
    RtlInitUnicodeString(&funcName, L"KeQueryMaximumProcessorCountEx");
    funcPtr = MmGetSystemRoutineAddress(&funcName);
    if (funcPtr != NULL) {
        //
        // Win 7 and forward.
        //
        m_Number = ((PFN_KE_QUERY_MAXIMUM_PROCESSOR_COUNT_EX)funcPtr)(
                            ALL_PROCESSOR_GROUPS);
    }
    else {
        RtlInitUnicodeString(&funcName, L"KeQueryMaximumProcessorCount");
        funcPtr = MmGetSystemRoutineAddress(&funcName);
        if (funcPtr != NULL) {
            //
            // Windows Server 2008.
            //
            m_Number = ((PFN_KE_QUERY_MAXIMUM_PROCESSOR_COUNT)funcPtr)();
        }
        else {
            if ((5 == FxLibraryGlobals.OsVersionInfo.dwMajorVersion &&
                 0 <  FxLibraryGlobals.OsVersionInfo.dwMinorVersion) ||
                (6 == FxLibraryGlobals.OsVersionInfo.dwMajorVersion &&
                 0 == FxLibraryGlobals.OsVersionInfo.dwMinorVersion)){
                //
                // XP (Major=5, Minor>0) and Vista (Major=6, Minor=0).
                //
                m_Number = (ULONG)(*((CCHAR *)&KeNumberProcessors));
            }
            else {
                //
                // This feature is not supported for Windows 2000.
                //
                ASSERT(FALSE);
                status = STATUS_NOT_SUPPORTED;
                goto Done;
            }
        }
    }
 
    //
    // Validate upper bound.
    //
    if (m_Number > FX_DRIVER_TRACKER_MAX_CPUS) {
        status = STATUS_NOT_SUPPORTED;
        goto Done;
    }
 
    //
    // Determine padded size of each tracking entry structure.
    //
    if (m_Number > 1 ) {
        RtlInitUnicodeString(&funcName, L"KeGetRecommendedSharedDataAlignment");
        funcPtr = MmGetSystemRoutineAddress(&funcName);
 
        if (funcPtr != NULL) {
            //
            //XP and forward
            //
            paddedSize = ((PFN_KE_GET_RECOMMENDED_SHARED_DATA_ALIGNMENT)funcPtr)();
            ASSERT ((paddedSize & (paddedSize - 1)) == 0);
        }
        else {
            //
            // This feature is not supported for Windows 2000.
            //
            status = STATUS_NOT_SUPPORTED;
            goto Done;
        }
    }
    else {
        paddedSize = sizeof(FX_DRIVER_TRACKER_ENTRY);
    }
 
    ASSERT(sizeof(FX_DRIVER_TRACKER_ENTRY) <= paddedSize);
 
    //
    // Remember the size.
    //
    m_EntrySize = paddedSize;
 
    pool = (PFX_DRIVER_TRACKER_ENTRY)MxMemory::MxAllocatePoolWithTag(
                                        NonPagedPool,
                                        paddedSize * m_Number,
                                        FX_TAG);
    if (NULL == pool) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Done;
    }
 
    //
    // Check if pool is aligned if this is a multi-proc.
    //
    if ((m_Number > 1) && !EXP_IS_PTR_ALIGNED_ON_BOUNDARY(pool, paddedSize)) {
        //
        // We will allocate a padded size, free the old pool.
        //
        ExFreePool(pool);
 
        //
        // Allocate enough padding so we can start the refs on an aligned boundary
        //
        pool = (PFX_DRIVER_TRACKER_ENTRY)MxMemory::MxAllocatePoolWithTag(
                                        NonPagedPool,
                                        paddedSize * m_Number + paddedSize,
                                        FX_TAG);
        if (NULL == pool) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Done;
        }
 
        driverUsage = (PFX_DRIVER_TRACKER_ENTRY)
                            EXP_ALIGN_UP_PTR_ON_BOUNDARY(pool, paddedSize);
 
    }
    else {
        //
        // Already aligned pool.
        //
        driverUsage = pool;
    }
 
    //
    // Remember the pool block to free.
    //
    m_PoolToFree  = pool;
    m_DriverUsage = driverUsage;
 
    //
    // Init driver usage entries.
    //
    for (index = 0; index < m_Number; ++index) {
        driverUsage = GetProcessorDriverEntryRef(index);
        driverUsage->FxDriverGlobals = NULL;
    }
 
    //
    // All done.
    //
    status = STATUS_SUCCESS;
 
Done:
    return status;
}

Referenced by FxRegisterBugCheckCallback().

TrackDriver()

__inline VOID _FX_DRIVER_TRACKER_CACHE_AWARE::TrackDriver ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals )

inline

Definition at line 386 of file fxglobalskm.h.

    {
        ASSERT(m_PoolToFree != NULL);
 
        GetProcessorDriverEntryRef(
            KeGetCurrentProcessorIndex())->FxDriverGlobals =
                FxDriverGlobals;
    }

Referenced by FX_TRACK_DRIVER().

Uninitialize()

VOID FX_DRIVER_TRACKER_CACHE_AWARE::Uninitialize

(

)

Definition at line 988 of file fxbugcheckcallback.cpp.

{
    if (m_PoolToFree != NULL) {
 
#ifdef DBG
    for (ULONG index = 0; index < m_Number; ++index) {
        PFX_DRIVER_TRACKER_ENTRY driverUsage = NULL;
        driverUsage = GetProcessorDriverEntryRef(index);
        ASSERT(NULL == driverUsage->FxDriverGlobals);
    }
#endif
        MxMemory::MxFreePool(m_PoolToFree);
        m_PoolToFree = NULL;
    }
 
    m_DriverUsage   = NULL;
    m_Number        = 0;
}

Referenced by FxLibraryGlobalsDecommission().

Member Data Documentation

m_DriverUsage

PFX_DRIVER_TRACKER_ENTRY _FX_DRIVER_TRACKER_CACHE_AWARE::m_DriverUsage

private

Definition at line 442 of file fxglobalskm.h.

Referenced by Deregister(), GetProcessorDriverEntryRef(), Initialize(), Register(), and Uninitialize().

m_EntrySize

ULONG _FX_DRIVER_TRACKER_CACHE_AWARE::m_EntrySize

private

Definition at line 452 of file fxglobalskm.h.

Referenced by GetProcessorDriverEntryRef(), Initialize(), and Register().

m_Number

ULONG _FX_DRIVER_TRACKER_CACHE_AWARE::m_Number

private

Definition at line 457 of file fxglobalskm.h.

Referenced by Deregister(), Initialize(), Register(), and Uninitialize().

m_PoolToFree

PVOID _FX_DRIVER_TRACKER_CACHE_AWARE::m_PoolToFree

private

Definition at line 447 of file fxglobalskm.h.

Referenced by Deregister(), GetCurrentTrackedDriver(), Initialize(), Register(), TrackDriver(), and Uninitialize().

---

The documentation for this struct was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/km/fxglobalskm.h
• sdk/lib/drivers/wdf/kmdf/src/core/fxbugcheckcallback.cpp