namespace.c File Reference

#include <uacpi/namespace.h>
#include <uacpi/internal/namespace.h>
#include <uacpi/internal/types.h>
#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/interpreter.h>
#include <uacpi/internal/opregion.h>
#include <uacpi/internal/log.h>
#include <uacpi/internal/utilities.h>
#include <uacpi/internal/mutex.h>
#include <uacpi/kernel_api.h>

Include dependency graph for namespace.c:

Go to the source code of this file.

Macros
#define	UACPI_REV_VALUE   2
#define	UACPI_OS_VALUE   "Microsoft Windows NT"
#define	MAKE_PREDEFINED(c0, c1, c2, c3)

Enumerations
enum	action { ACTION_REACQUIRE , ACTION_PUT }

Functions
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)
static uacpi_object *	make_object_for_predefined (enum uacpi_predefined_namespace ns)
static void	namespace_node_detach_object (uacpi_namespace_node *node)
static void	free_namespace_node (uacpi_handle handle)
uacpi_status	uacpi_initialize_namespace (void)
void	uacpi_deinitialize_namespace (void)
uacpi_namespace_node *	uacpi_namespace_root (void)
uacpi_namespace_node *	uacpi_namespace_get_predefined (enum uacpi_predefined_namespace ns)
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_install (uacpi_namespace_node *parent, uacpi_namespace_node *node)
uacpi_bool	uacpi_namespace_node_is_alias (uacpi_namespace_node *node)
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_node_uninstall (uacpi_namespace_node *node)
uacpi_namespace_node *	uacpi_namespace_node_find_sub_node (uacpi_namespace_node *parent, uacpi_object_name name)
static uacpi_object_name	segment_to_name (const uacpi_char **string, uacpi_size *in_out_size)
uacpi_status	uacpi_namespace_node_resolve (uacpi_namespace_node *parent, const uacpi_char *path, enum uacpi_should_lock should_lock, enum uacpi_may_search_above_parent may_search_above_parent, enum uacpi_permanent_only permanent_only, uacpi_namespace_node **out_node)
uacpi_status	uacpi_namespace_node_find (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_namespace_node **out_node)
uacpi_status	uacpi_namespace_node_resolve_from_aml_namepath (uacpi_namespace_node *scope, const uacpi_char *path, uacpi_namespace_node **out_node)
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_typed (const uacpi_namespace_node *node, uacpi_object_type_bits type_mask, uacpi_object **out_obj)
uacpi_status	uacpi_namespace_node_acquire_object (const uacpi_namespace_node *node, uacpi_object **out_obj)
static uacpi_status	object_mutate_refcount (uacpi_object *obj, void(*cb)(uacpi_object *))
uacpi_status	uacpi_namespace_node_reacquire_object (uacpi_object *obj)
uacpi_status	uacpi_namespace_node_release_object (uacpi_object *obj)
uacpi_object_name	uacpi_namespace_node_name (const 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_type (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_is_one_of (const uacpi_namespace_node *node, uacpi_object_type_bits type_mask, uacpi_bool *out)
uacpi_status	uacpi_namespace_node_is (const uacpi_namespace_node *node, uacpi_object_type type, uacpi_bool *out)
uacpi_status	uacpi_namespace_do_for_each_child (uacpi_namespace_node *node, uacpi_iteration_callback descending_callback, uacpi_iteration_callback ascending_callback, uacpi_object_type_bits type_mask, uacpi_u32 max_depth, enum uacpi_should_lock should_lock, enum uacpi_permanent_only permanent_only, void *user)
uacpi_status	uacpi_namespace_for_each_child_simple (uacpi_namespace_node *parent, uacpi_iteration_callback callback, void *user)
uacpi_status	uacpi_namespace_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, void *user)
uacpi_status	uacpi_namespace_node_next_typed (uacpi_namespace_node *parent, uacpi_namespace_node **iter, uacpi_object_type_bits type_mask)
uacpi_status	uacpi_namespace_node_next (uacpi_namespace_node *parent, uacpi_namespace_node **iter)
uacpi_size	uacpi_namespace_node_depth (const uacpi_namespace_node *node)
uacpi_namespace_node *	uacpi_namespace_node_parent (uacpi_namespace_node *node)
const uacpi_char *	uacpi_namespace_node_generate_absolute_path (const uacpi_namespace_node *node)
void	uacpi_free_absolute_path (const uacpi_char *path)

Variables
static uacpi_namespace_node	predefined_namespaces [UACPI_PREDEFINED_NAMESPACE_MAX+1]
static struct uacpi_rw_lock	namespace_lock

Macro Definition Documentation

MAKE_PREDEFINED

#define MAKE_PREDEFINED	(		c0,
			c1,
			c2,
			c3
	)

