tables.c File Reference

#include <uacpi/internal/tables.h>
#include <uacpi/internal/utilities.h>
#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/interpreter.h>
#include <uacpi/internal/mutex.h>

Include dependency graph for tables.c:

Go to the source code of this file.

Classes
struct	table_search_ctx
struct	table_ctl_request
struct	register_description

Macros
#define	ENSURE_TABLES_ONLINE()
#define	TABLE_CTL_SET_FLAGS   (1 << 0)
#define	TABLE_CTL_CLEAR_FLAGS   (1 << 1)
#define	TABLE_CTL_VALIDATE_SET_FLAGS   (1 << 2)
#define	TABLE_CTL_VALIDATE_CLEAR_FLAGS   (1 << 3)
#define	TABLE_CTL_GET   (1 << 4)
#define	TABLE_CTL_PUT   (1 << 5)
#define	fadt_offset(field)   uacpi_offsetof(struct acpi_fadt, field)

Enumerations
enum	search_type { SEARCH_TYPE_BY_ID , SEARCH_TYPE_MATCH }

Functions
	DYNAMIC_ARRAY_WITH_INLINE_STORAGE (DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(table_array, DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(struct uacpi_installed_table, UACPI_STATIC_TABLE_ARRAY_LEN)
static uacpi_status	table_install_physical_with_origin_unlocked (uacpi_phys_addr phys, enum uacpi_table_origin origin, const uacpi_char *expected_signature, uacpi_table *out_table)
static uacpi_status	table_install_with_origin_unlocked (void *virt, enum uacpi_table_origin origin, uacpi_table *out_table)
	UACPI_PACKED (struct uacpi_rxsdt { struct acpi_sdt_hdr hdr;uacpi_u8 ptr_bytes[];})
static uacpi_status	initialize_from_rxsdt (uacpi_phys_addr rxsdt_addr, uacpi_size entry_size)
static uacpi_status	initialize_from_rsdp (void)
uacpi_size	uacpi_table_count (void)
uacpi_status	uacpi_setup_early_table_access (void *temporary_buffer, uacpi_size buffer_size)
static uacpi_iteration_decision	warn_if_early_referenced (void *user, struct uacpi_installed_table *tbl, uacpi_size idx)
uacpi_status	uacpi_initialize_tables (void)
void	uacpi_deinitialize_tables (void)
uacpi_status	uacpi_set_table_installation_handler (uacpi_table_installation_handler handler)
static uacpi_status	initialize_fadt (const void *)
static uacpi_u8	table_checksum (void *table, uacpi_size size)
uacpi_status	uacpi_verify_table_checksum (void *table, uacpi_size size, uacpi_u8 *out_flags)
static bool	skip_due_to_bad_csum (struct uacpi_installed_table *tbl)
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)
static uacpi_status	table_alloc (struct uacpi_installed_table **out_tbl, uacpi_size *out_idx)
static uacpi_status	get_external_table_header (uacpi_phys_addr phys_addr, struct acpi_sdt_hdr *out_hdr)
static uacpi_status	table_ref_unlocked (struct uacpi_installed_table *tbl)
static uacpi_status	table_unref_unlocked (struct uacpi_installed_table *tbl)
static void	table_info_by_index_unchecked (uacpi_size idx, uacpi_table_info *out_info)
uacpi_status	uacpi_table_info_get_by_index (uacpi_size idx, uacpi_table_info *out_info)
uacpi_status	uacpi_for_each_table (uacpi_table_iteration_callback cb, void *user)
static uacpi_status	verify_and_install_table (struct acpi_sdt_hdr *hdr, uacpi_phys_addr phys_addr, void *virt_addr, enum uacpi_table_origin origin, uacpi_table *out_table)
static uacpi_status	handle_table_override (uacpi_table_installation_disposition disposition, uacpi_u64 address, uacpi_table *out_table)
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)
uacpi_status	uacpi_table_install (void *virt, uacpi_table *out_table)
uacpi_status	uacpi_table_install_physical (uacpi_phys_addr addr, uacpi_table *out_table)
uacpi_status	uacpi_for_each_installed_table (uacpi_size base_idx, uacpi_installed_table_iteration_callback cb, void *user)
static uacpi_iteration_decision	do_search_tables (void *user, struct uacpi_installed_table *tbl, uacpi_size idx)
uacpi_status	uacpi_table_match (uacpi_size base_idx, uacpi_table_match_callback cb, uacpi_table *out_table)
static uacpi_status	find_table (uacpi_size idx, uacpi_size nth, const uacpi_table_identifiers *id, uacpi_table *out_table)
static uacpi_status	find_table_by_signature (const uacpi_char *signature_string, uacpi_size idx, uacpi_size nth, uacpi_table *out_table)
uacpi_status	uacpi_table_find_by_signature_at (const uacpi_char *signature, uacpi_size idx, uacpi_table *out_table)
uacpi_status	uacpi_table_find_nth_by_signature (const uacpi_char *signature, uacpi_size nth, uacpi_table *out_table)
uacpi_status	uacpi_table_find_by_signature (const uacpi_char *signature_string, struct uacpi_table *out_table)
uacpi_status	uacpi_table_find_next_with_same_signature (uacpi_table *in_out_table)
uacpi_status	uacpi_table_find (const uacpi_table_identifiers *id, uacpi_table *out_table)
static uacpi_status	table_ctl (uacpi_size idx, struct table_ctl_request *req)
uacpi_status	uacpi_table_load_with_cause (uacpi_size idx, enum uacpi_table_load_cause cause)
uacpi_status	uacpi_table_load (uacpi_size idx)
void	uacpi_table_mark_as_loaded (uacpi_size idx)
uacpi_status	uacpi_table_get_by_index (uacpi_size idx, uacpi_table *out_table)
uacpi_status	uacpi_table_ref_by_index (uacpi_size index)
uacpi_status	uacpi_table_ref (uacpi_table *tbl)
uacpi_status	uacpi_table_unref_by_index (uacpi_size index)
uacpi_status	uacpi_table_unref (uacpi_table *tbl)
static void	fadt_ensure_correct_revision (struct acpi_fadt *fadt)
static void	gas_init_system_io (struct acpi_gas *gas, uacpi_u64 address, uacpi_u8 byte_size)
static void *	fadt_relative (uacpi_size offset)
static void	convert_registers_to_gas (void)
static void	split_one_block (struct acpi_gas *src, struct acpi_gas *dst0, struct acpi_gas *dst1)
static void	split_event_blocks (void)
uacpi_status	uacpi_table_fadt (struct acpi_fadt **out_fadt)
uacpi_status	uacpi_for_each_subtable (struct acpi_sdt_hdr *hdr, size_t hdr_size, uacpi_subtable_iteration_callback cb, void *user)

Variables
uacpi_u16	fadt_version_sizes []
static struct register_description	fadt_registers []

Macro Definition Documentation

ENSURE_TABLES_ONLINE

#define ENSURE_TABLES_ONLINE

(

)

Value:

    do {                                               \
        if (!early_table_access)                       \
            UACPI_ENSURE_INIT_LEVEL_AT_LEAST(          \
                UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED \
            );                                         \
    } while (0)

