1 /****************************************************************************** 2 * 3 * Module Name: utdebug - Debug print/trace routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 49 #define _COMPONENT ACPI_UTILITIES 50 ACPI_MODULE_NAME("utdebug") 51 52 #ifdef ACPI_DEBUG_OUTPUT 53 static acpi_thread_id acpi_gbl_prev_thread_id = (acpi_thread_id) 0xFFFFFFFF; 54 static char *acpi_gbl_fn_entry_str = "----Entry"; 55 static char *acpi_gbl_fn_exit_str = "----Exit-"; 56 57 /* Local prototypes */ 58 59 static const char *acpi_ut_trim_function_name(const char *function_name); 60 61 /******************************************************************************* 62 * 63 * FUNCTION: acpi_ut_init_stack_ptr_trace 64 * 65 * PARAMETERS: None 66 * 67 * RETURN: None 68 * 69 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup 70 * 71 ******************************************************************************/ 72 73 void acpi_ut_init_stack_ptr_trace(void) 74 { 75 acpi_size current_sp; 76 77 acpi_gbl_entry_stack_pointer = ¤t_sp; 78 } 79 80 /******************************************************************************* 81 * 82 * FUNCTION: acpi_ut_track_stack_ptr 83 * 84 * PARAMETERS: None 85 * 86 * RETURN: None 87 * 88 * DESCRIPTION: Save the current CPU stack pointer 89 * 90 ******************************************************************************/ 91 92 void acpi_ut_track_stack_ptr(void) 93 { 94 acpi_size current_sp; 95 96 if (¤t_sp < acpi_gbl_lowest_stack_pointer) { 97 acpi_gbl_lowest_stack_pointer = ¤t_sp; 98 } 99 100 if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) { 101 acpi_gbl_deepest_nesting = acpi_gbl_nesting_level; 102 } 103 } 104 105 /******************************************************************************* 106 * 107 * FUNCTION: acpi_ut_trim_function_name 108 * 109 * PARAMETERS: function_name - Ascii string containing a procedure name 110 * 111 * RETURN: Updated pointer to the function name 112 * 113 * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present. 114 * This allows compiler macros such as __FUNCTION__ to be used 115 * with no change to the debug output. 116 * 117 ******************************************************************************/ 118 119 static const char *acpi_ut_trim_function_name(const char *function_name) 120 { 121 122 /* All Function names are longer than 4 chars, check is safe */ 123 124 if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_MIXED) { 125 126 /* This is the case where the original source has not been modified */ 127 128 return (function_name + 4); 129 } 130 131 if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_LOWER) { 132 133 /* This is the case where the source has been 'linuxized' */ 134 135 return (function_name + 5); 136 } 137 138 return (function_name); 139 } 140 141 /******************************************************************************* 142 * 143 * FUNCTION: acpi_debug_print 144 * 145 * PARAMETERS: requested_debug_level - Requested debug print level 146 * line_number - Caller's line number (for error output) 147 * function_name - Caller's procedure name 148 * module_name - Caller's module name 149 * component_id - Caller's component ID 150 * format - Printf format field 151 * ... - Optional printf arguments 152 * 153 * RETURN: None 154 * 155 * DESCRIPTION: Print error message with prefix consisting of the module name, 156 * line number, and component ID. 157 * 158 ******************************************************************************/ 159 160 void ACPI_INTERNAL_VAR_XFACE 161 acpi_debug_print(u32 requested_debug_level, 162 u32 line_number, 163 const char *function_name, 164 const char *module_name, 165 u32 component_id, const char *format, ...) 166 { 167 acpi_thread_id thread_id; 168 va_list args; 169 170 /* Check if debug output enabled */ 171 172 if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) { 173 return; 174 } 175 176 /* 177 * Thread tracking and context switch notification 178 */ 179 thread_id = acpi_os_get_thread_id(); 180 if (thread_id != acpi_gbl_prev_thread_id) { 181 if (ACPI_LV_THREADS & acpi_dbg_level) { 182 acpi_os_printf 183 ("\n**** Context Switch from TID %u to TID %u ****\n\n", 184 (u32)acpi_gbl_prev_thread_id, (u32)thread_id); 185 } 186 187 acpi_gbl_prev_thread_id = thread_id; 188 acpi_gbl_nesting_level = 0; 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("%9s-%04ld ", module_name, line_number); 196 197 #ifdef ACPI_EXEC_APP 198 /* 199 * For acpi_exec only, emit the thread ID and nesting level. 200 * Note: nesting level is really only useful during a single-thread 201 * execution. Otherwise, multiple threads will keep resetting the 202 * level. 203 */ 204 if (ACPI_LV_THREADS & acpi_dbg_level) { 205 acpi_os_printf("[%u] ", (u32)thread_id); 206 } 207 208 acpi_os_printf("[%02ld] ", acpi_gbl_nesting_level); 209 #endif 210 211 acpi_os_printf("%-22.22s: ", acpi_ut_trim_function_name(function_name)); 212 213 va_start(args, format); 214 acpi_os_vprintf(format, args); 215 va_end(args); 216 } 217 218 ACPI_EXPORT_SYMBOL(acpi_debug_print) 219 220 /******************************************************************************* 221 * 222 * FUNCTION: acpi_debug_print_raw 223 * 224 * PARAMETERS: requested_debug_level - Requested debug print level 225 * line_number - Caller's line number 226 * function_name - Caller's procedure name 227 * module_name - Caller's module name 228 * component_id - Caller's component ID 229 * format - Printf format field 230 * ... - Optional printf arguments 231 * 232 * RETURN: None 233 * 234 * DESCRIPTION: Print message with no headers. Has same interface as 235 * debug_print so that the same macros can be used. 236 * 237 ******************************************************************************/ 238 void ACPI_INTERNAL_VAR_XFACE 239 acpi_debug_print_raw(u32 requested_debug_level, 240 u32 line_number, 241 const char *function_name, 242 const char *module_name, 243 u32 component_id, const char *format, ...) 244 { 245 va_list args; 246 247 /* Check if debug output enabled */ 248 249 if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) { 250 return; 251 } 252 253 va_start(args, format); 254 acpi_os_vprintf(format, args); 255 va_end(args); 256 } 257 258 ACPI_EXPORT_SYMBOL(acpi_debug_print_raw) 259 260 /******************************************************************************* 261 * 262 * FUNCTION: acpi_ut_trace 263 * 264 * PARAMETERS: line_number - Caller's line number 265 * function_name - Caller's procedure name 266 * module_name - Caller's module name 267 * component_id - Caller's component ID 268 * 269 * RETURN: None 270 * 271 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 272 * set in debug_level 273 * 274 ******************************************************************************/ 275 void 276 acpi_ut_trace(u32 line_number, 277 const char *function_name, 278 const char *module_name, u32 component_id) 279 { 280 281 acpi_gbl_nesting_level++; 282 acpi_ut_track_stack_ptr(); 283 284 /* Check if enabled up-front for performance */ 285 286 if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) { 287 acpi_debug_print(ACPI_LV_FUNCTIONS, 288 line_number, function_name, module_name, 289 component_id, "%s\n", acpi_gbl_fn_entry_str); 290 } 291 } 292 293 ACPI_EXPORT_SYMBOL(acpi_ut_trace) 294 295 /******************************************************************************* 296 * 297 * FUNCTION: acpi_ut_trace_ptr 298 * 299 * PARAMETERS: line_number - Caller's line number 300 * function_name - Caller's procedure name 301 * module_name - Caller's module name 302 * component_id - Caller's component ID 303 * pointer - Pointer to display 304 * 305 * RETURN: None 306 * 307 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 308 * set in debug_level 309 * 310 ******************************************************************************/ 311 void 312 acpi_ut_trace_ptr(u32 line_number, 313 const char *function_name, 314 const char *module_name, u32 component_id, void *pointer) 315 { 316 317 acpi_gbl_nesting_level++; 318 acpi_ut_track_stack_ptr(); 319 320 /* Check if enabled up-front for performance */ 321 322 if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) { 323 acpi_debug_print(ACPI_LV_FUNCTIONS, 324 line_number, function_name, module_name, 325 component_id, "%s %p\n", acpi_gbl_fn_entry_str, 326 pointer); 327 } 328 } 329 330 /******************************************************************************* 331 * 332 * FUNCTION: acpi_ut_trace_str 333 * 334 * PARAMETERS: line_number - Caller's line number 335 * function_name - Caller's procedure name 336 * module_name - Caller's module name 337 * component_id - Caller's component ID 338 * string - Additional string to display 339 * 340 * RETURN: None 341 * 342 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 343 * set in debug_level 344 * 345 ******************************************************************************/ 346 347 void 348 acpi_ut_trace_str(u32 line_number, 349 const char *function_name, 350 const char *module_name, u32 component_id, char *string) 351 { 352 353 acpi_gbl_nesting_level++; 354 acpi_ut_track_stack_ptr(); 355 356 /* Check if enabled up-front for performance */ 357 358 if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) { 359 acpi_debug_print(ACPI_LV_FUNCTIONS, 360 line_number, function_name, module_name, 361 component_id, "%s %s\n", acpi_gbl_fn_entry_str, 362 string); 363 } 364 } 365 366 /******************************************************************************* 367 * 368 * FUNCTION: acpi_ut_trace_u32 369 * 370 * PARAMETERS: line_number - Caller's line number 371 * function_name - Caller's procedure name 372 * module_name - Caller's module name 373 * component_id - Caller's component ID 374 * integer - Integer to display 375 * 376 * RETURN: None 377 * 378 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is 379 * set in debug_level 380 * 381 ******************************************************************************/ 382 383 void 384 acpi_ut_trace_u32(u32 line_number, 385 const char *function_name, 386 const char *module_name, u32 component_id, u32 integer) 387 { 388 389 acpi_gbl_nesting_level++; 390 acpi_ut_track_stack_ptr(); 391 392 /* Check if enabled up-front for performance */ 393 394 if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) { 395 acpi_debug_print(ACPI_LV_FUNCTIONS, 396 line_number, function_name, module_name, 397 component_id, "%s %08X\n", 398 acpi_gbl_fn_entry_str, integer); 399 } 400 } 401 402 /******************************************************************************* 403 * 404 * FUNCTION: acpi_ut_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 * 411 * RETURN: None 412 * 413 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is 414 * set in debug_level 415 * 416 ******************************************************************************/ 417 418 void 419 acpi_ut_exit(u32 line_number, 420 const char *function_name, 421 const char *module_name, u32 component_id) 422 { 423 424 /* Check if enabled up-front for performance */ 425 426 if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) { 427 acpi_debug_print(ACPI_LV_FUNCTIONS, 428 line_number, function_name, module_name, 429 component_id, "%s\n", acpi_gbl_fn_exit_str); 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_fn_exit_str, 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_fn_exit_str, 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_fn_exit_str, 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", acpi_gbl_fn_exit_str, 555 ptr); 556 } 557 558 if (acpi_gbl_nesting_level) { 559 acpi_gbl_nesting_level--; 560 } 561 } 562 563 #endif 564