Value:

    {                                            \
        .name.text = { c0, c1, c2, c3 },         \
        .flags = UACPI_NAMESPACE_NODE_PREDEFINED \
    }

Definition at line 17 of file namespace.c.

UACPI_OS_VALUE

#define UACPI_OS_VALUE   "Microsoft Windows NT"

Definition at line 15 of file namespace.c.

UACPI_REV_VALUE

#define UACPI_REV_VALUE   2

Definition at line 14 of file namespace.c.

Enumeration Type Documentation

action

enum action

Enumerator
ACTION_REACQUIRE
ACTION_PUT

Definition at line 707 of file namespace.c.

            {
    ACTION_REACQUIRE,
    ACTION_PUT,
};

Function Documentation

free_namespace_node()

static void free_namespace_node ( uacpi_handle  handle )

static

Definition at line 143 of file namespace.c.

{
    uacpi_namespace_node *node = handle;
 
    if (uacpi_likely(!uacpi_namespace_node_is_predefined(node))) {
        uacpi_free(node, sizeof(*node));
        return;
    }
 
    node->flags = UACPI_NAMESPACE_NODE_PREDEFINED;
    node->object = UACPI_NULL;
    node->parent = UACPI_NULL;
    node->child = UACPI_NULL;
    node->next = UACPI_NULL;
}

Referenced by uacpi_deinitialize_namespace(), and uacpi_namespace_node_unref().

make_object_for_predefined()

static uacpi_object * make_object_for_predefined ( enum uacpi_predefined_namespace  ns )

static

Definition at line 59 of file namespace.c.

{
    uacpi_object *obj;
 
    switch (ns) {
    case UACPI_PREDEFINED_NAMESPACE_ROOT:
        /*
         * The real root object is stored in the global context, whereas the \
         * node gets a placeholder uninitialized object instead. This is to
         * protect against CopyObject(JUNK, \‍), so that all of the opregion and
         * notify handlers are preserved if AML decides to do that.
         */
        g_uacpi_rt_ctx.root_object = uacpi_create_object(UACPI_OBJECT_DEVICE);
        if (uacpi_unlikely(g_uacpi_rt_ctx.root_object == UACPI_NULL))
            return UACPI_NULL;
 
        obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
        break;
 
    case UACPI_PREDEFINED_NAMESPACE_OS:
        obj = uacpi_create_object(UACPI_OBJECT_STRING);
        if (uacpi_unlikely(obj == UACPI_NULL))
            return obj;
 
        obj->buffer->text = uacpi_kernel_alloc(sizeof(UACPI_OS_VALUE));
        if (uacpi_unlikely(obj->buffer->text == UACPI_NULL)) {
            uacpi_object_unref(obj);
            return UACPI_NULL;
        }
 
        obj->buffer->size = sizeof(UACPI_OS_VALUE);
        uacpi_memcpy(obj->buffer->text, UACPI_OS_VALUE, obj->buffer->size);
        break;
 
    case UACPI_PREDEFINED_NAMESPACE_REV:
        obj = uacpi_create_object(UACPI_OBJECT_INTEGER);
        if (uacpi_unlikely(obj == UACPI_NULL))
            return obj;
 
        obj->integer = UACPI_REV_VALUE;
        break;
 
    case UACPI_PREDEFINED_NAMESPACE_GL:
        obj = uacpi_create_object(UACPI_OBJECT_MUTEX);
        if (uacpi_likely(obj != UACPI_NULL)) {
            uacpi_shareable_ref(obj->mutex);
            g_uacpi_rt_ctx.global_lock_mutex = obj->mutex;
        }
        break;
 
    case UACPI_PREDEFINED_NAMESPACE_OSI:
        obj = uacpi_create_object(UACPI_OBJECT_METHOD);
        if (uacpi_unlikely(obj == UACPI_NULL))
            return obj;
 
        obj->method->native_call = UACPI_TRUE;
        obj->method->handler = uacpi_osi;
        obj->method->args = 1;
        break;
 
    default:
        obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
        break;
    }
 
    return obj;
}