Definition at line 29 of file tables.c.

fadt_offset

#define fadt_offset

(

field

)

uacpi_offsetof(struct acpi_fadt, field)

Definition at line 1415 of file tables.c.

TABLE_CTL_CLEAR_FLAGS

#define TABLE_CTL_CLEAR_FLAGS   (1 << 1)

Definition at line 1188 of file tables.c.

TABLE_CTL_GET

#define TABLE_CTL_GET   (1 << 4)

Definition at line 1191 of file tables.c.

TABLE_CTL_PUT

#define TABLE_CTL_PUT   (1 << 5)

Definition at line 1192 of file tables.c.

TABLE_CTL_SET_FLAGS

#define TABLE_CTL_SET_FLAGS   (1 << 0)

Definition at line 1187 of file tables.c.

TABLE_CTL_VALIDATE_CLEAR_FLAGS

#define TABLE_CTL_VALIDATE_CLEAR_FLAGS   (1 << 3)

Definition at line 1190 of file tables.c.

TABLE_CTL_VALIDATE_SET_FLAGS

#define TABLE_CTL_VALIDATE_SET_FLAGS   (1 << 2)

Definition at line 1189 of file tables.c.

Enumeration Type Documentation

search_type

enum search_type

Enumerator
SEARCH_TYPE_BY_ID
SEARCH_TYPE_MATCH

Definition at line 1001 of file tables.c.

                 {
    SEARCH_TYPE_BY_ID,
    SEARCH_TYPE_MATCH,
};

Function Documentation

convert_registers_to_gas()

static void convert_registers_to_gas ( void  )

static

Definition at line 1469 of file tables.c.

{
    uacpi_size i;
    struct register_description *desc;
    struct acpi_gas *gas;
    uacpi_u32 legacy_addr;
    uacpi_u8 length;
 
    for (i = 0; i < UACPI_ARRAY_SIZE(fadt_registers); ++i) {
        desc = &fadt_registers[i];
 
        legacy_addr = *(uacpi_u32*)fadt_relative(desc->offset);
        length = *(uacpi_u8*)fadt_relative(desc->length_offset);
        gas = fadt_relative(desc->xoffset);
 
        if (gas->address)
            continue;
 
        gas_init_system_io(gas, legacy_addr, length);
    }
}

Referenced by initialize_fadt().

do_search_tables()

static uacpi_iteration_decision do_search_tables ( void *  user, struct uacpi_installed_table *  tbl, uacpi_size  idx  )

static

Definition at line 1018 of file tables.c.

{
    struct table_search_ctx *ctx = user;
    uacpi_table *out_table;
    uacpi_status ret;
 
    switch (ctx->search_type) {
    case SEARCH_TYPE_BY_ID: {
        const uacpi_table_identifiers *id = ctx->id;
 
        if (!uacpi_signatures_match(&id->signature, tbl->hdr.signature))
            return UACPI_ITERATION_DECISION_CONTINUE;
        if (id->oemid[0] != '\0' &&
            uacpi_memcmp(id->oemid, tbl->hdr.oemid, sizeof(id->oemid)) != 0)
            return UACPI_ITERATION_DECISION_CONTINUE;
 
        if (id->oem_table_id[0] != '\0' &&
            uacpi_memcmp(id->oem_table_id, tbl->hdr.oem_table_id,
                         sizeof(id->oem_table_id)) != 0)
            return UACPI_ITERATION_DECISION_CONTINUE;
 
        break;
    }
 
    case SEARCH_TYPE_MATCH:
        if (!ctx->match_cb(tbl))
            return UACPI_ITERATION_DECISION_CONTINUE;
        break;
 
    default:
        ctx->status = UACPI_STATUS_INVALID_ARGUMENT;
        return UACPI_ITERATION_DECISION_BREAK;
    }
 
    // Match, but we were asked for an nth table
    if (ctx->to_skip) {
        ctx->to_skip--;
        return UACPI_ITERATION_DECISION_CONTINUE;
    }
 
    ret = table_ref_unlocked(tbl);
    if (uacpi_likely_success(ret)) {
        out_table = ctx->out_table;
        out_table->ptr = tbl->ptr;
        out_table->index = idx;
        ctx->status = ret;
        return UACPI_ITERATION_DECISION_BREAK;
    }
 
    /*
     * Don't abort nor propagate bad checksums, just pretend this table never
     * existed and go on with the search.
     */
    if (ret == UACPI_STATUS_BAD_CHECKSUM)
        return UACPI_ITERATION_DECISION_CONTINUE;
 
    ctx->status = ret;
    return UACPI_ITERATION_DECISION_BREAK;
}

Referenced by find_table(), and uacpi_table_match().

DYNAMIC_ARRAY_WITH_INLINE_STORAGE()

