utdebug.c revision 241973 
1/******************************************************************************
2 *
3 * Module Name: utdebug - Debug print routines
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, 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 __UTDEBUG_C__
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48
49#define _COMPONENT          ACPI_UTILITIES
50        ACPI_MODULE_NAME    ("utdebug")
51
52
53#ifdef ACPI_DEBUG_OUTPUT
54
55static ACPI_THREAD_ID       AcpiGbl_PrevThreadId = (ACPI_THREAD_ID) 0xFFFFFFFF;
56static char                 *AcpiGbl_FnEntryStr = "----Entry";
57static char                 *AcpiGbl_FnExitStr  = "----Exit-";
58
59/* Local prototypes */
60
61static const char *
62AcpiUtTrimFunctionName (
63    const char              *FunctionName);
64
65
66/*******************************************************************************
67 *
68 * FUNCTION:    AcpiUtInitStackPtrTrace
69 *
70 * PARAMETERS:  None
71 *
72 * RETURN:      None
73 *
74 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
75 *
76 ******************************************************************************/
77
78void
79AcpiUtInitStackPtrTrace (
80    void)
81{
82    ACPI_SIZE               CurrentSp;
83
84
85    AcpiGbl_EntryStackPointer = &CurrentSp;
86}
87
88
89/*******************************************************************************
90 *
91 * FUNCTION:    AcpiUtTrackStackPtr
92 *
93 * PARAMETERS:  None
94 *
95 * RETURN:      None
96 *
97 * DESCRIPTION: Save the current CPU stack pointer
98 *
99 ******************************************************************************/
100
101void
102AcpiUtTrackStackPtr (
103    void)
104{
105    ACPI_SIZE               CurrentSp;
106
107
108    if (&CurrentSp < AcpiGbl_LowestStackPointer)
109    {
110        AcpiGbl_LowestStackPointer = &CurrentSp;
111    }
112
113    if (AcpiGbl_NestingLevel > AcpiGbl_DeepestNesting)
114    {
115        AcpiGbl_DeepestNesting = AcpiGbl_NestingLevel;
116    }
117}
118
119
120/*******************************************************************************
121 *
122 * FUNCTION:    AcpiUtTrimFunctionName
123 *
124 * PARAMETERS:  FunctionName        - Ascii string containing a procedure name
125 *
126 * RETURN:      Updated pointer to the function name
127 *
128 * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
129 *              This allows compiler macros such as __FUNCTION__ to be used
130 *              with no change to the debug output.
131 *
132 ******************************************************************************/
133
134static const char *
135AcpiUtTrimFunctionName (
136    const char              *FunctionName)
137{
138
139    /* All Function names are longer than 4 chars, check is safe */
140
141    if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_MIXED)
142    {
143        /* This is the case where the original source has not been modified */
144
145        return (FunctionName + 4);
146    }
147
148    if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_LOWER)
149    {
150        /* This is the case where the source has been 'linuxized' */
151
152        return (FunctionName + 5);
153    }
154
155    return (FunctionName);
156}
157
158
159/*******************************************************************************
160 *
161 * FUNCTION:    AcpiDebugPrint
162 *
163 * PARAMETERS:  RequestedDebugLevel - Requested debug print level
164 *              LineNumber          - Caller's line number (for error output)
165 *              FunctionName        - Caller's procedure name
166 *              ModuleName          - Caller's module name
167 *              ComponentId         - Caller's component ID
168 *              Format              - Printf format field
169 *              ...                 - Optional printf arguments
170 *
171 * RETURN:      None
172 *
173 * DESCRIPTION: Print error message with prefix consisting of the module name,
174 *              line number, and component ID.
175 *
176 ******************************************************************************/
177
178void  ACPI_INTERNAL_VAR_XFACE
179AcpiDebugPrint (
180    UINT32                  RequestedDebugLevel,
181    UINT32                  LineNumber,
182    const char              *FunctionName,
183    const char              *ModuleName,
184    UINT32                  ComponentId,
185    const char              *Format,
186    ...)
187{
188    ACPI_THREAD_ID          ThreadId;
189    va_list                 args;
190
191
192    /*
193     * Stay silent if the debug level or component ID is disabled
194     */
195    if (!(RequestedDebugLevel & AcpiDbgLevel) ||
196        !(ComponentId & AcpiDbgLayer))
197    {
198        return;
199    }
200
201    /*
202     * Thread tracking and context switch notification
203     */
204    ThreadId = AcpiOsGetThreadId ();
205    if (ThreadId != AcpiGbl_PrevThreadId)
206    {
207        if (ACPI_LV_THREADS & AcpiDbgLevel)
208        {
209            AcpiOsPrintf (
210                "\n**** Context Switch from TID %u to TID %u ****\n\n",
211                (UINT32) AcpiGbl_PrevThreadId, (UINT32) ThreadId);
212        }
213
214        AcpiGbl_PrevThreadId = ThreadId;
215    }
216
217    /*
218     * Display the module name, current line number, thread ID (if requested),
219     * current procedure nesting level, and the current procedure name
220     */
221    AcpiOsPrintf ("%8s-%04ld ", ModuleName, LineNumber);
222
223    if (ACPI_LV_THREADS & AcpiDbgLevel)
224    {
225        AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
226    }
227
228    AcpiOsPrintf ("[%02ld] %-22.22s: ",
229        AcpiGbl_NestingLevel, AcpiUtTrimFunctionName (FunctionName));
230
231    va_start (args, Format);
232    AcpiOsVprintf (Format, args);
233    va_end (args);
234}
235
236ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
237
238
239/*******************************************************************************
240 *
241 * FUNCTION:    AcpiDebugPrintRaw
242 *
243 * PARAMETERS:  RequestedDebugLevel - Requested debug print level
244 *              LineNumber          - Caller's line number
245 *              FunctionName        - Caller's procedure name
246 *              ModuleName          - Caller's module name
247 *              ComponentId         - Caller's component ID
248 *              Format              - Printf format field
249 *              ...                 - Optional printf arguments
250 *
251 * RETURN:      None
252 *
253 * DESCRIPTION: Print message with no headers. Has same interface as
254 *              DebugPrint so that the same macros can be used.
255 *
256 ******************************************************************************/
257
258void  ACPI_INTERNAL_VAR_XFACE
259AcpiDebugPrintRaw (
260    UINT32                  RequestedDebugLevel,
261    UINT32                  LineNumber,
262    const char              *FunctionName,
263    const char              *ModuleName,
264    UINT32                  ComponentId,
265    const char              *Format,
266    ...)
267{
268    va_list                 args;
269
270
271    if (!(RequestedDebugLevel & AcpiDbgLevel) ||
272        !(ComponentId & AcpiDbgLayer))
273    {
274        return;
275    }
276
277    va_start (args, Format);
278    AcpiOsVprintf (Format, args);
279    va_end (args);
280}
281
282ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
283
284
285/*******************************************************************************
286 *
287 * FUNCTION:    AcpiUtTrace
288 *
289 * PARAMETERS:  LineNumber          - Caller's line number
290 *              FunctionName        - Caller's procedure name
291 *              ModuleName          - Caller's module name
292 *              ComponentId         - Caller's component ID
293 *
294 * RETURN:      None
295 *
296 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
297 *              set in DebugLevel
298 *
299 ******************************************************************************/
300
301void
302AcpiUtTrace (
303    UINT32                  LineNumber,
304    const char              *FunctionName,
305    const char              *ModuleName,
306    UINT32                  ComponentId)
307{
308
309    AcpiGbl_NestingLevel++;
310    AcpiUtTrackStackPtr ();
311
312    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
313        LineNumber, FunctionName, ModuleName, ComponentId,
314        "%s\n", AcpiGbl_FnEntryStr);
315}
316
317ACPI_EXPORT_SYMBOL (AcpiUtTrace)
318
319
320/*******************************************************************************
321 *
322 * FUNCTION:    AcpiUtTracePtr
323 *
324 * PARAMETERS:  LineNumber          - Caller's line number
325 *              FunctionName        - Caller's procedure name
326 *              ModuleName          - Caller's module name
327 *              ComponentId         - Caller's component ID
328 *              Pointer             - Pointer to display
329 *
330 * RETURN:      None
331 *
332 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
333 *              set in DebugLevel
334 *
335 ******************************************************************************/
336
337void
338AcpiUtTracePtr (
339    UINT32                  LineNumber,
340    const char              *FunctionName,
341    const char              *ModuleName,
342    UINT32                  ComponentId,
343    void                    *Pointer)
344{
345
346    AcpiGbl_NestingLevel++;
347    AcpiUtTrackStackPtr ();
348
349    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
350        LineNumber, FunctionName, ModuleName, ComponentId,
351        "%s %p\n", AcpiGbl_FnEntryStr, Pointer);
352}
353
354
355/*******************************************************************************
356 *
357 * FUNCTION:    AcpiUtTraceStr
358 *
359 * PARAMETERS:  LineNumber          - Caller's line number
360 *              FunctionName        - Caller's procedure name
361 *              ModuleName          - Caller's module name
362 *              ComponentId         - Caller's component ID
363 *              String              - Additional string to display
364 *
365 * RETURN:      None
366 *
367 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
368 *              set in DebugLevel
369 *
370 ******************************************************************************/
371
372void
373AcpiUtTraceStr (
374    UINT32                  LineNumber,
375    const char              *FunctionName,
376    const char              *ModuleName,
377    UINT32                  ComponentId,
378    char                    *String)
379{
380
381    AcpiGbl_NestingLevel++;
382    AcpiUtTrackStackPtr ();
383
384    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
385        LineNumber, FunctionName, ModuleName, ComponentId,
386        "%s %s\n", AcpiGbl_FnEntryStr, String);
387}
388
389
390/*******************************************************************************
391 *
392 * FUNCTION:    AcpiUtTraceU32
393 *
394 * PARAMETERS:  LineNumber          - Caller's line number
395 *              FunctionName        - Caller's procedure name
396 *              ModuleName          - Caller's module name
397 *              ComponentId         - Caller's component ID
398 *              Integer             - Integer to display
399 *
400 * RETURN:      None
401 *
402 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
403 *              set in DebugLevel
404 *
405 ******************************************************************************/
406
407void
408AcpiUtTraceU32 (
409    UINT32                  LineNumber,
410    const char              *FunctionName,
411    const char              *ModuleName,
412    UINT32                  ComponentId,
413    UINT32                  Integer)
414{
415
416    AcpiGbl_NestingLevel++;
417    AcpiUtTrackStackPtr ();
418
419    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
420        LineNumber, FunctionName, ModuleName, ComponentId,
421        "%s %08X\n", AcpiGbl_FnEntryStr, Integer);
422}
423
424
425/*******************************************************************************
426 *
427 * FUNCTION:    AcpiUtExit
428 *
429 * PARAMETERS:  LineNumber          - Caller's line number
430 *              FunctionName        - Caller's procedure name
431 *              ModuleName          - Caller's module name
432 *              ComponentId         - Caller's component ID
433 *
434 * RETURN:      None
435 *
436 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
437 *              set in DebugLevel
438 *
439 ******************************************************************************/
440
441void
442AcpiUtExit (
443    UINT32                  LineNumber,
444    const char              *FunctionName,
445    const char              *ModuleName,
446    UINT32                  ComponentId)
447{
448
449    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
450        LineNumber, FunctionName, ModuleName, ComponentId,
451        "%s\n", AcpiGbl_FnExitStr);
452
453    AcpiGbl_NestingLevel--;
454}
455
456ACPI_EXPORT_SYMBOL (AcpiUtExit)
457
458
459/*******************************************************************************
460 *
461 * FUNCTION:    AcpiUtStatusExit
462 *
463 * PARAMETERS:  LineNumber          - Caller's line number
464 *              FunctionName        - Caller's procedure name
465 *              ModuleName          - Caller's module name
466 *              ComponentId         - Caller's component ID
467 *              Status              - Exit status code
468 *
469 * RETURN:      None
470 *
471 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
472 *              set in DebugLevel. Prints exit status also.
473 *
474 ******************************************************************************/
475
476void
477AcpiUtStatusExit (
478    UINT32                  LineNumber,
479    const char              *FunctionName,
480    const char              *ModuleName,
481    UINT32                  ComponentId,
482    ACPI_STATUS             Status)
483{
484
485    if (ACPI_SUCCESS (Status))
486    {
487        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
488            LineNumber, FunctionName, ModuleName, ComponentId,
489            "%s %s\n", AcpiGbl_FnExitStr,
490            AcpiFormatException (Status));
491    }
492    else
493    {
494        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
495            LineNumber, FunctionName, ModuleName, ComponentId,
496            "%s ****Exception****: %s\n", AcpiGbl_FnExitStr,
497            AcpiFormatException (Status));
498    }
499
500    AcpiGbl_NestingLevel--;
501}
502
503ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
504
505
506/*******************************************************************************
507 *
508 * FUNCTION:    AcpiUtValueExit
509 *
510 * PARAMETERS:  LineNumber          - Caller's line number
511 *              FunctionName        - Caller's procedure name
512 *              ModuleName          - Caller's module name
513 *              ComponentId         - Caller's component ID
514 *              Value               - Value to be printed with exit msg
515 *
516 * RETURN:      None
517 *
518 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
519 *              set in DebugLevel. Prints exit value also.
520 *
521 ******************************************************************************/
522
523void
524AcpiUtValueExit (
525    UINT32                  LineNumber,
526    const char              *FunctionName,
527    const char              *ModuleName,
528    UINT32                  ComponentId,
529    UINT64                  Value)
530{
531
532    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
533        LineNumber, FunctionName, ModuleName, ComponentId,
534        "%s %8.8X%8.8X\n", AcpiGbl_FnExitStr,
535        ACPI_FORMAT_UINT64 (Value));
536
537    AcpiGbl_NestingLevel--;
538}
539
540ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
541
542
543/*******************************************************************************
544 *
545 * FUNCTION:    AcpiUtPtrExit
546 *
547 * PARAMETERS:  LineNumber          - Caller's line number
548 *              FunctionName        - Caller's procedure name
549 *              ModuleName          - Caller's module name
550 *              ComponentId         - Caller's component ID
551 *              Ptr                 - Pointer to display
552 *
553 * RETURN:      None
554 *
555 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
556 *              set in DebugLevel. Prints exit value also.
557 *
558 ******************************************************************************/
559
560void
561AcpiUtPtrExit (
562    UINT32                  LineNumber,
563    const char              *FunctionName,
564    const char              *ModuleName,
565    UINT32                  ComponentId,
566    UINT8                   *Ptr)
567{
568
569    AcpiDebugPrint (ACPI_LV_FUNCTIONS,
570        LineNumber, FunctionName, ModuleName, ComponentId,
571        "%s %p\n", AcpiGbl_FnExitStr, Ptr);
572
573    AcpiGbl_NestingLevel--;
574}
575
576#endif
577
578
579/*******************************************************************************
580 *
581 * FUNCTION:    AcpiUtDumpBuffer
582 *
583 * PARAMETERS:  Buffer              - Buffer to dump
584 *              Count               - Amount to dump, in bytes
585 *              Display             - BYTE, WORD, DWORD, or QWORD display
586 *              Offset              - Beginning buffer offset (display only)
587 *
588 * RETURN:      None
589 *
590 * DESCRIPTION: Generic dump buffer in both hex and ascii.
591 *
592 ******************************************************************************/
593
594void
595AcpiUtDumpBuffer (
596    UINT8                   *Buffer,
597    UINT32                  Count,
598    UINT32                  Display,
599    UINT32                  BaseOffset)
600{
601    UINT32                  i = 0;
602    UINT32                  j;
603    UINT32                  Temp32;
604    UINT8                   BufChar;
605
606
607    if (!Buffer)
608    {
609        AcpiOsPrintf ("Null Buffer Pointer in DumpBuffer!\n");
610        return;
611    }
612
613    if ((Count < 4) || (Count & 0x01))
614    {
615        Display = DB_BYTE_DISPLAY;
616    }
617
618    /* Nasty little dump buffer routine! */
619
620    while (i < Count)
621    {
622        /* Print current offset */
623
624        AcpiOsPrintf ("%6.4X: ", (BaseOffset + i));
625
626        /* Print 16 hex chars */
627
628        for (j = 0; j < 16;)
629        {
630            if (i + j >= Count)
631            {
632                /* Dump fill spaces */
633
634                AcpiOsPrintf ("%*s", ((Display * 2) + 1), " ");
635                j += Display;
636                continue;
637            }
638
639            switch (Display)
640            {
641            case DB_BYTE_DISPLAY:
642            default:    /* Default is BYTE display */
643
644                AcpiOsPrintf ("%02X ", Buffer[(ACPI_SIZE) i + j]);
645                break;
646
647
648            case DB_WORD_DISPLAY:
649
650                ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
651                AcpiOsPrintf ("%04X ", Temp32);
652                break;
653
654
655            case DB_DWORD_DISPLAY:
656
657                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
658                AcpiOsPrintf ("%08X ", Temp32);
659                break;
660
661
662            case DB_QWORD_DISPLAY:
663
664                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
665                AcpiOsPrintf ("%08X", Temp32);
666
667                ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
668                AcpiOsPrintf ("%08X ", Temp32);
669                break;
670            }
671
672            j += Display;
673        }
674
675        /*
676         * Print the ASCII equivalent characters but watch out for the bad
677         * unprintable ones (printable chars are 0x20 through 0x7E)
678         */
679        AcpiOsPrintf (" ");
680        for (j = 0; j < 16; j++)
681        {
682            if (i + j >= Count)
683            {
684                AcpiOsPrintf ("\n");
685                return;
686            }
687
688            BufChar = Buffer[(ACPI_SIZE) i + j];
689            if (ACPI_IS_PRINT (BufChar))
690            {
691                AcpiOsPrintf ("%c", BufChar);
692            }
693            else
694            {
695                AcpiOsPrintf (".");
696            }
697        }
698
699        /* Done with that line. */
700
701        AcpiOsPrintf ("\n");
702        i += 16;
703    }
704
705    return;
706}
707
708
709/*******************************************************************************
710 *
711 * FUNCTION:    AcpiUtDebugDumpBuffer
712 *
713 * PARAMETERS:  Buffer              - Buffer to dump
714 *              Count               - Amount to dump, in bytes
715 *              Display             - BYTE, WORD, DWORD, or QWORD display
716 *              ComponentID         - Caller's component ID
717 *
718 * RETURN:      None
719 *
720 * DESCRIPTION: Generic dump buffer in both hex and ascii.
721 *
722 ******************************************************************************/
723
724void
725AcpiUtDebugDumpBuffer (
726    UINT8                   *Buffer,
727    UINT32                  Count,
728    UINT32                  Display,
729    UINT32                  ComponentId)
730{
731
732    /* Only dump the buffer if tracing is enabled */
733
734    if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
735        (ComponentId & AcpiDbgLayer)))
736    {
737        return;
738    }
739
740    AcpiUtDumpBuffer (Buffer, Count, Display, 0);
741}
742