bug.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for bug.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	TAG_KNMI   'IMNK'

Functions
PVOID NTAPI	KiPcToFileHeader (IN PVOID Pc, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry, IN BOOLEAN DriversOnly, OUT PBOOLEAN InKernel)
PVOID NTAPI	KiRosPcToUserFileHeader (IN PVOID Pc, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry)
USHORT NTAPI	KeRosCaptureUserStackBackTrace (IN ULONG FramesToSkip, IN ULONG FramesToCapture, OUT PVOID *BackTrace, OUT PULONG BackTraceHash OPTIONAL)
VOID FASTCALL	KeRosDumpStackFrameArray (IN PULONG_PTR Frames, IN ULONG FrameCount)
VOID NTAPI	KeRosDumpStackFrames (IN PULONG_PTR Frame OPTIONAL, IN ULONG FrameCount OPTIONAL)
VOID NTAPI	KeRosDumpTriageForBugZillaReport (VOID)
VOID INIT_FUNCTION NTAPI	KiInitializeBugCheck (VOID)
BOOLEAN NTAPI	KeGetBugMessageText (IN ULONG BugCheckCode, OUT PANSI_STRING OutputString OPTIONAL)
VOID NTAPI	KiDoBugCheckCallbacks (VOID)
VOID NTAPI	KiBugCheckDebugBreak (IN ULONG StatusCode)
PCHAR NTAPI	KeBugCheckUnicodeToAnsi (IN PUNICODE_STRING Unicode, OUT PCHAR Ansi, IN ULONG Length)
VOID NTAPI	KiDumpParameterImages (IN PCHAR Message, IN PULONG_PTR Parameters, IN ULONG ParameterCount, IN PKE_BUGCHECK_UNICODE_TO_ANSI ConversionRoutine)
VOID NTAPI	KiDisplayBlueScreen (IN ULONG MessageId, IN BOOLEAN IsHardError, IN PCHAR HardErrCaption OPTIONAL, IN PCHAR HardErrMessage OPTIONAL, IN PCHAR Message)
VOID NTAPI	KeBugCheckWithTf (IN ULONG BugCheckCode, IN ULONG_PTR BugCheckParameter1, IN ULONG_PTR BugCheckParameter2, IN ULONG_PTR BugCheckParameter3, IN ULONG_PTR BugCheckParameter4, IN PKTRAP_FRAME TrapFrame)
BOOLEAN NTAPI	KiHandleNmi (VOID)
NTSTATUS NTAPI	KeInitializeCrashDumpHeader (IN ULONG Type, IN ULONG Flags, OUT PVOID Buffer, IN ULONG BufferSize, OUT ULONG BufferNeeded OPTIONAL)
BOOLEAN NTAPI	KeDeregisterBugCheckCallback (IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord)
BOOLEAN NTAPI	KeDeregisterBugCheckReasonCallback (IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord)
BOOLEAN NTAPI	KeRegisterBugCheckCallback (IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord, IN PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine, IN PVOID Buffer, IN ULONG Length, IN PUCHAR Component)
BOOLEAN NTAPI	KeRegisterBugCheckReasonCallback (IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord, IN PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine, IN KBUGCHECK_CALLBACK_REASON Reason, IN PUCHAR Component)
PVOID NTAPI	KeRegisterNmiCallback (IN PNMI_CALLBACK CallbackRoutine, IN PVOID Context)
NTSTATUS NTAPI	KeDeregisterNmiCallback (IN PVOID Handle)
VOID NTAPI	KeBugCheckEx (IN ULONG BugCheckCode, IN ULONG_PTR BugCheckParameter1, IN ULONG_PTR BugCheckParameter2, IN ULONG_PTR BugCheckParameter3, IN ULONG_PTR BugCheckParameter4)
VOID NTAPI	KeBugCheck (ULONG BugCheckCode)
VOID NTAPI	KeEnterKernelDebugger (VOID)

Variables
LIST_ENTRY	KeBugcheckCallbackListHead
LIST_ENTRY	KeBugcheckReasonCallbackListHead
KSPIN_LOCK	BugCheckCallbackLock
ULONG	KeBugCheckActive
ULONG	KeBugCheckOwner
LONG	KeBugCheckOwnerRecursionCount
PMESSAGE_RESOURCE_DATA	KiBugCodeMessages
ULONG	KeBugCheckCount = 1
ULONG	KiHardwareTrigger
PUNICODE_STRING	KiBugCheckDriver
ULONG_PTR	KiBugCheckData [5]
PKNMI_HANDLER_CALLBACK	KiNmiCallbackListHead = NULL
KSPIN_LOCK	KiNmiCallbackListLock
UNICODE_STRING	KeRosProcessorName
UNICODE_STRING	KeRosBiosDate
UNICODE_STRING	KeRosBiosVersion
UNICODE_STRING	KeRosVideoBiosDate
UNICODE_STRING	KeRosVideoBiosVersion

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file bug.c.

TAG_KNMI

#define TAG_KNMI   'IMNK'

Definition at line 34 of file bug.c.

Function Documentation

KeBugCheck()

VOID NTAPI KeBugCheck

(

ULONG

BugCheckCode

)

Definition at line 1469 of file bug.c.

{
    /* Call the internal API */
    KeBugCheckWithTf(BugCheckCode, 0, 0, 0, 0, NULL);
}

Referenced by abort(), CcInitCacheZeroPage(), CcpDereferenceCache(), CcReadVirtualAddress(), CcRosMapVacbInKernelSpace(), CcRosMarkDirtyFile(), CcRosRequestVacb(), CcScheduleReadAhead(), CcWriteVirtualAddress(), ClassSendStartUnit(), ExeFmtpReadFile(), ExInitSystem(), ExpInitializeExecutive(), ExpInitNls(), FsRtlCreateSectionForDataScan(), HalpAssignPCISlotResources(), HalpInitializeTsc(), i8042KbdInterruptService(), KdbEnterDebuggerException(), KdpCauseBugCheck(), KeDetachProcess(), Kei386EoiHelper(), KeRaiseIrqlToDpcLevel(), KeUnstackDetachProcess(), KeWaitForMultipleObjects(), KfLowerIrql(), KfRaiseIrql(), KiDispatchException(), KiInitializeCpu(), KiSetAffinityThread(), KiSystemStartupBootStack(), KiThreadStartup(), KiUnexpectedInterrupt(), MiBalancerThread(), MiInitBalancerThread(), MiReadPageFile(), MiRosUnmapViewOfSection(), MiTrimMemoryConsumer(), MmAccessFaultSectionView(), MmAllocPage(), MmAllocSwapPage(), MmCreatePageFileMapping(), MmCreatePhysicalMemorySection(), MmCreateVirtualMapping(), MmCreateVirtualMappingUnsafe(), MmDeleteAllRmaps(), MmDeletePageFileMapping(), MmDeleteRmap(), MmFreeSectionPage(), MmFreeSectionSegments(), MmFreeSwapPage(), MmGetPageTableForProcess(), MmInsertRmap(), MmNotPresentFaultCachePage(), MmNotPresentFaultSectionView(), MmPageOutPhysicalAddress(), MmPageOutSectionView(), MmpPageOutPhysicalAddress(), MmReleasePageMemoryConsumer(), MmRequestPageMemoryConsumer(), MmSetCleanAllRmaps(), MmSetCleanPage(), MmSetDirtyAllRmaps(), MmSetDirtyPage(), MmSetPageProtect(), MmSharePageEntrySectionSegment(), MmspPageAlignSegments(), MmUnsharePageEntrySectionSegment(), MmWritePageSectionView(), MmWriteToSwapPage(), MupDereferenceMasterQueryContext(), Phase1InitializationDiscard(), PpInitSystem(), ProtectToPTE(), PspDeleteProcess(), PspDeleteThread(), PspSystemThreadStartup(), RawDispatch(), ScsiClassReleaseQueue(), TdiAddressSizeFromType(), USBCCGP_PDOSelectConfiguration(), UserProcessCreate(), VfatReadFileData(), and VfatWriteFileData().

