arch/all-pc/acpica/source/components/utilities/utdebug.c

   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 #define EXPORT_ACPI_INTERFACES
  46
  47 #include "acpi.h"
  48 #include "accommon.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_PrevThreadId = (ACPI_THREAD_ID) 0xFFFFFFFF;
  57 static char                 *AcpiGbl_FnEntryStr = "----Entry";
  58 static char                 *AcpiGbl_FnExitStr  = "----Exit-";
  59
  60 /* Local prototypes */
  61
  62 static const char *
  63 AcpiUtTrimFunctionName (
  64     const char              *FunctionName);
  65
  66
  67 /*******************************************************************************
  68  *
  69  * FUNCTION:    AcpiUtInitStackPtrTrace
  70  *
  71  * PARAMETERS:  None
  72  *
  73  * RETURN:      None
  74  *
  75  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
  76  *
  77  ******************************************************************************/
  78
  79 void
  80 AcpiUtInitStackPtrTrace (
  81     void)
  82 {
  83     ACPI_SIZE               CurrentSp;
  84
  85
  86     AcpiGbl_EntryStackPointer = &CurrentSp;
  87 }
  88
  89
  90 /*******************************************************************************
  91  *
  92  * FUNCTION:    AcpiUtTrackStackPtr
  93  *
  94  * PARAMETERS:  None
  95  *
  96  * RETURN:      None
  97  *
  98  * DESCRIPTION: Save the current CPU stack pointer
  99  *
 100  ******************************************************************************/
 101
 102 void
 103 AcpiUtTrackStackPtr (
 104     void)
 105 {
 106     ACPI_SIZE               CurrentSp;
 107
 108
 109     if (&CurrentSp < AcpiGbl_LowestStackPointer)
 110     {
 111         AcpiGbl_LowestStackPointer = &CurrentSp;
 112     }
 113
 114     if (AcpiGbl_NestingLevel > AcpiGbl_DeepestNesting)
 115     {
 116         AcpiGbl_DeepestNesting = AcpiGbl_NestingLevel;
 117     }
 118 }
 119
 120
 121 /*******************************************************************************
 122  *
 123  * FUNCTION:    AcpiUtTrimFunctionName
 124  *
 125  * PARAMETERS:  FunctionName        - Ascii string containing a procedure name
 126  *
 127  * RETURN:      Updated pointer to the function name
 128  *
 129  * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
 130  *              This allows compiler macros such as __FUNCTION__ to be used
 131  *              with no change to the debug output.
 132  *
 133  ******************************************************************************/
 134
 135 static const char *
 136 AcpiUtTrimFunctionName (
 137     const char              *FunctionName)
 138 {
 139
 140     /* All Function names are longer than 4 chars, check is safe */
 141
 142     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_MIXED)
 143     {
 144         /* This is the case where the original source has not been modified */
 145
 146         return (FunctionName + 4);
 147     }
 148
 149     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_LOWER)
 150     {
 151         /* This is the case where the source has been 'linuxized' */
 152
 153         return (FunctionName + 5);
 154     }
 155
 156     return (FunctionName);
 157 }
 158
 159
 160 /*******************************************************************************
 161  *
 162  * FUNCTION:    AcpiDebugPrint
 163  *
 164  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
 165  *              LineNumber          - Caller's line number (for error output)
 166  *              FunctionName        - Caller's procedure name
 167  *              ModuleName          - Caller's module name
 168  *              ComponentId         - Caller's component ID
 169  *              Format              - Printf format field
 170  *              ...                 - Optional printf arguments
 171  *
 172  * RETURN:      None
 173  *
 174  * DESCRIPTION: Print error message with prefix consisting of the module name,
 175  *              line number, and component ID.
 176  *
 177  ******************************************************************************/
 178
 179 void  ACPI_INTERNAL_VAR_XFACE
 180 AcpiDebugPrint (
 181     UINT32                  RequestedDebugLevel,
 182     UINT32                  LineNumber,
 183     const char              *FunctionName,
 184     const char              *ModuleName,
 185     UINT32                  ComponentId,
 186     const char              *Format,
 187     ...)
 188 {
 189     ACPI_THREAD_ID          ThreadId;
 190     va_list                 args;
 191
 192
 193     /* Check if debug output enabled */
 194
 195     if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
 196     {
 197         return;
 198     }
 199
 200     /*
 201      * Thread tracking and context switch notification
 202      */
 203     ThreadId = AcpiOsGetThreadId ();
 204     if (ThreadId != AcpiGbl_PrevThreadId)
 205     {
 206         if (ACPI_LV_THREADS & AcpiDbgLevel)
 207         {
 208             AcpiOsPrintf (
 209                 "\n**** Context Switch from TID %u to TID %u ****\n\n",
 210                 (UINT32) AcpiGbl_PrevThreadId, (UINT32) ThreadId);
 211         }
 212
 213         AcpiGbl_PrevThreadId = ThreadId;
 214         AcpiGbl_NestingLevel = 0;
 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 ("%9s-%04ld ", ModuleName, LineNumber);
 222
 223 #ifdef ACPI_EXEC_APP
 224     /*
 225      * For AcpiExec only, emit the thread ID and nesting level.
 226      * Note: nesting level is really only useful during a single-thread
 227      * execution. Otherwise, multiple threads will keep resetting the
 228      * level.
 229      */
 230     if (ACPI_LV_THREADS & AcpiDbgLevel)
 231     {
 232         AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
 233     }
 234
 235     AcpiOsPrintf ("[%02ld] ", AcpiGbl_NestingLevel);
 236 #endif
 237
 238     AcpiOsPrintf ("%-22.22s: ", AcpiUtTrimFunctionName (FunctionName));
 239
 240     va_start (args, Format);
 241     AcpiOsVprintf (Format, args);
 242     va_end (args);
 243 }
 244
 245 ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
 246
 247
 248 /*******************************************************************************
 249  *
 250  * FUNCTION:    AcpiDebugPrintRaw
 251  *
 252  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
 253  *              LineNumber          - Caller's line number
 254  *              FunctionName        - Caller's procedure name
 255  *              ModuleName          - Caller's module name
 256  *              ComponentId         - Caller's component ID
 257  *              Format              - Printf format field
 258  *              ...                 - Optional printf arguments
 259  *
 260  * RETURN:      None
 261  *
 262  * DESCRIPTION: Print message with no headers. Has same interface as
 263  *              DebugPrint so that the same macros can be used.
 264  *
 265  ******************************************************************************/
 266
 267 void  ACPI_INTERNAL_VAR_XFACE
 268 AcpiDebugPrintRaw (
 269     UINT32                  RequestedDebugLevel,
 270     UINT32                  LineNumber,
 271     const char              *FunctionName,
 272     const char              *ModuleName,
 273     UINT32                  ComponentId,
 274     const char              *Format,
 275     ...)
 276 {
 277     va_list                 args;
 278
 279
 280     /* Check if debug output enabled */
 281
 282     if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
 283     {
 284         return;
 285     }
 286
 287     va_start (args, Format);
 288     AcpiOsVprintf (Format, args);
 289     va_end (args);
 290 }
 291
 292 ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
 293
 294
 295 /*******************************************************************************
 296  *
 297  * FUNCTION:    AcpiUtTrace
 298  *
 299  * PARAMETERS:  LineNumber          - Caller's line number
 300  *              FunctionName        - Caller's procedure name
 301  *              ModuleName          - Caller's module name
 302  *              ComponentId         - Caller's component ID
 303  *
 304  * RETURN:      None
 305  *
 306  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 307  *              set in DebugLevel
 308  *
 309  ******************************************************************************/
 310
 311 void
 312 AcpiUtTrace (
 313     UINT32                  LineNumber,
 314     const char              *FunctionName,
 315     const char              *ModuleName,
 316     UINT32                  ComponentId)
 317 {
 318
 319     AcpiGbl_NestingLevel++;
 320     AcpiUtTrackStackPtr ();
 321
 322     /* Check if enabled up-front for performance */
 323
 324     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 325     {
 326         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 327             LineNumber, FunctionName, ModuleName, ComponentId,
 328             "%s\n", AcpiGbl_FnEntryStr);
 329     }
 330 }
 331
 332 ACPI_EXPORT_SYMBOL (AcpiUtTrace)
 333
 334
 335 /*******************************************************************************
 336  *
 337  * FUNCTION:    AcpiUtTracePtr
 338  *
 339  * PARAMETERS:  LineNumber          - Caller's line number
 340  *              FunctionName        - Caller's procedure name
 341  *              ModuleName          - Caller's module name
 342  *              ComponentId         - Caller's component ID
 343  *              Pointer             - Pointer to display
 344  *
 345  * RETURN:      None
 346  *
 347  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 348  *              set in DebugLevel
 349  *
 350  ******************************************************************************/
 351
 352 void
 353 AcpiUtTracePtr (
 354     UINT32                  LineNumber,
 355     const char              *FunctionName,
 356     const char              *ModuleName,
 357     UINT32                  ComponentId,
 358     void                    *Pointer)
 359 {
 360
 361     AcpiGbl_NestingLevel++;
 362     AcpiUtTrackStackPtr ();
 363
 364     /* Check if enabled up-front for performance */
 365
 366     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 367     {
 368         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 369             LineNumber, FunctionName, ModuleName, ComponentId,
 370             "%s %p\n", AcpiGbl_FnEntryStr, Pointer);
 371     }
 372 }
 373
 374
 375 /*******************************************************************************
 376  *
 377  * FUNCTION:    AcpiUtTraceStr
 378  *
 379  * PARAMETERS:  LineNumber          - Caller's line number
 380  *              FunctionName        - Caller's procedure name
 381  *              ModuleName          - Caller's module name
 382  *              ComponentId         - Caller's component ID
 383  *              String              - Additional string to display
 384  *
 385  * RETURN:      None
 386  *
 387  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 388  *              set in DebugLevel
 389  *
 390  ******************************************************************************/
 391
 392 void
 393 AcpiUtTraceStr (
 394     UINT32                  LineNumber,
 395     const char              *FunctionName,
 396     const char              *ModuleName,
 397     UINT32                  ComponentId,
 398     char                    *String)
 399 {
 400
 401     AcpiGbl_NestingLevel++;
 402     AcpiUtTrackStackPtr ();
 403
 404     /* Check if enabled up-front for performance */
 405
 406     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 407     {
 408         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 409             LineNumber, FunctionName, ModuleName, ComponentId,
 410             "%s %s\n", AcpiGbl_FnEntryStr, String);
 411     }
 412 }
 413
 414
 415 /*******************************************************************************
 416  *
 417  * FUNCTION:    AcpiUtTraceU32
 418  *
 419  * PARAMETERS:  LineNumber          - Caller's line number
 420  *              FunctionName        - Caller's procedure name
 421  *              ModuleName          - Caller's module name
 422  *              ComponentId         - Caller's component ID
 423  *              Integer             - Integer to display
 424  *
 425  * RETURN:      None
 426  *
 427  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 428  *              set in DebugLevel
 429  *
 430  ******************************************************************************/
 431
 432 void
 433 AcpiUtTraceU32 (
 434     UINT32                  LineNumber,
 435     const char              *FunctionName,
 436     const char              *ModuleName,
 437     UINT32                  ComponentId,
 438     UINT32                  Integer)
 439 {
 440
 441     AcpiGbl_NestingLevel++;
 442     AcpiUtTrackStackPtr ();
 443
 444     /* Check if enabled up-front for performance */
 445
 446     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 447     {
 448         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 449             LineNumber, FunctionName, ModuleName, ComponentId,
 450             "%s %08X\n", AcpiGbl_FnEntryStr, Integer);
 451     }
 452 }
 453
 454
 455 /*******************************************************************************
 456  *
 457  * FUNCTION:    AcpiUtExit
 458  *
 459  * PARAMETERS:  LineNumber          - Caller's line number
 460  *              FunctionName        - Caller's procedure name
 461  *              ModuleName          - Caller's module name
 462  *              ComponentId         - Caller's component ID
 463  *
 464  * RETURN:      None
 465  *
 466  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 467  *              set in DebugLevel
 468  *
 469  ******************************************************************************/
 470
 471 void
 472 AcpiUtExit (
 473     UINT32                  LineNumber,
 474     const char              *FunctionName,
 475     const char              *ModuleName,
 476     UINT32                  ComponentId)
 477 {
 478
 479     /* Check if enabled up-front for performance */
 480
 481     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 482     {
 483         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 484             LineNumber, FunctionName, ModuleName, ComponentId,
 485             "%s\n", AcpiGbl_FnExitStr);
 486     }
 487
 488     if (AcpiGbl_NestingLevel)
 489     {
 490         AcpiGbl_NestingLevel--;
 491     }
 492 }
 493
 494 ACPI_EXPORT_SYMBOL (AcpiUtExit)
 495
 496
 497 /*******************************************************************************
 498  *
 499  * FUNCTION:    AcpiUtStatusExit
 500  *
 501  * PARAMETERS:  LineNumber          - Caller's line number
 502  *              FunctionName        - Caller's procedure name
 503  *              ModuleName          - Caller's module name
 504  *              ComponentId         - Caller's component ID
 505  *              Status              - Exit status code
 506  *
 507  * RETURN:      None
 508  *
 509  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 510  *              set in DebugLevel. Prints exit status also.
 511  *
 512  ******************************************************************************/
 513
 514 void
 515 AcpiUtStatusExit (
 516     UINT32                  LineNumber,
 517     const char              *FunctionName,
 518     const char              *ModuleName,
 519     UINT32                  ComponentId,
 520     ACPI_STATUS             Status)
 521 {
 522
 523     /* Check if enabled up-front for performance */
 524
 525     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 526     {
 527         if (ACPI_SUCCESS (Status))
 528         {
 529             AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 530                 LineNumber, FunctionName, ModuleName, ComponentId,
 531                 "%s %s\n", AcpiGbl_FnExitStr,
 532                 AcpiFormatException (Status));
 533         }
 534         else
 535         {
 536             AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 537                 LineNumber, FunctionName, ModuleName, ComponentId,
 538                 "%s ****Exception****: %s\n", AcpiGbl_FnExitStr,
 539                 AcpiFormatException (Status));
 540         }
 541     }
 542
 543     if (AcpiGbl_NestingLevel)
 544     {
 545         AcpiGbl_NestingLevel--;
 546     }
 547 }
 548
 549 ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
 550
 551
 552 /*******************************************************************************
 553  *
 554  * FUNCTION:    AcpiUtValueExit
 555  *
 556  * PARAMETERS:  LineNumber          - Caller's line number
 557  *              FunctionName        - Caller's procedure name
 558  *              ModuleName          - Caller's module name
 559  *              ComponentId         - Caller's component ID
 560  *              Value               - Value to be printed with exit msg
 561  *
 562  * RETURN:      None
 563  *
 564  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 565  *              set in DebugLevel. Prints exit value also.
 566  *
 567  ******************************************************************************/
 568
 569 void
 570 AcpiUtValueExit (
 571     UINT32                  LineNumber,
 572     const char              *FunctionName,
 573     const char              *ModuleName,
 574     UINT32                  ComponentId,
 575     UINT64                  Value)
 576 {
 577
 578     /* Check if enabled up-front for performance */
 579
 580     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 581     {
 582         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 583             LineNumber, FunctionName, ModuleName, ComponentId,
 584             "%s %8.8X%8.8X\n", AcpiGbl_FnExitStr,
 585             ACPI_FORMAT_UINT64 (Value));
 586     }
 587
 588     if (AcpiGbl_NestingLevel)
 589     {
 590         AcpiGbl_NestingLevel--;
 591     }
 592 }
 593
 594 ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
 595
 596
 597 /*******************************************************************************
 598  *
 599  * FUNCTION:    AcpiUtPtrExit
 600  *
 601  * PARAMETERS:  LineNumber          - Caller's line number
 602  *              FunctionName        - Caller's procedure name
 603  *              ModuleName          - Caller's module name
 604  *              ComponentId         - Caller's component ID
 605  *              Ptr                 - Pointer to display
 606  *
 607  * RETURN:      None
 608  *
 609  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 610  *              set in DebugLevel. Prints exit value also.
 611  *
 612  ******************************************************************************/
 613
 614 void
 615 AcpiUtPtrExit (
 616     UINT32                  LineNumber,
 617     const char              *FunctionName,
 618     const char              *ModuleName,
 619     UINT32                  ComponentId,
 620     UINT8                   *Ptr)
 621 {
 622
 623     /* Check if enabled up-front for performance */
 624
 625     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 626     {
 627         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 628             LineNumber, FunctionName, ModuleName, ComponentId,
 629             "%s %p\n", AcpiGbl_FnExitStr, Ptr);
 630     }
 631
 632     if (AcpiGbl_NestingLevel)
 633     {
 634         AcpiGbl_NestingLevel--;
 635     }
 636 }
 637
 638 #endif