1 files changed, 205 insertions, 19 deletions

diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 9eaf708f5885..3ff267861541 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -534,6 +534,137 @@ acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
         return AE_OK;
 }
 
+#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
+#include <linux/earlycpio.h>
+#include <linux/memblock.h>
+
+static u64 acpi_tables_addr;
+static int all_tables_size;
+
+/* Copied from acpica/tbutils.c:acpi_tb_checksum() */
+u8 __init acpi_table_checksum(u8 *buffer, u32 length)
+{
+        u8 sum = 0;
+        u8 *end = buffer + length;
+
+        while (buffer < end)
+                sum = (u8) (sum + *(buffer++));
+        return sum;
+}
+
+/* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
+static const char * const table_sigs[] = {
+        ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
+        ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
+        ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
+        ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
+        ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
+        ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
+        ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
+        ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
+        ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
+
+/* Non-fatal errors: Affected tables/files are ignored */
+#define INVALID_TABLE(x, path, name)                                    \
+        { pr_err("ACPI OVERRIDE: " x " [%s%s]\n", path, name); continue; }
+
+#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
+
+/* Must not increase 10 or needs code modification below */
+#define ACPI_OVERRIDE_TABLES 10
+
+void __init acpi_initrd_override(void *data, size_t size)
+{
+        int sig, no, table_nr = 0, total_offset = 0;
+        long offset = 0;
+        struct acpi_table_header *table;
+        char cpio_path[32] = "kernel/firmware/acpi/";
+        struct cpio_data file;
+        struct cpio_data early_initrd_files[ACPI_OVERRIDE_TABLES];
+        char *p;
+
+        if (data == NULL || size == 0)
+                return;
+
+        for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
+                file = find_cpio_data(cpio_path, data, size, &offset);
+                if (!file.data)
+                        break;
+
+                data += offset;
+                size -= offset;
+
+                if (file.size < sizeof(struct acpi_table_header))
+                        INVALID_TABLE("Table smaller than ACPI header",
+                                      cpio_path, file.name);
+
+                table = file.data;
+
+                for (sig = 0; table_sigs[sig]; sig++)
+                        if (!memcmp(table->signature, table_sigs[sig], 4))
+                                break;
+
+                if (!table_sigs[sig])
+                        INVALID_TABLE("Unknown signature",
+                                      cpio_path, file.name);
+                if (file.size != table->length)
+                        INVALID_TABLE("File length does not match table length",
+                                      cpio_path, file.name);
+                if (acpi_table_checksum(file.data, table->length))
+                        INVALID_TABLE("Bad table checksum",
+                                      cpio_path, file.name);
+
+                pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
+                        table->signature, cpio_path, file.name, table->length);
+
+                all_tables_size += table->length;
+                early_initrd_files[table_nr].data = file.data;
+                early_initrd_files[table_nr].size = file.size;
+                table_nr++;
+        }
+        if (table_nr == 0)
+                return;
+
+        acpi_tables_addr =
+                memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
+                                       all_tables_size, PAGE_SIZE);
+        if (!acpi_tables_addr) {
+                WARN_ON(1);
+                return;
+        }
+        /*
+         * Only calling e820_add_reserve does not work and the
+         * tables are invalid (memory got used) later.
+         * memblock_reserve works as expected and the tables won't get modified.
+         * But it's not enough on X86 because ioremap will
+         * complain later (used by acpi_os_map_memory) that the pages
+         * that should get mapped are not marked "reserved".
+         * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
+         * works fine.
+         */
+        memblock_reserve(acpi_tables_addr, acpi_tables_addr + all_tables_size);
+        arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
+
+        p = early_ioremap(acpi_tables_addr, all_tables_size);
+
+        for (no = 0; no < table_nr; no++) {
+                memcpy(p + total_offset, early_initrd_files[no].data,
+                       early_initrd_files[no].size);
+                total_offset += early_initrd_files[no].size;
+        }
+        early_iounmap(p, all_tables_size);
+}
+#endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE */
+
+static void acpi_table_taint(struct acpi_table_header *table)
+{
+        pr_warn(PREFIX
+                "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
+                table->signature, table->oem_table_id);
+        add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
+}
+
+
 acpi_status
 acpi_os_table_override(struct acpi_table_header * existing_table,
                        struct acpi_table_header ** new_table)
