Merge branch 'x86-mce-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull x86 RAS changes from Ingo Molnar:
 "The biggest change adds support for Intel 'CPER' (UEFI Common Platform
  Error Record) error logging, which builds upon an enhanced error
  logging mechanism available on Xeon processors.

  Full description is here:

    http://www.intel.com/content/www/us/en/architecture-and-technology/enhanced-mca-logging-xeon-paper.html

  This change provides a module (and support code) to check for an
  extended error log and prints extra details about the error on the
  console"

* 'x86-mce-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  ACPI, x86: Fix extended error log driver to depend on CONFIG_X86_LOCAL_APIC
  dmi: Avoid unaligned memory access in save_mem_devices()
  Move cper.c from drivers/acpi/apei to drivers/firmware/efi
  EDAC, GHES: Update ghes error record info
  ACPI, APEI, CPER: Cleanup CPER memory error output format
  ACPI, APEI, CPER: Enhance memory reporting capability
  ACPI, APEI, CPER: Add UEFI 2.4 support for memory error
  DMI: Parse memory device (type 17) in SMBIOS
  ACPI, x86: Extended error log driver for x86 platform
  bitops: Introduce a more generic BITMASK macro
  ACPI, CPER: Update cper info
  ACPI, APEI, CPER: Fix status check during error printing

9 files changed, 390 insertions, 439 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 6efe2ac6902f..e11faae81ed9 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -372,4 +372,25 @@ config ACPI_BGRT
 
 source "drivers/acpi/apei/Kconfig"
 
+config ACPI_EXTLOG
+        tristate "Extended Error Log support"
+        depends on X86_MCE && X86_LOCAL_APIC
+        select EFI
+        select UEFI_CPER
+        default n
+        help
+          Certain usages such as Predictive Failure Analysis (PFA) require
+          more information about the error than what can be described in
+          processor machine check banks. Most server processors log
+          additional information about the error in processor uncore
+          registers. Since the addresses and layout of these registers vary
+          widely from one processor to another, system software cannot
+          readily make use of them. To complicate matters further, some of
+          the additional error information cannot be constructed without
+          detailed knowledge about platform topology.
+
+          Enhanced MCA Logging allows firmware to provide additional error
+          information to system software, synchronous with MCE or CMCI. This
+          driver adds support for that functionality.
+
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index cdaf68b58b00..bce34afadcd0 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -82,3 +82,5 @@ processor-$(CONFIG_CPU_FREQ)	+= processor_perflib.o
 obj-$(CONFIG_ACPI_PROCESSOR_AGGREGATOR) += acpi_pad.o
 
 obj-$(CONFIG_ACPI_APEI)         += apei/
