drivers/acpi/acpica/utdebug.c

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