KeBugCheckEx()

VOID NTAPI KeBugCheckEx	(	IN ULONG	BugCheckCode,
		IN ULONG_PTR	BugCheckParameter1,
		IN ULONG_PTR	BugCheckParameter2,
		IN ULONG_PTR	BugCheckParameter3,
		IN ULONG_PTR	BugCheckParameter4
	)

Definition at line 1449 of file bug.c.

{
    /* Call the internal API */
    KeBugCheckWithTf(BugCheckCode,
                     BugCheckParameter1,
                     BugCheckParameter2,
                     BugCheckParameter3,
                     BugCheckParameter4,
                     NULL);
}

KeBugCheckUnicodeToAnsi()

PCHAR NTAPI KeBugCheckUnicodeToAnsi	(	IN PUNICODE_STRING	Unicode,
		OUT PCHAR	Ansi,
		IN ULONG	Length
	)

Definition at line 552 of file bug.c.

{
    PCHAR p;
    PWCHAR pw;
    ULONG i;

    /* Set length and normalize it */
    i = Unicode->Length / sizeof(WCHAR);
    i = min(i, Length - 1);

    /* Set source and destination, and copy */
    pw = Unicode->Buffer;
    p = Ansi;
    while (i--) *p++ = (CHAR)*pw++;

    /* Null terminate and return */
    *p = ANSI_NULL;
    return Ansi;
}

Referenced by KeBugCheckWithTf(), KeRosDumpStackFrameArray(), and KiDisplayBlueScreen().

KeBugCheckWithTf()

