1d503919a7fd1ee1fa7c562a09a629c5c6159137
[reactos.git] / 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 */