tables.h File Reference

#include <uacpi/internal/context.h>
#include <uacpi/internal/interpreter.h>
#include <uacpi/types.h>
#include <uacpi/status.h>
#include <uacpi/tables.h>

Include dependency graph for tables.h:

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

Go to the source code of this file.

Classes
struct	uacpi_installed_table

Macros
#define	UACPI_PRI_TBL_HDR   "'%.4s' (OEM ID '%.6s' OEM Table ID '%.8s')"
#define	UACPI_FMT_TBL_HDR(hdr)   (hdr)->signature, (hdr)->oemid, (hdr)->oem_table_id

Typedefs
typedef uacpi_iteration_decision(*	uacpi_installed_table_iteration_callback) (void *user, struct uacpi_installed_table *tbl, uacpi_size idx)
typedef uacpi_bool(*	uacpi_table_match_callback) (struct uacpi_installed_table *tbl)

Functions
uacpi_status	uacpi_initialize_tables (void)
void	uacpi_deinitialize_tables (void)
uacpi_bool	uacpi_signatures_match (const void *const lhs, const void *const rhs)
uacpi_status	uacpi_check_table_signature (void *table, const uacpi_char *expect)
uacpi_status	uacpi_verify_table_checksum (void *table, uacpi_size size, uacpi_u8 *out_flags)
uacpi_status	uacpi_table_install_physical_with_origin (uacpi_phys_addr phys, enum uacpi_table_origin origin, uacpi_table *out_table)
uacpi_status	uacpi_table_install_with_origin (void *virt, enum uacpi_table_origin origin, uacpi_table *out_table)
void	uacpi_table_mark_as_loaded (uacpi_size idx)
uacpi_status	uacpi_table_load_with_cause (uacpi_size idx, enum uacpi_table_load_cause cause)
uacpi_status	uacpi_for_each_installed_table (uacpi_size base_idx, uacpi_installed_table_iteration_callback, void *user)
uacpi_status	uacpi_table_match (uacpi_size base_idx, uacpi_table_match_callback, uacpi_table *out_table)

Macro Definition Documentation

UACPI_FMT_TBL_HDR

#define UACPI_FMT_TBL_HDR

(

hdr

)

(hdr)->signature, (hdr)->oemid, (hdr)->oem_table_id

Definition at line 59 of file tables.h.

UACPI_PRI_TBL_HDR

#define UACPI_PRI_TBL_HDR   "'%.4s' (OEM ID '%.6s' OEM Table ID '%.8s')"

Definition at line 58 of file tables.h.

Typedef Documentation

uacpi_installed_table_iteration_callback

typedef uacpi_iteration_decision(* uacpi_installed_table_iteration_callback) (void *user, struct uacpi_installed_table *tbl, uacpi_size idx)

Definition at line 44 of file tables.h.

uacpi_table_match_callback

typedef uacpi_bool(* uacpi_table_match_callback) (struct uacpi_installed_table *tbl)

Definition at line 51 of file tables.h.

Function Documentation

uacpi_check_table_signature()

uacpi_status uacpi_check_table_signature	(	void *	table,
		const uacpi_char *	expect
	)

Definition at line 469 of file tables.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
 
    if (!uacpi_signatures_match(table, expect)) {
        enum uacpi_log_level lvl = UACPI_LOG_WARN;
        struct acpi_sdt_hdr *hdr = table;
 
        if (uacpi_check_flag(UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL)) {
            ret = UACPI_STATUS_INVALID_SIGNATURE;
            lvl = UACPI_LOG_ERROR;
        }
 
        uacpi_log_lvl(
            lvl,
            "invalid table "UACPI_PRI_TBL_HDR" signature (expected '%.4s')",
            UACPI_FMT_TBL_HDR(hdr), expect
        );
    }
 
    return ret;
}

Referenced by initialize_from_rxsdt(), and table_install_physical_with_origin_unlocked().

uacpi_deinitialize_tables()

void uacpi_deinitialize_tables

(

void

)

Definition at line 351 of file tables.c.