VOID NTAPI KeBugCheckWithTf	(	IN ULONG	BugCheckCode,
		IN ULONG_PTR	BugCheckParameter1,
		IN ULONG_PTR	BugCheckParameter2,
		IN ULONG_PTR	BugCheckParameter3,
		IN ULONG_PTR	BugCheckParameter4,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 744 of file bug.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    CONTEXT Context;
    ULONG MessageId;
    CHAR AnsiName[128];
    BOOLEAN IsSystem, IsHardError = FALSE, Reboot = FALSE;
    PCHAR HardErrCaption = NULL, HardErrMessage = NULL;
    PVOID Pc = NULL, Memory;
    PVOID DriverBase;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    PULONG_PTR HardErrorParameters;
    KIRQL OldIrql;
#ifdef CONFIG_SMP
    LONG i = 0;
#endif

    /* Set active bugcheck */
    KeBugCheckActive = TRUE;
    KiBugCheckDriver = NULL;

    /* Check if this is power failure simulation */
    if (BugCheckCode == POWER_FAILURE_SIMULATE)
    {
        /* Call the Callbacks and reboot */
        KiDoBugCheckCallbacks();
        HalReturnToFirmware(HalRebootRoutine);
    }

    /* Save the IRQL and set hardware trigger */
    Prcb->DebuggerSavedIRQL = KeGetCurrentIrql();
    InterlockedIncrement((PLONG)&KiHardwareTrigger);

    /* Capture the CPU Context */
    RtlCaptureContext(&Prcb->ProcessorState.ContextFrame);
    KiSaveProcessorControlState(&Prcb->ProcessorState);
    Context = Prcb->ProcessorState.ContextFrame;

    /* FIXME: Call the Watchdog if it's registered */

    /* Check which bugcode this is */
    switch (BugCheckCode)
    {
        /* These bug checks already have detailed messages, keep them */
        case UNEXPECTED_KERNEL_MODE_TRAP:
        case DRIVER_CORRUPTED_EXPOOL:
        case ACPI_BIOS_ERROR:
        case ACPI_BIOS_FATAL_ERROR:
        case THREAD_STUCK_IN_DEVICE_DRIVER:
        case DATA_BUS_ERROR:
        case FAT_FILE_SYSTEM:
        case NO_MORE_SYSTEM_PTES:
        case INACCESSIBLE_BOOT_DEVICE:

            /* Keep the same code */
            MessageId = BugCheckCode;
            break;

        /* Check if this is a kernel-mode exception */
        case KERNEL_MODE_EXCEPTION_NOT_HANDLED:
        case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED:
        case KMODE_EXCEPTION_NOT_HANDLED:

            /* Use the generic text message */
            MessageId = KMODE_EXCEPTION_NOT_HANDLED;
            break;

        /* File-system errors */
        case NTFS_FILE_SYSTEM:

            /* Use the generic message for FAT */
            MessageId = FAT_FILE_SYSTEM;
            break;

        /* Check if this is a coruption of the Mm's Pool */
        case DRIVER_CORRUPTED_MMPOOL:

            /* Use generic corruption message */
            MessageId = DRIVER_CORRUPTED_EXPOOL;
            break;

        /* Check if this is a signature check failure */
        case STATUS_SYSTEM_IMAGE_BAD_SIGNATURE:

            /* Use the generic corruption message */
            MessageId = BUGCODE_PSS_MESSAGE_SIGNATURE;
            break;

        /* All other codes */
        default:

            /* Use the default bugcheck message */
            MessageId = BUGCODE_PSS_MESSAGE;
            break;
    }

    /* Save bugcheck data */
    KiBugCheckData[0] = BugCheckCode;
    KiBugCheckData[1] = BugCheckParameter1;
    KiBugCheckData[2] = BugCheckParameter2;
    KiBugCheckData[3] = BugCheckParameter3;
    KiBugCheckData[4] = BugCheckParameter4;

    /* Now check what bugcheck this is */
    switch (BugCheckCode)
    {
        /* Invalid access to R/O memory or Unhandled KM Exception */
        case KERNEL_MODE_EXCEPTION_NOT_HANDLED:
        case ATTEMPTED_WRITE_TO_READONLY_MEMORY:
        case ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY:

            /* Check if we have a trap frame */
            if (!TrapFrame)
            {
                /* Use parameter 3 as a trap frame, if it exists */
                if (BugCheckParameter3) TrapFrame = (PVOID)BugCheckParameter3;
            }

            /* Check if we got one now and if we need to get the Program Counter */
            if ((TrapFrame) &&
                (BugCheckCode != KERNEL_MODE_EXCEPTION_NOT_HANDLED))
            {
                /* Get the Program Counter */
                Pc = (PVOID)KeGetTrapFramePc(TrapFrame);
            }
            break;

        /* Wrong IRQL */
        case IRQL_NOT_LESS_OR_EQUAL:

            /*
             * The NT kernel has 3 special sections:
             * MISYSPTE, POOLMI and POOLCODE. The bug check code can
             * determine in which of these sections this bugcode happened
             * and provide a more detailed analysis. For now, we don't.
             */

            /* Program Counter is in parameter 4 */
            Pc = (PVOID)BugCheckParameter4;

            /* Get the driver base */
            DriverBase = KiPcToFileHeader(Pc,
                                          &LdrEntry,
                                          FALSE,
                                          &IsSystem);
            if (IsSystem)
            {
                /*
                 * The error happened inside the kernel or HAL.
                 * Get the memory address that was being referenced.
                 */
                Memory = (PVOID)BugCheckParameter1;

                /* Find to which driver it belongs */
                DriverBase = KiPcToFileHeader(Memory,
                                              &LdrEntry,
                                              TRUE,
                                              &IsSystem);
                if (DriverBase)
                {
                    /* Get the driver name and update the bug code */
                    KiBugCheckDriver = &LdrEntry->BaseDllName;
                    KiBugCheckData[0] = DRIVER_PORTION_MUST_BE_NONPAGED;
                }
                else
                {
                    /* Find the driver that unloaded at this address */
                    KiBugCheckDriver = NULL; // FIXME: ROS can't locate

                    /* Check if the cause was an unloaded driver */
                    if (KiBugCheckDriver)
                    {
                        /* Update bug check code */
                        KiBugCheckData[0] =
                            SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD;
                    }
                }
            }
            else
            {
                /* Update the bug check code */
                KiBugCheckData[0] = DRIVER_IRQL_NOT_LESS_OR_EQUAL;
            }

            /* Clear Pc so we don't look it up later */
            Pc = NULL;
            break;

        /* Hard error */
        case FATAL_UNHANDLED_HARD_ERROR:

            /* Copy bug check data from hard error */
            HardErrorParameters = (PULONG_PTR)BugCheckParameter2;
            KiBugCheckData[0] = BugCheckParameter1;
            KiBugCheckData[1] = HardErrorParameters[0];
            KiBugCheckData[2] = HardErrorParameters[1];
            KiBugCheckData[3] = HardErrorParameters[2];
            KiBugCheckData[4] = HardErrorParameters[3];

            /* Remember that this is hard error and set the caption/message */
            IsHardError = TRUE;
            HardErrCaption = (PCHAR)BugCheckParameter3;
            HardErrMessage = (PCHAR)BugCheckParameter4;
            break;

        /* Page fault */
        case PAGE_FAULT_IN_NONPAGED_AREA:

            /* Assume no driver */
            DriverBase = NULL;

            /* Check if we have a trap frame */
            if (!TrapFrame)
            {
                /* We don't, use parameter 3 if possible */
                if (BugCheckParameter3) TrapFrame = (PVOID)BugCheckParameter3;
            }

            /* Check if we have a frame now */
            if (TrapFrame)
            {
                /* Get the Program Counter */
                Pc = (PVOID)KeGetTrapFramePc(TrapFrame);
                KiBugCheckData[3] = (ULONG_PTR)Pc;

                /* Find out if was in the kernel or drivers */
                DriverBase = KiPcToFileHeader(Pc,
                                              &LdrEntry,
                                              FALSE,
                                              &IsSystem);
            }
            else
            {
                /* Can't blame a driver, assume system */
                IsSystem = TRUE;
            }

            /* FIXME: Check for session pool in addition to special pool */

            /* Special pool has its own bug check codes */
            if (MmIsSpecialPoolAddress((PVOID)BugCheckParameter1))
            {
                if (MmIsSpecialPoolAddressFree((PVOID)BugCheckParameter1))
                {
                    KiBugCheckData[0] = IsSystem
                        ? PAGE_FAULT_IN_FREED_SPECIAL_POOL
                        : DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL;
                }
                else
                {
                    KiBugCheckData[0] = IsSystem
                        ? PAGE_FAULT_BEYOND_END_OF_ALLOCATION
                        : DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION;
                }
            }
            else if (!DriverBase)
            {
                /* Find the driver that unloaded at this address */
                KiBugCheckDriver = NULL; // FIXME: ROS can't locate

                /* Check if the cause was an unloaded driver */
                if (KiBugCheckDriver)
                {
                    KiBugCheckData[0] =
                        DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS;
                }
            }
            break;

        /* Check if the driver forgot to unlock pages */
        case DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS:

            /* Program Counter is in parameter 1 */
            Pc = (PVOID)BugCheckParameter1;
            break;

        /* Check if the driver consumed too many PTEs */
        case DRIVER_USED_EXCESSIVE_PTES:

            /* Loader entry is in parameter 1 */
            LdrEntry = (PVOID)BugCheckParameter1;
            KiBugCheckDriver = &LdrEntry->BaseDllName;
            break;

        /* Check if the driver has a stuck thread */
        case THREAD_STUCK_IN_DEVICE_DRIVER:

            /* The name is in Parameter 3 */
            KiBugCheckDriver = (PVOID)BugCheckParameter3;
            break;

        /* Anything else */
        default:
            break;
    }

    /* Do we have a driver name? */
    if (KiBugCheckDriver)
    {
        /* Convert it to ANSI */
        KeBugCheckUnicodeToAnsi(KiBugCheckDriver, AnsiName, sizeof(AnsiName));
    }
    else
    {
        /* Do we have a Program Counter? */
        if (Pc)
        {
            /* Dump image name */
            KiDumpParameterImages(AnsiName,
                                  (PULONG_PTR)&Pc,
                                  1,
                                  KeBugCheckUnicodeToAnsi);
        }
    }

    /* Check if we need to save the context for KD */
#ifdef _WINKD_
    if (!KdPitchDebugger) KdDebuggerDataBlock.SavedContext = (ULONG_PTR)&Context;
#endif

    /* Check if a debugger is connected */
    if ((BugCheckCode != MANUALLY_INITIATED_CRASH) && (KdDebuggerEnabled))
    {
        /* Crash on the debugger console */
        DbgPrint("\n*** Fatal System Error: 0x%08lx\n"
                 "                       (0x%p,0x%p,0x%p,0x%p)\n\n",
                 KiBugCheckData[0],
                 KiBugCheckData[1],
                 KiBugCheckData[2],
                 KiBugCheckData[3],
                 KiBugCheckData[4]);

        /* Check if the debugger isn't currently connected */
        if (!KdDebuggerNotPresent)
        {
            /* Check if we have a driver to blame */
            if (KiBugCheckDriver)
            {
                /* Dump it */
                DbgPrint("Driver at fault: %s.\n", AnsiName);
            }

            /* Check if this was a hard error */
            if (IsHardError)
            {
                /* Print caption and message */
                if (HardErrCaption) DbgPrint(HardErrCaption);
                if (HardErrMessage) DbgPrint(HardErrMessage);
            }

            /* Break in the debugger */
            KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_FIRST);
        }
        else
        {
            /*
             * ROS HACK.
             * Ok, so debugging is enabled, but KDBG isn't there.
             * We'll manually dump the stack for the user.
             */
            KeRosDumpStackFrames(NULL, 0);

            /* ROS HACK 2: Generate something useful for Bugzilla */
            KeRosDumpTriageForBugZillaReport();
        }
    }

    /* Raise IRQL to HIGH_LEVEL */
    _disable();
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);

    /* Avoid recursion */
    if (!InterlockedDecrement((PLONG)&KeBugCheckCount))
    {
#ifdef CONFIG_SMP
        /* Set CPU that is bug checking now */
        KeBugCheckOwner = Prcb->Number;

        /* Freeze the other CPUs */
        for (i = 0; i < KeNumberProcessors; i++)
        {
            if (i != (LONG)KeGetCurrentProcessorNumber())
            {
                /* Send the IPI and give them one second to catch up */
                KiIpiSend(1 << i, IPI_FREEZE);
                KeStallExecutionProcessor(1000000);
            }
        }
#endif

        /* Display the BSOD */
        KiDisplayBlueScreen(MessageId,
                            IsHardError,
                            HardErrCaption,
                            HardErrMessage,
                            AnsiName);

        /* Check if the debugger is disabled but we can enable it */
        if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
        {
            /* Enable it */
#ifdef _WINKD_
            KdEnableDebuggerWithLock(FALSE);
#endif
        }
        else
        {
            /* Otherwise, print the last line */
            InbvDisplayString("\r\n");
        }

        /* Save the context */
        Prcb->ProcessorState.ContextFrame = Context;

        /* FIXME: Support Triage Dump */

        /* FIXME: Write the crash dump */
    }
    else
    {
        /* Increase recursion count */
        KeBugCheckOwnerRecursionCount++;
        if (KeBugCheckOwnerRecursionCount == 2)
        {
            /* Break in the debugger */
            KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_SECOND);
        }
        else if (KeBugCheckOwnerRecursionCount > 2)
        {
            /* Halt execution */
            while (TRUE);
        }
    }

    /* Call the Callbacks */
    KiDoBugCheckCallbacks();

    /* FIXME: Call Watchdog if enabled */

    /* Check if we have to reboot */
    if (Reboot)
    {
        /* Unload symbols */
        DbgUnLoadImageSymbols(NULL, (PVOID)MAXULONG_PTR, 0);
        HalReturnToFirmware(HalRebootRoutine);
    }

    /* Attempt to break in the debugger (otherwise halt CPU) */
    KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_SECOND);

    /* Shouldn't get here */
    ASSERT(FALSE);
    while (TRUE);
}

