1/******************************************************************************
2 *
3 * Module Name: utdebug - Debug print/trace routines
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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#include "acinterp.h"
49
50#define _COMPONENT          ACPI_UTILITIES
51ACPI_MODULE_NAME("utdebug")
52
53#ifdef ACPI_DEBUG_OUTPUT
54static acpi_thread_id acpi_gbl_prev_thread_id = (acpi_thread_id) 0xFFFFFFFF;
55static char *acpi_gbl_fn_entry_str = "----Entry";
56static char *acpi_gbl_fn_exit_str = "----Exit-";
57
58/* Local prototypes */
59
60static const char *acpi_ut_trim_function_name(const char *function_name);
61
62/*******************************************************************************
63 *
64 * FUNCTION:    acpi_ut_init_stack_ptr_trace
65 *
66 * PARAMETERS:  None
67 *
68 * RETURN:      None
69 *
70 * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
71 *
72 ******************************************************************************/
73
74void acpi_ut_init_stack_ptr_trace(void)
75{
76	acpi_size current_sp;
77
78	acpi_gbl_entry_stack_pointer = &current_sp;
79}
80
81/*******************************************************************************
82 *
83 * FUNCTION:    acpi_ut_track_stack_ptr
84 *
85 * PARAMETERS:  None
86 *
87 * RETURN:      None
88 *
89 * DESCRIPTION: Save the current CPU stack pointer
90 *
91 ******************************************************************************/
92
93void acpi_ut_track_stack_ptr(void)
94{
95	acpi_size current_sp;
96
97	if (&current_sp < acpi_gbl_lowest_stack_pointer) {
98		acpi_gbl_lowest_stack_pointer = &current_sp;
99	}
100
101	if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) {
102		acpi_gbl_deepest_nesting = acpi_gbl_nesting_level;
103	}
104}
105
106/*******************************************************************************
107 *
108 * FUNCTION:    acpi_ut_trim_function_name
109 *
110 * PARAMETERS:  function_name       - Ascii string containing a procedure name
111 *
112 * RETURN:      Updated pointer to the function name
113 *
114 * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
115 *              This allows compiler macros such as __func__ to be used
116 *              with no change to the debug output.
117 *
118 ******************************************************************************/
119
120static const char *acpi_ut_trim_function_name(const char *function_name)
121{
122
123	/* All Function names are longer than 4 chars, check is safe */
124
125	if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_MIXED) {
126
127		/* This is the case where the original source has not been modified */
128
129		return (function_name + 4);
130	}
131
132	if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_LOWER) {
133
134		/* This is the case where the source has been 'linuxized' */
135
136		return (function_name + 5);
137	}
138
139	return (function_name);
140}
141
142/*******************************************************************************
143 *
144 * FUNCTION:    acpi_debug_print
145 *
146 * PARAMETERS:  requested_debug_level - Requested debug print level
147 *              line_number         - Caller's line number (for error output)
148 *              function_name       - Caller's procedure name
149 *              module_name         - Caller's module name
150 *              component_id        - Caller's component ID
151 *              format              - Printf format field
152 *              ...                 - Optional printf arguments
153 *
154 * RETURN:      None
155 *
156 * DESCRIPTION: Print error message with prefix consisting of the module name,
157 *              line number, and component ID.
158 *
159 ******************************************************************************/
160
161void ACPI_INTERNAL_VAR_XFACE
162acpi_debug_print(u32 requested_debug_level,
163		 u32 line_number,
164		 const char *function_name,
165		 const char *module_name,
166		 u32 component_id, const char *format, ...)
167{
168	acpi_thread_id thread_id;
169	va_list args;
170
171	/* Check if debug output enabled */
172
173	if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) {
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		acpi_gbl_nesting_level = 0;
190	}
191
192	/*
193	 * Display the module name, current line number, thread ID (if requested),
194	 * current procedure nesting level, and the current procedure name
195	 */
196	acpi_os_printf("%9s-%04ld ", module_name, line_number);
197
198#ifdef ACPI_APPLICATION
199	/*
200	 * For acpi_exec/iASL only, emit the thread ID and nesting level.
201	 * Note: nesting level is really only useful during a single-thread
202	 * execution. Otherwise, multiple threads will keep resetting the
203	 * level.
204	 */
205	if (ACPI_LV_THREADS & acpi_dbg_level) {
206		acpi_os_printf("[%u] ", (u32)thread_id);
207	}
208
209	acpi_os_printf("[%02ld] ", acpi_gbl_nesting_level);
210#endif
211
212	acpi_os_printf("%-22.22s: ", acpi_ut_trim_function_name(function_name));
213
214	va_start(args, format);
215	acpi_os_vprintf(format, args);
216	va_end(args);
217}
218
219ACPI_EXPORT_SYMBOL(acpi_debug_print)
220
221/*******************************************************************************
222 *
223 * FUNCTION:    acpi_debug_print_raw
224 *
225 * PARAMETERS:  requested_debug_level - Requested debug print level
226 *              line_number         - Caller's line number
227 *              function_name       - Caller's procedure name
228 *              module_name         - Caller's module name
229 *              component_id        - Caller's component ID
230 *              format              - Printf format field
231 *              ...                 - Optional printf arguments
232 *
233 * RETURN:      None
234 *
235 * DESCRIPTION: Print message with no headers. Has same interface as
236 *              debug_print so that the same macros can be used.
237 *
238 ******************************************************************************/
239void ACPI_INTERNAL_VAR_XFACE
240acpi_debug_print_raw(u32 requested_debug_level,
241		     u32 line_number,
242		     const char *function_name,
243		     const char *module_name,
244		     u32 component_id, const char *format, ...)
245{
246	va_list args;
247
248	/* Check if debug output enabled */
249
250	if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) {
251		return;
252	}
253
254	va_start(args, format);
255	acpi_os_vprintf(format, args);
256	va_end(args);
257}
258
259ACPI_EXPORT_SYMBOL(acpi_debug_print_raw)
260
261/*******************************************************************************
262 *
263 * FUNCTION:    acpi_ut_trace
264 *
265 * PARAMETERS:  line_number         - Caller's line number
266 *              function_name       - Caller's procedure name
267 *              module_name         - Caller's module name
268 *              component_id        - Caller's component ID
269 *
270 * RETURN:      None
271 *
272 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
273 *              set in debug_level
274 *
275 ******************************************************************************/
276void
277acpi_ut_trace(u32 line_number,
278	      const char *function_name,
279	      const char *module_name, u32 component_id)
280{
281
282	acpi_gbl_nesting_level++;
283	acpi_ut_track_stack_ptr();
284
285	/* Check if enabled up-front for performance */
286
287	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
288		acpi_debug_print(ACPI_LV_FUNCTIONS,
289				 line_number, function_name, module_name,
290				 component_id, "%s\n", acpi_gbl_fn_entry_str);
291	}
292}
293
294ACPI_EXPORT_SYMBOL(acpi_ut_trace)
295
296/*******************************************************************************
297 *
298 * FUNCTION:    acpi_ut_trace_ptr
299 *
300 * PARAMETERS:  line_number         - Caller's line number
301 *              function_name       - Caller's procedure name
302 *              module_name         - Caller's module name
303 *              component_id        - Caller's component ID
304 *              pointer             - Pointer to display
305 *
306 * RETURN:      None
307 *
308 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
309 *              set in debug_level
310 *
311 ******************************************************************************/
312void
313acpi_ut_trace_ptr(u32 line_number,
314		  const char *function_name,
315		  const char *module_name, u32 component_id, void *pointer)
316{
317
318	acpi_gbl_nesting_level++;
319	acpi_ut_track_stack_ptr();
320
321	/* Check if enabled up-front for performance */
322
323	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
324		acpi_debug_print(ACPI_LV_FUNCTIONS,
325				 line_number, function_name, module_name,
326				 component_id, "%s %p\n", acpi_gbl_fn_entry_str,
327				 pointer);
328	}
329}
330
331/*******************************************************************************
332 *
333 * FUNCTION:    acpi_ut_trace_str
334 *
335 * PARAMETERS:  line_number         - Caller's line number
336 *              function_name       - Caller's procedure name
337 *              module_name         - Caller's module name
338 *              component_id        - Caller's component ID
339 *              string              - Additional string to display
340 *
341 * RETURN:      None
342 *
343 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
344 *              set in debug_level
345 *
346 ******************************************************************************/
347
348void
349acpi_ut_trace_str(u32 line_number,
350		  const char *function_name,
351		  const char *module_name, u32 component_id, char *string)
352{
353
354	acpi_gbl_nesting_level++;
355	acpi_ut_track_stack_ptr();
356
357	/* Check if enabled up-front for performance */
358
359	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
360		acpi_debug_print(ACPI_LV_FUNCTIONS,
361				 line_number, function_name, module_name,
362				 component_id, "%s %s\n", acpi_gbl_fn_entry_str,
363				 string);
364	}
365}
366
367/*******************************************************************************
368 *
369 * FUNCTION:    acpi_ut_trace_u32
370 *
371 * PARAMETERS:  line_number         - Caller's line number
372 *              function_name       - Caller's procedure name
373 *              module_name         - Caller's module name
374 *              component_id        - Caller's component ID
375 *              integer             - Integer to display
376 *
377 * RETURN:      None
378 *
379 * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
380 *              set in debug_level
381 *
382 ******************************************************************************/
383
384void
385acpi_ut_trace_u32(u32 line_number,
386		  const char *function_name,
387		  const char *module_name, u32 component_id, u32 integer)
388{
389
390	acpi_gbl_nesting_level++;
391	acpi_ut_track_stack_ptr();
392
393	/* Check if enabled up-front for performance */
394
395	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
396		acpi_debug_print(ACPI_LV_FUNCTIONS,
397				 line_number, function_name, module_name,
398				 component_id, "%s %08X\n",
399				 acpi_gbl_fn_entry_str, integer);
400	}
401}
402
403/*******************************************************************************
404 *
405 * FUNCTION:    acpi_ut_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 *
412 * RETURN:      None
413 *
414 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
415 *              set in debug_level
416 *
417 ******************************************************************************/
418
419void
420acpi_ut_exit(u32 line_number,
421	     const char *function_name,
422	     const char *module_name, u32 component_id)
423{
424
425	/* Check if enabled up-front for performance */
426
427	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
428		acpi_debug_print(ACPI_LV_FUNCTIONS,
429				 line_number, function_name, module_name,
430				 component_id, "%s\n", acpi_gbl_fn_exit_str);
431	}
432
433	if (acpi_gbl_nesting_level) {
434		acpi_gbl_nesting_level--;
435	}
436}
437
438ACPI_EXPORT_SYMBOL(acpi_ut_exit)
439
440/*******************************************************************************
441 *
442 * FUNCTION:    acpi_ut_status_exit
443 *
444 * PARAMETERS:  line_number         - Caller's line number
445 *              function_name       - Caller's procedure name
446 *              module_name         - Caller's module name
447 *              component_id        - Caller's component ID
448 *              status              - Exit status code
449 *
450 * RETURN:      None
451 *
452 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
453 *              set in debug_level. Prints exit status also.
454 *
455 ******************************************************************************/
456void
457acpi_ut_status_exit(u32 line_number,
458		    const char *function_name,
459		    const char *module_name,
460		    u32 component_id, acpi_status status)
461{
462
463	/* Check if enabled up-front for performance */
464
465	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
466		if (ACPI_SUCCESS(status)) {
467			acpi_debug_print(ACPI_LV_FUNCTIONS,
468					 line_number, function_name,
469					 module_name, component_id, "%s %s\n",
470					 acpi_gbl_fn_exit_str,
471					 acpi_format_exception(status));
472		} else {
473			acpi_debug_print(ACPI_LV_FUNCTIONS,
474					 line_number, function_name,
475					 module_name, component_id,
476					 "%s ****Exception****: %s\n",
477					 acpi_gbl_fn_exit_str,
478					 acpi_format_exception(status));
479		}
480	}
481
482	if (acpi_gbl_nesting_level) {
483		acpi_gbl_nesting_level--;
484	}
485}
486
487ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
488
489/*******************************************************************************
490 *
491 * FUNCTION:    acpi_ut_value_exit
492 *
493 * PARAMETERS:  line_number         - Caller's line number
494 *              function_name       - Caller's procedure name
495 *              module_name         - Caller's module name
496 *              component_id        - Caller's component ID
497 *              value               - Value to be printed with exit msg
498 *
499 * RETURN:      None
500 *
501 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
502 *              set in debug_level. Prints exit value also.
503 *
504 ******************************************************************************/
505void
506acpi_ut_value_exit(u32 line_number,
507		   const char *function_name,
508		   const char *module_name, u32 component_id, u64 value)
509{
510
511	/* Check if enabled up-front for performance */
512
513	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
514		acpi_debug_print(ACPI_LV_FUNCTIONS,
515				 line_number, function_name, module_name,
516				 component_id, "%s %8.8X%8.8X\n",
517				 acpi_gbl_fn_exit_str,
518				 ACPI_FORMAT_UINT64(value));
519	}
520
521	if (acpi_gbl_nesting_level) {
522		acpi_gbl_nesting_level--;
523	}
524}
525
526ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
527
528/*******************************************************************************
529 *
530 * FUNCTION:    acpi_ut_ptr_exit
531 *
532 * PARAMETERS:  line_number         - Caller's line number
533 *              function_name       - Caller's procedure name
534 *              module_name         - Caller's module name
535 *              component_id        - Caller's component ID
536 *              ptr                 - Pointer to display
537 *
538 * RETURN:      None
539 *
540 * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
541 *              set in debug_level. Prints exit value also.
542 *
543 ******************************************************************************/
544void
545acpi_ut_ptr_exit(u32 line_number,
546		 const char *function_name,
547		 const char *module_name, u32 component_id, u8 *ptr)
548{
549
550	/* Check if enabled up-front for performance */
551
552	if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
553		acpi_debug_print(ACPI_LV_FUNCTIONS,
554				 line_number, function_name, module_name,
555				 component_id, "%s %p\n", acpi_gbl_fn_exit_str,
556				 ptr);
557	}
558
559	if (acpi_gbl_nesting_level) {
560		acpi_gbl_nesting_level--;
561	}
562}
563
564/*******************************************************************************
565 *
566 * FUNCTION:    acpi_trace_point
567 *
568 * PARAMETERS:  type                - Trace event type
569 *              begin               - TRUE if before execution
570 *              aml                 - Executed AML address
571 *              pathname            - Object path
572 *              pointer             - Pointer to the related object
573 *
574 * RETURN:      None
575 *
576 * DESCRIPTION: Interpreter execution trace.
577 *
578 ******************************************************************************/
579
580void
581acpi_trace_point(acpi_trace_event_type type, u8 begin, u8 *aml, char *pathname)
582{
583
584	ACPI_FUNCTION_ENTRY();
585
586	acpi_ex_trace_point(type, begin, aml, pathname);
587
588#ifdef ACPI_USE_SYSTEM_TRACER
589	acpi_os_trace_point(type, begin, aml, pathname);
590#endif
591}
592
593ACPI_EXPORT_SYMBOL(acpi_trace_point)
594#endif
595#ifdef ACPI_APPLICATION
596/*******************************************************************************
597 *
598 * FUNCTION:    acpi_log_error
599 *
600 * PARAMETERS:  format              - Printf format field
601 *              ...                 - Optional printf arguments
602 *
603 * RETURN:      None
604 *
605 * DESCRIPTION: Print error message to the console, used by applications.
606 *
607 ******************************************************************************/
608void ACPI_INTERNAL_VAR_XFACE acpi_log_error(const char *format, ...)
609{
610	va_list args;
611
612	va_start(args, format);
613	(void)acpi_ut_file_vprintf(ACPI_FILE_ERR, format, args);
614	va_end(args);
615}
616
617ACPI_EXPORT_SYMBOL(acpi_log_error)
618#endif
619