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