utdebug.c revision 256281 
1/******************************************************************************
2 *
3 * Module Name: utdebug - Debug print/trace routines
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2013, 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    /* Check if debug output enabled */
193
194    if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
195    {
196        return;
197    }
198
199    /*
200     * Thread tracking and context switch notification
201     */
202    ThreadId = AcpiOsGetThreadId ();
203    if (ThreadId != AcpiGbl_PrevThreadId)
204    {
205        if (ACPI_LV_THREADS & AcpiDbgLevel)
206        {
207            AcpiOsPrintf (
208                "\n**** Context Switch from TID %u to TID %u ****\n\n",
209                (UINT32) AcpiGbl_PrevThreadId, (UINT32) ThreadId);
210        }
211
212        AcpiGbl_PrevThreadId = ThreadId;
213    }
214
215    /*
216     * Display the module name, current line number, thread ID (if requested),
217     * current procedure nesting level, and the current procedure name
218     */
219    AcpiOsPrintf ("%9s-%04ld ", ModuleName, LineNumber);
220
221    if (ACPI_LV_THREADS & AcpiDbgLevel)
222    {
223        AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
224    }
225
226    AcpiOsPrintf ("[%02ld] %-22.22s: ",
227        AcpiGbl_NestingLevel, AcpiUtTrimFunctionName (FunctionName));
228
229    va_start (args, Format);
230    AcpiOsVprintf (Format, args);
231    va_end (args);
232}
233
234ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
235
236
237/*******************************************************************************
238 *
239 * FUNCTION:    AcpiDebugPrintRaw
240 *
241 * PARAMETERS:  RequestedDebugLevel - Requested debug print level
242 *              LineNumber          - Caller's line number
243 *              FunctionName        - Caller's procedure name
244 *              ModuleName          - Caller's module name
245 *              ComponentId         - Caller's component ID
246 *              Format              - Printf format field
247 *              ...                 - Optional printf arguments
248 *
249 * RETURN:      None
250 *
251 * DESCRIPTION: Print message with no headers. Has same interface as
252 *              DebugPrint so that the same macros can be used.
253 *
254 ******************************************************************************/
255
256void  ACPI_INTERNAL_VAR_XFACE
257AcpiDebugPrintRaw (
258    UINT32                  RequestedDebugLevel,
259    UINT32                  LineNumber,
260    const char              *FunctionName,
261    const char              *ModuleName,
262    UINT32                  ComponentId,
263    const char              *Format,
264    ...)
265{
266    va_list                 args;
267
268
269    /* Check if debug output enabled */
270
271    if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
272    {
273        return;
274    }
275
276    va_start (args, Format);
277    AcpiOsVprintf (Format, args);
278    va_end (args);
279}
280
281ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
282
283
284/*******************************************************************************
285 *
286 * FUNCTION:    AcpiUtTrace
287 *
288 * PARAMETERS:  LineNumber          - Caller's line number
289 *              FunctionName        - Caller's procedure name
290 *              ModuleName          - Caller's module name
291 *              ComponentId         - Caller's component ID
292 *
293 * RETURN:      None
294 *
295 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
296 *              set in DebugLevel
297 *
298 ******************************************************************************/
299
300void
301AcpiUtTrace (
302    UINT32                  LineNumber,
303    const char              *FunctionName,
304    const char              *ModuleName,
305    UINT32                  ComponentId)
306{
307
308    AcpiGbl_NestingLevel++;
309    AcpiUtTrackStackPtr ();
310
311    /* Check if enabled up-front for performance */
312
313    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
314    {
315        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
316            LineNumber, FunctionName, ModuleName, ComponentId,
317            "%s\n", AcpiGbl_FnEntryStr);
318    }
319}
320
321ACPI_EXPORT_SYMBOL (AcpiUtTrace)
322
323
324/*******************************************************************************
325 *
326 * FUNCTION:    AcpiUtTracePtr
327 *
328 * PARAMETERS:  LineNumber          - Caller's line number
329 *              FunctionName        - Caller's procedure name
330 *              ModuleName          - Caller's module name
331 *              ComponentId         - Caller's component ID
332 *              Pointer             - Pointer to display
333 *
334 * RETURN:      None
335 *
336 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
337 *              set in DebugLevel
338 *
339 ******************************************************************************/
340
341void
342AcpiUtTracePtr (
343    UINT32                  LineNumber,
344    const char              *FunctionName,
345    const char              *ModuleName,
346    UINT32                  ComponentId,
347    void                    *Pointer)
348{
349
350    AcpiGbl_NestingLevel++;
351    AcpiUtTrackStackPtr ();
352
353    /* Check if enabled up-front for performance */
354
355    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
356    {
357        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
358            LineNumber, FunctionName, ModuleName, ComponentId,
359            "%s %p\n", AcpiGbl_FnEntryStr, Pointer);
360    }
361}
362
363
364/*******************************************************************************
365 *
366 * FUNCTION:    AcpiUtTraceStr
367 *
368 * PARAMETERS:  LineNumber          - Caller's line number
369 *              FunctionName        - Caller's procedure name
370 *              ModuleName          - Caller's module name
371 *              ComponentId         - Caller's component ID
372 *              String              - Additional string to display
373 *
374 * RETURN:      None
375 *
376 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
377 *              set in DebugLevel
378 *
379 ******************************************************************************/
380
381void
382AcpiUtTraceStr (
383    UINT32                  LineNumber,
384    const char              *FunctionName,
385    const char              *ModuleName,
386    UINT32                  ComponentId,
387    char                    *String)
388{
389
390    AcpiGbl_NestingLevel++;
391    AcpiUtTrackStackPtr ();
392
393    /* Check if enabled up-front for performance */
394
395    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
396    {
397        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
398            LineNumber, FunctionName, ModuleName, ComponentId,
399            "%s %s\n", AcpiGbl_FnEntryStr, String);
400    }
401}
402
403
404/*******************************************************************************
405 *
406 * FUNCTION:    AcpiUtTraceU32
407 *
408 * PARAMETERS:  LineNumber          - Caller's line number
409 *              FunctionName        - Caller's procedure name
410 *              ModuleName          - Caller's module name
411 *              ComponentId         - Caller's component ID
412 *              Integer             - Integer to display
413 *
414 * RETURN:      None
415 *
416 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
417 *              set in DebugLevel
418 *
419 ******************************************************************************/
420
421void
422AcpiUtTraceU32 (
423    UINT32                  LineNumber,
424    const char              *FunctionName,
425    const char              *ModuleName,
426    UINT32                  ComponentId,
427    UINT32                  Integer)
428{
429
430    AcpiGbl_NestingLevel++;
431    AcpiUtTrackStackPtr ();
432
433    /* Check if enabled up-front for performance */
434
435    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
436    {
437        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
438            LineNumber, FunctionName, ModuleName, ComponentId,
439            "%s %08X\n", AcpiGbl_FnEntryStr, Integer);
440    }
441}
442
443
444/*******************************************************************************
445 *
446 * FUNCTION:    AcpiUtExit
447 *
448 * PARAMETERS:  LineNumber          - Caller's line number
449 *              FunctionName        - Caller's procedure name
450 *              ModuleName          - Caller's module name
451 *              ComponentId         - Caller's component ID
452 *
453 * RETURN:      None
454 *
455 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
456 *              set in DebugLevel
457 *
458 ******************************************************************************/
459
460void
461AcpiUtExit (
462    UINT32                  LineNumber,
463    const char              *FunctionName,
464    const char              *ModuleName,
465    UINT32                  ComponentId)
466{
467
468    /* Check if enabled up-front for performance */
469
470    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
471    {
472        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
473            LineNumber, FunctionName, ModuleName, ComponentId,
474            "%s\n", AcpiGbl_FnExitStr);
475    }
476
477    AcpiGbl_NestingLevel--;
478}
479
480ACPI_EXPORT_SYMBOL (AcpiUtExit)
481
482
483/*******************************************************************************
484 *
485 * FUNCTION:    AcpiUtStatusExit
486 *
487 * PARAMETERS:  LineNumber          - Caller's line number
488 *              FunctionName        - Caller's procedure name
489 *              ModuleName          - Caller's module name
490 *              ComponentId         - Caller's component ID
491 *              Status              - Exit status code
492 *
493 * RETURN:      None
494 *
495 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
496 *              set in DebugLevel. Prints exit status also.
497 *
498 ******************************************************************************/
499
500void
501AcpiUtStatusExit (
502    UINT32                  LineNumber,
503    const char              *FunctionName,
504    const char              *ModuleName,
505    UINT32                  ComponentId,
506    ACPI_STATUS             Status)
507{
508
509    /* Check if enabled up-front for performance */
510
511    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
512    {
513        if (ACPI_SUCCESS (Status))
514        {
515            AcpiDebugPrint (ACPI_LV_FUNCTIONS,
516                LineNumber, FunctionName, ModuleName, ComponentId,
517                "%s %s\n", AcpiGbl_FnExitStr,
518                AcpiFormatException (Status));
519        }
520        else
521        {
522            AcpiDebugPrint (ACPI_LV_FUNCTIONS,
523                LineNumber, FunctionName, ModuleName, ComponentId,
524                "%s ****Exception****: %s\n", AcpiGbl_FnExitStr,
525                AcpiFormatException (Status));
526        }
527    }
528
529    AcpiGbl_NestingLevel--;
530}
531
532ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
533
534
535/*******************************************************************************
536 *
537 * FUNCTION:    AcpiUtValueExit
538 *
539 * PARAMETERS:  LineNumber          - Caller's line number
540 *              FunctionName        - Caller's procedure name
541 *              ModuleName          - Caller's module name
542 *              ComponentId         - Caller's component ID
543 *              Value               - Value to be printed with exit msg
544 *
545 * RETURN:      None
546 *
547 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
548 *              set in DebugLevel. Prints exit value also.
549 *
550 ******************************************************************************/
551
552void
553AcpiUtValueExit (
554    UINT32                  LineNumber,
555    const char              *FunctionName,
556    const char              *ModuleName,
557    UINT32                  ComponentId,
558    UINT64                  Value)
559{
560
561    /* Check if enabled up-front for performance */
562
563    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
564    {
565        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
566            LineNumber, FunctionName, ModuleName, ComponentId,
567            "%s %8.8X%8.8X\n", AcpiGbl_FnExitStr,
568            ACPI_FORMAT_UINT64 (Value));
569    }
570
571    AcpiGbl_NestingLevel--;
572}
573
574ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
575
576
577/*******************************************************************************
578 *
579 * FUNCTION:    AcpiUtPtrExit
580 *
581 * PARAMETERS:  LineNumber          - Caller's line number
582 *              FunctionName        - Caller's procedure name
583 *              ModuleName          - Caller's module name
584 *              ComponentId         - Caller's component ID
585 *              Ptr                 - Pointer to display
586 *
587 * RETURN:      None
588 *
589 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
590 *              set in DebugLevel. Prints exit value also.
591 *
592 ******************************************************************************/
593
594void
595AcpiUtPtrExit (
596    UINT32                  LineNumber,
597    const char              *FunctionName,
598    const char              *ModuleName,
599    UINT32                  ComponentId,
600    UINT8                   *Ptr)
601{
602
603    /* Check if enabled up-front for performance */
604
605    if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
606    {
607        AcpiDebugPrint (ACPI_LV_FUNCTIONS,
608            LineNumber, FunctionName, ModuleName, ComponentId,
609            "%s %p\n", AcpiGbl_FnExitStr, Ptr);
610    }
611
612    AcpiGbl_NestingLevel--;
613}
614
615#endif
616