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