Referenced by KeBugCheck(), and KeBugCheckEx().

KeDeregisterBugCheckCallback()

BOOLEAN NTAPI KeDeregisterBugCheckCallback

(

IN PKBUGCHECK_CALLBACK_RECORD

CallbackRecord

)

Definition at line 1246 of file bug.c.

{
    KIRQL OldIrql;
    BOOLEAN Status = FALSE;

    /* Raise IRQL to High */
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);

    /* Check the Current State */
    if (CallbackRecord->State == BufferInserted)
    {
        /* Reset state and remove from list */
        CallbackRecord->State = BufferEmpty;
        RemoveEntryList(&CallbackRecord->Entry);
        Status = TRUE;
    }

    /* Lower IRQL and return */
    KeLowerIrql(OldIrql);
    return Status;
}

Referenced by NdisMDeregisterAdapterShutdownHandler().

KeDeregisterBugCheckReasonCallback()

BOOLEAN NTAPI KeDeregisterBugCheckReasonCallback

(

IN PKBUGCHECK_REASON_CALLBACK_RECORD

CallbackRecord

)

Definition at line 1273 of file bug.c.

{
    KIRQL OldIrql;
    BOOLEAN Status = FALSE;

    /* Raise IRQL to High */
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);

    /* Check the Current State */
    if (CallbackRecord->State == BufferInserted)
    {
        /* Reset state and remove from list */
        CallbackRecord->State = BufferEmpty;
        RemoveEntryList(&CallbackRecord->Entry);
        Status = TRUE;
    }

    /* Lower IRQL and return */
    KeLowerIrql(OldIrql);
    return Status;
}

KeDeregisterNmiCallback()

NTSTATUS NTAPI KeDeregisterNmiCallback

(

IN PVOID

Handle

)

Definition at line 1405 of file bug.c.

{
    KIRQL OldIrql;
    PKNMI_HANDLER_CALLBACK NmiData;
    PKNMI_HANDLER_CALLBACK* Previous;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);

    /* Find in the list the NMI callback corresponding to the handle */
    KiAcquireNmiListLock(&OldIrql);
    Previous = &KiNmiCallbackListHead;
    NmiData = *Previous;
    while (NmiData)
    {
        if (NmiData->Handle == Handle)
        {
            /* The handle is the pointer to the callback itself */
            ASSERT(Handle == NmiData);

            /* Found it, remove from the list */
            *Previous = NmiData->Next;
            break;
        }

        /* Not found; try again */
        Previous = &NmiData->Next;
        NmiData = *Previous;
    }
    KiReleaseNmiListLock(OldIrql);

    /* If we have found the entry, free it */
    if (NmiData)
    {
        ExFreePoolWithTag(NmiData, TAG_KNMI);
        return STATUS_SUCCESS;
    }

    return STATUS_INVALID_HANDLE;
}

KeEnterKernelDebugger()

VOID NTAPI KeEnterKernelDebugger

(

VOID

)

Definition at line 1480 of file bug.c.

{
    /* Disable interrupts */
    KiHardwareTrigger = 1;
    _disable();

    /* Check the bugcheck count */
    if (!InterlockedDecrement((PLONG)&KeBugCheckCount))
    {
        /* There was only one, is the debugger disabled? */
        if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
        {
            /* Enable the debugger */
            KdInitSystem(0, NULL);
        }
    }

    /* Break in the debugger */
    KiBugCheckDebugBreak(DBG_STATUS_FATAL);
}

KeGetBugMessageText()

BOOLEAN NTAPI KeGetBugMessageText	(	IN ULONG	BugCheckCode,
		OUT PANSI_STRING OutputString	OPTIONAL
	)

Definition at line 406 of file bug.c.

{
    ULONG i, j;
    ULONG IdOffset;
    ULONG_PTR MessageEntry;
    PCHAR BugCode;
    BOOLEAN Result = FALSE;
    USHORT Length;

    /* Make sure we're not bugchecking too early */
    if (!KiBugCodeMessages) return Result;

    /* Find the message. This code is based on RtlFindMesssage */
    for (i = 0; i < KiBugCodeMessages->NumberOfBlocks; i++)
    {
        /* Check if the ID Matches */
        if ((BugCheckCode >= KiBugCodeMessages->Blocks[i].LowId) &&
            (BugCheckCode <= KiBugCodeMessages->Blocks[i].HighId))
        {
            /* Get Offset to Entry */
            MessageEntry = KiBugCodeMessages->Blocks[i].OffsetToEntries +
                           (ULONG_PTR)KiBugCodeMessages;
            IdOffset = BugCheckCode - KiBugCodeMessages->Blocks[i].LowId;

            /* Get offset to ID */
            for (j = 0; j < IdOffset; j++)
            {
                /* Advance in the Entries */
                MessageEntry += ((PMESSAGE_RESOURCE_ENTRY)MessageEntry)->
                                Length;
            }

            /* Get the final Code */
            BugCode = (PCHAR)((PMESSAGE_RESOURCE_ENTRY)MessageEntry)->Text;
            Length = (USHORT)strlen(BugCode);

            /* Handle trailing newlines */
            while ((Length > 0) && ((BugCode[Length] == '\n') ||
                                    (BugCode[Length] == '\r') ||
                                    (BugCode[Length] == ANSI_NULL)))
            {
                /* Check if we have a string to return */
                if (!OutputString) BugCode[Length] = ANSI_NULL;
                Length--;
            }

            /* Check if caller wants an output string */
            if (OutputString)
            {
                /* Return it in the OutputString */
                OutputString->Buffer = BugCode;
                OutputString->Length = Length + 1;
                OutputString->MaximumLength = Length + 1;
            }
            else
            {
                /* Direct Output to Screen */
                InbvDisplayString(BugCode);
                InbvDisplayString("\r");
            }

            /* We're done */
            Result = TRUE;
            break;
        }
    }

    /* Return the result */
    return Result;
}

Referenced by KiDisplayBlueScreen().

