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