6464695 acpica: update to Intel ACPI CA 20080829

6747548 acpica: must check size of buffers returned from AcpiEvaluateObject()

--HG--
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsfield.c => usr/src/uts/intel/io/acpica/dispatcher/dsfield.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsinit.c => usr/src/uts/intel/io/acpica/dispatcher/dsinit.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsmethod.c => usr/src/uts/intel/io/acpica/dispatcher/dsmethod.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsmthdat.c => usr/src/uts/intel/io/acpica/dispatcher/dsmthdat.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsobject.c => usr/src/uts/intel/io/acpica/dispatcher/dsobject.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsopcode.c => usr/src/uts/intel/io/acpica/dispatcher/dsopcode.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dsutils.c => usr/src/uts/intel/io/acpica/dispatcher/dsutils.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dswexec.c => usr/src/uts/intel/io/acpica/dispatcher/dswexec.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dswload.c => usr/src/uts/intel/io/acpica/dispatcher/dswload.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dswscope.c => usr/src/uts/intel/io/acpica/dispatcher/dswscope.c
rename : usr/src/uts/intel/io/acpica/interpreter/dispatcher/dswstate.c => usr/src/uts/intel/io/acpica/dispatcher/dswstate.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exconfig.c => usr/src/uts/intel/io/acpica/executer/exconfig.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exconvrt.c => usr/src/uts/intel/io/acpica/executer/exconvrt.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/excreate.c => usr/src/uts/intel/io/acpica/executer/excreate.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exdump.c => usr/src/uts/intel/io/acpica/executer/exdump.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exfield.c => usr/src/uts/intel/io/acpica/executer/exfield.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exfldio.c => usr/src/uts/intel/io/acpica/executer/exfldio.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exmisc.c => usr/src/uts/intel/io/acpica/executer/exmisc.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exmutex.c => usr/src/uts/intel/io/acpica/executer/exmutex.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exnames.c => usr/src/uts/intel/io/acpica/executer/exnames.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exoparg1.c => usr/src/uts/intel/io/acpica/executer/exoparg1.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exoparg2.c => usr/src/uts/intel/io/acpica/executer/exoparg2.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exoparg3.c => usr/src/uts/intel/io/acpica/executer/exoparg3.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exoparg6.c => usr/src/uts/intel/io/acpica/executer/exoparg6.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exprep.c => usr/src/uts/intel/io/acpica/executer/exprep.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exregion.c => usr/src/uts/intel/io/acpica/executer/exregion.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exresnte.c => usr/src/uts/intel/io/acpica/executer/exresnte.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exresolv.c => usr/src/uts/intel/io/acpica/executer/exresolv.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exresop.c => usr/src/uts/intel/io/acpica/executer/exresop.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exstore.c => usr/src/uts/intel/io/acpica/executer/exstore.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exstoren.c => usr/src/uts/intel/io/acpica/executer/exstoren.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exstorob.c => usr/src/uts/intel/io/acpica/executer/exstorob.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exsystem.c => usr/src/uts/intel/io/acpica/executer/exsystem.c
rename : usr/src/uts/intel/io/acpica/interpreter/executer/exutils.c => usr/src/uts/intel/io/acpica/executer/exutils.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psargs.c => usr/src/uts/intel/io/acpica/parser/psargs.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psloop.c => usr/src/uts/intel/io/acpica/parser/psloop.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psopcode.c => usr/src/uts/intel/io/acpica/parser/psopcode.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psparse.c => usr/src/uts/intel/io/acpica/parser/psparse.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psscope.c => usr/src/uts/intel/io/acpica/parser/psscope.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/pstree.c => usr/src/uts/intel/io/acpica/parser/pstree.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psutils.c => usr/src/uts/intel/io/acpica/parser/psutils.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/pswalk.c => usr/src/uts/intel/io/acpica/parser/pswalk.c
rename : usr/src/uts/intel/io/acpica/interpreter/parser/psxface.c => usr/src/uts/intel/io/acpica/parser/psxface.c

1 files changed, 373 insertions, 350 deletions

