CTC++ Coverage Report - Execution Profile    #219/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: drivers/acpi/namespace/nssearch.c
Instrumentation mode: function-decision-multicondition
TER: 71 % ( 42/ 59)

Start/	End/
True	False	-	Line	Source
			1	/*******************************************************************************
			2	*
			3	* Module Name: nssearch - Namespace search
			4	*
			5	******************************************************************************/
			6
			7	/*
			8	* Copyright (C) 2000 - 2006, R. Byron Moore
			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 <acpi/acpi.h>
			45	#include <acpi/acnamesp.h>
			46
			47	#define _COMPONENT          ACPI_NAMESPACE
			48	ACPI_MODULE_NAME("nssearch")
			49
			50	/* Local prototypes */
			51	static acpi_status
			52	acpi_ns_search_parent_tree(u32 target_name,
			53	struct acpi_namespace_node *node,
			54	acpi_object_type type,
			55	struct acpi_namespace_node **return_node);
			56
			57	/*******************************************************************************
			58	*
			59	* FUNCTION:    acpi_ns_search_node
			60	*
			61	* PARAMETERS:  target_name     - Ascii ACPI name to search for
			62	*              Node            - Starting node where search will begin
			63	*              Type            - Object type to match
			64	*              return_node     - Where the matched Named obj is returned
			65	*
			66	* RETURN:      Status
			67	*
			68	* DESCRIPTION: Search a single level of the namespace.  Performs a
			69	*              simple search of the specified level, and does not add
			70	*              entries or search parents.
			71	*
			72	*
			73	*      Named object lists are built (and subsequently dumped) in the
			74	*      order in which the names are encountered during the namespace load;
			75	*
			76	*      All namespace searching is linear in this implementation, but
			77	*      could be easily modified to support any improved search
			78	*      algorithm.  However, the linear search was chosen for simplicity
			79	*      and because the trees are small and the other interpreter
			80	*      execution overhead is relatively high.
			81	*
			82	******************************************************************************/
			83
			84	acpi_status
2089E3	0		85	acpi_ns_search_node(u32 target_name,
			86	struct acpi_namespace_node *node,
			87	acpi_object_type type,
			88	struct acpi_namespace_node **return_node)
			89	{
			90	struct acpi_namespace_node *next_node;
			91
			92	ACPI_FUNCTION_TRACE("ns_search_node");
			93
			94	#ifdef ACPI_DEBUG_OUTPUT
			95	if (ACPI_LV_NAMES & acpi_dbg_level) {
			96	char *scope_name;
			97
			98	scope_name = acpi_ns_get_external_pathname(node);
			99	if (scope_name) {
			100	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			101	"Searching %s (%p) For [%4.4s] (%s)\n",
			102	scope_name, node, ACPI_CAST_PTR(char,
			103	&target_name),
			104	acpi_ut_get_type_name(type)));
			105
			106	ACPI_MEM_FREE(scope_name);
			107	}
			108	}
			109	#endif
			110
			111	/*
			112	* Search for name at this namespace level, which is to say that we
			113	* must search for the name among the children of this object
			114	*/
			115	next_node = node->child;
6136E4	708216		116	while (next_node) {
			117	/* Check for match against the name */
			118
1204E3	6016E4		119	if (next_node->name.integer == target_name) {
			120	/* Resolve a control method alias if any */
			121
			122	if (acpi_ns_get_type(next_node) ==
0	1204E3	-	123	ACPI_TYPE_LOCAL_METHOD_ALIAS) {
			124	next_node =
			125	ACPI_CAST_PTR(struct acpi_namespace_node,
			126	next_node->object);
			127	}
			128
			129	/*
			130	* Found matching entry.
			131	*/
			132	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			133	"Name [%4.4s] (%s) %p found in scope [%4.4s] %p\n",
			134	ACPI_CAST_PTR(char, &target_name),
			135	acpi_ut_get_type_name(next_node->
			136	type),
			137	next_node,
			138	acpi_ut_get_node_name(node), node));
			139
			140	*return_node = next_node;
1204E3			141	return_ACPI_STATUS(AE_OK);
			142	}
			143
			144	/*
			145	* The last entry in the list points back to the parent,
			146	* so a flag is used to indicate the end-of-list
			147	*/
177185	5998E4		148	if (next_node->flags & ANOBJ_END_OF_PEER_LIST) {
			149	/* Searched entire list, we are done */
			150
177185			151	break;
			152	}
			153
			154	/* Didn't match name, move on to the next peer object */
			155
			156	next_node = next_node->peer;
			157	}
			158
			159	/* Searched entire namespace level, not found */
			160
			161	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			162	"Name [%4.4s] (%s) not found in search in scope [%4.4s] %p first child %p\n",
			163	ACPI_CAST_PTR(char, &target_name),
			164	acpi_ut_get_type_name(type),
			165	acpi_ut_get_node_name(node), node, node->child));
			166
