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