diff --git a/usr/src/uts/intel/io/acpica/tables/tbinstal.c b/usr/src/uts/intel/io/acpica/tables/tbinstal.c
index b192646abb..b8325cd4ae 100644
--- a/usr/src/uts/intel/io/acpica/tables/tbinstal.c
+++ b/usr/src/uts/intel/io/acpica/tables/tbinstal.c
@@ -1,7 +1,7 @@
 /******************************************************************************
  *
  * Module Name: tbinstal - ACPI table installation and removal
- *              $Revision: 1.87 $
+ *              $Revision: 1.94 $
  *
  *****************************************************************************/
 
@@ -9,7 +9,7 @@
  *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2008, Intel Corp.
  * All rights reserved.
  *
  * 2. License
@@ -118,138 +118,191 @@
 #define __TBINSTAL_C__
 
 #include "acpi.h"
+#include "acnamesp.h"
 #include "actables.h"
 
 
 #define _COMPONENT          ACPI_TABLES
         ACPI_MODULE_NAME    ("tbinstal")
 
-/* Local prototypes */
 
-static ACPI_STATUS
-AcpiTbMatchSignature (
-    char                    *Signature,
-    ACPI_TABLE_DESC         *TableInfo,
-    UINT8                   SearchType);
-
-
-/*******************************************************************************
+/******************************************************************************
  *
- * FUNCTION:    AcpiTbMatchSignature
+ * FUNCTION:    AcpiTbVerifyTable
  *
- * PARAMETERS:  Signature           - Table signature to match
- *              TableInfo           - Return data
- *              SearchType          - Table type to match (primary/secondary)
+ * PARAMETERS:  TableDesc           - table
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Compare signature against the list of "ACPI-subsystem-owned"
- *              tables (DSDT/FADT/SSDT, etc.) Returns the TableTypeID on match.
+ * DESCRIPTION: this function is called to verify and map table
  *
- ******************************************************************************/
+ *****************************************************************************/
 
-static ACPI_STATUS
-AcpiTbMatchSignature (
-    char                    *Signature,
-    ACPI_TABLE_DESC         *TableInfo,
-    UINT8                   SearchType)
+ACPI_STATUS
+AcpiTbVerifyTable (
+    ACPI_TABLE_DESC         *TableDesc)
 {
-    ACPI_NATIVE_UINT        i;
+    ACPI_STATUS             Status = AE_OK;
 
 
-    ACPI_FUNCTION_TRACE (TbMatchSignature);
+    ACPI_FUNCTION_TRACE (TbVerifyTable);
 
 
-    /* Search for a signature match among the known table types */
+    /* Map the table if necessary */
 
-    for (i = 0; i < (ACPI_TABLE_ID_MAX+1); i++)
+    if (!TableDesc->Pointer)
     {
-        if (!(AcpiGbl_TableData[i].Flags & SearchType))
+        if ((TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) ==
+            ACPI_TABLE_ORIGIN_MAPPED)
         {
-            continue;
+            TableDesc->Pointer = AcpiOsMapMemory (TableDesc->Address, TableDesc->Length);
         }
 
-        if (!ACPI_STRNCMP (Signature, AcpiGbl_TableData[i].Signature,
-                AcpiGbl_TableData[i].SigLength))
+        if (!TableDesc->Pointer)
         {
-            /* Found a signature match, return index if requested */
+            return_ACPI_STATUS (AE_NO_MEMORY);
+        }
+    }
 
-            if (TableInfo)
-            {
-                TableInfo->Type = (UINT8) i;
-            }
+    /* FACS is the odd table, has no standard ACPI header and no checksum */
 
-            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-                "Table [%4.4s] is an ACPI table consumed by the core subsystem\n",
-                (char *) AcpiGbl_TableData[i].Signature));
+    if (!ACPI_COMPARE_NAME (&TableDesc->Signature, ACPI_SIG_FACS))
+    {
+        /* Always calculate checksum, ignore bad checksum if requested */
 
-            return_ACPI_STATUS (AE_OK);
-        }
+        Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length);
     }
 
-    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
-        "Table [%4.4s] is not an ACPI table consumed by the core subsystem - ignored\n",
-        (char *) Signature));
-
-    return_ACPI_STATUS (AE_TABLE_NOT_SUPPORTED);
+    return_ACPI_STATUS (Status);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbInstallTable
+ * FUNCTION:    AcpiTbAddTable
  *
- * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
+ * PARAMETERS:  TableDesc           - Table descriptor
+ *              TableIndex          - Where the table index is returned
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Install the table into the global data structures.
+ * DESCRIPTION: This function is called to add the ACPI table
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiTbInstallTable (
-    ACPI_TABLE_DESC         *TableInfo)
+AcpiTbAddTable (
+    ACPI_TABLE_DESC         *TableDesc,
+    UINT32                  *TableIndex)
 {
-    ACPI_STATUS             Status;
-
+    UINT32                  i;
+    ACPI_STATUS             Status = AE_OK;
 
-    ACPI_FUNCTION_TRACE (TbInstallTable);
 
+    ACPI_FUNCTION_TRACE (TbAddTable);
 
-    /* Lock tables while installing */
 
-    Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
-    if (ACPI_FAILURE (Status))
+    if (!TableDesc->Pointer)
     {
-        ACPI_EXCEPTION ((AE_INFO, Status, "Could not acquire table mutex"));
-        return_ACPI_STATUS (Status);
+        Status = AcpiTbVerifyTable (TableDesc);
+        if (ACPI_FAILURE (Status) || !TableDesc->Pointer)
+        {
+            return_ACPI_STATUS (Status);
+        }
     }
 
     /*
-     * Ignore a table that is already installed. For example, some BIOS
-     * ASL code will repeatedly attempt to load the same SSDT.
+     * Originally, we checked the table signature for "SSDT" or "PSDT" here.
+     * Next, we added support for OEMx tables, signature "OEM".
+     * Valid tables were encountered with a null signature, so we've just
+     * given up on validating the signature, since it seems to be a waste
+     * of code. The original code was removed (05/2008).
      */
-    Status = AcpiTbIsTableInstalled (TableInfo);
-    if (ACPI_FAILURE (Status))
+
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+
+    /* Check if table is already registered */
+
+    for (i = 0; i < AcpiGbl_RootTableList.Count; ++i)
     {
-        goto UnlockAndExit;
+        if (!AcpiGbl_RootTableList.Tables[i].Pointer)
+        {
+            Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]);
+            if (ACPI_FAILURE (Status) || !AcpiGbl_RootTableList.Tables[i].Pointer)
+            {
+                continue;
+            }
+        }
+
+        /*
+         * Check for a table match on the entire table length,
+         * not just the header.
+         */
+        if (TableDesc->Length != AcpiGbl_RootTableList.Tables[i].Length)
+        {
+            continue;
+        }
+
+        if (ACPI_MEMCMP (TableDesc->Pointer,
+                AcpiGbl_RootTableList.Tables[i].Pointer,
+                AcpiGbl_RootTableList.Tables[i].Length))
+        {
+            continue;
+        }
+
+        /*
+         * Note: the current mechanism does not unregister a table if it is
+         * dynamically unloaded. The related namespace entries are deleted,
+         * but the table remains in the root table list.
+         *
+         * The assumption here is that the number of different tables that
+         * will be loaded is actually small, and there is minimal overhead
+         * in just keeping the table in case it is needed again.
+         *
+         * If this assumption changes in the future (perhaps on large
+         * machines with many table load/unload operations), tables will
+         * need to be unregistered when they are unloaded, and slots in the
+         * root table list should be reused when empty.
+         */
+
+        /*
+         * Table is already registered.
+         * We can delete the table that was passed as a parameter.
+         */
+        AcpiTbDeleteTable (TableDesc);
+        *TableIndex = i;
+
+        if (AcpiGbl_RootTableList.Tables[i].Flags & ACPI_TABLE_IS_LOADED)
+        {
+            /* Table is still loaded, this is an error */
+
+            Status = AE_ALREADY_EXISTS;
+            goto Release;
+        }
+        else
+        {
+            /* Table was unloaded, allow it to be reloaded */
+
+            TableDesc->Pointer = AcpiGbl_RootTableList.Tables[i].Pointer;
+            TableDesc->Address = AcpiGbl_RootTableList.Tables[i].Address;
+            Status = AE_OK;
+            goto PrintHeader;
+        }
     }
 
-    /* Install the table into the global data structure */
+    /* Add the table to the global root table list */
 
