[ACPICA] Update to version 20171215. CORE-15222
[reactos.git] / drivers / bus / acpi / acpica / utilities / utdebug.c
1 /******************************************************************************
2 *
3 * Module Name: utdebug - Debug print/trace routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #define EXPORT_ACPI_INTERFACES
45
46 #include "acpi.h"
47 #include "accommon.h"
48 #include "acinterp.h"
49
50 #define _COMPONENT ACPI_UTILITIES
51 ACPI_MODULE_NAME ("utdebug")
52
53
54 #ifdef ACPI_DEBUG_OUTPUT
55
56 static ACPI_THREAD_ID AcpiGbl_PreviousThreadId = (ACPI_THREAD_ID) 0xFFFFFFFF;
57 static const char *AcpiGbl_FunctionEntryPrefix = "----Entry";
58 static const char *AcpiGbl_FunctionExitPrefix = "----Exit-";
59
60
61 /*******************************************************************************
62 *
63 * FUNCTION: AcpiUtInitStackPtrTrace
64 *
65 * PARAMETERS: None
66 *
67 * RETURN: None
68 *
69 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
70 *
71 ******************************************************************************/
72
73 void
74 AcpiUtInitStackPtrTrace (
75 void)
76 {
77 ACPI_SIZE CurrentSp;
78
79
80 AcpiGbl_EntryStackPointer = &CurrentSp;
81 }
82
83
84 /*******************************************************************************
85 *
86 * FUNCTION: AcpiUtTrackStackPtr
87 *
88 * PARAMETERS: None
89 *
90 * RETURN: None
91 *
92 * DESCRIPTION: Save the current CPU stack pointer
93 *
94 ******************************************************************************/
95
96 void
97 AcpiUtTrackStackPtr (
98 void)
99 {
100 ACPI_SIZE CurrentSp;
101
102
103 if (&CurrentSp < AcpiGbl_LowestStackPointer)
104 {
105 AcpiGbl_LowestStackPointer = &CurrentSp;
106 }
107
108 if (AcpiGbl_NestingLevel > AcpiGbl_DeepestNesting)
109 {
110 AcpiGbl_DeepestNesting = AcpiGbl_NestingLevel;
111 }
112 }
113
114
115 /*******************************************************************************
116 *
117 * FUNCTION: AcpiUtTrimFunctionName
118 *
119 * PARAMETERS: FunctionName - Ascii string containing a procedure name
120 *
121 * RETURN: Updated pointer to the function name
122 *
123 * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
124 * This allows compiler macros such as __FUNCTION__ to be used
125 * with no change to the debug output.
126 *
127 ******************************************************************************/
128
129 static const char *
130 AcpiUtTrimFunctionName (
131 const char *FunctionName)
132 {
133
134 /* All Function names are longer than 4 chars, check is safe */
135
136 if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_MIXED)
137 {
138 /* This is the case where the original source has not been modified */
139
140 return (FunctionName + 4);
141 }
142
143 if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_LOWER)
144 {
145 /* This is the case where the source has been 'linuxized' */
146
147 return (FunctionName + 5);
148 }
149
150 return (FunctionName);
151 }
152
153
154 /*******************************************************************************
155 *
156 * FUNCTION: AcpiDebugPrint
157 *
158 * PARAMETERS: RequestedDebugLevel - Requested debug print level
159 * LineNumber - Caller's line number (for error output)
160 * FunctionName - Caller's procedure name
161 * ModuleName - Caller's module name
162 * ComponentId - Caller's component ID
163 * Format - Printf format field
164 * ... - Optional printf arguments
165 *
166 * RETURN: None
167 *
168 * DESCRIPTION: Print error message with prefix consisting of the module name,
169 * line number, and component ID.
170 *
171 ******************************************************************************/
172
173 void ACPI_INTERNAL_VAR_XFACE
174 AcpiDebugPrint (
175 UINT32 RequestedDebugLevel,
176 UINT32 LineNumber,
177 const char *FunctionName,
178 const char *ModuleName,
179 UINT32 ComponentId,
180 const char *Format,
181 ...)
182 {
183 ACPI_THREAD_ID ThreadId;
184 va_list args;
185 #ifdef ACPI_APPLICATION
186 int FillCount;
187 #endif
188
189 /* Check if debug output enabled */
190
191 if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
192 {
193 return;
194 }
195
196 /*
197 * Thread tracking and context switch notification
198 */
199 ThreadId = AcpiOsGetThreadId ();
200 if (ThreadId != AcpiGbl_PreviousThreadId)
201 {
202 if (ACPI_LV_THREADS & AcpiDbgLevel)
203 {
204 AcpiOsPrintf (
205 "\n**** Context Switch from TID %u to TID %u ****\n\n",
206 (UINT32) AcpiGbl_PreviousThreadId, (UINT32) ThreadId);
207 }
208
209 AcpiGbl_PreviousThreadId = ThreadId;
210 AcpiGbl_NestingLevel = 0;
211 }
212
213 /*
214 * Display the module name, current line number, thread ID (if requested),
215 * current procedure nesting level, and the current procedure name
216 */
217 AcpiOsPrintf ("%9s-%04ld ", ModuleName, LineNumber);
218
219 #ifdef ACPI_APPLICATION
220 /*
221 * For AcpiExec/iASL only, emit the thread ID and nesting level.
222 * Note: nesting level is really only useful during a single-thread
223 * execution. Otherwise, multiple threads will keep resetting the
224 * level.
225 */
226 if (ACPI_LV_THREADS & AcpiDbgLevel)
227 {
228 AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
229 }
230
231 FillCount = 48 - AcpiGbl_NestingLevel -
232 strlen (AcpiUtTrimFunctionName (FunctionName));
233 if (FillCount < 0)
234 {
235 FillCount = 0;
236 }
237
238 AcpiOsPrintf ("[%02ld] %*s",
239 AcpiGbl_NestingLevel, AcpiGbl_NestingLevel + 1, " ");
240 AcpiOsPrintf ("%s%*s: ",
241 AcpiUtTrimFunctionName (FunctionName), FillCount, " ");
242
243 #else
244 AcpiOsPrintf ("%-22.22s: ", AcpiUtTrimFunctionName (FunctionName));
245 #endif
246
247 va_start (args, Format);
248 AcpiOsVprintf (Format, args);
249 va_end (args);
250 }
251
252 ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
253
254
255 /*******************************************************************************
256 *
257 * FUNCTION: AcpiDebugPrintRaw
258 *
259 * PARAMETERS: RequestedDebugLevel - Requested debug print level
260 * LineNumber - Caller's line number
261 * FunctionName - Caller's procedure name
262 * ModuleName - Caller's module name
263 * ComponentId - Caller's component ID
264 * Format - Printf format field
265 * ... - Optional printf arguments
266 *
267 * RETURN: None
268 *
269 * DESCRIPTION: Print message with no headers. Has same interface as
270 * DebugPrint so that the same macros can be used.
271 *
272 ******************************************************************************/
273
274 void ACPI_INTERNAL_VAR_XFACE
275 AcpiDebugPrintRaw (
276 UINT32 RequestedDebugLevel,
277 UINT32 LineNumber,
278 const char *FunctionName,
279 const char *ModuleName,
280 UINT32 ComponentId,
281 const char *Format,
282 ...)
283 {
284 va_list args;
285
286
287 /* Check if debug output enabled */
288
289 if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
290 {
291 return;
292 }
293
294 va_start (args, Format);
295 AcpiOsVprintf (Format, args);
296 va_end (args);
297 }
298
299 ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
300
301
302 /*******************************************************************************
303 *
304 * FUNCTION: AcpiUtTrace
305 *
306 * PARAMETERS: LineNumber - Caller's line number
307 * FunctionName - Caller's procedure name
308 * ModuleName - Caller's module name
309 * ComponentId - Caller's component ID
310 *
311 * RETURN: None
312 *
313 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
314 * set in DebugLevel
315 *
316 ******************************************************************************/
317
318 void
319 AcpiUtTrace (
320 UINT32 LineNumber,
321 const char *FunctionName,
322 const char *ModuleName,
323 UINT32 ComponentId)
324 {
325
326 AcpiGbl_NestingLevel++;
327 AcpiUtTrackStackPtr ();
328
329 /* Check if enabled up-front for performance */
330
331 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
332 {
333 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
334 LineNumber, FunctionName, ModuleName, ComponentId,
335 "%s\n", AcpiGbl_FunctionEntryPrefix);
336 }
337 }
338
339 ACPI_EXPORT_SYMBOL (AcpiUtTrace)
340
341
342 /*******************************************************************************
343 *
344 * FUNCTION: AcpiUtTracePtr
345 *
346 * PARAMETERS: LineNumber - Caller's line number
347 * FunctionName - Caller's procedure name
348 * ModuleName - Caller's module name
349 * ComponentId - Caller's component ID
350 * Pointer - Pointer to display
351 *
352 * RETURN: None
353 *
354 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
355 * set in DebugLevel
356 *
357 ******************************************************************************/
358
359 void
360 AcpiUtTracePtr (
361 UINT32 LineNumber,
362 const char *FunctionName,
363 const char *ModuleName,
364 UINT32 ComponentId,
365 const void *Pointer)
366 {
367
368 AcpiGbl_NestingLevel++;
369 AcpiUtTrackStackPtr ();
370
371 /* Check if enabled up-front for performance */
372
373 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
374 {
375 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
376 LineNumber, FunctionName, ModuleName, ComponentId,
377 "%s %p\n", AcpiGbl_FunctionEntryPrefix, Pointer);
378 }
379 }
380
381
382 /*******************************************************************************
383 *
384 * FUNCTION: AcpiUtTraceStr
385 *
386 * PARAMETERS: LineNumber - Caller's line number
387 * FunctionName - Caller's procedure name
388 * ModuleName - Caller's module name
389 * ComponentId - Caller's component ID
390 * String - Additional string to display
391 *
392 * RETURN: None
393 *
394 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
395 * set in DebugLevel
396 *
397 ******************************************************************************/
398
399 void
400 AcpiUtTraceStr (
401 UINT32 LineNumber,
402 const char *FunctionName,
403 const char *ModuleName,
404 UINT32 ComponentId,
405 const char *String)
406 {
407
408 AcpiGbl_NestingLevel++;
409 AcpiUtTrackStackPtr ();
410
411 /* Check if enabled up-front for performance */
412
413 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
414 {
415 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
416 LineNumber, FunctionName, ModuleName, ComponentId,
417 "%s %s\n", AcpiGbl_FunctionEntryPrefix, String);
418 }
419 }
420
421
422 /*******************************************************************************
423 *
424 * FUNCTION: AcpiUtTraceU32
425 *
426 * PARAMETERS: LineNumber - Caller's line number
427 * FunctionName - Caller's procedure name
428 * ModuleName - Caller's module name
429 * ComponentId - Caller's component ID
430 * Integer - Integer to display
431 *
432 * RETURN: None
433 *
434 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
435 * set in DebugLevel
436 *
437 ******************************************************************************/
438
439 void
440 AcpiUtTraceU32 (
441 UINT32 LineNumber,
442 const char *FunctionName,
443 const char *ModuleName,
444 UINT32 ComponentId,
445 UINT32 Integer)
446 {
447
448 AcpiGbl_NestingLevel++;
449 AcpiUtTrackStackPtr ();
450
451 /* Check if enabled up-front for performance */
452
453 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
454 {
455 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
456 LineNumber, FunctionName, ModuleName, ComponentId,
457 "%s %08X\n", AcpiGbl_FunctionEntryPrefix, Integer);
458 }
459 }
460
461
462 /*******************************************************************************
463 *
464 * FUNCTION: AcpiUtExit
465 *
466 * PARAMETERS: LineNumber - Caller's line number
467 * FunctionName - Caller's procedure name
468 * ModuleName - Caller's module name
469 * ComponentId - Caller's component ID
470 *
471 * RETURN: None
472 *
473 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
474 * set in DebugLevel
475 *
476 ******************************************************************************/
477
478 void
479 AcpiUtExit (
480 UINT32 LineNumber,
481 const char *FunctionName,
482 const char *ModuleName,
483 UINT32 ComponentId)
484 {
485
486 /* Check if enabled up-front for performance */
487
488 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
489 {
490 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
491 LineNumber, FunctionName, ModuleName, ComponentId,
492 "%s\n", AcpiGbl_FunctionExitPrefix);
493 }
494
495 if (AcpiGbl_NestingLevel)
496 {
497 AcpiGbl_NestingLevel--;
498 }
499 }
500
501 ACPI_EXPORT_SYMBOL (AcpiUtExit)
502
503
504 /*******************************************************************************
505 *
506 * FUNCTION: AcpiUtStatusExit
507 *
508 * PARAMETERS: LineNumber - Caller's line number
509 * FunctionName - Caller's procedure name
510 * ModuleName - Caller's module name
511 * ComponentId - Caller's component ID
512 * Status - Exit status code
513 *
514 * RETURN: None
515 *
516 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
517 * set in DebugLevel. Prints exit status also.
518 *
519 ******************************************************************************/
520
521 void
522 AcpiUtStatusExit (
523 UINT32 LineNumber,
524 const char *FunctionName,
525 const char *ModuleName,
526 UINT32 ComponentId,
527 ACPI_STATUS Status)
528 {
529
530 /* Check if enabled up-front for performance */
531
532 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
533 {
534 if (ACPI_SUCCESS (Status))
535 {
536 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
537 LineNumber, FunctionName, ModuleName, ComponentId,
538 "%s %s\n", AcpiGbl_FunctionExitPrefix,
539 AcpiFormatException (Status));
540 }
541 else
542 {
543 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
544 LineNumber, FunctionName, ModuleName, ComponentId,
545 "%s ****Exception****: %s\n", AcpiGbl_FunctionExitPrefix,
546 AcpiFormatException (Status));
547 }
548 }
549
550 if (AcpiGbl_NestingLevel)
551 {
552 AcpiGbl_NestingLevel--;
553 }
554 }
555
556 ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
557
558
559 /*******************************************************************************
560 *
561 * FUNCTION: AcpiUtValueExit
562 *
563 * PARAMETERS: LineNumber - Caller's line number
564 * FunctionName - Caller's procedure name
565 * ModuleName - Caller's module name
566 * ComponentId - Caller's component ID
567 * Value - Value to be printed with exit msg
568 *
569 * RETURN: None
570 *
571 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
572 * set in DebugLevel. Prints exit value also.
573 *
574 ******************************************************************************/
575
576 void
577 AcpiUtValueExit (
578 UINT32 LineNumber,
579 const char *FunctionName,
580 const char *ModuleName,
581 UINT32 ComponentId,
582 UINT64 Value)
583 {
584
585 /* Check if enabled up-front for performance */
586
587 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
588 {
589 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
590 LineNumber, FunctionName, ModuleName, ComponentId,
591 "%s %8.8X%8.8X\n", AcpiGbl_FunctionExitPrefix,
592 ACPI_FORMAT_UINT64 (Value));
593 }
594
595 if (AcpiGbl_NestingLevel)
596 {
597 AcpiGbl_NestingLevel--;
598 }
599 }
600
601 ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
602
603
604 /*******************************************************************************
605 *
606 * FUNCTION: AcpiUtPtrExit
607 *
608 * PARAMETERS: LineNumber - Caller's line number
609 * FunctionName - Caller's procedure name
610 * ModuleName - Caller's module name
611 * ComponentId - Caller's component ID
612 * Ptr - Pointer to display
613 *
614 * RETURN: None
615 *
616 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
617 * set in DebugLevel. Prints exit value also.
618 *
619 ******************************************************************************/
620
621 void
622 AcpiUtPtrExit (
623 UINT32 LineNumber,
624 const char *FunctionName,
625 const char *ModuleName,
626 UINT32 ComponentId,
627 UINT8 *Ptr)
628 {
629
630 /* Check if enabled up-front for performance */
631
632 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
633 {
634 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
635 LineNumber, FunctionName, ModuleName, ComponentId,
636 "%s %p\n", AcpiGbl_FunctionExitPrefix, Ptr);
637 }
638
639 if (AcpiGbl_NestingLevel)
640 {
641 AcpiGbl_NestingLevel--;
642 }
643 }
644
645
646 /*******************************************************************************
647 *
648 * FUNCTION: AcpiUtStrExit
649 *
650 * PARAMETERS: LineNumber - Caller's line number
651 * FunctionName - Caller's procedure name
652 * ModuleName - Caller's module name
653 * ComponentId - Caller's component ID
654 * String - String to display
655 *
656 * RETURN: None
657 *
658 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
659 * set in DebugLevel. Prints exit value also.
660 *
661 ******************************************************************************/
662
663 void
664 AcpiUtStrExit (
665 UINT32 LineNumber,
666 const char *FunctionName,
667 const char *ModuleName,
668 UINT32 ComponentId,
669 const char *String)
670 {
671
672 /* Check if enabled up-front for performance */
673
674 if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
675 {
676 AcpiDebugPrint (ACPI_LV_FUNCTIONS,
677 LineNumber, FunctionName, ModuleName, ComponentId,
678 "%s %s\n", AcpiGbl_FunctionExitPrefix, String);
679 }
680
681 if (AcpiGbl_NestingLevel)
682 {
683 AcpiGbl_NestingLevel--;
684 }
685 }
686
687
688 /*******************************************************************************
689 *
690 * FUNCTION: AcpiTracePoint
691 *
692 * PARAMETERS: Type - Trace event type
693 * Begin - TRUE if before execution
694 * Aml - Executed AML address
695 * Pathname - Object path
696 * Pointer - Pointer to the related object
697 *
698 * RETURN: None
699 *
700 * DESCRIPTION: Interpreter execution trace.
701 *
702 ******************************************************************************/
703
704 void
705 AcpiTracePoint (
706 ACPI_TRACE_EVENT_TYPE Type,
707 BOOLEAN Begin,
708 UINT8 *Aml,
709 char *Pathname)
710 {
711
712 ACPI_FUNCTION_ENTRY ();
713
714 AcpiExTracePoint (Type, Begin, Aml, Pathname);
715
716 #ifdef ACPI_USE_SYSTEM_TRACER
717 AcpiOsTracePoint (Type, Begin, Aml, Pathname);
718 #endif
719 }
720
721 ACPI_EXPORT_SYMBOL (AcpiTracePoint)
722
723
724 #endif