namespace.h File Reference

#include <uacpi/types.h>
#include <uacpi/internal/shareable.h>
#include <uacpi/status.h>
#include <uacpi/namespace.h>

Include dependency graph for namespace.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	uacpi_namespace_node

Macros
#define	UACPI_NAMESPACE_NODE_FLAG_ALIAS   (1 << 0)
#define	UACPI_NAMESPACE_NODE_FLAG_DANGLING   (1u << 1)
#define	UACPI_NAMESPACE_NODE_FLAG_TEMPORARY   (1u << 2)

Typedefs
typedef struct uacpi_namespace_node	uacpi_namespace_node

Enumerations
enum	uacpi_may_search_above_parent { UACPI_MAY_SEARCH_ABOVE_PARENT_NO , UACPI_MAY_SEARCH_ABOVE_PARENT_YES }
enum	uacpi_permanent_only { UACPI_PERMANENT_ONLY_NO , UACPI_PERMANENT_ONLY_YES }
enum	uacpi_should_lock { UACPI_SHOULD_LOCK_NO , UACPI_SHOULD_LOCK_YES }

Functions
uacpi_status	uacpi_initialize_namespace (void)
void	uacpi_deinitialize_namespace (void)
uacpi_namespace_node *	uacpi_namespace_node_alloc (uacpi_object_name name)
void	uacpi_namespace_node_unref (uacpi_namespace_node *node)
uacpi_status	uacpi_namespace_node_type_unlocked (const uacpi_namespace_node *node, uacpi_object_type *out_type)
uacpi_status	uacpi_namespace_node_is_one_of_unlocked (const uacpi_namespace_node *node, uacpi_object_type_bits type_mask, uacpi_bool *out)
uacpi_status	uacpi_namespace_node_next_typed_unlocked (uacpi_namespace_node *parent, uacpi_namespace_node **iter, uacpi_object_type_bits type_mask)
uacpi_object *	uacpi_namespace_node_get_object (const uacpi_namespace_node *node)
uacpi_object *	uacpi_namespace_node_get_object_typed (const uacpi_namespace_node *node, uacpi_object_type_bits type_mask)
uacpi_status	uacpi_namespace_node_acquire_object (const uacpi_namespace_node *node, uacpi_object **out_obj)
uacpi_status	uacpi_namespace_node_acquire_object_typed (const uacpi_namespace_node *node, uacpi_object_type_bits, uacpi_object **out_obj)
uacpi_status	uacpi_namespace_node_reacquire_object (uacpi_object *obj)
uacpi_status	uacpi_namespace_node_release_object (uacpi_object *obj)
uacpi_status	uacpi_namespace_node_install (uacpi_namespace_node *parent, uacpi_namespace_node *node)
uacpi_status	uacpi_namespace_node_uninstall (uacpi_namespace_node *node)
uacpi_namespace_node *	uacpi_namespace_node_find_sub_node (uacpi_namespace_node *parent, uacpi_object_name name)
uacpi_status	uacpi_namespace_node_resolve (uacpi_namespace_node *scope, const uacpi_char *path, enum uacpi_should_lock, enum uacpi_may_search_above_parent, enum uacpi_permanent_only, uacpi_namespace_node **out_node)
uacpi_status	uacpi_namespace_do_for_each_child (uacpi_namespace_node *parent, uacpi_iteration_callback descending_callback, uacpi_iteration_callback ascending_callback, uacpi_object_type_bits, uacpi_u32 max_depth, enum uacpi_should_lock, enum uacpi_permanent_only, void *user)
uacpi_bool	uacpi_namespace_node_is_dangling (uacpi_namespace_node *node)
uacpi_bool	uacpi_namespace_node_is_temporary (uacpi_namespace_node *node)
uacpi_bool	uacpi_namespace_node_is_predefined (uacpi_namespace_node *node)
uacpi_status	uacpi_namespace_read_lock (void)
uacpi_status	uacpi_namespace_read_unlock (void)
uacpi_status	uacpi_namespace_write_lock (void)
uacpi_status	uacpi_namespace_write_unlock (void)

Macro Definition Documentation

UACPI_NAMESPACE_NODE_FLAG_ALIAS

#define UACPI_NAMESPACE_NODE_FLAG_ALIAS   (1 << 0)

