Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
utdebug.c
Go to the documentation of this file.
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 #ifdef ACPI_DEBUG_OUTPUT
51 static acpi_thread_id acpi_gbl_prev_thread_id;
52 static char *acpi_gbl_fn_entry_str = "----Entry";
53 static char *acpi_gbl_fn_exit_str = "----Exit-";
54 
55 /* Local prototypes */
56 
57 static const char *acpi_ut_trim_function_name(const char *function_name);
58 
59 /*******************************************************************************
60  *
61  * FUNCTION: acpi_ut_init_stack_ptr_trace
62  *
63  * PARAMETERS: None
64  *
65  * RETURN: None
66  *
67  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
68  *
69  ******************************************************************************/
70 
72 {
73  acpi_size current_sp;
74 
75  acpi_gbl_entry_stack_pointer = &current_sp;
76 }
77 
78 /*******************************************************************************
79  *
80  * FUNCTION: acpi_ut_track_stack_ptr
81  *
82  * PARAMETERS: None
83  *
84  * RETURN: None
85  *
86  * DESCRIPTION: Save the current CPU stack pointer
87  *
88  ******************************************************************************/
89 
90 void acpi_ut_track_stack_ptr(void)
91 {
92  acpi_size current_sp;
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 __func__ to be used
113  * with no change to the debug output.
114  *
115  ******************************************************************************/
116 
117 static 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_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 
159 acpi_debug_print(u32 requested_debug_level,
160  u32 line_number,
161  const char *function_name,
162  const char *module_name,
163  u32 component_id, const char *format, ...)
164 {
165  acpi_thread_id thread_id;
166  va_list args;
167 
168  /*
169  * Stay silent if the debug level or component ID is disabled
170  */
171  if (!(requested_debug_level & acpi_dbg_level) ||
172  !(component_id & acpi_dbg_layer)) {
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) {
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  }
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("[%u] ", (u32)thread_id);
198  }
199 
200  acpi_os_printf("[%02ld] %-22.22s: ",
202  acpi_ut_trim_function_name(function_name));
203 
204  va_start(args, format);
205  acpi_os_vprintf(format, args);
206  va_end(args);
207 }
208 
209 ACPI_EXPORT_SYMBOL(acpi_debug_print)
210 
211 /*******************************************************************************
212  *
213  * FUNCTION: acpi_debug_print_raw
214  *
215  * PARAMETERS: requested_debug_level - Requested debug print level
216  * line_number - Caller's line number
217  * function_name - Caller's procedure name
218  * module_name - Caller's module name
219  * component_id - Caller's component ID
220  * format - Printf format field
221  * ... - Optional printf arguments
222  *
223  * RETURN: None
224  *
225  * DESCRIPTION: Print message with no headers. Has same interface as
226  * debug_print so that the same macros can be used.
227  *
228  ******************************************************************************/
230 acpi_debug_print_raw(u32 requested_debug_level,
231  u32 line_number,
232  const char *function_name,
233  const char *module_name,
234  u32 component_id, const char *format, ...)
235 {
236  va_list args;
237 
238  if (!(requested_debug_level & acpi_dbg_level) ||
239  !(component_id & acpi_dbg_layer)) {
240  return;
241  }
242 
243  va_start(args, format);
244  acpi_os_vprintf(format, args);
245  va_end(args);
246 }
247 
248 ACPI_EXPORT_SYMBOL(acpi_debug_print_raw)
249 
250 /*******************************************************************************
251  *
252  * FUNCTION: acpi_ut_trace
253  *
254  * PARAMETERS: line_number - Caller's line number
255  * function_name - Caller's procedure name
256  * module_name - Caller's module name
257  * component_id - Caller's component ID
258  *
259  * RETURN: None
260  *
261  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
262  * set in debug_level
263  *
264  ******************************************************************************/
265 void
266 acpi_ut_trace(u32 line_number,
267  const char *function_name,
268  const char *module_name, u32 component_id)
269 {
270 
273 
274  acpi_debug_print(ACPI_LV_FUNCTIONS,
275  line_number, function_name, module_name, component_id,
276  "%s\n", acpi_gbl_fn_entry_str);
277 }
278 
280 
281 /*******************************************************************************
282  *
283  * FUNCTION: acpi_ut_trace_ptr
284  *
285  * PARAMETERS: line_number - Caller's line number
286  * function_name - Caller's procedure name
287  * module_name - Caller's module name
288  * component_id - Caller's component ID
289  * pointer - Pointer to display
290  *
291  * RETURN: None
292  *
293  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
294  * set in debug_level
295  *
296  ******************************************************************************/
297 void
298 acpi_ut_trace_ptr(u32 line_number,
299  const char *function_name,
300  const char *module_name, u32 component_id, void *pointer)
301 {
304 
305  acpi_debug_print(ACPI_LV_FUNCTIONS,
306  line_number, function_name, module_name, component_id,
307  "%s %p\n", acpi_gbl_fn_entry_str, pointer);
308 }
309 
310 /*******************************************************************************
311  *
312  * FUNCTION: acpi_ut_trace_str
313  *
314  * PARAMETERS: line_number - Caller's line number
315  * function_name - Caller's procedure name
316  * module_name - Caller's module name
317  * component_id - Caller's component ID
318  * string - Additional string to display
319  *
320  * RETURN: None
321  *
322  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
323  * set in debug_level
324  *
325  ******************************************************************************/
326 
327 void
328 acpi_ut_trace_str(u32 line_number,
329  const char *function_name,
330  const char *module_name, u32 component_id, char *string)
331 {
332 
335 
336  acpi_debug_print(ACPI_LV_FUNCTIONS,
337  line_number, function_name, module_name, component_id,
338  "%s %s\n", acpi_gbl_fn_entry_str, string);
339 }
340 
341 /*******************************************************************************
342  *
343  * FUNCTION: acpi_ut_trace_u32
344  *
345  * PARAMETERS: line_number - Caller's line number
346  * function_name - Caller's procedure name
347  * module_name - Caller's module name
348  * component_id - Caller's component ID
349  * integer - Integer to display
350  *
351  * RETURN: None
352  *
353  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
354  * set in debug_level
355  *
356  ******************************************************************************/
357 
358 void
359 acpi_ut_trace_u32(u32 line_number,
360  const char *function_name,
361  const char *module_name, u32 component_id, u32 integer)
362 {
363 
366 
367  acpi_debug_print(ACPI_LV_FUNCTIONS,
368  line_number, function_name, module_name, component_id,
369  "%s %08X\n", acpi_gbl_fn_entry_str, integer);
370 }
371 
372 /*******************************************************************************
373  *
374  * FUNCTION: acpi_ut_exit
375  *
376  * PARAMETERS: line_number - Caller's line number
377  * function_name - Caller's procedure name
378  * module_name - Caller's module name
379  * component_id - Caller's component ID
380  *
381  * RETURN: None
382  *
383  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
384  * set in debug_level
385  *
386  ******************************************************************************/
387 
388 void
389 acpi_ut_exit(u32 line_number,
390  const char *function_name,
391  const char *module_name, u32 component_id)
392 {
393 
394  acpi_debug_print(ACPI_LV_FUNCTIONS,
395  line_number, function_name, module_name, component_id,
396  "%s\n", acpi_gbl_fn_exit_str);
397 
399 }
400 
402 
403 /*******************************************************************************
404  *
405  * FUNCTION: acpi_ut_status_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  * status - Exit status code
412  *
413  * RETURN: None
414  *
415  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
416  * set in debug_level. Prints exit status also.
417  *
418  ******************************************************************************/
419 void
420 acpi_ut_status_exit(u32 line_number,
421  const char *function_name,
422  const char *module_name,
423  u32 component_id, acpi_status status)
424 {
425 
426  if (ACPI_SUCCESS(status)) {
427  acpi_debug_print(ACPI_LV_FUNCTIONS,
428  line_number, function_name, module_name,
429  component_id, "%s %s\n", acpi_gbl_fn_exit_str,
430  acpi_format_exception(status));
431  } else {
432  acpi_debug_print(ACPI_LV_FUNCTIONS,
433  line_number, function_name, module_name,
434  component_id, "%s ****Exception****: %s\n",
435  acpi_gbl_fn_exit_str,
436  acpi_format_exception(status));
437  }
438 
440 }
441 
443 
444 /*******************************************************************************
445  *
446  * FUNCTION: acpi_ut_value_exit
447  *
448  * PARAMETERS: line_number - Caller's line number
449  * function_name - Caller's procedure name
450  * module_name - Caller's module name
451  * component_id - Caller's component ID
452  * value - Value to be printed with exit msg
453  *
454  * RETURN: None
455  *
456  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
457  * set in debug_level. Prints exit value also.
458  *
459  ******************************************************************************/
460 void
461 acpi_ut_value_exit(u32 line_number,
462  const char *function_name,
463  const char *module_name, u32 component_id, u64 value)
464 {
465 
466  acpi_debug_print(ACPI_LV_FUNCTIONS,
467  line_number, function_name, module_name, component_id,
468  "%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str,
469  ACPI_FORMAT_UINT64(value));
470 
472 }
473 
475 
476 /*******************************************************************************
477  *
478  * FUNCTION: acpi_ut_ptr_exit
479  *
480  * PARAMETERS: line_number - Caller's line number
481  * function_name - Caller's procedure name
482  * module_name - Caller's module name
483  * component_id - Caller's component ID
484  * ptr - Pointer to display
485  *
486  * RETURN: None
487  *
488  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
489  * set in debug_level. Prints exit value also.
490  *
491  ******************************************************************************/
492 void
493 acpi_ut_ptr_exit(u32 line_number,
494  const char *function_name,
495  const char *module_name, u32 component_id, u8 *ptr)
496 {
497 
498  acpi_debug_print(ACPI_LV_FUNCTIONS,
499  line_number, function_name, module_name, component_id,
500  "%s %p\n", acpi_gbl_fn_exit_str, ptr);
501 
503 }
504 
505 #endif
506 
507 /*******************************************************************************
508  *
509  * FUNCTION: acpi_ut_dump_buffer
510  *
511  * PARAMETERS: buffer - Buffer to dump
512  * count - Amount to dump, in bytes
513  * display - BYTE, WORD, DWORD, or QWORD display
514  * component_ID - Caller's component ID
515  *
516  * RETURN: None
517  *
518  * DESCRIPTION: Generic dump buffer in both hex and ascii.
519  *
520  ******************************************************************************/
521 
523 {
524  u32 i = 0;
525  u32 j;
526  u32 temp32;
527  u8 buf_char;
528 
529  if (!buffer) {
530  acpi_os_printf("Null Buffer Pointer in DumpBuffer!\n");
531  return;
532  }
533 
534  if ((count < 4) || (count & 0x01)) {
535  display = DB_BYTE_DISPLAY;
536  }
537 
538  /* Nasty little dump buffer routine! */
539 
540  while (i < count) {
541 
542  /* Print current offset */
543 
544  acpi_os_printf("%6.4X: ", i);
545 
546  /* Print 16 hex chars */
547 
548  for (j = 0; j < 16;) {
549  if (i + j >= count) {
550 
551  /* Dump fill spaces */
552 
553  acpi_os_printf("%*s", ((display * 2) + 1), " ");
554  j += display;
555  continue;
556  }
557 
558  switch (display) {
559  case DB_BYTE_DISPLAY:
560  default: /* Default is BYTE display */
561 
562  acpi_os_printf("%02X ",
563  buffer[(acpi_size) i + j]);
564  break;
565 
566  case DB_WORD_DISPLAY:
567 
568  ACPI_MOVE_16_TO_32(&temp32,
569  &buffer[(acpi_size) i + j]);
570  acpi_os_printf("%04X ", temp32);
571  break;
572 
573  case DB_DWORD_DISPLAY:
574 
575  ACPI_MOVE_32_TO_32(&temp32,
576  &buffer[(acpi_size) i + j]);
577  acpi_os_printf("%08X ", temp32);
578  break;
579 
580  case DB_QWORD_DISPLAY:
581 
582  ACPI_MOVE_32_TO_32(&temp32,
583  &buffer[(acpi_size) i + j]);
584  acpi_os_printf("%08X", temp32);
585 
586  ACPI_MOVE_32_TO_32(&temp32,
587  &buffer[(acpi_size) i + j +
588  4]);
589  acpi_os_printf("%08X ", temp32);
590  break;
591  }
592 
593  j += display;
594  }
595 
596  /*
597  * Print the ASCII equivalent characters but watch out for the bad
598  * unprintable ones (printable chars are 0x20 through 0x7E)
599  */
600  acpi_os_printf(" ");
601  for (j = 0; j < 16; j++) {
602  if (i + j >= count) {
603  acpi_os_printf("\n");
604  return;
605  }
606 
607  buf_char = buffer[(acpi_size) i + j];
608  if (ACPI_IS_PRINT(buf_char)) {
609  acpi_os_printf("%c", buf_char);
610  } else {
611  acpi_os_printf(".");
612  }
613  }
614 
615  /* Done with that line. */
616 
617  acpi_os_printf("\n");
618  i += 16;
619  }
620 
621  return;
622 }
623 
624 /*******************************************************************************
625  *
626  * FUNCTION: acpi_ut_dump_buffer
627  *
628  * PARAMETERS: buffer - Buffer to dump
629  * count - Amount to dump, in bytes
630  * display - BYTE, WORD, DWORD, or QWORD display
631  * component_ID - Caller's component ID
632  *
633  * RETURN: None
634  *
635  * DESCRIPTION: Generic dump buffer in both hex and ascii.
636  *
637  ******************************************************************************/
638 
640 {
641 
642  /* Only dump the buffer if tracing is enabled */
643 
644  if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
645  (component_id & acpi_dbg_layer))) {
646  return;
647  }
648 
649  acpi_ut_dump_buffer2(buffer, count, display);
650 }