-    Status = AcpiTbInitTableDescriptor (TableInfo->Type, TableInfo);
+    Status = AcpiTbStoreTable (TableDesc->Address, TableDesc->Pointer,
+                TableDesc->Length, TableDesc->Flags, TableIndex);
     if (ACPI_FAILURE (Status))
     {
-        ACPI_EXCEPTION ((AE_INFO, Status, "Could not install table [%4.4s]",
-            TableInfo->Pointer->Signature));
+        goto Release;
     }
 
-    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p\n",
-        AcpiGbl_TableData[TableInfo->Type].Name, TableInfo->Pointer));
-
+PrintHeader:
+    AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
 
-UnlockAndExit:
+Release:
     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
     return_ACPI_STATUS (Status);
 }
@@ -257,442 +310,412 @@ UnlockAndExit:
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbRecognizeTable
+ * FUNCTION:    AcpiTbResizeRootTableList
  *
- * PARAMETERS:  TableInfo           - Return value from AcpiTbGetTableBody
- *              SearchType          - Table type to match (primary/secondary)
+ * PARAMETERS:  None
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Check a table signature for a match against known table types
- *
- * NOTE:  All table pointers are validated as follows:
- *          1) Table pointer must point to valid physical memory
- *          2) Signature must be 4 ASCII chars, even if we don't recognize the
- *             name
- *          3) Table must be readable for length specified in the header
- *          4) Table checksum must be valid (with the exception of the FACS
- *             which has no checksum for some odd reason)
+ * DESCRIPTION: Expand the size of global table array
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiTbRecognizeTable (
-    ACPI_TABLE_DESC         *TableInfo,
-    UINT8                   SearchType)
+AcpiTbResizeRootTableList (
+    void)
 {
-    ACPI_TABLE_HEADER       *TableHeader;
-    ACPI_STATUS             Status;
+    ACPI_TABLE_DESC         *Tables;
 
 
-    ACPI_FUNCTION_TRACE (TbRecognizeTable);
+    ACPI_FUNCTION_TRACE (TbResizeRootTableList);
 
 
-    /* Ensure that we have a valid table pointer */
+    /* AllowResize flag is a parameter to AcpiInitializeTables */
 
-    TableHeader = (ACPI_TABLE_HEADER *) TableInfo->Pointer;
-    if (!TableHeader)
+    if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE))
     {
-        return_ACPI_STATUS (AE_BAD_PARAMETER);
+        ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed"));
+        return_ACPI_STATUS (AE_SUPPORT);
     }
 
-    /*
-     * We only "recognize" a limited number of ACPI tables -- namely, the
-     * ones that are used by the subsystem (DSDT, FADT, etc.)
-     *
-     * An AE_TABLE_NOT_SUPPORTED means that the table was not recognized.
-     * This can be any one of many valid ACPI tables, it just isn't one of
-     * the tables that is consumed by the core subsystem
-     */
-    Status = AcpiTbMatchSignature (TableHeader->Signature,
-                TableInfo, SearchType);
-    if (ACPI_FAILURE (Status))
+    /* Increase the Table Array size */
+
+    Tables = ACPI_ALLOCATE_ZEROED (
+        ((ACPI_SIZE) AcpiGbl_RootTableList.Size + ACPI_ROOT_TABLE_SIZE_INCREMENT)
+        * sizeof (ACPI_TABLE_DESC));
+    if (!Tables)
     {
-        return_ACPI_STATUS (Status);
+        ACPI_ERROR ((AE_INFO, "Could not allocate new root table array"));
+        return_ACPI_STATUS (AE_NO_MEMORY);
     }
 
-    Status = AcpiTbValidateTableHeader (TableHeader);
-    if (ACPI_FAILURE (Status))
+    /* Copy and free the previous table array */
+
+    if (AcpiGbl_RootTableList.Tables)
     {
-        return_ACPI_STATUS (Status);
+        ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables,
+            (ACPI_SIZE) AcpiGbl_RootTableList.Size * sizeof (ACPI_TABLE_DESC));
+
+        if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
+        {
+            ACPI_FREE (AcpiGbl_RootTableList.Tables);
+        }
     }
 
-    /* Return the table type and length via the info struct */
+    AcpiGbl_RootTableList.Tables = Tables;
+    AcpiGbl_RootTableList.Size += ACPI_ROOT_TABLE_SIZE_INCREMENT;
+    AcpiGbl_RootTableList.Flags |= (UINT8) ACPI_ROOT_ORIGIN_ALLOCATED;
 
