mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 03:27:44 -04:00
Merge branch 'apei' into apei-release
Some trivial conflicts due to other various merges adding to the end of common lists sooner than this one. arch/ia64/Kconfig arch/powerpc/Kconfig arch/x86/Kconfig lib/Kconfig lib/Makefile Signed-off-by: Len Brown <[email protected]>
This commit is contained in:
Len Brown
commit
d0e323b470
35 changed files with 1172 additions and 135 deletions
|
|
@ -10,9 +10,11 @@ config ACPI_APEI
|
|||
error injection.
|
||||
|
||||
config ACPI_APEI_GHES
|
||||
tristate "APEI Generic Hardware Error Source"
|
||||
bool "APEI Generic Hardware Error Source"
|
||||
depends on ACPI_APEI && X86
|
||||
select ACPI_HED
|
||||
select LLIST
|
||||
select GENERIC_ALLOCATOR
|
||||
help
|
||||
Generic Hardware Error Source provides a way to report
|
||||
platform hardware errors (such as that from chipset). It
|
||||
|
|
@ -30,6 +32,13 @@ config ACPI_APEI_PCIEAER
|
|||
PCIe AER errors may be reported via APEI firmware first mode.
|
||||
Turn on this option to enable the corresponding support.
|
||||
|
||||
config ACPI_APEI_MEMORY_FAILURE
|
||||
bool "APEI memory error recovering support"
|
||||
depends on ACPI_APEI && MEMORY_FAILURE
|
||||
help
|
||||
Memory errors may be reported via APEI firmware first mode.
|
||||
Turn on this option to enable the memory recovering support.
|
||||
|
||||
config ACPI_APEI_EINJ
|
||||
tristate "APEI Error INJection (EINJ)"
|
||||
depends on ACPI_APEI && DEBUG_FS
|
||||
|
|
|
|||
|
|
@ -157,9 +157,10 @@ EXPORT_SYMBOL_GPL(apei_exec_noop);
|
|||
* Interpret the specified action. Go through whole action table,
|
||||
* execute all instructions belong to the action.
|
||||
*/
|
||||
int apei_exec_run(struct apei_exec_context *ctx, u8 action)
|
||||
int __apei_exec_run(struct apei_exec_context *ctx, u8 action,
|
||||
bool optional)
|
||||
{
|
||||
int rc;
|
||||
int rc = -ENOENT;
|
||||
u32 i, ip;
|
||||
struct acpi_whea_header *entry;
|
||||
apei_exec_ins_func_t run;
|
||||
|
|
@ -198,9 +199,9 @@ rewind:
|
|||
goto rewind;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return !optional && rc < 0 ? rc : 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(apei_exec_run);
|
||||
EXPORT_SYMBOL_GPL(__apei_exec_run);
|
||||
|
||||
typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
|
||||
struct acpi_whea_header *entry,
|
||||
|
|
@ -603,3 +604,29 @@ struct dentry *apei_get_debugfs_dir(void)
|
|||
return dapei;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);
|
||||
|
||||
int apei_osc_setup(void)
|
||||
{
|
||||
static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c";
|
||||
acpi_handle handle;
|
||||
u32 capbuf[3];
|
||||
struct acpi_osc_context context = {
|
||||
.uuid_str = whea_uuid_str,
|
||||
.rev = 1,
|
||||
.cap.length = sizeof(capbuf),
|
||||
.cap.pointer = capbuf,
|
||||
};
|
||||
|
||||
capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
|
||||
capbuf[OSC_SUPPORT_TYPE] = 0;
|
||||
capbuf[OSC_CONTROL_TYPE] = 0;
|
||||
|
||||
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))
|
||||
|| ACPI_FAILURE(acpi_run_osc(handle, &context)))
|
||||
return -EIO;
|
||||
else {
|
||||
kfree(context.ret.pointer);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(apei_osc_setup);
|
||||
|
|
|
|||
|
|
@ -50,7 +50,18 @@ static inline u64 apei_exec_ctx_get_output(struct apei_exec_context *ctx)
|
|||
return ctx->value;
|
||||
}
|
||||
|
||||
int apei_exec_run(struct apei_exec_context *ctx, u8 action);
|
||||
int __apei_exec_run(struct apei_exec_context *ctx, u8 action, bool optional);
|
||||
|
||||
static inline int apei_exec_run(struct apei_exec_context *ctx, u8 action)
|
||||
{
|
||||
return __apei_exec_run(ctx, action, 0);
|
||||
}
|
||||
|
||||
/* It is optional whether the firmware provides the action */
|
||||
static inline int apei_exec_run_optional(struct apei_exec_context *ctx, u8 action)
|
||||
{
|
||||
return __apei_exec_run(ctx, action, 1);
|
||||
}
|
||||
|
||||
/* Common instruction implementation */
|
||||
|
||||
|
|
@ -113,4 +124,6 @@ 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);
|
||||
|
||||
int apei_osc_setup(void);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -46,7 +46,8 @@
|
|||
* Some BIOSes allow parameters to the SET_ERROR_TYPE entries in the
|
||||
* EINJ table through an unpublished extension. Use with caution as
|
||||
* most will ignore the parameter and make their own choice of address
|
||||
* for error injection.
|
||||
* for error injection. This extension is used only if
|
||||
* param_extension module parameter is specified.
|
||||
*/
|
||||
struct einj_parameter {
|
||||
u64 type;
|
||||
|
|
@ -65,6 +66,9 @@ struct einj_parameter {
|
|||
((struct acpi_whea_header *)((char *)(tab) + \
|
||||
sizeof(struct acpi_table_einj)))
|
||||
|
||||
static bool param_extension;
|
||||
module_param(param_extension, bool, 0);
|
||||
|
||||
static struct acpi_table_einj *einj_tab;
|
||||
|
||||
static struct apei_resources einj_resources;
|
||||
|
|
@ -285,7 +289,7 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
|
|||
|
||||
einj_exec_ctx_init(&ctx);
|
||||
|
||||
rc = apei_exec_run(&ctx, ACPI_EINJ_BEGIN_OPERATION);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_EINJ_BEGIN_OPERATION);
|
||||
if (rc)
|
||||
return rc;
|
||||
apei_exec_ctx_set_input(&ctx, type);
|
||||
|
|
@ -323,7 +327,7 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
|
|||
rc = __einj_error_trigger(trigger_paddr);
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = apei_exec_run(&ctx, ACPI_EINJ_END_OPERATION);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_EINJ_END_OPERATION);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
|
@ -489,14 +493,6 @@ static int __init einj_init(void)
|
|||
einj_debug_dir, NULL, &error_type_fops);
|
||||
if (!fentry)
|
||||
goto err_cleanup;
|
||||
fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
|
||||
einj_debug_dir, &error_param1);
|
||||
if (!fentry)
|
||||
goto err_cleanup;
|
||||
fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
|
||||
einj_debug_dir, &error_param2);
|
||||
if (!fentry)
|
||||
goto err_cleanup;
|
||||
fentry = debugfs_create_file("error_inject", S_IWUSR,
|
||||
einj_debug_dir, NULL, &error_inject_fops);
|
||||
if (!fentry)
|
||||
|
|
@ -513,12 +509,23 @@ static int __init einj_init(void)
|
|||
rc = apei_exec_pre_map_gars(&ctx);
|
||||
if (rc)
|
||||
goto err_release;
|
||||
param_paddr = einj_get_parameter_address();
|
||||
if (param_paddr) {
|
||||
einj_param = ioremap(param_paddr, sizeof(*einj_param));
|
||||
rc = -ENOMEM;
|
||||
if (!einj_param)
|
||||
goto err_unmap;
|
||||
if (param_extension) {
|
||||
param_paddr = einj_get_parameter_address();
|
||||
if (param_paddr) {
|
||||
einj_param = ioremap(param_paddr, sizeof(*einj_param));
|
||||
rc = -ENOMEM;
|
||||
if (!einj_param)
|
||||
goto err_unmap;
|
||||
fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
|
||||
einj_debug_dir, &error_param1);
|
||||
if (!fentry)
|
||||
goto err_unmap;
|
||||
fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
|
||||
einj_debug_dir, &error_param2);
|
||||
if (!fentry)
|
||||
goto err_unmap;
|
||||
} else
|
||||
pr_warn(EINJ_PFX "Parameter extension is not supported.\n");
|
||||
}
|
||||
|
||||
pr_info(EINJ_PFX "Error INJection is initialized.\n");
|
||||
|
|
@ -526,6 +533,8 @@ static int __init einj_init(void)
|
|||
return 0;
|
||||
|
||||
err_unmap:
|
||||
if (einj_param)
|
||||
iounmap(einj_param);
|
||||
apei_exec_post_unmap_gars(&ctx);
|
||||
err_release:
|
||||
apei_resources_release(&einj_resources);
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
#define ERST_DBG_PFX "ERST DBG: "
|
||||
|
||||
#define ERST_DBG_RECORD_LEN_MAX 4096
|
||||
#define ERST_DBG_RECORD_LEN_MAX 0x4000
|
||||
|
||||
static void *erst_dbg_buf;
|
||||
static unsigned int erst_dbg_buf_len;
|
||||
|
|
@ -213,6 +213,10 @@ static struct miscdevice erst_dbg_dev = {
|
|||
|
||||
static __init int erst_dbg_init(void)
|
||||
{
|
||||
if (erst_disable) {
|
||||
pr_info(ERST_DBG_PFX "ERST support is disabled.\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
return misc_register(&erst_dbg_dev);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -642,7 +642,7 @@ static int __erst_write_to_storage(u64 offset)
|
|||
int rc;
|
||||
|
||||
erst_exec_ctx_init(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_WRITE);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_WRITE);
|
||||
if (rc)
|
||||
return rc;
|
||||
apei_exec_ctx_set_input(&ctx, offset);
|
||||
|
|
@ -666,7 +666,7 @@ static int __erst_write_to_storage(u64 offset)
|
|||
if (rc)
|
||||
return rc;
|
||||
val = apei_exec_ctx_get_output(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_END);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
|
|
@ -681,7 +681,7 @@ static int __erst_read_from_storage(u64 record_id, u64 offset)
|
|||
int rc;
|
||||
|
||||
erst_exec_ctx_init(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_READ);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_READ);
|
||||
if (rc)
|
||||
return rc;
|
||||
apei_exec_ctx_set_input(&ctx, offset);
|
||||
|
|
@ -709,7 +709,7 @@ static int __erst_read_from_storage(u64 record_id, u64 offset)
|
|||
if (rc)
|
||||
return rc;
|
||||
val = apei_exec_ctx_get_output(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_END);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
|
|
@ -724,7 +724,7 @@ static int __erst_clear_from_storage(u64 record_id)
|
|||
int rc;
|
||||
|
||||
erst_exec_ctx_init(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_CLEAR);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_CLEAR);
|
||||
if (rc)
|
||||
return rc;
|
||||
apei_exec_ctx_set_input(&ctx, record_id);
|
||||
|
|
@ -748,7 +748,7 @@ static int __erst_clear_from_storage(u64 record_id)
|
|||
if (rc)
|
||||
return rc;
|
||||
val = apei_exec_ctx_get_output(&ctx);
|
||||
rc = apei_exec_run(&ctx, ACPI_ERST_END);
|
||||
rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
* For more information about Generic Hardware Error Source, please
|
||||
* refer to ACPI Specification version 4.0, section 17.3.2.6
|
||||
*
|
||||
* Copyright 2010 Intel Corp.
|
||||
* Copyright 2010,2011 Intel Corp.
|
||||
* Author: Huang Ying <ying.huang@intel.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
|
|
@ -42,6 +42,9 @@
|
|||
#include <linux/mutex.h>
|
||||
#include <linux/ratelimit.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/irq_work.h>
|
||||
#include <linux/llist.h>
|
||||
#include <linux/genalloc.h>
|
||||
#include <acpi/apei.h>
|
||||
#include <acpi/atomicio.h>
|
||||
#include <acpi/hed.h>
|
||||
|
|
@ -53,6 +56,30 @@
|
|||
#define GHES_PFX "GHES: "
|
||||
|
||||
#define GHES_ESTATUS_MAX_SIZE 65536
|
||||
#define GHES_ESOURCE_PREALLOC_MAX_SIZE 65536
|
||||
|
||||
#define GHES_ESTATUS_POOL_MIN_ALLOC_ORDER 3
|
||||
|
||||
/* This is just an estimation for memory pool allocation */
|
||||
#define GHES_ESTATUS_CACHE_AVG_SIZE 512
|
||||
|
||||
#define GHES_ESTATUS_CACHES_SIZE 4
|
||||
|
||||
#define GHES_ESTATUS_IN_CACHE_MAX_NSEC 10000000000ULL
|
||||
/* Prevent too many caches are allocated because of RCU */
|
||||
#define GHES_ESTATUS_CACHE_ALLOCED_MAX (GHES_ESTATUS_CACHES_SIZE * 3 / 2)
|
||||
|
||||
#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 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 *) \
|
||||
((struct ghes_estatus_node *)(estatus_node) + 1))
|
||||
|
||||
/*
|
||||
* One struct ghes is created for each generic hardware error source.
|
||||
|
|
@ -77,6 +104,22 @@ struct ghes {
|
|||
};
|
||||
};
|
||||
|
||||
struct ghes_estatus_node {
|
||||
struct llist_node llnode;
|
||||
struct acpi_hest_generic *generic;
|
||||
};
|
||||
|
||||
struct ghes_estatus_cache {
|
||||
u32 estatus_len;
|
||||
atomic_t count;
|
||||
struct acpi_hest_generic *generic;
|
||||
unsigned long long time_in;
|
||||
struct rcu_head rcu;
|
||||
};
|
||||
|
||||
int ghes_disable;
|
||||
module_param_named(disable, ghes_disable, bool, 0);
|
||||
|
||||
static int ghes_panic_timeout __read_mostly = 30;
|
||||
|
||||
/*
|
||||
|
|
@ -121,6 +164,22 @@ static struct vm_struct *ghes_ioremap_area;
|
|||
static DEFINE_RAW_SPINLOCK(ghes_ioremap_lock_nmi);
|
||||
static DEFINE_SPINLOCK(ghes_ioremap_lock_irq);
|
||||
|
||||
/*
|
||||
* printk is not safe in NMI context. So in NMI handler, we allocate
|
||||
* required memory from lock-less memory allocator
|
||||
* (ghes_estatus_pool), save estatus into it, put them into lock-less
|
||||
* list (ghes_estatus_llist), then delay printk into IRQ context via
|
||||
* irq_work (ghes_proc_irq_work). ghes_estatus_size_request record
|
||||
* required pool size by all NMI error source.
|
||||
*/
|
||||
static struct gen_pool *ghes_estatus_pool;
|
||||
static unsigned long ghes_estatus_pool_size_request;
|
||||
static struct llist_head ghes_estatus_llist;
|
||||
static struct irq_work ghes_proc_irq_work;
|
||||
|
||||
struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
|
||||
static atomic_t ghes_estatus_cache_alloced;
|
||||
|
||||
static int ghes_ioremap_init(void)
|
||||
{
|
||||
ghes_ioremap_area = __get_vm_area(PAGE_SIZE * GHES_IOREMAP_PAGES,
|
||||
|
|
@ -180,6 +239,55 @@ static void ghes_iounmap_irq(void __iomem *vaddr_ptr)
|
|||
__flush_tlb_one(vaddr);
|
||||
}
|
||||
|
||||
static int ghes_estatus_pool_init(void)
|
||||
{
|
||||
ghes_estatus_pool = gen_pool_create(GHES_ESTATUS_POOL_MIN_ALLOC_ORDER, -1);
|
||||
if (!ghes_estatus_pool)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ghes_estatus_pool_free_chunk_page(struct gen_pool *pool,
|
||||
struct gen_pool_chunk *chunk,
|
||||
void *data)
|
||||
{
|
||||
free_page(chunk->start_addr);
|
||||
}
|
||||
|
||||
static void ghes_estatus_pool_exit(void)
|
||||
{
|
||||
gen_pool_for_each_chunk(ghes_estatus_pool,
|
||||
ghes_estatus_pool_free_chunk_page, NULL);
|
||||
gen_pool_destroy(ghes_estatus_pool);
|
||||
}
|
||||
|
||||
static int ghes_estatus_pool_expand(unsigned long len)
|
||||
{
|
||||
unsigned long i, pages, size, addr;
|
||||
int ret;
|
||||
|
||||
ghes_estatus_pool_size_request += PAGE_ALIGN(len);
|
||||
size = gen_pool_size(ghes_estatus_pool);
|
||||
if (size >= ghes_estatus_pool_size_request)
|
||||
return 0;
|
||||
pages = (ghes_estatus_pool_size_request - size) / PAGE_SIZE;
|
||||
for (i = 0; i < pages; i++) {
|
||||
addr = __get_free_page(GFP_KERNEL);
|
||||
if (!addr)
|
||||
return -ENOMEM;
|
||||
ret = gen_pool_add(ghes_estatus_pool, addr, PAGE_SIZE, -1);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ghes_estatus_pool_shrink(unsigned long len)
|
||||
{
|
||||
ghes_estatus_pool_size_request -= PAGE_ALIGN(len);
|
||||
}
|
||||
|
||||
static struct ghes *ghes_new(struct acpi_hest_generic *generic)
|
||||
{
|
||||
struct ghes *ghes;
|
||||
|
|
@ -341,43 +449,196 @@ static void ghes_clear_estatus(struct ghes *ghes)
|
|||
ghes->flags &= ~GHES_TO_CLEAR;
|
||||
}
|
||||
|
||||
static void ghes_do_proc(struct ghes *ghes)
|
||||
static void ghes_do_proc(const struct acpi_hest_generic_status *estatus)
|
||||
{
|
||||
int sev, processed = 0;
|
||||
int sev, sec_sev;
|
||||
struct acpi_hest_generic_data *gdata;
|
||||
|
||||
sev = ghes_severity(ghes->estatus->error_severity);
|
||||
apei_estatus_for_each_section(ghes->estatus, gdata) {
|
||||
#ifdef CONFIG_X86_MCE
|
||||
sev = ghes_severity(estatus->error_severity);
|
||||
apei_estatus_for_each_section(estatus, gdata) {
|
||||
sec_sev = ghes_severity(gdata->error_severity);
|
||||
if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
|
||||
CPER_SEC_PLATFORM_MEM)) {
|
||||
apei_mce_report_mem_error(
|
||||
sev == GHES_SEV_CORRECTED,
|
||||
(struct cper_sec_mem_err *)(gdata+1));
|
||||
processed = 1;
|
||||
}
|
||||
struct cper_sec_mem_err *mem_err;
|
||||
mem_err = (struct cper_sec_mem_err *)(gdata+1);
|
||||
#ifdef CONFIG_X86_MCE
|
||||
apei_mce_report_mem_error(sev == GHES_SEV_CORRECTED,
|
||||
mem_err);
|
||||
#endif
|
||||
#ifdef CONFIG_ACPI_APEI_MEMORY_FAILURE
|
||||
if (sev == GHES_SEV_RECOVERABLE &&
|
||||
sec_sev == GHES_SEV_RECOVERABLE &&
|
||||
mem_err->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS) {
|
||||
unsigned long pfn;
|
||||
pfn = mem_err->physical_addr >> PAGE_SHIFT;
|
||||
memory_failure_queue(pfn, 0, 0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void ghes_print_estatus(const char *pfx, struct ghes *ghes)
|
||||
static void __ghes_print_estatus(const char *pfx,
|
||||
const struct acpi_hest_generic *generic,
|
||||
const struct acpi_hest_generic_status *estatus)
|
||||
{
|
||||
/* Not more than 2 messages every 5 seconds */
|
||||
static DEFINE_RATELIMIT_STATE(ratelimit, 5*HZ, 2);
|
||||
|
||||
if (pfx == NULL) {
|
||||
if (ghes_severity(ghes->estatus->error_severity) <=
|
||||
if (ghes_severity(estatus->error_severity) <=
|
||||
GHES_SEV_CORRECTED)
|
||||
pfx = KERN_WARNING HW_ERR;
|
||||
else
|
||||
pfx = KERN_ERR HW_ERR;
|
||||
}
|
||||
if (__ratelimit(&ratelimit)) {
|
||||
printk(
|
||||
"%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
|
||||
pfx, ghes->generic->header.source_id);
|
||||
apei_estatus_print(pfx, ghes->estatus);
|
||||
printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
|
||||
pfx, generic->header.source_id);
|
||||
apei_estatus_print(pfx, estatus);
|
||||
}
|
||||
|
||||
static int ghes_print_estatus(const char *pfx,
|
||||
const struct acpi_hest_generic *generic,
|
||||
const struct acpi_hest_generic_status *estatus)
|
||||
{
|
||||
/* 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 (ghes_severity(estatus->error_severity) <= GHES_SEV_CORRECTED)
|
||||
ratelimit = &ratelimit_corrected;
|
||||
else
|
||||
ratelimit = &ratelimit_uncorrected;
|
||||
if (__ratelimit(ratelimit)) {
|
||||
__ghes_print_estatus(pfx, generic, estatus);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* 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)
|
||||
{
|
||||
u32 len;
|
||||
int i, cached = 0;
|
||||
unsigned long long now;
|
||||
struct ghes_estatus_cache *cache;
|
||||
struct acpi_hest_generic_status *cache_estatus;
|
||||
|
||||
len = apei_estatus_len(estatus);
|
||||
rcu_read_lock();
|
||||
for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
|
||||
cache = rcu_dereference(ghes_estatus_caches[i]);
|
||||
if (cache == NULL)
|
||||
continue;
|
||||
if (len != cache->estatus_len)
|
||||
continue;
|
||||
cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
|
||||
if (memcmp(estatus, cache_estatus, len))
|
||||
continue;
|
||||
atomic_inc(&cache->count);
|
||||
now = sched_clock();
|
||||
if (now - cache->time_in < GHES_ESTATUS_IN_CACHE_MAX_NSEC)
|
||||
cached = 1;
|
||||
break;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
return cached;
|
||||
}
|
||||
|
||||
static struct ghes_estatus_cache *ghes_estatus_cache_alloc(
|
||||
struct acpi_hest_generic *generic,
|
||||
struct acpi_hest_generic_status *estatus)
|
||||
{
|
||||
int alloced;
|
||||
u32 len, cache_len;
|
||||
struct ghes_estatus_cache *cache;
|
||||
struct acpi_hest_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);
|
||||
cache_len = GHES_ESTATUS_CACHE_LEN(len);
|
||||
cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len);
|
||||
if (!cache) {
|
||||
atomic_dec(&ghes_estatus_cache_alloced);
|
||||
return NULL;
|
||||
}
|
||||
cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
|
||||
memcpy(cache_estatus, estatus, len);
|
||||
cache->estatus_len = len;
|
||||
atomic_set(&cache->count, 0);
|
||||
cache->generic = generic;
|
||||
cache->time_in = sched_clock();
|
||||
return cache;
|
||||
}
|
||||
|
||||
static void ghes_estatus_cache_free(struct ghes_estatus_cache *cache)
|
||||
{
|
||||
u32 len;
|
||||
|
||||
len = apei_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);
|
||||
}
|
||||
|
||||
static void ghes_estatus_cache_rcu_free(struct rcu_head *head)
|
||||
{
|
||||
struct ghes_estatus_cache *cache;
|
||||
|
||||
cache = container_of(head, struct ghes_estatus_cache, rcu);
|
||||
ghes_estatus_cache_free(cache);
|
||||
}
|
||||
|
||||
static void ghes_estatus_cache_add(
|
||||
struct acpi_hest_generic *generic,
|
||||
struct acpi_hest_generic_status *estatus)
|
||||
{
|
||||
int i, slot = -1, count;
|
||||
unsigned long long now, duration, period, max_period = 0;
|
||||
struct ghes_estatus_cache *cache, *slot_cache = NULL, *new_cache;
|
||||
|
||||
new_cache = ghes_estatus_cache_alloc(generic, estatus);
|
||||
if (new_cache == NULL)
|
||||
return;
|
||||
rcu_read_lock();
|
||||
now = sched_clock();
|
||||
for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
|
||||
cache = rcu_dereference(ghes_estatus_caches[i]);
|
||||
if (cache == NULL) {
|
||||
slot = i;
|
||||
slot_cache = NULL;
|
||||
break;
|
||||
}
|
||||
duration = now - cache->time_in;
|
||||
if (duration >= GHES_ESTATUS_IN_CACHE_MAX_NSEC) {
|
||||
slot = i;
|
||||
slot_cache = cache;
|
||||
break;
|
||||
}
|
||||
count = atomic_read(&cache->count);
|
||||
period = duration;
|
||||
do_div(period, (count + 1));
|
||||
if (period > max_period) {
|
||||
max_period = period;
|
||||
slot = i;
|
||||
slot_cache = cache;
|
||||
}
|
||||
}
|
||||
/* new_cache must be put into array after its contents are written */
|
||||
smp_wmb();
|
||||
if (slot != -1 && cmpxchg(ghes_estatus_caches + slot,
|
||||
slot_cache, new_cache) == slot_cache) {
|
||||
if (slot_cache)
|
||||
call_rcu(&slot_cache->rcu, ghes_estatus_cache_rcu_free);
|
||||
} else
|
||||
ghes_estatus_cache_free(new_cache);
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static int ghes_proc(struct ghes *ghes)
|
||||
|
|
@ -387,9 +648,11 @@ static int ghes_proc(struct ghes *ghes)
|
|||
rc = ghes_read_estatus(ghes, 0);
|
||||
if (rc)
|
||||
goto out;
|
||||
ghes_print_estatus(NULL, ghes);
|
||||
ghes_do_proc(ghes);
|
||||
|
||||
if (!ghes_estatus_cached(ghes->estatus)) {
|
||||
if (ghes_print_estatus(NULL, ghes->generic, ghes->estatus))
|
||||
ghes_estatus_cache_add(ghes->generic, ghes->estatus);
|
||||
}
|
||||
ghes_do_proc(ghes->estatus);
|
||||
out:
|
||||
ghes_clear_estatus(ghes);
|
||||
return 0;
|
||||
|
|
@ -447,6 +710,45 @@ static int ghes_notify_sci(struct notifier_block *this,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static void ghes_proc_in_irq(struct irq_work *irq_work)
|
||||
{
|
||||
struct llist_node *llnode, *next, *tail = NULL;
|
||||
struct ghes_estatus_node *estatus_node;
|
||||
struct acpi_hest_generic *generic;
|
||||
struct acpi_hest_generic_status *estatus;
|
||||
u32 len, node_len;
|
||||
|
||||
/*
|
||||
* Because the time order of estatus in list is reversed,
|
||||
* revert it back to proper order.
|
||||
*/
|
||||
llnode = llist_del_all(&ghes_estatus_llist);
|
||||
while (llnode) {
|
||||
next = llnode->next;
|
||||
llnode->next = tail;
|
||||
tail = llnode;
|
||||
llnode = next;
|
||||
}
|
||||
llnode = tail;
|
||||
while (llnode) {
|
||||
next = llnode->next;
|
||||
estatus_node = llist_entry(llnode, struct ghes_estatus_node,
|
||||
llnode);
|
||||
estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
|
||||
len = apei_estatus_len(estatus);
|
||||
node_len = GHES_ESTATUS_NODE_LEN(len);
|
||||
ghes_do_proc(estatus);
|
||||
if (!ghes_estatus_cached(estatus)) {
|
||||
generic = estatus_node->generic;
|
||||
if (ghes_print_estatus(NULL, generic, estatus))
|
||||
ghes_estatus_cache_add(generic, estatus);
|
||||
}
|
||||
gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node,
|
||||
node_len);
|
||||
llnode = next;
|
||||
}
|
||||
}
|
||||
|
||||
static int ghes_notify_nmi(struct notifier_block *this,
|
||||
unsigned long cmd, void *data)
|
||||
{
|
||||
|
|
@ -476,7 +778,8 @@ static int ghes_notify_nmi(struct notifier_block *this,
|
|||
|
||||
if (sev_global >= GHES_SEV_PANIC) {
|
||||
oops_begin();
|
||||
ghes_print_estatus(KERN_EMERG HW_ERR, ghes_global);
|
||||
__ghes_print_estatus(KERN_EMERG HW_ERR, ghes_global->generic,
|
||||
ghes_global->estatus);
|
||||
/* reboot to log the error! */
|
||||
if (panic_timeout == 0)
|
||||
panic_timeout = ghes_panic_timeout;
|
||||
|
|
@ -484,12 +787,34 @@ static int ghes_notify_nmi(struct notifier_block *this,
|
|||
}
|
||||
|
||||
list_for_each_entry_rcu(ghes, &ghes_nmi, list) {
|
||||
#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
|
||||
u32 len, node_len;
|
||||
struct ghes_estatus_node *estatus_node;
|
||||
struct acpi_hest_generic_status *estatus;
|
||||
#endif
|
||||
if (!(ghes->flags & GHES_TO_CLEAR))
|
||||
continue;
|
||||
/* Do not print estatus because printk is not NMI safe */
|
||||
ghes_do_proc(ghes);
|
||||
#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
|
||||
if (ghes_estatus_cached(ghes->estatus))
|
||||
goto next;
|
||||
/* Save estatus for further processing in IRQ context */
|
||||
len = apei_estatus_len(ghes->estatus);
|
||||
node_len = GHES_ESTATUS_NODE_LEN(len);
|
||||
estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool,
|
||||
node_len);
|
||||
if (estatus_node) {
|
||||
estatus_node->generic = ghes->generic;
|
||||
estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
|
||||
memcpy(estatus, ghes->estatus, len);
|
||||
llist_add(&estatus_node->llnode, &ghes_estatus_llist);
|
||||
}
|
||||
next:
|
||||
#endif
|
||||
ghes_clear_estatus(ghes);
|
||||
}
|
||||
#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
|
||||
irq_work_queue(&ghes_proc_irq_work);
|
||||
#endif
|
||||
|
||||
out:
|
||||
raw_spin_unlock(&ghes_nmi_lock);
|
||||
|
|
@ -504,10 +829,26 @@ static struct notifier_block ghes_notifier_nmi = {
|
|||
.notifier_call = ghes_notify_nmi,
|
||||
};
|
||||
|
||||
static unsigned long ghes_esource_prealloc_size(
|
||||
const struct acpi_hest_generic *generic)
|
||||
{
|
||||
unsigned long block_length, prealloc_records, prealloc_size;
|
||||
|
||||
block_length = min_t(unsigned long, generic->error_block_length,
|
||||
GHES_ESTATUS_MAX_SIZE);
|
||||
prealloc_records = max_t(unsigned long,
|
||||
generic->records_to_preallocate, 1);
|
||||
prealloc_size = min_t(unsigned long, block_length * prealloc_records,
|
||||
GHES_ESOURCE_PREALLOC_MAX_SIZE);
|
||||
|
||||
return prealloc_size;
|
||||
}
|
||||
|
||||
static int __devinit ghes_probe(struct platform_device *ghes_dev)
|
||||
{
|
||||
struct acpi_hest_generic *generic;
|
||||
struct ghes *ghes = NULL;
|
||||
unsigned long len;
|
||||
int rc = -EINVAL;
|
||||
|
||||
generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data;
|
||||
|
|
@ -573,6 +914,8 @@ static int __devinit ghes_probe(struct platform_device *ghes_dev)
|
|||
mutex_unlock(&ghes_list_mutex);
|
||||
break;
|
||||
case ACPI_HEST_NOTIFY_NMI:
|
||||
len = ghes_esource_prealloc_size(generic);
|
||||
ghes_estatus_pool_expand(len);
|
||||
mutex_lock(&ghes_list_mutex);
|
||||
if (list_empty(&ghes_nmi))
|
||||
register_die_notifier(&ghes_notifier_nmi);
|
||||
|
|
@ -597,6 +940,7 @@ static int __devexit ghes_remove(struct platform_device *ghes_dev)
|
|||
{
|
||||
struct ghes *ghes;
|
||||
struct acpi_hest_generic *generic;
|
||||
unsigned long len;
|
||||
|
||||
ghes = platform_get_drvdata(ghes_dev);
|
||||
generic = ghes->generic;
|
||||
|
|
@ -627,6 +971,8 @@ static int __devexit ghes_remove(struct platform_device *ghes_dev)
|
|||
* freed after NMI handler finishes.
|
||||
*/
|
||||
synchronize_rcu();
|
||||
len = ghes_esource_prealloc_size(generic);
|
||||
ghes_estatus_pool_shrink(len);
|
||||
break;
|
||||
default:
|
||||
BUG();
|
||||
|
|
@ -662,15 +1008,43 @@ static int __init ghes_init(void)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (ghes_disable) {
|
||||
pr_info(GHES_PFX "GHES is not enabled!\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq);
|
||||
|
||||
rc = ghes_ioremap_init();
|
||||
if (rc)
|
||||
goto err;
|
||||
|
||||
rc = platform_driver_register(&ghes_platform_driver);
|
||||
rc = ghes_estatus_pool_init();
|
||||
if (rc)
|
||||
goto err_ioremap_exit;
|
||||
|
||||
rc = ghes_estatus_pool_expand(GHES_ESTATUS_CACHE_AVG_SIZE *
|
||||
GHES_ESTATUS_CACHE_ALLOCED_MAX);
|
||||
if (rc)
|
||||
goto err_pool_exit;
|
||||
|
||||
rc = platform_driver_register(&ghes_platform_driver);
|
||||
if (rc)
|
||||
goto err_pool_exit;
|
||||
|
||||
rc = apei_osc_setup();
|
||||
if (rc == 0 && osc_sb_apei_support_acked)
|
||||
pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit and WHEA _OSC.\n");
|
||||
else if (rc == 0 && !osc_sb_apei_support_acked)
|
||||
pr_info(GHES_PFX "APEI firmware first mode is enabled by WHEA _OSC.\n");
|
||||
else if (rc && osc_sb_apei_support_acked)
|
||||
pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit.\n");
|
||||
else
|
||||
pr_info(GHES_PFX "Failed to enable APEI firmware first mode.\n");
|
||||
|
||||
return 0;
|
||||
err_pool_exit:
|
||||
ghes_estatus_pool_exit();
|
||||
err_ioremap_exit:
|
||||
ghes_ioremap_exit();
|
||||
err:
|
||||
|
|
@ -680,6 +1054,7 @@ err:
|
|||
static void __exit ghes_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&ghes_platform_driver);
|
||||
ghes_estatus_pool_exit();
|
||||
ghes_ioremap_exit();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -231,16 +231,17 @@ void __init acpi_hest_init(void)
|
|||
goto err;
|
||||
}
|
||||
|
||||
rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
|
||||
if (rc)
|
||||
goto err;
|
||||
|
||||
rc = hest_ghes_dev_register(ghes_count);
|
||||
if (!rc) {
|
||||
pr_info(HEST_PFX "Table parsing has been initialized.\n");
|
||||
return;
|
||||
if (!ghes_disable) {
|
||||
rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
|
||||
if (rc)
|
||||
goto err;
|
||||
rc = hest_ghes_dev_register(ghes_count);
|
||||
if (rc)
|
||||
goto err;
|
||||
}
|
||||
|
||||
pr_info(HEST_PFX "Table parsing has been initialized.\n");
|
||||
return;
|
||||
err:
|
||||
hest_disable = 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@
|
|||
#include <linux/pci.h>
|
||||
#include <acpi/acpi_bus.h>
|
||||
#include <acpi/acpi_drivers.h>
|
||||
#include <acpi/apei.h>
|
||||
#include <linux/dmi.h>
|
||||
#include <linux/suspend.h>
|
||||
|
||||
|
|
@ -519,6 +520,7 @@ out_kfree:
|
|||
}
|
||||
EXPORT_SYMBOL(acpi_run_osc);
|
||||
|
||||
bool osc_sb_apei_support_acked;
|
||||
static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
|
||||
static void acpi_bus_osc_support(void)
|
||||
{
|
||||
|
|
@ -541,11 +543,19 @@ static void acpi_bus_osc_support(void)
|
|||
#if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
|
||||
capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;
|
||||
#endif
|
||||
|
||||
if (!ghes_disable)
|
||||
capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_APEI_SUPPORT;
|
||||
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
|
||||
return;
|
||||
if (ACPI_SUCCESS(acpi_run_osc(handle, &context)))
|
||||
if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
|
||||
u32 *capbuf_ret = context.ret.pointer;
|
||||
if (context.ret.length > OSC_SUPPORT_TYPE)
|
||||
osc_sb_apei_support_acked =
|
||||
capbuf_ret[OSC_SUPPORT_TYPE] & OSC_SB_APEI_SUPPORT;
|
||||
kfree(context.ret.pointer);
|
||||
/* do we need to check the returned cap? Sounds no */
|
||||
}
|
||||
/* do we need to check other returned cap? Sounds no */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
|
|
|
|||
Loading…
Reference in a new issue