drivers/acpi/acpica/utdebug.c

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