-    TableInfo->Length = (ACPI_SIZE) TableHeader->Length;
-    return_ACPI_STATUS (Status);
+    return_ACPI_STATUS (AE_OK);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbInitTableDescriptor
+ * FUNCTION:    AcpiTbStoreTable
  *
- * PARAMETERS:  TableType           - The type of the table
- *              TableInfo           - A table info struct
+ * PARAMETERS:  Address             - Table address
+ *              Table               - Table header
+ *              Length              - Table length
+ *              Flags               - flags
  *
- * RETURN:      None.
+ * RETURN:      Status and table index.
  *
- * DESCRIPTION: Install a table into the global data structs.
+ * DESCRIPTION: Add an ACPI table to the global table list
  *
  ******************************************************************************/
 
 ACPI_STATUS
-AcpiTbInitTableDescriptor (
-    ACPI_TABLE_TYPE         TableType,
-    ACPI_TABLE_DESC         *TableInfo)
+AcpiTbStoreTable (
+    ACPI_PHYSICAL_ADDRESS   Address,
+    ACPI_TABLE_HEADER       *Table,
+    UINT32                  Length,
+    UINT8                   Flags,
+    UINT32                  *TableIndex)
 {
-    ACPI_TABLE_LIST         *ListHead;
-    ACPI_TABLE_DESC         *TableDesc;
-    ACPI_STATUS             Status;
-
-
-    ACPI_FUNCTION_TRACE_U32 (TbInitTableDescriptor, TableType);
-
-
-    /* Allocate a descriptor for this table */
+    ACPI_STATUS             Status = AE_OK;
 
-    TableDesc = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_TABLE_DESC));
-    if (!TableDesc)
-    {
-        return_ACPI_STATUS (AE_NO_MEMORY);
-    }
 
-    /* Get a new owner ID for the table */
+    /* Ensure that there is room for the table in the Root Table List */
 
-    Status = AcpiUtAllocateOwnerId (&TableDesc->OwnerId);
-    if (ACPI_FAILURE (Status))
+    if (AcpiGbl_RootTableList.Count >= AcpiGbl_RootTableList.Size)
     {
-        goto ErrorExit1;
-    }
-
-    /* Install the table into the global data structure */
-
-    ListHead = &AcpiGbl_TableLists[TableType];
-
-    /*
-     * Two major types of tables:  1) Only one instance is allowed.  This
-     * includes most ACPI tables such as the DSDT.  2) Multiple instances of
-     * the table are allowed.  This includes SSDT and PSDTs.
-     */
-    if (ACPI_IS_SINGLE_TABLE (AcpiGbl_TableData[TableType].Flags))
-    {
-        /*
-         * Only one table allowed, and a table has alread been installed
-         * at this location, so return an error.
-         */
-        if (ListHead->Next)
+        Status = AcpiTbResizeRootTableList();
+        if (ACPI_FAILURE (Status))
         {
-            Status = AE_ALREADY_EXISTS;
-            goto ErrorExit2;
+            return (Status);
         }
+    }
 
-        TableDesc->Next = ListHead->Next;
-        ListHead->Next = TableDesc;
+    /* Initialize added table */
 
-        if (TableDesc->Next)
-        {
-            TableDesc->Next->Prev = TableDesc;
-        }
+    AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].Address = Address;
+    AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].Pointer = Table;
+    AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].Length = Length;
+    AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].OwnerId = 0;
+    AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].Flags = Flags;
 
-        ListHead->Count++;
-    }
-    else
-    {
-        /*
-         * Link the new table in to the list of tables of this type.
-         * Insert at the end of the list, order IS IMPORTANT.
-         *
-         * TableDesc->Prev & Next are already NULL from calloc()
-         */
-        ListHead->Count++;
+    ACPI_MOVE_32_TO_32 (
+        &(AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.Count].Signature),
+        Table->Signature);
 
-        if (!ListHead->Next)
-        {
-            ListHead->Next = TableDesc;
-        }
-        else
-        {
-            TableDesc->Next = ListHead->Next;
+    *TableIndex = AcpiGbl_RootTableList.Count;
+    AcpiGbl_RootTableList.Count++;
+    return (Status);
+}
 
