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 = ¤t_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 (¤t_sp < acpi_gbl_lowest_stack_pointer) { 94 acpi_gbl_lowest_stack_pointer = ¤t_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_trace_point 566 * 567 * PARAMETERS: type - Trace event type 568 * begin - TRUE if before execution 569 * aml - Executed AML address 570 * pathname - Object path 571 * pointer - Pointer to the related object 572 * 573 * RETURN: None 574 * 575 * DESCRIPTION: Interpreter execution trace. 576 * 577 ******************************************************************************/ 578 579 void 580 acpi_trace_point(acpi_trace_event_type type, u8 begin, u8 *aml, char *pathname) 581 { 582 583 ACPI_FUNCTION_ENTRY(); 584 585 acpi_ex_trace_point(type, begin, aml, pathname); 586 587 #ifdef ACPI_USE_SYSTEM_TRACER 588 acpi_os_trace_point(type, begin, aml, pathname); 589 #endif 590 } 591 592 ACPI_EXPORT_SYMBOL(acpi_trace_point) 593 #endif 594 #ifdef ACPI_APPLICATION 595 /******************************************************************************* 596 * 597 * FUNCTION: acpi_log_error 598 * 599 * PARAMETERS: format - Printf format field 600 * ... - Optional printf arguments 601 * 602 * RETURN: None 603 * 604 * DESCRIPTION: Print error message to the console, used by applications. 605 * 606 ******************************************************************************/ 607 void ACPI_INTERNAL_VAR_XFACE acpi_log_error(const char *format, ...) 608 { 609 va_list args; 610 611 va_start(args, format); 612 (void)acpi_ut_file_vprintf(ACPI_FILE_ERR, format, args); 613 va_end(args); 614 } 615 616 ACPI_EXPORT_SYMBOL(acpi_log_error) 617 #endif 618