DYNAMIC_ARRAY_WITH_INLINE_STORAGE	(	DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(	table_array,
		DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(	struct uacpi_installed_table,
		UACPI_STATIC_TABLE_ARRAY_LEN
	)

Definition at line 7 of file tables.c.

{
    return early_table_access ||
        g_uacpi_rt_ctx.init_level >= UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED;
}

fadt_ensure_correct_revision()

static void fadt_ensure_correct_revision ( struct acpi_fadt *  fadt )

static

Definition at line 1366 of file tables.c.

{
    uacpi_size current_rev, rev;
 
    current_rev = fadt->hdr.revision;
 
    for (rev = 0; rev < UACPI_ARRAY_SIZE(fadt_version_sizes); ++rev) {
        if (fadt->hdr.length <= fadt_version_sizes[rev])
            break;
    }
 
    if (rev == UACPI_ARRAY_SIZE(fadt_version_sizes)) {
        uacpi_trace(
            "FADT revision (%zu) is likely greater than the last "
            "supported, reducing to %zu", current_rev, rev
        );
        fadt->hdr.revision = rev;
        return;
    }
 
    rev++;
 
    if (current_rev != rev && !(rev == 3 && current_rev == 4)) {
        uacpi_warn(
            "FADT length %u doesn't match expected for revision %zu, "
            "assuming version %zu", fadt->hdr.length, current_rev,
            rev
        );
        fadt->hdr.revision = rev;
    }
}

Referenced by initialize_fadt().

fadt_relative()

static void * fadt_relative ( uacpi_size  offset )

static

Definition at line 1464 of file tables.c.

{
    return ((uacpi_u8*)&g_uacpi_rt_ctx.fadt) + offset;
}

Referenced by convert_registers_to_gas().

find_table()

static uacpi_status find_table ( uacpi_size  idx, uacpi_size  nth, const uacpi_table_identifiers *  id, uacpi_table *  out_table  )

static

Definition at line 1101 of file tables.c.

{
    uacpi_status ret;
    struct table_search_ctx ctx = { 0 };
 
    ctx.id = id;
    ctx.out_table = out_table;
    ctx.search_type = SEARCH_TYPE_BY_ID;
    ctx.to_skip = nth;
    ctx.status = UACPI_STATUS_NOT_FOUND;
 
    ret = uacpi_for_each_installed_table(idx, do_search_tables, &ctx);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return ctx.status;
}

Referenced by find_table_by_signature(), uacpi_table_find(), and uacpi_table_find_next_with_same_signature().

find_table_by_signature()

static uacpi_status find_table_by_signature ( const uacpi_char *  signature_string, uacpi_size  idx, uacpi_size  nth, uacpi_table *  out_table  )

static

Definition at line 1122 of file tables.c.

{
    struct uacpi_table_identifiers id = { 0 };
 
    ENSURE_TABLES_ONLINE();
 
    id.signature.text[0] = signature_string[0];
    id.signature.text[1] = signature_string[1];
    id.signature.text[2] = signature_string[2];
    id.signature.text[3] = signature_string[3];
 
    return find_table(idx, nth, &id, out_table);
}

Referenced by uacpi_table_find_by_signature(), uacpi_table_find_by_signature_at(), and uacpi_table_find_nth_by_signature().

gas_init_system_io()

static void gas_init_system_io ( struct acpi_gas *  gas, uacpi_u64  address, uacpi_u8  byte_size  )

static

Definition at line 1398 of file tables.c.

{
    gas->address = address;
    gas->address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO;
    gas->register_bit_width = UACPI_MIN(255, byte_size * 8);
    gas->register_bit_offset = 0;
    gas->access_size = 0;
}

Referenced by convert_registers_to_gas(), and split_one_block().

get_external_table_header()

static uacpi_status get_external_table_header ( uacpi_phys_addr  phys_addr, struct acpi_sdt_hdr *  out_hdr  )

static

Definition at line 513 of file tables.c.

{
    void *virt;
 
    virt = uacpi_kernel_map(phys_addr, sizeof(*out_hdr));
    if (uacpi_unlikely(virt == UACPI_MAP_FAILED))
        return UACPI_STATUS_MAPPING_FAILED;
 
    uacpi_memcpy(out_hdr, virt, sizeof(*out_hdr));
 
    uacpi_kernel_unmap(virt,  sizeof(*out_hdr));
    return UACPI_STATUS_OK;
}

Referenced by table_install_physical_with_origin_unlocked().

handle_table_override()

static uacpi_status handle_table_override ( uacpi_table_installation_disposition  disposition, uacpi_u64  address, uacpi_table *  out_table  )

static

Definition at line 762 of file tables.c.

{
    uacpi_status ret;
 
    switch (disposition) {
    case UACPI_TABLE_INSTALLATION_DISPOSITON_VIRTUAL_OVERRIDE:
        ret = table_install_with_origin_unlocked(
            UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)address),
            UACPI_TABLE_ORIGIN_HOST_VIRTUAL,
            out_table
        );
        return ret;
    case UACPI_TABLE_INSTALLATION_DISPOSITON_PHYSICAL_OVERRIDE:
        return table_install_physical_with_origin_unlocked(
            (uacpi_phys_addr)address,
            UACPI_TABLE_ORIGIN_HOST_PHYSICAL,
            UACPI_NULL,
            out_table
        );
    default:
        uacpi_error("invalid table installation disposition %d", disposition);
        return UACPI_STATUS_INTERNAL_ERROR;
    }
}

Referenced by table_install_physical_with_origin_unlocked(), and table_install_with_origin_unlocked().

initialize_fadt()

static uacpi_status initialize_fadt ( const void *  virt )

static

Definition at line 1523 of file tables.c.

{
    uacpi_status ret;
    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
    const struct acpi_sdt_hdr *hdr = virt;
 
    /*
     * Here we (roughly) follow ACPICA initialization sequence to make sure we
     * handle potential BIOS quirks with garbage inside FADT correctly.
     */
 
    uacpi_memcpy(fadt, hdr, UACPI_MIN(sizeof(*fadt), hdr->length));
 
#ifndef UACPI_REDUCED_HARDWARE
    g_uacpi_rt_ctx.is_hardware_reduced = fadt->flags & ACPI_HW_REDUCED_ACPI;
#endif
 
    fadt_ensure_correct_revision(fadt);
 
    /*
     * These are reserved prior to version 3, so zero them out to work around
     * BIOS implementations that might dirty these.
     */
    if (fadt->hdr.revision <= 2) {
        fadt->preferred_pm_profile = 0;
        fadt->pstate_cnt = 0;
        fadt->cst_cnt = 0;
        fadt->iapc_boot_arch = 0;
    }
 
    if (!fadt->x_dsdt)
        fadt->x_dsdt = fadt->dsdt;
 
    if (fadt->x_dsdt) {
        ret = table_install_physical_with_origin_unlocked(
            fadt->x_dsdt, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
            ACPI_DSDT_SIGNATURE, UACPI_NULL
        );
        if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
                           ret != UACPI_STATUS_OVERRIDDEN))
            return ret;
    }
 
    /*
     * Unconditionally use 32 bit FACS if it exists, as 64 bit FACS is known
     * to cause issues on some firmware:
     * https://bugzilla.kernel.org/show_bug.cgi?id=74021
     *
     * Note that we don't install it here as FACS needs permanent mapping, which
     * we might not be able to obtain at this point in case of early table
     * access.
     */
    if (fadt->firmware_ctrl)
        fadt->x_firmware_ctrl = fadt->firmware_ctrl;
 
    if (!uacpi_is_hardware_reduced()) {
        convert_registers_to_gas();
#ifndef UACPI_BAREBONES_MODE
        split_event_blocks();
#endif
    }
 
    fadt_available = true;
    return UACPI_STATUS_OK;
}

Referenced by verify_and_install_table().

initialize_from_rsdp()

static uacpi_status initialize_from_rsdp ( void  )

static

Definition at line 171 of file tables.c.