-            while (TableDesc->Next->Next)
-            {
-                TableDesc->Next = TableDesc->Next->Next;
-            }
 
-            TableDesc->Next->Next = TableDesc;
-            TableDesc->Prev = TableDesc->Next;
-            TableDesc->Next = NULL;
-        }
-    }
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTbDeleteTable
+ *
+ * PARAMETERS:  TableIndex          - Table index
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Delete one internal ACPI table
+ *
+ ******************************************************************************/
 
-    /* Finish initialization of the table descriptor */
+void
+AcpiTbDeleteTable (
+    ACPI_TABLE_DESC         *TableDesc)
+{
 
-    TableDesc->LoadedIntoNamespace = FALSE;
-    TableDesc->Type = (UINT8) TableType;
-    TableDesc->Pointer = TableInfo->Pointer;
-    TableDesc->Length = TableInfo->Length;
-    TableDesc->Allocation = TableInfo->Allocation;
-    TableDesc->AmlStart = (UINT8 *) (TableDesc->Pointer + 1),
-    TableDesc->AmlLength = (UINT32)
-        (TableDesc->Length - (UINT32) sizeof (ACPI_TABLE_HEADER));
+    /* Table must be mapped or allocated */
 
-    /*
-     * Set the appropriate global pointer (if there is one) to point to the
-     * newly installed table
-     */
-    if (AcpiGbl_TableData[TableType].GlobalPtr)
+    if (!TableDesc->Pointer)
     {
-        *(AcpiGbl_TableData[TableType].GlobalPtr) = TableInfo->Pointer;
+        return;
     }
 
-    /* Return Data */
-
-    TableInfo->OwnerId = TableDesc->OwnerId;
-    TableInfo->InstalledDesc = TableDesc;
-    return_ACPI_STATUS (AE_OK);
-
-
-    /* Error exit with cleanup */
-
-ErrorExit2:
+    switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
+    {
+    case ACPI_TABLE_ORIGIN_MAPPED:
+        AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);
+        break;
 
-    AcpiUtReleaseOwnerId (&TableDesc->OwnerId);
+    case ACPI_TABLE_ORIGIN_ALLOCATED:
+        ACPI_FREE (TableDesc->Pointer);
+        break;
 
-ErrorExit1:
+    default:
+        break;
+    }
 
-    ACPI_FREE (TableDesc);
-    return_ACPI_STATUS (Status);
+    TableDesc->Pointer = NULL;
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbDeleteAllTables
+ * FUNCTION:    AcpiTbTerminate
  *
- * PARAMETERS:  None.
+ * PARAMETERS:  None
  *
- * RETURN:      None.
+ * RETURN:      None
  *
  * DESCRIPTION: Delete all internal ACPI tables
  *
  ******************************************************************************/
 
 void