Referenced by uacpi_initialize_namespace().

namespace_node_detach_object()

static void namespace_node_detach_object ( uacpi_namespace_node *  node )

static

Definition at line 129 of file namespace.c.

{
    uacpi_object *object;
 
    object = uacpi_namespace_node_get_object(node);
    if (object != UACPI_NULL) {
        if (object->type == UACPI_OBJECT_OPERATION_REGION)
            uacpi_opregion_uninstall_handler(node);
 
        uacpi_object_unref(node->object);
        node->object = UACPI_NULL;
    }
}

Referenced by uacpi_deinitialize_namespace(), and uacpi_namespace_node_uninstall().

object_mutate_refcount()

static uacpi_status object_mutate_refcount ( uacpi_object *  obj, void(*)(uacpi_object *)  cb  )

static

Definition at line 712 of file namespace.c.

{
   uacpi_status ret = UACPI_STATUS_OK;
 
    if (uacpi_likely(!uacpi_object_is(obj, UACPI_OBJECT_REFERENCE))) {
        cb(obj);
        return ret;
    }
 
    /*
     * Reference objects must be (un)referenced under at least a read lock, as
     * this requires walking down the entire reference chain and dropping each
     * object ref-count by 1. This might race with the interpreter and
     * object_replace_child in case an object in the chain is CopyObject'ed
     * into.
     */
    ret = uacpi_namespace_read_lock();
    if (uacpi_unlikely_error(ret))
        return ret;
 
    cb(obj);
 
    uacpi_namespace_read_unlock();
    return ret;
}

Referenced by uacpi_namespace_node_reacquire_object(), and uacpi_namespace_node_release_object().

segment_to_name()

static uacpi_object_name segment_to_name ( const uacpi_char **  string, uacpi_size *  in_out_size  )

static

Definition at line 468 of file namespace.c.

{
    uacpi_object_name out_name;
    const uacpi_char *cursor = *string;
    uacpi_size offset, bytes_left = *in_out_size;
 
    for (offset = 0; offset < 4; offset++) {
        if (bytes_left < 1 || *cursor == '.') {
            out_name.text[offset] = '_';
            continue;
        }
 
        out_name.text[offset] = *cursor++;
        bytes_left--;
    }
 
    *string = cursor;
    *in_out_size = bytes_left;
    return out_name;
}

Referenced by uacpi_namespace_node_resolve().

uacpi_deinitialize_namespace()

void uacpi_deinitialize_namespace

(

void

)

Definition at line 208 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_free_absolute_path()

void uacpi_free_absolute_path

(

const uacpi_char *

path

)

Definition at line 1074 of file namespace.c.

{
    uacpi_free_dynamic_string(path);
}

Referenced by exec_op().

uacpi_initialize_namespace()

uacpi_status uacpi_initialize_namespace

(

void

)

Definition at line 159 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 *	node,
		uacpi_iteration_callback	descending_callback,
		uacpi_iteration_callback	ascending_callback,
		uacpi_object_type_bits	type_mask,
		uacpi_u32	max_depth,
		enum uacpi_should_lock	should_lock,
		enum uacpi_permanent_only	permanent_only,
		void *	user
	)

Definition at line 834 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_or_unreg_all_opregions(), 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_for_each_child()

uacpi_status uacpi_namespace_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,
		void *	user
	)

Definition at line 948 of file namespace.c.

{
    return uacpi_namespace_do_for_each_child(
        parent, descending_callback, ascending_callback, type_mask, max_depth,
        UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, user
    );
}

Referenced by uacpi_find_devices_at(), and uacpi_namespace_initialize().

uacpi_namespace_for_each_child_simple()

uacpi_status uacpi_namespace_for_each_child_simple	(	uacpi_namespace_node *	parent,
		uacpi_iteration_callback	callback,
		void *	user
	)

Definition at line 938 of file namespace.c.

{
    return uacpi_namespace_do_for_each_child(
        parent, callback, UACPI_NULL, UACPI_OBJECT_ANY_BIT, UACPI_MAX_DEPTH_ANY,
        UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, user
    );
}

uacpi_namespace_get_predefined()

uacpi_namespace_node * uacpi_namespace_get_predefined

(

enum uacpi_predefined_namespace

ns

)

Definition at line 272 of file namespace.c.

