1/****************************************************************************** 2 * 3 * Module Name: utdebug - Debug print routines 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2011, 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 <acpi/acpi.h> 45#include "accommon.h" 46 47#define _COMPONENT ACPI_UTILITIES 48ACPI_MODULE_NAME("utdebug") 49#ifdef ACPI_DEBUG_OUTPUT 50static acpi_thread_id acpi_gbl_prev_thread_id; 51static char *acpi_gbl_fn_entry_str = "----Entry"; 52static char *acpi_gbl_fn_exit_str = "----Exit-"; 53 54/* Local prototypes */ 55 56static const char *acpi_ut_trim_function_name(const char *function_name); 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 70void 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 89void 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 116static 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 157void ACPI_INTERNAL_VAR_XFACE 158acpi_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 /* 168 * Stay silent if the debug level or component ID is disabled 169 */ 170 if (!(requested_debug_level & acpi_dbg_level) || 171 !(component_id & acpi_dbg_layer)) { 172 return; 173 } 174 175 /* 176 * Thread tracking and context switch notification 177 */ 178 thread_id = acpi_os_get_thread_id(); 179 if (thread_id != acpi_gbl_prev_thread_id) { 180 if (ACPI_LV_THREADS & acpi_dbg_level) { 181 acpi_os_printf 182 ("\n**** Context Switch from TID %u to TID %u ****\n\n", 183 (u32)acpi_gbl_prev_thread_id, (u32)thread_id); 184 } 185 186 acpi_gbl_prev_thread_id = thread_id; 187 } 188 189 /* 190 * Display the module name, current line number, thread ID (if requested), 191 * current procedure nesting level, and the current procedure name 192 */ 193 acpi_os_printf("%8s-%04ld ", module_name, line_number); 194 195 if (ACPI_LV_THREADS & acpi_dbg_level) { 196 acpi_os_printf("[%u] ", (u32)thread_id); 197 } 198 199 acpi_os_printf("[%02ld] %-22.22s: ", 200 acpi_gbl_nesting_level, 201 acpi_ut_trim_function_name(function_name)); 202 203 va_start(args, format); 204 acpi_os_vprintf(format, args); 205 va_end(args); 206} 207 208ACPI_EXPORT_SYMBOL(acpi_debug_print) 209 210/******************************************************************************* 211 * 212 * FUNCTION: acpi_debug_print_raw 213 * 214 * PARAMETERS: requested_debug_level - Requested debug print level 215 * line_number - Caller's line number 216 * function_name - Caller's procedure name 217 * module_name - Caller's module name 218 * component_id - Caller's component ID 219 * Format - Printf format field 220 * ... - Optional printf arguments 221 * 222 * RETURN: None 223 * 224 * DESCRIPTION: Print message with no headers. Has same interface as 225 * debug_print so that the same macros can be used. 226 * 227 ******************************************************************************/ 228void ACPI_INTERNAL_VAR_XFACE 229acpi_debug_print_raw(u32 requested_debug_level, 230 u32 line_number, 231 const char *function_name, 232 const char *module_name, 233 u32 component_id, const char *format, ...) 234{ 235 va_list args; 236 237 if (!(requested_debug_level & acpi_dbg_level) || 238 !(component_id & acpi_dbg_layer)) { 239 return; 240 } 241 242 va_start(args, format); 243 acpi_os_vprintf(format, args); 244 va_end(args); 245} 246 247ACPI_EXPORT_SYMBOL(acpi_debug_print_raw) 248 249/******************************************************************************* 250 * 251 * FUNCTION: acpi_ut_trace 252 * 253 * PARAMETERS: line_number - Caller's line number 254 * function_name - Caller's procedure name 255 * module_name - Caller's module name 256 * component_id - Caller's component ID 257 * 258 * RETURN: None 259 * 260 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 261 * set in debug_level 262 * 263 ******************************************************************************/ 264void 265acpi_ut_trace(u32 line_number, 266 const char *function_name, 267 const char *module_name, u32 component_id) 268{ 269 270 acpi_gbl_nesting_level++; 271 acpi_ut_track_stack_ptr(); 272 273 acpi_debug_print(ACPI_LV_FUNCTIONS, 274 line_number, function_name, module_name, component_id, 275 "%s\n", acpi_gbl_fn_entry_str); 276} 277 278ACPI_EXPORT_SYMBOL(acpi_ut_trace) 279 280/******************************************************************************* 281 * 282 * FUNCTION: acpi_ut_trace_ptr 283 * 284 * PARAMETERS: line_number - Caller's line number 285 * function_name - Caller's procedure name 286 * module_name - Caller's module name 287 * component_id - Caller's component ID 288 * Pointer - Pointer to display 289 * 290 * RETURN: None 291 * 292 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 293 * set in debug_level 294 * 295 ******************************************************************************/ 296void 297acpi_ut_trace_ptr(u32 line_number, 298 const char *function_name, 299 const char *module_name, u32 component_id, void *pointer) 300{ 301 acpi_gbl_nesting_level++; 302 acpi_ut_track_stack_ptr(); 303 304 acpi_debug_print(ACPI_LV_FUNCTIONS, 305 line_number, function_name, module_name, component_id, 306 "%s %p\n", acpi_gbl_fn_entry_str, pointer); 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 326void 327acpi_ut_trace_str(u32 line_number, 328 const char *function_name, 329 const char *module_name, u32 component_id, char *string) 330{ 331 332 acpi_gbl_nesting_level++; 333 acpi_ut_track_stack_ptr(); 334 335 acpi_debug_print(ACPI_LV_FUNCTIONS, 336 line_number, function_name, module_name, component_id, 337 "%s %s\n", acpi_gbl_fn_entry_str, string); 338} 339 340/******************************************************************************* 341 * 342 * FUNCTION: acpi_ut_trace_u32 343 * 344 * PARAMETERS: line_number - Caller's line number 345 * function_name - Caller's procedure name 346 * module_name - Caller's module name 347 * component_id - Caller's component ID 348 * Integer - Integer to display 349 * 350 * RETURN: None 351 * 352 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 353 * set in debug_level 354 * 355 ******************************************************************************/ 356 357void 358acpi_ut_trace_u32(u32 line_number, 359 const char *function_name, 360 const char *module_name, u32 component_id, u32 integer) 361{ 362 363 acpi_gbl_nesting_level++; 364 acpi_ut_track_stack_ptr(); 365 366 acpi_debug_print(ACPI_LV_FUNCTIONS, 367 line_number, function_name, module_name, component_id, 368 "%s %08X\n", acpi_gbl_fn_entry_str, integer); 369} 370 371/******************************************************************************* 372 * 373 * FUNCTION: acpi_ut_exit 374 * 375 * PARAMETERS: line_number - Caller's line number 376 * function_name - Caller's procedure name 377 * module_name - Caller's module name 378 * component_id - Caller's component ID 379 * 380 * RETURN: None 381 * 382 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is 383 * set in debug_level 384 * 385 ******************************************************************************/ 386 387void 388acpi_ut_exit(u32 line_number, 389 const char *function_name, 390 const char *module_name, u32 component_id) 391{ 392 393 acpi_debug_print(ACPI_LV_FUNCTIONS, 394 line_number, function_name, module_name, component_id, 395 "%s\n", acpi_gbl_fn_exit_str); 396 397 acpi_gbl_nesting_level--; 398} 399 400ACPI_EXPORT_SYMBOL(acpi_ut_exit) 401 402/******************************************************************************* 403 * 404 * FUNCTION: acpi_ut_status_exit 405 * 406 * PARAMETERS: line_number - Caller's line number 407 * function_name - Caller's procedure name 408 * module_name - Caller's module name 409 * component_id - Caller's component ID 410 * Status - Exit status code 411 * 412 * RETURN: None 413 * 414 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is 415 * set in debug_level. Prints exit status also. 416 * 417 ******************************************************************************/ 418void 419acpi_ut_status_exit(u32 line_number, 420 const char *function_name, 421 const char *module_name, 422 u32 component_id, acpi_status status) 423{ 424 425 if (ACPI_SUCCESS(status)) { 426 acpi_debug_print(ACPI_LV_FUNCTIONS, 427 line_number, function_name, module_name, 428 component_id, "%s %s\n", acpi_gbl_fn_exit_str, 429 acpi_format_exception(status)); 430 } else { 431 acpi_debug_print(ACPI_LV_FUNCTIONS, 432 line_number, function_name, module_name, 433 component_id, "%s ****Exception****: %s\n", 434 acpi_gbl_fn_exit_str, 435 acpi_format_exception(status)); 436 } 437 438 acpi_gbl_nesting_level--; 439} 440 441ACPI_EXPORT_SYMBOL(acpi_ut_status_exit) 442 443/******************************************************************************* 444 * 445 * FUNCTION: acpi_ut_value_exit 446 * 447 * PARAMETERS: line_number - Caller's line number 448 * function_name - Caller's procedure name 449 * module_name - Caller's module name 450 * component_id - Caller's component ID 451 * Value - Value to be printed with exit msg 452 * 453 * RETURN: None 454 * 455 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is 456 * set in debug_level. Prints exit value also. 457 * 458 ******************************************************************************/ 459void 460acpi_ut_value_exit(u32 line_number, 461 const char *function_name, 462 const char *module_name, u32 component_id, u64 value) 463{ 464 465 acpi_debug_print(ACPI_LV_FUNCTIONS, 466 line_number, function_name, module_name, component_id, 467 "%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str, 468 ACPI_FORMAT_UINT64(value)); 469 470 acpi_gbl_nesting_level--; 471} 472 473ACPI_EXPORT_SYMBOL(acpi_ut_value_exit) 474 475/******************************************************************************* 476 * 477 * FUNCTION: acpi_ut_ptr_exit 478 * 479 * PARAMETERS: line_number - Caller's line number 480 * function_name - Caller's procedure name 481 * module_name - Caller's module name 482 * component_id - Caller's component ID 483 * Ptr - Pointer to display 484 * 485 * RETURN: None 486 * 487 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is 488 * set in debug_level. Prints exit value also. 489 * 490 ******************************************************************************/ 491void 492acpi_ut_ptr_exit(u32 line_number, 493 const char *function_name, 494 const char *module_name, u32 component_id, u8 *ptr) 495{ 496 497 acpi_debug_print(ACPI_LV_FUNCTIONS, 498 line_number, function_name, module_name, component_id, 499 "%s %p\n", acpi_gbl_fn_exit_str, ptr); 500 501 acpi_gbl_nesting_level--; 502} 503 504#endif 505 506/******************************************************************************* 507 * 508 * FUNCTION: acpi_ut_dump_buffer 509 * 510 * PARAMETERS: Buffer - Buffer to dump 511 * Count - Amount to dump, in bytes 512 * Display - BYTE, WORD, DWORD, or QWORD display 513 * component_iD - Caller's component ID 514 * 515 * RETURN: None 516 * 517 * DESCRIPTION: Generic dump buffer in both hex and ascii. 518 * 519 ******************************************************************************/ 520 521void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display) 522{ 523 u32 i = 0; 524 u32 j; 525 u32 temp32; 526 u8 buf_char; 527 528 if (!buffer) { 529 acpi_os_printf("Null Buffer Pointer in DumpBuffer!\n"); 530 return; 531 } 532 533 if ((count < 4) || (count & 0x01)) { 534 display = DB_BYTE_DISPLAY; 535 } 536 537 /* Nasty little dump buffer routine! */ 538 539 while (i < count) { 540 541 /* Print current offset */ 542 543 acpi_os_printf("%6.4X: ", i); 544 545 /* Print 16 hex chars */ 546 547 for (j = 0; j < 16;) { 548 if (i + j >= count) { 549 550 /* Dump fill spaces */ 551 552 acpi_os_printf("%*s", ((display * 2) + 1), " "); 553 j += display; 554 continue; 555 } 556 557 switch (display) { 558 case DB_BYTE_DISPLAY: 559 default: /* Default is BYTE display */ 560 561 acpi_os_printf("%02X ", 562 buffer[(acpi_size) i + j]); 563 break; 564 565 case DB_WORD_DISPLAY: 566 567 ACPI_MOVE_16_TO_32(&temp32, 568 &buffer[(acpi_size) i + j]); 569 acpi_os_printf("%04X ", temp32); 570 break; 571 572 case DB_DWORD_DISPLAY: 573 574 ACPI_MOVE_32_TO_32(&temp32, 575 &buffer[(acpi_size) i + j]); 576 acpi_os_printf("%08X ", temp32); 577 break; 578 579 case DB_QWORD_DISPLAY: 580 581 ACPI_MOVE_32_TO_32(&temp32, 582 &buffer[(acpi_size) i + j]); 583 acpi_os_printf("%08X", temp32); 584 585 ACPI_MOVE_32_TO_32(&temp32, 586 &buffer[(acpi_size) i + j + 587 4]); 588 acpi_os_printf("%08X ", temp32); 589 break; 590 } 591 592 j += display; 593 } 594 595 /* 596 * Print the ASCII equivalent characters but watch out for the bad 597 * unprintable ones (printable chars are 0x20 through 0x7E) 598 */ 599 acpi_os_printf(" "); 600 for (j = 0; j < 16; j++) { 601 if (i + j >= count) { 602 acpi_os_printf("\n"); 603 return; 604 } 605 606 buf_char = buffer[(acpi_size) i + j]; 607 if (ACPI_IS_PRINT(buf_char)) { 608 acpi_os_printf("%c", buf_char); 609 } else { 610 acpi_os_printf("."); 611 } 612 } 613 614 /* Done with that line. */ 615 616 acpi_os_printf("\n"); 617 i += 16; 618 } 619 620 return; 621} 622 623/******************************************************************************* 624 * 625 * FUNCTION: acpi_ut_dump_buffer 626 * 627 * PARAMETERS: Buffer - Buffer to dump 628 * Count - Amount to dump, in bytes 629 * Display - BYTE, WORD, DWORD, or QWORD display 630 * component_iD - Caller's component ID 631 * 632 * RETURN: None 633 * 634 * DESCRIPTION: Generic dump buffer in both hex and ascii. 635 * 636 ******************************************************************************/ 637 638void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id) 639{ 640 641 /* Only dump the buffer if tracing is enabled */ 642 643 if (!((ACPI_LV_TABLES & acpi_dbg_level) && 644 (component_id & acpi_dbg_layer))) { 645 return; 646 } 647 648 acpi_ut_dump_buffer2(buffer, count, display); 649} 650