reactos/ntoskrnl/ke/bug.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/ke/bug.c
   5  * PURPOSE:         Bugcheck Support
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 #if defined (ALLOC_PRAGMA)
  16 #pragma alloc_text(INIT, KiInitializeBugCheck)
  17 #endif
  18
  19 /* GLOBALS *******************************************************************/
  20
  21 LIST_ENTRY KeBugcheckCallbackListHead;
  22 LIST_ENTRY KeBugcheckReasonCallbackListHead;
  23 KSPIN_LOCK BugCheckCallbackLock;
  24 ULONG KeBugCheckActive, KeBugCheckOwner;
  25 LONG KeBugCheckOwnerRecursionCount;
  26 PRTL_MESSAGE_RESOURCE_DATA KiBugCodeMessages;
  27 ULONG KeBugCheckCount = 1;
  28 ULONG KiHardwareTrigger;
  29 PUNICODE_STRING KiBugCheckDriver;
  30 ULONG_PTR KiBugCheckData[5];
  31
  32 /* Bugzilla Reporting */
  33 UNICODE_STRING KeRosProcessorName, KeRosBiosDate, KeRosBiosVersion;
  34 UNICODE_STRING KeRosVideoBiosDate, KeRosVideoBiosVersion;
  35
  36 /* PRIVATE FUNCTIONS *********************************************************/
  37
  38 PVOID
  39 NTAPI
  40 KiPcToFileHeader(IN PVOID Pc,
  41                  OUT PLDR_DATA_TABLE_ENTRY *LdrEntry,
  42                  IN BOOLEAN DriversOnly,
  43                  OUT PBOOLEAN InKernel)
  44 {
  45     ULONG i = 0;
  46     PVOID ImageBase, PcBase = NULL;
  47     PLDR_DATA_TABLE_ENTRY Entry;
  48     PLIST_ENTRY ListHead, NextEntry;
  49
  50     /* Check which list we should use */
  51     ListHead = (KeLoaderBlock) ? &KeLoaderBlock->LoadOrderListHead :
  52                                  &PsLoadedModuleList;
  53
  54     /* Assume no */
  55     *InKernel = FALSE;
  56
  57     /* Set list pointers and make sure it's valid */
  58     NextEntry = ListHead->Flink;
  59     if (NextEntry)
  60     {
  61         /* Start loop */
  62         while (NextEntry != ListHead)
  63         {
  64             /* Increase entry */
  65             i++;
  66
  67             /* Check if this is a kernel entry and we only want drivers */
  68             if ((i <= 2) && (DriversOnly == TRUE))
  69             {
  70                 /* Skip it */
  71                 NextEntry = NextEntry->Flink;
  72                 continue;
  73             }
  74
  75             /* Get the loader entry */
  76             Entry = CONTAINING_RECORD(NextEntry,
  77                                       LDR_DATA_TABLE_ENTRY,
  78                                       InLoadOrderLinks);
  79
  80             /* Move to the next entry */
  81             NextEntry = NextEntry->Flink;
  82             ImageBase = Entry->DllBase;
  83
  84             /* Check if this is the right one */
  85             if (((ULONG_PTR)Pc >= (ULONG_PTR)Entry->DllBase) &&
  86                 ((ULONG_PTR)Pc < ((ULONG_PTR)Entry->DllBase + Entry->SizeOfImage)))
  87             {
  88                 /* Return this entry */
  89                 *LdrEntry = Entry;
  90                 PcBase = ImageBase;
  91
  92                 /* Check if this was a kernel or HAL entry */
  93                 if (i <= 2) *InKernel = TRUE;
  94                 break;
  95             }
  96         }
  97     }
  98
  99     /* Return the base address */
 100     return PcBase;
 101 }
 102
 103 BOOLEAN
 104 NTAPI
 105 KiRosPrintAddress(PVOID address)
 106 {
 107     PLIST_ENTRY current_entry;
 108     PLDR_DATA_TABLE_ENTRY current;
 109     extern LIST_ENTRY PsLoadedModuleList;
 110     ULONG_PTR RelativeAddress;
 111     ULONG i = 0;
 112
 113     do
 114     {
 115         current_entry = PsLoadedModuleList.Flink;
 116
 117         while (current_entry != &PsLoadedModuleList)
 118         {
 119             current = CONTAINING_RECORD(current_entry,
 120                                         LDR_DATA_TABLE_ENTRY,
 121                                         InLoadOrderLinks);
 122
 123             if (address >= (PVOID)current->DllBase &&
 124                 address < (PVOID)((ULONG_PTR)current->DllBase +
 125                                              current->SizeOfImage))
 126             {
 127                 RelativeAddress = (ULONG_PTR)address -
 128                                   (ULONG_PTR)current->DllBase;
 129                 DbgPrint("<%wZ: %x>", &current->FullDllName, RelativeAddress);
 130                 return(TRUE);
 131             }
 132             current_entry = current_entry->Flink;
 133         }
 134     } while(++i <= 1);
 135
 136     return(FALSE);
 137 }
 138
 139 PVOID
 140 NTAPI
 141 KiRosPcToUserFileHeader(IN PVOID Pc,
 142                         OUT PLDR_DATA_TABLE_ENTRY *LdrEntry)
 143 {
 144     PVOID ImageBase, PcBase = NULL;
 145     PLDR_DATA_TABLE_ENTRY Entry;
 146     PLIST_ENTRY ListHead, NextEntry;
 147
 148     /*
 149      * We know this is valid because we should only be called after a
 150      * succesfull address from RtlWalkFrameChain for UserMode, which
 151      * validates everything for us.
 152      */
 153     ListHead = &KeGetCurrentThread()->
 154                Teb->ProcessEnvironmentBlock->Ldr->InLoadOrderModuleList;
 155
 156     /* Set list pointers and make sure it's valid */
 157     NextEntry = ListHead->Flink;
 158     if (NextEntry)
 159     {
 160         /* Start loop */
 161         while (NextEntry != ListHead)
 162         {
 163             /* Get the loader entry */
 164             Entry = CONTAINING_RECORD(NextEntry,
 165                                       LDR_DATA_TABLE_ENTRY,
 166                                       InLoadOrderLinks);
 167
 168             /* Move to the next entry */
 169             NextEntry = NextEntry->Flink;
 170             ImageBase = Entry->DllBase;
 171
 172             /* Check if this is the right one */
 173             if (((ULONG_PTR)Pc >= (ULONG_PTR)Entry->DllBase) &&
 174                 ((ULONG_PTR)Pc < ((ULONG_PTR)Entry->DllBase + Entry->SizeOfImage)))
 175             {
 176                 /* Return this entry */
 177                 *LdrEntry = Entry;
 178                 PcBase = ImageBase;
 179                 break;
 180             }
 181         }
 182     }
 183
 184     /* Return the base address */
 185     return PcBase;
 186 }
 187
 188 USHORT
 189 NTAPI
 190 KeRosCaptureUserStackBackTrace(IN ULONG FramesToSkip,
 191                                IN ULONG FramesToCapture,
 192                                OUT PVOID *BackTrace,
 193                                OUT PULONG BackTraceHash OPTIONAL)
 194 {
 195     PVOID Frames[2 * 64];
 196     ULONG FrameCount;
 197     ULONG Hash = 0, i;
 198
 199     /* Skip a frame for the caller */
 200     FramesToSkip++;
 201
 202     /* Don't go past the limit */
 203     if ((FramesToCapture + FramesToSkip) >= 128) return 0;
 204
 205     /* Do the back trace */
 206     FrameCount = RtlWalkFrameChain(Frames, FramesToCapture + FramesToSkip, 1);
 207
 208     /* Make sure we're not skipping all of them */
 209     if (FrameCount <= FramesToSkip) return 0;
 210
 211     /* Loop all the frames */
 212     for (i = 0; i < FramesToCapture; i++)
 213     {
 214         /* Don't go past the limit */
 215         if ((FramesToSkip + i) >= FrameCount) break;
 216
 217         /* Save this entry and hash it */
 218         BackTrace[i] = Frames[FramesToSkip + i];
 219         Hash += PtrToUlong(BackTrace[i]);
 220     }
 221
 222     /* Write the hash */
 223     if (BackTraceHash) *BackTraceHash = Hash;
 224
 225     /* Clear the other entries and return count */
 226     RtlFillMemoryUlong(Frames, 128, 0);
 227     return (USHORT)i;
 228 }
 229
 230
 231 VOID
 232 FASTCALL
 233 KeRosDumpStackFrameArray(IN PULONG Frames,
 234                          IN ULONG FrameCount)
 235 {
 236     ULONG i, Addr;
 237     BOOLEAN InSystem;
 238     PVOID p;
 239
 240     /* GCC complaints that it may be used uninitialized */
 241     PLDR_DATA_TABLE_ENTRY LdrEntry = NULL;
 242
 243     /* Loop them */
 244     for (i = 0; i < FrameCount; i++)
 245     {
 246         /* Get the EIP */
 247         Addr = Frames[i];
 248         if (!Addr)
 249         {
 250                 break;
 251         }
 252
 253         /* Get the base for this file */
 254         if (Addr > (ULONG_PTR)MmHighestUserAddress)
 255         {
 256             /* We are in kernel */
 257             p = KiPcToFileHeader((PVOID)Addr, &LdrEntry, FALSE, &InSystem);
 258         }
 259         else
 260         {
 261             /* We are in user land */
 262             p = KiRosPcToUserFileHeader((PVOID)Addr, &LdrEntry);
 263         }
 264         if (p)
 265         {
 266 #ifdef KDBG
 267             if (!KdbSymPrintAddress((PVOID)Addr))
 268 #endif
 269             {
 270                 /* Print out the module name */
 271                 Addr -= (ULONG_PTR)LdrEntry->DllBase;
 272                 DbgPrint("<%wZ: %x>\n", &LdrEntry->FullDllName, Addr);
 273             }
 274         }
 275         else
 276         {
 277             /* Print only the address */
 278             DbgPrint("<%x>\n", Addr);
 279         }
 280
 281         /* Go to the next frame */
 282         DbgPrint("\n");
 283     }
 284 }
 285
 286 VOID
 287 NTAPI
 288 KeRosDumpStackFrames(IN PULONG Frame OPTIONAL,
 289                      IN ULONG FrameCount OPTIONAL)
 290 {
 291     ULONG Frames[32];
 292     ULONG RealFrameCount;
 293
 294     /* If the caller didn't ask, assume 32 frames */
 295     if (!FrameCount || FrameCount > 32) FrameCount = 32;
 296
 297     if (Frame)
 298     {
 299         /* Dump them */
 300         KeRosDumpStackFrameArray(Frame, FrameCount);
 301     }
 302     else
 303     {
 304         /* Get the current frames (skip the two. One for the dumper, one for the caller) */
 305         RealFrameCount = RtlCaptureStackBackTrace(2, FrameCount, (PVOID*)Frames, NULL);
 306
 307         /* Dump them */
 308         KeRosDumpStackFrameArray(Frames, RealFrameCount);
 309
 310         /* Count left for user mode? */
 311         if (FrameCount - RealFrameCount > 0)
 312         {
 313             /* Get the current frames */
 314             RealFrameCount = KeRosCaptureUserStackBackTrace(-1, FrameCount - RealFrameCount, (PVOID*)Frames, NULL);
 315
 316             /* Dump them */
 317             KeRosDumpStackFrameArray(Frames, RealFrameCount);
 318         }
 319     }
 320 }
 321
 322 VOID
 323 NTAPI
 324 KeRosDumpTriageForBugZillaReport(VOID)
 325 {
 326 #if 0
 327     extern BOOLEAN KiFastSystemCallDisable, KiSMTProcessorsPresent;
 328     extern ULONG KeI386MachineType, MxcsrFeatureMask;
 329     extern BOOLEAN Ke386Pae, Ke386NoExecute;
 330
 331     DbgPrint("ReactOS has crashed! Please go to http://www.reactos.org/bugzilla/enter_bug.cgi to file a bug!\n");
 332     DbgPrint("\nHardware Information\n");
 333     DbgPrint("Processor Architecture: %d\n"
 334              "Feature Bits: %d\n"
 335              "System Call Disabled: %d\n"
 336              "NPX Present: %d\n"
 337              "MXCsr Mask: %d\n"
 338              "MXCsr Feature Mask: %d\n"
 339              "XMMI Present: %d\n"
 340              "FXSR Present: %d\n"
 341              "Machine Type: %d\n"
 342              "PAE: %d\n"
 343              "NX: %d\n"
 344              "Processors: %d\n"
 345              "Active Processors: %d\n"
 346              "Pentium LOCK Bug: %d\n"
 347              "Hyperthreading: %d\n"
 348              "CPU Manufacturer: %s\n"
 349              "CPU Name: %wZ\n"
 350              "CPUID: %d\n"
 351              "CPU Type: %d\n"
 352              "CPU Stepping: %d\n"
 353              "CPU Speed: %d\n"
 354              "CPU L2 Cache: %d\n"
 355              "BIOS Date: %wZ\n"
 356              "BIOS Version: %wZ\n"
 357              "Video BIOS Date: %wZ\n"
 358              "Video BIOS Version: %wZ\n"
 359              "Memory: %d\n",
 360              KeProcessorArchitecture,
 361              KeFeatureBits,
 362              KiFastSystemCallDisable,
 363              KeI386NpxPresent,
 364              KiMXCsrMask,
 365              MxcsrFeatureMask,
 366              KeI386XMMIPresent,
 367              KeI386FxsrPresent,
 368              KeI386MachineType,
 369              Ke386Pae,
 370              Ke386NoExecute,
 371              KeNumberProcessors,
 372              KeActiveProcessors,
 373              KiI386PentiumLockErrataPresent,
 374              KiSMTProcessorsPresent,
 375              KeGetCurrentPrcb()->VendorString,
 376              &KeRosProcessorName,
 377              KeGetCurrentPrcb()->CpuID,
 378              KeGetCurrentPrcb()->CpuType,
 379              KeGetCurrentPrcb()->CpuStep,
 380              KeGetCurrentPrcb()->MHz,
 381              ((PKIPCR)KeGetPcr())->SecondLevelCacheSize,
 382              &KeRosBiosDate,
 383              &KeRosBiosVersion,
 384              &KeRosVideoBiosDate,
 385              &KeRosVideoBiosVersion,
 386              MmNumberOfPhysicalPages * PAGE_SIZE);
 387 #endif
 388 }
 389
 390 VOID
 391 INIT_FUNCTION
 392 NTAPI
 393 KiInitializeBugCheck(VOID)
 394 {
 395     PRTL_MESSAGE_RESOURCE_DATA BugCheckData;
 396     LDR_RESOURCE_INFO ResourceInfo;
 397     PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
 398     NTSTATUS Status;
 399     PLDR_DATA_TABLE_ENTRY LdrEntry;
 400
 401     /* Get the kernel entry */
 402     LdrEntry = CONTAINING_RECORD(KeLoaderBlock->LoadOrderListHead.Flink,
 403                                  LDR_DATA_TABLE_ENTRY,
 404                                  InLoadOrderLinks);
 405
 406     /* Cache the Bugcheck Message Strings. Prepare the Lookup Data */
 407     ResourceInfo.Type = 11;
 408     ResourceInfo.Name = 1;
 409     ResourceInfo.Language = 9;
 410
 411     /* Do the lookup. */
 412     Status = LdrFindResource_U(LdrEntry->DllBase,
 413                                &ResourceInfo,
 414                                RESOURCE_DATA_LEVEL,
 415                                &ResourceDataEntry);
 416
 417     /* Make sure it worked */
 418     if (NT_SUCCESS(Status))
 419     {
 420         /* Now actually get a pointer to it */
 421         Status = LdrAccessResource(LdrEntry->DllBase,
 422                                    ResourceDataEntry,
 423                                    (PVOID*)&BugCheckData,
 424                                    NULL);
 425         if (NT_SUCCESS(Status)) KiBugCodeMessages = BugCheckData;
 426     }
 427 }
 428
 429 BOOLEAN
 430 NTAPI
 431 KeGetBugMessageText(IN ULONG BugCheckCode,
 432                     OUT PANSI_STRING OutputString OPTIONAL)
 433 {
 434     ULONG i;
 435     ULONG IdOffset;
 436     ULONG_PTR MessageEntry;
 437     PCHAR BugCode;
 438     BOOLEAN Result = FALSE;
 439
 440     /* Make sure we're not bugchecking too early */
 441     if (!KiBugCodeMessages) return Result;
 442
 443     /* Find the message. This code is based on RtlFindMesssage */
 444     for (i = 0; i < KiBugCodeMessages->NumberOfBlocks; i++)
 445     {
 446         /* Check if the ID Matches */
 447         if ((BugCheckCode >= KiBugCodeMessages->Blocks[i].LowId) &&
 448             (BugCheckCode <= KiBugCodeMessages->Blocks[i].HighId))
 449         {
 450             /* Get Offset to Entry */
 451             MessageEntry = KiBugCodeMessages->Blocks[i].OffsetToEntries +
 452                            (ULONG_PTR)KiBugCodeMessages;
 453             IdOffset = BugCheckCode - KiBugCodeMessages->Blocks[i].LowId;
 454
 455             /* Get offset to ID */
 456             for (i = 0; i < IdOffset; i++)
 457             {
 458                 /* Advance in the Entries */
 459                 MessageEntry += ((PRTL_MESSAGE_RESOURCE_ENTRY)MessageEntry)->
 460                                 Length;
 461             }
 462
 463             /* Get the final Code */
 464             BugCode = ((PRTL_MESSAGE_RESOURCE_ENTRY)MessageEntry)->Text;
 465             i = strlen(BugCode);
 466
 467             /* Handle newlines */
 468             while ((i > 0) && ((BugCode[i] == '\n') ||
 469                                (BugCode[i] == '\r') ||
 470                                (BugCode[i] == ANSI_NULL)))
 471             {
 472                 /* Check if we have a string to return */
 473                 if (!OutputString) BugCode[i] = ANSI_NULL;
 474                 i--;
 475             }
 476
 477             /* Check if caller wants an output string */
 478             if (OutputString)
 479             {
 480                 /* Return it in the OutputString */
 481                 OutputString->Buffer = BugCode;
 482                 OutputString->Length = (USHORT)i + 1;
 483                 OutputString->MaximumLength = (USHORT)i + 1;
 484             }
 485             else
 486             {
 487                 /* Direct Output to Screen */
 488                 InbvDisplayString(BugCode);
 489                 InbvDisplayString("\r");
 490             }
 491
 492             /* We're done */
 493             Result = TRUE;
 494             break;
 495         }
 496     }
 497
 498     /* Return the result */
 499     return Result;
 500 }
 501
 502 VOID
 503 NTAPI
 504 KiDoBugCheckCallbacks(VOID)
 505 {
 506     PKBUGCHECK_CALLBACK_RECORD CurrentRecord;
 507     PLIST_ENTRY ListHead, NextEntry, LastEntry;
 508     ULONG_PTR Checksum;
 509
 510     /* First make sure that the list is Initialized... it might not be */
 511     ListHead = &KeBugcheckCallbackListHead;
 512     if ((ListHead->Flink) && (ListHead->Blink))
 513     {
 514         /* Loop the list */
 515         LastEntry = ListHead;
 516         NextEntry = ListHead->Flink;
 517         while (NextEntry != ListHead)
 518         {
 519             /* Get the reord */
 520             CurrentRecord = CONTAINING_RECORD(NextEntry,
 521                                               KBUGCHECK_CALLBACK_RECORD,
 522                                               Entry);
 523
 524             /* Validate it */
 525             if (CurrentRecord->Entry.Blink != LastEntry) return;
 526             Checksum = (ULONG_PTR)CurrentRecord->CallbackRoutine;
 527             Checksum += (ULONG_PTR)CurrentRecord->Buffer;
 528             Checksum += (ULONG_PTR)CurrentRecord->Length;
 529             Checksum += (ULONG_PTR)CurrentRecord->Component;
 530
 531             /* Make sure it's inserted and valitdated */
 532             if ((CurrentRecord->State == BufferInserted) &&
 533                 (CurrentRecord->Checksum == Checksum))
 534             {
 535                 /* Call the routine */
 536                 CurrentRecord->State = BufferStarted;
 537                 (CurrentRecord->CallbackRoutine)(CurrentRecord->Buffer,
 538                                                  CurrentRecord->Length);
 539                 CurrentRecord->State = BufferFinished;
 540             }
 541
 542             /* Go to the next entry */
 543             LastEntry = NextEntry;
 544             NextEntry = NextEntry->Flink;
 545         }
 546     }
 547 }
 548
 549 DECLSPEC_NORETURN
 550 VOID
 551 NTAPI
 552 KiBugCheckDebugBreak(IN ULONG StatusCode)
 553 {
 554     /* If KDBG isn't connected, freeze the CPU, otherwise, break */
 555 #if defined(_M_IX86) || defined(_M_AMD64)
 556     if (KdDebuggerNotPresent) for (;;) __halt();
 557 #elif defined(_M_ARM)
 558     if (KdDebuggerNotPresent) for (;;) KeArmHaltProcessor();
 559 #else
 560 #error
 561 #endif
 562     DbgBreakPointWithStatus(StatusCode);
 563     while (TRUE);
 564 }
 565
 566 PCHAR
 567 NTAPI
 568 KeBugCheckUnicodeToAnsi(IN PUNICODE_STRING Unicode,
 569                         OUT PCHAR Ansi,
 570                         IN ULONG Length)
 571 {
 572     PCHAR p;
 573     PWCHAR pw;
 574     ULONG i;
 575
 576     /* Set length and normalize it */
 577     i = Unicode->Length / sizeof(WCHAR);
 578     i = min(i, Length - 1);
 579
 580     /* Set source and destination, and copy */
 581     pw = Unicode->Buffer;
 582     p = Ansi;
 583     while (i--) *p++ = (CHAR)*pw++;
 584
 585     /* Null terminate and return */
 586     *p = ANSI_NULL;
 587     return Ansi;
 588 }
 589
 590 VOID
 591 NTAPI
 592 KiDumpParameterImages(IN PCHAR Message,
 593                       IN PULONG_PTR Parameters,
 594                       IN ULONG ParameterCount,
 595                       IN PKE_BUGCHECK_UNICODE_TO_ANSI ConversionRoutine)
 596 {
 597     ULONG i;
 598     BOOLEAN InSystem;
 599     PLDR_DATA_TABLE_ENTRY LdrEntry;
 600     PVOID ImageBase;
 601     PUNICODE_STRING DriverName;
 602     CHAR AnsiName[32];
 603     PIMAGE_NT_HEADERS NtHeader;
 604     ULONG TimeStamp;
 605     BOOLEAN FirstRun = TRUE;
 606
 607     /* Loop parameters */
 608     for (i = 0; i < ParameterCount; i++)
 609     {
 610         /* Get the base for this parameter */
 611         ImageBase = KiPcToFileHeader((PVOID)Parameters[i],
 612                                      &LdrEntry,
 613                                      FALSE,
 614                                      &InSystem);
 615         if (!ImageBase)
 616         {
 617             /* FIXME: Add code to check for unloaded drivers */
 618             DPRINT1("Potentially unloaded driver!\n");
 619             continue;
 620         }
 621         else
 622         {
 623             /* Get the NT Headers and Timestamp */
 624             NtHeader = RtlImageNtHeader(LdrEntry->DllBase);
 625             TimeStamp = NtHeader->FileHeader.TimeDateStamp;
 626
 627             /* Convert the driver name */
 628             DriverName = &LdrEntry->BaseDllName;
 629             ConversionRoutine(&LdrEntry->BaseDllName,
 630                               AnsiName,
 631                               sizeof(AnsiName));
 632         }
 633
 634         /* Format driver name */
 635         sprintf(Message,
 636                 "%s**  %12s - Address %p base at %p, DateStamp %08lx\n",
 637                 FirstRun ? "\r\n*":"*",
 638                 AnsiName,
 639                 (PVOID)Parameters[i],
 640                 ImageBase,
 641                 TimeStamp);
 642
 643         /* Check if we only had one parameter */
 644         if (ParameterCount <= 1)
 645         {
 646             /* Then just save the name */
 647             KiBugCheckDriver = DriverName;
 648         }
 649         else
 650         {
 651             /* Otherwise, display the message */
 652             InbvDisplayString(Message);
 653         }
 654
 655         /* Loop again */
 656         FirstRun = FALSE;
 657     }
 658 }
 659
 660 VOID
 661 NTAPI
 662 KiDisplayBlueScreen(IN ULONG MessageId,
 663                     IN BOOLEAN IsHardError,
 664                     IN PCHAR HardErrCaption OPTIONAL,
 665                     IN PCHAR HardErrMessage OPTIONAL,
 666                     IN PCHAR Message)
 667 {
 668     CHAR AnsiName[75];
 669
 670     /* Check if bootvid is installed */
 671     if (InbvIsBootDriverInstalled())
 672     {
 673         /* Acquire ownership and reset the display */
 674         InbvAcquireDisplayOwnership();
 675         InbvResetDisplay();
 676
 677         /* Display blue screen */
 678         InbvSolidColorFill(0, 0, 639, 479, 4);
 679         InbvSetTextColor(15);
 680         InbvInstallDisplayStringFilter(NULL);
 681         InbvEnableDisplayString(TRUE);
 682         InbvSetScrollRegion(0, 0, 639, 479);
 683     }
 684
 685     /* Check if this is a hard error */
 686     if (IsHardError)
 687     {
 688         /* Display caption and message */
 689         if (HardErrCaption) InbvDisplayString(HardErrCaption);
 690         if (HardErrMessage) InbvDisplayString(HardErrMessage);
 691     }
 692
 693     /* Begin the display */
 694     InbvDisplayString("\r\n");
 695
 696     /* Print out initial message */
 697     KeGetBugMessageText(BUGCHECK_MESSAGE_INTRO, NULL);
 698     InbvDisplayString("\r\n\r\n");
 699
 700     /* Check if we have a driver */
 701     if (KiBugCheckDriver)
 702     {
 703         /* Print out into to driver name */
 704         KeGetBugMessageText(BUGCODE_ID_DRIVER, NULL);
 705
 706         /* Convert and print out driver name */
 707         KeBugCheckUnicodeToAnsi(KiBugCheckDriver, AnsiName, sizeof(AnsiName));
 708         InbvDisplayString(" ");
 709         InbvDisplayString(AnsiName);
 710         InbvDisplayString("\r\n\r\n");
 711     }
 712
 713     /* Check if this is the generic message */
 714     if (MessageId == BUGCODE_PSS_MESSAGE)
 715     {
 716         /* It is, so get the bug code string as well */
 717         KeGetBugMessageText(KiBugCheckData[0], NULL);
 718         InbvDisplayString("\r\n\r\n");
 719     }
 720
 721     /* Print second introduction message */
 722     KeGetBugMessageText(PSS_MESSAGE_INTRO, NULL);
 723     InbvDisplayString("\r\n\r\n");
 724
 725     /* Get the bug code string */
 726     KeGetBugMessageText(MessageId, NULL);
 727     InbvDisplayString("\r\n\r\n");
 728
 729     /* Print message for technical information */
 730     KeGetBugMessageText(BUGCHECK_TECH_INFO, NULL);
 731
 732     /* Show the technical Data */
 733     sprintf(AnsiName,
 734             "\r\n\r\n*** STOP: 0x%08lX (0x%p,0x%p,0x%p,0x%p)\r\n\r\n",
 735             KiBugCheckData[0],
 736             (PVOID)KiBugCheckData[1],
 737             (PVOID)KiBugCheckData[2],
 738             (PVOID)KiBugCheckData[3],
 739             (PVOID)KiBugCheckData[4]);
 740     InbvDisplayString(AnsiName);
 741
 742     /* Check if we have a driver*/
 743     if (KiBugCheckDriver)
 744     {
 745         /* Display technical driver data */
 746         InbvDisplayString(Message);
 747     }
 748     else
 749     {
 750         /* Dump parameter information */
 751         KiDumpParameterImages(Message,
 752                               (PVOID)&KiBugCheckData[1],
 753                               4,
 754                               KeBugCheckUnicodeToAnsi);
 755     }
 756 }
 757
 758 VOID
 759 NTAPI
 760 KeBugCheckWithTf(IN ULONG BugCheckCode,
 761                  IN ULONG_PTR BugCheckParameter1,
 762                  IN ULONG_PTR BugCheckParameter2,
 763                  IN ULONG_PTR BugCheckParameter3,
 764                  IN ULONG_PTR BugCheckParameter4,
 765                  IN PKTRAP_FRAME TrapFrame)
 766 {
 767     PKPRCB Prcb = KeGetCurrentPrcb();
 768     CONTEXT Context;
 769     ULONG MessageId;
 770     CHAR AnsiName[128];
 771     BOOLEAN IsSystem, IsHardError = FALSE, Reboot = FALSE;
 772     PCHAR HardErrCaption = NULL, HardErrMessage = NULL;
 773     PVOID Pc = NULL, Memory;
 774     PVOID DriverBase;
 775     PLDR_DATA_TABLE_ENTRY LdrEntry;
 776     PULONG_PTR HardErrorParameters;
 777     KIRQL OldIrql;
 778 #ifdef CONFIG_SMP
 779     LONG i = 0;
 780 #endif
 781
 782     /* Set active bugcheck */
 783     KeBugCheckActive = TRUE;
 784     KiBugCheckDriver = NULL;
 785
 786     /* Check if this is power failure simulation */
 787     if (BugCheckCode == POWER_FAILURE_SIMULATE)
 788     {
 789         /* Call the Callbacks and reboot */;
 790         KiDoBugCheckCallbacks();
 791         HalReturnToFirmware(HalRebootRoutine);
 792     }
 793
 794     /* Save the IRQL and set hardware trigger */
 795     Prcb->DebuggerSavedIRQL = KeGetCurrentIrql();
 796     InterlockedIncrement((PLONG)&KiHardwareTrigger);
 797
 798     /* Capture the CPU Context */
 799     RtlCaptureContext(&Prcb->ProcessorState.ContextFrame);
 800     KiSaveProcessorControlState(&Prcb->ProcessorState);
 801     Context = Prcb->ProcessorState.ContextFrame;
 802
 803     /* FIXME: Call the Watchdog if it's registered */
 804
 805     /* Check which bugcode this is */
 806     switch (BugCheckCode)
 807     {
 808         /* These bug checks already have detailed messages, keep them */
 809         case UNEXPECTED_KERNEL_MODE_TRAP:
 810         case DRIVER_CORRUPTED_EXPOOL:
 811         case ACPI_BIOS_ERROR:
 812         case ACPI_BIOS_FATAL_ERROR:
 813         case THREAD_STUCK_IN_DEVICE_DRIVER:
 814         case DATA_BUS_ERROR:
 815         case FAT_FILE_SYSTEM:
 816         case NO_MORE_SYSTEM_PTES:
 817         case INACCESSIBLE_BOOT_DEVICE:
 818
 819             /* Keep the same code */
 820             MessageId = BugCheckCode;
 821             break;
 822
 823         /* Check if this is a kernel-mode exception */
 824         case KERNEL_MODE_EXCEPTION_NOT_HANDLED:
 825         //case SYSTEM_THREAD_EXCEPTION_NOT_HANDLED:
 826         case KMODE_EXCEPTION_NOT_HANDLED:
 827
 828             /* Use the generic text message */
 829             MessageId = KMODE_EXCEPTION_NOT_HANDLED;
 830             break;
 831
 832         /* File-system errors */
 833         case NTFS_FILE_SYSTEM:
 834
 835             /* Use the generic message for FAT */
 836             MessageId = FAT_FILE_SYSTEM;
 837             break;
 838
 839         /* Check if this is a coruption of the Mm's Pool */
 840         case DRIVER_CORRUPTED_MMPOOL:
 841
 842             /* Use generic corruption message */
 843             MessageId = DRIVER_CORRUPTED_EXPOOL;
 844             break;
 845
 846         /* Check if this is a signature check failure */
 847         case STATUS_SYSTEM_IMAGE_BAD_SIGNATURE:
 848
 849             /* Use the generic corruption message */
 850             MessageId = BUGCODE_PSS_MESSAGE_SIGNATURE;
 851             break;
 852
 853         /* All other codes */
 854         default:
 855
 856             /* Use the default bugcheck message */
 857             MessageId = BUGCODE_PSS_MESSAGE;
 858             break;
 859     }
 860
 861     /* Save bugcheck data */
 862     KiBugCheckData[0] = BugCheckCode;
 863     KiBugCheckData[1] = BugCheckParameter1;
 864     KiBugCheckData[2] = BugCheckParameter2;
 865     KiBugCheckData[3] = BugCheckParameter3;
 866     KiBugCheckData[4] = BugCheckParameter4;
 867
 868     /* Now check what bugcheck this is */
 869     switch (BugCheckCode)
 870     {
 871         /* Invalid access to R/O memory or Unhandled KM Exception */
 872         case KERNEL_MODE_EXCEPTION_NOT_HANDLED:
 873         case ATTEMPTED_WRITE_TO_READONLY_MEMORY:
 874         case ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY:
 875
 876             /* Check if we have a trap frame */
 877             if (!TrapFrame)
 878             {
 879                 /* Use parameter 3 as a trap frame, if it exists */
 880                 if (BugCheckParameter3) TrapFrame = (PVOID)BugCheckParameter3;
 881             }
 882
 883             /* Check if we got one now and if we need to get the Program Counter */
 884             if ((TrapFrame) &&
 885                 (BugCheckCode != KERNEL_MODE_EXCEPTION_NOT_HANDLED))
 886             {
 887                 /* Get the Program Counter */
 888                 Pc = (PVOID)KeGetTrapFramePc(TrapFrame);
 889             }
 890             break;
 891
 892         /* Wrong IRQL */
 893         case IRQL_NOT_LESS_OR_EQUAL:
 894
 895             /*
 896              * The NT kernel has 3 special sections:
 897              * MISYSPTE, POOLMI and POOLCODE. The bug check code can
 898              * determine in which of these sections this bugcode happened
 899              * and provide a more detailed analysis. For now, we don't.
 900              */
 901
 902             /* Program Counter is in parameter 4 */
 903             Pc = (PVOID)BugCheckParameter4;
 904
 905             /* Get the driver base */
 906             DriverBase = KiPcToFileHeader(Pc,
 907                                           &LdrEntry,
 908                                           FALSE,
 909                                           &IsSystem);
 910             if (IsSystem)
 911             {
 912                 /*
 913                  * The error happened inside the kernel or HAL.
 914                  * Get the memory address that was being referenced.
 915                  */
 916                 Memory = (PVOID)BugCheckParameter1;
 917
 918                 /* Find to which driver it belongs */
 919                 DriverBase = KiPcToFileHeader(Memory,
 920                                               &LdrEntry,
 921                                               TRUE,
 922                                               &IsSystem);
 923                 if (DriverBase)
 924                 {
 925                     /* Get the driver name and update the bug code */
 926                     KiBugCheckDriver = &LdrEntry->BaseDllName;
 927                     KiBugCheckData[0] = DRIVER_PORTION_MUST_BE_NONPAGED;
 928                 }
 929                 else
 930                 {
 931                     /* Find the driver that unloaded at this address */
 932                     KiBugCheckDriver = NULL; // FIXME: ROS can't locate
 933
 934                     /* Check if the cause was an unloaded driver */
 935                     if (KiBugCheckDriver)
 936                     {
 937                         /* Update bug check code */
 938                         KiBugCheckData[0] =
 939                             SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD;
 940                     }
 941                 }
 942             }
 943             else
 944             {
 945                 /* Update the bug check code */
 946                 KiBugCheckData[0] = DRIVER_IRQL_NOT_LESS_OR_EQUAL;
 947             }
 948
 949             /* Clear Pc so we don't look it up later */
 950             Pc = NULL;
 951             break;
 952
 953         /* Hard error */
 954         case FATAL_UNHANDLED_HARD_ERROR:
 955
 956             /* Copy bug check data from hard error */
 957             HardErrorParameters = (PULONG_PTR)BugCheckParameter2;
 958             KiBugCheckData[0] = BugCheckParameter1;
 959             KiBugCheckData[1] = HardErrorParameters[0];
 960             KiBugCheckData[2] = HardErrorParameters[1];
 961             KiBugCheckData[3] = HardErrorParameters[2];
 962             KiBugCheckData[4] = HardErrorParameters[3];
 963
 964             /* Remember that this is hard error and set the caption/message */
 965             IsHardError = TRUE;
 966             HardErrCaption = (PCHAR)BugCheckParameter3;
 967             HardErrMessage = (PCHAR)BugCheckParameter4;
 968             break;
 969
 970         /* Page fault */
 971         case PAGE_FAULT_IN_NONPAGED_AREA:
 972
 973             /* Assume no driver */
 974             DriverBase = NULL;
 975
 976             /* Check if we have a trap frame */
 977             if (!TrapFrame)
 978             {
 979                 /* We don't, use parameter 3 if possible */
 980                 if (BugCheckParameter3) TrapFrame = (PVOID)BugCheckParameter3;
 981             }
 982
 983             /* Check if we have a frame now */
 984             if (TrapFrame)
 985             {
 986                 /* Get the Program Counter */
 987                 Pc = (PVOID)KeGetTrapFramePc(TrapFrame);
 988                 KiBugCheckData[3] = (ULONG_PTR)Pc;
 989
 990                 /* Find out if was in the kernel or drivers */
 991                 DriverBase = KiPcToFileHeader(Pc,
 992                                               &LdrEntry,
 993                                               FALSE,
 994                                               &IsSystem);
 995             }
 996
 997             /*
 998              * Now we should check if this happened in:
 999              * 1) Special Pool 2) Free Special Pool 3) Session Pool
1000              * and update the bugcheck code appropriately.
1001              */
1002
1003             /* Check if we didn't have a driver base */
1004             if (!DriverBase)
1005             {
1006                 /* Find the driver that unloaded at this address */
1007                 KiBugCheckDriver = NULL; // FIXME: ROS can't locate
1008
1009                 /* Check if the cause was an unloaded driver */
1010                 if (KiBugCheckDriver)
1011                 {
1012                     KiBugCheckData[0] =
1013                         DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS;
1014                 }
1015             }
1016             break;
1017
1018         /* Check if the driver forgot to unlock pages */
1019         case DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS:
1020
1021             /* Program Counter is in parameter 1 */
1022             Pc = (PVOID)BugCheckParameter1;
1023             break;
1024
1025         /* Check if the driver consumed too many PTEs */
1026         case DRIVER_USED_EXCESSIVE_PTES:
1027
1028             /* Loader entry is in parameter 1 */
1029             LdrEntry = (PVOID)BugCheckParameter1;
1030             KiBugCheckDriver = &LdrEntry->BaseDllName;
1031             break;
1032
1033         /* Check if the driver has a stuck thread */
1034         case THREAD_STUCK_IN_DEVICE_DRIVER:
1035
1036             /* The name is in Parameter 3 */
1037             KiBugCheckDriver = (PVOID)BugCheckParameter3;
1038             break;
1039
1040         /* Anything else */
1041         default:
1042             break;
1043     }
1044
1045     /* Do we have a driver name? */
1046     if (KiBugCheckDriver)
1047     {
1048         /* Convert it to ANSI */
1049         KeBugCheckUnicodeToAnsi(KiBugCheckDriver, AnsiName, sizeof(AnsiName));
1050     }
1051     else
1052     {
1053         /* Do we have a Program Counter? */
1054         if (Pc)
1055         {
1056             /* Dump image name */
1057             KiDumpParameterImages(AnsiName,
1058                                   (PULONG_PTR)&Pc,
1059                                   1,
1060                                   KeBugCheckUnicodeToAnsi);
1061         }
1062     }
1063
1064     /* Check if we need to save the context for KD */
1065 #ifdef _WINKD_
1066     if (!KdPitchDebugger) KdDebuggerDataBlock.SavedContext = (ULONG)&Context;
1067 #endif
1068
1069     /* Check if a debugger is connected */
1070     if ((BugCheckCode != MANUALLY_INITIATED_CRASH) && (KdDebuggerEnabled))
1071     {
1072         /* Crash on the debugger console */
1073         DbgPrint("\n*** Fatal System Error: 0x%08lx\n"
1074                  "                       (0x%p,0x%p,0x%p,0x%p)\n\n",
1075                  KiBugCheckData[0],
1076                  KiBugCheckData[1],
1077                  KiBugCheckData[2],
1078                  KiBugCheckData[3],
1079                  KiBugCheckData[4]);
1080
1081         /* Check if the debugger isn't currently connected */
1082         if (!KdDebuggerNotPresent)
1083         {
1084             /* Check if we have a driver to blame */
1085             if (KiBugCheckDriver)
1086             {
1087                 /* Dump it */
1088                 DbgPrint("Driver at fault: %s.\n", AnsiName);
1089             }
1090
1091             /* Check if this was a hard error */
1092             if (IsHardError)
1093             {
1094                 /* Print caption and message */
1095                 if (HardErrCaption) DbgPrint(HardErrCaption);
1096                 if (HardErrMessage) DbgPrint(HardErrMessage);
1097             }
1098
1099             /* Break in the debugger */
1100             KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_FIRST);
1101         }
1102         else
1103         {
1104             /*
1105              * ROS HACK.
1106              * Ok, so debugging is enabled, but KDBG isn't there.
1107              * We'll manually dump the stack for the user.
1108              */
1109             KeRosDumpStackFrames(NULL, 0);
1110
1111             /* ROS HACK 2: Generate something useful for Bugzilla */
1112             KeRosDumpTriageForBugZillaReport();
1113         }
1114     }
1115
1116     /* Raise IRQL to HIGH_LEVEL */
1117     _disable();
1118     KeRaiseIrql(HIGH_LEVEL, &OldIrql);
1119
1120     /* Avoid recursion */
1121     if (!InterlockedDecrement((PLONG)&KeBugCheckCount))
1122     {
1123 #ifdef CONFIG_SMP
1124         /* Set CPU that is bug checking now */
1125         KeBugCheckOwner = Prcb->Number;
1126
1127         /* Freeze the other CPUs */
1128         for (i = 0; i < KeNumberProcessors; i++)
1129         {
1130             if (i != (LONG)KeGetCurrentProcessorNumber())
1131             {
1132                 /* Send the IPI and give them one second to catch up */
1133                 KiIpiSend(1 << i, IPI_FREEZE);
1134                 KeStallExecutionProcessor(1000000);
1135             }
1136         }
1137 #endif
1138
1139         /* Display the BSOD */
1140         KiDisplayBlueScreen(MessageId,
1141                             IsHardError,
1142                             HardErrCaption,
1143                             HardErrMessage,
1144                             AnsiName);
1145
1146         /* Check if the debugger is disabled but we can enable it */
1147         if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
1148         {
1149             /* Enable it */
1150 #ifdef _WINKD_
1151             KdEnableDebuggerWithLock(FALSE);
1152 #endif
1153         }
1154         else
1155         {
1156             /* Otherwise, print the last line */
1157             InbvDisplayString("\r\n");
1158         }
1159
1160         /* Save the context */
1161         Prcb->ProcessorState.ContextFrame = Context;
1162
1163         /* FIXME: Support Triage Dump */
1164
1165         /* FIXME: Write the crash dump */
1166     }
1167     else
1168     {
1169         /* Increase recursion count */
1170         KeBugCheckOwnerRecursionCount++;
1171         if (KeBugCheckOwnerRecursionCount == 2)
1172         {
1173             /* Break in the debugger */
1174             KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_SECOND);
1175         }
1176         else if (KeBugCheckOwnerRecursionCount > 2)
1177         {
1178             /* Halt the CPU */
1179 #if defined(_M_IX86) || defined(_M_AMD64)
1180             for (;;) __halt();
1181 #elif defined(_M_ARM)
1182             for (;;) KeArmHaltProcessor();
1183 #else
1184 #error
1185 #endif
1186         }
1187     }
1188
1189     /* Call the Callbacks */
1190     KiDoBugCheckCallbacks();
1191
1192     /* FIXME: Call Watchdog if enabled */
1193
1194     /* Check if we have to reboot */
1195     if (Reboot)
1196     {
1197         /* Unload symbols */
1198         DbgUnLoadImageSymbols(NULL, NtCurrentProcess(), 0);
1199         HalReturnToFirmware(HalRebootRoutine);
1200     }
1201
1202     /* Attempt to break in the debugger (otherwise halt CPU) */
1203     KiBugCheckDebugBreak(DBG_STATUS_BUGCHECK_SECOND);
1204 }
1205
1206 /* PUBLIC FUNCTIONS **********************************************************/
1207
1208 /*
1209  * @unimplemented
1210  */
1211 NTSTATUS
1212 NTAPI
1213 KeInitializeCrashDumpHeader(IN ULONG Type,
1214                             IN ULONG Flags,
1215                             OUT PVOID Buffer,
1216                             IN ULONG BufferSize,
1217                             OUT ULONG BufferNeeded OPTIONAL)
1218 {
1219     UNIMPLEMENTED;
1220     return STATUS_UNSUCCESSFUL;
1221 }
1222
1223 /*
1224  * @implemented
1225  */
1226 BOOLEAN
1227 NTAPI
1228 KeDeregisterBugCheckCallback(IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord)
1229 {
1230     KIRQL OldIrql;
1231     BOOLEAN Status = FALSE;
1232
1233     /* Raise IRQL to High */
1234     KeRaiseIrql(HIGH_LEVEL, &OldIrql);
1235
1236     /* Check the Current State */
1237     if (CallbackRecord->State == BufferInserted)
1238     {
1239         /* Reset state and remove from list */
1240         CallbackRecord->State = BufferEmpty;
1241         RemoveEntryList(&CallbackRecord->Entry);
1242         Status = TRUE;
1243     }
1244
1245     /* Lower IRQL and return */
1246     KeLowerIrql(OldIrql);
1247     return Status;
1248 }
1249
1250 /*
1251  * @implemented
1252  */
1253 BOOLEAN
1254 NTAPI
1255 KeDeregisterBugCheckReasonCallback(
1256     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord)
1257 {
1258     KIRQL OldIrql;
1259     BOOLEAN Status = FALSE;
1260
1261     /* Raise IRQL to High */
1262     KeRaiseIrql(HIGH_LEVEL, &OldIrql);
1263
1264     /* Check the Current State */
1265     if (CallbackRecord->State == BufferInserted)
1266     {
1267         /* Reset state and remove from list */
1268         CallbackRecord->State = BufferEmpty;
1269         RemoveEntryList(&CallbackRecord->Entry);
1270         Status = TRUE;
1271     }
1272
1273     /* Lower IRQL and return */
1274     KeLowerIrql(OldIrql);
1275     return Status;
1276 }
1277
1278 /*
1279  * @unimplemented
1280  */
1281 NTSTATUS
1282 NTAPI
1283 KeDeregisterNmiCallback(PVOID Handle)
1284 {
1285     UNIMPLEMENTED;
1286     return STATUS_UNSUCCESSFUL;
1287 }
1288
1289 /*
1290  * @implemented
1291  */
1292 BOOLEAN
1293 NTAPI
1294 KeRegisterBugCheckCallback(IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
1295                            IN PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
1296                            IN PVOID Buffer,
1297                            IN ULONG Length,
1298                            IN PUCHAR Component)
1299 {
1300     KIRQL OldIrql;
1301     BOOLEAN Status = FALSE;
1302
1303     /* Raise IRQL to High */
1304     KeRaiseIrql(HIGH_LEVEL, &OldIrql);
1305
1306     /* Check the Current State first so we don't double-register */
1307     if (CallbackRecord->State == BufferEmpty)
1308     {
1309         /* Set the Callback Settings and insert into the list */
1310         CallbackRecord->Length = Length;
1311         CallbackRecord->Buffer = Buffer;
1312         CallbackRecord->Component = Component;
1313         CallbackRecord->CallbackRoutine = CallbackRoutine;
1314         CallbackRecord->State = BufferInserted;
1315         InsertTailList(&KeBugcheckCallbackListHead, &CallbackRecord->Entry);
1316         Status = TRUE;
1317     }
1318
1319     /* Lower IRQL and return */
1320     KeLowerIrql(OldIrql);
1321     return Status;
1322 }
1323
1324 /*
1325  * @implemented
1326  */
1327 BOOLEAN
1328 NTAPI
1329 KeRegisterBugCheckReasonCallback(
1330     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
1331     IN PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
1332     IN KBUGCHECK_CALLBACK_REASON Reason,
1333     IN PUCHAR Component)
1334 {
1335     KIRQL OldIrql;
1336     BOOLEAN Status = FALSE;
1337
1338     /* Raise IRQL to High */
1339     KeRaiseIrql(HIGH_LEVEL, &OldIrql);
1340
1341     /* Check the Current State first so we don't double-register */
1342     if (CallbackRecord->State == BufferEmpty)
1343     {
1344         /* Set the Callback Settings and insert into the list */
1345         CallbackRecord->Component = Component;
1346         CallbackRecord->CallbackRoutine = CallbackRoutine;
1347         CallbackRecord->State = BufferInserted;
1348         CallbackRecord->Reason = Reason;
1349         InsertTailList(&KeBugcheckReasonCallbackListHead,
1350                        &CallbackRecord->Entry);
1351         Status = TRUE;
1352     }
1353
1354     /* Lower IRQL and return */
1355     KeLowerIrql(OldIrql);
1356     return Status;
1357 }
1358
1359 /*
1360  * @unimplemented
1361  */
1362 PVOID
1363 NTAPI
1364 KeRegisterNmiCallback(IN PNMI_CALLBACK CallbackRoutine,
1365                       IN PVOID Context)
1366 {
1367     UNIMPLEMENTED;
1368     return NULL;
1369 }
1370
1371 /*
1372  * @implemented
1373  */
1374 VOID
1375 NTAPI
1376 KeBugCheckEx(IN ULONG BugCheckCode,
1377              IN ULONG_PTR BugCheckParameter1,
1378              IN ULONG_PTR BugCheckParameter2,
1379              IN ULONG_PTR BugCheckParameter3,
1380              IN ULONG_PTR BugCheckParameter4)
1381 {
1382     /* Call the internal API */
1383     KeBugCheckWithTf(BugCheckCode,
1384                      BugCheckParameter1,
1385                      BugCheckParameter2,
1386                      BugCheckParameter3,
1387                      BugCheckParameter4,
1388                      NULL);
1389 }
1390
1391 /*
1392  * @implemented
1393  */
1394 VOID
1395 NTAPI
1396 KeBugCheck(ULONG BugCheckCode)
1397 {
1398     /* Call the internal API */
1399     KeBugCheckWithTf(BugCheckCode, 0, 0, 0, 0, NULL);
1400 }
1401
1402 /*
1403  * @implemented
1404  */
1405 VOID
1406 NTAPI
1407 KeEnterKernelDebugger(VOID)
1408 {
1409     /* Disable interrupts */
1410     KiHardwareTrigger = 1;
1411     _disable();
1412
1413     /* Check the bugcheck count */
1414     if (!InterlockedDecrement((PLONG)&KeBugCheckCount))
1415     {
1416         /* There was only one, is the debugger disabled? */
1417         if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
1418         {
1419             /* Enable the debugger */
1420             KdInitSystem(0, NULL);
1421         }
1422     }
1423
1424     /* Bugcheck */
1425     KiBugCheckDebugBreak(DBG_STATUS_FATAL);
1426 }
1427
1428 /* EOF */