885401			167	return_ACPI_STATUS(AE_NOT_FOUND);
			168	}
			169
			170	/*******************************************************************************
			171	*
			172	* FUNCTION:    acpi_ns_search_parent_tree
			173	*
			174	* PARAMETERS:  target_name     - Ascii ACPI name to search for
			175	*              Node            - Starting node where search will begin
			176	*              Type            - Object type to match
			177	*              return_node     - Where the matched Node is returned
			178	*
			179	* RETURN:      Status
			180	*
			181	* DESCRIPTION: Called when a name has not been found in the current namespace
			182	*              level.  Before adding it or giving up, ACPI scope rules require
			183	*              searching enclosing scopes in cases identified by acpi_ns_local().
			184	*
			185	*              "A name is located by finding the matching name in the current
			186	*              name space, and then in the parent name space. If the parent
			187	*              name space does not contain the name, the search continues
			188	*              recursively until either the name is found or the name space
			189	*              does not have a parent (the root of the name space).  This
			190	*              indicates that the name is not found" (From ACPI Specification,
			191	*              section 5.3)
			192	*
			193	******************************************************************************/
			194
			195	static acpi_status
708186	0		196	acpi_ns_search_parent_tree(u32 target_name,
			197	struct acpi_namespace_node *node,
			198	acpi_object_type type,
			199	struct acpi_namespace_node **return_node)
			200	{
			201	acpi_status status;
			202	struct acpi_namespace_node *parent_node;
			203
			204	ACPI_FUNCTION_TRACE("ns_search_parent_tree");
			205
			206	parent_node = acpi_ns_get_parent_node(node);
			207
			208	/*
			209	* If there is no parent (i.e., we are at the root) or type is "local",
			210	* we won't be searching the parent tree.
			211	*/
0	708186	-	212	if (!parent_node) {
			213	ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "[%4.4s] has no parent\n",
			214	ACPI_CAST_PTR(char, &target_name)));
0		-	215	return_ACPI_STATUS(AE_NOT_FOUND);
			216	}
			217
0	708186	-	218	if (acpi_ns_local(type)) {
			219	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			220	"[%4.4s] type [%s] must be local to this scope (no parent search)\n",
			221	ACPI_CAST_PTR(char, &target_name),
			222	acpi_ut_get_type_name(type)));
0		-	223	return_ACPI_STATUS(AE_NOT_FOUND);
			224	}
			225
			226	/* Search the parent tree */
			227
			228	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			229	"Searching parent [%4.4s] for [%4.4s]\n",
			230	acpi_ut_get_node_name(parent_node),
			231	ACPI_CAST_PTR(char, &target_name)));
			232
			233	/*
			234	* Search parents until target is found or we have backed up to the root
			235	*/
779664	948		236	while (parent_node) {
			237	/*
			238	* Search parent scope.  Use TYPE_ANY because we don't care about the
			239	* object type at this point, we only care about the existence of
			240	* the actual name we are searching for.  Typechecking comes later.
			241	*/
			242	status = acpi_ns_search_node(target_name, parent_node,
			243	ACPI_TYPE_ANY, return_node);
707238	72426		244	if (ACPI_SUCCESS(status)) {
707238			245	return_ACPI_STATUS(status);
			246	}
			247
			248	/*
			249	* Not found here, go up another level
			250	* (until we reach the root)
			251	*/
			252	parent_node = acpi_ns_get_parent_node(parent_node);
			253	}
			254
			255	/* Not found in parent tree */
			256
948			257	return_ACPI_STATUS(AE_NOT_FOUND);
			258	}
			259
			260	/*******************************************************************************
			261	*
			262	* FUNCTION:    acpi_ns_search_and_enter
			263	*
			264	* PARAMETERS:  target_name         - Ascii ACPI name to search for (4 chars)
			265	*              walk_state          - Current state of the walk
			266	*              Node                - Starting node where search will begin
			267	*              interpreter_mode    - Add names only in ACPI_MODE_LOAD_PASS_x.
			268	*                                    Otherwise,search only.
			269	*              Type                - Object type to match
			270	*              Flags               - Flags describing the search restrictions
			271	*              return_node         - Where the Node is returned
			272	*
			273	* RETURN:      Status
			274	*
			275	* DESCRIPTION: Search for a name segment in a single namespace level,
			276	*              optionally adding it if it is not found.  If the passed
			277	*              Type is not Any and the type previously stored in the
			278	*              entry was Any (i.e. unknown), update the stored type.
			279	*
			280	*              In ACPI_IMODE_EXECUTE, search only.
			281	*              In other modes, search and add if not found.
			282	*
			283	******************************************************************************/
			284
			285	acpi_status