{
    if (uacpi_unlikely(ns > UACPI_PREDEFINED_NAMESPACE_MAX)) {
        uacpi_warn("requested invalid predefined namespace %d\n", ns);
        return UACPI_NULL;
    }
 
    return &predefined_namespaces[ns];
}

Referenced by do_sta_ini(), eval_sst(), initialize_gpes(), sanitize_device_and_find_gpe(), and uacpi_namespace_initialize().

uacpi_namespace_node_acquire_object()

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

Definition at line 698 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 670 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 284 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_depth()

uacpi_size uacpi_namespace_node_depth

(

const uacpi_namespace_node *

node

)

Definition at line 1015 of file namespace.c.

{
    uacpi_size depth = 0;
 
    while (node->parent) {
        depth++;
        node = node->parent;
    }
 
    return depth;
}

Referenced by uacpi_namespace_node_generate_absolute_path().

uacpi_namespace_node_find()

uacpi_status uacpi_namespace_node_find	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_namespace_node **	out_node
	)

Definition at line 623 of file namespace.c.

{
    return uacpi_namespace_node_resolve(
        parent, path, UACPI_SHOULD_LOCK_YES, UACPI_MAY_SEARCH_ABOVE_PARENT_NO,
        UACPI_PERMANENT_ONLY_YES, out_node
    );
}

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 448 of file namespace.c.