+
+obj-$(CONFIG_ACPI_EXTLOG)       += acpi_extlog.o
diff --git a/drivers/acpi/acpi_extlog.c b/drivers/acpi/acpi_extlog.c
new file mode 100644
index 000000000000..a6869e110ce5
--- /dev/null
+++ b/drivers/acpi/acpi_extlog.c
@@ -0,0 +1,327 @@
+/*
+ * Extended Error Log driver
+ *
+ * Copyright (C) 2013 Intel Corp.
+ * Author: Chen, Gong <gong.chen@intel.com>
+ *
+ * This file is licensed under GPLv2.
+ */
+
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <linux/cper.h>
+#include <linux/ratelimit.h>
+#include <asm/cpu.h>
+#include <asm/mce.h>
+
+#include "apei/apei-internal.h"
+
+#define EXT_ELOG_ENTRY_MASK     GENMASK_ULL(51, 0) /* elog entry address mask */
+
+#define EXTLOG_DSM_REV          0x0
+#define EXTLOG_FN_QUERY         0x0
+#define EXTLOG_FN_ADDR          0x1
+
+#define FLAG_OS_OPTIN           BIT(0)
+#define EXTLOG_QUERY_L1_EXIST   BIT(1)
+#define ELOG_ENTRY_VALID        (1ULL<<63)
+#define ELOG_ENTRY_LEN          0x1000
+
+#define EMCA_BUG \
+        "Can not request iomem region <0x%016llx-0x%016llx> - eMCA disabled\n"
+
+struct extlog_l1_head {
+        u32 ver;        /* Header Version */
+        u32 hdr_len;    /* Header Length */
+        u64 total_len;  /* entire L1 Directory length including this header */
+        u64 elog_base;  /* MCA Error Log Directory base address */
+        u64 elog_len;   /* MCA Error Log Directory length */
+        u32 flags;      /* bit 0 - OS/VMM Opt-in */
+        u8  rev0[12];
+        u32 entries;    /* Valid L1 Directory entries per logical processor */
+        u8  rev1[12];
+};
+
+static u8 extlog_dsm_uuid[] = "663E35AF-CC10-41A4-88EA-5470AF055295";
+
+/* L1 table related physical address */
+static u64 elog_base;
+static size_t elog_size;
+static u64 l1_dirbase;
+static size_t l1_size;
+
+/* L1 table related virtual address */
+static void __iomem *extlog_l1_addr;
+static void __iomem *elog_addr;
+
+static void *elog_buf;
+
+static u64 *l1_entry_base;
+static u32 l1_percpu_entry;
+
+#define ELOG_IDX(cpu, bank) \
+        (cpu_physical_id(cpu) * l1_percpu_entry + (bank))
+
+#define ELOG_ENTRY_DATA(idx) \
+        (*(l1_entry_base + (idx)))
+
+#define ELOG_ENTRY_ADDR(phyaddr) \
+        (phyaddr - elog_base + (u8 *)elog_addr)
+
+static struct acpi_generic_status *extlog_elog_entry_check(int cpu, int bank)
+{
+        int idx;
+        u64 data;
+        struct acpi_generic_status *estatus;
+
+        WARN_ON(cpu < 0);
+        idx = ELOG_IDX(cpu, bank);
+        data = ELOG_ENTRY_DATA(idx);
+        if ((data & ELOG_ENTRY_VALID) == 0)
+                return NULL;
+
+        data &= EXT_ELOG_ENTRY_MASK;
+        estatus = (struct acpi_generic_status *)ELOG_ENTRY_ADDR(data);
+
+        /* if no valid data in elog entry, just return */
+        if (estatus->block_status == 0)
+                return NULL;
+
+        return estatus;
+}
+
+static void __print_extlog_rcd(const char *pfx,
+                               struct acpi_generic_status *estatus, int cpu)
+{
+        static atomic_t seqno;
+        unsigned int curr_seqno;
+        char pfx_seq[64];
+
+        if (!pfx) {
+                if (estatus->error_severity <= CPER_SEV_CORRECTED)
+                        pfx = KERN_INFO;
+                else
+                        pfx = KERN_ERR;
+        }
+        curr_seqno = atomic_inc_return(&seqno);
+        snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}", pfx, curr_seqno);
+        printk("%s""Hardware error detected on CPU%d\n", pfx_seq, cpu);
+        cper_estatus_print(pfx_seq, estatus);
+}
+
+static int print_extlog_rcd(const char *pfx,
+                            struct acpi_generic_status *estatus, int cpu)
+{
+        /* Not more than 2 messages every 5 seconds */
+        static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2);
+        static DEFINE_RATELIMIT_STATE(ratelimit_uncorrected, 5*HZ, 2);
+        struct ratelimit_state *ratelimit;
+
+        if (estatus->error_severity == CPER_SEV_CORRECTED ||
+            (estatus->error_severity == CPER_SEV_INFORMATIONAL))
+                ratelimit = &ratelimit_corrected;
+        else
+                ratelimit = &ratelimit_uncorrected;
+        if (__ratelimit(ratelimit)) {
+                __print_extlog_rcd(pfx, estatus, cpu);
+                return 0;
+        }
+
+        return 1;
+}
+
+static int extlog_print(struct notifier_block *nb, unsigned long val,
+                        void *data)
+{
+        struct mce *mce = (struct mce *)data;
+        int     bank = mce->bank;
+        int     cpu = mce->extcpu;
+        struct acpi_generic_status *estatus;
+        int rc;
+
+        estatus = extlog_elog_entry_check(cpu, bank);
+        if (estatus == NULL)
+                return NOTIFY_DONE;
+
+        memcpy(elog_buf, (void *)estatus, ELOG_ENTRY_LEN);
+        /* clear record status to enable BIOS to update it again */
+        estatus->block_status = 0;
+
+        rc = print_extlog_rcd(NULL, (struct acpi_generic_status *)elog_buf, cpu);
+
+        return NOTIFY_DONE;
+}
+
+static int extlog_get_dsm(acpi_handle handle, int rev, int func, u64 *ret)
+{
+        struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
+        struct acpi_object_list input;
+        union acpi_object params[4], *obj;
+        u8 uuid[16];
+        int i;
+
+        acpi_str_to_uuid(extlog_dsm_uuid, uuid);
+        input.count = 4;
+        input.pointer = params;
+        params[0].type = ACPI_TYPE_BUFFER;
+        params[0].buffer.length = 16;
+        params[0].buffer.pointer = uuid;
+        params[1].type = ACPI_TYPE_INTEGER;
+        params[1].integer.value = rev;
+        params[2].type = ACPI_TYPE_INTEGER;
+        params[2].integer.value = func;
+        params[3].type = ACPI_TYPE_PACKAGE;
+        params[3].package.count = 0;
+        params[3].package.elements = NULL;
+
+        if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DSM", &input, &buf)))
+                return -1;
+
+        *ret = 0;
+        obj = (union acpi_object *)buf.pointer;
+        if (obj->type == ACPI_TYPE_INTEGER) {
+                *ret = obj->integer.value;
+        } else if (obj->type == ACPI_TYPE_BUFFER) {
+                if (obj->buffer.length <= 8) {
+                        for (i = 0; i < obj->buffer.length; i++)
+                                *ret |= (obj->buffer.pointer[i] << (i * 8));
+                }
+        }
+        kfree(buf.pointer);
+
+        return 0;
+}
+
+static bool extlog_get_l1addr(void)
+{
+        acpi_handle handle;
+        u64 ret;
+
+        if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
+                return false;
+
+        if (extlog_get_dsm(handle, EXTLOG_DSM_REV, EXTLOG_FN_QUERY, &ret) ||
+            !(ret & EXTLOG_QUERY_L1_EXIST))
+                return false;
+
+        if (extlog_get_dsm(handle, EXTLOG_DSM_REV, EXTLOG_FN_ADDR, &ret))
+                return false;
+
+        l1_dirbase = ret;
+        /* Spec says L1 directory must be 4K aligned, bail out if it isn't */
+        if (l1_dirbase & ((1 << 12) - 1)) {
+                pr_warn(FW_BUG "L1 Directory is invalid at physical %llx\n",
+                        l1_dirbase);
+                return false;
+        }
+
+        return true;
+}
+static struct notifier_block extlog_mce_dec = {
+        .notifier_call  = extlog_print,
+};
+
+static int __init extlog_init(void)
+{
+        struct extlog_l1_head *l1_head;
+        void __iomem *extlog_l1_hdr;
+        size_t l1_hdr_size;
+        struct resource *r;
+        u64 cap;
+        int rc;
+
+        rc = -ENODEV;
+
+        rdmsrl(MSR_IA32_MCG_CAP, cap);
+        if (!(cap & MCG_ELOG_P))
+                return rc;
+
+        if (!extlog_get_l1addr())
+                return rc;
+
+        rc = -EINVAL;
+        /* get L1 header to fetch necessary information */
+        l1_hdr_size = sizeof(struct extlog_l1_head);
+        r = request_mem_region(l1_dirbase, l1_hdr_size, "L1 DIR HDR");
+        if (!r) {
+                pr_warn(FW_BUG EMCA_BUG,
+                        (unsigned long long)l1_dirbase,
+                        (unsigned long long)l1_dirbase + l1_hdr_size);
+                goto err;
+        }
+
+        extlog_l1_hdr = acpi_os_map_memory(l1_dirbase, l1_hdr_size);
+        l1_head = (struct extlog_l1_head *)extlog_l1_hdr;
+        l1_size = l1_head->total_len;
+        l1_percpu_entry = l1_head->entries;
+        elog_base = l1_head->elog_base;
+        elog_size = l1_head->elog_len;
+        acpi_os_unmap_memory(extlog_l1_hdr, l1_hdr_size);
+        release_mem_region(l1_dirbase, l1_hdr_size);
+
+        /* remap L1 header again based on completed information */
+        r = request_mem_region(l1_dirbase, l1_size, "L1 Table");
+        if (!r) {
+                pr_warn(FW_BUG EMCA_BUG,
+                        (unsigned long long)l1_dirbase,
+                        (unsigned long long)l1_dirbase + l1_size);
+                goto err;
+        }
+        extlog_l1_addr = acpi_os_map_memory(l1_dirbase, l1_size);
+        l1_entry_base = (u64 *)((u8 *)extlog_l1_addr + l1_hdr_size);
+
+        /* remap elog table */
+        r = request_mem_region(elog_base, elog_size, "Elog Table");
+        if (!r) {
+                pr_warn(FW_BUG EMCA_BUG,
+                        (unsigned long long)elog_base,
+                        (unsigned long long)elog_base + elog_size);
+                goto err_release_l1_dir;
+        }
+        elog_addr = acpi_os_map_memory(elog_base, elog_size);
+
+        rc = -ENOMEM;
+        /* allocate buffer to save elog record */
+        elog_buf = kmalloc(ELOG_ENTRY_LEN, GFP_KERNEL);
+        if (elog_buf == NULL)
+                goto err_release_elog;
+
+        mce_register_decode_chain(&extlog_mce_dec);
+        /* enable OS to be involved to take over management from BIOS */
+        ((struct extlog_l1_head *)extlog_l1_addr)->flags |= FLAG_OS_OPTIN;
+
+        return 0;
+
+err_release_elog:
+        if (elog_addr)
+                acpi_os_unmap_memory(elog_addr, elog_size);
+        release_mem_region(elog_base, elog_size);
+err_release_l1_dir:
+        if (extlog_l1_addr)
+                acpi_os_unmap_memory(extlog_l1_addr, l1_size);
+        release_mem_region(l1_dirbase, l1_size);
+err:
+        pr_warn(FW_BUG "Extended error log disabled because of problems parsing f/w tables\n");
+        return rc;
+}
+
+static void __exit extlog_exit(void)
+{
+        mce_unregister_decode_chain(&extlog_mce_dec);
+        ((struct extlog_l1_head *)extlog_l1_addr)->flags &= ~FLAG_OS_OPTIN;
+        if (extlog_l1_addr)
+                acpi_os_unmap_memory(extlog_l1_addr, l1_size);
+        if (elog_addr)
+                acpi_os_unmap_memory(elog_addr, elog_size);
+        release_mem_region(elog_base, elog_size);
+        release_mem_region(l1_dirbase, l1_size);
+        kfree(elog_buf);
+}
+
+module_init(extlog_init);
+module_exit(extlog_exit);
+
+MODULE_AUTHOR("Chen, Gong <gong.chen@intel.com>");
+MODULE_DESCRIPTION("Extended MCA Error Log Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
index f0c1ce95a0ec..786294bb682c 100644
--- a/drivers/acpi/apei/Kconfig
+++ b/drivers/acpi/apei/Kconfig
@@ -2,6 +2,8 @@ config ACPI_APEI
         bool "ACPI Platform Error Interface (APEI)"
         select MISC_FILESYSTEMS
         select PSTORE
+        select EFI
+        select UEFI_CPER
         depends on X86
         help
           APEI allows to report errors (for example from the chipset)
diff --git a/drivers/acpi/apei/Makefile b/drivers/acpi/apei/Makefile
index d1d1bc0a4ee1..5d575a955940 100644
--- a/drivers/acpi/apei/Makefile
+++ b/drivers/acpi/apei/Makefile
@@ -3,4 +3,4 @@ obj-$(CONFIG_ACPI_APEI_GHES)	+= ghes.o
 obj-$(CONFIG_ACPI_APEI_EINJ)    += einj.o
 obj-$(CONFIG_ACPI_APEI_ERST_DEBUG) += erst-dbg.o
 
-apei-y := apei-base.o hest.o cper.o erst.o
+apei-y := apei-base.o hest.o erst.o
diff --git a/drivers/acpi/apei/apei-internal.h b/drivers/acpi/apei/apei-internal.h
index f220d642136e..21ba34a73883 100644
--- a/drivers/acpi/apei/apei-internal.h
+++ b/drivers/acpi/apei/apei-internal.h
@@ -122,11 +122,11 @@ struct dentry;
 struct dentry *apei_get_debugfs_dir(void);
 
 #define apei_estatus_for_each_section(estatus, section)                 \
-        for (section = (struct acpi_hest_generic_data *)(estatus + 1);  \
+        for (section = (struct acpi_generic_data *)(estatus + 1);       \
              (void *)section - (void *)estatus < estatus->data_length;  \
              section = (void *)(section+1) + section->error_data_length)
 
-static inline u32 apei_estatus_len(struct acpi_hest_generic_status *estatus)
+static inline u32 cper_estatus_len(struct acpi_generic_status *estatus)
 {
         if (estatus->raw_data_length)
                 return estatus->raw_data_offset + \
@@ -135,10 +135,10 @@ static inline u32 apei_estatus_len(struct acpi_hest_generic_status *estatus)
                 return sizeof(*estatus) + estatus->data_length;
 }
 
-void apei_estatus_print(const char *pfx,
-                        const struct acpi_hest_generic_status *estatus);
-int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus);
-int apei_estatus_check(const struct acpi_hest_generic_status *estatus);
+void cper_estatus_print(const char *pfx,
+                        const struct acpi_generic_status *estatus);
+int cper_estatus_check_header(const struct acpi_generic_status *estatus);
+int cper_estatus_check(const struct acpi_generic_status *estatus);
 
 int apei_osc_setup(void);
 #endif
diff --git a/drivers/acpi/apei/cper.c b/drivers/acpi/apei/cper.c
deleted file mode 100644
index 33dc6a004802..000000000000
--- a/drivers/acpi/apei/cper.c
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
- * UEFI Common Platform Error Record (CPER) support
- *
- * Copyright (C) 2010, Intel Corp.
- *      Author: Huang Ying <ying.huang@intel.com>
- *
- * CPER is the format used to describe platform hardware error by
- * various APEI tables, such as ERST, BERT and HEST etc.
- *
- * For more information about CPER, please refer to Appendix N of UEFI
- * Specification version 2.3.
- *
- * This program is free software; you can redistribute it and/or
- * modify it 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 that 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/time.h>
-#include <linux/cper.h>
-#include <linux/acpi.h>
-#include <linux/pci.h>
-#include <linux/aer.h>
-
-/*
- * CPER record ID need to be unique even after reboot, because record
- * ID is used as index for ERST storage, while CPER records from
- * multiple boot may co-exist in ERST.
- */
-u64 cper_next_record_id(void)
-{
-        static atomic64_t seq;
-
-        if (!atomic64_read(&seq))
-                atomic64_set(&seq, ((u64)get_seconds()) << 32);
-
-        return atomic64_inc_return(&seq);
-}
-EXPORT_SYMBOL_GPL(cper_next_record_id);
-
-static const char *cper_severity_strs[] = {
-        "recoverable",
-        "fatal",
-        "corrected",
-        "info",
-};
-
-static const char *cper_severity_str(unsigned int severity)
-{
-        return severity < ARRAY_SIZE(cper_severity_strs) ?
-                cper_severity_strs[severity] : "unknown";
-}
-
-/*
- * cper_print_bits - print strings for set bits
- * @pfx: prefix for each line, including log level and prefix string
- * @bits: bit mask
- * @strs: string array, indexed by bit position
- * @strs_size: size of the string array: @strs
- *
- * For each set bit in @bits, print the corresponding string in @strs.
- * If the output length is longer than 80, multiple line will be
- * printed, with @pfx is printed at the beginning of each line.
- */
-void cper_print_bits(const char *pfx, unsigned int bits,
-                     const char *strs[], unsigned int strs_size)
-{
-        int i, len = 0;
-        const char *str;
-        char buf[84];
-
-        for (i = 0; i < strs_size; i++) {
-                if (!(bits & (1U << i)))
-                        continue;
-                str = strs[i];
-                if (!str)
-                        continue;
-                if (len && len + strlen(str) + 2 > 80) {
-                        printk("%s\n", buf);
-                        len = 0;
-                }
-                if (!len)
-                        len = snprintf(buf, sizeof(buf), "%s%s", pfx, str);
-                else
-                        len += snprintf(buf+len, sizeof(buf)-len, ", %s", str);
-        }
-        if (len)
-                printk("%s\n", buf);
-}
-
-static const char *cper_proc_type_strs[] = {
-        "IA32/X64",
-        "IA64",
-};
-
-static const char *cper_proc_isa_strs[] = {
-        "IA32",
-        "IA64",
-        "X64",
-};
-
-static const char *cper_proc_error_type_strs[] = {
-        "cache error",
-        "TLB error",
-        "bus error",
-        "micro-architectural error",
-};
-
-static const char *cper_proc_op_strs[] = {
-        "unknown or generic",
-        "data read",
-        "data write",
-        "instruction execution",
-};
-
-static const char *cper_proc_flag_strs[] = {
-        "restartable",
-        "precise IP",
-        "overflow",
-        "corrected",
-};
-
-static void cper_print_proc_generic(const char *pfx,
-                                    const struct cper_sec_proc_generic *proc)
-{
-        if (proc->validation_bits & CPER_PROC_VALID_TYPE)
-                printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type,
-                       proc->proc_type < ARRAY_SIZE(cper_proc_type_strs) ?
-                       cper_proc_type_strs[proc->proc_type] : "unknown");
-        if (proc->validation_bits & CPER_PROC_VALID_ISA)
-                printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa,
-                       proc->proc_isa < ARRAY_SIZE(cper_proc_isa_strs) ?
-                       cper_proc_isa_strs[proc->proc_isa] : "unknown");
-        if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) {
-                printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type);
-                cper_print_bits(pfx, proc->proc_error_type,
-                                cper_proc_error_type_strs,
-                                ARRAY_SIZE(cper_proc_error_type_strs));
-        }
-        if (proc->validation_bits & CPER_PROC_VALID_OPERATION)
-                printk("%s""operation: %d, %s\n", pfx, proc->operation,
-                       proc->operation < ARRAY_SIZE(cper_proc_op_strs) ?
-                       cper_proc_op_strs[proc->operation] : "unknown");
-        if (proc->validation_bits & CPER_PROC_VALID_FLAGS) {
-                printk("%s""flags: 0x%02x\n", pfx, proc->flags);
-                cper_print_bits(pfx, proc->flags, cper_proc_flag_strs,
-                                ARRAY_SIZE(cper_proc_flag_strs));
-        }
-        if (proc->validation_bits & CPER_PROC_VALID_LEVEL)
-                printk("%s""level: %d\n", pfx, proc->level);
-        if (proc->validation_bits & CPER_PROC_VALID_VERSION)
-                printk("%s""version_info: 0x%016llx\n", pfx, proc->cpu_version);
-        if (proc->validation_bits & CPER_PROC_VALID_ID)
-                printk("%s""processor_id: 0x%016llx\n", pfx, proc->proc_id);
-        if (proc->validation_bits & CPER_PROC_VALID_TARGET_ADDRESS)
-                printk("%s""target_address: 0x%016llx\n",
-                       pfx, proc->target_addr);
-        if (proc->validation_bits & CPER_PROC_VALID_REQUESTOR_ID)
-                printk("%s""requestor_id: 0x%016llx\n",
-                       pfx, proc->requestor_id);
-        if (proc->validation_bits & CPER_PROC_VALID_RESPONDER_ID)
-                printk("%s""responder_id: 0x%016llx\n",
-                       pfx, proc->responder_id);
-        if (proc->validation_bits & CPER_PROC_VALID_IP)
-                printk("%s""IP: 0x%016llx\n", pfx, proc->ip);
-}
-
-static const char *cper_mem_err_type_strs[] = {
-        "unknown",
-        "no error",
-        "single-bit ECC",
-        "multi-bit ECC",
-        "single-symbol chipkill ECC",
-        "multi-symbol chipkill ECC",
-        "master abort",
-        "target abort",
-        "parity error",
-        "watchdog timeout",
-        "invalid address",
-        "mirror Broken",
-        "memory sparing",
-        "scrub corrected error",
-        "scrub uncorrected error",
-};
-
-static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem)
-{
-        if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS)
-                printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status);
-        if (mem->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS)
-                printk("%s""physical_address: 0x%016llx\n",
-                       pfx, mem->physical_addr);
-        if (mem->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS_MASK)
-                printk("%s""physical_address_mask: 0x%016llx\n",
-                       pfx, mem->physical_addr_mask);
-        if (mem->validation_bits & CPER_MEM_VALID_NODE)
-                printk("%s""node: %d\n", pfx, mem->node);
-        if (mem->validation_bits & CPER_MEM_VALID_CARD)
-                printk("%s""card: %d\n", pfx, mem->card);
-        if (mem->validation_bits & CPER_MEM_VALID_MODULE)
-                printk("%s""module: %d\n", pfx, mem->module);
-        if (mem->validation_bits & CPER_MEM_VALID_BANK)
-                printk("%s""bank: %d\n", pfx, mem->bank);
-        if (mem->validation_bits & CPER_MEM_VALID_DEVICE)
-                printk("%s""device: %d\n", pfx, mem->device);
-        if (mem->validation_bits & CPER_MEM_VALID_ROW)
-                printk("%s""row: %d\n", pfx, mem->row);
-        if (mem->validation_bits & CPER_MEM_VALID_COLUMN)
-                printk("%s""column: %d\n", pfx, mem->column);
-        if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION)
-                printk("%s""bit_position: %d\n", pfx, mem->bit_pos);
-        if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID)
-                printk("%s""requestor_id: 0x%016llx\n", pfx, mem->requestor_id);
-        if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID)
-                printk("%s""responder_id: 0x%016llx\n", pfx, mem->responder_id);
-        if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID)
-                printk("%s""target_id: 0x%016llx\n", pfx, mem->target_id);
-        if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) {
-                u8 etype = mem->error_type;
-                printk("%s""error_type: %d, %s\n", pfx, etype,
-                       etype < ARRAY_SIZE(cper_mem_err_type_strs) ?
-                       cper_mem_err_type_strs[etype] : "unknown");
-        }
-}
-
-static const char *cper_pcie_port_type_strs[] = {
-        "PCIe end point",
-        "legacy PCI end point",
-        "unknown",
-        "unknown",
-        "root port",
-        "upstream switch port",
-        "downstream switch port",
-        "PCIe to PCI/PCI-X bridge",
-        "PCI/PCI-X to PCIe bridge",
-        "root complex integrated endpoint device",
-        "root complex event collector",
-};
-
-static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie,
-                            const struct acpi_hest_generic_data *gdata)
-{
-        if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE)
-                printk("%s""port_type: %d, %s\n", pfx, pcie->port_type,
-                       pcie->port_type < ARRAY_SIZE(cper_pcie_port_type_strs) ?
-                       cper_pcie_port_type_strs[pcie->port_type] : "unknown");
-        if (pcie->validation_bits & CPER_PCIE_VALID_VERSION)
-                printk("%s""version: %d.%d\n", pfx,
-                       pcie->version.major, pcie->version.minor);
-        if (pcie->validation_bits & CPER_PCIE_VALID_COMMAND_STATUS)
-                printk("%s""command: 0x%04x, status: 0x%04x\n", pfx,
-                       pcie->command, pcie->status);
-        if (pcie->validation_bits & CPER_PCIE_VALID_DEVICE_ID) {
-                const __u8 *p;
-                printk("%s""device_id: %04x:%02x:%02x.%x\n", pfx,
-                       pcie->device_id.segment, pcie->device_id.bus,
-                       pcie->device_id.device, pcie->device_id.function);
-                printk("%s""slot: %d\n", pfx,
-                       pcie->device_id.slot >> CPER_PCIE_SLOT_SHIFT);
-                printk("%s""secondary_bus: 0x%02x\n", pfx,
-                       pcie->device_id.secondary_bus);
-                printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx,
-                       pcie->device_id.vendor_id, pcie->device_id.device_id);
-                p = pcie->device_id.class_code;
-                printk("%s""class_code: %02x%02x%02x\n", pfx, p[0], p[1], p[2]);
-        }
-        if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER)
-                printk("%s""serial number: 0x%04x, 0x%04x\n", pfx,
-                       pcie->serial_number.lower, pcie->serial_number.upper);
-        if (pcie->validation_bits & CPER_PCIE_VALID_BRIDGE_CONTROL_STATUS)
-                printk(
-        "%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n",
-        pfx, pcie->bridge.secondary_status, pcie->bridge.control);
-}
-
-static const char *apei_estatus_section_flag_strs[] = {
-        "primary",
-        "containment warning",
-        "reset",
-        "threshold exceeded",
-        "resource not accessible",
-        "latent error",
-};
-
-static void apei_estatus_print_section(
-        const char *pfx, const struct acpi_hest_generic_data *gdata, int sec_no)
-{
-        uuid_le *sec_type = (uuid_le *)gdata->section_type;
-        __u16 severity;
-
-        severity = gdata->error_severity;
-        printk("%s""section: %d, severity: %d, %s\n", pfx, sec_no, severity,
-               cper_severity_str(severity));
-        printk("%s""flags: 0x%02x\n", pfx, gdata->flags);
-        cper_print_bits(pfx, gdata->flags, apei_estatus_section_flag_strs,
-                        ARRAY_SIZE(apei_estatus_section_flag_strs));
-        if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID)
-                printk("%s""fru_id: %pUl\n", pfx, (uuid_le *)gdata->fru_id);
-        if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT)
-                printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text);
-
-        if (!uuid_le_cmp(*sec_type, CPER_SEC_PROC_GENERIC)) {
-                struct cper_sec_proc_generic *proc_err = (void *)(gdata + 1);
-                printk("%s""section_type: general processor error\n", pfx);
-                if (gdata->error_data_length >= sizeof(*proc_err))
-                        cper_print_proc_generic(pfx, proc_err);
-                else
-                        goto err_section_too_small;
-        } else if (!uuid_le_cmp(*sec_type, CPER_SEC_PLATFORM_MEM)) {
-                struct cper_sec_mem_err *mem_err = (void *)(gdata + 1);
-                printk("%s""section_type: memory error\n", pfx);
-                if (gdata->error_data_length >= sizeof(*mem_err))
-                        cper_print_mem(pfx, mem_err);
-                else
-                        goto err_section_too_small;
-        } else if (!uuid_le_cmp(*sec_type, CPER_SEC_PCIE)) {
-                struct cper_sec_pcie *pcie = (void *)(gdata + 1);
-                printk("%s""section_type: PCIe error\n", pfx);
-                if (gdata->error_data_length >= sizeof(*pcie))
-                        cper_print_pcie(pfx, pcie, gdata);
-                else
-                        goto err_section_too_small;
-        } else
-                printk("%s""section type: unknown, %pUl\n", pfx, sec_type);
-
-        return;
-
-err_section_too_small:
-        pr_err(FW_WARN "error section length is too small\n");
-}
-
-void apei_estatus_print(const char *pfx,
-                        const struct acpi_hest_generic_status *estatus)
-{
-        struct acpi_hest_generic_data *gdata;
-        unsigned int data_len, gedata_len;
-        int sec_no = 0;
-        __u16 severity;
-
-        printk("%s""APEI generic hardware error status\n", pfx);
-        severity = estatus->error_severity;
-        printk("%s""severity: %d, %s\n", pfx, severity,
-               cper_severity_str(severity));
-        data_len = estatus->data_length;
-        gdata = (struct acpi_hest_generic_data *)(estatus + 1);
-        while (data_len > sizeof(*gdata)) {
-                gedata_len = gdata->error_data_length;
-                apei_estatus_print_section(pfx, gdata, sec_no);
-                data_len -= gedata_len + sizeof(*gdata);
-                gdata = (void *)(gdata + 1) + gedata_len;
-                sec_no++;
-        }
-}
-EXPORT_SYMBOL_GPL(apei_estatus_print);
-
-int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus)
-{
-        if (estatus->data_length &&
-            estatus->data_length < sizeof(struct acpi_hest_generic_data))
-                return -EINVAL;
-        if (estatus->raw_data_length &&
-            estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length)
-                return -EINVAL;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(apei_estatus_check_header);
-
-int apei_estatus_check(const struct acpi_hest_generic_status *estatus)
-{
-        struct acpi_hest_generic_data *gdata;
-        unsigned int data_len, gedata_len;
-        int rc;
-
-        rc = apei_estatus_check_header(estatus);
-        if (rc)
-                return rc;
-        data_len = estatus->data_length;
-        gdata = (struct acpi_hest_generic_data *)(estatus + 1);
-        while (data_len >= sizeof(*gdata)) {
-                gedata_len = gdata->error_data_length;
-                if (gedata_len > data_len - sizeof(*gdata))
-                        return -EINVAL;
-                data_len -= gedata_len + sizeof(*gdata);
-                gdata = (void *)(gdata + 1) + gedata_len;
-        }
-        if (data_len)
-                return -EINVAL;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(apei_estatus_check);
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index 8ec37bbdd699..a30bc313787b 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -75,13 +75,13 @@
 #define GHES_ESTATUS_CACHE_LEN(estatus_len)                     \
         (sizeof(struct ghes_estatus_cache) + (estatus_len))
 #define GHES_ESTATUS_FROM_CACHE(estatus_cache)                  \
-        ((struct acpi_hest_generic_status *)                    \
+        ((struct acpi_generic_status *)                         \
          ((struct ghes_estatus_cache *)(estatus_cache) + 1))
 
 #define GHES_ESTATUS_NODE_LEN(estatus_len)                      \
         (sizeof(struct ghes_estatus_node) + (estatus_len))
-#define GHES_ESTATUS_FROM_NODE(estatus_node)                            \
-        ((struct acpi_hest_generic_status *)                            \
+#define GHES_ESTATUS_FROM_NODE(estatus_node)                    \
+        ((struct acpi_generic_status *)                         \
          ((struct ghes_estatus_node *)(estatus_node) + 1))
 
 bool ghes_disable;
@@ -378,17 +378,17 @@ static int ghes_read_estatus(struct ghes *ghes, int silent)
         ghes->flags |= GHES_TO_CLEAR;
 
         rc = -EIO;
-        len = apei_estatus_len(ghes->estatus);
+        len = cper_estatus_len(ghes->estatus);
         if (len < sizeof(*ghes->estatus))
                 goto err_read_block;
         if (len > ghes->generic->error_block_length)
                 goto err_read_block;
-        if (apei_estatus_check_header(ghes->estatus))
+        if (cper_estatus_check_header(ghes->estatus))
                 goto err_read_block;
         ghes_copy_tofrom_phys(ghes->estatus + 1,
                               buf_paddr + sizeof(*ghes->estatus),
                               len - sizeof(*ghes->estatus), 1);
-        if (apei_estatus_check(ghes->estatus))
+        if (cper_estatus_check(ghes->estatus))
                 goto err_read_block;
         rc = 0;
 
@@ -409,7 +409,7 @@ static void ghes_clear_estatus(struct ghes *ghes)
         ghes->flags &= ~GHES_TO_CLEAR;
 }
 
-static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int sev)
+static void ghes_handle_memory_failure(struct acpi_generic_data *gdata, int sev)
 {
 #ifdef CONFIG_ACPI_APEI_MEMORY_FAILURE
         unsigned long pfn;
@@ -419,7 +419,7 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int
 
         if (sec_sev == GHES_SEV_CORRECTED &&
             (gdata->flags & CPER_SEC_ERROR_THRESHOLD_EXCEEDED) &&
-            (mem_err->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS)) {
+            (mem_err->validation_bits & CPER_MEM_VALID_PA)) {
                 pfn = mem_err->physical_addr >> PAGE_SHIFT;
                 if (pfn_valid(pfn))
                         memory_failure_queue(pfn, 0, MF_SOFT_OFFLINE);
@@ -430,7 +430,7 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int
         }
         if (sev == GHES_SEV_RECOVERABLE &&
             sec_sev == GHES_SEV_RECOVERABLE &&
-            mem_err->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS) {
+            mem_err->validation_bits & CPER_MEM_VALID_PA) {
                 pfn = mem_err->physical_addr >> PAGE_SHIFT;
                 memory_failure_queue(pfn, 0, 0);
         }
@@ -438,10 +438,10 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int
 }
 
 static void ghes_do_proc(struct ghes *ghes,
-                         const struct acpi_hest_generic_status *estatus)
+                         const struct acpi_generic_status *estatus)
 {
         int sev, sec_sev;
-        struct acpi_hest_generic_data *gdata;
+        struct acpi_generic_data *gdata;
 
         sev = ghes_severity(estatus->error_severity);
         apei_estatus_for_each_section(estatus, gdata) {
@@ -496,7 +496,7 @@ static void ghes_do_proc(struct ghes *ghes,
 
 static void __ghes_print_estatus(const char *pfx,
                                  const struct acpi_hest_generic *generic,
-                                 const struct acpi_hest_generic_status *estatus)
+                                 const struct acpi_generic_status *estatus)
 {
         static atomic_t seqno;
         unsigned int curr_seqno;
@@ -513,12 +513,12 @@ static void __ghes_print_estatus(const char *pfx,
         snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}" HW_ERR, pfx, curr_seqno);
         printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
                pfx_seq, generic->header.source_id);
-        apei_estatus_print(pfx_seq, estatus);
+        cper_estatus_print(pfx_seq, estatus);
 }
 
 static int ghes_print_estatus(const char *pfx,
                               const struct acpi_hest_generic *generic,
-                              const struct acpi_hest_generic_status *estatus)
+                              const struct acpi_generic_status *estatus)
 {
         /* Not more than 2 messages every 5 seconds */
         static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2);
@@ -540,15 +540,15 @@ static int ghes_print_estatus(const char *pfx,
  * GHES error status reporting throttle, to report more kinds of
  * errors, instead of just most frequently occurred errors.
  */
-static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus)
+static int ghes_estatus_cached(struct acpi_generic_status *estatus)
 {
         u32 len;
         int i, cached = 0;
         unsigned long long now;
         struct ghes_estatus_cache *cache;
-        struct acpi_hest_generic_status *cache_estatus;
+        struct acpi_generic_status *cache_estatus;
 
-        len = apei_estatus_len(estatus);
+        len = cper_estatus_len(estatus);
         rcu_read_lock();
         for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
                 cache = rcu_dereference(ghes_estatus_caches[i]);
@@ -571,19 +571,19 @@ static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus)
 
 static struct ghes_estatus_cache *ghes_estatus_cache_alloc(
         struct acpi_hest_generic *generic,
-        struct acpi_hest_generic_status *estatus)
+        struct acpi_generic_status *estatus)
 {
         int alloced;
         u32 len, cache_len;
         struct ghes_estatus_cache *cache;
-        struct acpi_hest_generic_status *cache_estatus;
+        struct acpi_generic_status *cache_estatus;
 
         alloced = atomic_add_return(1, &ghes_estatus_cache_alloced);
         if (alloced > GHES_ESTATUS_CACHE_ALLOCED_MAX) {
                 atomic_dec(&ghes_estatus_cache_alloced);
                 return NULL;
         }
-        len = apei_estatus_len(estatus);
+        len = cper_estatus_len(estatus);
         cache_len = GHES_ESTATUS_CACHE_LEN(len);
         cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len);
         if (!cache) {
@@ -603,7 +603,7 @@ static void ghes_estatus_cache_free(struct ghes_estatus_cache *cache)
 {
         u32 len;
 
-        len = apei_estatus_len(GHES_ESTATUS_FROM_CACHE(cache));
+        len = cper_estatus_len(GHES_ESTATUS_FROM_CACHE(cache));
         len = GHES_ESTATUS_CACHE_LEN(len);
         gen_pool_free(ghes_estatus_pool, (unsigned long)cache, len);
         atomic_dec(&ghes_estatus_cache_alloced);
@@ -619,7 +619,7 @@ static void ghes_estatus_cache_rcu_free(struct rcu_head *head)
 
 static void ghes_estatus_cache_add(
         struct acpi_hest_generic *generic,
-        struct acpi_hest_generic_status *estatus)
+        struct acpi_generic_status *estatus)
 {
         int i, slot = -1, count;
         unsigned long long now, duration, period, max_period = 0;
@@ -751,7 +751,7 @@ static void ghes_proc_in_irq(struct irq_work *irq_work)
         struct llist_node *llnode, *next;
         struct ghes_estatus_node *estatus_node;
         struct acpi_hest_generic *generic;
-        struct acpi_hest_generic_status *estatus;
+        struct acpi_generic_status *estatus;
         u32 len, node_len;
 
         llnode = llist_del_all(&ghes_estatus_llist);
@@ -765,7 +765,7 @@ static void ghes_proc_in_irq(struct irq_work *irq_work)
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
                                            llnode);
                 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
-                len = apei_estatus_len(estatus);
+                len = cper_estatus_len(estatus);
                 node_len = GHES_ESTATUS_NODE_LEN(len);
                 ghes_do_proc(estatus_node->ghes, estatus);
                 if (!ghes_estatus_cached(estatus)) {
@@ -784,7 +784,7 @@ static void ghes_print_queued_estatus(void)
         struct llist_node *llnode;
         struct ghes_estatus_node *estatus_node;
         struct acpi_hest_generic *generic;
-        struct acpi_hest_generic_status *estatus;
+        struct acpi_generic_status *estatus;
         u32 len, node_len;
 
         llnode = llist_del_all(&ghes_estatus_llist);
@@ -797,7 +797,7 @@ static void ghes_print_queued_estatus(void)
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
                                            llnode);
                 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
-                len = apei_estatus_len(estatus);
+                len = cper_estatus_len(estatus);
                 node_len = GHES_ESTATUS_NODE_LEN(len);
                 generic = estatus_node->generic;
                 ghes_print_estatus(NULL, generic, estatus);
@@ -843,7 +843,7 @@ static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
 #ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
                 u32 len, node_len;
                 struct ghes_estatus_node *estatus_node;
-                struct acpi_hest_generic_status *estatus;
+                struct acpi_generic_status *estatus;
 #endif
                 if (!(ghes->flags & GHES_TO_CLEAR))
                         continue;
@@ -851,7 +851,7 @@ static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
                 if (ghes_estatus_cached(ghes->estatus))
                         goto next;
                 /* Save estatus for further processing in IRQ context */
-                len = apei_estatus_len(ghes->estatus);
+                len = cper_estatus_len(ghes->estatus);
                 node_len = GHES_ESTATUS_NODE_LEN(len);
                 estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool,
                                                       node_len);
@@ -923,7 +923,7 @@ static int ghes_probe(struct platform_device *ghes_dev)
 
         rc = -EIO;
         if (generic->error_block_length <
-            sizeof(struct acpi_hest_generic_status)) {
+            sizeof(struct acpi_generic_status)) {
                 pr_warning(FW_BUG GHES_PFX "Invalid error block length: %u for generic hardware error source: %d\n",
                            generic->error_block_length,
                            generic->header.source_id);
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index b587ec8257b2..e1bd9a181117 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -174,7 +174,7 @@ static void acpi_print_osc_error(acpi_handle handle,
         printk("\n");
 }
 
-static acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
+acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
 {
         int i;
         static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
@@ -195,6 +195,7 @@ static acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
         }
         return AE_OK;
 }
+EXPORT_SYMBOL_GPL(acpi_str_to_uuid);
 
 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
 {