1309E3	0		286	acpi_ns_search_and_enter(u32 target_name,
			287	struct acpi_walk_state *walk_state,
			288	struct acpi_namespace_node *node,
			289	acpi_interpreter_mode interpreter_mode,
			290	acpi_object_type type,
			291	u32 flags, struct acpi_namespace_node **return_node)
			292	{
			293	acpi_status status;
			294	struct acpi_namespace_node *new_node;
			295
			296	ACPI_FUNCTION_TRACE("ns_search_and_enter");
			297
			298	/* Parameter validation */
			299
0	1309E3	-	300	if (!node || !target_name || !return_node) {
0		-	300	T || _ || _
0		-	300	F || T || _
0		-	300	F || F || T
	1309E3		300	F || F || F
			301	ACPI_ERROR((AE_INFO,
			302	"Null param: Node %p Name %X return_node %p",
			303	node, target_name, return_node));
0		-	304	return_ACPI_STATUS(AE_BAD_PARAMETER);
			305	}
			306
			307	/* Name must consist of printable characters */
			308
0	1309E3	-	309	if (!acpi_ut_valid_acpi_name(target_name)) {
			310	ACPI_ERROR((AE_INFO, "Bad character in ACPI Name: %X",
			311	target_name));
0		-	312	return_ACPI_STATUS(AE_BAD_CHARACTER);
			313	}
			314
			315	/* Try to find the name in the namespace level specified by the caller */
			316
			317	*return_node = ACPI_ENTRY_NOT_FOUND;
			318	status = acpi_ns_search_node(target_name, node, type, return_node);
497308	812591		319	if (status != AE_NOT_FOUND) {
			320	/*
			321	* If we found it AND the request specifies that a find is an error,
			322	* return the error
			323	*/
0	497308	-	324	if ((status == AE_OK) && (flags & ACPI_NS_ERROR_IF_FOUND)) {
0		-	324	(T) && (T)
	497308		324	(T) && (F)
	0	-	324	(F) && (_)
			325	status = AE_ALREADY_EXISTS;
			326	}
			327
			328	/*
			329	* Either found it or there was an error
			330	* -- finished either way
			331	*/
497308			332	return_ACPI_STATUS(status);
			333	}
			334
			335	/*
			336	* The name was not found.  If we are NOT performing the first pass
			337	* (name entry) of loading the namespace, search the parent tree (all the
			338	* way to the root if necessary.) We don't want to perform the parent
			339	* search when the namespace is actually being loaded.  We want to perform
			340	* the search when namespace references are being resolved (load pass 2)
			341	* and during the execution phase.
			342	*/
			343	if ((interpreter_mode != ACPI_IMODE_LOAD_PASS1) &&
708186	104405		344	(flags & ACPI_NS_SEARCH_PARENT)) {
708186			344	(T) && (T)
	100049		344	(T) && (F)
	4356		344	(F) && (_)
			345	/*
			346	* Not found at this level - search parent tree according to the
			347	* ACPI specification
			348	*/
			349	status =
			350	acpi_ns_search_parent_tree(target_name, node, type,
			351	return_node);
707238	948		352	if (ACPI_SUCCESS(status)) {
707238			353	return_ACPI_STATUS(status);
			354	}
			355	}
			356
			357	/*
			358	* In execute mode, just search, never add names.  Exit now.
			359	*/
100883	4470		360	if (interpreter_mode == ACPI_IMODE_EXECUTE) {
			361	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
			362	"%4.4s Not found in %p [Not adding]\n",
			363	ACPI_CAST_PTR(char, &target_name), node));
			364
100883			365	return_ACPI_STATUS(AE_NOT_FOUND);
			366	}
			367
			368	/* Create the new named object */
			369
			370	new_node = acpi_ns_create_node(target_name);
0	4470	-	371	if (!new_node) {
0		-	372	return_ACPI_STATUS(AE_NO_MEMORY);
			373	}
			374
			375	/* Install the new object into the parent's list of children */
			376
			377	acpi_ns_install_node(walk_state, node, new_node, type);
			378	*return_node = new_node;
			379
4470			380	return_ACPI_STATUS(AE_OK);
			381	}
***TER 71% (42/59) of SOURCE FILE nssearch.c

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last | Top