[NTOSKRNL] Add a raw implementation of !irpfind in kdbg
[reactos.git] / ntoskrnl / kd / kdio.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/kd/kdio.c
5 * PURPOSE: NT Kernel Debugger Input/Output Functions
6 *
7 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #include <reactos/buildno.h>
14 #define NDEBUG
15 #include <debug.h>
16
17 /* GLOBALS *******************************************************************/
18
19 #define KdpBufferSize (1024 * 512)
20 BOOLEAN KdpLoggingEnabled = FALSE;
21 PCHAR KdpDebugBuffer = NULL;
22 volatile ULONG KdpCurrentPosition = 0;
23 volatile ULONG KdpFreeBytes = 0;
24 KSPIN_LOCK KdpDebugLogSpinLock;
25 KEVENT KdpLoggerThreadEvent;
26 HANDLE KdpLogFileHandle;
27 ANSI_STRING KdpLogFileName = RTL_CONSTANT_STRING("\\SystemRoot\\debug.log");
28
29 KSPIN_LOCK KdpSerialSpinLock;
30 ULONG SerialPortNumber = DEFAULT_DEBUG_PORT;
31 CPPORT SerialPortInfo = {0, DEFAULT_DEBUG_BAUD_RATE, 0};
32
33 /* Current Port in use. FIXME: Do we support more then one? */
34 ULONG KdpPort;
35
36 #define KdpScreenLineLengthDefault 80
37 CHAR KdpScreenLineBuffer[KdpScreenLineLengthDefault + 1] = "";
38 ULONG KdpScreenLineBufferPos = 0, KdpScreenLineLength = 0;
39
40 const ULONG KdpDmesgBufferSize = 128 * 1024; // 512*1024; // 5*1024*1024;
41 PCHAR KdpDmesgBuffer = NULL;
42 volatile ULONG KdpDmesgCurrentPosition = 0;
43 volatile ULONG KdpDmesgFreeBytes = 0;
44 volatile ULONG KdbDmesgTotalWritten = 0;
45 KSPIN_LOCK KdpDmesgLogSpinLock;
46 volatile BOOLEAN KdbpIsInDmesgMode = FALSE;
47
48 /* UTILITY FUNCTIONS *********************************************************/
49
50 /*
51 * Get the total size of the memory before
52 * Mm is initialized, by counting the number
53 * of physical pages. Useful for debug logging.
54 *
55 * Strongly inspired by:
56 * mm\ARM3\mminit.c : MiScanMemoryDescriptors(...)
57 *
58 * See also: kd64\kdinit.c
59 */
60 static SIZE_T
61 INIT_FUNCTION
62 KdpGetMemorySizeInMBs(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
63 {
64 PLIST_ENTRY ListEntry;
65 PMEMORY_ALLOCATION_DESCRIPTOR Descriptor;
66 SIZE_T NumberOfPhysicalPages = 0;
67
68 /* Loop the memory descriptors */
69 for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Flink;
70 ListEntry != &LoaderBlock->MemoryDescriptorListHead;
71 ListEntry = ListEntry->Flink)
72 {
73 /* Get the descriptor */
74 Descriptor = CONTAINING_RECORD(ListEntry,
75 MEMORY_ALLOCATION_DESCRIPTOR,
76 ListEntry);
77
78 /* Check if this is invisible memory */
79 if ((Descriptor->MemoryType == LoaderFirmwarePermanent) ||
80 (Descriptor->MemoryType == LoaderSpecialMemory) ||
81 (Descriptor->MemoryType == LoaderHALCachedMemory) ||
82 (Descriptor->MemoryType == LoaderBBTMemory))
83 {
84 /* Skip this descriptor */
85 continue;
86 }
87
88 /* Check if this is bad memory */
89 if (Descriptor->MemoryType != LoaderBad)
90 {
91 /* Count this in the total of pages */
92 NumberOfPhysicalPages += Descriptor->PageCount;
93 }
94 }
95
96 /* Round size up. Assumed to better match actual physical RAM size */
97 return ALIGN_UP_BY(NumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
98 }
99
100 /* See also: kd64\kdinit.c */
101 static VOID
102 INIT_FUNCTION
103 KdpPrintBanner(IN SIZE_T MemSizeMBs)
104 {
105 DPRINT1("-----------------------------------------------------\n");
106 DPRINT1("ReactOS " KERNEL_VERSION_STR " (Build " KERNEL_VERSION_BUILD_STR ") (Commit " KERNEL_VERSION_COMMIT_HASH ")\n");
107 DPRINT1("%u System Processor [%u MB Memory]\n", KeNumberProcessors, MemSizeMBs);
108 DPRINT1("Command Line: %s\n", KeLoaderBlock->LoadOptions);
109 DPRINT1("ARC Paths: %s %s %s %s\n", KeLoaderBlock->ArcBootDeviceName, KeLoaderBlock->NtHalPathName, KeLoaderBlock->ArcHalDeviceName, KeLoaderBlock->NtBootPathName);
110 }
111
112 /* FILE DEBUG LOG FUNCTIONS **************************************************/
113
114 VOID
115 NTAPI
116 KdpLoggerThread(PVOID Context)
117 {
118 ULONG beg, end, num;
119 IO_STATUS_BLOCK Iosb;
120
121 KdpLoggingEnabled = TRUE;
122
123 while (TRUE)
124 {
125 KeWaitForSingleObject(&KdpLoggerThreadEvent, 0, KernelMode, FALSE, NULL);
126
127 /* Bug */
128 /* Keep KdpCurrentPosition and KdpFreeBytes values in local
129 * variables to avoid their possible change from Producer part,
130 * KdpPrintToLogFile function
131 */
132 end = KdpCurrentPosition;
133 num = KdpFreeBytes;
134
135 /* Now securely calculate values, based on local variables */
136 beg = (end + num) % KdpBufferSize;
137 num = KdpBufferSize - num;
138
139 /* Nothing to do? */
140 if (num == 0)
141 continue;
142
143 if (end > beg)
144 {
145 NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
146 KdpDebugBuffer + beg, num, NULL, NULL);
147 }
148 else
149 {
150 NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
151 KdpDebugBuffer + beg, KdpBufferSize - beg, NULL, NULL);
152
153 NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
154 KdpDebugBuffer, end, NULL, NULL);
155 }
156
157 (VOID)InterlockedExchangeAddUL(&KdpFreeBytes, num);
158 }
159 }
160
161 VOID
162 NTAPI
163 KdpPrintToLogFile(PCH String,
164 ULONG StringLength)
165 {
166 ULONG beg, end, num;
167 KIRQL OldIrql;
168
169 if (KdpDebugBuffer == NULL) return;
170
171 /* Acquire the printing spinlock without waiting at raised IRQL */
172 while (TRUE)
173 {
174 /* Wait when the spinlock becomes available */
175 while (!KeTestSpinLock(&KdpDebugLogSpinLock));
176
177 /* Spinlock was free, raise IRQL */
178 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
179
180 /* Try to get the spinlock */
181 if (KeTryToAcquireSpinLockAtDpcLevel(&KdpDebugLogSpinLock))
182 break;
183
184 /* Someone else got the spinlock, lower IRQL back */
185 KeLowerIrql(OldIrql);
186 }
187
188 beg = KdpCurrentPosition;
189 num = KdpFreeBytes;
190 if (StringLength < num)
191 num = StringLength;
192
193 if (num != 0)
194 {
195 end = (beg + num) % KdpBufferSize;
196 KdpCurrentPosition = end;
197 KdpFreeBytes -= num;
198
199 if (end > beg)
200 {
201 RtlCopyMemory(KdpDebugBuffer + beg, String, num);
202 }
203 else
204 {
205 RtlCopyMemory(KdpDebugBuffer + beg, String, KdpBufferSize - beg);
206 RtlCopyMemory(KdpDebugBuffer, String + KdpBufferSize - beg, end);
207 }
208 }
209
210 /* Release spinlock */
211 KiReleaseSpinLock(&KdpDebugLogSpinLock);
212
213 /* Lower IRQL */
214 KeLowerIrql(OldIrql);
215
216 /* Signal the logger thread */
217 if (OldIrql <= DISPATCH_LEVEL && KdpLoggingEnabled)
218 KeSetEvent(&KdpLoggerThreadEvent, 0, FALSE);
219 }
220
221 VOID
222 NTAPI
223 INIT_FUNCTION
224 KdpInitDebugLog(PKD_DISPATCH_TABLE DispatchTable,
225 ULONG BootPhase)
226 {
227 NTSTATUS Status;
228 UNICODE_STRING FileName;
229 OBJECT_ATTRIBUTES ObjectAttributes;
230 IO_STATUS_BLOCK Iosb;
231 HANDLE ThreadHandle;
232 KPRIORITY Priority;
233 SIZE_T MemSizeMBs;
234
235 if (!KdpDebugMode.File) return;
236
237 if (BootPhase == 0)
238 {
239 KdComPortInUse = NULL;
240
241 /* Write out the functions that we support for now */
242 DispatchTable->KdpInitRoutine = KdpInitDebugLog;
243 DispatchTable->KdpPrintRoutine = KdpPrintToLogFile;
244
245 /* Register as a Provider */
246 InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
247
248 }
249 else if (BootPhase == 1)
250 {
251 /* Allocate a buffer for debug log */
252 KdpDebugBuffer = ExAllocatePool(NonPagedPool, KdpBufferSize);
253 KdpFreeBytes = KdpBufferSize;
254
255 /* Initialize spinlock */
256 KeInitializeSpinLock(&KdpDebugLogSpinLock);
257
258 /* Display separator + ReactOS version at start of the debug log */
259 /* Round size up. Assumed to better match actual physical RAM size */
260 MemSizeMBs = ALIGN_UP_BY(MmNumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
261 KdpPrintBanner(MemSizeMBs);
262 }
263 else if (BootPhase == 2)
264 {
265 HalDisplayString("\r\n File log debugging enabled\r\n\r\n");
266 }
267 else if (BootPhase == 3)
268 {
269 /* Setup the log name */
270 Status = RtlAnsiStringToUnicodeString(&FileName, &KdpLogFileName, TRUE);
271 if (!NT_SUCCESS(Status)) return;
272
273 InitializeObjectAttributes(&ObjectAttributes,
274 &FileName,
275 0,
276 NULL,
277 NULL);
278
279 /* Create the log file */
280 Status = NtCreateFile(&KdpLogFileHandle,
281 FILE_APPEND_DATA | SYNCHRONIZE,
282 &ObjectAttributes,
283 &Iosb,
284 NULL,
285 FILE_ATTRIBUTE_NORMAL,
286 FILE_SHARE_READ,
287 FILE_SUPERSEDE,
288 FILE_WRITE_THROUGH | FILE_SYNCHRONOUS_IO_NONALERT,
289 NULL,
290 0);
291
292 RtlFreeUnicodeString(&FileName);
293
294 if (!NT_SUCCESS(Status)) return;
295
296 KeInitializeEvent(&KdpLoggerThreadEvent, SynchronizationEvent, TRUE);
297
298 /* Create the logger thread */
299 Status = PsCreateSystemThread(&ThreadHandle,
300 THREAD_ALL_ACCESS,
301 NULL,
302 NULL,
303 NULL,
304 KdpLoggerThread,
305 NULL);
306
307 if (!NT_SUCCESS(Status)) return;
308
309 Priority = 7;
310 NtSetInformationThread(ThreadHandle,
311 ThreadPriority,
312 &Priority,
313 sizeof(Priority));
314 }
315 }
316
317 /* SERIAL FUNCTIONS **********************************************************/
318
319 VOID
320 NTAPI
321 KdpSerialDebugPrint(LPSTR Message,
322 ULONG Length)
323 {
324 KIRQL OldIrql;
325 PCHAR pch = (PCHAR) Message;
326
327 /* Acquire the printing spinlock without waiting at raised IRQL */
328 while (TRUE)
329 {
330 /* Wait when the spinlock becomes available */
331 while (!KeTestSpinLock(&KdpSerialSpinLock));
332
333 /* Spinlock was free, raise IRQL */
334 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
335
336 /* Try to get the spinlock */
337 if (KeTryToAcquireSpinLockAtDpcLevel(&KdpSerialSpinLock))
338 break;
339
340 /* Someone else got the spinlock, lower IRQL back */
341 KeLowerIrql(OldIrql);
342 }
343
344 /* Output the message */
345 while (pch < Message + Length && *pch != '\0')
346 {
347 if (*pch == '\n')
348 {
349 KdPortPutByteEx(&SerialPortInfo, '\r');
350 }
351 KdPortPutByteEx(&SerialPortInfo, *pch);
352 pch++;
353 }
354
355 /* Release spinlock */
356 KiReleaseSpinLock(&KdpSerialSpinLock);
357
358 /* Lower IRQL */
359 KeLowerIrql(OldIrql);
360 }
361
362 VOID
363 NTAPI
364 KdpSerialInit(PKD_DISPATCH_TABLE DispatchTable,
365 ULONG BootPhase)
366 {
367 SIZE_T MemSizeMBs;
368 if (!KdpDebugMode.Serial) return;
369
370 if (BootPhase == 0)
371 {
372 /* Write out the functions that we support for now */
373 DispatchTable->KdpInitRoutine = KdpSerialInit;
374 DispatchTable->KdpPrintRoutine = KdpSerialDebugPrint;
375
376 /* Initialize the Port */
377 if (!KdPortInitializeEx(&SerialPortInfo, SerialPortNumber))
378 {
379 KdpDebugMode.Serial = FALSE;
380 return;
381 }
382 KdComPortInUse = SerialPortInfo.Address;
383
384 /* Initialize spinlock */
385 KeInitializeSpinLock(&KdpSerialSpinLock);
386
387 /* Register as a Provider */
388 InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
389
390 /* Display separator + ReactOS version at start of the debug log */
391 MemSizeMBs = KdpGetMemorySizeInMBs(KeLoaderBlock);
392 KdpPrintBanner(MemSizeMBs);
393 }
394 else if (BootPhase == 2)
395 {
396 HalDisplayString("\r\n Serial debugging enabled\r\n\r\n");
397 }
398 }
399
400 /* SCREEN FUNCTIONS **********************************************************/
401
402 /*
403 * Screen debug logger function KdpScreenPrint() writes text messages into
404 * KdpDmesgBuffer, using it as a circular buffer. KdpDmesgBuffer contents could
405 * be later (re)viewed using dmesg command of kdbg. KdpScreenPrint() protects
406 * KdpDmesgBuffer from simultaneous writes by use of KdpDmesgLogSpinLock.
407 */
408 VOID
409 NTAPI
410 KdpScreenPrint(LPSTR Message,
411 ULONG Length)
412 {
413 ULONG beg, end, num;
414 KIRQL OldIrql;
415 PCHAR pch = (PCHAR) Message;
416
417 while (pch < Message + Length && *pch)
418 {
419 if(*pch == '\b')
420 {
421 /* HalDisplayString does not support '\b'. Workaround it and use '\r' */
422 if(KdpScreenLineLength > 0)
423 {
424 /* Remove last character from buffer */
425 KdpScreenLineBuffer[--KdpScreenLineLength] = '\0';
426 KdpScreenLineBufferPos = KdpScreenLineLength;
427
428 /* Clear row and print line again */
429 HalDisplayString("\r");
430 HalDisplayString(KdpScreenLineBuffer);
431 }
432 }
433 else
434 {
435 KdpScreenLineBuffer[KdpScreenLineLength++] = *pch;
436 KdpScreenLineBuffer[KdpScreenLineLength] = '\0';
437 }
438
439 if(*pch == '\n' || KdpScreenLineLength == KdpScreenLineLengthDefault)
440 {
441 /* Print buffered characters */
442 if(KdpScreenLineBufferPos != KdpScreenLineLength)
443 HalDisplayString(KdpScreenLineBuffer + KdpScreenLineBufferPos);
444
445 /* Clear line buffer */
446 KdpScreenLineBuffer[0] = '\0';
447 KdpScreenLineLength = KdpScreenLineBufferPos = 0;
448 }
449
450 ++pch;
451 }
452
453 /* Print buffered characters */
454 if(KdpScreenLineBufferPos != KdpScreenLineLength)
455 {
456 HalDisplayString(KdpScreenLineBuffer + KdpScreenLineBufferPos);
457 KdpScreenLineBufferPos = KdpScreenLineLength;
458 }
459
460 /* Dmesg: store Message in the buffer to show it later */
461 if (KdbpIsInDmesgMode)
462 return;
463
464 if (KdpDmesgBuffer == NULL)
465 return;
466
467 /* Acquire the printing spinlock without waiting at raised IRQL */
468 while (TRUE)
469 {
470 /* Wait when the spinlock becomes available */
471 while (!KeTestSpinLock(&KdpDmesgLogSpinLock));
472
473 /* Spinlock was free, raise IRQL */
474 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
475
476 /* Try to get the spinlock */
477 if (KeTryToAcquireSpinLockAtDpcLevel(&KdpDmesgLogSpinLock))
478 break;
479
480 /* Someone else got the spinlock, lower IRQL back */
481 KeLowerIrql(OldIrql);
482 }
483
484 /* Invariant: always_true(KdpDmesgFreeBytes == KdpDmesgBufferSize);
485 * set num to min(KdpDmesgFreeBytes, Length).
486 */
487 num = (Length < KdpDmesgFreeBytes) ? Length : KdpDmesgFreeBytes;
488 beg = KdpDmesgCurrentPosition;
489 if (num != 0)
490 {
491 end = (beg + num) % KdpDmesgBufferSize;
492 if (end > beg)
493 {
494 RtlCopyMemory(KdpDmesgBuffer + beg, Message, Length);
495 }
496 else
497 {
498 RtlCopyMemory(KdpDmesgBuffer + beg, Message, KdpDmesgBufferSize - beg);
499 RtlCopyMemory(KdpDmesgBuffer, Message + (KdpDmesgBufferSize - beg), end);
500 }
501 KdpDmesgCurrentPosition = end;
502
503 /* Counting the total bytes written */
504 KdbDmesgTotalWritten += num;
505 }
506
507 /* Release spinlock */
508 KiReleaseSpinLock(&KdpDmesgLogSpinLock);
509
510 /* Lower IRQL */
511 KeLowerIrql(OldIrql);
512
513 /* Optional step(?): find out a way to notify about buffer exhaustion,
514 * and possibly fall into kbd to use dmesg command: user will read
515 * debug messages before they will be wiped over by next writes.
516 */
517 }
518
519 VOID
520 NTAPI
521 KdpScreenInit(PKD_DISPATCH_TABLE DispatchTable,
522 ULONG BootPhase)
523 {
524 SIZE_T MemSizeMBs;
525 if (!KdpDebugMode.Screen) return;
526
527 if (BootPhase == 0)
528 {
529 /* Write out the functions that we support for now */
530 DispatchTable->KdpInitRoutine = KdpScreenInit;
531 DispatchTable->KdpPrintRoutine = KdpScreenPrint;
532
533 /* Register as a Provider */
534 InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
535 }
536 else if (BootPhase == 1)
537 {
538 /* Allocate a buffer for dmesg log buffer. +1 for terminating null,
539 * see kdbp_cli.c:KdbpCmdDmesg()/2
540 */
541 KdpDmesgBuffer = ExAllocatePool(NonPagedPool, KdpDmesgBufferSize + 1);
542 RtlZeroMemory(KdpDmesgBuffer, KdpDmesgBufferSize + 1);
543 KdpDmesgFreeBytes = KdpDmesgBufferSize;
544 KdbDmesgTotalWritten = 0;
545
546 /* Take control of the display */
547 InbvAcquireDisplayOwnership();
548 InbvResetDisplay();
549 InbvSolidColorFill(0, 0, 639, 479, 0);
550 InbvSetTextColor(15);
551 InbvSetScrollRegion(0, 0, 639, 479);
552 InbvInstallDisplayStringFilter(NULL);
553 InbvEnableDisplayString(TRUE);
554
555 /* Initialize spinlock */
556 KeInitializeSpinLock(&KdpDmesgLogSpinLock);
557
558 /* Display separator + ReactOS version at start of the debug log */
559 /* Round size up. Assumed to better match actual physical RAM size */
560 MemSizeMBs = ALIGN_UP_BY(MmNumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
561 KdpPrintBanner(MemSizeMBs);
562 }
563 else if (BootPhase == 2)
564 {
565 HalDisplayString("\r\n Screen debugging enabled\r\n\r\n");
566 }
567 }
568
569 /* GENERAL FUNCTIONS *********************************************************/
570
571 ULONG
572 NTAPI
573 KdpPrintString(
574 _In_reads_bytes_(Length) PCHAR UnsafeString,
575 _In_ ULONG Length,
576 _In_ KPROCESSOR_MODE PreviousMode)
577 {
578 PLIST_ENTRY CurrentEntry;
579 PKD_DISPATCH_TABLE CurrentTable;
580 PCHAR String;
581 CHAR StringBuffer[512];
582
583 if (!KdpDebugMode.Value) return 0;
584
585 Length = min(Length, sizeof(StringBuffer));
586
587 if (PreviousMode != KernelMode)
588 {
589 _SEH2_TRY
590 {
591 ProbeForRead(UnsafeString, Length, 1);
592 String = StringBuffer;
593 RtlCopyMemory(String, UnsafeString, Length);
594 }
595 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
596 {
597 return 0;
598 }
599 _SEH2_END;
600 }
601 else
602 {
603 String = UnsafeString;
604 }
605
606 /* Call the registered handlers */
607 CurrentEntry = KdProviders.Flink;
608 while (CurrentEntry != &KdProviders)
609 {
610 /* Get the current table */
611 CurrentTable = CONTAINING_RECORD(CurrentEntry,
612 KD_DISPATCH_TABLE,
613 KdProvidersList);
614
615 /* Call it */
616 CurrentTable->KdpPrintRoutine(String, Length);
617
618 /* Next Table */
619 CurrentEntry = CurrentEntry->Flink;
620 }
621
622 /* Call the Wrapper Routine */
623 if (WrapperTable.KdpPrintRoutine)
624 WrapperTable.KdpPrintRoutine(String, Length);
625
626 /* Return the Length */
627 return Length;
628 }
629
630 /* EOF */