-AcpiTbDeleteAllTables (
+AcpiTbTerminate (
     void)
 {
-    ACPI_TABLE_TYPE         Type;
+    UINT32                  i;
 
 
+    ACPI_FUNCTION_TRACE (TbTerminate);
+
+
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+
+    /* Delete the individual tables */
+
+    for (i = 0; i < AcpiGbl_RootTableList.Count; i++)
+    {
+        AcpiTbDeleteTable (&AcpiGbl_RootTableList.Tables[i]);
+    }
+
     /*
-     * Free memory allocated for ACPI tables
-     * Memory can either be mapped or allocated
+     * Delete the root table array if allocated locally. Array cannot be
+     * mapped, so we don't need to check for that flag.
      */
-    for (Type = 0; Type < (ACPI_TABLE_ID_MAX+1); Type++)
+    if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
     {
-        AcpiTbDeleteTablesByType (Type);
+        ACPI_FREE (AcpiGbl_RootTableList.Tables);
     }
+
+    AcpiGbl_RootTableList.Tables = NULL;
+    AcpiGbl_RootTableList.Flags = 0;
+    AcpiGbl_RootTableList.Count = 0;
+
+    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n"));
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbDeleteTablesByType
+ * FUNCTION:    AcpiTbDeleteNamespaceByOwner
  *
- * PARAMETERS:  Type                - The table type to be deleted
+ * PARAMETERS:  TableIndex          - Table index
  *
- * RETURN:      None.
+ * RETURN:      None
  *
- * DESCRIPTION: Delete an internal ACPI table
- *              Locks the ACPI table mutex
+ * DESCRIPTION: Delete all namespace objects created when this table was loaded.
  *
  ******************************************************************************/
 
 void
-AcpiTbDeleteTablesByType (
-    ACPI_TABLE_TYPE         Type)
+AcpiTbDeleteNamespaceByOwner (
+    UINT32                  TableIndex)
 {
-    ACPI_TABLE_DESC         *TableDesc;
-    UINT32                  Count;
-    UINT32                  i;
-
+    ACPI_OWNER_ID           OwnerId;
 
-    ACPI_FUNCTION_TRACE_U32 (TbDeleteTablesByType, Type);
 
-
-    if (Type > ACPI_TABLE_ID_MAX)
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
     {
-        return_VOID;
+        OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
     }
-
-    if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_TABLES)))
+    else
     {
+        (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
         return;
     }
 
-    /* Clear the appropriate "typed" global table pointer */
-
-    switch (Type)
-    {
-    case ACPI_TABLE_ID_RSDP:
-        AcpiGbl_RSDP = NULL;
-        break;
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
+    AcpiNsDeleteNamespaceByOwner (OwnerId);
+}
 
-    case ACPI_TABLE_ID_DSDT:
-        AcpiGbl_DSDT = NULL;
-        break;
 
-    case ACPI_TABLE_ID_FADT:
-        AcpiGbl_FADT = NULL;
-        break;
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTbAllocateOwnerId
+ *
+ * PARAMETERS:  TableIndex          - Table index
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Allocates OwnerId in TableDesc
+ *
+ ******************************************************************************/
 
-    case ACPI_TABLE_ID_FACS:
-        AcpiGbl_FACS = NULL;
-        break;
+ACPI_STATUS
+AcpiTbAllocateOwnerId (
+    UINT32                  TableIndex)
+{
+    ACPI_STATUS             Status = AE_BAD_PARAMETER;
 
-    case ACPI_TABLE_ID_XSDT:
-        AcpiGbl_XSDT = NULL;
-        break;
 
-    case ACPI_TABLE_ID_SSDT:
-    case ACPI_TABLE_ID_PSDT:
-    default:
-        break;
-    }
+    ACPI_FUNCTION_TRACE (TbAllocateOwnerId);
 
-    /*
-     * Free the table
-     * 1) Get the head of the list
-     */
-    TableDesc = AcpiGbl_TableLists[Type].Next;
-    Count = AcpiGbl_TableLists[Type].Count;
 
-    /*
-     * 2) Walk the entire list, deleting both the allocated tables
-     *    and the table descriptors
-     */
-    for (i = 0; i < Count; i++)
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
     {
-        TableDesc = AcpiTbUninstallTable (TableDesc);
+        Status = AcpiUtAllocateOwnerId
+                    (&(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
     }
 
     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
-    return_VOID;
+    return_ACPI_STATUS (Status);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbDeleteSingleTable
+ * FUNCTION:    AcpiTbReleaseOwnerId
  *
- * PARAMETERS:  TableInfo           - A table info struct
+ * PARAMETERS:  TableIndex          - Table index
  *
- * RETURN:      None.
+ * RETURN:      Status
  *
- * DESCRIPTION: Low-level free for a single ACPI table.  Handles cases where
- *              the table was allocated a buffer or was mapped.
+ * DESCRIPTION: Releases OwnerId in TableDesc
  *
  ******************************************************************************/
 
-void
-AcpiTbDeleteSingleTable (
-    ACPI_TABLE_DESC         *TableDesc)
+ACPI_STATUS
+AcpiTbReleaseOwnerId (
+    UINT32                  TableIndex)
 {
+    ACPI_STATUS             Status = AE_BAD_PARAMETER;
 
-    /* Must have a valid table descriptor and pointer */
 
-    if ((!TableDesc) ||
-         (!TableDesc->Pointer))
-    {
-        return;
-    }
+    ACPI_FUNCTION_TRACE (TbReleaseOwnerId);
 
-    /* Valid table, determine type of memory allocation */
 
-    switch (TableDesc->Allocation)
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
     {
-    case ACPI_MEM_NOT_ALLOCATED:
-        break;
-
-    case ACPI_MEM_ALLOCATED:
-
-        ACPI_FREE (TableDesc->Pointer);
-        break;
-
-    case ACPI_MEM_MAPPED:
-
-        AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);
-        break;
-
-    default:
-        break;
+        AcpiUtReleaseOwnerId (&(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
+        Status = AE_OK;
     }
+
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
+    return_ACPI_STATUS (Status);
 }
 
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiTbUninstallTable
+ * FUNCTION:    AcpiTbGetOwnerId
  *
- * PARAMETERS:  TableInfo           - A table info struct
+ * PARAMETERS:  TableIndex          - Table index
+ *              OwnerId             - Where the table OwnerId is returned
  *
- * RETURN:      Pointer to the next table in the list (of same type)
+ * RETURN:      Status
  *
- * DESCRIPTION: Free the memory associated with an internal ACPI table that
- *              is either installed or has never been installed.
- *              Table mutex should be locked.
+ * DESCRIPTION: returns OwnerId for the ACPI table
  *
  ******************************************************************************/
 
-ACPI_TABLE_DESC *
-AcpiTbUninstallTable (
-    ACPI_TABLE_DESC         *TableDesc)
+ACPI_STATUS
+AcpiTbGetOwnerId (
+    UINT32                  TableIndex,
+    ACPI_OWNER_ID           *OwnerId)
 {
-    ACPI_TABLE_DESC         *NextDesc;
+    ACPI_STATUS             Status = AE_BAD_PARAMETER;
 
 
-    ACPI_FUNCTION_TRACE_PTR (TbUninstallTable, TableDesc);
+    ACPI_FUNCTION_TRACE (TbGetOwnerId);
 
 
-    if (!TableDesc)
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
     {
-        return_PTR (NULL);
+        *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
+        Status = AE_OK;
     }
 
-    /* Unlink the descriptor from the doubly linked list */
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
+    return_ACPI_STATUS (Status);
+}
 
-    if (TableDesc->Prev)
-    {
-        TableDesc->Prev->Next = TableDesc->Next;
-    }
-    else
-    {
-        /* Is first on list, update list head */
 
-        AcpiGbl_TableLists[TableDesc->Type].Next = TableDesc->Next;
-    }
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTbIsTableLoaded
+ *
+ * PARAMETERS:  TableIndex          - Table index
+ *
+ * RETURN:      Table Loaded Flag
+ *
+ ******************************************************************************/
 
-    if (TableDesc->Next)
-    {
-        TableDesc->Next->Prev = TableDesc->Prev;
-    }
+BOOLEAN
+AcpiTbIsTableLoaded (
+    UINT32                  TableIndex)
+{
+    BOOLEAN                 IsLoaded = FALSE;
 
-    /* Free the memory allocated for the table itself */
 
-    AcpiTbDeleteSingleTable (TableDesc);
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
+    {
+        IsLoaded = (BOOLEAN)
+            (AcpiGbl_RootTableList.Tables[TableIndex].Flags & ACPI_TABLE_IS_LOADED);
+    }
 
-    /* Free the owner ID associated with this table */
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
+    return (IsLoaded);
+}
 
-    AcpiUtReleaseOwnerId (&TableDesc->OwnerId);
 
-    /* Free the table descriptor */
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiTbSetTableLoadedFlag
+ *
+ * PARAMETERS:  TableIndex          - Table index
+ *              IsLoaded            - TRUE if table is loaded, FALSE otherwise
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
+ *
+ ******************************************************************************/
 
-    NextDesc = TableDesc->Next;
-    ACPI_FREE (TableDesc);
+void
+AcpiTbSetTableLoadedFlag (
+    UINT32                  TableIndex,
+    BOOLEAN                 IsLoaded)
+{
 
-    /* Return pointer to the next descriptor */
+    (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
+    if (TableIndex < AcpiGbl_RootTableList.Count)
+    {
+        if (IsLoaded)
+        {
+            AcpiGbl_RootTableList.Tables[TableIndex].Flags |= ACPI_TABLE_IS_LOADED;
+        }
+        else
+        {
+            AcpiGbl_RootTableList.Tables[TableIndex].Flags &= ~ACPI_TABLE_IS_LOADED;
+        }
+    }
 
-    return_PTR (NextDesc);
+    (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 }