2018-03-14 23:13:07 +00:00
|
|
|
/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
/******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Name: actables.h - ACPI table management
|
|
|
|
|
*
|
2021-01-15 18:48:25 +00:00
|
|
|
* Copyright (C) 2000 - 2021, Intel Corp.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2018-03-14 23:13:07 +00:00
|
|
|
*****************************************************************************/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#ifndef __ACTABLES_H__
|
|
|
|
|
#define __ACTABLES_H__
|
|
|
|
|
|
2007-02-02 16:48:20 +00:00
|
|
|
acpi_status acpi_allocate_root_table(u32 initial_table_count);
|
|
|
|
|
|
2013-07-17 01:48:27 +00:00
|
|
|
/*
|
|
|
|
|
* tbxfroot - Root pointer utilities
|
|
|
|
|
*/
|
2014-10-10 02:39:32 +00:00
|
|
|
u32 acpi_tb_get_rsdp_length(struct acpi_table_rsdp *rsdp);
|
|
|
|
|
|
2013-08-08 07:29:22 +00:00
|
|
|
acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
|
|
|
|
|
|
2013-07-17 01:48:27 +00:00
|
|
|
u8 *acpi_tb_scan_memory_for_rsdp(u8 *start_address, u32 length);
|
|
|
|
|
|
2014-04-04 04:39:34 +00:00
|
|
|
/*
|
|
|
|
|
* tbdata - table data structure management
|
|
|
|
|
*/
|
2015-04-13 03:49:30 +00:00
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_get_next_table_descriptor(u32 *table_index,
|
|
|
|
|
struct acpi_table_desc **table_desc);
|
2014-04-04 04:39:34 +00:00
|
|
|
|
|
|
|
|
void
|
|
|
|
|
acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
|
|
|
|
|
acpi_physical_address address,
|
|
|
|
|
u8 flags, struct acpi_table_header *table);
|
|
|
|
|
|
|
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 16:22:28 +00:00
|
|
|
acpi_physical_address address,
|
|
|
|
|
u8 flags, struct acpi_table_header *table);
|
2014-04-04 04:39:34 +00:00
|
|
|
|
|
|
|
|
void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc);
|
|
|
|
|
|
2014-05-31 00:14:44 +00:00
|
|
|
acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc);
|
|
|
|
|
|
|
|
|
|
acpi_status
|
2017-07-10 07:23:50 +00:00
|
|
|
acpi_tb_verify_temp_table(struct acpi_table_desc *table_desc,
|
|
|
|
|
char *signature, u32 *table_index);
|
2014-05-31 00:14:44 +00:00
|
|
|
|
2014-04-04 04:39:34 +00:00
|
|
|
u8 acpi_tb_is_table_loaded(u32 table_index);
|
|
|
|
|
|
|
|
|
|
void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded);
|
|
|
|
|
|
2007-02-02 16:48:20 +00:00
|
|
|
/*
|
|
|
|
|
* tbfadt - FADT parse/convert/validate
|
|
|
|
|
*/
|
2015-10-14 05:53:57 +00:00
|
|
|
void acpi_tb_parse_fadt(void);
|
2007-02-02 16:48:20 +00:00
|
|
|
|
2007-02-02 16:48:20 +00:00
|
|
|
void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length);
|
2007-02-02 16:48:20 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2007-02-02 16:48:18 +00:00
|
|
|
* tbfind - find ACPI table
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
acpi_status
|
2007-02-02 16:48:18 +00:00
|
|
|
acpi_tb_find_table(char *signature,
|
2008-06-10 05:42:13 +00:00
|
|
|
char *oem_id, char *oem_table_id, u32 *table_index);
|
2005-04-19 02:49:35 +00:00
|
|
|
|
|
|
|
|
/*
|
2007-02-02 16:48:18 +00:00
|
|
|
* tbinstal - Table removal and deletion
|
2005-04-19 02:49:35 +00:00
|
|
|
*/
|
2007-02-02 16:48:18 +00:00
|
|
|
acpi_status acpi_tb_resize_root_table_list(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPICA: Tables: Clean up split INSTALLED/VALIDATED table state logics.
This patch is mainly a naming cleanup to clarify hidden logics, no
functional changes.
acpi_initialize_tables() is used by Linux to install table addresses for
early boot steps. During this stage, table addresses are mapped by
early_ioremap() mechanism which is different from the runtime IO mappings.
Thus it is not safe for ACPICA to keep mapped pointers in struct acpi_table_desc
structure during this stage.
In order to support this in ACPICA, table states are divided into
1. "INSTALLED" (where struct acpi_table_desc.Pointer is always NULL) and
2. "VALIDATED" (where struct acpi_table_desc.Pointer is always not NULL).
During acpi_initialize_tables(), table state are ensured to be "INSTALLED"
but not "VALIDATED". This logic is ensured by the original code in very
ambigious way. For example, currently acpi_tb_delete_table() is invoked in
some place to perform an uninstallation while it is invoked in other place
to perform an invalidation. They happen to work just because no one enters
the penalty where the 2 behaviours are not equivalent.
The naming cleanups are made in this patch:
A. For installation and validation:
There is code setting struct acpi_table_desc.Pointer first and delete it
immediately to keep the descriptor's state as "INSTALLED" during the
installation. This patch implements this in more direct way. After
applying it, struct acpi_table_desc.Pointer will never be set in
acpi_tb_install_table() and acpi_tb_override_table() as they are the only
functions invoked during acpi_initialize_tables(). This is achieved by:
1. Rename acpi_tb_verify_table() to acpi_tb_validate_table() to clarify this
change.
2. Rename acpi_tb_table_override() to acpi_tb_override_table() to keep nameing
consistencies as other APIs (verb. Table).
3. Stops setting struct acpi_table_desc.Pointer in acpi_tb_install_table() and
acpi_tb_table_override().
4. Introduce acpi_tb_acquire_table() to acquire the table pointer that is not
maintained in the struct acpi_table_desc of the global root table list and
rewrite acpi_tb_validate_table() using this new function to reduce
redundancies.
5. Replace the table pointer using the overridden table pointer in
acpi_tb_add_table(). As acpi_tb_add_table() is not invoked during early boot
stage, tables returned from this functions should be "VALIDATED". As
acpi_tb_override_table() is modified by this patch to return a "INSTALLED"
but not "VALIDATED" descriptor, to keep acpi_tb_add_table() unchanged,
struct acpi_table_desc.Pointer is filled in acpi_tb_add_table().
B. For invalidation and uninstallation:
The original code invalidate table by invoking acpi_tb_delete_table() here
and there, but actually this function should only be used to uninstall
tables. This can work just because its invocations are equivalent to
invalidation in some cases.
This patch splits acpi_tb_delete_table() into acpi_tb_invalidate_table() and
acpi_tb_uninstall_table() and cleans up the hidden logic using the new
APIs. This is achieved by:
1. Rename acpi_tb_delete_table() to acpi_tb_uninstall_table() as it is mainly
called before resetting struct acpi_table_desc.Address. Thus the table
descriptor is in "not INSTALLED" state. This patch enforces this by
setting struct acpi_table_desc.Address to NULL in this function.
2. Introduce acpi_tb_invalidate_table() to be the reversal of
acpi_tb_validate_table() and invoke it in acpi_tb_uninstall_table().
3. Introduce acpi_tb_release_table() to release the table pointer that is not
maintained in acpi_gbl_root_table_list and rewrite acpi_tb_invalidate_table()
using this new function to reduce redundancies.
After cleaning up, the maintainability of the internal APIs are also
improved:
1. acpi_tb_acquire_table: Acquire struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
2. acpi_tb_release_table: Release struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
3. acpi_tb_install_table: Make struct acpi_table_desc.Address not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
4. acpi_tb_uninstall_table: Make struct acpi_table_desc.Address NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
5. acpi_tb_validate_table: Make struct acpi_table_desc.Pointer not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
6. acpi_tb_invalidate_table: Make struct acpi_table_desc.Pointer NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
7. acpi_tb_override_table: Replace struct acpi_table_desc.Address and
struct acpi_table_desc.Flags. It only happens in
"INSTALLED" state.
The patch has been unit tested in acpi_exec by:
1. Initializing;
2. Executing exc_tbl ASLTS tests;
3. Executing "Load" command.
So that all original acpi_tb_install_table() and acpi_tb_override_table()
invocations are covered.
Known Issues:
1. Cleanup acpi_tb_add_table() to Kill Code Redundancies
Current implementation in acpi_tb_add_table() is not very clean, further
patch can rewrite acpi_tb_add_table() with ordered acpi_tb_install_table(),
acpi_tb_override_table() and acpi_tb_validate_table(). It is not done in this
patch so that it is easy for the reviewers to understand the changes in
this patch.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:42 +00:00
|
|
|
acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPICA: Tables: Clean up split INSTALLED/VALIDATED table state logics.
This patch is mainly a naming cleanup to clarify hidden logics, no
functional changes.
acpi_initialize_tables() is used by Linux to install table addresses for
early boot steps. During this stage, table addresses are mapped by
early_ioremap() mechanism which is different from the runtime IO mappings.
Thus it is not safe for ACPICA to keep mapped pointers in struct acpi_table_desc
structure during this stage.
In order to support this in ACPICA, table states are divided into
1. "INSTALLED" (where struct acpi_table_desc.Pointer is always NULL) and
2. "VALIDATED" (where struct acpi_table_desc.Pointer is always not NULL).
During acpi_initialize_tables(), table state are ensured to be "INSTALLED"
but not "VALIDATED". This logic is ensured by the original code in very
ambigious way. For example, currently acpi_tb_delete_table() is invoked in
some place to perform an uninstallation while it is invoked in other place
to perform an invalidation. They happen to work just because no one enters
the penalty where the 2 behaviours are not equivalent.
The naming cleanups are made in this patch:
A. For installation and validation:
There is code setting struct acpi_table_desc.Pointer first and delete it
immediately to keep the descriptor's state as "INSTALLED" during the
installation. This patch implements this in more direct way. After
applying it, struct acpi_table_desc.Pointer will never be set in
acpi_tb_install_table() and acpi_tb_override_table() as they are the only
functions invoked during acpi_initialize_tables(). This is achieved by:
1. Rename acpi_tb_verify_table() to acpi_tb_validate_table() to clarify this
change.
2. Rename acpi_tb_table_override() to acpi_tb_override_table() to keep nameing
consistencies as other APIs (verb. Table).
3. Stops setting struct acpi_table_desc.Pointer in acpi_tb_install_table() and
acpi_tb_table_override().
4. Introduce acpi_tb_acquire_table() to acquire the table pointer that is not
maintained in the struct acpi_table_desc of the global root table list and
rewrite acpi_tb_validate_table() using this new function to reduce
redundancies.
5. Replace the table pointer using the overridden table pointer in
acpi_tb_add_table(). As acpi_tb_add_table() is not invoked during early boot
stage, tables returned from this functions should be "VALIDATED". As
acpi_tb_override_table() is modified by this patch to return a "INSTALLED"
but not "VALIDATED" descriptor, to keep acpi_tb_add_table() unchanged,
struct acpi_table_desc.Pointer is filled in acpi_tb_add_table().
B. For invalidation and uninstallation:
The original code invalidate table by invoking acpi_tb_delete_table() here
and there, but actually this function should only be used to uninstall
tables. This can work just because its invocations are equivalent to
invalidation in some cases.
This patch splits acpi_tb_delete_table() into acpi_tb_invalidate_table() and
acpi_tb_uninstall_table() and cleans up the hidden logic using the new
APIs. This is achieved by:
1. Rename acpi_tb_delete_table() to acpi_tb_uninstall_table() as it is mainly
called before resetting struct acpi_table_desc.Address. Thus the table
descriptor is in "not INSTALLED" state. This patch enforces this by
setting struct acpi_table_desc.Address to NULL in this function.
2. Introduce acpi_tb_invalidate_table() to be the reversal of
acpi_tb_validate_table() and invoke it in acpi_tb_uninstall_table().
3. Introduce acpi_tb_release_table() to release the table pointer that is not
maintained in acpi_gbl_root_table_list and rewrite acpi_tb_invalidate_table()
using this new function to reduce redundancies.
After cleaning up, the maintainability of the internal APIs are also
improved:
1. acpi_tb_acquire_table: Acquire struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
2. acpi_tb_release_table: Release struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
3. acpi_tb_install_table: Make struct acpi_table_desc.Address not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
4. acpi_tb_uninstall_table: Make struct acpi_table_desc.Address NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
5. acpi_tb_validate_table: Make struct acpi_table_desc.Pointer not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
6. acpi_tb_invalidate_table: Make struct acpi_table_desc.Pointer NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
7. acpi_tb_override_table: Replace struct acpi_table_desc.Address and
struct acpi_table_desc.Flags. It only happens in
"INSTALLED" state.
The patch has been unit tested in acpi_exec by:
1. Initializing;
2. Executing exc_tbl ASLTS tests;
3. Executing "Load" command.
So that all original acpi_tb_install_table() and acpi_tb_override_table()
invocations are covered.
Known Issues:
1. Cleanup acpi_tb_add_table() to Kill Code Redundancies
Current implementation in acpi_tb_add_table() is not very clean, further
patch can rewrite acpi_tb_add_table() with ordered acpi_tb_install_table(),
acpi_tb_override_table() and acpi_tb_validate_table(). It is not done in this
patch so that it is easy for the reviewers to understand the changes in
this patch.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:42 +00:00
|
|
|
void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc);
|
|
|
|
|
|
ACPICA: Tables: Fix table checksums verification before installation.
The original table handling code does not always verify checksums before
installing a table, this is because code to achieve this must be
implemented here and there in the redundant code blocks.
There are two stages during table initialization:
1. "INSTALLED" after acpi_tb_install_table() and acpi_tb_override_table(),
struct acpi_table_desc.Pointer is ensured to be NULL. This can be safely used
during OSPM's early boot stage.
2. "VALIDATED" after acpi_tb_validate_table(), struct acpi_table_desc.Pointer is
ensured to be not NULL. This must not be used during OSPM's early boot
stage.
This patch changes acpi_tb_add_table() into an early boot safe API to reduce
code redundancies by changing the table state that is returned by this
function from "VALIDATED" to "INSTALLED". Then the table verification
code can be done in a single place. Originally, the acpi_tb_add_table() can
only be used by dynamic table loadings that are executed after early boot
stage, it cannot be used by static table loadings that are executed in
early boot stage as:
1. The address of the table is a virtual address either maintained by
OSPMs who call acpi_load_table() or by ACPICA whenever "Load" or
"LoadTable" opcodes are executed, while during early boot stage,
physical address of the table should be used for table loading.
2. The API will ensure the state of the loaded table to be "VALIDATED"
while during early boot stage, tables maintained by root table list
should be kept as "INSTALLED".
To achieve this:
1. Rename acpi_tb_install_table() to acpi_tb_install_fixed_table() as it only
applies to DSDT/FACS installation. Rename acpi_tb_add_table() to
acpi_tb_install_non_fixed_table() as it will be applied to the installation
of the rest kinds of tables.
2. Introduce acpi_tb_install_table(), acpi_tb_install_and_override_table to collect
redudant code where their invocations actually have slight differences.
1. acpi_tb_install_table() is used to fill an struct acpi_table_desc where the
table length is known to the caller.
2. acpi_tb_install_and_override_table() is used to perform necessary
overriding before installation.
3. Change a parameter of acpi_tb_install_non_fixed_table() from struct acpi_table_desc
to acpi_physical_address to allow it to be invoked by static table
loadings. Also cleanup acpi_ex_load_op() and acpi_load_table() to accomodate
to the parameter change.
4. Invoke acpi_tb_install_non_fixed_table() for all table loadings other than
DSDT/FACS in acpi_tb_parse_root_table() to improve code maintainability
(logics are collected in the single function). Also delete useless code
from acpi_tb_parse_root_table().
5. Remove all acpi_tb_validate_table() from acpi_tb_install_non_fixed_table() and
acpi_tb_install_fixed_table() so that the table descriptor is kept in the
state of "INSTALLED" but not "VALIDATED" after returning from these
functions.
6. Introduce temporary struct acpi_table_desc (new_table_desc/old_table_desc) into
the functions to indicate a table descriptor that is not maintained by
acpi_gbl_root_table_list. Introduce acpi_tb_acquire_temporal_table() and
acpi_tb_release_temporal_table() to handle the use cases of such temporal
tables. They are only used for verified installation.
7. Introduce acpi_tb_verify_table() to validate table and verify table
checksum, also remove table checksum verification from
acpi_tb_validate_table(). Invoke acpi_tb_validate_table() in the functions
that will convert a table into "LOADED" state or invoke it from
acpi_get_table_XXX() APIs. Invoke acpi_tb_verify_table() on temporary
struct acpi_table_desc(s) that are going to be "INSTALLED".
8. Change acpi_tb_override_table() logic so that a temporary struct acpi_table_desc
will be overridden before installtion, this makes code simpler.
After applying the patch, tables are always installed after being
overridden and the table checksums are always verified before installation.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
[rjw: Subject]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:57 +00:00
|
|
|
void acpi_tb_override_table(struct acpi_table_desc *old_table_desc);
|
2012-02-14 10:31:56 +00:00
|
|
|
|
ACPICA: Tables: Clean up split INSTALLED/VALIDATED table state logics.
This patch is mainly a naming cleanup to clarify hidden logics, no
functional changes.
acpi_initialize_tables() is used by Linux to install table addresses for
early boot steps. During this stage, table addresses are mapped by
early_ioremap() mechanism which is different from the runtime IO mappings.
Thus it is not safe for ACPICA to keep mapped pointers in struct acpi_table_desc
structure during this stage.
In order to support this in ACPICA, table states are divided into
1. "INSTALLED" (where struct acpi_table_desc.Pointer is always NULL) and
2. "VALIDATED" (where struct acpi_table_desc.Pointer is always not NULL).
During acpi_initialize_tables(), table state are ensured to be "INSTALLED"
but not "VALIDATED". This logic is ensured by the original code in very
ambigious way. For example, currently acpi_tb_delete_table() is invoked in
some place to perform an uninstallation while it is invoked in other place
to perform an invalidation. They happen to work just because no one enters
the penalty where the 2 behaviours are not equivalent.
The naming cleanups are made in this patch:
A. For installation and validation:
There is code setting struct acpi_table_desc.Pointer first and delete it
immediately to keep the descriptor's state as "INSTALLED" during the
installation. This patch implements this in more direct way. After
applying it, struct acpi_table_desc.Pointer will never be set in
acpi_tb_install_table() and acpi_tb_override_table() as they are the only
functions invoked during acpi_initialize_tables(). This is achieved by:
1. Rename acpi_tb_verify_table() to acpi_tb_validate_table() to clarify this
change.
2. Rename acpi_tb_table_override() to acpi_tb_override_table() to keep nameing
consistencies as other APIs (verb. Table).
3. Stops setting struct acpi_table_desc.Pointer in acpi_tb_install_table() and
acpi_tb_table_override().
4. Introduce acpi_tb_acquire_table() to acquire the table pointer that is not
maintained in the struct acpi_table_desc of the global root table list and
rewrite acpi_tb_validate_table() using this new function to reduce
redundancies.
5. Replace the table pointer using the overridden table pointer in
acpi_tb_add_table(). As acpi_tb_add_table() is not invoked during early boot
stage, tables returned from this functions should be "VALIDATED". As
acpi_tb_override_table() is modified by this patch to return a "INSTALLED"
but not "VALIDATED" descriptor, to keep acpi_tb_add_table() unchanged,
struct acpi_table_desc.Pointer is filled in acpi_tb_add_table().
B. For invalidation and uninstallation:
The original code invalidate table by invoking acpi_tb_delete_table() here
and there, but actually this function should only be used to uninstall
tables. This can work just because its invocations are equivalent to
invalidation in some cases.
This patch splits acpi_tb_delete_table() into acpi_tb_invalidate_table() and
acpi_tb_uninstall_table() and cleans up the hidden logic using the new
APIs. This is achieved by:
1. Rename acpi_tb_delete_table() to acpi_tb_uninstall_table() as it is mainly
called before resetting struct acpi_table_desc.Address. Thus the table
descriptor is in "not INSTALLED" state. This patch enforces this by
setting struct acpi_table_desc.Address to NULL in this function.
2. Introduce acpi_tb_invalidate_table() to be the reversal of
acpi_tb_validate_table() and invoke it in acpi_tb_uninstall_table().
3. Introduce acpi_tb_release_table() to release the table pointer that is not
maintained in acpi_gbl_root_table_list and rewrite acpi_tb_invalidate_table()
using this new function to reduce redundancies.
After cleaning up, the maintainability of the internal APIs are also
improved:
1. acpi_tb_acquire_table: Acquire struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
2. acpi_tb_release_table: Release struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
3. acpi_tb_install_table: Make struct acpi_table_desc.Address not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
4. acpi_tb_uninstall_table: Make struct acpi_table_desc.Address NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
5. acpi_tb_validate_table: Make struct acpi_table_desc.Pointer not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
6. acpi_tb_invalidate_table: Make struct acpi_table_desc.Pointer NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
7. acpi_tb_override_table: Replace struct acpi_table_desc.Address and
struct acpi_table_desc.Flags. It only happens in
"INSTALLED" state.
The patch has been unit tested in acpi_exec by:
1. Initializing;
2. Executing exc_tbl ASLTS tests;
3. Executing "Load" command.
So that all original acpi_tb_install_table() and acpi_tb_override_table()
invocations are covered.
Known Issues:
1. Cleanup acpi_tb_add_table() to Kill Code Redundancies
Current implementation in acpi_tb_add_table() is not very clean, further
patch can rewrite acpi_tb_add_table() with ordered acpi_tb_install_table(),
acpi_tb_override_table() and acpi_tb_validate_table(). It is not done in this
patch so that it is easy for the reviewers to understand the changes in
this patch.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:42 +00:00
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
|
|
|
|
|
struct acpi_table_header **table_ptr,
|
|
|
|
|
u32 *table_length, u8 *table_flags);
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
acpi_tb_release_table(struct acpi_table_header *table,
|
|
|
|
|
u32 table_length, u8 table_flags);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
acpi_status
|
2014-04-04 04:39:26 +00:00
|
|
|
acpi_tb_install_standard_table(acpi_physical_address address,
|
|
|
|
|
u8 flags,
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 16:22:28 +00:00
|
|
|
struct acpi_table_header *table,
|
2014-04-04 04:39:26 +00:00
|
|
|
u8 reload, u8 override, u32 *table_index);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPICA: Tables: Clean up split INSTALLED/VALIDATED table state logics.
This patch is mainly a naming cleanup to clarify hidden logics, no
functional changes.
acpi_initialize_tables() is used by Linux to install table addresses for
early boot steps. During this stage, table addresses are mapped by
early_ioremap() mechanism which is different from the runtime IO mappings.
Thus it is not safe for ACPICA to keep mapped pointers in struct acpi_table_desc
structure during this stage.
In order to support this in ACPICA, table states are divided into
1. "INSTALLED" (where struct acpi_table_desc.Pointer is always NULL) and
2. "VALIDATED" (where struct acpi_table_desc.Pointer is always not NULL).
During acpi_initialize_tables(), table state are ensured to be "INSTALLED"
but not "VALIDATED". This logic is ensured by the original code in very
ambigious way. For example, currently acpi_tb_delete_table() is invoked in
some place to perform an uninstallation while it is invoked in other place
to perform an invalidation. They happen to work just because no one enters
the penalty where the 2 behaviours are not equivalent.
The naming cleanups are made in this patch:
A. For installation and validation:
There is code setting struct acpi_table_desc.Pointer first and delete it
immediately to keep the descriptor's state as "INSTALLED" during the
installation. This patch implements this in more direct way. After
applying it, struct acpi_table_desc.Pointer will never be set in
acpi_tb_install_table() and acpi_tb_override_table() as they are the only
functions invoked during acpi_initialize_tables(). This is achieved by:
1. Rename acpi_tb_verify_table() to acpi_tb_validate_table() to clarify this
change.
2. Rename acpi_tb_table_override() to acpi_tb_override_table() to keep nameing
consistencies as other APIs (verb. Table).
3. Stops setting struct acpi_table_desc.Pointer in acpi_tb_install_table() and
acpi_tb_table_override().
4. Introduce acpi_tb_acquire_table() to acquire the table pointer that is not
maintained in the struct acpi_table_desc of the global root table list and
rewrite acpi_tb_validate_table() using this new function to reduce
redundancies.
5. Replace the table pointer using the overridden table pointer in
acpi_tb_add_table(). As acpi_tb_add_table() is not invoked during early boot
stage, tables returned from this functions should be "VALIDATED". As
acpi_tb_override_table() is modified by this patch to return a "INSTALLED"
but not "VALIDATED" descriptor, to keep acpi_tb_add_table() unchanged,
struct acpi_table_desc.Pointer is filled in acpi_tb_add_table().
B. For invalidation and uninstallation:
The original code invalidate table by invoking acpi_tb_delete_table() here
and there, but actually this function should only be used to uninstall
tables. This can work just because its invocations are equivalent to
invalidation in some cases.
This patch splits acpi_tb_delete_table() into acpi_tb_invalidate_table() and
acpi_tb_uninstall_table() and cleans up the hidden logic using the new
APIs. This is achieved by:
1. Rename acpi_tb_delete_table() to acpi_tb_uninstall_table() as it is mainly
called before resetting struct acpi_table_desc.Address. Thus the table
descriptor is in "not INSTALLED" state. This patch enforces this by
setting struct acpi_table_desc.Address to NULL in this function.
2. Introduce acpi_tb_invalidate_table() to be the reversal of
acpi_tb_validate_table() and invoke it in acpi_tb_uninstall_table().
3. Introduce acpi_tb_release_table() to release the table pointer that is not
maintained in acpi_gbl_root_table_list and rewrite acpi_tb_invalidate_table()
using this new function to reduce redundancies.
After cleaning up, the maintainability of the internal APIs are also
improved:
1. acpi_tb_acquire_table: Acquire struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
2. acpi_tb_release_table: Release struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
3. acpi_tb_install_table: Make struct acpi_table_desc.Address not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
4. acpi_tb_uninstall_table: Make struct acpi_table_desc.Address NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
5. acpi_tb_validate_table: Make struct acpi_table_desc.Pointer not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
6. acpi_tb_invalidate_table: Make struct acpi_table_desc.Pointer NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
7. acpi_tb_override_table: Replace struct acpi_table_desc.Address and
struct acpi_table_desc.Flags. It only happens in
"INSTALLED" state.
The patch has been unit tested in acpi_exec by:
1. Initializing;
2. Executing exc_tbl ASLTS tests;
3. Executing "Load" command.
So that all original acpi_tb_install_table() and acpi_tb_override_table()
invocations are covered.
Known Issues:
1. Cleanup acpi_tb_add_table() to Kill Code Redundancies
Current implementation in acpi_tb_add_table() is not very clean, further
patch can rewrite acpi_tb_add_table() with ordered acpi_tb_install_table(),
acpi_tb_override_table() and acpi_tb_validate_table(). It is not done in this
patch so that it is easy for the reviewers to understand the changes in
this patch.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:42 +00:00
|
|
|
void acpi_tb_uninstall_table(struct acpi_table_desc *table_desc);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-09-07 06:07:24 +00:00
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_load_table(u32 table_index, struct acpi_namespace_node *parent_node);
|
|
|
|
|
|
|
|
|
|
acpi_status
|
2016-11-30 07:21:19 +00:00
|
|
|
acpi_tb_install_and_load_table(acpi_physical_address address,
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 16:22:28 +00:00
|
|
|
u8 flags,
|
|
|
|
|
struct acpi_table_header *table,
|
|
|
|
|
u8 override, u32 *table_index);
|
2016-09-07 06:07:24 +00:00
|
|
|
|
2016-11-30 07:21:26 +00:00
|
|
|
acpi_status acpi_tb_unload_table(u32 table_index);
|
|
|
|
|
|
2017-07-10 07:23:28 +00:00
|
|
|
void acpi_tb_notify_table(u32 event, void *table);
|
|
|
|
|
|
2007-02-02 16:48:18 +00:00
|
|
|
void acpi_tb_terminate(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-09 08:31:04 +00:00
|
|
|
acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-10 05:42:13 +00:00
|
|
|
acpi_status acpi_tb_allocate_owner_id(u32 table_index);
|
2007-02-02 16:48:18 +00:00
|
|
|
|
2008-06-10 05:42:13 +00:00
|
|
|
acpi_status acpi_tb_release_owner_id(u32 table_index);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-10 05:42:13 +00:00
|
|
|
acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
2007-02-02 16:48:18 +00:00
|
|
|
* tbutils - table manager utilities
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-11-12 07:34:52 +00:00
|
|
|
acpi_status acpi_tb_initialize_facs(void);
|
|
|
|
|
|
2007-02-02 16:48:18 +00:00
|
|
|
void
|
|
|
|
|
acpi_tb_print_table_header(acpi_physical_address address,
|
|
|
|
|
struct acpi_table_header *header);
|
2005-07-29 22:15:00 +00:00
|
|
|
|
2008-06-10 05:42:13 +00:00
|
|
|
u8 acpi_tb_checksum(u8 *buffer, u32 length);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-02 16:48:19 +00:00
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_verify_checksum(struct acpi_table_header *table, u32 length);
|
ACPI: ACPICA 20060331
Implemented header file support for the following
additional ACPI tables: ASF!, BOOT, CPEP, DBGP, MCFG, SPCR,
SPMI, TCPA, and WDRT. With this support, all current and
known ACPI tables are now defined in the ACPICA headers and
are available for use by device drivers and other software.
Implemented support to allow tables that contain ACPI
names with invalid characters to be loaded. Previously,
this would cause the table load to fail, but since
there are several known cases of such tables on
existing machines, this change was made to enable
ACPI support for them. Also, this matches the
behavior of the Microsoft ACPI implementation.
https://bugzilla.novell.com/show_bug.cgi?id=147621
Fixed a couple regressions introduced during the memory
optimization in the 20060317 release. The namespace
node definition required additional reorganization and
an internal datatype that had been changed to 8-bit was
restored to 32-bit. (Valery Podrezov)
Fixed a problem where a null pointer passed to
acpi_ut_delete_generic_state() could be passed through
to acpi_os_release_object which is unexpected. Such
null pointers are now trapped and ignored, matching
the behavior of the previous implementation before the
deployment of acpi_os_release_object(). (Valery Podrezov,
Fiodor Suietov)
Fixed a memory mapping leak during the deletion of
a SystemMemory operation region where a cached memory
mapping was not deleted. This became a noticeable problem
for operation regions that are defined within frequently
used control methods. (Dana Meyers)
Reorganized the ACPI table header files into two main
files: one for the ACPI tables consumed by the ACPICA core,
and another for the miscellaneous ACPI tables that are
consumed by the drivers and other software. The various
FADT definitions were merged into one common section and
three different tables (ACPI 1.0, 1.0+, and 2.0)
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-03-31 05:00:00 +00:00
|
|
|
|
2010-04-01 02:47:56 +00:00
|
|
|
void acpi_tb_check_dsdt_header(void);
|
|
|
|
|
|
2010-04-07 03:05:11 +00:00
|
|
|
struct acpi_table_header *acpi_tb_copy_dsdt(u32 table_index);
|
2010-04-01 03:14:12 +00:00
|
|
|
|
ACPICA: Tables: Fix table checksums verification before installation.
The original table handling code does not always verify checksums before
installing a table, this is because code to achieve this must be
implemented here and there in the redundant code blocks.
There are two stages during table initialization:
1. "INSTALLED" after acpi_tb_install_table() and acpi_tb_override_table(),
struct acpi_table_desc.Pointer is ensured to be NULL. This can be safely used
during OSPM's early boot stage.
2. "VALIDATED" after acpi_tb_validate_table(), struct acpi_table_desc.Pointer is
ensured to be not NULL. This must not be used during OSPM's early boot
stage.
This patch changes acpi_tb_add_table() into an early boot safe API to reduce
code redundancies by changing the table state that is returned by this
function from "VALIDATED" to "INSTALLED". Then the table verification
code can be done in a single place. Originally, the acpi_tb_add_table() can
only be used by dynamic table loadings that are executed after early boot
stage, it cannot be used by static table loadings that are executed in
early boot stage as:
1. The address of the table is a virtual address either maintained by
OSPMs who call acpi_load_table() or by ACPICA whenever "Load" or
"LoadTable" opcodes are executed, while during early boot stage,
physical address of the table should be used for table loading.
2. The API will ensure the state of the loaded table to be "VALIDATED"
while during early boot stage, tables maintained by root table list
should be kept as "INSTALLED".
To achieve this:
1. Rename acpi_tb_install_table() to acpi_tb_install_fixed_table() as it only
applies to DSDT/FACS installation. Rename acpi_tb_add_table() to
acpi_tb_install_non_fixed_table() as it will be applied to the installation
of the rest kinds of tables.
2. Introduce acpi_tb_install_table(), acpi_tb_install_and_override_table to collect
redudant code where their invocations actually have slight differences.
1. acpi_tb_install_table() is used to fill an struct acpi_table_desc where the
table length is known to the caller.
2. acpi_tb_install_and_override_table() is used to perform necessary
overriding before installation.
3. Change a parameter of acpi_tb_install_non_fixed_table() from struct acpi_table_desc
to acpi_physical_address to allow it to be invoked by static table
loadings. Also cleanup acpi_ex_load_op() and acpi_load_table() to accomodate
to the parameter change.
4. Invoke acpi_tb_install_non_fixed_table() for all table loadings other than
DSDT/FACS in acpi_tb_parse_root_table() to improve code maintainability
(logics are collected in the single function). Also delete useless code
from acpi_tb_parse_root_table().
5. Remove all acpi_tb_validate_table() from acpi_tb_install_non_fixed_table() and
acpi_tb_install_fixed_table() so that the table descriptor is kept in the
state of "INSTALLED" but not "VALIDATED" after returning from these
functions.
6. Introduce temporary struct acpi_table_desc (new_table_desc/old_table_desc) into
the functions to indicate a table descriptor that is not maintained by
acpi_gbl_root_table_list. Introduce acpi_tb_acquire_temporal_table() and
acpi_tb_release_temporal_table() to handle the use cases of such temporal
tables. They are only used for verified installation.
7. Introduce acpi_tb_verify_table() to validate table and verify table
checksum, also remove table checksum verification from
acpi_tb_validate_table(). Invoke acpi_tb_validate_table() in the functions
that will convert a table into "LOADED" state or invoke it from
acpi_get_table_XXX() APIs. Invoke acpi_tb_verify_table() on temporary
struct acpi_table_desc(s) that are going to be "INSTALLED".
8. Change acpi_tb_override_table() logic so that a temporary struct acpi_table_desc
will be overridden before installtion, this makes code simpler.
After applying the patch, tables are always installed after being
overridden and the table checksums are always verified before installation.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
[rjw: Subject]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:57 +00:00
|
|
|
void
|
2015-08-25 02:29:01 +00:00
|
|
|
acpi_tb_install_table_with_override(struct acpi_table_desc *new_table_desc,
|
|
|
|
|
u8 override, u32 *table_index);
|
ACPICA: Tables: Fix table checksums verification before installation.
The original table handling code does not always verify checksums before
installing a table, this is because code to achieve this must be
implemented here and there in the redundant code blocks.
There are two stages during table initialization:
1. "INSTALLED" after acpi_tb_install_table() and acpi_tb_override_table(),
struct acpi_table_desc.Pointer is ensured to be NULL. This can be safely used
during OSPM's early boot stage.
2. "VALIDATED" after acpi_tb_validate_table(), struct acpi_table_desc.Pointer is
ensured to be not NULL. This must not be used during OSPM's early boot
stage.
This patch changes acpi_tb_add_table() into an early boot safe API to reduce
code redundancies by changing the table state that is returned by this
function from "VALIDATED" to "INSTALLED". Then the table verification
code can be done in a single place. Originally, the acpi_tb_add_table() can
only be used by dynamic table loadings that are executed after early boot
stage, it cannot be used by static table loadings that are executed in
early boot stage as:
1. The address of the table is a virtual address either maintained by
OSPMs who call acpi_load_table() or by ACPICA whenever "Load" or
"LoadTable" opcodes are executed, while during early boot stage,
physical address of the table should be used for table loading.
2. The API will ensure the state of the loaded table to be "VALIDATED"
while during early boot stage, tables maintained by root table list
should be kept as "INSTALLED".
To achieve this:
1. Rename acpi_tb_install_table() to acpi_tb_install_fixed_table() as it only
applies to DSDT/FACS installation. Rename acpi_tb_add_table() to
acpi_tb_install_non_fixed_table() as it will be applied to the installation
of the rest kinds of tables.
2. Introduce acpi_tb_install_table(), acpi_tb_install_and_override_table to collect
redudant code where their invocations actually have slight differences.
1. acpi_tb_install_table() is used to fill an struct acpi_table_desc where the
table length is known to the caller.
2. acpi_tb_install_and_override_table() is used to perform necessary
overriding before installation.
3. Change a parameter of acpi_tb_install_non_fixed_table() from struct acpi_table_desc
to acpi_physical_address to allow it to be invoked by static table
loadings. Also cleanup acpi_ex_load_op() and acpi_load_table() to accomodate
to the parameter change.
4. Invoke acpi_tb_install_non_fixed_table() for all table loadings other than
DSDT/FACS in acpi_tb_parse_root_table() to improve code maintainability
(logics are collected in the single function). Also delete useless code
from acpi_tb_parse_root_table().
5. Remove all acpi_tb_validate_table() from acpi_tb_install_non_fixed_table() and
acpi_tb_install_fixed_table() so that the table descriptor is kept in the
state of "INSTALLED" but not "VALIDATED" after returning from these
functions.
6. Introduce temporary struct acpi_table_desc (new_table_desc/old_table_desc) into
the functions to indicate a table descriptor that is not maintained by
acpi_gbl_root_table_list. Introduce acpi_tb_acquire_temporal_table() and
acpi_tb_release_temporal_table() to handle the use cases of such temporal
tables. They are only used for verified installation.
7. Introduce acpi_tb_verify_table() to validate table and verify table
checksum, also remove table checksum verification from
acpi_tb_validate_table(). Invoke acpi_tb_validate_table() in the functions
that will convert a table into "LOADED" state or invoke it from
acpi_get_table_XXX() APIs. Invoke acpi_tb_verify_table() on temporary
struct acpi_table_desc(s) that are going to be "INSTALLED".
8. Change acpi_tb_override_table() logic so that a temporary struct acpi_table_desc
will be overridden before installtion, this makes code simpler.
After applying the patch, tables are always installed after being
overridden and the table checksums are always verified before installation.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
[rjw: Subject]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-04 04:38:57 +00:00
|
|
|
|
2016-09-07 06:06:17 +00:00
|
|
|
acpi_status acpi_tb_parse_root_table(acpi_physical_address rsdp_address);
|
ACPI: ACPICA 20060331
Implemented header file support for the following
additional ACPI tables: ASF!, BOOT, CPEP, DBGP, MCFG, SPCR,
SPMI, TCPA, and WDRT. With this support, all current and
known ACPI tables are now defined in the ACPICA headers and
are available for use by device drivers and other software.
Implemented support to allow tables that contain ACPI
names with invalid characters to be loaded. Previously,
this would cause the table load to fail, but since
there are several known cases of such tables on
existing machines, this change was made to enable
ACPI support for them. Also, this matches the
behavior of the Microsoft ACPI implementation.
https://bugzilla.novell.com/show_bug.cgi?id=147621
Fixed a couple regressions introduced during the memory
optimization in the 20060317 release. The namespace
node definition required additional reorganization and
an internal datatype that had been changed to 8-bit was
restored to 32-bit. (Valery Podrezov)
Fixed a problem where a null pointer passed to
acpi_ut_delete_generic_state() could be passed through
to acpi_os_release_object which is unexpected. Such
null pointers are now trapped and ignored, matching
the behavior of the previous implementation before the
deployment of acpi_os_release_object(). (Valery Podrezov,
Fiodor Suietov)
Fixed a memory mapping leak during the deletion of
a SystemMemory operation region where a cached memory
mapping was not deleted. This became a noticeable problem
for operation regions that are defined within frequently
used control methods. (Dana Meyers)
Reorganized the ACPI table header files into two main
files: one for the ACPI tables consumed by the ACPICA core,
and another for the miscellaneous ACPI tables that are
consumed by the drivers and other software. The various
FADT definitions were merged into one common section and
three different tables (ACPI 1.0, 1.0+, and 2.0)
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-03-31 05:00:00 +00:00
|
|
|
|
ACPICA: Tables: Back port acpi_get_table_with_size() and early_acpi_os_unmap_memory() from Linux kernel
ACPICA commit cac6790954d4d752a083e6122220b8a22febcd07
This patch back ports Linux acpi_get_table_with_size() and
early_acpi_os_unmap_memory() into ACPICA upstream to reduce divergences.
The 2 APIs are used by Linux as table management APIs for long time, it
contains a hidden logic that during the early stage, the mapped tables
should be unmapped before the early stage ends.
During the early stage, tables are handled by the following sequence:
acpi_get_table_with_size();
parse the table
early_acpi_os_unmap_memory();
During the late stage, tables are handled by the following sequence:
acpi_get_table();
parse the table
Linux uses acpi_gbl_permanent_mmap to distinguish the early stage and the
late stage.
The reasoning of introducing acpi_get_table_with_size() is: ACPICA will
remember the early mapped pointer in acpi_get_table() and Linux isn't able to
prevent ACPICA from using the wrong early mapped pointer during the late
stage as there is no API provided from ACPICA to be an inverse of
acpi_get_table() to forget the early mapped pointer.
But how ACPICA can work with the early/late stage requirement? Inside of
ACPICA, tables are ensured to be remained in "INSTALLED" state during the
early stage, and they are carefully not transitioned to "VALIDATED" state
until the late stage. So the same logic is in fact implemented inside of
ACPICA in a different way. The gap is only that the feature is not provided
to the OSPMs in an accessible external API style.
It then is possible to fix the gap by providing an inverse of
acpi_get_table() from ACPICA, so that the two Linux sequences can be
combined:
acpi_get_table();
parse the table
acpi_put_table();
In order to work easier with the current Linux code, acpi_get_table() and
acpi_put_table() is implemented in a usage counting based style:
1. When the usage count of the table is increased from 0 to 1, table is
mapped and .Pointer is set with the mapping address (VALIDATED);
2. When the usage count of the table is decreased from 1 to 0, .Pointer
is unset and the mapping address is unmapped (INVALIDATED).
So that we can deploy the new APIs to Linux with minimal effort by just
invoking acpi_get_table() in acpi_get_table_with_size() and invoking
acpi_put_table() in early_acpi_os_unmap_memory(). Lv Zheng.
Link: https://github.com/acpica/acpica/commit/cac67909
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-12-14 07:04:25 +00:00
|
|
|
acpi_status
|
|
|
|
|
acpi_tb_get_table(struct acpi_table_desc *table_desc,
|
|
|
|
|
struct acpi_table_header **out_table);
|
|
|
|
|
|
|
|
|
|
void acpi_tb_put_table(struct acpi_table_desc *table_desc);
|
|
|
|
|
|
2015-08-25 02:29:33 +00:00
|
|
|
/*
|
|
|
|
|
* tbxfload
|
|
|
|
|
*/
|
|
|
|
|
acpi_status acpi_tb_load_namespace(void);
|
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
#endif /* __ACTABLES_H__ */
|