{
    uacpi_status ret;
    uacpi_phys_addr rsdp_phys;
    struct acpi_rsdp *rsdp;
    uacpi_phys_addr rxsdt;
    uacpi_size rxsdt_entry_size;
 
    g_uacpi_rt_ctx.is_rev1 = UACPI_TRUE;
 
    ret = uacpi_kernel_get_rsdp(&rsdp_phys);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    rsdp = uacpi_kernel_map(rsdp_phys, sizeof(struct acpi_rsdp));
    if (rsdp == UACPI_MAP_FAILED)
        return UACPI_STATUS_MAPPING_FAILED;
 
    dump_table_header(rsdp_phys, rsdp);
 
    if (rsdp->revision > 1 && rsdp->xsdt_addr &&
        !uacpi_check_flag(UACPI_FLAG_BAD_XSDT))
    {
        rxsdt = uacpi_truncate_phys_addr_with_warn(rsdp->xsdt_addr);
        rxsdt_entry_size = 8;
    } else {
        rxsdt = (uacpi_phys_addr)rsdp->rsdt_addr;
        rxsdt_entry_size = 4;
    }
 
    uacpi_kernel_unmap(rsdp, sizeof(struct acpi_rsdp));
 
    if (!rxsdt) {
        uacpi_error("both RSDT & XSDT tables are NULL!");
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return initialize_from_rxsdt(rxsdt, rxsdt_entry_size);
}

Referenced by uacpi_initialize_tables(), and uacpi_setup_early_table_access().

initialize_from_rxsdt()

static uacpi_status initialize_from_rxsdt ( uacpi_phys_addr  rxsdt_addr, uacpi_size  entry_size  )

static

Definition at line 111 of file tables.c.

{
    struct uacpi_rxsdt *rxsdt;
    uacpi_size i, entry_bytes, map_len = sizeof(*rxsdt);
    uacpi_phys_addr entry_addr;
    uacpi_status ret;
 
    rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
    if (rxsdt == UACPI_MAP_FAILED)
        return UACPI_STATUS_MAPPING_FAILED;
 
    dump_table_header(rxsdt_addr, rxsdt);
 
    ret = uacpi_check_table_signature(rxsdt,
        entry_size == 8 ? ACPI_XSDT_SIGNATURE : ACPI_RSDT_SIGNATURE);
    if (uacpi_unlikely_error(ret))
        goto error_out;
 
    map_len = rxsdt->hdr.length;
    uacpi_kernel_unmap(rxsdt, sizeof(*rxsdt));
 
    if (uacpi_unlikely(map_len < (sizeof(*rxsdt) + entry_size)))
        return UACPI_STATUS_INVALID_TABLE_LENGTH;
 
    // Make sure length is aligned to entry size so we don't OOB
    entry_bytes = map_len - sizeof(*rxsdt);
    entry_bytes &= ~(entry_size - 1);
 
    rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
    if (uacpi_unlikely(rxsdt == UACPI_MAP_FAILED))
        return UACPI_STATUS_MAPPING_FAILED;
 
    ret = uacpi_verify_table_checksum(rxsdt, map_len, UACPI_NULL);
    if (uacpi_unlikely_error(ret))
        goto error_out;
 
    for (i = 0; i < entry_bytes; i += entry_size) {
        uacpi_u64 entry_phys_addr_large = 0;
        uacpi_memcpy(&entry_phys_addr_large, &rxsdt->ptr_bytes[i], entry_size);
 
        if (!entry_phys_addr_large)
            continue;
 
        entry_addr = uacpi_truncate_phys_addr_with_warn(entry_phys_addr_large);
        ret = uacpi_table_install_physical_with_origin(
            entry_addr, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL, UACPI_NULL
        );
        if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
                           ret != UACPI_STATUS_OVERRIDDEN))
            goto error_out;
    }
 
    ret = UACPI_STATUS_OK;
 
error_out:
    uacpi_kernel_unmap(rxsdt, map_len);
    return ret;
}

Referenced by initialize_from_rsdp().

skip_due_to_bad_csum()

static bool skip_due_to_bad_csum ( struct uacpi_installed_table *  tbl )

static

Definition at line 458 of file tables.c.

{
    return uacpi_check_flag(UACPI_FLAG_BAD_CSUM_FATAL) &&
           (tbl->flags & UACPI_TABLE_CSUM_BAD);
}

Referenced by table_ctl(), table_ref_unlocked(), and uacpi_for_each_installed_table().

split_event_blocks()

static void split_event_blocks ( void  )

static

Definition at line 1508 of file tables.c.

{
    split_one_block(
        &g_uacpi_rt_ctx.fadt.x_pm1a_evt_blk,
        &g_uacpi_rt_ctx.pm1a_status_blk,
        &g_uacpi_rt_ctx.pm1a_enable_blk
    );
    split_one_block(
        &g_uacpi_rt_ctx.fadt.x_pm1b_evt_blk,
        &g_uacpi_rt_ctx.pm1b_status_blk,
        &g_uacpi_rt_ctx.pm1b_enable_blk
    );
}

Referenced by initialize_fadt().

split_one_block()

static void split_one_block ( struct acpi_gas *  src, struct acpi_gas *  dst0, struct acpi_gas *  dst1  )

static

Definition at line 1492 of file tables.c.

{
    uacpi_size byte_length;
 
    if (src->address == 0)
        return;
 
    byte_length = src->register_bit_width / 8;
    byte_length /= 2;
 
    gas_init_system_io(dst0, src->address, byte_length);
    gas_init_system_io(dst1, src->address + byte_length, byte_length);
}

Referenced by split_event_blocks().

table_alloc()

static uacpi_status table_alloc ( struct uacpi_installed_table **  out_tbl, uacpi_size *  out_idx  )

static

Definition at line 492 of file tables.c.