Definition at line 10 of file namespace.h.

UACPI_NAMESPACE_NODE_FLAG_DANGLING

#define UACPI_NAMESPACE_NODE_FLAG_DANGLING   (1u << 1)

Definition at line 19 of file namespace.h.

UACPI_NAMESPACE_NODE_FLAG_TEMPORARY

#define UACPI_NAMESPACE_NODE_FLAG_TEMPORARY   (1u << 2)

Definition at line 25 of file namespace.h.

Typedef Documentation

uacpi_namespace_node

typedef struct uacpi_namespace_node uacpi_namespace_node

Enumeration Type Documentation

uacpi_may_search_above_parent

enum uacpi_may_search_above_parent

Enumerator
UACPI_MAY_SEARCH_ABOVE_PARENT_NO
UACPI_MAY_SEARCH_ABOVE_PARENT_YES

Definition at line 87 of file namespace.h.

                                   {
    UACPI_MAY_SEARCH_ABOVE_PARENT_NO,
    UACPI_MAY_SEARCH_ABOVE_PARENT_YES,
};

uacpi_permanent_only

enum uacpi_permanent_only

Enumerator
UACPI_PERMANENT_ONLY_NO
UACPI_PERMANENT_ONLY_YES

Definition at line 92 of file namespace.h.

                          {
    UACPI_PERMANENT_ONLY_NO,
    UACPI_PERMANENT_ONLY_YES,
};

uacpi_should_lock

enum uacpi_should_lock

Enumerator
UACPI_SHOULD_LOCK_NO
UACPI_SHOULD_LOCK_YES

Definition at line 97 of file namespace.h.

                       {
    UACPI_SHOULD_LOCK_NO,
    UACPI_SHOULD_LOCK_YES,
};

Function Documentation

uacpi_deinitialize_namespace()

void uacpi_deinitialize_namespace

(

void

)

Definition at line 205 of file namespace.c.

{
    uacpi_status ret;
    uacpi_namespace_node *current, *next = UACPI_NULL;
    uacpi_u32 depth = 1;
 
    current = uacpi_namespace_root();
 
    ret = uacpi_namespace_write_lock();
 
    while (depth) {
        next = next == UACPI_NULL ? current->child : next->next;
 
        /*
         * The previous value of 'next' was the last child of this subtree,
         * we can now remove the entire scope of 'current->child'
         */
        if (next == UACPI_NULL) {
            depth--;
 
            // Wipe the subtree
            while (current->child != UACPI_NULL)
                uacpi_namespace_node_uninstall(current->child);
 
            // Reset the pointers back as if this iteration never happened
            next = current;
            current = current->parent;
 
            continue;
        }
 
        /*
         * We have more nodes to process, proceed to the next one, either the
         * child of the 'next' node, if one exists, or its peer
         */
        if (next->child) {
            depth++;
            current = next;
            next = UACPI_NULL;
        }
 
        // This node has no children, move on to its peer
    }
 
    namespace_node_detach_object(uacpi_namespace_root());
    free_namespace_node(uacpi_namespace_root());
 
    if (ret == UACPI_STATUS_OK)
        uacpi_namespace_write_unlock();
 
    uacpi_object_unref(g_uacpi_rt_ctx.root_object);
    g_uacpi_rt_ctx.root_object = UACPI_NULL;
 
    uacpi_mutex_unref(g_uacpi_rt_ctx.global_lock_mutex);
    g_uacpi_rt_ctx.global_lock_mutex = UACPI_NULL;
 
    uacpi_rw_lock_deinit(&namespace_lock);
}

Referenced by uacpi_state_reset().

uacpi_initialize_namespace()

uacpi_status uacpi_initialize_namespace

(

void

)

Definition at line 156 of file namespace.c.

