utdebug.c revision 73a3090a2160fb01317f5a44af6ee5a064a29625 
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
49ACPI_MODULE_NAME("utdebug")
50
51#ifdef ACPI_DEBUG_OUTPUT
52static acpi_thread_id acpi_gbl_prev_thread_id = (acpi_thread_id) 0xFFFFFFFF;
53static char *acpi_gbl_fn_entry_str = "----Entry";
54static char *acpi_gbl_fn_exit_str = "----Exit-";
55
56/* Local prototypes */
57
58static 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
72void acpi_ut_init_stack_ptr_trace(void)
73{
74	acpi_size current_sp;
75
76	acpi_gbl_entry_stack_pointer = &current_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
91void acpi_ut_track_stack_ptr(void)
92{
93	acpi_size current_sp;
94
95	if (&current_sp < acpi_gbl_lowest_stack_pointer) {
96		acpi_gbl_lowest_stack_pointer = &current_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
118static 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
159void ACPI_INTERNAL_VAR_XFACE
160acpi_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
210ACPI_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 ******************************************************************************/
230void ACPI_INTERNAL_VAR_XFACE
231acpi_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
249ACPI_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 ******************************************************************************/
266void
267acpi_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
280ACPI_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 ******************************************************************************/
298void
299acpi_ut_trace_ptr(u32 line_number,
300		  const char *function_name,
301		  const char *module_name, u32 component_id, void *pointer)
302{
303
304	acpi_gbl_nesting_level++;
305	acpi_ut_track_stack_ptr();
306
307	acpi_debug_print(ACPI_LV_FUNCTIONS,
308			 line_number, function_name, module_name, component_id,
309			 "%s %p\n", acpi_gbl_fn_entry_str, pointer);
310}
311
312/*******************************************************************************
313 *
314 * FUNCTION:    acpi_ut_trace_str
315 *
316 * PARAMETERS:  line_number         - Caller's line number
317 *              function_name       - Caller's procedure name
318 *              module_name         - Caller's module name
319 *              component_id        - Caller's component ID
320 *              string              - Additional string to display
321 *
322 * RETURN:      None
323 *
324 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
325 *              set in debug_level
326 *
327 ******************************************************************************/
328
329void
330acpi_ut_trace_str(u32 line_number,
331		  const char *function_name,
332		  const char *module_name, u32 component_id, char *string)
333{
334
335	acpi_gbl_nesting_level++;
336	acpi_ut_track_stack_ptr();
337
338	acpi_debug_print(ACPI_LV_FUNCTIONS,
339			 line_number, function_name, module_name, component_id,
340			 "%s %s\n", acpi_gbl_fn_entry_str, string);
341}
342
343/*******************************************************************************
344 *
345 * FUNCTION:    acpi_ut_trace_u32
346 *
347 * PARAMETERS:  line_number         - Caller's line number
348 *              function_name       - Caller's procedure name
349 *              module_name         - Caller's module name
350 *              component_id        - Caller's component ID
351 *              integer             - Integer to display
352 *
353 * RETURN:      None
354 *
355 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
356 *              set in debug_level
357 *
358 ******************************************************************************/
359
360void
361acpi_ut_trace_u32(u32 line_number,
362		  const char *function_name,
363		  const char *module_name, u32 component_id, u32 integer)
364{
365
366	acpi_gbl_nesting_level++;
367	acpi_ut_track_stack_ptr();
368
369	acpi_debug_print(ACPI_LV_FUNCTIONS,
370			 line_number, function_name, module_name, component_id,
371			 "%s %08X\n", acpi_gbl_fn_entry_str, integer);
372}
373
374/*******************************************************************************
375 *
376 * FUNCTION:    acpi_ut_exit
377 *
378 * PARAMETERS:  line_number         - Caller's line number
379 *              function_name       - Caller's procedure name
380 *              module_name         - Caller's module name
381 *              component_id        - Caller's component ID
382 *
383 * RETURN:      None
384 *
385 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
386 *              set in debug_level
387 *
388 ******************************************************************************/
389
390void
391acpi_ut_exit(u32 line_number,
392	     const char *function_name,
393	     const char *module_name, u32 component_id)
394{
395
396	acpi_debug_print(ACPI_LV_FUNCTIONS,
397			 line_number, function_name, module_name, component_id,
398			 "%s\n", acpi_gbl_fn_exit_str);
399
400	acpi_gbl_nesting_level--;
401}
402
403ACPI_EXPORT_SYMBOL(acpi_ut_exit)
404
405/*******************************************************************************
406 *
407 * FUNCTION:    acpi_ut_status_exit
408 *
409 * PARAMETERS:  line_number         - Caller's line number
410 *              function_name       - Caller's procedure name
411 *              module_name         - Caller's module name
412 *              component_id        - Caller's component ID
413 *              status              - Exit status code
414 *
415 * RETURN:      None
416 *
417 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
418 *              set in debug_level. Prints exit status also.
419 *
420 ******************************************************************************/
421void
422acpi_ut_status_exit(u32 line_number,
423		    const char *function_name,
424		    const char *module_name,
425		    u32 component_id, acpi_status status)
426{
427
428	if (ACPI_SUCCESS(status)) {
429		acpi_debug_print(ACPI_LV_FUNCTIONS,
430				 line_number, function_name, module_name,
431				 component_id, "%s %s\n", acpi_gbl_fn_exit_str,
432				 acpi_format_exception(status));
433	} else {
434		acpi_debug_print(ACPI_LV_FUNCTIONS,
435				 line_number, function_name, module_name,
436				 component_id, "%s ****Exception****: %s\n",
437				 acpi_gbl_fn_exit_str,
438				 acpi_format_exception(status));
439	}
440
441	acpi_gbl_nesting_level--;
442}
443
444ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
445
446/*******************************************************************************
447 *
448 * FUNCTION:    acpi_ut_value_exit
449 *
450 * PARAMETERS:  line_number         - Caller's line number
451 *              function_name       - Caller's procedure name
452 *              module_name         - Caller's module name
453 *              component_id        - Caller's component ID
454 *              value               - Value to be printed with exit msg
455 *
456 * RETURN:      None
457 *
458 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
459 *              set in debug_level. Prints exit value also.
460 *
461 ******************************************************************************/
462void
463acpi_ut_value_exit(u32 line_number,
464		   const char *function_name,
465		   const char *module_name, u32 component_id, u64 value)
466{
467
468	acpi_debug_print(ACPI_LV_FUNCTIONS,
469			 line_number, function_name, module_name, component_id,
470			 "%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str,
471			 ACPI_FORMAT_UINT64(value));
472
473	acpi_gbl_nesting_level--;
474}
475
476ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
477
478/*******************************************************************************
479 *
480 * FUNCTION:    acpi_ut_ptr_exit
481 *
482 * PARAMETERS:  line_number         - Caller's line number
483 *              function_name       - Caller's procedure name
484 *              module_name         - Caller's module name
485 *              component_id        - Caller's component ID
486 *              ptr                 - Pointer to display
487 *
488 * RETURN:      None
489 *
490 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
491 *              set in debug_level. Prints exit value also.
492 *
493 ******************************************************************************/
494void
495acpi_ut_ptr_exit(u32 line_number,
496		 const char *function_name,
497		 const char *module_name, u32 component_id, u8 *ptr)
498{
499
500	acpi_debug_print(ACPI_LV_FUNCTIONS,
501			 line_number, function_name, module_name, component_id,
502			 "%s %p\n", acpi_gbl_fn_exit_str, ptr);
503
504	acpi_gbl_nesting_level--;
505}
506
507#endif
508
509/*******************************************************************************
510 *
511 * FUNCTION:    acpi_ut_dump_buffer
512 *
513 * PARAMETERS:  buffer              - Buffer to dump
514 *              count               - Amount to dump, in bytes
515 *              display             - BYTE, WORD, DWORD, or QWORD display
516 *              component_ID        - Caller's component ID
517 *
518 * RETURN:      None
519 *
520 * DESCRIPTION: Generic dump buffer in both hex and ascii.
521 *
522 ******************************************************************************/
523
524void acpi_ut_dump_buffer2(u8 *buffer, u32 count, u32 display)
525{
526	u32 i = 0;
527	u32 j;
528	u32 temp32;
529	u8 buf_char;
530
531	if (!buffer) {
532		acpi_os_printf("Null Buffer Pointer in DumpBuffer!\n");
533		return;
534	}
535
536	if ((count < 4) || (count & 0x01)) {
537		display = DB_BYTE_DISPLAY;
538	}
539
540	/* Nasty little dump buffer routine! */
541
542	while (i < count) {
543
544		/* Print current offset */
545
546		acpi_os_printf("%6.4X: ", i);
547
548		/* Print 16 hex chars */
549
550		for (j = 0; j < 16;) {
551			if (i + j >= count) {
552
553				/* Dump fill spaces */
554
555				acpi_os_printf("%*s", ((display * 2) + 1), " ");
556				j += display;
557				continue;
558			}
559
560			switch (display) {
561			case DB_BYTE_DISPLAY:
562			default:	/* Default is BYTE display */
563
564				acpi_os_printf("%02X ",
565					       buffer[(acpi_size) i + j]);
566				break;
567
568			case DB_WORD_DISPLAY:
569
570				ACPI_MOVE_16_TO_32(&temp32,
571						   &buffer[(acpi_size) i + j]);
572				acpi_os_printf("%04X ", temp32);
573				break;
574
575			case DB_DWORD_DISPLAY:
576
577				ACPI_MOVE_32_TO_32(&temp32,
578						   &buffer[(acpi_size) i + j]);
579				acpi_os_printf("%08X ", temp32);
580				break;
581
582			case DB_QWORD_DISPLAY:
583
584				ACPI_MOVE_32_TO_32(&temp32,
585						   &buffer[(acpi_size) i + j]);
586				acpi_os_printf("%08X", temp32);
587
588				ACPI_MOVE_32_TO_32(&temp32,
589						   &buffer[(acpi_size) i + j +
590							   4]);
591				acpi_os_printf("%08X ", temp32);
592				break;
593			}
594
595			j += display;
596		}
597
598		/*
599		 * Print the ASCII equivalent characters but watch out for the bad
600		 * unprintable ones (printable chars are 0x20 through 0x7E)
601		 */
602		acpi_os_printf(" ");
603		for (j = 0; j < 16; j++) {
604			if (i + j >= count) {
605				acpi_os_printf("\n");
606				return;
607			}
608
609			buf_char = buffer[(acpi_size) i + j];
610			if (ACPI_IS_PRINT(buf_char)) {
611				acpi_os_printf("%c", buf_char);
612			} else {
613				acpi_os_printf(".");
614			}
615		}
616
617		/* Done with that line. */
618
619		acpi_os_printf("\n");
620		i += 16;
621	}
622
623	return;
624}
625
626/*******************************************************************************
627 *
628 * FUNCTION:    acpi_ut_dump_buffer
629 *
630 * PARAMETERS:  buffer              - Buffer to dump
631 *              count               - Amount to dump, in bytes
632 *              display             - BYTE, WORD, DWORD, or QWORD display
633 *              component_ID        - Caller's component ID
634 *
635 * RETURN:      None
636 *
637 * DESCRIPTION: Generic dump buffer in both hex and ascii.
638 *
639 ******************************************************************************/
640
641void acpi_ut_dump_buffer(u8 *buffer, u32 count, u32 display, u32 component_id)
642{
643
644	/* Only dump the buffer if tracing is enabled */
645
646	if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
647	      (component_id & acpi_dbg_layer))) {
648		return;
649	}
650
651	acpi_ut_dump_buffer2(buffer, count, display);
652}
653