{
    struct uacpi_installed_table *tbl;
 
    if (early_table_access &&
        table_array_size(&tables) == table_array_capacity(&tables)) {
        uacpi_warn("early table access buffer capacity exhausted!");
        return UACPI_STATUS_OUT_OF_MEMORY;
    }
 
    tbl = table_array_alloc(&tables);
    if (uacpi_unlikely(tbl == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    *out_tbl = tbl;
    *out_idx = table_array_size(&tables) - 1;
    return UACPI_STATUS_OK;
}

Referenced by verify_and_install_table().

table_checksum()

static uacpi_u8 table_checksum ( void *  table, uacpi_size  size  )

static

Definition at line 414 of file tables.c.

{
    uacpi_u8 *bytes = table;
    uacpi_u8 csum = 0;
    uacpi_size i;
 
    for (i = 0; i < size; ++i)
        csum += bytes[i];
 
    return csum;
}

Referenced by uacpi_verify_table_checksum().

table_ctl()

static uacpi_status table_ctl ( uacpi_size  idx, struct table_ctl_request *  req  )

static

Definition at line 1205 of file tables.c.

{
    uacpi_status ret;
    struct uacpi_installed_table *tbl;
 
    ENSURE_TABLES_ONLINE();
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (uacpi_unlikely(table_array_size(&tables) <= idx)) {
        uacpi_error(
            "requested invalid table index %zu (%zu tables installed)",
            idx, table_array_size(&tables)
        );
        ret = UACPI_STATUS_INVALID_ARGUMENT;
        goto out;
    }
 
    tbl = table_array_at(&tables, idx);
    if (uacpi_unlikely(uacpi_unlikely(skip_due_to_bad_csum(tbl))))
        return UACPI_STATUS_BAD_CHECKSUM;
 
    if (req->type & TABLE_CTL_VALIDATE_SET_FLAGS) {
        uacpi_u8 mask = req->expect_set;
 
        if (uacpi_unlikely((tbl->flags & mask) != mask)) {
            uacpi_error(
                "unexpected table '%.4s' flags %02X, expected %02X to be set",
                tbl->hdr.signature, tbl->flags, mask
            );
            ret = UACPI_STATUS_INVALID_ARGUMENT;
            goto out;
        }
    }
 
    if (req->type & TABLE_CTL_VALIDATE_CLEAR_FLAGS) {
        uacpi_u8 mask = req->expect_clear;
 
        if (uacpi_unlikely((tbl->flags & mask) != 0)) {
            uacpi_error(
                "unexpected table '%.4s' flags %02X, expected %02X "
                "to be clear", tbl->hdr.signature, tbl->flags, mask
            );
            ret = UACPI_STATUS_ALREADY_EXISTS;
            goto out;
        }
    }
 
    if (req->type & TABLE_CTL_GET) {
        ret = table_ref_unlocked(tbl);
        if (uacpi_unlikely_error(ret))
            goto out;
 
        req->out_tbl = tbl->ptr;
    }
 
    if (req->type & TABLE_CTL_PUT) {
        ret = table_unref_unlocked(tbl);
        if (uacpi_unlikely_error(ret))
            goto out;
    }
 
    if (req->type & TABLE_CTL_SET_FLAGS)
        tbl->flags |= req->set;
    if (req->type & TABLE_CTL_CLEAR_FLAGS)
        tbl->flags &= ~req->clear;
 
out:
    uacpi_release_native_mutex_may_be_null(table_mutex);
    return ret;
}

Referenced by uacpi_table_get_by_index(), uacpi_table_load_with_cause(), uacpi_table_mark_as_loaded(), uacpi_table_ref_by_index(), and uacpi_table_unref_by_index().

table_info_by_index_unchecked()

static void table_info_by_index_unchecked ( uacpi_size  idx, uacpi_table_info *  out_info  )

static

Definition at line 604 of file tables.c.

{
    struct uacpi_installed_table *tbl;
 
    tbl = table_array_at(&tables, idx);
 
    out_info->idx = idx;
    out_info->size = tbl->hdr.length;
    uacpi_memcpy(
        out_info->signature, tbl->hdr.signature,
        sizeof(out_info->signature)
    );
    out_info->origin = tbl->origin;
    out_info->flags = tbl->flags;
    out_info->reference_count = tbl->reference_count;
 
    if (out_info->origin & (UACPI_TABLE_ORIGIN_HOST_VIRTUAL |
                            UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL)) {
        out_info->virt_addr = tbl->ptr;
    } else {
        out_info->phys_addr = tbl->phys_addr;
    }
}

Referenced by uacpi_for_each_table(), and uacpi_table_info_get_by_index().

table_install_physical_with_origin_unlocked()

static uacpi_status table_install_physical_with_origin_unlocked ( uacpi_phys_addr  phys, enum uacpi_table_origin  origin, const uacpi_char *  expected_signature, uacpi_table *  out_table  )

static

Definition at line 790 of file tables.c.

{
    struct acpi_sdt_hdr hdr;
    void *virt = UACPI_NULL;
    uacpi_status ret;
 
    ret = get_external_table_header(phys, &hdr);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (uacpi_unlikely(hdr.length < sizeof(struct acpi_sdt_hdr))) {
        uacpi_warn(
            "bogus table '%.4s' (0x%016"UACPI_PRIX64") size: %u bytes",
            hdr.signature, UACPI_FMT64(phys), hdr.length
        );
    }
 
    if (expected_signature != UACPI_NULL) {
        ret = uacpi_check_table_signature(&hdr, expected_signature);
        if (uacpi_unlikely_error(ret))
            return ret;
    }
 
    if (installation_handler != UACPI_NULL || out_table != UACPI_NULL) {
        virt = uacpi_kernel_map(phys, hdr.length);
        if (uacpi_unlikely(virt == UACPI_MAP_FAILED))
            return UACPI_STATUS_MAPPING_FAILED;
    }
 
    if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL &&
        installation_handler != UACPI_NULL) {
        uacpi_u64 override;
        uacpi_table_installation_disposition disposition;
 
        disposition = installation_handler(virt, &override);
 
        switch (disposition) {
        case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
            break;
        case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
            uacpi_info(
                "table '%.4s' (0x%016"UACPI_PRIX64") installation denied "
                "by host", hdr.signature, UACPI_FMT64(phys)
            );
            ret = UACPI_STATUS_DENIED;
            goto out;
 
        default:
            uacpi_info(
                "table '%.4s' (0x%016"UACPI_PRIX64") installation "
                "overridden by host", hdr.signature, UACPI_FMT64(phys)
            );
 
            ret = handle_table_override(disposition, override, out_table);
            if (uacpi_likely_success(ret))
                ret = UACPI_STATUS_OVERRIDDEN;
 
            goto out;
        }
    }
 
    ret = verify_and_install_table(&hdr, phys, virt, origin, out_table);
out:
    // We don't unmap only in this case
    if (ret == UACPI_STATUS_OK && out_table != UACPI_NULL)
        return ret;
 
    if (virt != UACPI_NULL)
        uacpi_kernel_unmap(virt, hdr.length);
    return UACPI_STATUS_OK;
}

Referenced by handle_table_override(), initialize_fadt(), uacpi_initialize_tables(), and uacpi_table_install_physical_with_origin().

table_install_with_origin_unlocked()

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

static

Definition at line 883 of file tables.c.

{
    struct acpi_sdt_hdr *hdr = virt;
 
    if (uacpi_unlikely(hdr->length < sizeof(struct acpi_sdt_hdr))) {
        uacpi_error("invalid table '%.4s' (%p) size: %u",
                    hdr->signature, virt, hdr->length);
        return UACPI_STATUS_INVALID_TABLE_LENGTH;
    }
 
#ifndef UACPI_BAREBONES_MODE
    if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL &&
        installation_handler != UACPI_NULL) {
        uacpi_u64 override;
        uacpi_table_installation_disposition disposition;
 
        disposition = installation_handler(virt, &override);
 
        switch (disposition) {
        case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
            break;
        case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
            uacpi_info(
                "table "UACPI_PRI_TBL_HDR" installation denied by host",
                UACPI_FMT_TBL_HDR(hdr)
            );
            return UACPI_STATUS_DENIED;
 
        default: {
            uacpi_status ret;
            uacpi_info(
                "table "UACPI_PRI_TBL_HDR" installation overridden by host",
                UACPI_FMT_TBL_HDR(hdr)
            );
 
            ret = handle_table_override(disposition, override, out_table);
            if (uacpi_likely_success(ret))
                ret = UACPI_STATUS_OVERRIDDEN;
 
            return ret;
        }
        }
    }
#endif
 
    return verify_and_install_table(
        hdr, 0, virt, origin, out_table
    );
}

Referenced by handle_table_override(), and uacpi_table_install_with_origin().

table_ref_unlocked()

static uacpi_status table_ref_unlocked ( struct uacpi_installed_table *  tbl )

static

Definition at line 529 of file tables.c.

{
    switch (tbl->reference_count) {
    case 0: {
        uacpi_status ret;
 
        if (uacpi_unlikely(skip_due_to_bad_csum(tbl)))
            return UACPI_STATUS_BAD_CHECKSUM;
 
        if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
            tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
            break;
 
        tbl->ptr = uacpi_kernel_map(tbl->phys_addr, tbl->hdr.length);
        if (uacpi_unlikely(tbl->ptr == UACPI_MAP_FAILED))
            return UACPI_STATUS_MAPPING_FAILED;
 
        if (!(tbl->flags & UACPI_TABLE_CSUM_CHECKED)) {
            ret = uacpi_verify_table_checksum(
                tbl->ptr, tbl->hdr.length, &tbl->flags
            );
            if (uacpi_unlikely_error(ret)) {
                uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
                tbl->ptr = UACPI_NULL;
                return ret;
            }
        }
        break;
    }
    case 0xFFFF - 1:
        uacpi_warn(
            "too many references for "UACPI_PRI_TBL_HDR
            ", mapping permanently", UACPI_FMT_TBL_HDR(&tbl->hdr)
        );
        break;
    default:
        break;
    }
 
    if (uacpi_likely(tbl->reference_count != 0xFFFF))
        tbl->reference_count++;
    return UACPI_STATUS_OK;
}