{
    enum uacpi_predefined_namespace ns;
    uacpi_object *obj;
    uacpi_namespace_node *node;
    uacpi_status ret;
 
    ret = uacpi_rw_lock_init(&namespace_lock);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    for (ns = 0; ns <= UACPI_PREDEFINED_NAMESPACE_MAX; ns++) {
        node = &predefined_namespaces[ns];
        uacpi_shareable_init(node);
 
        obj = make_object_for_predefined(ns);
        if (uacpi_unlikely(obj == UACPI_NULL))
            return UACPI_STATUS_OUT_OF_MEMORY;
 
        node->object = uacpi_create_internal_reference(
            UACPI_REFERENCE_KIND_NAMED, obj
        );
        if (uacpi_unlikely(node->object == UACPI_NULL)) {
            uacpi_object_unref(obj);
            return UACPI_STATUS_OUT_OF_MEMORY;
        }
 
        uacpi_object_unref(obj);
    }
 
    for (ns = UACPI_PREDEFINED_NAMESPACE_GPE;
         ns <= UACPI_PREDEFINED_NAMESPACE_MAX; ns++) {
 
        /*
         * Skip the installation of \_OSI if it was disabled by user.
         * We still create the object, but it's not attached to the namespace.
         */
        if (ns == UACPI_PREDEFINED_NAMESPACE_OSI &&
            uacpi_check_flag(UACPI_FLAG_NO_OSI))
            continue;
 
        uacpi_namespace_node_install(
            uacpi_namespace_root(), &predefined_namespaces[ns]
        );
    }
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_initialize().

uacpi_namespace_do_for_each_child()

uacpi_status uacpi_namespace_do_for_each_child	(	uacpi_namespace_node *	parent,
		uacpi_iteration_callback	descending_callback,
		uacpi_iteration_callback	ascending_callback,
		uacpi_object_type_bits	type_mask,
		uacpi_u32	max_depth,
		enum	uacpi_should_lock,
		enum	uacpi_permanent_only,
		void *	user
	)

Definition at line 841 of file namespace.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
    uacpi_iteration_decision decision;
    uacpi_iteration_callback cb;
    uacpi_bool walking_up = UACPI_FALSE, matches = UACPI_FALSE;
    uacpi_u32 depth = 1;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    if (uacpi_unlikely(descending_callback == UACPI_NULL &&
                       ascending_callback == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (uacpi_unlikely(node == UACPI_NULL || max_depth == 0))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (should_lock == UACPI_SHOULD_LOCK_YES) {
        ret = uacpi_namespace_read_lock();
        if (uacpi_unlikely_error(ret))
            return ret;
    }
 
    if (node->child == UACPI_NULL)
        goto out;
 
    node = node->child;
 
    while (depth) {
        uacpi_namespace_node_is_one_of_unlocked(node, type_mask, &matches);
        if (!matches) {
            decision = UACPI_ITERATION_DECISION_CONTINUE;
            goto do_next;
        }
 
        if (permanent_only == UACPI_PERMANENT_ONLY_YES &&
            uacpi_namespace_node_is_temporary(node)) {
            decision = UACPI_ITERATION_DECISION_NEXT_PEER;
            goto do_next;
        }
 
        cb = walking_up ? ascending_callback : descending_callback;
        if (cb != UACPI_NULL) {
            if (should_lock == UACPI_SHOULD_LOCK_YES) {
                ret = uacpi_namespace_read_unlock();
                if (uacpi_unlikely_error(ret))
                    return ret;
            }
 
            decision = cb(user, node, depth);
            if (decision == UACPI_ITERATION_DECISION_BREAK)
                return ret;
 
            if (should_lock == UACPI_SHOULD_LOCK_YES) {
                ret = uacpi_namespace_read_lock();
                if (uacpi_unlikely_error(ret))
                    return ret;
            }
        } else {
            decision = UACPI_ITERATION_DECISION_CONTINUE;
        }
 
    do_next:
        if (walking_up) {
            if (node->next) {
                node = node->next;
                walking_up = UACPI_FALSE;
                continue;
            }
 
            depth--;
            node = node->parent;
            continue;
        }
 
        switch (decision) {
        case UACPI_ITERATION_DECISION_CONTINUE:
            if ((depth != max_depth) && (node->child != UACPI_NULL)) {
                node = node->child;
                depth++;
                continue;
            }
            UACPI_FALLTHROUGH;
        case UACPI_ITERATION_DECISION_NEXT_PEER:
            walking_up = UACPI_TRUE;
            continue;
        default:
            ret = UACPI_STATUS_INVALID_ARGUMENT;
            goto out;
        }
    }
 
out:
    if (should_lock == UACPI_SHOULD_LOCK_YES)
        uacpi_namespace_read_unlock();
    return ret;
}

Referenced by create_gpe_block(), object_replace_child(), reg_all_opregions(), run_orphan_ec_regs(), uacpi_events_match_post_dynamic_table_load(), uacpi_install_address_space_handler_with_flags(), uacpi_namespace_for_each_child(), uacpi_namespace_for_each_child_simple(), and uacpi_uninstall_address_space_handler().

uacpi_namespace_node_acquire_object()

uacpi_status uacpi_namespace_node_acquire_object	(	const uacpi_namespace_node *	node,
		uacpi_object **	out_obj
	)

Definition at line 705 of file namespace.c.

{
    return uacpi_namespace_node_acquire_object_typed(
        node, UACPI_OBJECT_ANY_BIT, out_obj
    );
}

uacpi_namespace_node_acquire_object_typed()

uacpi_status uacpi_namespace_node_acquire_object_typed	(	const uacpi_namespace_node *	node,
		uacpi_object_type_bits	type_mask,
		uacpi_object **	out_obj
	)

Definition at line 677 of file namespace.c.

{
    uacpi_status ret;
    uacpi_object *obj;
 
    ret = uacpi_namespace_read_lock();
    if (uacpi_unlikely_error(ret))
        return ret;
 
    obj = uacpi_namespace_node_get_object(node);
 
    if (uacpi_unlikely(obj == UACPI_NULL) ||
        !uacpi_object_is_one_of(obj, type_mask)) {
        ret = UACPI_STATUS_INVALID_ARGUMENT;
        goto out;
    }
 
    uacpi_object_ref(obj);
    *out_obj = obj;
 
out:
    uacpi_namespace_read_unlock();
    return ret;
}

Referenced by uacpi_install_notify_handler(), uacpi_namespace_node_acquire_object(), and uacpi_uninstall_notify_handler().

uacpi_namespace_node_alloc()

uacpi_namespace_node * uacpi_namespace_node_alloc

(

uacpi_object_name

name

)

Definition at line 281 of file namespace.c.

{
    uacpi_namespace_node *ret;
 
    ret = uacpi_kernel_alloc_zeroed(sizeof(*ret));
    if (uacpi_unlikely(ret == UACPI_NULL))
        return ret;
 
    uacpi_shareable_init(ret);
    ret->name = name;
    return ret;
}

Referenced by resolve_name_string().

uacpi_namespace_node_find_sub_node()

uacpi_namespace_node * uacpi_namespace_node_find_sub_node	(	uacpi_namespace_node *	parent,
		uacpi_object_name	name
	)

Definition at line 453 of file namespace.c.

{
    uacpi_namespace_node *node;
 
    if (parent == UACPI_NULL)
        parent = uacpi_namespace_root();
 
    node = parent->child;
 
    while (node) {
        if (node->name.id == name.id)
            return node;
 
        node = node->next;
    }
 
    return UACPI_NULL;
}

Referenced by resolve_name_string(), and uacpi_namespace_node_resolve().

uacpi_namespace_node_get_object()

uacpi_object * uacpi_namespace_node_get_object

(

const uacpi_namespace_node *

node

)

Definition at line 653 of file namespace.c.

{
    if (node == UACPI_NULL || node->object == UACPI_NULL)
        return UACPI_NULL;
 
    return uacpi_unwrap_internal_reference(node->object);
}

Referenced by do_install_or_uninstall_handler(), do_run_reg(), ensure_is_a_field_unit(), ensure_is_an_op_region(), exec_op(), handle_field_read(), namespace_node_detach_object(), run_orphan_reg(), uacpi_eval(), uacpi_get_namespace_node_info(), uacpi_get_pci_routing_table(), uacpi_initialize_opregion_node(), uacpi_namespace_node_acquire_object_typed(), uacpi_namespace_node_get_object_typed(), uacpi_namespace_node_is_one_of_unlocked(), uacpi_namespace_node_type_unlocked(), uacpi_node_get_address_space_handlers(), and uacpi_notify_all().

uacpi_namespace_node_get_object_typed()

uacpi_object * uacpi_namespace_node_get_object_typed	(	const uacpi_namespace_node *	node,
		uacpi_object_type_bits	type_mask
	)

Definition at line 661 of file namespace.c.

{
    uacpi_object *obj;
 
    obj = uacpi_namespace_node_get_object(node);
    if (uacpi_unlikely(obj == UACPI_NULL))
        return obj;
 
    if (!uacpi_object_is_one_of(obj, type_mask))
        return UACPI_NULL;
 
    return obj;
}

Referenced by async_run_gpe_handler(), do_install_or_uninstall_handler(), extract_handlers(), handle_special_field(), region_uninstall_handler(), run_reg(), uacpi_dispatch_opregion_io(), uacpi_field_unit_get_bit_length(), uacpi_field_unit_get_read_type(), uacpi_notify_all(), uacpi_opregion_attach(), and uacpi_trace_region_error().

uacpi_namespace_node_install()

uacpi_status uacpi_namespace_node_install	(	uacpi_namespace_node *	parent,
		uacpi_namespace_node *	node
	)

Definition at line 299 of file namespace.c.

{
    if (parent == UACPI_NULL)
        parent = uacpi_namespace_root();
 
    if (uacpi_unlikely(uacpi_namespace_node_is_dangling(node))) {
        uacpi_warn("attempting to install a dangling namespace node %.4s",
                   node->name.text);
        return UACPI_STATUS_NAMESPACE_NODE_DANGLING;
    }
 
    if (parent->child == UACPI_NULL) {
        parent->child = node;
    } else {
        uacpi_namespace_node *prev = parent->child;
 
        for (;;) {
            if (uacpi_unlikely(prev->name.id == node->name.id))
                return UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS;
 
            if (prev->next == UACPI_NULL)
                break;
 
            prev = prev->next;
        }
 
        prev->next = node;
    }
 
    node->parent = parent;
    return UACPI_STATUS_OK;
}

Referenced by do_install_node_item(), and uacpi_initialize_namespace().

uacpi_namespace_node_is_dangling()

uacpi_bool uacpi_namespace_node_is_dangling

(

uacpi_namespace_node *

node

)

Definition at line 340 of file namespace.c.

{
    return node->flags & UACPI_NAMESPACE_NODE_FLAG_DANGLING;
}

Referenced by uacpi_namespace_node_install(), uacpi_namespace_node_uninstall(), and uacpi_opregion_attach().

uacpi_namespace_node_is_one_of_unlocked()

uacpi_status uacpi_namespace_node_is_one_of_unlocked	(	const uacpi_namespace_node *	node,
		uacpi_object_type_bits	type_mask,
		uacpi_bool *	out
	)

Definition at line 797 of file namespace.c.

{
    uacpi_object *obj;
 
    if (uacpi_unlikely(node == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    obj = uacpi_namespace_node_get_object(node);
    if (uacpi_unlikely(obj == UACPI_NULL))
        return UACPI_STATUS_NOT_FOUND;
 
    *out = uacpi_object_is_one_of(obj, type_mask);
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_namespace_do_for_each_child(), uacpi_namespace_node_is_one_of(), and uacpi_namespace_node_next_typed_unlocked().

uacpi_namespace_node_is_predefined()

uacpi_bool uacpi_namespace_node_is_predefined

(

uacpi_namespace_node *

node

)

Definition at line 350 of file namespace.c.

{
    return node >= &predefined_namespaces[0] &&
           node <= &predefined_namespaces[UACPI_PREDEFINED_NAMESPACE_MAX];
}

Referenced by free_namespace_node().

uacpi_namespace_node_is_temporary()

uacpi_bool uacpi_namespace_node_is_temporary

(

uacpi_namespace_node *

node

)

Definition at line 345 of file namespace.c.

{
    return node->flags & UACPI_NAMESPACE_NODE_FLAG_TEMPORARY;
}

Referenced by uacpi_namespace_do_for_each_child(), uacpi_namespace_node_next_typed_unlocked(), and uacpi_namespace_node_resolve().

uacpi_namespace_node_next_typed_unlocked()

uacpi_status uacpi_namespace_node_next_typed_unlocked	(	uacpi_namespace_node *	parent,
		uacpi_namespace_node **	iter,
		uacpi_object_type_bits	type_mask
	)

Definition at line 967 of file namespace.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
    uacpi_bool is_one_of;
    uacpi_namespace_node *node;
 
    node = *iter;
    if (node == UACPI_NULL)
        node = parent->child;
    else
        node = node->next;
 
    for (; node != UACPI_NULL; node = node->next) {
        if (uacpi_namespace_node_is_temporary(node))
            continue;
 
        ret = uacpi_namespace_node_is_one_of_unlocked(
            node, type_mask, &is_one_of
        );
        if (uacpi_unlikely_error(ret))
            break;
        if (is_one_of)
            break;
    }
 
    if (node == UACPI_NULL)
        return UACPI_STATUS_NOT_FOUND;
 
    if (uacpi_likely_success(ret))
        *iter = node;
    return ret;
}

Referenced by run_orphan_reg(), and uacpi_namespace_node_next_typed().

uacpi_namespace_node_reacquire_object()

uacpi_status uacpi_namespace_node_reacquire_object

(

uacpi_object *

obj

)

Definition at line 747 of file namespace.c.

{
    return object_mutate_refcount(obj, uacpi_object_ref);
}

uacpi_namespace_node_release_object()

uacpi_status uacpi_namespace_node_release_object

(

uacpi_object *

obj

)

Definition at line 754 of file namespace.c.

{
    return object_mutate_refcount(obj, uacpi_object_unref);
}

Referenced by free_notification_ctx().

uacpi_namespace_node_resolve()

uacpi_status uacpi_namespace_node_resolve	(	uacpi_namespace_node *	scope,
		const uacpi_char *	path,
		enum	uacpi_should_lock,
		enum	uacpi_may_search_above_parent,
		enum	uacpi_permanent_only,
		uacpi_namespace_node **	out_node
	)

Definition at line 498 of file namespace.c.

{
    uacpi_namespace_node *cur_node = parent;
    uacpi_status ret = UACPI_STATUS_OK;
    const uacpi_char *cursor = path;
    uacpi_size bytes_left;
    uacpi_char prev_char = 0;
    uacpi_bool single_nameseg = UACPI_TRUE;
 
    if (cur_node == UACPI_NULL)
        cur_node = uacpi_namespace_root();
 
    bytes_left = uacpi_strlen(path);
 
    if (should_lock == UACPI_SHOULD_LOCK_YES) {
        ret = uacpi_namespace_read_lock();
        if (uacpi_unlikely_error(ret))
            return ret;
    }
 
    for (;;) {
        if (bytes_left == 0)
            goto out;
 
        switch (*cursor) {
        case '\\':
            single_nameseg = UACPI_FALSE;
 
            if (prev_char == '^') {
                ret = UACPI_STATUS_INVALID_ARGUMENT;
                goto out;
            }
 
            cur_node = uacpi_namespace_root();
            break;
        case '^':
            single_nameseg = UACPI_FALSE;
 
            // Tried to go behind root
            if (uacpi_unlikely(cur_node == uacpi_namespace_root())) {
                ret = UACPI_STATUS_INVALID_ARGUMENT;
                goto out;
            }
 
            cur_node = cur_node->parent;
            break;
        default:
            break;
        }
 
        prev_char = *cursor;
 
        switch (prev_char) {
        case '^':
        case '\\':
            cursor++;
            bytes_left--;
            break;
        default:
            break;
        }
 
        if (prev_char != '^')
            break;
    }
 
    while (bytes_left != 0) {
        uacpi_object_name nameseg;
 
        if (*cursor == '.') {
            cursor++;
            bytes_left--;
        }
 
        nameseg = segment_to_name(&cursor, &bytes_left);
        if (bytes_left != 0 && single_nameseg)
            single_nameseg = UACPI_FALSE;
 
        cur_node = uacpi_namespace_node_find_sub_node(cur_node, nameseg);
        if (cur_node == UACPI_NULL) {
            if (may_search_above_parent == UACPI_MAY_SEARCH_ABOVE_PARENT_NO ||
                !single_nameseg)
                goto out;
 
            parent = parent->parent;
 
            while (parent) {
                cur_node = uacpi_namespace_node_find_sub_node(parent, nameseg);
                if (cur_node != UACPI_NULL)
                    goto out;
 
                parent = parent->parent;
            }
 
            goto out;
        }
    }
 
out:
    if (uacpi_unlikely(ret == UACPI_STATUS_INVALID_ARGUMENT)) {
        uacpi_warn("invalid path '%s'", path);
        goto out_read_unlock;
    }
 
    if (cur_node == UACPI_NULL) {
        ret = UACPI_STATUS_NOT_FOUND;
        goto out_read_unlock;
    }
 
    if (uacpi_namespace_node_is_temporary(cur_node) &&
        permanent_only == UACPI_PERMANENT_ONLY_YES) {
        uacpi_warn("denying access to temporary namespace node '%.4s'",
                   cur_node->name.text);
        ret = UACPI_STATUS_DENIED;
        goto out_read_unlock;
    }
 
    if (out_node != UACPI_NULL)
        *out_node = cur_node;
 
out_read_unlock:
    if (should_lock == UACPI_SHOULD_LOCK_YES)
        uacpi_namespace_read_unlock();
    return ret;
}

Referenced by handle_load_table(), run_reg(), uacpi_eval(), uacpi_namespace_node_find(), and uacpi_namespace_node_resolve_from_aml_namepath().

uacpi_namespace_node_type_unlocked()

uacpi_status uacpi_namespace_node_type_unlocked	(	const uacpi_namespace_node *	node,
		uacpi_object_type *	out_type
	)

Definition at line 764 of file namespace.c.

{
    uacpi_object *obj;
 
    if (uacpi_unlikely(node == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    obj = uacpi_namespace_node_get_object(node);
    if (uacpi_unlikely(obj == UACPI_NULL))
        return UACPI_STATUS_NOT_FOUND;
 
    *out_type = obj->type;
    return UACPI_STATUS_OK;
}

Referenced by uacpi_namespace_node_type().

uacpi_namespace_node_uninstall()

uacpi_status uacpi_namespace_node_uninstall

(

uacpi_namespace_node *

node

)

Definition at line 356 of file namespace.c.

{
    uacpi_namespace_node *prev;
 
    if (uacpi_unlikely(uacpi_namespace_node_is_dangling(node))) {
        uacpi_warn("attempting to uninstall a dangling namespace node %.4s",
                   node->name.text);
        return UACPI_STATUS_INTERNAL_ERROR;
    }
 
    /*
     * The way to trigger this is as follows:
     *
     * Method (FOO) {
     *     // Temporary device, will be deleted upon returning from FOO
     *     Device (\BAR) {
     *     }
     *
     *     //
     *     // Load TBL where TBL is:
     *     //     Scope (\BAR) {
     *     //         Name (TEST, 123)
     *     //     }
     *     //
     *     Load(TBL)
     * }
     *
     * In the above example, TEST is a permanent node attached by bad AML to a
     * temporary node created inside the FOO method at \BAR. The cleanup code
     * will attempt to remove the \BAR device upon exit from FOO, but that is
     * no longer possible as there's now a permanent child attached to it.
     */
    if (uacpi_unlikely(node->child != UACPI_NULL)) {
        uacpi_warn(
            "refusing to uninstall node %.4s with a child (%.4s)",
            node->name.text, node->child->name.text
        );
        return UACPI_STATUS_DENIED;
    }
 
    /*
     * Even though namespace_node is reference-counted it still has an 'invalid'
     * state that is entered after it is uninstalled from the global namespace.
     *
     * Reference counting is only needed to combat dangling pointer issues
     * whereas bad AML might try to prolong a local object lifetime by
     * returning it from a method, or CopyObject it somewhere. In that case the
     * namespace node object itself is still alive, but no longer has a valid
     * object associated with it.
     *
     * Example:
     *     Method (BAD) {
     *         OperationRegion(REG, SystemMemory, 0xDEADBEEF, 4)
     *         Field (REG, AnyAcc, NoLock) {
     *             FILD, 8,
     *         }
     *
     *         Return (RefOf(FILD))
     *     }
     *
     *     // Local0 is now the sole owner of the 'FILD' object that under the
     *     // hood is still referencing the 'REG' operation region object from
     *     // the 'BAD' method.
     *     Local0 = DerefOf(BAD())
     *
     * This is done to prevent potential very deep recursion where an object
     * frees a namespace node that frees an attached object that frees a
     * namespace node as well as potential infinite cycles between a namespace
     * node and an object.
     */
    namespace_node_detach_object(node);
 
    prev = node->parent ? node->parent->child : UACPI_NULL;
 
    if (prev == node) {
        node->parent->child = node->next;
    } else {
        while (uacpi_likely(prev != UACPI_NULL) && prev->next != node)
            prev = prev->next;
 
        if (uacpi_unlikely(prev == UACPI_NULL)) {
            uacpi_warn(
                "trying to uninstall a node %.4s (%p) not linked to any peer",
                node->name.text, node
            );
            return UACPI_STATUS_INTERNAL_ERROR;
        }
 
        prev->next = node->next;
    }
 
    node->flags |= UACPI_NAMESPACE_NODE_FLAG_DANGLING;
    uacpi_namespace_node_unref(node);
 
    return UACPI_STATUS_OK;
}

Referenced by call_frame_clear(), and uacpi_deinitialize_namespace().

uacpi_namespace_node_unref()

void uacpi_namespace_node_unref

(

uacpi_namespace_node *

node

)

Definition at line 294 of file namespace.c.

{
    uacpi_shareable_unref_and_delete_if_last(node, free_namespace_node);
}

Referenced by exec_op(), free_field_unit(), free_notification_ctx(), pop_item(), region_uninstall_handler(), and uacpi_namespace_node_uninstall().

uacpi_namespace_read_lock()

uacpi_status uacpi_namespace_read_lock

(

void

)

Definition at line 36 of file namespace.c.

{
    return uacpi_rw_lock_read(&namespace_lock);
}

Referenced by object_mutate_refcount(), uacpi_eval(), uacpi_namespace_do_for_each_child(), uacpi_namespace_node_acquire_object_typed(), uacpi_namespace_node_is_one_of(), uacpi_namespace_node_next_typed(), uacpi_namespace_node_resolve(), and uacpi_namespace_node_type().

uacpi_namespace_read_unlock()

uacpi_status uacpi_namespace_read_unlock

(

void

)

Definition at line 41 of file namespace.c.

{
    return uacpi_rw_unlock_read(&namespace_lock);
}

Referenced by object_mutate_refcount(), uacpi_eval(), uacpi_namespace_do_for_each_child(), uacpi_namespace_node_acquire_object_typed(), uacpi_namespace_node_is_one_of(), uacpi_namespace_node_next_typed(), uacpi_namespace_node_resolve(), and uacpi_namespace_node_type().

uacpi_namespace_write_lock()

uacpi_status uacpi_namespace_write_lock

(

void

)

Definition at line 46 of file namespace.c.

{
    return uacpi_rw_lock_write(&namespace_lock);
}

Referenced by async_run_gpe_handler(), do_run_orphan_ec_reg(), gpe_set_aml_handler(), handle_event_ctl(), handle_firmware_request(), handle_stall_or_sleep(), region_uninstall_handler(), run_orphan_ec_regs(), uacpi_acquire_aml_mutex(), uacpi_deinitialize_namespace(), uacpi_dispatch_opregion_io(), uacpi_eval(), uacpi_events_match_post_dynamic_table_load(), uacpi_execute_table(), uacpi_install_address_space_handler_with_flags(), uacpi_notify_all(), uacpi_opregion_attach(), uacpi_reg_all_opregions(), uacpi_uninstall_address_space_handler(), and uacpi_upgrade_to_opregion_lock().

uacpi_namespace_write_unlock()

uacpi_status uacpi_namespace_write_unlock

(

void

)

Definition at line 51 of file namespace.c.

{
    return uacpi_rw_unlock_write(&namespace_lock);
}

Referenced by async_run_gpe_handler(), do_run_orphan_ec_reg(), gpe_set_aml_handler(), handle_event_ctl(), handle_firmware_request(), handle_stall_or_sleep(), region_uninstall_handler(), run_orphan_ec_regs(), uacpi_acquire_aml_mutex(), uacpi_deinitialize_namespace(), uacpi_dispatch_opregion_io(), uacpi_eval(), uacpi_events_match_post_dynamic_table_load(), uacpi_execute_table(), uacpi_install_address_space_handler_with_flags(), uacpi_notify_all(), uacpi_opregion_attach(), uacpi_reg_all_opregions(), uacpi_uninstall_address_space_handler(), and uacpi_upgrade_to_opregion_lock().