{
    if (parent == UACPI_NULL)
        parent = uacpi_namespace_root();
 
    uacpi_namespace_node *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_generate_absolute_path()

const uacpi_char * uacpi_namespace_node_generate_absolute_path

(

const uacpi_namespace_node *

node

)

Definition at line 1034 of file namespace.c.

{
    uacpi_size depth, offset;
    uacpi_size bytes_needed;
    uacpi_char *path;
 
    depth = uacpi_namespace_node_depth(node) + 1;
 
    // \ only needs 1 byte, the rest is 4 bytes
    bytes_needed = 1 + (depth - 1) * sizeof(uacpi_object_name);
 
    // \ and the first NAME don't need a '.', every other segment does
    bytes_needed += depth > 2 ? depth - 2 : 0;
 
    // Null terminator
    bytes_needed += 1;
 
    path = uacpi_kernel_alloc(bytes_needed);
    if (uacpi_unlikely(path == UACPI_NULL))
        return path;
 
    path[0] = '\\';
 
    offset = bytes_needed - 1;
    path[offset] = '\0';
 
    while (node != uacpi_namespace_root()) {
        offset -= sizeof(uacpi_object_name);
        uacpi_memcpy(&path[offset], node->name.text, sizeof(uacpi_object_name));
 
        node = node->parent;
        if (node != uacpi_namespace_root())
            path[--offset] = '.';
    }
 
    return path;
}

Referenced by exec_op(), handle_notify(), trace_invalid_return_type(), trace_method_abort(), trace_named_object_lookup_or_creation_failure(), trace_region_io(), uacpi_dispatch_opregion_io(), uacpi_eval_dstate_method_template(), and uacpi_trace_region_error().

uacpi_namespace_node_get_object()

uacpi_object * uacpi_namespace_node_get_object

(

const uacpi_namespace_node *

node

)

Definition at line 646 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(), region_install_handler(), region_run_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 654 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(), extract_handlers(), handle_special_field(), region_run_reg(), region_uninstall_handler(), 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 302 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\n",
                   node->name.text);
        return UACPI_STATUS_NAMESPACE_NODE_DANGLING;
    }
 
    if (parent->child == UACPI_NULL) {
        parent->child = node;
    } else {
        uacpi_namespace_node *prev = parent->child;
 
        while (prev->next != UACPI_NULL)
            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()

uacpi_status uacpi_namespace_node_is	(	const uacpi_namespace_node *	node,
		uacpi_object_type	type,
		uacpi_bool *	out
	)

Definition at line 825 of file namespace.c.

{
    return uacpi_namespace_node_is_one_of(
        node, 1u << type, out
    );
}

Referenced by eval_resource_helper(), uacpi_install_gpe_block(), uacpi_setup_gpe_for_wake(), and uacpi_uninstall_gpe_block().

uacpi_namespace_node_is_alias()

uacpi_bool uacpi_namespace_node_is_alias

(

uacpi_namespace_node *

node

)

Definition at line 331 of file namespace.c.

{
    return node->flags & UACPI_NAMESPACE_NODE_FLAG_ALIAS;
}

Referenced by do_sta_ini().

uacpi_namespace_node_is_dangling()

uacpi_bool uacpi_namespace_node_is_dangling

(

uacpi_namespace_node *

node

)

Definition at line 336 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()

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

Definition at line 808 of file namespace.c.

{
    uacpi_status ret;
 
    ret = uacpi_namespace_read_lock();
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_namespace_node_is_one_of_unlocked(node,type_mask, out);
 
    uacpi_namespace_read_unlock();
    return ret;
}

Referenced by uacpi_namespace_node_is().

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 790 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().

uacpi_namespace_node_is_predefined()

uacpi_bool uacpi_namespace_node_is_predefined

(

uacpi_namespace_node *

node

)

Definition at line 346 of file namespace.c.

{
    return node->flags & UACPI_NAMESPACE_NODE_PREDEFINED;
}

Referenced by free_namespace_node().

uacpi_namespace_node_is_temporary()

uacpi_bool uacpi_namespace_node_is_temporary

(

uacpi_namespace_node *

node

)

Definition at line 341 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(), and uacpi_namespace_node_resolve().

uacpi_namespace_node_name()

uacpi_object_name uacpi_namespace_node_name

(

const uacpi_namespace_node *

node

)

Definition at line 752 of file namespace.c.

{
    return node->name;
}

Referenced by async_run_gpe_handler(), uacpi_eval_cid(), uacpi_eval_hid(), uacpi_eval_uid(), and uacpi_get_namespace_node_info().

uacpi_namespace_node_next()

uacpi_status uacpi_namespace_node_next	(	uacpi_namespace_node *	parent,
		uacpi_namespace_node **	iter
	)

Definition at line 1006 of file namespace.c.

{
    return uacpi_namespace_node_next_typed(
        parent, iter, UACPI_OBJECT_ANY_BIT
    );
}

uacpi_namespace_node_next_typed()

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

Definition at line 960 of file namespace.c.

{
    uacpi_status ret;
    uacpi_bool is_one_of;
    uacpi_namespace_node *node;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    if (uacpi_unlikely(parent == UACPI_NULL && *iter == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    ret = uacpi_namespace_read_lock();
    if (uacpi_unlikely_error(ret))
        return ret;
 
    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;
    }
 
    uacpi_namespace_read_unlock();
    if (node == UACPI_NULL)
        return UACPI_STATUS_NOT_FOUND;
 
    if (uacpi_likely_success(ret))
        *iter = node;
    return ret;
}

Referenced by uacpi_namespace_node_next().

uacpi_namespace_node_parent()

uacpi_namespace_node * uacpi_namespace_node_parent

(

uacpi_namespace_node *

node

)

Definition at line 1027 of file namespace.c.

{
    return node->parent;
}

uacpi_namespace_node_reacquire_object()

uacpi_status uacpi_namespace_node_reacquire_object

(

uacpi_object *

obj

)

Definition at line 740 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 747 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 *	parent,
		const uacpi_char *	path,
		enum uacpi_should_lock	should_lock,
		enum uacpi_may_search_above_parent	may_search_above_parent,
		enum uacpi_permanent_only	permanent_only,
		uacpi_namespace_node **	out_node
	)

Definition at line 491 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'\n", 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'\n",
                   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(), region_run_reg(), uacpi_eval(), uacpi_namespace_node_find(), and uacpi_namespace_node_resolve_from_aml_namepath().

uacpi_namespace_node_resolve_from_aml_namepath()

uacpi_status uacpi_namespace_node_resolve_from_aml_namepath	(	uacpi_namespace_node *	scope,
		const uacpi_char *	path,
		uacpi_namespace_node **	out_node
	)

Definition at line 634 of file namespace.c.

{
    return uacpi_namespace_node_resolve(
        scope, path, UACPI_SHOULD_LOCK_YES, UACPI_MAY_SEARCH_ABOVE_PARENT_YES,
        UACPI_PERMANENT_ONLY_YES, out_node
    );
}

Referenced by uacpi_object_resolve_as_aml_namepath().

uacpi_namespace_node_type()

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

Definition at line 774 of file namespace.c.

{
    uacpi_status ret;
 
    ret = uacpi_namespace_read_lock();
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_namespace_node_type_unlocked(node, out_type);
 
    uacpi_namespace_read_unlock();
    return ret;
}

Referenced by do_sta_ini(), and pci_region_attach().

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 757 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 351 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\n",
                   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)\n",
            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\n",
                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 297 of file namespace.c.

