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