Referenced by do_search_tables(), and table_ctl().

table_unref_unlocked()

static uacpi_status table_unref_unlocked ( struct uacpi_installed_table *  tbl )

static

Definition at line 573 of file tables.c.

{
    switch (tbl->reference_count) {
    case 0:
        uacpi_warn(
            "tried to unref table "UACPI_PRI_TBL_HDR" with no references",
            UACPI_FMT_TBL_HDR(&tbl->hdr)
        );
        return UACPI_STATUS_INVALID_ARGUMENT;
    case 1:
        if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
            tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
            break;
 
        uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
        tbl->ptr = UACPI_NULL;
        break;
    case 0xFFFF:
        /*
         * Consider the reference count (overflow) of 0xFFFF to be a permanently
         * mapped table as we don't know the actual number of references.
         */
        return UACPI_STATUS_OK;
    default:
        break;
    }
 
    tbl->reference_count--;
    return UACPI_STATUS_OK;
}

Referenced by table_ctl().

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_for_each_subtable()

uacpi_status uacpi_for_each_subtable	(	struct acpi_sdt_hdr *	hdr,
		size_t	hdr_size,
		uacpi_subtable_iteration_callback	cb,
		void *	user
	)

Iterate every subtable of a table such as MADT or SRAT.

'hdr' is the pointer to the main table, 'hdr_size' is the number of bytes in the table before the beginning of the subtable records. 'cb' is the callback invoked for each subtable with the 'user' context pointer passed for every invocation.

Example usage: uacpi_table tbl;

uacpi_table_find_by_signature(ACPI_MADT_SIGNATURE, &tbl); uacpi_for_each_subtable( tbl.hdr, sizeof(struct acpi_madt), parse_madt, NULL );

Definition at line 1600 of file tables.c.

{
    void *cursor;
    size_t bytes_left;
 
    cursor = UACPI_PTR_ADD(hdr, hdr_size);
    bytes_left = hdr->length - hdr_size;
 
    if (uacpi_unlikely(bytes_left > hdr->length))
        return UACPI_STATUS_INVALID_TABLE_LENGTH;
 
    while (bytes_left > sizeof(struct acpi_entry_hdr)) {
        struct acpi_entry_hdr *subtable_hdr = cursor;
 
        if (uacpi_unlikely(subtable_hdr->length > bytes_left ||
                           subtable_hdr->length < sizeof(*subtable_hdr))) {
            uacpi_error(
                "corrupted '%.4s' subtable length: %u (%zu bytes left)",
                hdr->signature, subtable_hdr->length, bytes_left
            );
            return UACPI_STATUS_INVALID_TABLE_LENGTH;
        }
 
        switch (cb(user, subtable_hdr)) {
        case UACPI_ITERATION_DECISION_CONTINUE:
            break;
        case UACPI_ITERATION_DECISION_BREAK:
            return UACPI_STATUS_OK;
        default:
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        cursor = UACPI_PTR_ADD(cursor, subtable_hdr->length);
        bytes_left -= subtable_hdr->length;
    }
 
    if (uacpi_unlikely(bytes_left != 0)) {
        uacpi_warn(
            "found %zu stray bytes in table '%.4s'",
            bytes_left, hdr->signature
        );
    }
 
    return UACPI_STATUS_OK;
}

uacpi_for_each_table()

uacpi_status uacpi_for_each_table	(	uacpi_table_iteration_callback	cb,
		void *	user
	)

Iterate every installed table on the system.

The provided callback receives the information about each table in the 'info' pointer. A table may be mapped by client code if needed via uacpi_table_get_by_index().

Note that this is a low level helper that iterates every installed table, even tables that are unreachable via uacpi_table_find() etc. due to bad checksum.

Definition at line 658 of file tables.c.

{
    uacpi_status ret;
    uacpi_size num_tables, i = 0;
    uacpi_table_info info;
 
    ENSURE_TABLES_ONLINE();
 
    for (;;) {
        ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        // Number of tables may have increased while we were in the callback
        num_tables = table_array_size(&tables);
        if (i >= num_tables) {
            ret = uacpi_release_native_mutex_may_be_null(table_mutex);
            return ret;
        }
 
        table_info_by_index_unchecked(i, &info);
 
        ret = uacpi_release_native_mutex_may_be_null(table_mutex);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        if (cb(user, &info) == UACPI_ITERATION_DECISION_BREAK)
            break;
 
        i++;
    }
 
    return UACPI_STATUS_OK;
}

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_PACKED()

UACPI_PACKED

(

struct uacpi_rxsdt { struct acpi_sdt_hdr hdr;uacpi_u8 ptr_bytes[];}

)

Definition at line 74 of file tables.c.

                                {
    struct acpi_sdt_hdr hdr;
    uacpi_u8 ptr_bytes[];
})
 
static void dump_table_header(
    uacpi_phys_addr phys_addr, void *hdr
)
{
    struct acpi_sdt_hdr *sdt = hdr;
 
    if (uacpi_signatures_match(hdr, ACPI_FACS_SIGNATURE)) {
        uacpi_info(
            "FACS 0x%016"UACPI_PRIX64" %08X", UACPI_FMT64(phys_addr),
            sdt->length
        );
        return;
    }
 
    if (!uacpi_memcmp(hdr, ACPI_RSDP_SIGNATURE, sizeof(ACPI_RSDP_SIGNATURE) - 1)) {
        struct acpi_rsdp *rsdp = hdr;
 
        uacpi_info(
            "RSDP 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s)",
            UACPI_FMT64(phys_addr), rsdp->revision >= 2 ? rsdp->length : 20,
            rsdp->revision, rsdp->oemid
        );
        return;
    }
 
    uacpi_info(
        "%.4s 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s %8.8s)",
        sdt->signature, UACPI_FMT64(phys_addr), sdt->length, sdt->revision,
        sdt->oemid, sdt->oem_table_id
    );
}

uacpi_set_table_installation_handler()

uacpi_status uacpi_set_table_installation_handler

(

uacpi_table_installation_handler

handler

)

Set a handler that is invoked for each table before it gets installed.

Depending on the return value, the table is either allowed to be installed as-is, denied, or overriden with a new one.

Definition at line 392 of file tables.c.

{
    uacpi_status ret;
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (installation_handler != UACPI_NULL && handler != UACPI_NULL)
        goto out;
 
    installation_handler = handler;
 
out:
    uacpi_release_native_mutex_may_be_null(table_mutex);
    return ret;
}

uacpi_setup_early_table_access()

uacpi_status uacpi_setup_early_table_access	(	void *	temporary_buffer,
		uacpi_size	buffer_size
	)

Set up early access to the table subsystem. What this means is:

• uacpi_table_find() and similar API becomes usable before the call to uacpi_initialize().
• No kernel API besides logging and map/unmap will be invoked at this stage, allowing for heap and scheduling to still be fully offline.
• The provided 'temporary_buffer' will be used as a temporary storage for the internal metadata about the tables (list, reference count, addresses, sizes, etc).
• The 'temporary_buffer' is replaced with a normal heap buffer allocated via uacpi_kernel_alloc() after the call to uacpi_initialize() and can therefore be reclaimed by the kernel.

The 'temporary_buffer' is expected to be aligned on the native pointer size boundary (4 on a 32-bit system, 8 on a 64-bit system), although any misalignment is handled gracefully and does not result in an error.

The approximate overhead per table is 56 bytes, so a buffer of 4096 bytes yields about 73 tables in terms of capacity. uACPI also has an internal static buffer for tables, "UACPI_STATIC_TABLE_ARRAY_LEN", which is configured as 16 descriptors in length by default.

This function is used to initialize the barebones mode, see UACPI_BAREBONES_MODE in config.h for more information.

Definition at line 216 of file tables.c.

{
    uacpi_status ret;
    uacpi_virt_addr buffer_addr, aligned_buffer_addr;
 
#ifndef UACPI_BAREBONES_MODE
    UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_EARLY);
#endif
    if (uacpi_unlikely(early_table_access))
        return UACPI_STATUS_INIT_LEVEL_MISMATCH;
 
    uacpi_logger_initialize();
 
    buffer_addr = UACPI_PTR_TO_VIRT_ADDR(temporary_buffer);
    aligned_buffer_addr = UACPI_ALIGN_UP(
        buffer_addr, UACPI_POINTER_SIZE, uacpi_virt_addr
    );
    if (buffer_addr != aligned_buffer_addr) {
        uacpi_size stripped_bytes;
 
        stripped_bytes = aligned_buffer_addr - buffer_addr;
        uacpi_warn(
            "fixed up misaligned early tables buffer (%zu bytes stripped)",
            stripped_bytes
        );
 
        buffer_size -= UACPI_MIN(stripped_bytes, buffer_size);
        temporary_buffer = UACPI_VIRT_ADDR_TO_PTR(aligned_buffer_addr);
    }
 
    if (uacpi_unlikely(buffer_size < sizeof(struct uacpi_installed_table)))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    tables.dynamic_storage = temporary_buffer;
    tables.dynamic_capacity = buffer_size / sizeof(struct uacpi_installed_table);
    early_table_access = UACPI_TRUE;
 
    ret = initialize_from_rsdp();
    if (uacpi_unlikely_error(ret))
        uacpi_deinitialize_tables();
 
    return ret;
}

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_count()

uacpi_size uacpi_table_count

(

void

)

Returns the number of tables stored in the internal array via 'out_count'. This includes all firmware-provided, dynamically loaded, as well as client-installed tables via 'uacpi_table_install' etc.

Definition at line 211 of file tables.c.

{
    return table_array_size(&tables);
}

uacpi_table_fadt()

uacpi_status uacpi_table_fadt

(

struct acpi_fadt **

out_fadt

)

Returns the pointer to a sanitized internal version of FADT.

The revision is guaranteed to be correct. All of the registers are converted to GAS format. Fields that might contain garbage are cleared.

Definition at line 1589 of file tables.c.

{
    ENSURE_TABLES_ONLINE();
 
    if (!fadt_available)
        return UACPI_STATUS_NOT_FOUND;
 
    *out_fadt = &g_uacpi_rt_ctx.fadt;
    return UACPI_STATUS_OK;
}

uacpi_table_find()

uacpi_status uacpi_table_find	(	const uacpi_table_identifiers *	id,
		uacpi_table *	out_table
	)

Definition at line 1178 of file tables.c.

{
    ENSURE_TABLES_ONLINE();
 
    return find_table(0, 0, id, out_table);
}

Referenced by handle_create_data_region(), and handle_load_table().

uacpi_table_find_by_signature()

uacpi_status uacpi_table_find_by_signature	(	const uacpi_char *	signature,
		uacpi_table *	out_table
	)

Helpers for finding tables.

for find_by_signature: 'signature' is an array of 4 characters, a null terminator is not necessary and can be omitted (especially useful for non-C language bindings)

for find_by_signature_at: 'offset' specifies the base index in the internal array where to start searching for the table

for find_nth_by_signature: This works exactly like find_by_signature, but finds the nth copy of the specified table in the firmware enumeration order

'out_table' is a pointer to a caller allocated uacpi_table structure that receives the table pointer & its internal index in case the call was successful.

NOTE: The returned table's reference count is incremented by 1, which keeps its mapping alive forever unless uacpi_table_unref() is called for this table later on. Calling uacpi_table_find_next_with_same_signature() on a table also drops its reference count by 1, so if you want to keep it mapped you must manually call uacpi_table_ref() beforehand.

Definition at line 1153 of file tables.c.

{
    return find_table_by_signature(signature_string, 0, 0, out_table);
}

Referenced by uacpi_namespace_load().

uacpi_table_find_by_signature_at()

uacpi_status uacpi_table_find_by_signature_at	(	const uacpi_char *	signature,
		uacpi_size	idx,
		uacpi_table *	out_table
	)

Definition at line 1139 of file tables.c.

{
    return find_table_by_signature(signature, idx, 0, out_table);
}

uacpi_table_find_next_with_same_signature()

uacpi_status uacpi_table_find_next_with_same_signature

(

uacpi_table *

in_out_table

)

Definition at line 1160 of file tables.c.