KeInitializeCrashDumpHeader()

NTSTATUS NTAPI KeInitializeCrashDumpHeader	(	IN ULONG	Type,
		IN ULONG	Flags,
		OUT PVOID	Buffer,
		IN ULONG	BufferSize,
		OUT ULONG BufferNeeded	OPTIONAL
	)

Definition at line 1231 of file bug.c.

{
    UNIMPLEMENTED;
    return STATUS_UNSUCCESSFUL;
}

KeRegisterBugCheckCallback()

BOOLEAN NTAPI KeRegisterBugCheckCallback	(	IN PKBUGCHECK_CALLBACK_RECORD	CallbackRecord,
		IN PKBUGCHECK_CALLBACK_ROUTINE	CallbackRoutine,
		IN PVOID	Buffer,
		IN ULONG	Length,
		IN PUCHAR	Component
	)

Definition at line 1301 of file bug.c.

{
    KIRQL OldIrql;
    BOOLEAN Status = FALSE;

    /* Raise IRQL to High */
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);

    /* Check the Current State first so we don't double-register */
    if (CallbackRecord->State == BufferEmpty)
    {
        /* Set the Callback Settings and insert into the list */
        CallbackRecord->Length = Length;
        CallbackRecord->Buffer = Buffer;
        CallbackRecord->Component = Component;
        CallbackRecord->CallbackRoutine = CallbackRoutine;
        CallbackRecord->State = BufferInserted;
        InsertTailList(&KeBugcheckCallbackListHead, &CallbackRecord->Entry);
        Status = TRUE;
    }

    /* Lower IRQL and return */
    KeLowerIrql(OldIrql);
    return Status;
}

Referenced by NdisMRegisterAdapterShutdownHandler().

KeRegisterBugCheckReasonCallback()

BOOLEAN NTAPI KeRegisterBugCheckReasonCallback	(	IN PKBUGCHECK_REASON_CALLBACK_RECORD	CallbackRecord,
		IN PKBUGCHECK_REASON_CALLBACK_ROUTINE	CallbackRoutine,
		IN KBUGCHECK_CALLBACK_REASON	Reason,
		IN PUCHAR	Component
	)

Definition at line 1336 of file bug.c.

{
    KIRQL OldIrql;
    BOOLEAN Status = FALSE;

    /* Raise IRQL to High */
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);

    /* Check the Current State first so we don't double-register */
    if (CallbackRecord->State == BufferEmpty)
    {
        /* Set the Callback Settings and insert into the list */
        CallbackRecord->Component = Component;
        CallbackRecord->CallbackRoutine = CallbackRoutine;
        CallbackRecord->State = BufferInserted;
        CallbackRecord->Reason = Reason;
        InsertTailList(&KeBugcheckReasonCallbackListHead,
                       &CallbackRecord->Entry);
        Status = TRUE;
    }

    /* Lower IRQL and return */
    KeLowerIrql(OldIrql);
    return Status;
}

KeRegisterNmiCallback()

PVOID NTAPI KeRegisterNmiCallback	(	IN PNMI_CALLBACK	CallbackRoutine,
		IN PVOID	Context
	)

Definition at line 1371 of file bug.c.

{
    KIRQL OldIrql;
    PKNMI_HANDLER_CALLBACK NmiData, Next;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);

    /* Allocate NMI callback data */
    NmiData = ExAllocatePoolWithTag(NonPagedPool, sizeof(*NmiData), TAG_KNMI);
    if (!NmiData) return NULL;

    /* Fill in the information */
    NmiData->Callback = CallbackRoutine;
    NmiData->Context = Context;
    NmiData->Handle = NmiData;

    /* Insert it into NMI callback list */
    KiAcquireNmiListLock(&OldIrql);
    NmiData->Next = KiNmiCallbackListHead;
    Next = InterlockedCompareExchangePointer((PVOID*)&KiNmiCallbackListHead,
                                             NmiData,
                                             NmiData->Next);
    ASSERT(Next == NmiData->Next);
    KiReleaseNmiListLock(OldIrql);

    /* Return the opaque "handle" */
    return NmiData->Handle;
}

Referenced by DriverEntry().

KeRosCaptureUserStackBackTrace()

USHORT NTAPI KeRosCaptureUserStackBackTrace	(	IN ULONG	FramesToSkip,
		IN ULONG	FramesToCapture,
		OUT PVOID *	BackTrace,
		OUT PULONG BackTraceHash	OPTIONAL
	)

Definition at line 158 of file bug.c.

{
    PVOID Frames[2 * 64];
    ULONG FrameCount;
    ULONG Hash = 0, i;

    /* Skip a frame for the caller */
    FramesToSkip++;

    /* Don't go past the limit */
    if ((FramesToCapture + FramesToSkip) >= 128) return 0;

    /* Do the back trace */
    FrameCount = RtlWalkFrameChain(Frames, FramesToCapture + FramesToSkip, 1);

    /* Make sure we're not skipping all of them */
    if (FrameCount <= FramesToSkip) return 0;

    /* Loop all the frames */
    for (i = 0; i < FramesToCapture; i++)
    {
        /* Don't go past the limit */
        if ((FramesToSkip + i) >= FrameCount) break;

        /* Save this entry and hash it */
        BackTrace[i] = Frames[FramesToSkip + i];
        Hash += PtrToUlong(BackTrace[i]);
    }

    /* Write the hash */
    if (BackTraceHash) *BackTraceHash = Hash;

    /* Clear the other entries and return count */
    RtlFillMemoryUlong(Frames, 128, 0);
    return (USHORT)i;
}

Referenced by KeRosDumpStackFrames().

KeRosDumpStackFrameArray()

VOID FASTCALL KeRosDumpStackFrameArray	(	IN PULONG_PTR	Frames,
		IN ULONG	FrameCount
	)

Definition at line 201 of file bug.c.

{
    ULONG i;
    ULONG_PTR Addr;
    BOOLEAN InSystem;
    PVOID p;

    /* GCC complaints that it may be used uninitialized */
    PLDR_DATA_TABLE_ENTRY LdrEntry = NULL;

    /* Loop them */
    for (i = 0; i < FrameCount; i++)
    {
        /* Get the EIP */
        Addr = Frames[i];
        if (!Addr)
        {
            break;
        }

        /* Get the base for this file */
        if (Addr > (ULONG_PTR)MmHighestUserAddress)
        {
            /* We are in kernel */
            p = KiPcToFileHeader((PVOID)Addr, &LdrEntry, FALSE, &InSystem);
        }
        else
        {
            /* We are in user land */
            p = KiRosPcToUserFileHeader((PVOID)Addr, &LdrEntry);
        }
        if (p)
        {
#ifdef KDBG
            if (!KdbSymPrintAddress((PVOID)Addr, NULL))
#endif
            {
                CHAR AnsiName[64];

                /* Convert module name to ANSI and print it */
                KeBugCheckUnicodeToAnsi(&LdrEntry->BaseDllName,
                                        AnsiName,
                                        sizeof(AnsiName));
                Addr -= (ULONG_PTR)LdrEntry->DllBase;
                DbgPrint("<%s: %p>", AnsiName, (PVOID)Addr);
            }
        }
        else
        {
            /* Print only the address */
            DbgPrint("<%p>", (PVOID)Addr);
        }

        /* Go to the next frame */
        DbgPrint("\n");
    }
}

Referenced by KeRosDumpStackFrames().

KeRosDumpStackFrames()

