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