{
    struct uacpi_table_identifiers id = { 0 };
 
    ENSURE_TABLES_ONLINE();
 
    if (uacpi_unlikely(in_out_table->ptr == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    uacpi_memcpy(&id.signature, in_out_table->hdr->signature,
                 sizeof(id.signature));
    uacpi_table_unref(in_out_table);
 
    return find_table(in_out_table->index + 1, 0, &id, in_out_table);
}

uacpi_table_find_nth_by_signature()

uacpi_status uacpi_table_find_nth_by_signature	(	const uacpi_char *	signature,
		uacpi_size	nth,
		uacpi_table *	out_table
	)

Definition at line 1146 of file tables.c.

{
    return find_table_by_signature(signature, 0, nth, out_table);
}

uacpi_table_get_by_index()

uacpi_status uacpi_table_get_by_index	(	uacpi_size	idx,
		uacpi_table *	out_table
	)

Returns a table by its index in the internal table array.

The number of available tables can be queried via 'uacpi_table_count()'.

NOTE: Even if a table is present, this may still fail with UACPI_STATUS_BAD_CHECKSUM in case UACPI_FLAG_BAD_CSUM_FATAL is enabled.

Definition at line 1318 of file tables.c.

{
    uacpi_status ret;
    struct table_ctl_request req = {
        .type = TABLE_CTL_GET,
    };
 
    ret = table_ctl(idx, &req);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    out_table->ptr = req.out_tbl;
    out_table->index = idx;
    return UACPI_STATUS_OK;
}

uacpi_table_info_get_by_index()

uacpi_status uacpi_table_info_get_by_index	(	uacpi_size	idx,
		uacpi_table_info *	out_info
	)

Definition at line 630 of file tables.c.

{
    uacpi_status ret;
 
    ENSURE_TABLES_ONLINE();
 
    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (uacpi_unlikely(table_array_size(&tables) <= idx)) {
        uacpi_error(
            "requested invalid table index %zu (%zu tables installed)",
            idx, table_array_size(&tables)
        );
        ret = UACPI_STATUS_INVALID_ARGUMENT;
        goto out;
    }
 
    table_info_by_index_unchecked(idx, out_info);
 
out:
    uacpi_release_native_mutex_may_be_null(table_mutex);
    return ret;
}

uacpi_table_install()

uacpi_status uacpi_table_install	(	void *	virt,
		uacpi_table *	out_table
	)

Install a table from either a virtual or a physical address. The table is simply stored in the internal table array, and not loaded by the interpreter (see uacpi_table_load).

The table is optionally returned via 'out_table'.

Manual calls to uacpi_table_install are not subject to filtering via the table installation callback (if any).

Definition at line 951 of file tables.c.

{
    ENSURE_TABLES_ONLINE();
 
    return uacpi_table_install_with_origin(
        virt, UACPI_TABLE_ORIGIN_HOST_VIRTUAL, out_table
    );
}

uacpi_table_install_physical()

uacpi_status uacpi_table_install_physical	(	uacpi_phys_addr	addr,
		uacpi_table *	out_table
	)

Definition at line 960 of file tables.c.

{
    ENSURE_TABLES_ONLINE();
 
    return uacpi_table_install_physical_with_origin(
        addr, UACPI_TABLE_ORIGIN_HOST_PHYSICAL, out_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()

uacpi_status uacpi_table_load

(

uacpi_size

index

)

Load a previously installed table by feeding it to the interpreter.

Definition at line 1303 of file tables.c.

{
    return uacpi_table_load_with_cause(idx, UACPI_TABLE_LOAD_CAUSE_HOST);
}

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_table_ref()

uacpi_status uacpi_table_ref

(

uacpi_table *

tbl

)

Increment/decrement a table's reference count. The table is unmapped when the reference count drops to 0.

Definition at line 1343 of file tables.c.

{
    return uacpi_table_ref_by_index(tbl->index);
}

uacpi_table_ref_by_index()

uacpi_status uacpi_table_ref_by_index

(

uacpi_size

index

)

Definition at line 1334 of file tables.c.

{
    struct table_ctl_request req = {
        .type = TABLE_CTL_GET
    };
 
    return table_ctl(index, &req);
}

Referenced by uacpi_table_ref().

uacpi_table_unref()

uacpi_status uacpi_table_unref

(

uacpi_table *

tbl

)

Definition at line 1357 of file tables.c.

{
    return uacpi_table_unref_by_index(tbl->index);
}

Referenced by free_op_region(), handle_load(), handle_load_table(), uacpi_namespace_load(), and uacpi_table_find_next_with_same_signature().

uacpi_table_unref_by_index()

uacpi_status uacpi_table_unref_by_index

(

uacpi_size

index

)

Definition at line 1348 of file tables.c.

{
    struct table_ctl_request req = {
        .type = TABLE_CTL_PUT
    };
 
    return table_ctl(index, &req);
}

Referenced by uacpi_table_unref().

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

verify_and_install_table()

static uacpi_status verify_and_install_table ( struct acpi_sdt_hdr *  hdr, uacpi_phys_addr  phys_addr, void *  virt_addr, enum uacpi_table_origin  origin, uacpi_table *  out_table  )

static

Definition at line 695 of file tables.c.

{
    uacpi_status ret;
    struct uacpi_installed_table *table;
    uacpi_bool is_fadt;
    uacpi_size idx;
    uacpi_u8 flags = 0;
 
    is_fadt = uacpi_signatures_match(hdr->signature, ACPI_FADT_SIGNATURE);
 
    /*
     * FACS is the only(?) table without a checksum because it has OSPM
     * writable fields. Don't try to validate it here.
     */
    if (uacpi_signatures_match(hdr->signature, ACPI_FACS_SIGNATURE)) {
        flags |= UACPI_TABLE_CSUM_CHECKED;
    } else if (uacpi_check_flag(UACPI_FLAG_PROACTIVE_TBL_CSUM) || is_fadt ||
               out_table != UACPI_NULL) {
        void *mapping = virt_addr;
 
        // We may already have a valid mapping, reuse it if we do
        if (mapping == UACPI_NULL)
            mapping = uacpi_kernel_map(phys_addr, hdr->length);
        if (uacpi_unlikely(mapping == UACPI_MAP_FAILED))
            return UACPI_STATUS_MAPPING_FAILED;
 
        ret = uacpi_verify_table_checksum(mapping, hdr->length, &flags);
        if (uacpi_likely_success(ret)) {
            if (is_fadt)
                ret = initialize_fadt(mapping);
        }
 
        if (virt_addr == UACPI_NULL)
            uacpi_kernel_unmap(mapping, hdr->length);
 
        if (uacpi_unlikely_error(ret))
            return ret;
    }
 
    if (uacpi_signatures_match(hdr->signature, ACPI_DSDT_SIGNATURE))
        g_uacpi_rt_ctx.is_rev1 = hdr->revision < 2;
 
    ret = table_alloc(&table, &idx);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    dump_table_header(phys_addr, hdr);
 
    uacpi_memcpy(&table->hdr, hdr, sizeof(*hdr));
    table->reference_count = 0;
    table->phys_addr = phys_addr;
    table->ptr = virt_addr;
    table->flags = flags;
    table->origin = origin;
 
    if (out_table == UACPI_NULL)
        return UACPI_STATUS_OK;
 
    table->reference_count++;
    out_table->ptr = virt_addr;
    out_table->index = idx;
    return UACPI_STATUS_OK;
}

Referenced by table_install_physical_with_origin_unlocked(), and table_install_with_origin_unlocked().

warn_if_early_referenced()

static uacpi_iteration_decision warn_if_early_referenced ( void *  user, struct uacpi_installed_table *  tbl, uacpi_size  idx  )

static

Definition at line 263 of file tables.c.

{
    UACPI_UNUSED(user);
 
    if (uacpi_unlikely(tbl->reference_count != 0)) {
        uacpi_warn(
            "table "UACPI_PRI_TBL_HDR" (%zu) still has %d early reference(s)!",
            UACPI_FMT_TBL_HDR(&tbl->hdr), idx, tbl->reference_count
        );
    }
 
    return UACPI_ITERATION_DECISION_CONTINUE;
}

Referenced by uacpi_initialize_tables().

Variable Documentation

fadt_registers

struct register_description fadt_registers[]

static

Definition at line 1421 of file tables.c.

Referenced by convert_registers_to_gas().

fadt_version_sizes

uacpi_u16 fadt_version_sizes[]

Initial value:

= {
    116, 132, 244, 244, 268, 276
}

Definition at line 1362 of file tables.c.

Referenced by fadt_ensure_correct_revision().