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