@@ -547,24 +678,73 @@ acpi_os_table_override(struct acpi_table_header * existing_table,
         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
                 *new_table = (struct acpi_table_header *)AmlCode;
 #endif
-        if (*new_table != NULL) {
-                printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
-                           "this is unsafe: tainting kernel\n",
-                       existing_table->signature,
-                       existing_table->oem_table_id);
-                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
-        }
+        if (*new_table != NULL)
+                acpi_table_taint(existing_table);
         return AE_OK;
 }
 
 acpi_status
 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
-                                acpi_physical_address * new_address,
-                                u32 *new_table_length)
+                                acpi_physical_address *address,
+                                u32 *table_length)
 {
-        return AE_SUPPORT;
-}
+#ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
+        *table_length = 0;
+        *address = 0;
+        return AE_OK;
+#else
+        int table_offset = 0;
+        struct acpi_table_header *table;
+
+        *table_length = 0;
+        *address = 0;
+
+        if (!acpi_tables_addr)
+                return AE_OK;
+
+        do {
+                if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
+                        WARN_ON(1);
+                        return AE_OK;
+                }
+
+                table = acpi_os_map_memory(acpi_tables_addr + table_offset,
+                                           ACPI_HEADER_SIZE);
+
+                if (table_offset + table->length > all_tables_size) {
+                        acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
+                        WARN_ON(1);
+                        return AE_OK;
+                }
 
+                table_offset += table->length;
+
+                if (memcmp(existing_table->signature, table->signature, 4)) {
+                        acpi_os_unmap_memory(table,
+                                     ACPI_HEADER_SIZE);
+                        continue;
+                }
+
+                /* Only override tables with matching oem id */
+                if (memcmp(table->oem_table_id, existing_table->oem_table_id,
+                           ACPI_OEM_TABLE_ID_SIZE)) {
+                        acpi_os_unmap_memory(table,
+                                     ACPI_HEADER_SIZE);
+                        continue;
+                }
+
+                table_offset -= table->length;
+                *table_length = table->length;
+                acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
+                *address = acpi_tables_addr + table_offset;
+                break;
+        } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
+
+        if (*address != 0)
+                acpi_table_taint(existing_table);
+        return AE_OK;
+#endif
+}
 
 static irqreturn_t acpi_irq(int irq, void *dev_id)
 {
@@ -932,7 +1112,7 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
          * having a static work_struct.
          */
 
-        dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
+        dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
         if (!dpc)
                 return AE_NO_MEMORY;
 
@@ -944,17 +1124,22 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
          * because the hotplug code may call driver .remove() functions,
          * which invoke flush_scheduled_work/acpi_os_wait_events_complete
          * to flush these workqueues.
+         *
+         * To prevent lockdep from complaining unnecessarily, make sure that
+         * there is a different static lockdep key for each workqueue by using
+         * INIT_WORK() for each of them separately.
          */
-        queue = hp ? kacpi_hotplug_wq :
-                (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
-        dpc->wait = hp ? 1 : 0;
-
-        if (queue == kacpi_hotplug_wq)
+        if (hp) {
+                queue = kacpi_hotplug_wq;
+                dpc->wait = 1;
                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
-        else if (queue == kacpi_notify_wq)
+        } else if (type == OSL_NOTIFY_HANDLER) {
+                queue = kacpi_notify_wq;
                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
-        else
+        } else {
+                queue = kacpid_wq;
                 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
+        }
 
         /*
          * On some machines, a software-initiated SMI causes corruption unless
@@ -986,6 +1171,7 @@ acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
 {
         return __acpi_os_execute(0, function, context, 1);
 }
+EXPORT_SYMBOL(acpi_os_hotplug_execute);
 
 void acpi_os_wait_events_complete(void)
 {