VOID NTAPI KeRosDumpStackFrames	(	IN PULONG_PTR Frame	OPTIONAL,
		IN ULONG FrameCount	OPTIONAL
	)

Definition at line 262 of file bug.c.

{
    ULONG_PTR Frames[32];
    ULONG RealFrameCount;

    /* If the caller didn't ask, assume 32 frames */
    if (!FrameCount || FrameCount > 32) FrameCount = 32;

    if (Frame)
    {
        /* Dump them */
        KeRosDumpStackFrameArray(Frame, FrameCount);
    }
    else
    {
        /* Get the current frames (skip the two. One for the dumper, one for the caller) */
        RealFrameCount = RtlCaptureStackBackTrace(2, FrameCount, (PVOID*)Frames, NULL);
        DPRINT1("RealFrameCount =%lu\n", RealFrameCount);

        /* Dump them */
        KeRosDumpStackFrameArray(Frames, RealFrameCount);

        /* Count left for user mode? */
        if (FrameCount - RealFrameCount > 0)
        {
            /* Get the current frames */
            RealFrameCount = KeRosCaptureUserStackBackTrace(-1, FrameCount - RealFrameCount, (PVOID*)Frames, NULL);

            /* Dump them */
            KeRosDumpStackFrameArray(Frames, RealFrameCount);
        }
    }
}

Referenced by KeBugCheckWithTf().

KeRosDumpTriageForBugZillaReport()

VOID NTAPI KeRosDumpTriageForBugZillaReport

(

VOID

)

Definition at line 299 of file bug.c.

{
#if 0
    extern BOOLEAN KiFastSystemCallDisable, KiSMTProcessorsPresent;
    extern ULONG KeI386MachineType, MxcsrFeatureMask;
    extern BOOLEAN Ke386Pae, Ke386NoExecute;

    DbgPrint("ReactOS has crashed! Please go to http://jira.reactos.org/ to file a bug!\n");
    DbgPrint("\nHardware Information\n");
    DbgPrint("Processor Architecture: %d\n"
             "Feature Bits: %d\n"
             "System Call Disabled: %d\n"
             "NPX Present: %d\n"
             "MXCsr Mask: %d\n"
             "MXCsr Feature Mask: %d\n"
             "XMMI Present: %d\n"
             "FXSR Present: %d\n"
             "Machine Type: %d\n"
             "PAE: %d\n"
             "NX: %d\n"
             "Processors: %d\n"
             "Active Processors: %d\n"
             "Pentium LOCK Bug: %d\n"
             "Hyperthreading: %d\n"
             "CPU Manufacturer: %s\n"
             "CPU Name: %wZ\n"
             "CPUID: %d\n"
             "CPU Type: %d\n"
             "CPU Stepping: %d\n"
             "CPU Speed: %d\n"
             "CPU L2 Cache: %d\n"
             "BIOS Date: %wZ\n"
             "BIOS Version: %wZ\n"
             "Video BIOS Date: %wZ\n"
             "Video BIOS Version: %wZ\n"
             "Memory: %d\n",
             KeProcessorArchitecture,
             KeFeatureBits,
             KiFastSystemCallDisable,
             KeI386NpxPresent,
             KiMXCsrMask,
             MxcsrFeatureMask,
             KeI386XMMIPresent,
             KeI386FxsrPresent,
             KeI386MachineType,
             Ke386Pae,
             Ke386NoExecute,
             KeNumberProcessors,
             KeActiveProcessors,
             KiI386PentiumLockErrataPresent,
             KiSMTProcessorsPresent,
             KeGetCurrentPrcb()->VendorString,
             &KeRosProcessorName,
             KeGetCurrentPrcb()->CpuID,
             KeGetCurrentPrcb()->CpuType,
             KeGetCurrentPrcb()->CpuStep,
             KeGetCurrentPrcb()->MHz,
             ((PKIPCR)KeGetPcr())->SecondLevelCacheSize,
             &KeRosBiosDate,
             &KeRosBiosVersion,
             &KeRosVideoBiosDate,
             &KeRosVideoBiosVersion,
             MmNumberOfPhysicalPages * PAGE_SIZE);
#endif
}

Referenced by KeBugCheckWithTf().

KiBugCheckDebugBreak()

VOID NTAPI KiBugCheckDebugBreak

(

IN ULONG

StatusCode

)

Definition at line 527 of file bug.c.

{
    /*
     * Wrap this in SEH so we don't crash if
     * there is no debugger or if it disconnected
     */
DoBreak:
    _SEH2_TRY
    {
        /* Breakpoint */
        DbgBreakPointWithStatus(StatusCode);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* No debugger, halt the CPU */
        HalHaltSystem();
    }
    _SEH2_END;

    /* Break again if this wasn't first try */
    if (StatusCode != DBG_STATUS_BUGCHECK_FIRST) goto DoBreak;
}

Referenced by KeBugCheckWithTf(), and KeEnterKernelDebugger().

KiDisplayBlueScreen()

VOID NTAPI KiDisplayBlueScreen	(	IN ULONG	MessageId,
		IN BOOLEAN	IsHardError,
		IN PCHAR HardErrCaption	OPTIONAL,
		IN PCHAR HardErrMessage	OPTIONAL,
		IN PCHAR	Message
	)

Definition at line 646 of file bug.c.

{
    CHAR AnsiName[75];

    /* Check if bootvid is installed */
    if (InbvIsBootDriverInstalled())
    {
        /* Acquire ownership and reset the display */
        InbvAcquireDisplayOwnership();
        InbvResetDisplay();

        /* Display blue screen */
        InbvSolidColorFill(0, 0, 639, 479, 4);
        InbvSetTextColor(15);
        InbvInstallDisplayStringFilter(NULL);
        InbvEnableDisplayString(TRUE);
        InbvSetScrollRegion(0, 0, 639, 479);
    }

    /* Check if this is a hard error */
    if (IsHardError)
    {
        /* Display caption and message */
        if (HardErrCaption) InbvDisplayString(HardErrCaption);
        if (HardErrMessage) InbvDisplayString(HardErrMessage);
    }

    /* Begin the display */
    InbvDisplayString("\r\n");

    /* Print out initial message */
    KeGetBugMessageText(BUGCHECK_MESSAGE_INTRO, NULL);
    InbvDisplayString("\r\n\r\n");

    /* Check if we have a driver */
    if (KiBugCheckDriver)
    {
        /* Print out into to driver name */
        KeGetBugMessageText(BUGCODE_ID_DRIVER, NULL);

        /* Convert and print out driver name */
        KeBugCheckUnicodeToAnsi(KiBugCheckDriver, AnsiName, sizeof(AnsiName));
        InbvDisplayString(" ");
        InbvDisplayString(AnsiName);
        InbvDisplayString("\r\n\r\n");
    }

    /* Check if this is the generic message */
    if (MessageId == BUGCODE_PSS_MESSAGE)
    {
        /* It is, so get the bug code string as well */
        KeGetBugMessageText((ULONG)KiBugCheckData[0], NULL);
        InbvDisplayString("\r\n\r\n");
    }

    /* Print second introduction message */
    KeGetBugMessageText(PSS_MESSAGE_INTRO, NULL);
    InbvDisplayString("\r\n\r\n");

    /* Get the bug code string */
    KeGetBugMessageText(MessageId, NULL);
    InbvDisplayString("\r\n\r\n");

    /* Print message for technical information */
    KeGetBugMessageText(BUGCHECK_TECH_INFO, NULL);

    /* Show the technical Data */
    sprintf(AnsiName,
            "\r\n\r\n*** STOP: 0x%08lX (0x%p,0x%p,0x%p,0x%p)\r\n\r\n",
            (ULONG)KiBugCheckData[0],
            (PVOID)KiBugCheckData[1],
            (PVOID)KiBugCheckData[2],
            (PVOID)KiBugCheckData[3],
            (PVOID)KiBugCheckData[4]);
    InbvDisplayString(AnsiName);

    /* Check if we have a driver*/
    if (KiBugCheckDriver)
    {
        /* Display technical driver data */
        InbvDisplayString(Message);
    }
    else
    {
        /* Dump parameter information */
        KiDumpParameterImages(Message,
                              (PVOID)&KiBugCheckData[1],
                              4,
                              KeBugCheckUnicodeToAnsi);
    }
}

