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