{
    uacpi_size i;
 
    for (i = 0; i < table_array_size(&tables); ++i) {
        struct uacpi_installed_table *tbl = table_array_at(&tables, i);
 
        switch (tbl->origin) {
#ifndef UACPI_BAREBONES_MODE
        case UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL:
            uacpi_free(tbl->ptr, tbl->hdr.length);
            break;
#endif
        case UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL:
        case UACPI_TABLE_ORIGIN_HOST_PHYSICAL:
            if (tbl->reference_count != 0)
                uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
            break;
        default:
            break;
        }
    }
 
    if (early_table_access) {
        uacpi_memzero(&tables, sizeof(tables));
        early_table_access = UACPI_FALSE;
    } else {
        table_array_clear(&tables);
    }
 
    installation_handler = UACPI_NULL;
    fadt_available = UACPI_FALSE;
 
#ifndef UACPI_BAREBONES_MODE
    if (table_mutex)
        uacpi_kernel_free_mutex(table_mutex);
 
    table_mutex = UACPI_NULL;
#endif
}

Referenced by uacpi_setup_early_table_access(), and uacpi_state_reset().

uacpi_for_each_installed_table()

uacpi_status uacpi_for_each_installed_table	(	uacpi_size	base_idx,
		uacpi_installed_table_iteration_callback	cb,
		void *	user
	)

Definition at line 971 of file tables.c.

{
    uacpi_status ret;
    uacpi_size idx;
    struct uacpi_installed_table *tbl;
    uacpi_iteration_decision dec;
 
    ENSURE_TABLES_ONLINE();
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    for (idx = base_idx; idx < table_array_size(&tables); ++idx) {
        tbl = table_array_at(&tables, idx);
 
        if (uacpi_unlikely(skip_due_to_bad_csum(tbl)))
            continue;
 
        dec = cb(user, tbl, idx);
        if (dec == UACPI_ITERATION_DECISION_BREAK)
            break;
    }
 
    uacpi_release_native_mutex_may_be_null(table_mutex);
    return ret;
}

Referenced by find_table(), uacpi_initialize_tables(), and uacpi_table_match().

uacpi_initialize_tables()

uacpi_status uacpi_initialize_tables

(

void

)

Definition at line 279 of file tables.c.

