|
@@ -165,24 +165,27 @@ struct acpi_namespace_node *acpi_ns_get_next_node_typed(acpi_object_type type,
|
|
|
* max_depth - Depth to which search is to reach
|
|
|
* Flags - Whether to unlock the NS before invoking
|
|
|
* the callback routine
|
|
|
- * user_function - Called when an object of "Type" is found
|
|
|
- * Context - Passed to user function
|
|
|
- * return_value - from the user_function if terminated early.
|
|
|
- * Otherwise, returns NULL.
|
|
|
+ * pre_order_visit - Called during tree pre-order visit
|
|
|
+ * when an object of "Type" is found
|
|
|
+ * post_order_visit - Called during tree post-order visit
|
|
|
+ * when an object of "Type" is found
|
|
|
+ * Context - Passed to user function(s) above
|
|
|
+ * return_value - from the user_function if terminated
|
|
|
+ * early. Otherwise, returns NULL.
|
|
|
* RETURNS: Status
|
|
|
*
|
|
|
* DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
|
|
|
* starting (and ending) at the node specified by start_handle.
|
|
|
- * The user_function is called whenever a node that matches
|
|
|
- * the type parameter is found. If the user function returns
|
|
|
+ * The callback function is called whenever a node that matches
|
|
|
+ * the type parameter is found. If the callback function returns
|
|
|
* a non-zero value, the search is terminated immediately and
|
|
|
* this value is returned to the caller.
|
|
|
*
|
|
|
* The point of this procedure is to provide a generic namespace
|
|
|
* walk routine that can be called from multiple places to
|
|
|
- * provide multiple services; the User Function can be tailored
|
|
|
- * to each task, whether it is a print function, a compare
|
|
|
- * function, etc.
|
|
|
+ * provide multiple services; the callback function(s) can be
|
|
|
+ * tailored to each task, whether it is a print function,
|
|
|
+ * a compare function, etc.
|
|
|
*
|
|
|
******************************************************************************/
|
|
|
|
|
@@ -191,7 +194,8 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
|
|
acpi_handle start_node,
|
|
|
u32 max_depth,
|
|
|
u32 flags,
|
|
|
- acpi_walk_callback user_function,
|
|
|
+ acpi_walk_callback pre_order_visit,
|
|
|
+ acpi_walk_callback post_order_visit,
|
|
|
void *context, void **return_value)
|
|
|
{
|
|
|
acpi_status status;
|
|
@@ -200,6 +204,7 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
|
|
struct acpi_namespace_node *parent_node;
|
|
|
acpi_object_type child_type;
|
|
|
u32 level;
|
|
|
+ u8 node_previously_visited = FALSE;
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(ns_walk_namespace);
|
|
|
|
|
@@ -212,7 +217,7 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
|
|
/* Null child means "get first node" */
|
|
|
|
|
|
parent_node = start_node;
|
|
|
- child_node = NULL;
|
|
|
+ child_node = acpi_ns_get_next_node(parent_node, NULL);
|
|
|
child_type = ACPI_TYPE_ANY;
|
|
|
level = 1;
|
|
|
|
|
@@ -221,102 +226,129 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
|
|
* started. When Level is zero, the loop is done because we have
|
|
|
* bubbled up to (and passed) the original parent handle (start_entry)
|
|
|
*/
|
|
|
- while (level > 0) {
|
|
|
+ while (level > 0 && child_node) {
|
|
|
+ status = AE_OK;
|
|
|
|
|
|
- /* Get the next node in this scope. Null if not found */
|
|
|
+ /* Found next child, get the type if we are not searching for ANY */
|
|
|
|
|
|
- status = AE_OK;
|
|
|
- child_node = acpi_ns_get_next_node(parent_node, child_node);
|
|
|
- if (child_node) {
|
|
|
+ if (type != ACPI_TYPE_ANY) {
|
|
|
+ child_type = child_node->type;
|
|
|
+ }
|
|
|
|
|
|
- /* Found next child, get the type if we are not searching for ANY */
|
|
|
+ /*
|
|
|
+ * Ignore all temporary namespace nodes (created during control
|
|
|
+ * method execution) unless told otherwise. These temporary nodes
|
|
|
+ * can cause a race condition because they can be deleted during
|
|
|
+ * the execution of the user function (if the namespace is
|
|
|
+ * unlocked before invocation of the user function.) Only the
|
|
|
+ * debugger namespace dump will examine the temporary nodes.
|
|
|
+ */
|
|
|
+ if ((child_node->flags & ANOBJ_TEMPORARY) &&
|
|
|
+ !(flags & ACPI_NS_WALK_TEMP_NODES)) {
|
|
|
+ status = AE_CTRL_DEPTH;
|
|
|
+ }
|
|
|
|
|
|
- if (type != ACPI_TYPE_ANY) {
|
|
|
- child_type = child_node->type;
|
|
|
- }
|
|
|
+ /* Type must match requested type */
|
|
|
|
|
|
+ else if (child_type == type) {
|
|
|
/*
|
|
|
- * Ignore all temporary namespace nodes (created during control
|
|
|
- * method execution) unless told otherwise. These temporary nodes
|
|
|
- * can cause a race condition because they can be deleted during
|
|
|
- * the execution of the user function (if the namespace is
|
|
|
- * unlocked before invocation of the user function.) Only the
|
|
|
- * debugger namespace dump will examine the temporary nodes.
|
|
|
+ * Found a matching node, invoke the user callback function.
|
|
|
+ * Unlock the namespace if flag is set.
|
|
|
*/
|
|
|
- if ((child_node->flags & ANOBJ_TEMPORARY) &&
|
|
|
- !(flags & ACPI_NS_WALK_TEMP_NODES)) {
|
|
|
- status = AE_CTRL_DEPTH;
|
|
|
+ if (flags & ACPI_NS_WALK_UNLOCK) {
|
|
|
+ mutex_status =
|
|
|
+ acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
|
|
|
+ if (ACPI_FAILURE(mutex_status)) {
|
|
|
+ return_ACPI_STATUS(mutex_status);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- /* Type must match requested type */
|
|
|
-
|
|
|
- else if (child_type == type) {
|
|
|
- /*
|
|
|
- * Found a matching node, invoke the user callback function.
|
|
|
- * Unlock the namespace if flag is set.
|
|
|
- */
|
|
|
- if (flags & ACPI_NS_WALK_UNLOCK) {
|
|
|
- mutex_status =
|
|
|
- acpi_ut_release_mutex
|
|
|
- (ACPI_MTX_NAMESPACE);
|
|
|
- if (ACPI_FAILURE(mutex_status)) {
|
|
|
- return_ACPI_STATUS
|
|
|
- (mutex_status);
|
|
|
- }
|
|
|
+ /*
|
|
|
+ * Invoke the user function, either pre-order or post-order
|
|
|
+ * or both.
|
|
|
+ */
|
|
|
+ if (!node_previously_visited) {
|
|
|
+ if (pre_order_visit) {
|
|
|
+ status =
|
|
|
+ pre_order_visit(child_node, level,
|
|
|
+ context,
|
|
|
+ return_value);
|
|
|
}
|
|
|
+ } else {
|
|
|
+ if (post_order_visit) {
|
|
|
+ status =
|
|
|
+ post_order_visit(child_node, level,
|
|
|
+ context,
|
|
|
+ return_value);
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- status =
|
|
|
- user_function(child_node, level, context,
|
|
|
- return_value);
|
|
|
-
|
|
|
- if (flags & ACPI_NS_WALK_UNLOCK) {
|
|
|
- mutex_status =
|
|
|
- acpi_ut_acquire_mutex
|
|
|
- (ACPI_MTX_NAMESPACE);
|
|
|
- if (ACPI_FAILURE(mutex_status)) {
|
|
|
- return_ACPI_STATUS
|
|
|
- (mutex_status);
|
|
|
- }
|
|
|
+ if (flags & ACPI_NS_WALK_UNLOCK) {
|
|
|
+ mutex_status =
|
|
|
+ acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
|
|
+ if (ACPI_FAILURE(mutex_status)) {
|
|
|
+ return_ACPI_STATUS(mutex_status);
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- switch (status) {
|
|
|
- case AE_OK:
|
|
|
- case AE_CTRL_DEPTH:
|
|
|
+ switch (status) {
|
|
|
+ case AE_OK:
|
|
|
+ case AE_CTRL_DEPTH:
|
|
|
|
|
|
- /* Just keep going */
|
|
|
- break;
|
|
|
+ /* Just keep going */
|
|
|
+ break;
|
|
|
|
|
|
- case AE_CTRL_TERMINATE:
|
|
|
+ case AE_CTRL_TERMINATE:
|
|
|
|
|
|
- /* Exit now, with OK status */
|
|
|
+ /* Exit now, with OK status */
|
|
|
|
|
|
- return_ACPI_STATUS(AE_OK);
|
|
|
+ return_ACPI_STATUS(AE_OK);
|
|
|
|
|
|
- default:
|
|
|
+ default:
|
|
|
|
|
|
- /* All others are valid exceptions */
|
|
|
+ /* All others are valid exceptions */
|
|
|
|
|
|
- return_ACPI_STATUS(status);
|
|
|
- }
|
|
|
+ return_ACPI_STATUS(status);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Depth first search: Attempt to go down another level in the
|
|
|
+ * namespace if we are allowed to. Don't go any further if we have
|
|
|
+ * reached the caller specified maximum depth or if the user
|
|
|
+ * function has specified that the maximum depth has been reached.
|
|
|
+ */
|
|
|
+ if (!node_previously_visited &&
|
|
|
+ (level < max_depth) && (status != AE_CTRL_DEPTH)) {
|
|
|
+ if (child_node->child) {
|
|
|
+
|
|
|
+ /* There is at least one child of this node, visit it */
|
|
|
+
|
|
|
+ level++;
|
|
|
+ parent_node = child_node;
|
|
|
+ child_node =
|
|
|
+ acpi_ns_get_next_node(parent_node, NULL);
|
|
|
+ continue;
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- /*
|
|
|
- * Depth first search: Attempt to go down another level in the
|
|
|
- * namespace if we are allowed to. Don't go any further if we have
|
|
|
- * reached the caller specified maximum depth or if the user
|
|
|
- * function has specified that the maximum depth has been reached.
|
|
|
- */
|
|
|
- if ((level < max_depth) && (status != AE_CTRL_DEPTH)) {
|
|
|
- if (child_node->child) {
|
|
|
+ /* No more children, re-visit this node */
|
|
|
|
|
|
- /* There is at least one child of this node, visit it */
|
|
|
+ if (!node_previously_visited) {
|
|
|
+ node_previously_visited = TRUE;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
|
|
|
- level++;
|
|
|
- parent_node = child_node;
|
|
|
- child_node = NULL;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
+ /* No more children, visit peers */
|
|
|
+
|
|
|
+ child_node = acpi_ns_get_next_node(parent_node, child_node);
|
|
|
+ if (child_node) {
|
|
|
+ node_previously_visited = FALSE;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* No peers, re-visit parent */
|
|
|
+
|
|
|
+ else {
|
|
|
/*
|
|
|
* No more children of this node (acpi_ns_get_next_node failed), go
|
|
|
* back upwards in the namespace tree to the node's parent.
|
|
@@ -324,6 +356,8 @@ acpi_ns_walk_namespace(acpi_object_type type,
|
|
|
level--;
|
|
|
child_node = parent_node;
|
|
|
parent_node = acpi_ns_get_parent_node(parent_node);
|
|
|
+
|
|
|
+ node_previously_visited = TRUE;
|
|
|
}
|
|
|
}
|
|
|
|