{
    uacpi_shareable_unref_and_delete_if_last(node, free_namespace_node);
}

Referenced by 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 39 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 44 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_root()

uacpi_namespace_node * uacpi_namespace_root

(

void

)

Definition at line 267 of file namespace.c.

{
    return &predefined_namespaces[UACPI_PREDEFINED_NAMESPACE_ROOT];
}

Referenced by eval_pts(), eval_wak(), extract_handlers(), find_pci_root(), get_slp_type_for_state(), handle_load(), handle_load_table(), object_replace_child(), resolve_name_string(), uacpi_deinitialize_namespace(), uacpi_execute_table(), uacpi_find_devices(), uacpi_initialize_namespace(), uacpi_install_default_address_space_handlers(), uacpi_install_notify_handler(), uacpi_namespace_initialize(), uacpi_namespace_node_find_sub_node(), uacpi_namespace_node_generate_absolute_path(), uacpi_namespace_node_install(), uacpi_namespace_node_resolve(), uacpi_node_get_address_space_handlers(), uacpi_set_interrupt_model(), uacpi_setup_gpe_for_wake(), uacpi_uninstall_notify_handler(), and update_scope().

uacpi_namespace_write_lock()

uacpi_status uacpi_namespace_write_lock

(

void

)

Definition at line 49 of file namespace.c.

{
    return uacpi_rw_lock_write(&namespace_lock);
}

Referenced by async_run_gpe_handler(), handle_event_ctl(), handle_firmware_request(), handle_stall_or_sleep(), region_uninstall_handler(), 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_opregion_attach(), uacpi_reg_all_opregions(), uacpi_uninstall_address_space_handler(), and upgrade_to_opregion_lock().

uacpi_namespace_write_unlock()

uacpi_status uacpi_namespace_write_unlock

(

void

)

Definition at line 54 of file namespace.c.

{
    return uacpi_rw_unlock_write(&namespace_lock);
}

Referenced by async_run_gpe_handler(), handle_event_ctl(), handle_firmware_request(), handle_stall_or_sleep(), region_uninstall_handler(), 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_opregion_attach(), uacpi_reg_all_opregions(), uacpi_uninstall_address_space_handler(), and upgrade_to_opregion_lock().

Variable Documentation

namespace_lock

struct uacpi_rw_lock namespace_lock

static

Definition at line 37 of file namespace.c.

Referenced by uacpi_deinitialize_namespace(), uacpi_initialize_namespace(), uacpi_namespace_read_lock(), uacpi_namespace_read_unlock(), uacpi_namespace_write_lock(), and uacpi_namespace_write_unlock().

predefined_namespaces

uacpi_namespace_node predefined_namespaces[UACPI_PREDEFINED_NAMESPACE_MAX+1]

static

Initial value:

= {
    [UACPI_PREDEFINED_NAMESPACE_ROOT] = MAKE_PREDEFINED('\\', 0, 0, 0),
    [UACPI_PREDEFINED_NAMESPACE_GPE] = MAKE_PREDEFINED('_', 'G', 'P', 'E'),
    [UACPI_PREDEFINED_NAMESPACE_PR] = MAKE_PREDEFINED('_', 'P', 'R', '_'),
    [UACPI_PREDEFINED_NAMESPACE_SB] = MAKE_PREDEFINED('_', 'S', 'B', '_'),
    [UACPI_PREDEFINED_NAMESPACE_SI] = MAKE_PREDEFINED('_', 'S', 'I', '_'),
    [UACPI_PREDEFINED_NAMESPACE_TZ] = MAKE_PREDEFINED('_', 'T', 'Z', '_'),
    [UACPI_PREDEFINED_NAMESPACE_GL] = MAKE_PREDEFINED('_', 'G', 'L', '_'),
    [UACPI_PREDEFINED_NAMESPACE_OS] = MAKE_PREDEFINED('_', 'O', 'S', '_'),
    [UACPI_PREDEFINED_NAMESPACE_OSI] = MAKE_PREDEFINED('_', 'O', 'S', 'I'),
    [UACPI_PREDEFINED_NAMESPACE_REV] = MAKE_PREDEFINED('_', 'R', 'E', 'V'),
}

Definition at line 24 of file namespace.c.

Referenced by uacpi_initialize_namespace(), uacpi_namespace_get_predefined(), and uacpi_namespace_root().