9 files changed, 484 insertions, 12 deletions

diff --git a/Documentation/acpi/initrd_table_override.txt b/Documentation/acpi/initrd_table_override.txt
new file mode 100644
index 000000000000..35c3f5415476
--- /dev/null
+++ b/Documentation/acpi/initrd_table_override.txt
@@ -0,0 +1,94 @@
+Overriding ACPI tables via initrd
+=================================
+
+1) Introduction (What is this about)
+2) What is this for
+3) How does it work
+4) References (Where to retrieve userspace tools)
+
+1) What is this about
+---------------------
+
+If the ACPI_INITRD_TABLE_OVERRIDE compile option is true, it is possible to
+override nearly any ACPI table provided by the BIOS with an instrumented,
+modified one.
+
+For a full list of ACPI tables that can be overridden, take a look at
+the char *table_sigs[MAX_ACPI_SIGNATURE]; definition in drivers/acpi/osl.c
+All ACPI tables iasl (Intel's ACPI compiler and disassembler) knows should
+be overridable, except:
+   - ACPI_SIG_RSDP (has a signature of 6 bytes)
+   - ACPI_SIG_FACS (does not have an ordinary ACPI table header)
+Both could get implemented as well.
+
+
+2) What is this for
+-------------------
+
+Please keep in mind that this is a debug option.
+ACPI tables should not get overridden for productive use.
+If BIOS ACPI tables are overridden the kernel will get tainted with the
+TAINT_OVERRIDDEN_ACPI_TABLE flag.
+Complain to your platform/BIOS vendor if you find a bug which is so sever
+that a workaround is not accepted in the Linux kernel.
+
+Still, it can and should be enabled in any kernel, because:
+  - There is no functional change with not instrumented initrds
+  - It provides a powerful feature to easily debug and test ACPI BIOS table
+    compatibility with the Linux kernel.
+
+
+3) How does it work
+-------------------
+
+# Extract the machine's ACPI tables:
+cd /tmp
+acpidump >acpidump
+acpixtract -a acpidump
+# Disassemble, modify and recompile them:
+iasl -d *.dat
+# For example add this statement into a _PRT (PCI Routing Table) function
+# of the DSDT:
+Store("HELLO WORLD", debug)
+iasl -sa dsdt.dsl
+# Add the raw ACPI tables to an uncompressed cpio archive.
+# They must be put into a /kernel/firmware/acpi directory inside the
+# cpio archive.
+# The uncompressed cpio archive must be the first.
+# Other, typically compressed cpio archives, must be
+# concatenated on top of the uncompressed one.
+mkdir -p kernel/firmware/acpi
+cp dsdt.aml kernel/firmware/acpi
+# A maximum of: #define ACPI_OVERRIDE_TABLES 10
+# tables are  currently allowed (see osl.c):
+iasl -sa facp.dsl
+iasl -sa ssdt1.dsl
+cp facp.aml kernel/firmware/acpi
+cp ssdt1.aml kernel/firmware/acpi
+# Create the uncompressed cpio archive and concatenate the original initrd
+# on top:
+find kernel | cpio -H newc --create > /boot/instrumented_initrd
+cat /boot/initrd >>/boot/instrumented_initrd
+# reboot with increased acpi debug level, e.g. boot params:
+acpi.debug_level=0x2 acpi.debug_layer=0xFFFFFFFF
+# and check your syslog:
+[    1.268089] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT]
+[    1.272091] [ACPI Debug]  String [0x0B] "HELLO WORLD"
+
+iasl is able to disassemble and recompile quite a lot different,
+also static ACPI tables.
+
+
+4) Where to retrieve userspace tools
+------------------------------------
+
+iasl and acpixtract are part of Intel's ACPICA project:
+http://acpica.org/
+and should be packaged by distributions (for example in the acpica package
+on SUSE).
+
+acpidump can be found in Len Browns pmtools:
+ftp://kernel.org/pub/linux/kernel/people/lenb/acpi/utils/pmtools/acpidump
+This tool is also part of the acpica package on SUSE.
+Alternatively, used ACPI tables can be retrieved via sysfs in latest kernels:
+/sys/firmware/acpi/tables
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index e48cafcf92ae..bacf4b0d91f4 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -1706,3 +1706,9 @@ int __acpi_release_global_lock(unsigned int *lock)
         } while (unlikely (val != old));
         return old & 0x1;
 }