Referenced by KeBugCheckWithTf().

KiDoBugCheckCallbacks()

VOID NTAPI KiDoBugCheckCallbacks

(

VOID

)

Definition at line 480 of file bug.c.

{
    PKBUGCHECK_CALLBACK_RECORD CurrentRecord;
    PLIST_ENTRY ListHead, NextEntry, LastEntry;
    ULONG_PTR Checksum;

    /* First make sure that the list is Initialized... it might not be */
    ListHead = &KeBugcheckCallbackListHead;
    if ((ListHead->Flink) && (ListHead->Blink))
    {
        /* Loop the list */
        LastEntry = ListHead;
        NextEntry = ListHead->Flink;
        while (NextEntry != ListHead)
        {
            /* Get the reord */
            CurrentRecord = CONTAINING_RECORD(NextEntry,
                                              KBUGCHECK_CALLBACK_RECORD,
                                              Entry);

            /* Validate it */
            if (CurrentRecord->Entry.Blink != LastEntry) return;
            Checksum = (ULONG_PTR)CurrentRecord->CallbackRoutine;
            Checksum += (ULONG_PTR)CurrentRecord->Buffer;
            Checksum += (ULONG_PTR)CurrentRecord->Length;
            Checksum += (ULONG_PTR)CurrentRecord->Component;

            /* Make sure it's inserted and valitdated */
            if ((CurrentRecord->State == BufferInserted) &&
                (CurrentRecord->Checksum == Checksum))
            {
                /* Call the routine */
                CurrentRecord->State = BufferStarted;
                (CurrentRecord->CallbackRoutine)(CurrentRecord->Buffer,
                                                 CurrentRecord->Length);
                CurrentRecord->State = BufferFinished;
            }

            /* Go to the next entry */
            LastEntry = NextEntry;
            NextEntry = NextEntry->Flink;
        }
    }
}

Referenced by KeBugCheckWithTf().

KiDumpParameterImages()

VOID NTAPI KiDumpParameterImages	(	IN PCHAR	Message,
		IN PULONG_PTR	Parameters,
		IN ULONG	ParameterCount,
		IN PKE_BUGCHECK_UNICODE_TO_ANSI	ConversionRoutine
	)

Definition at line 576 of file bug.c.

{
    ULONG i;
    BOOLEAN InSystem;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    PVOID ImageBase;
    PUNICODE_STRING DriverName;
    CHAR AnsiName[32];
    PIMAGE_NT_HEADERS NtHeader;
    ULONG TimeStamp;
    BOOLEAN FirstRun = TRUE;

    /* Loop parameters */
    for (i = 0; i < ParameterCount; i++)
    {
        /* Get the base for this parameter */
        ImageBase = KiPcToFileHeader((PVOID)Parameters[i],
                                     &LdrEntry,
                                     FALSE,
                                     &InSystem);
        if (!ImageBase)
        {
            /* FIXME: Add code to check for unloaded drivers */
            DPRINT1("Potentially unloaded driver!\n");
            continue;
        }
        else
        {
            /* Get the NT Headers and Timestamp */
            NtHeader = RtlImageNtHeader(LdrEntry->DllBase);
            TimeStamp = NtHeader->FileHeader.TimeDateStamp;

            /* Convert the driver name */
            DriverName = &LdrEntry->BaseDllName;
            ConversionRoutine(&LdrEntry->BaseDllName,
                              AnsiName,
                              sizeof(AnsiName));
        }

        /* Format driver name */
        sprintf(Message,
                "%s**  %12s - Address %p base at %p, DateStamp %08lx\r\n",
                FirstRun ? "\r\n*":"*",
                AnsiName,
                (PVOID)Parameters[i],
                ImageBase,
                TimeStamp);

        /* Check if we only had one parameter */
        if (ParameterCount <= 1)
        {
            /* Then just save the name */
            KiBugCheckDriver = DriverName;
        }
        else
        {
            /* Otherwise, display the message */
            InbvDisplayString(Message);
        }

        /* Loop again */
        FirstRun = FALSE;
    }
}

Referenced by KeBugCheckWithTf(), and KiDisplayBlueScreen().

KiHandleNmi()

BOOLEAN NTAPI KiHandleNmi

(

VOID

)

Definition at line 1206 of file bug.c.

{
    BOOLEAN Handled = FALSE;
    PKNMI_HANDLER_CALLBACK NmiData;

    /* Parse the list of callbacks */
    NmiData = KiNmiCallbackListHead;
    while (NmiData)
    {
        /* Save if this callback has handled it -- all it takes is one */
        Handled |= NmiData->Callback(NmiData->Context, Handled);
        NmiData = NmiData->Next;
    }

    /* Has anyone handled this? */
    return Handled;
}

Referenced by KiTrap02().

KiInitializeBugCheck()

VOID INIT_FUNCTION NTAPI KiInitializeBugCheck

(

VOID

)

Definition at line 368 of file bug.c.

{
    PMESSAGE_RESOURCE_DATA BugCheckData;
    LDR_RESOURCE_INFO ResourceInfo;
    PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
    NTSTATUS Status;
    PLDR_DATA_TABLE_ENTRY LdrEntry;

    /* Get the kernel entry */
    LdrEntry = CONTAINING_RECORD(KeLoaderBlock->LoadOrderListHead.Flink,
                                 LDR_DATA_TABLE_ENTRY,
                                 InLoadOrderLinks);

    /* Cache the Bugcheck Message Strings. Prepare the Lookup Data */
    ResourceInfo.Type = 11;
    ResourceInfo.Name = 1;
    ResourceInfo.Language = 9;

    /* Do the lookup. */
    Status = LdrFindResource_U(LdrEntry->DllBase,
                               &ResourceInfo,
                               RESOURCE_DATA_LEVEL,
                               &ResourceDataEntry);

    /* Make sure it worked */
    if (NT_SUCCESS(Status))
    {
        /* Now actually get a pointer to it */
        Status = LdrAccessResource(LdrEntry->DllBase,
                                   ResourceDataEntry,
                                   (PVOID*)&BugCheckData,
                                   NULL);
        if (NT_SUCCESS(Status)) KiBugCodeMessages = BugCheckData;
    }
}

Referenced by ExpInitializeExecutive().

KiPcToFileHeader()

PVOID NTAPI KiPcToFileHeader	(	IN PVOID	Pc,
		OUT PLDR_DATA_TABLE_ENTRY *	LdrEntry,
		IN BOOLEAN	DriversOnly,
		OUT PBOOLEAN	InKernel
	)

Definition at line 44 of file bug.c.

