WebSVN – Kolibri OS – Blame – /drivers/acpi/acpica/utdebug.c

Rev	Author	Line No.	Line
6595	serge	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
		47	#include "accommon.h"
		48	#include "acinterp.h"
		49
		50	#define _COMPONENT ACPI_UTILITIES
		51	ACPI_MODULE_NAME("utdebug")
		52
		53	#ifdef ACPI_DEBUG_OUTPUT
		54	static acpi_thread_id acpi_gbl_prev_thread_id = (acpi_thread_id) 0xFFFFFFFF;
		55	static char *acpi_gbl_fn_entry_str = "----Entry";
		56	static char *acpi_gbl_fn_exit_str = "----Exit-";
		57
		58	/* Local prototypes */
		59
		60	static 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
		74	void acpi_ut_init_stack_ptr_trace(void)
		75	{
		76	acpi_size current_sp;
		77
		78	acpi_gbl_entry_stack_pointer = ¤t_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
		93	void acpi_ut_track_stack_ptr(void)
		94	{
		95	acpi_size current_sp;
		96
		97	if (¤t_sp < acpi_gbl_lowest_stack_pointer) {
		98	acpi_gbl_lowest_stack_pointer = ¤t_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
		120	static 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
		161	void ACPI_INTERNAL_VAR_XFACE
		162	acpi_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
		219	ACPI_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	******************************************************************************/
		239	void ACPI_INTERNAL_VAR_XFACE
		240	acpi_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
		259	ACPI_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	******************************************************************************/
		276	void
		277	acpi_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
		294	ACPI_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	******************************************************************************/
		312	void
		313	acpi_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
		348	void
		349	acpi_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
		384	void
		385	acpi_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
		419	void
		420	acpi_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
		438	ACPI_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	******************************************************************************/
		456	void
		457	acpi_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
		487	ACPI_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	******************************************************************************/
		505	void
		506	acpi_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
		526	ACPI_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	******************************************************************************/
		544	void
		545	acpi_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
		580	void
		581	acpi_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
		593	ACPI_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	******************************************************************************/
		608	void 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
		617	ACPI_EXPORT_SYMBOL(acpi_log_error)
		618	#endif

Subversion Repositories Kolibri OS

(root)/drivers/acpi/acpica/utdebug.c – Rev 6595