{
    if (early_table_access) {
        uacpi_size num_tables;
 
        uacpi_for_each_installed_table(0, warn_if_early_referenced, UACPI_NULL);
 
        // Reallocate the user buffer into a normal heap array
        num_tables = table_array_size(&tables);
        if (num_tables > table_array_inline_capacity(&tables)) {
            void *new_buf;
 
            /*
             * Allocate a new buffer with size equal to exactly the number of
             * dynamic tables (that live in the user provided temporary buffer).
             */
            num_tables -= table_array_inline_capacity(&tables);
            new_buf = uacpi_kernel_alloc(
                sizeof(struct uacpi_installed_table) * num_tables
            );
            if (uacpi_unlikely(new_buf == UACPI_NULL))
                return UACPI_STATUS_OUT_OF_MEMORY;
 
            uacpi_memcpy(new_buf, tables.dynamic_storage,
                         sizeof(struct uacpi_installed_table) * num_tables);
            tables.dynamic_storage = new_buf;
            tables.dynamic_capacity = num_tables;
        } else {
            /*
             * User-provided temporary buffer was not used at all, just remove
             * any references to it.
             */
            tables.dynamic_storage = UACPI_NULL;
            tables.dynamic_capacity = 0;
        }
 
        early_table_access = UACPI_FALSE;
    } else {
        uacpi_status ret;
 
        ret = initialize_from_rsdp();
        if (uacpi_unlikely_error(ret))
            return ret;
    }
 
    if (!uacpi_is_hardware_reduced()) {
        struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
        uacpi_table tbl;
 
        if (fadt->x_firmware_ctrl) {
            uacpi_status ret;
 
            ret = table_install_physical_with_origin_unlocked(
                fadt->x_firmware_ctrl, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
                ACPI_FACS_SIGNATURE, &tbl
            );
            if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
                               ret != UACPI_STATUS_OVERRIDDEN))
                return ret;
 
            g_uacpi_rt_ctx.facs = tbl.ptr;
        }
    }
 
    table_mutex = uacpi_kernel_create_mutex();
    if (uacpi_unlikely(table_mutex == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_initialize().

uacpi_signatures_match()

uacpi_bool uacpi_signatures_match	(	const void *const	lhs,
		const void *const	rhs
	)

Definition at line 464 of file tables.c.

{
    return uacpi_memcmp(lhs, rhs, sizeof(uacpi_object_name)) == 0;
}

Referenced by do_search_tables(), match_ssdt_or_psdt(), uacpi_check_table_signature(), and verify_and_install_table().

uacpi_table_install_physical_with_origin()

uacpi_status uacpi_table_install_physical_with_origin	(	uacpi_phys_addr	phys,
		enum uacpi_table_origin	origin,
		uacpi_table *	out_table
	)

Definition at line 865 of file tables.c.

{
    uacpi_status ret;
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = table_install_physical_with_origin_unlocked(
        phys, origin, UACPI_NULL, out_table
    );
    uacpi_release_native_mutex_may_be_null(table_mutex);
 
    return ret;
}

Referenced by initialize_from_rxsdt(), and uacpi_table_install_physical().

uacpi_table_install_with_origin()

uacpi_status uacpi_table_install_with_origin	(	void *	virt,
		enum uacpi_table_origin	origin,
		uacpi_table *	out_table
	)

Definition at line 935 of file tables.c.

{
    uacpi_status ret;
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = table_install_with_origin_unlocked(virt, origin, out_table);
 
    uacpi_release_native_mutex_may_be_null(table_mutex);
    return ret;
}

Referenced by handle_load(), and uacpi_table_install().

uacpi_table_load_with_cause()

uacpi_status uacpi_table_load_with_cause	(	uacpi_size	idx,
		enum uacpi_table_load_cause	cause
	)

Definition at line 1280 of file tables.c.

{
    uacpi_status ret;
    struct table_ctl_request req = {
        .type = TABLE_CTL_SET_FLAGS | TABLE_CTL_VALIDATE_CLEAR_FLAGS |
                TABLE_CTL_GET,
        .set = UACPI_TABLE_LOADED,
        .expect_clear = UACPI_TABLE_LOADED,
    };
 
    ret = table_ctl(idx, &req);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_execute_table(req.out_tbl, cause);
 
    req.type = TABLE_CTL_PUT;
    table_ctl(idx, &req);
    return ret;
}

Referenced by uacpi_namespace_load(), and uacpi_table_load().

uacpi_table_mark_as_loaded()

void uacpi_table_mark_as_loaded

(

uacpi_size

idx

)

Definition at line 1308 of file tables.c.

{
    struct table_ctl_request req = {
        .type = TABLE_CTL_SET_FLAGS, .set = UACPI_TABLE_LOADED
    };
 
    table_ctl(idx, &req);
}

Referenced by handle_load(), and handle_load_table().

uacpi_table_match()

uacpi_status uacpi_table_match	(	uacpi_size	base_idx,
		uacpi_table_match_callback	cb,
		uacpi_table *	out_table
	)

Definition at line 1081 of file tables.c.

{
    uacpi_status ret;
    struct table_search_ctx ctx = { 0 };
 
    ctx.match_cb = cb;
    ctx.search_type = SEARCH_TYPE_MATCH;
    ctx.out_table = out_table;
    ctx.status = UACPI_STATUS_NOT_FOUND;
 
    ret = uacpi_for_each_installed_table(base_idx, do_search_tables, &ctx);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return ctx.status;
}

Referenced by uacpi_namespace_load().

uacpi_verify_table_checksum()

uacpi_status uacpi_verify_table_checksum	(	void *	table,
		uacpi_size	size,
		uacpi_u8 *	out_flags
	)

Definition at line 426 of file tables.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
    uacpi_u8 csum;
 
    csum = table_checksum(table, size);
    if (out_flags != UACPI_NULL)
        *out_flags |= UACPI_TABLE_CSUM_CHECKED;
 
    if (uacpi_unlikely(csum != 0)) {
        enum uacpi_log_level lvl = UACPI_LOG_WARN;
        struct acpi_sdt_hdr *hdr = table;
 
        if (out_flags != UACPI_NULL)
            *out_flags |= UACPI_TABLE_CSUM_BAD;
 
        if (uacpi_check_flag(UACPI_FLAG_BAD_CSUM_FATAL)) {
            ret = UACPI_STATUS_BAD_CHECKSUM;
            lvl = UACPI_LOG_ERROR;
        }
 
        uacpi_log_lvl(
            lvl, "invalid table "UACPI_PRI_TBL_HDR" checksum %d!",
            UACPI_FMT_TBL_HDR(hdr), csum
        );
    }
 
    return ret;
}

Referenced by initialize_from_rxsdt(), table_ref_unlocked(), and verify_and_install_table().