{
    ULONG i = 0;
    PVOID ImageBase, PcBase = NULL;
    PLDR_DATA_TABLE_ENTRY Entry;
    PLIST_ENTRY ListHead, NextEntry;

    /* Check which list we should use */
    ListHead = (KeLoaderBlock) ? &KeLoaderBlock->LoadOrderListHead :
                                 &PsLoadedModuleList;

    /* Assume no */
    *InKernel = FALSE;

    /* Set list pointers and make sure it's valid */
    NextEntry = ListHead->Flink;
    if (NextEntry)
    {
        /* Start loop */
        while (NextEntry != ListHead)
        {
            /* Increase entry */
            i++;

            /* Check if this is a kernel entry and we only want drivers */
            if ((i <= 2) && (DriversOnly != FALSE))
            {
                /* Skip it */
                NextEntry = NextEntry->Flink;
                continue;
            }

            /* Get the loader entry */
            Entry = CONTAINING_RECORD(NextEntry,
                                      LDR_DATA_TABLE_ENTRY,
                                      InLoadOrderLinks);

            /* Move to the next entry */
            NextEntry = NextEntry->Flink;
            ImageBase = Entry->DllBase;

            /* Check if this is the right one */
            if (((ULONG_PTR)Pc >= (ULONG_PTR)Entry->DllBase) &&
                ((ULONG_PTR)Pc < ((ULONG_PTR)Entry->DllBase + Entry->SizeOfImage)))
            {
                /* Return this entry */
                *LdrEntry = Entry;
                PcBase = ImageBase;

                /* Check if this was a kernel or HAL entry */
                if (i <= 2) *InKernel = TRUE;
                break;
            }
        }
    }

    /* Return the base address */
    return PcBase;
}

Referenced by KeBugCheckWithTf(), KeRosDumpStackFrameArray(), KiDumpParameterImages(), and RtlPcToFileHeader().

KiRosPcToUserFileHeader()

PVOID NTAPI KiRosPcToUserFileHeader	(	IN PVOID	Pc,
		OUT PLDR_DATA_TABLE_ENTRY *	LdrEntry
	)

Definition at line 109 of file bug.c.

{
    PVOID ImageBase, PcBase = NULL;
    PLDR_DATA_TABLE_ENTRY Entry;
    PLIST_ENTRY ListHead, NextEntry;

    /*
     * We know this is valid because we should only be called after a
     * succesfull address from RtlWalkFrameChain for UserMode, which
     * validates everything for us.
     */
    ListHead = &KeGetCurrentThread()->
               Teb->ProcessEnvironmentBlock->Ldr->InLoadOrderModuleList;

    /* Set list pointers and make sure it's valid */
    NextEntry = ListHead->Flink;
    if (NextEntry)
    {
        /* Start loop */
        while (NextEntry != ListHead)
        {
            /* Get the loader entry */
            Entry = CONTAINING_RECORD(NextEntry,
                                      LDR_DATA_TABLE_ENTRY,
                                      InLoadOrderLinks);

            /* Move to the next entry */
            NextEntry = NextEntry->Flink;
            ImageBase = Entry->DllBase;

            /* Check if this is the right one */
            if (((ULONG_PTR)Pc >= (ULONG_PTR)Entry->DllBase) &&
                ((ULONG_PTR)Pc < ((ULONG_PTR)Entry->DllBase + Entry->SizeOfImage)))
            {
                /* Return this entry */
                *LdrEntry = Entry;
                PcBase = ImageBase;
                break;
            }
        }
    }

    /* Return the base address */
    return PcBase;
}

Referenced by KeRosDumpStackFrameArray(), and RtlPcToFileHeader().

Variable Documentation

BugCheckCallbackLock

KSPIN_LOCK BugCheckCallbackLock

Definition at line 23 of file bug.c.

Referenced by KiInitializeKernel(), and KiInitSystem().

KeBugCheckActive

ULONG KeBugCheckActive

Definition at line 24 of file bug.c.

Referenced by KeBugCheckWithTf().

KeBugcheckCallbackListHead

LIST_ENTRY KeBugcheckCallbackListHead

Definition at line 21 of file bug.c.

Referenced by KeRegisterBugCheckCallback(), KiDoBugCheckCallbacks(), KiInitializeKernel(), and KiInitSystem().

KeBugCheckCount

ULONG KeBugCheckCount = 1

Definition at line 27 of file bug.c.

Referenced by KeBugCheckWithTf(), and KeEnterKernelDebugger().

KeBugCheckOwner

ULONG KeBugCheckOwner

Definition at line 24 of file bug.c.

Referenced by KeBugCheckWithTf().

KeBugCheckOwnerRecursionCount

LONG KeBugCheckOwnerRecursionCount

Definition at line 25 of file bug.c.

Referenced by KeBugCheckWithTf().

KeBugcheckReasonCallbackListHead

LIST_ENTRY KeBugcheckReasonCallbackListHead

Definition at line 22 of file bug.c.

Referenced by KeRegisterBugCheckReasonCallback(), KiInitializeKernel(), and KiInitSystem().

KeRosBiosDate

UNICODE_STRING KeRosBiosDate

Definition at line 37 of file bug.c.

Referenced by CmpInitializeMachineDependentConfiguration(), and KeRosDumpTriageForBugZillaReport().

KeRosBiosVersion

UNICODE_STRING KeRosBiosVersion

Definition at line 37 of file bug.c.

Referenced by CmpInitializeMachineDependentConfiguration(), and KeRosDumpTriageForBugZillaReport().

KeRosProcessorName

UNICODE_STRING KeRosProcessorName

Definition at line 37 of file bug.c.

Referenced by CmpInitializeMachineDependentConfiguration(), and KeRosDumpTriageForBugZillaReport().

KeRosVideoBiosDate

UNICODE_STRING KeRosVideoBiosDate

Definition at line 38 of file bug.c.

Referenced by CmpInitializeMachineDependentConfiguration(), and KeRosDumpTriageForBugZillaReport().

KeRosVideoBiosVersion

UNICODE_STRING KeRosVideoBiosVersion

Definition at line 38 of file bug.c.

Referenced by CmpInitializeMachineDependentConfiguration(), and KeRosDumpTriageForBugZillaReport().

KiBugCheckData

ULONG_PTR KiBugCheckData[5]

Definition at line 30 of file bug.c.

Referenced by FindBitmapResource(), HalHandleNMI(), KeBugCheckWithTf(), KiDisplayBlueScreen(), NmiClearFlag(), and NmiDbgCallback().

KiBugCheckDriver

PUNICODE_STRING KiBugCheckDriver

Definition at line 29 of file bug.c.

Referenced by KeBugCheckWithTf(), KiDisplayBlueScreen(), and KiDumpParameterImages().

KiBugCodeMessages

PMESSAGE_RESOURCE_DATA KiBugCodeMessages

Definition at line 26 of file bug.c.

Referenced by KeGetBugMessageText(), and KiInitializeBugCheck().

KiHardwareTrigger

ULONG KiHardwareTrigger

Definition at line 28 of file bug.c.

Referenced by KeBugCheckWithTf(), and KeEnterKernelDebugger().

KiNmiCallbackListHead

PKNMI_HANDLER_CALLBACK KiNmiCallbackListHead = NULL

Definition at line 32 of file bug.c.

Referenced by KeDeregisterNmiCallback(), KeRegisterNmiCallback(), and KiHandleNmi().

KiNmiCallbackListLock

KSPIN_LOCK KiNmiCallbackListLock

Definition at line 33 of file bug.c.

Referenced by KiAcquireNmiListLock(), and KiReleaseNmiListLock().