fxbugcheckcallback.cpp File Reference

#include "fxcorepch.hpp"
#include "fxifr.h"
#include "fxifrkm.h"
#include "fxldr.h"
#include "fxbugcheck.h"
#include <aux_klib.h>
#include <ntimage.h>

Include dependency graph for fxbugcheckcallback.cpp:

Go to the source code of this file.

Functions
_Must_inspect_result_ BOOLEAN	FxpIsAddressKnownToWdf (__in PVOID Address, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
_Must_inspect_result_ NTSTATUS	FxpGetImageBase (__in PDRIVER_OBJECT DriverObject, __out PVOID *ImageBase, __out PULONG ImageSize)
_Must_inspect_result_ BOOLEAN	FxpBugCheckCallbackFilter (__inout PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID STDCALL	FxpBugCheckCallback (__in KBUGCHECK_CALLBACK_REASON Reason, __in PKBUGCHECK_REASON_CALLBACK_RECORD Record, __inout PVOID ReasonSpecificData, __in ULONG ReasonSpecificLength)
VOID	FxRegisterBugCheckCallback (__inout PFX_DRIVER_GLOBALS FxDriverGlobals, __in PDRIVER_OBJECT DriverObject)
VOID	FxUnregisterBugCheckCallback (__inout PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID STDCALL	FxpLibraryBugCheckCallback (__in KBUGCHECK_CALLBACK_REASON Reason, __in PKBUGCHECK_REASON_CALLBACK_RECORD, __inout PVOID ReasonSpecificData, __in ULONG ReasonSpecificLength)
VOID	FxInitializeBugCheckDriverInfo ()
VOID	FxUninitializeBugCheckDriverInfo ()
VOID	FxCacheBugCheckDriverInfo (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
VOID	FxPurgeBugCheckDriverInfo (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

Variables
KBUGCHECK_REASON_CALLBACK_ROUTINE	FxpBugCheckCallback
KBUGCHECK_REASON_CALLBACK_ROUTINE	FxpLibraryBugCheckCallback

Function Documentation

FxCacheBugCheckDriverInfo()

VOID FxCacheBugCheckDriverInfo

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 781 of file fxbugcheckcallback.cpp.

{
    KIRQL                       irql;
    PFX_DUMP_DRIVER_INFO_ENTRY  driverInfo      = NULL;
    PFX_DUMP_DRIVER_INFO_ENTRY  oldDriverInfo   = NULL;
    ULONG                       newCount        = 0;
 
    //
    // Clear driver index (0-based). Drivers do not use index 0.
    //
    FxDriverGlobals->BugCheckDriverInfoIndex = 0;
 
    if (NULL == FxLibraryGlobals.BugCheckDriverInfo) {
        return;
    }
 
    FxLibraryGlobals.FxDriverGlobalsListLock.Acquire(&irql);
 
    //
    // Make sure we have enough space, else allocate some more memory.
    //
    if (FxLibraryGlobals.BugCheckDriverInfoIndex >=
            FxLibraryGlobals.BugCheckDriverInfoCount) {
 
        //
        // Just exit if no more space in dump buffer.
        //
        if ((FX_MAX_DUMP_DRIVER_INFO_COUNT - FX_DUMP_DRIVER_INFO_INCREMENT) <
             FxLibraryGlobals.BugCheckDriverInfoCount) {
             ASSERT(FALSE);
             goto Done;
        }
 
        newCount = FxLibraryGlobals.BugCheckDriverInfoCount +
                      FX_DUMP_DRIVER_INFO_INCREMENT;
 
        //
        // Allocate new buffer to hold driver info.
        //
        driverInfo = (PFX_DUMP_DRIVER_INFO_ENTRY)MxMemory::MxAllocatePoolWithTag(
                                NonPagedPool,
                                sizeof(FX_DUMP_DRIVER_INFO_ENTRY)* newCount,
                                FX_TAG);
 
        if (NULL == driverInfo) {
            goto Done;
        }
 
        //
        // Copy data from old to new buffer.
        //
        RtlCopyMemory(driverInfo,
                      FxLibraryGlobals.BugCheckDriverInfo,
                      FxLibraryGlobals.BugCheckDriverInfoCount *
                        sizeof(FX_DUMP_DRIVER_INFO_ENTRY));
        //
        // Ok, replace global pointer and its count.
        //
        oldDriverInfo = FxLibraryGlobals.BugCheckDriverInfo;
        FxLibraryGlobals.BugCheckDriverInfo = driverInfo;
        FxLibraryGlobals.BugCheckDriverInfoCount = newCount;
        driverInfo = NULL; // just in case.
 
        //
        // Free old memory.
        //
        MxMemory::MxFreePool(oldDriverInfo);
        oldDriverInfo = NULL;
    }
 
    ASSERT(FxLibraryGlobals.BugCheckDriverInfoIndex <
                FxLibraryGlobals.BugCheckDriverInfoCount);
    //
    // Compute ptr to free entry.
    //
    driverInfo = FxLibraryGlobals.BugCheckDriverInfo +
                    FxLibraryGlobals.BugCheckDriverInfoIndex;
    //
    // Cache some of this driver's info.
    //
    driverInfo->FxDriverGlobals = FxDriverGlobals;
    driverInfo->Version = FxDriverGlobals->WdfBindInfo->Version;
 
    C_ASSERT(sizeof(driverInfo->DriverName) ==
                sizeof(FxDriverGlobals->Public.DriverName));
    RtlCopyMemory(driverInfo->DriverName,
                  FxDriverGlobals->Public.DriverName,
                  sizeof(driverInfo->DriverName));
    driverInfo->DriverName[ARRAY_SIZE(driverInfo->DriverName) - 1] = '\0';
 
    //
    // Cache this index for later when the driver is removed.
    //
    FxDriverGlobals->BugCheckDriverInfoIndex =
        FxLibraryGlobals.BugCheckDriverInfoIndex;
 
    //
    // Update global index.
    //
    FxLibraryGlobals.BugCheckDriverInfoIndex++;
 
Done:
 
    FxLibraryGlobals.FxDriverGlobalsListLock.Release(irql);
}

Referenced by FxInitialize().

FxInitializeBugCheckDriverInfo()

VOID FxInitializeBugCheckDriverInfo

(

)

Definition at line 627 of file fxbugcheckcallback.cpp.

{
    NTSTATUS                                 status;
    UNICODE_STRING                           funcName;
    PKBUGCHECK_REASON_CALLBACK_RECORD        callbackRecord;
    PFN_KE_REGISTER_BUGCHECK_REASON_CALLBACK funcPtr;
    SIZE_T                                   arraySize;
    ULONG                                    arrayCount;
 
 
    callbackRecord = &FxLibraryGlobals.BugCheckCallbackRecord;
    RtlZeroMemory(callbackRecord, sizeof(KBUGCHECK_REASON_CALLBACK_RECORD));
 
    FxLibraryGlobals.BugCheckDriverInfoCount = 0;
    FxLibraryGlobals.BugCheckDriverInfoIndex = 0;
    FxLibraryGlobals.BugCheckDriverInfo = NULL;
 
 
 
 
 
 
 
 
 
 
    //
    // The KeRegisterBugCheckReasonCallback exists for xp sp1 and above. So
    // check whether this function is defined on the current OS and register
    // for the bugcheck callback only if this function is defined.
    //
    RtlInitUnicodeString(&funcName, L"KeRegisterBugCheckReasonCallback");
    funcPtr = (PFN_KE_REGISTER_BUGCHECK_REASON_CALLBACK)
        MmGetSystemRoutineAddress(&funcName);
 
    if (NULL == funcPtr) {
        goto Done;
    }
 
    arraySize = sizeof(FX_DUMP_DRIVER_INFO_ENTRY) * FX_DUMP_DRIVER_INFO_INCREMENT;
    arrayCount = FX_DUMP_DRIVER_INFO_INCREMENT;
 
    FxLibraryGlobals.BugCheckDriverInfo =
        (PFX_DUMP_DRIVER_INFO_ENTRY)MxMemory::MxAllocatePoolWithTag(
                                    NonPagedPool,
                                    arraySize,
                                    FX_TAG);
 
    if (NULL == FxLibraryGlobals.BugCheckDriverInfo) {
        goto Done;
    }
 
    FxLibraryGlobals.BugCheckDriverInfoCount = arrayCount;
 
    //
    // Init first entry for the framework.
    //
    FxLibraryGlobals.BugCheckDriverInfo[0].FxDriverGlobals = NULL;
    FxLibraryGlobals.BugCheckDriverInfo[0].Version.Major = __WDF_MAJOR_VERSION;
    FxLibraryGlobals.BugCheckDriverInfo[0].Version.Minor = __WDF_MINOR_VERSION;
    FxLibraryGlobals.BugCheckDriverInfo[0].Version.Build = __WDF_BUILD_NUMBER;
 
    status = RtlStringCbCopyA(
                    FxLibraryGlobals.BugCheckDriverInfo[0].DriverName,
                    sizeof(FxLibraryGlobals.BugCheckDriverInfo[0].DriverName),
                    WdfLdrType);
 
    if (!NT_SUCCESS(status)) {
        ASSERT(FALSE);
        FxLibraryGlobals.BugCheckDriverInfo[0].DriverName[0] = '\0';
    }
 
    FxLibraryGlobals.BugCheckDriverInfoIndex++;
 
    //
    // Initialize the callback record.
    //
    KeInitializeCallbackRecord(callbackRecord);
 
    //
    // Register the bugcheck callback.
    //
    funcPtr(callbackRecord,
            FxpLibraryBugCheckCallback,
            KbCallbackSecondaryDumpData,
            (PUCHAR)WdfLdrType);
 
    ASSERT(callbackRecord->CallbackRoutine != NULL);
 
Done:;
}

Referenced by FxLibraryGlobalsCommission().

FxpBugCheckCallback()

VOID STDCALL FxpBugCheckCallback	(	__in KBUGCHECK_CALLBACK_REASON	Reason,
		__in PKBUGCHECK_REASON_CALLBACK_RECORD	Record,
		__inout PVOID	ReasonSpecificData,
		__in ULONG	ReasonSpecificLength
	)

Definition at line 306 of file fxbugcheckcallback.cpp.

{
    PKBUGCHECK_SECONDARY_DUMP_DATA dumpData;
    PFX_DRIVER_GLOBALS fxDriverGlobals;
    ULONG logSize;
    BOOLEAN writeLog = FALSE;
 
    UNREFERENCED_PARAMETER(Reason);
    UNREFERENCED_PARAMETER(ReasonSpecificLength);
 
    ASSERT(ReasonSpecificLength >= sizeof(KBUGCHECK_SECONDARY_DUMP_DATA));
    ASSERT(Reason == KbCallbackSecondaryDumpData);
 
    dumpData = (PKBUGCHECK_SECONDARY_DUMP_DATA) ReasonSpecificData;
 
    //
    // See if the IFR's minimum amount of data can fit in the dump
    //
    if (dumpData->MaximumAllowed < FxIFRMinLogSize) {
        return;
    }
 
    //
    // Get the driver globals containing the bugcheck callback record.
    //
    fxDriverGlobals = CONTAINING_RECORD(Record,
                                        FX_DRIVER_GLOBALS,
                                        BugCheckCallbackRecord);
 
    //
    // If there is not IFR data, then this bugcheck callback does not have any
    // data to write to the minidump.
    //
    if (NULL == fxDriverGlobals->WdfLogHeader) {
        return;
    }
 
    //
    // Size is the length of the buffer which we log to. It should also include
    // the size of the header (which was subtracted out in FxIFRStart).
    //
    logSize = ((PWDF_IFR_HEADER) fxDriverGlobals->WdfLogHeader)->Size +
              sizeof(WDF_IFR_HEADER);
 
    ASSERT(FxIFRMinLogSize <= logSize && logSize <= FxIFRMaxLogSize);
 
    //
    // Check whether log can fit in the dump.
    //
    if (logSize > dumpData->MaximumAllowed) {
        return;
    }
 
    //
    // Check whether this log is the one to copy.
    //
    if (FxpBugCheckCallbackFilter(fxDriverGlobals)) {
        //
        // Let everyone know that we got the best match.
        //
        FxLibraryGlobals.BestDriverForDumpLog = fxDriverGlobals;
 
        //
        // Exact match driver.
        //
        writeLog = TRUE;
    }
    else if (NULL == FxLibraryGlobals.BestDriverForDumpLog) {
        //
        // So far we didn't get a perfect match. Make a best effort
        // to find a good candidate for the driver dump log.
        //
        if (fxDriverGlobals->FxTrackDriverForMiniDumpLog &&
            FxLibraryGlobals.DriverTracker.GetCurrentTrackedDriver() ==
                fxDriverGlobals) {
            //
            // Best effort match driver.
            //
            writeLog = TRUE;
        }
    }
 
    if (writeLog) {
        dumpData->OutBuffer = fxDriverGlobals->WdfLogHeader;
        dumpData->OutBufferLength  = logSize;
        dumpData->Guid = WdfDumpGuid;
    }
}

FxpBugCheckCallbackFilter()

_Must_inspect_result_ BOOLEAN FxpBugCheckCallbackFilter

(

__inout PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 228 of file fxbugcheckcallback.cpp.

{
    PVOID codeAddr = NULL;
    BOOLEAN found = FALSE;
    KBUGCHECK_DATA bugCheckData = {0};
 
    if (FxDriverGlobals->FxForceLogsInMiniDump) {
        return TRUE;
    }
 
    //
    // Retrieve the bugcheck parameters.
    //
    bugCheckData.BugCheckDataSize = sizeof(KBUGCHECK_DATA);
    AuxKlibGetBugCheckData(&bugCheckData);
 
    //
    // Check whether the code address that caused the bugcheck is from this wdf
    // driver.
    //
    switch (bugCheckData.BugCheckCode) {
 
    case KERNEL_APC_PENDING_DURING_EXIT:                    // 0x20
        codeAddr = (PVOID)bugCheckData.Parameter1;
        found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
        break;
 
    case KMODE_EXCEPTION_NOT_HANDLED:                       // 0x1E
    case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED:               // 0x7E
    case KERNEL_MODE_EXCEPTION_NOT_HANDLED:                 // 0x8E
        codeAddr = (PVOID)bugCheckData.Parameter2;
        found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
        break;
 
    case PAGE_FAULT_IN_NONPAGED_AREA:                       // 0x50
        codeAddr = (PVOID)bugCheckData.Parameter3;
        found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
        break;
 
    case IRQL_NOT_LESS_OR_EQUAL:                            // 0xA
    case DRIVER_IRQL_NOT_LESS_OR_EQUAL:                     // 0xD1
        codeAddr = (PVOID)bugCheckData.Parameter4;
        found = FxpIsAddressKnownToWdf(codeAddr, FxDriverGlobals);
        break;
    }
 
    //
    // If the code address was found in the wdf driver, then set the flag in the
    // driver globals to indicate that the IFR data has to be written to the
    // mini-dump.
    //
    if (found) {
        FxDriverGlobals->FxForceLogsInMiniDump = TRUE;
    }
    return found;
}

Referenced by FxpBugCheckCallback().

FxpGetImageBase()

_Must_inspect_result_ NTSTATUS FxpGetImageBase	(	__in PDRIVER_OBJECT	DriverObject,
		__out PVOID *	ImageBase,
		__out PULONG	ImageSize
	)

Definition at line 122 of file fxbugcheckcallback.cpp.

{
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    ULONG modulesSize = 0;
    AUX_MODULE_EXTENDED_INFO* modules = NULL;
    AUX_MODULE_EXTENDED_INFO* module;
    PVOID addressInImage = NULL;
    ULONG numberOfModules;
    ULONG i;
 
    //
    // Basic validation.
    //
    if (NULL == DriverObject || NULL == ImageBase || NULL == ImageSize) {
        status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    //
    // Get the address of a well known entry in the Image.
    //
    addressInImage = (PVOID) DriverObject->DriverStart;
    ASSERT(addressInImage != NULL);
 
    //
    // Initialize the AUX Kernel Library.
    //
    status = AuxKlibInitialize();
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    //
    // Get size of area needed for loaded modules.
    //
    status = AuxKlibQueryModuleInformation(&modulesSize,
                                           sizeof(AUX_MODULE_EXTENDED_INFO),
                                           NULL);
 
    if (!NT_SUCCESS(status) || (0 == modulesSize)) {
        goto exit;
    }
 
    numberOfModules = modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO);
 
    //
    // Allocate returned-sized memory for the modules area.
    //
    modules = (AUX_MODULE_EXTENDED_INFO*) ExAllocatePoolWithTag(PagedPool,
                                                                modulesSize,
                                                                '30LW');
    if (NULL == modules) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto exit;
    }
 
    //
    // Request the modules array be filled with module information.
    //
    status = AuxKlibQueryModuleInformation(&modulesSize,
                                           sizeof(AUX_MODULE_EXTENDED_INFO),
                                           modules);
 
    if (!NT_SUCCESS(status)) {
        goto exit;
    }
 
    //
    // Traverse list, searching for the well known address in Image for which the
    // module's Image Base Address is in its range.
    //
    module = modules;
 
    for (i=0; i < numberOfModules; i++) {
 
        if (addressInImage >= module->BasicInfo.ImageBase &&
            addressInImage < WDF_PTR_ADD_OFFSET(module->BasicInfo.ImageBase,
                                                module->ImageSize)) {
 
            *ImageBase = module->BasicInfo.ImageBase;
            *ImageSize = module->ImageSize;
 
            status = STATUS_SUCCESS;
            goto exit;
        }
        module++;
    }
 
    status = STATUS_NOT_FOUND;
 
exit:
 
    if (modules != NULL) {
        ExFreePool(modules);
        modules = NULL;
    }
 
    return status;
}

Referenced by FxRegisterBugCheckCallback().

FxpIsAddressKnownToWdf()

_Must_inspect_result_ BOOLEAN FxpIsAddressKnownToWdf	(	__in PVOID	Address,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals
	)

Definition at line 75 of file fxbugcheckcallback.cpp.

{
 
    if (NULL == Address || NULL == FxDriverGlobals) {
        return FALSE;
    }
 
    if (Address >= FxDriverGlobals->ImageAddress &&
        Address < WDF_PTR_ADD_OFFSET(FxDriverGlobals->ImageAddress,
                                     FxDriverGlobals->ImageSize)) {
        return TRUE;
    }
 
    return FALSE;
}

Referenced by FxpBugCheckCallbackFilter().

FxpLibraryBugCheckCallback()

VOID STDCALL FxpLibraryBugCheckCallback	(	__in KBUGCHECK_CALLBACK_REASON	Reason,
		__in	PKBUGCHECK_REASON_CALLBACK_RECORD,
		__inout PVOID	ReasonSpecificData,
		__in ULONG	ReasonSpecificLength
	)

Definition at line 557 of file fxbugcheckcallback.cpp.

{
    PKBUGCHECK_SECONDARY_DUMP_DATA  dumpData;
    ULONG                           dumpSize;
 
    UNREFERENCED_PARAMETER(Reason);
    UNREFERENCED_PARAMETER(ReasonSpecificLength);
 
    ASSERT(ReasonSpecificLength >= sizeof(KBUGCHECK_SECONDARY_DUMP_DATA));
    ASSERT(Reason == KbCallbackSecondaryDumpData);
 
    dumpData = (PKBUGCHECK_SECONDARY_DUMP_DATA) ReasonSpecificData;
    dumpSize = FxLibraryGlobals.BugCheckDriverInfoIndex *
                sizeof(FX_DUMP_DRIVER_INFO_ENTRY);
    //
    // See if the bugcheck driver info is more than can fit in the dump
    //
    if (dumpData->MaximumAllowed < dumpSize) {
        dumpSize = EXP_ALIGN_DOWN_ON_BOUNDARY(
                        dumpData->MaximumAllowed,
                        sizeof(FX_DUMP_DRIVER_INFO_ENTRY));
    }
 
    if (0 == dumpSize) {
        goto Done;
    }
 
    //
    // Ok, provide the info about the bugcheck data.
    //
    dumpData->OutBuffer = FxLibraryGlobals.BugCheckDriverInfo;
    dumpData->OutBufferLength  = dumpSize;
    dumpData->Guid = WdfDumpGuid2;
 
Done:;
}

FxPurgeBugCheckDriverInfo()

VOID FxPurgeBugCheckDriverInfo

(

__in PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 890 of file fxbugcheckcallback.cpp.

{
    KIRQL                       irql;
    PFX_DUMP_DRIVER_INFO_ENTRY  driverInfo  = NULL;
    ULONG                       driverIndex = 0;
    ULONG                       shiftCount  = 0;
    ULONG                       i           = 0;
 
    FxLibraryGlobals.FxDriverGlobalsListLock.Acquire(&irql);
 
    //
    // Zero means 'not used'.
    //
    driverIndex = FxDriverGlobals->BugCheckDriverInfoIndex;
    if (0 == driverIndex) {
        goto Done;
    }
 
    //
    // Check if feature is not supported.
    //
    if (NULL == FxLibraryGlobals.BugCheckDriverInfo) {
        ASSERT(FALSE); // driverIndex > 0 with NULL array?
        goto Done;
    }
 
 
    ASSERT(FxLibraryGlobals.BugCheckDriverInfoIndex <=
            FxLibraryGlobals.BugCheckDriverInfoCount);
 
    //
    // Index boundary validation.
    //
    if (driverIndex >= FxLibraryGlobals.BugCheckDriverInfoIndex) {
        ASSERT(FALSE);
        goto Done;
    }
 
    //
    // Compute ptr to driver info.
    //
    driverInfo = FxLibraryGlobals.BugCheckDriverInfo + driverIndex;
 
    //
    // Double-check that this is the same driver.
    //
    if (driverInfo->FxDriverGlobals != FxDriverGlobals) {
        ASSERT(FALSE);
        goto Done;
    }
 
    //
    // Shift memory to fill hole and update global free index.
    //
    shiftCount = FxLibraryGlobals.BugCheckDriverInfoIndex - driverIndex - 1;
    if (shiftCount > 0) {
        RtlMoveMemory(driverInfo,
                      driverInfo + 1,
                      shiftCount * sizeof(FX_DUMP_DRIVER_INFO_ENTRY));
    }
 
    FxLibraryGlobals.BugCheckDriverInfoIndex--;
 
    //
    // Update cached index for all 'shifted' drivers.
    //
    for (i = driverIndex; i < FxLibraryGlobals.BugCheckDriverInfoIndex; ++i) {
        FxLibraryGlobals.BugCheckDriverInfo[i].FxDriverGlobals->
                BugCheckDriverInfoIndex--;
    }
 
Done:
 
    FxLibraryGlobals.FxDriverGlobalsListLock.Release(irql);
}

Referenced by FxDestroy().

FxRegisterBugCheckCallback()

VOID FxRegisterBugCheckCallback	(	__inout PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PDRIVER_OBJECT	DriverObject
	)

Definition at line 428 of file fxbugcheckcallback.cpp.

{
    UNICODE_STRING funcName;
    PKBUGCHECK_REASON_CALLBACK_RECORD callbackRecord;
    PFN_KE_REGISTER_BUGCHECK_REASON_CALLBACK funcPtr;
    BOOLEAN enableDriverTracking;
 
    //
    // If any problem during this setup, disable driver tracking.
    //
    enableDriverTracking = FxDriverGlobals->FxTrackDriverForMiniDumpLog;
    FxDriverGlobals->FxTrackDriverForMiniDumpLog = FALSE;
 
    //
    // Zero out callback record.
    //
    callbackRecord = &FxDriverGlobals->BugCheckCallbackRecord;
    RtlZeroMemory(callbackRecord, sizeof(KBUGCHECK_REASON_CALLBACK_RECORD));
 
    //
    // Get the Image base address and size before registering the bugcheck
    // callbacks. If the image base address and size cannot be computed,
    // then the bugcheck callbacks depend on these values being properly
    // set.
    //
    FxDriverGlobals->ImageAddress = NULL;
    FxDriverGlobals->ImageSize = 0;
 
    if (!NT_SUCCESS(FxpGetImageBase(DriverObject,
                                   &FxDriverGlobals->ImageAddress,
                                   &FxDriverGlobals->ImageSize))) {
        goto Done;
    }
 
 
 
 
 
 
 
 
 
 
    //
    // The KeRegisterBugCheckReasonCallback exists for xp sp1 and above. So
    // check whether this function is defined on the current OS and register
    // for the bugcheck callback only if this function is defined.
    //
    RtlInitUnicodeString(&funcName, L"KeRegisterBugCheckReasonCallback");
    funcPtr = (PFN_KE_REGISTER_BUGCHECK_REASON_CALLBACK)
        MmGetSystemRoutineAddress(&funcName);
 
    if (NULL == funcPtr) {
        goto Done;
    }
 
    //
    // Register this driver with driver tracker.
    //
    if (enableDriverTracking) {
        if (NT_SUCCESS(FxLibraryGlobals.DriverTracker.Register(
                            FxDriverGlobals))) {
            FxDriverGlobals->FxTrackDriverForMiniDumpLog = TRUE;
        }
    }
 
    //
    // Initialize the callback record.
    //
    KeInitializeCallbackRecord(callbackRecord);
 
    //
    // Register the bugcheck callback.
    //
    funcPtr(callbackRecord,
            FxpBugCheckCallback,
            KbCallbackSecondaryDumpData,
            (PUCHAR)FxDriverGlobals->Public.DriverName);
 
    ASSERT(callbackRecord->CallbackRoutine != NULL);
 
Done:;
}

Referenced by FxInitialize().

FxUninitializeBugCheckDriverInfo()

VOID FxUninitializeBugCheckDriverInfo

(

)

Definition at line 720 of file fxbugcheckcallback.cpp.

{
    UNICODE_STRING                              funcName;
    PKBUGCHECK_REASON_CALLBACK_RECORD           callbackRecord;
    PFN_KE_DEREGISTER_BUGCHECK_REASON_CALLBACK  funcPtr;
 
    //
    // Deregister callback.
    //
 
 
 
 
 
 
 
    callbackRecord = &FxLibraryGlobals.BugCheckCallbackRecord;
    if (NULL == callbackRecord->CallbackRoutine) {
        goto Done;
    }
 
    //
    // The KeDeregisterBugCheckReasonCallback exists for xp sp1 and above. So
    // check whether this function is defined on the current OS and deregister
    // from the bugcheck callback only if this function is defined.
    //
    RtlInitUnicodeString(&funcName, L"KeDeregisterBugCheckReasonCallback");
    funcPtr = (PFN_KE_DEREGISTER_BUGCHECK_REASON_CALLBACK)
        MmGetSystemRoutineAddress(&funcName);
 
    if (NULL == funcPtr) {
        goto Done;
    }
 
    funcPtr(callbackRecord);
    callbackRecord->CallbackRoutine = NULL;
 
    //
    // Release memory.
    //
    if (NULL == FxLibraryGlobals.BugCheckDriverInfo) {
        goto Done;
    }
 
    //
    // Dynamic KMDF framework is unloading, make sure there is only one entry
    // left in the driver info array; the framework lib was using this entry
    // to store its version.
    //
    ASSERT(1 == FxLibraryGlobals.BugCheckDriverInfoIndex);
 
    FxLibraryGlobals.BugCheckDriverInfoIndex = 0;
    FxLibraryGlobals.BugCheckDriverInfoCount = 0;
 
    MxMemory::MxFreePool(FxLibraryGlobals.BugCheckDriverInfo);
    FxLibraryGlobals.BugCheckDriverInfo = NULL;
 
Done:;
}

Referenced by FxLibraryGlobalsDecommission().

FxUnregisterBugCheckCallback()

VOID FxUnregisterBugCheckCallback

(

__inout PFX_DRIVER_GLOBALS

FxDriverGlobals

)

Definition at line 516 of file fxbugcheckcallback.cpp.

{
    UNICODE_STRING funcName;
    PKBUGCHECK_REASON_CALLBACK_RECORD callbackRecord;
    PFN_KE_DEREGISTER_BUGCHECK_REASON_CALLBACK funcPtr;
 
    callbackRecord = &FxDriverGlobals->BugCheckCallbackRecord;
    if (NULL == callbackRecord->CallbackRoutine) {
        goto Done;
    }
 
    //
    // The KeDeregisterBugCheckReasonCallback exists for xp sp1 and above. So
    // check whether this function is defined on the current OS and deregister
    // from the bugcheck callback only if this function is defined.
    //
    RtlInitUnicodeString(&funcName, L"KeDeregisterBugCheckReasonCallback");
    funcPtr = (PFN_KE_DEREGISTER_BUGCHECK_REASON_CALLBACK)
        MmGetSystemRoutineAddress(&funcName);
 
    if (NULL == funcPtr) {
        goto Done;
    }
 
    funcPtr(callbackRecord);
    callbackRecord->CallbackRoutine = NULL;
 
    //
    // Deregister this driver with driver tracker.
    //
    if (FxDriverGlobals->FxTrackDriverForMiniDumpLog) {
        FxLibraryGlobals.DriverTracker.Deregister(FxDriverGlobals);
    }
 
Done:;
}

Referenced by FxDestroy().

Variable Documentation

FxpBugCheckCallback

KBUGCHECK_REASON_CALLBACK_ROUTINE FxpBugCheckCallback

Definition at line 69 of file fxbugcheckcallback.cpp.

Referenced by FxRegisterBugCheckCallback().

FxpLibraryBugCheckCallback

KBUGCHECK_REASON_CALLBACK_ROUTINE FxpLibraryBugCheckCallback

Definition at line 71 of file fxbugcheckcallback.cpp.

Referenced by FxInitializeBugCheckDriverInfo().