+
+void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
+{
+        e820_add_region(addr, size, E820_ACPI);
+        update_e820();
+}
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index c228322ca180..23ddd558fbd5 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -952,6 +952,10 @@ void __init setup_arch(char **cmdline_p)
 
         reserve_initrd();
 
+#if defined(CONFIG_ACPI) && defined(CONFIG_BLK_DEV_INITRD)
+        acpi_initrd_override((void *)initrd_start, initrd_end - initrd_start);
+#endif
+
         reserve_crashkernel();
 
         vsmp_init();
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 0300bf612946..38c5078da11d 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -267,6 +267,15 @@ config ACPI_CUSTOM_DSDT
         bool
         default ACPI_CUSTOM_DSDT_FILE != ""
 
+config ACPI_INITRD_TABLE_OVERRIDE
+        bool "ACPI tables can be passed via uncompressed cpio in initrd"
+        default n
+        help
+          This option provides functionality to override arbitrary ACPI tables
+          via initrd. No functional change if no ACPI tables are passed via
+          initrd, therefore it's safe to say Y.
+          See Documentation/acpi/initrd_table_override.txt for details
+
 config ACPI_BLACKLIST_YEAR
         int "Disable ACPI for systems before Jan 1st this year" if X86_32
         default 0
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 6dc4a2b1e956..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)
 {
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index c33fa3ce9b7c..3994d7790b23 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -78,6 +78,14 @@ typedef int (*acpi_table_handler) (struct acpi_table_header *table);
 
 typedef int (*acpi_table_entry_handler) (struct acpi_subtable_header *header, const unsigned long end);
 
+#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
+void acpi_initrd_override(void *data, size_t size);
+#else
+static inline void acpi_initrd_override(void *data, size_t size)
+{
+}
+#endif
+
 char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
 void __acpi_unmap_table(char *map, unsigned long size);
 int early_acpi_boot_init(void);
@@ -479,6 +487,14 @@ void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
 
 acpi_status acpi_os_prepare_sleep(u8 sleep_state,
                                   u32 pm1a_control, u32 pm1b_control);
+#ifdef CONFIG_X86
+void arch_reserve_mem_area(acpi_physical_address addr, size_t size);
+#else
+static inline void arch_reserve_mem_area(acpi_physical_address addr,
+                                          size_t size)
+{
+}
+#endif /* CONFIG_X86 */
 #else
 #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
 #endif
diff --git a/include/linux/earlycpio.h b/include/linux/earlycpio.h
new file mode 100644
index 000000000000..111f46d83d00
--- /dev/null
+++ b/include/linux/earlycpio.h
@@ -0,0 +1,17 @@
+#ifndef _LINUX_EARLYCPIO_H
+#define _LINUX_EARLYCPIO_H
+
+#include <linux/types.h>
+
+#define MAX_CPIO_FILE_NAME 18
+
+struct cpio_data {
+        void *data;
+        size_t size;
+        char name[MAX_CPIO_FILE_NAME];
+};
+
+struct cpio_data find_cpio_data(const char *path, void *data, size_t len,
+                                long *offset);
+
+#endif /* _LINUX_EARLYCPIO_H */
diff --git a/lib/Makefile b/lib/Makefile
index e3723c7527da..e2152fa7ff4d 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -12,7 +12,8 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          idr.o int_sqrt.o extable.o \
          sha1.o md5.o irq_regs.o reciprocal_div.o argv_split.o \
          proportions.o flex_proportions.o prio_heap.o ratelimit.o show_mem.o \
-         is_single_threaded.o plist.o decompress.o kobject_uevent.o
+         is_single_threaded.o plist.o decompress.o kobject_uevent.o \
+         earlycpio.o
 
 lib-$(CONFIG_MMU) += ioremap.o
 lib-$(CONFIG_SMP) += cpumask.o
diff --git a/lib/earlycpio.c b/lib/earlycpio.c
new file mode 100644
index 000000000000..8078ef49cb79
--- /dev/null
+++ b/lib/earlycpio.c
@@ -0,0 +1,145 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2012 Intel Corporation; author H. Peter Anvin
+ *
+ *   This file is part of the Linux kernel, and is made available
+ *   under the terms of the GNU General Public License version 2, as
+ *   published by the Free Software Foundation.
+ *
+ *   This program is distributed in the hope it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   General Public License for more details.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * earlycpio.c
+ *
+ * Find a specific cpio member; must precede any compressed content.
+ * This is used to locate data items in the initramfs used by the
+ * kernel itself during early boot (before the main initramfs is
+ * decompressed.)  It is the responsibility of the initramfs creator
+ * to ensure that these items are uncompressed at the head of the
+ * blob.  Depending on the boot loader or package tool that may be a
+ * separate file or part of the same file.
+ */
+
+#include <linux/earlycpio.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+
+enum cpio_fields {
+        C_MAGIC,
+        C_INO,
+        C_MODE,
+        C_UID,
+        C_GID,
+        C_NLINK,
+        C_MTIME,
+        C_FILESIZE,
+        C_MAJ,
+        C_MIN,
+        C_RMAJ,
+        C_RMIN,
+        C_NAMESIZE,
+        C_CHKSUM,
+        C_NFIELDS
+};
+
+/**
+ * cpio_data find_cpio_data - Search for files in an uncompressed cpio
+ * @path:   The directory to search for, including a slash at the end
+ * @data:   Pointer to the the cpio archive or a header inside
+ * @len:    Remaining length of the cpio based on data pointer
+ * @offset: When a matching file is found, this is the offset to the
+ *          beginning of the cpio. It can be used to iterate through
+ *          the cpio to find all files inside of a directory path
+ *
+ * @return: struct cpio_data containing the address, length and
+ *          filename (with the directory path cut off) of the found file.
+ *          If you search for a filename and not for files in a directory,
+ *          pass the absolute path of the filename in the cpio and make sure
+ *          the match returned an empty filename string.
+ */
+
+struct cpio_data __cpuinit find_cpio_data(const char *path, void *data,
+                                          size_t len,  long *offset)
+{
+        const size_t cpio_header_len = 8*C_NFIELDS - 2;
+        struct cpio_data cd = { NULL, 0, "" };
+        const char *p, *dptr, *nptr;
+        unsigned int ch[C_NFIELDS], *chp, v;
+        unsigned char c, x;
+        size_t mypathsize = strlen(path);
+        int i, j;
+
+        p = data;
+
+        while (len > cpio_header_len) {
+                if (!*p) {
+                        /* All cpio headers need to be 4-byte aligned */
+                        p += 4;
+                        len -= 4;
+                        continue;
+                }
+
+                j = 6;          /* The magic field is only 6 characters */
+                chp = ch;
+                for (i = C_NFIELDS; i; i--) {
+                        v = 0;
+                        while (j--) {
+                                v <<= 4;
+                                c = *p++;
+
+                                x = c - '0';
+                                if (x < 10) {
+                                        v += x;
+                                        continue;
+                                }
+
+                                x = (c | 0x20) - 'a';
+                                if (x < 6) {
+                                        v += x + 10;
+                                        continue;
+                                }
+
+                                goto quit; /* Invalid hexadecimal */
+                        }
+                        *chp++ = v;
+                        j = 8;  /* All other fields are 8 characters */
+                }
+
+                if ((ch[C_MAGIC] - 0x070701) > 1)
+                        goto quit; /* Invalid magic */
+
+                len -= cpio_header_len;
+
+                dptr = PTR_ALIGN(p + ch[C_NAMESIZE], 4);
+                nptr = PTR_ALIGN(dptr + ch[C_FILESIZE], 4);
+
+                if (nptr > p + len || dptr < p || nptr < dptr)
+                        goto quit; /* Buffer overrun */
+
+                if ((ch[C_MODE] & 0170000) == 0100000 &&
+                    ch[C_NAMESIZE] >= mypathsize &&
+                    !memcmp(p, path, mypathsize)) {
+                        *offset = (long)nptr - (long)data;
+                        if (ch[C_NAMESIZE] - mypathsize >= MAX_CPIO_FILE_NAME) {
+                                pr_warn(
+                                "File %s exceeding MAX_CPIO_FILE_NAME [%d]\n",
+                                p, MAX_CPIO_FILE_NAME);
+                        }
+                        strlcpy(cd.name, p + mypathsize, MAX_CPIO_FILE_NAME);
+
+                        cd.data = (void *)dptr;
+                        cd.size = ch[C_FILESIZE];
+                        return cd; /* Found it! */
+                }
+                len -= (nptr - p);
+                p = nptr;
+        }
+
+quit:
+        return cd;
+}