1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * APEI Generic Hardware Error Source support 4 * 5 * Generic Hardware Error Source provides a way to report platform 6 * hardware errors (such as that from chipset). It works in so called 7 * "Firmware First" mode, that is, hardware errors are reported to 8 * firmware firstly, then reported to Linux by firmware. This way, 9 * some non-standard hardware error registers or non-standard hardware 10 * link can be checked by firmware to produce more hardware error 11 * information for Linux. 12 * 13 * For more information about Generic Hardware Error Source, please 14 * refer to ACPI Specification version 4.0, section 17.3.2.6 15 * 16 * Copyright 2010,2011 Intel Corp. 17 * Author: Huang Ying <ying.huang@intel.com> 18 */ 19 20#include <linux/arm_sdei.h> 21#include <linux/kernel.h> 22#include <linux/moduleparam.h> 23#include <linux/init.h> 24#include <linux/acpi.h> 25#include <linux/io.h> 26#include <linux/interrupt.h> 27#include <linux/timer.h> 28#include <linux/cper.h> 29#include <linux/platform_device.h> 30#include <linux/mutex.h> 31#include <linux/ratelimit.h> 32#include <linux/vmalloc.h> 33#include <linux/irq_work.h> 34#include <linux/llist.h> 35#include <linux/genalloc.h> 36#include <linux/pci.h> 37#include <linux/pfn.h> 38#include <linux/aer.h> 39#include <linux/nmi.h> 40#include <linux/sched/clock.h> 41#include <linux/uuid.h> 42#include <linux/ras.h> 43#include <linux/task_work.h> 44 45#include <acpi/actbl1.h> 46#include <acpi/ghes.h> 47#include <acpi/apei.h> 48#include <asm/fixmap.h> 49#include <asm/tlbflush.h> 50#include <ras/ras_event.h> 51 52#include "apei-internal.h" 53 54#define GHES_PFX "GHES: " 55 56#define GHES_ESTATUS_MAX_SIZE 65536 57#define GHES_ESOURCE_PREALLOC_MAX_SIZE 65536 58 59#define GHES_ESTATUS_POOL_MIN_ALLOC_ORDER 3 60 61/* This is just an estimation for memory pool allocation */ 62#define GHES_ESTATUS_CACHE_AVG_SIZE 512 63 64#define GHES_ESTATUS_CACHES_SIZE 4 65 66#define GHES_ESTATUS_IN_CACHE_MAX_NSEC 10000000000ULL 67/* Prevent too many caches are allocated because of RCU */ 68#define GHES_ESTATUS_CACHE_ALLOCED_MAX (GHES_ESTATUS_CACHES_SIZE * 3 / 2) 69 70#define GHES_ESTATUS_CACHE_LEN(estatus_len) \ 71 (sizeof(struct ghes_estatus_cache) + (estatus_len)) 72#define GHES_ESTATUS_FROM_CACHE(estatus_cache) \ 73 ((struct acpi_hest_generic_status *) \ 74 ((struct ghes_estatus_cache *)(estatus_cache) + 1)) 75 76#define GHES_ESTATUS_NODE_LEN(estatus_len) \ 77 (sizeof(struct ghes_estatus_node) + (estatus_len)) 78#define GHES_ESTATUS_FROM_NODE(estatus_node) \ 79 ((struct acpi_hest_generic_status *) \ 80 ((struct ghes_estatus_node *)(estatus_node) + 1)) 81 82#define GHES_VENDOR_ENTRY_LEN(gdata_len) \ 83 (sizeof(struct ghes_vendor_record_entry) + (gdata_len)) 84#define GHES_GDATA_FROM_VENDOR_ENTRY(vendor_entry) \ 85 ((struct acpi_hest_generic_data *) \ 86 ((struct ghes_vendor_record_entry *)(vendor_entry) + 1)) 87 88/* 89 * NMI-like notifications vary by architecture, before the compiler can prune 90 * unused static functions it needs a value for these enums. 91 */ 92#ifndef CONFIG_ARM_SDE_INTERFACE 93#define FIX_APEI_GHES_SDEI_NORMAL __end_of_fixed_addresses 94#define FIX_APEI_GHES_SDEI_CRITICAL __end_of_fixed_addresses 95#endif 96 97static inline bool is_hest_type_generic_v2(struct ghes *ghes) 98{ 99 return ghes->generic->header.type == ACPI_HEST_TYPE_GENERIC_ERROR_V2; 100} 101 102/* 103 * A platform may describe one error source for the handling of synchronous 104 * errors (e.g. MCE or SEA), or for handling asynchronous errors (e.g. SCI 105 * or External Interrupt). On x86, the HEST notifications are always 106 * asynchronous, so only SEA on ARM is delivered as a synchronous 107 * notification. 108 */ 109static inline bool is_hest_sync_notify(struct ghes *ghes) 110{ 111 u8 notify_type = ghes->generic->notify.type; 112 113 return notify_type == ACPI_HEST_NOTIFY_SEA; 114} 115 116/* 117 * This driver isn't really modular, however for the time being, 118 * continuing to use module_param is the easiest way to remain 119 * compatible with existing boot arg use cases. 120 */ 121bool ghes_disable; 122module_param_named(disable, ghes_disable, bool, 0); 123 124/* 125 * All error sources notified with HED (Hardware Error Device) share a 126 * single notifier callback, so they need to be linked and checked one 127 * by one. This holds true for NMI too. 128 * 129 * RCU is used for these lists, so ghes_list_mutex is only used for 130 * list changing, not for traversing. 131 */ 132static LIST_HEAD(ghes_hed); 133static DEFINE_MUTEX(ghes_list_mutex); 134 135/* 136 * Because the memory area used to transfer hardware error information 137 * from BIOS to Linux can be determined only in NMI, IRQ or timer 138 * handler, but general ioremap can not be used in atomic context, so 139 * the fixmap is used instead. 140 * 141 * This spinlock is used to prevent the fixmap entry from being used 142 * simultaneously. 143 */ 144static DEFINE_SPINLOCK(ghes_notify_lock_irq); 145 146struct ghes_vendor_record_entry { 147 struct work_struct work; 148 int error_severity; 149 char vendor_record[]; 150}; 151 152static struct gen_pool *ghes_estatus_pool; 153static unsigned long ghes_estatus_pool_size_request; 154 155static struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE]; 156static atomic_t ghes_estatus_cache_alloced; 157 158static int ghes_panic_timeout __read_mostly = 30; 159 160static void __iomem *ghes_map(u64 pfn, enum fixed_addresses fixmap_idx) 161{ 162 phys_addr_t paddr; 163 pgprot_t prot; 164 165 paddr = PFN_PHYS(pfn); 166 prot = arch_apei_get_mem_attribute(paddr); 167 __set_fixmap(fixmap_idx, paddr, prot); 168 169 return (void __iomem *) __fix_to_virt(fixmap_idx); 170} 171 172static void ghes_unmap(void __iomem *vaddr, enum fixed_addresses fixmap_idx) 173{ 174 int _idx = virt_to_fix((unsigned long)vaddr); 175 176 WARN_ON_ONCE(fixmap_idx != _idx); 177 clear_fixmap(fixmap_idx); 178} 179 180int ghes_estatus_pool_init(unsigned int num_ghes) 181{ 182 unsigned long addr, len; 183 int rc; 184 185 ghes_estatus_pool = gen_pool_create(GHES_ESTATUS_POOL_MIN_ALLOC_ORDER, -1); 186 if (!ghes_estatus_pool) 187 return -ENOMEM; 188 189 len = GHES_ESTATUS_CACHE_AVG_SIZE * GHES_ESTATUS_CACHE_ALLOCED_MAX; 190 len += (num_ghes * GHES_ESOURCE_PREALLOC_MAX_SIZE); 191 192 ghes_estatus_pool_size_request = PAGE_ALIGN(len); 193 addr = (unsigned long)vmalloc(PAGE_ALIGN(len)); 194 if (!addr) 195 goto err_pool_alloc; 196 197 rc = gen_pool_add(ghes_estatus_pool, addr, PAGE_ALIGN(len), -1); 198 if (rc) 199 goto err_pool_add; 200 201 return 0; 202 203err_pool_add: 204 vfree((void *)addr); 205 206err_pool_alloc: 207 gen_pool_destroy(ghes_estatus_pool); 208 209 return -ENOMEM; 210} 211 212static int map_gen_v2(struct ghes *ghes) 213{ 214 return apei_map_generic_address(&ghes->generic_v2->read_ack_register); 215} 216 217static void unmap_gen_v2(struct ghes *ghes) 218{ 219 apei_unmap_generic_address(&ghes->generic_v2->read_ack_register); 220} 221 222static void ghes_ack_error(struct acpi_hest_generic_v2 *gv2) 223{ 224 int rc; 225 u64 val = 0; 226 227 rc = apei_read(&val, &gv2->read_ack_register); 228 if (rc) 229 return; 230 231 val &= gv2->read_ack_preserve << gv2->read_ack_register.bit_offset; 232 val |= gv2->read_ack_write << gv2->read_ack_register.bit_offset; 233 234 apei_write(val, &gv2->read_ack_register); 235} 236 237static struct ghes *ghes_new(struct acpi_hest_generic *generic) 238{ 239 struct ghes *ghes; 240 unsigned int error_block_length; 241 int rc; 242 243 ghes = kzalloc(sizeof(*ghes), GFP_KERNEL); 244 if (!ghes) 245 return ERR_PTR(-ENOMEM); 246 247 ghes->generic = generic; 248 if (is_hest_type_generic_v2(ghes)) { 249 rc = map_gen_v2(ghes); 250 if (rc) 251 goto err_free; 252 } 253 254 rc = apei_map_generic_address(&generic->error_status_address); 255 if (rc) 256 goto err_unmap_read_ack_addr; 257 error_block_length = generic->error_block_length; 258 if (error_block_length > GHES_ESTATUS_MAX_SIZE) { 259 pr_warn(FW_WARN GHES_PFX 260 "Error status block length is too long: %u for " 261 "generic hardware error source: %d.\n", 262 error_block_length, generic->header.source_id); 263 error_block_length = GHES_ESTATUS_MAX_SIZE; 264 } 265 ghes->estatus = kmalloc(error_block_length, GFP_KERNEL); 266 if (!ghes->estatus) { 267 rc = -ENOMEM; 268 goto err_unmap_status_addr; 269 } 270 271 return ghes; 272 273err_unmap_status_addr: 274 apei_unmap_generic_address(&generic->error_status_address); 275err_unmap_read_ack_addr: 276 if (is_hest_type_generic_v2(ghes)) 277 unmap_gen_v2(ghes); 278err_free: 279 kfree(ghes); 280 return ERR_PTR(rc); 281} 282 283static void ghes_fini(struct ghes *ghes) 284{ 285 kfree(ghes->estatus); 286 apei_unmap_generic_address(&ghes->generic->error_status_address); 287 if (is_hest_type_generic_v2(ghes)) 288 unmap_gen_v2(ghes); 289} 290 291static inline int ghes_severity(int severity) 292{ 293 switch (severity) { 294 case CPER_SEV_INFORMATIONAL: 295 return GHES_SEV_NO; 296 case CPER_SEV_CORRECTED: 297 return GHES_SEV_CORRECTED; 298 case CPER_SEV_RECOVERABLE: 299 return GHES_SEV_RECOVERABLE; 300 case CPER_SEV_FATAL: 301 return GHES_SEV_PANIC; 302 default: 303 /* Unknown, go panic */ 304 return GHES_SEV_PANIC; 305 } 306} 307 308static void ghes_copy_tofrom_phys(void *buffer, u64 paddr, u32 len, 309 int from_phys, 310 enum fixed_addresses fixmap_idx) 311{ 312 void __iomem *vaddr; 313 u64 offset; 314 u32 trunk; 315 316 while (len > 0) { 317 offset = paddr - (paddr & PAGE_MASK); 318 vaddr = ghes_map(PHYS_PFN(paddr), fixmap_idx); 319 trunk = PAGE_SIZE - offset; 320 trunk = min(trunk, len); 321 if (from_phys) 322 memcpy_fromio(buffer, vaddr + offset, trunk); 323 else 324 memcpy_toio(vaddr + offset, buffer, trunk); 325 len -= trunk; 326 paddr += trunk; 327 buffer += trunk; 328 ghes_unmap(vaddr, fixmap_idx); 329 } 330} 331 332/* Check the top-level record header has an appropriate size. */ 333static int __ghes_check_estatus(struct ghes *ghes, 334 struct acpi_hest_generic_status *estatus) 335{ 336 u32 len = cper_estatus_len(estatus); 337 338 if (len < sizeof(*estatus)) { 339 pr_warn_ratelimited(FW_WARN GHES_PFX "Truncated error status block!\n"); 340 return -EIO; 341 } 342 343 if (len > ghes->generic->error_block_length) { 344 pr_warn_ratelimited(FW_WARN GHES_PFX "Invalid error status block length!\n"); 345 return -EIO; 346 } 347 348 if (cper_estatus_check_header(estatus)) { 349 pr_warn_ratelimited(FW_WARN GHES_PFX "Invalid CPER header!\n"); 350 return -EIO; 351 } 352 353 return 0; 354} 355 356/* Read the CPER block, returning its address, and header in estatus. */ 357static int __ghes_peek_estatus(struct ghes *ghes, 358 struct acpi_hest_generic_status *estatus, 359 u64 *buf_paddr, enum fixed_addresses fixmap_idx) 360{ 361 struct acpi_hest_generic *g = ghes->generic; 362 int rc; 363 364 rc = apei_read(buf_paddr, &g->error_status_address); 365 if (rc) { 366 *buf_paddr = 0; 367 pr_warn_ratelimited(FW_WARN GHES_PFX 368"Failed to read error status block address for hardware error source: %d.\n", 369 g->header.source_id); 370 return -EIO; 371 } 372 if (!*buf_paddr) 373 return -ENOENT; 374 375 ghes_copy_tofrom_phys(estatus, *buf_paddr, sizeof(*estatus), 1, 376 fixmap_idx); 377 if (!estatus->block_status) { 378 *buf_paddr = 0; 379 return -ENOENT; 380 } 381 382 return 0; 383} 384 385static int __ghes_read_estatus(struct acpi_hest_generic_status *estatus, 386 u64 buf_paddr, enum fixed_addresses fixmap_idx, 387 size_t buf_len) 388{ 389 ghes_copy_tofrom_phys(estatus, buf_paddr, buf_len, 1, fixmap_idx); 390 if (cper_estatus_check(estatus)) { 391 pr_warn_ratelimited(FW_WARN GHES_PFX 392 "Failed to read error status block!\n"); 393 return -EIO; 394 } 395 396 return 0; 397} 398 399static int ghes_read_estatus(struct ghes *ghes, 400 struct acpi_hest_generic_status *estatus, 401 u64 *buf_paddr, enum fixed_addresses fixmap_idx) 402{ 403 int rc; 404 405 rc = __ghes_peek_estatus(ghes, estatus, buf_paddr, fixmap_idx); 406 if (rc) 407 return rc; 408 409 rc = __ghes_check_estatus(ghes, estatus); 410 if (rc) 411 return rc; 412 413 return __ghes_read_estatus(estatus, *buf_paddr, fixmap_idx, 414 cper_estatus_len(estatus)); 415} 416 417static void ghes_clear_estatus(struct ghes *ghes, 418 struct acpi_hest_generic_status *estatus, 419 u64 buf_paddr, enum fixed_addresses fixmap_idx) 420{ 421 estatus->block_status = 0; 422 423 if (!buf_paddr) 424 return; 425 426 ghes_copy_tofrom_phys(estatus, buf_paddr, 427 sizeof(estatus->block_status), 0, 428 fixmap_idx); 429 430 /* 431 * GHESv2 type HEST entries introduce support for error acknowledgment, 432 * so only acknowledge the error if this support is present. 433 */ 434 if (is_hest_type_generic_v2(ghes)) 435 ghes_ack_error(ghes->generic_v2); 436} 437 438/* 439 * Called as task_work before returning to user-space. 440 * Ensure any queued work has been done before we return to the context that 441 * triggered the notification. 442 */ 443static void ghes_kick_task_work(struct callback_head *head) 444{ 445 struct acpi_hest_generic_status *estatus; 446 struct ghes_estatus_node *estatus_node; 447 u32 node_len; 448 449 estatus_node = container_of(head, struct ghes_estatus_node, task_work); 450 if (IS_ENABLED(CONFIG_ACPI_APEI_MEMORY_FAILURE)) 451 memory_failure_queue_kick(estatus_node->task_work_cpu); 452 453 estatus = GHES_ESTATUS_FROM_NODE(estatus_node); 454 node_len = GHES_ESTATUS_NODE_LEN(cper_estatus_len(estatus)); 455 gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node, node_len); 456} 457 458static bool ghes_do_memory_failure(u64 physical_addr, int flags) 459{ 460 unsigned long pfn; 461 462 if (!IS_ENABLED(CONFIG_ACPI_APEI_MEMORY_FAILURE)) 463 return false; 464 465 pfn = PHYS_PFN(physical_addr); 466 if (!pfn_valid(pfn)) { 467 pr_warn_ratelimited(FW_WARN GHES_PFX 468 "Invalid address in generic error data: %#llx\n", 469 physical_addr); 470 return false; 471 } 472 473 memory_failure_queue(pfn, flags); 474 return true; 475} 476 477static bool ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, 478 int sev, bool sync) 479{ 480 int flags = -1; 481 int sec_sev = ghes_severity(gdata->error_severity); 482 struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); 483 484 if (!(mem_err->validation_bits & CPER_MEM_VALID_PA)) 485 return false; 486 487 /* iff following two events can be handled properly by now */ 488 if (sec_sev == GHES_SEV_CORRECTED && 489 (gdata->flags & CPER_SEC_ERROR_THRESHOLD_EXCEEDED)) 490 flags = MF_SOFT_OFFLINE; 491 if (sev == GHES_SEV_RECOVERABLE && sec_sev == GHES_SEV_RECOVERABLE) 492 flags = sync ? MF_ACTION_REQUIRED : 0; 493 494 if (flags != -1) 495 return ghes_do_memory_failure(mem_err->physical_addr, flags); 496 497 return false; 498} 499 500static bool ghes_handle_arm_hw_error(struct acpi_hest_generic_data *gdata, 501 int sev, bool sync) 502{ 503 struct cper_sec_proc_arm *err = acpi_hest_get_payload(gdata); 504 int flags = sync ? MF_ACTION_REQUIRED : 0; 505 bool queued = false; 506 int sec_sev, i; 507 char *p; 508 509 log_arm_hw_error(err); 510 511 sec_sev = ghes_severity(gdata->error_severity); 512 if (sev != GHES_SEV_RECOVERABLE || sec_sev != GHES_SEV_RECOVERABLE) 513 return false; 514 515 p = (char *)(err + 1); 516 for (i = 0; i < err->err_info_num; i++) { 517 struct cper_arm_err_info *err_info = (struct cper_arm_err_info *)p; 518 bool is_cache = (err_info->type == CPER_ARM_CACHE_ERROR); 519 bool has_pa = (err_info->validation_bits & CPER_ARM_INFO_VALID_PHYSICAL_ADDR); 520 const char *error_type = "unknown error"; 521 522 /* 523 * The field (err_info->error_info & BIT(26)) is fixed to set to 524 * 1 in some old firmware of HiSilicon Kunpeng920. We assume that 525 * firmware won't mix corrected errors in an uncorrected section, 526 * and don't filter out 'corrected' error here. 527 */ 528 if (is_cache && has_pa) { 529 queued = ghes_do_memory_failure(err_info->physical_fault_addr, flags); 530 p += err_info->length; 531 continue; 532 } 533 534 if (err_info->type < ARRAY_SIZE(cper_proc_error_type_strs)) 535 error_type = cper_proc_error_type_strs[err_info->type]; 536 537 pr_warn_ratelimited(FW_WARN GHES_PFX 538 "Unhandled processor error type: %s\n", 539 error_type); 540 p += err_info->length; 541 } 542 543 return queued; 544} 545 546/* 547 * PCIe AER errors need to be sent to the AER driver for reporting and 548 * recovery. The GHES severities map to the following AER severities and 549 * require the following handling: 550 * 551 * GHES_SEV_CORRECTABLE -> AER_CORRECTABLE 552 * These need to be reported by the AER driver but no recovery is 553 * necessary. 554 * GHES_SEV_RECOVERABLE -> AER_NONFATAL 555 * GHES_SEV_RECOVERABLE && CPER_SEC_RESET -> AER_FATAL 556 * These both need to be reported and recovered from by the AER driver. 557 * GHES_SEV_PANIC does not make it to this handling since the kernel must 558 * panic. 559 */ 560static void ghes_handle_aer(struct acpi_hest_generic_data *gdata) 561{ 562#ifdef CONFIG_ACPI_APEI_PCIEAER 563 struct cper_sec_pcie *pcie_err = acpi_hest_get_payload(gdata); 564 565 if (pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID && 566 pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) { 567 unsigned int devfn; 568 int aer_severity; 569 570 devfn = PCI_DEVFN(pcie_err->device_id.device, 571 pcie_err->device_id.function); 572 aer_severity = cper_severity_to_aer(gdata->error_severity); 573 574 /* 575 * If firmware reset the component to contain 576 * the error, we must reinitialize it before 577 * use, so treat it as a fatal AER error. 578 */ 579 if (gdata->flags & CPER_SEC_RESET) 580 aer_severity = AER_FATAL; 581 582 aer_recover_queue(pcie_err->device_id.segment, 583 pcie_err->device_id.bus, 584 devfn, aer_severity, 585 (struct aer_capability_regs *) 586 pcie_err->aer_info); 587 } 588#endif 589} 590 591static BLOCKING_NOTIFIER_HEAD(vendor_record_notify_list); 592 593int ghes_register_vendor_record_notifier(struct notifier_block *nb) 594{ 595 return blocking_notifier_chain_register(&vendor_record_notify_list, nb); 596} 597EXPORT_SYMBOL_GPL(ghes_register_vendor_record_notifier); 598 599void ghes_unregister_vendor_record_notifier(struct notifier_block *nb) 600{ 601 blocking_notifier_chain_unregister(&vendor_record_notify_list, nb); 602} 603EXPORT_SYMBOL_GPL(ghes_unregister_vendor_record_notifier); 604 605static void ghes_vendor_record_work_func(struct work_struct *work) 606{ 607 struct ghes_vendor_record_entry *entry; 608 struct acpi_hest_generic_data *gdata; 609 u32 len; 610 611 entry = container_of(work, struct ghes_vendor_record_entry, work); 612 gdata = GHES_GDATA_FROM_VENDOR_ENTRY(entry); 613 614 blocking_notifier_call_chain(&vendor_record_notify_list, 615 entry->error_severity, gdata); 616 617 len = GHES_VENDOR_ENTRY_LEN(acpi_hest_get_record_size(gdata)); 618 gen_pool_free(ghes_estatus_pool, (unsigned long)entry, len); 619} 620 621static void ghes_defer_non_standard_event(struct acpi_hest_generic_data *gdata, 622 int sev) 623{ 624 struct acpi_hest_generic_data *copied_gdata; 625 struct ghes_vendor_record_entry *entry; 626 u32 len; 627 628 len = GHES_VENDOR_ENTRY_LEN(acpi_hest_get_record_size(gdata)); 629 entry = (void *)gen_pool_alloc(ghes_estatus_pool, len); 630 if (!entry) 631 return; 632 633 copied_gdata = GHES_GDATA_FROM_VENDOR_ENTRY(entry); 634 memcpy(copied_gdata, gdata, acpi_hest_get_record_size(gdata)); 635 entry->error_severity = sev; 636 637 INIT_WORK(&entry->work, ghes_vendor_record_work_func); 638 schedule_work(&entry->work); 639} 640 641static bool ghes_do_proc(struct ghes *ghes, 642 const struct acpi_hest_generic_status *estatus) 643{ 644 int sev, sec_sev; 645 struct acpi_hest_generic_data *gdata; 646 guid_t *sec_type; 647 const guid_t *fru_id = &guid_null; 648 char *fru_text = ""; 649 bool queued = false; 650 bool sync = is_hest_sync_notify(ghes); 651 652 sev = ghes_severity(estatus->error_severity); 653 apei_estatus_for_each_section(estatus, gdata) { 654 sec_type = (guid_t *)gdata->section_type; 655 sec_sev = ghes_severity(gdata->error_severity); 656 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID) 657 fru_id = (guid_t *)gdata->fru_id; 658 659 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT) 660 fru_text = gdata->fru_text; 661 662 if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) { 663 struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); 664 665 ghes_edac_report_mem_error(sev, mem_err); 666 667 arch_apei_report_mem_error(sev, mem_err); 668 queued = ghes_handle_memory_failure(gdata, sev, sync); 669 } 670 else if (guid_equal(sec_type, &CPER_SEC_PCIE)) { 671 ghes_handle_aer(gdata); 672 } 673 else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) { 674 queued = ghes_handle_arm_hw_error(gdata, sev, sync); 675 } else { 676 void *err = acpi_hest_get_payload(gdata); 677 678 ghes_defer_non_standard_event(gdata, sev); 679 log_non_standard_event(sec_type, fru_id, fru_text, 680 sec_sev, err, 681 gdata->error_data_length); 682 } 683 } 684 685 return queued; 686} 687 688static void __ghes_print_estatus(const char *pfx, 689 const struct acpi_hest_generic *generic, 690 const struct acpi_hest_generic_status *estatus) 691{ 692 static atomic_t seqno; 693 unsigned int curr_seqno; 694 char pfx_seq[64]; 695 696 if (pfx == NULL) { 697 if (ghes_severity(estatus->error_severity) <= 698 GHES_SEV_CORRECTED) 699 pfx = KERN_WARNING; 700 else 701 pfx = KERN_ERR; 702 } 703 curr_seqno = atomic_inc_return(&seqno); 704 snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}" HW_ERR, pfx, curr_seqno); 705 printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n", 706 pfx_seq, generic->header.source_id); 707 cper_estatus_print(pfx_seq, estatus); 708} 709 710static int ghes_print_estatus(const char *pfx, 711 const struct acpi_hest_generic *generic, 712 const struct acpi_hest_generic_status *estatus) 713{ 714 /* Not more than 2 messages every 5 seconds */ 715 static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2); 716 static DEFINE_RATELIMIT_STATE(ratelimit_uncorrected, 5*HZ, 2); 717 struct ratelimit_state *ratelimit; 718 719 if (ghes_severity(estatus->error_severity) <= GHES_SEV_CORRECTED) 720 ratelimit = &ratelimit_corrected; 721 else 722 ratelimit = &ratelimit_uncorrected; 723 if (__ratelimit(ratelimit)) { 724 __ghes_print_estatus(pfx, generic, estatus); 725 return 1; 726 } 727 return 0; 728} 729 730/* 731 * GHES error status reporting throttle, to report more kinds of 732 * errors, instead of just most frequently occurred errors. 733 */ 734static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus) 735{ 736 u32 len; 737 int i, cached = 0; 738 unsigned long long now; 739 struct ghes_estatus_cache *cache; 740 struct acpi_hest_generic_status *cache_estatus; 741 742 len = cper_estatus_len(estatus); 743 rcu_read_lock(); 744 for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) { 745 cache = rcu_dereference(ghes_estatus_caches[i]); 746 if (cache == NULL) 747 continue; 748 if (len != cache->estatus_len) 749 continue; 750 cache_estatus = GHES_ESTATUS_FROM_CACHE(cache); 751 if (memcmp(estatus, cache_estatus, len)) 752 continue; 753 atomic_inc(&cache->count); 754 now = sched_clock(); 755 if (now - cache->time_in < GHES_ESTATUS_IN_CACHE_MAX_NSEC) 756 cached = 1; 757 break; 758 } 759 rcu_read_unlock(); 760 return cached; 761} 762 763static struct ghes_estatus_cache *ghes_estatus_cache_alloc( 764 struct acpi_hest_generic *generic, 765 struct acpi_hest_generic_status *estatus) 766{ 767 int alloced; 768 u32 len, cache_len; 769 struct ghes_estatus_cache *cache; 770 struct acpi_hest_generic_status *cache_estatus; 771 772 alloced = atomic_add_return(1, &ghes_estatus_cache_alloced); 773 if (alloced > GHES_ESTATUS_CACHE_ALLOCED_MAX) { 774 atomic_dec(&ghes_estatus_cache_alloced); 775 return NULL; 776 } 777 len = cper_estatus_len(estatus); 778 cache_len = GHES_ESTATUS_CACHE_LEN(len); 779 cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len); 780 if (!cache) { 781 atomic_dec(&ghes_estatus_cache_alloced); 782 return NULL; 783 } 784 cache_estatus = GHES_ESTATUS_FROM_CACHE(cache); 785 memcpy(cache_estatus, estatus, len); 786 cache->estatus_len = len; 787 atomic_set(&cache->count, 0); 788 cache->generic = generic; 789 cache->time_in = sched_clock(); 790 return cache; 791} 792 793static void ghes_estatus_cache_free(struct ghes_estatus_cache *cache) 794{ 795 u32 len; 796 797 len = cper_estatus_len(GHES_ESTATUS_FROM_CACHE(cache)); 798 len = GHES_ESTATUS_CACHE_LEN(len); 799 gen_pool_free(ghes_estatus_pool, (unsigned long)cache, len); 800 atomic_dec(&ghes_estatus_cache_alloced); 801} 802 803static void ghes_estatus_cache_rcu_free(struct rcu_head *head) 804{ 805 struct ghes_estatus_cache *cache; 806 807 cache = container_of(head, struct ghes_estatus_cache, rcu); 808 ghes_estatus_cache_free(cache); 809} 810 811static void ghes_estatus_cache_add( 812 struct acpi_hest_generic *generic, 813 struct acpi_hest_generic_status *estatus) 814{ 815 int i, slot = -1, count; 816 unsigned long long now, duration, period, max_period = 0; 817 struct ghes_estatus_cache *cache, *slot_cache = NULL, *new_cache; 818 819 new_cache = ghes_estatus_cache_alloc(generic, estatus); 820 if (new_cache == NULL) 821 return; 822 rcu_read_lock(); 823 now = sched_clock(); 824 for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) { 825 cache = rcu_dereference(ghes_estatus_caches[i]); 826 if (cache == NULL) { 827 slot = i; 828 slot_cache = NULL; 829 break; 830 } 831 duration = now - cache->time_in; 832 if (duration >= GHES_ESTATUS_IN_CACHE_MAX_NSEC) { 833 slot = i; 834 slot_cache = cache; 835 break; 836 } 837 count = atomic_read(&cache->count); 838 period = duration; 839 do_div(period, (count + 1)); 840 if (period > max_period) { 841 max_period = period; 842 slot = i; 843 slot_cache = cache; 844 } 845 } 846 /* new_cache must be put into array after its contents are written */ 847 smp_wmb(); 848 if (slot != -1 && cmpxchg(ghes_estatus_caches + slot, 849 slot_cache, new_cache) == slot_cache) { 850 if (slot_cache) 851 call_rcu(&slot_cache->rcu, ghes_estatus_cache_rcu_free); 852 } else 853 ghes_estatus_cache_free(new_cache); 854 rcu_read_unlock(); 855} 856 857static void __ghes_panic(struct ghes *ghes, 858 struct acpi_hest_generic_status *estatus, 859 u64 buf_paddr, enum fixed_addresses fixmap_idx) 860{ 861 __ghes_print_estatus(KERN_EMERG, ghes->generic, estatus); 862 863 ghes_clear_estatus(ghes, estatus, buf_paddr, fixmap_idx); 864 865 /* reboot to log the error! */ 866 if (!panic_timeout) 867 panic_timeout = ghes_panic_timeout; 868 panic("Fatal hardware error!"); 869} 870 871static int ghes_proc(struct ghes *ghes) 872{ 873 struct acpi_hest_generic_status *estatus = ghes->estatus; 874 u64 buf_paddr; 875 int rc; 876 877 rc = ghes_read_estatus(ghes, estatus, &buf_paddr, FIX_APEI_GHES_IRQ); 878 if (rc) 879 goto out; 880 881 if (ghes_severity(estatus->error_severity) >= GHES_SEV_PANIC) 882 __ghes_panic(ghes, estatus, buf_paddr, FIX_APEI_GHES_IRQ); 883 884 if (!ghes_estatus_cached(estatus)) { 885 if (ghes_print_estatus(NULL, ghes->generic, estatus)) 886 ghes_estatus_cache_add(ghes->generic, estatus); 887 } 888 ghes_do_proc(ghes, estatus); 889 890out: 891 ghes_clear_estatus(ghes, estatus, buf_paddr, FIX_APEI_GHES_IRQ); 892 893 return rc; 894} 895 896static void ghes_add_timer(struct ghes *ghes) 897{ 898 struct acpi_hest_generic *g = ghes->generic; 899 unsigned long expire; 900 901 if (!g->notify.poll_interval) { 902 pr_warn(FW_WARN GHES_PFX "Poll interval is 0 for generic hardware error source: %d, disabled.\n", 903 g->header.source_id); 904 return; 905 } 906 expire = jiffies + msecs_to_jiffies(g->notify.poll_interval); 907 ghes->timer.expires = round_jiffies_relative(expire); 908 add_timer(&ghes->timer); 909} 910 911static void ghes_poll_func(struct timer_list *t) 912{ 913 struct ghes *ghes = from_timer(ghes, t, timer); 914 unsigned long flags; 915 916 spin_lock_irqsave(&ghes_notify_lock_irq, flags); 917 ghes_proc(ghes); 918 spin_unlock_irqrestore(&ghes_notify_lock_irq, flags); 919 if (!(ghes->flags & GHES_EXITING)) 920 ghes_add_timer(ghes); 921} 922 923static irqreturn_t ghes_irq_func(int irq, void *data) 924{ 925 struct ghes *ghes = data; 926 unsigned long flags; 927 int rc; 928 929 spin_lock_irqsave(&ghes_notify_lock_irq, flags); 930 rc = ghes_proc(ghes); 931 spin_unlock_irqrestore(&ghes_notify_lock_irq, flags); 932 if (rc) 933 return IRQ_NONE; 934 935 return IRQ_HANDLED; 936} 937 938static int ghes_notify_hed(struct notifier_block *this, unsigned long event, 939 void *data) 940{ 941 struct ghes *ghes; 942 unsigned long flags; 943 int ret = NOTIFY_DONE; 944 945 spin_lock_irqsave(&ghes_notify_lock_irq, flags); 946 rcu_read_lock(); 947 list_for_each_entry_rcu(ghes, &ghes_hed, list) { 948 if (!ghes_proc(ghes)) 949 ret = NOTIFY_OK; 950 } 951 rcu_read_unlock(); 952 spin_unlock_irqrestore(&ghes_notify_lock_irq, flags); 953 954 return ret; 955} 956 957static struct notifier_block ghes_notifier_hed = { 958 .notifier_call = ghes_notify_hed, 959}; 960 961/* 962 * Handlers for CPER records may not be NMI safe. For example, 963 * memory_failure_queue() takes spinlocks and calls schedule_work_on(). 964 * In any NMI-like handler, memory from ghes_estatus_pool is used to save 965 * estatus, and added to the ghes_estatus_llist. irq_work_queue() causes 966 * ghes_proc_in_irq() to run in IRQ context where each estatus in 967 * ghes_estatus_llist is processed. 968 * 969 * Memory from the ghes_estatus_pool is also used with the ghes_estatus_cache 970 * to suppress frequent messages. 971 */ 972static struct llist_head ghes_estatus_llist; 973static struct irq_work ghes_proc_irq_work; 974 975static void ghes_proc_in_irq(struct irq_work *irq_work) 976{ 977 struct llist_node *llnode, *next; 978 struct ghes_estatus_node *estatus_node; 979 struct acpi_hest_generic *generic; 980 struct acpi_hest_generic_status *estatus; 981 bool task_work_pending; 982 u32 len, node_len; 983 int ret; 984 985 llnode = llist_del_all(&ghes_estatus_llist); 986 /* 987 * Because the time order of estatus in list is reversed, 988 * revert it back to proper order. 989 */ 990 llnode = llist_reverse_order(llnode); 991 while (llnode) { 992 next = llnode->next; 993 estatus_node = llist_entry(llnode, struct ghes_estatus_node, 994 llnode); 995 estatus = GHES_ESTATUS_FROM_NODE(estatus_node); 996 len = cper_estatus_len(estatus); 997 node_len = GHES_ESTATUS_NODE_LEN(len); 998 task_work_pending = ghes_do_proc(estatus_node->ghes, estatus); 999 if (!ghes_estatus_cached(estatus)) { 1000 generic = estatus_node->generic; 1001 if (ghes_print_estatus(NULL, generic, estatus)) 1002 ghes_estatus_cache_add(generic, estatus); 1003 } 1004 1005 if (task_work_pending && current->mm) { 1006 estatus_node->task_work.func = ghes_kick_task_work; 1007 estatus_node->task_work_cpu = smp_processor_id(); 1008 ret = task_work_add(current, &estatus_node->task_work, 1009 TWA_RESUME); 1010 if (ret) 1011 estatus_node->task_work.func = NULL; 1012 } 1013 1014 if (!estatus_node->task_work.func) 1015 gen_pool_free(ghes_estatus_pool, 1016 (unsigned long)estatus_node, node_len); 1017 1018 llnode = next; 1019 } 1020} 1021 1022static void ghes_print_queued_estatus(void) 1023{ 1024 struct llist_node *llnode; 1025 struct ghes_estatus_node *estatus_node; 1026 struct acpi_hest_generic *generic; 1027 struct acpi_hest_generic_status *estatus; 1028 1029 llnode = llist_del_all(&ghes_estatus_llist); 1030 /* 1031 * Because the time order of estatus in list is reversed, 1032 * revert it back to proper order. 1033 */ 1034 llnode = llist_reverse_order(llnode); 1035 while (llnode) { 1036 estatus_node = llist_entry(llnode, struct ghes_estatus_node, 1037 llnode); 1038 estatus = GHES_ESTATUS_FROM_NODE(estatus_node); 1039 generic = estatus_node->generic; 1040 ghes_print_estatus(NULL, generic, estatus); 1041 llnode = llnode->next; 1042 } 1043} 1044 1045static int ghes_in_nmi_queue_one_entry(struct ghes *ghes, 1046 enum fixed_addresses fixmap_idx) 1047{ 1048 struct acpi_hest_generic_status *estatus, tmp_header; 1049 struct ghes_estatus_node *estatus_node; 1050 u32 len, node_len; 1051 u64 buf_paddr; 1052 int sev, rc; 1053 1054 if (!IS_ENABLED(CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG)) 1055 return -EOPNOTSUPP; 1056 1057 rc = __ghes_peek_estatus(ghes, &tmp_header, &buf_paddr, fixmap_idx); 1058 if (rc) { 1059 ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx); 1060 return rc; 1061 } 1062 1063 rc = __ghes_check_estatus(ghes, &tmp_header); 1064 if (rc) { 1065 ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx); 1066 return rc; 1067 } 1068 1069 len = cper_estatus_len(&tmp_header); 1070 node_len = GHES_ESTATUS_NODE_LEN(len); 1071 estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool, node_len); 1072 if (!estatus_node) 1073 return -ENOMEM; 1074 1075 estatus_node->ghes = ghes; 1076 estatus_node->generic = ghes->generic; 1077 estatus_node->task_work.func = NULL; 1078 estatus = GHES_ESTATUS_FROM_NODE(estatus_node); 1079 1080 if (__ghes_read_estatus(estatus, buf_paddr, fixmap_idx, len)) { 1081 ghes_clear_estatus(ghes, estatus, buf_paddr, fixmap_idx); 1082 rc = -ENOENT; 1083 goto no_work; 1084 } 1085 1086 sev = ghes_severity(estatus->error_severity); 1087 if (sev >= GHES_SEV_PANIC) { 1088 ghes_print_queued_estatus(); 1089 __ghes_panic(ghes, estatus, buf_paddr, fixmap_idx); 1090 } 1091 1092 ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx); 1093 1094 /* This error has been reported before, don't process it again. */ 1095 if (ghes_estatus_cached(estatus)) 1096 goto no_work; 1097 1098 llist_add(&estatus_node->llnode, &ghes_estatus_llist); 1099 1100 return rc; 1101 1102no_work: 1103 gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node, 1104 node_len); 1105 1106 return rc; 1107} 1108 1109static int ghes_in_nmi_spool_from_list(struct list_head *rcu_list, 1110 enum fixed_addresses fixmap_idx) 1111{ 1112 int ret = -ENOENT; 1113 struct ghes *ghes; 1114 1115 rcu_read_lock(); 1116 list_for_each_entry_rcu(ghes, rcu_list, list) { 1117 if (!ghes_in_nmi_queue_one_entry(ghes, fixmap_idx)) 1118 ret = 0; 1119 } 1120 rcu_read_unlock(); 1121 1122 if (IS_ENABLED(CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG) && !ret) 1123 irq_work_queue(&ghes_proc_irq_work); 1124 1125 return ret; 1126} 1127 1128#ifdef CONFIG_ACPI_APEI_SEA 1129static LIST_HEAD(ghes_sea); 1130 1131/* 1132 * Return 0 only if one of the SEA error sources successfully reported an error 1133 * record sent from the firmware. 1134 */ 1135int ghes_notify_sea(void) 1136{ 1137 static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sea); 1138 int rv; 1139 1140 raw_spin_lock(&ghes_notify_lock_sea); 1141 rv = ghes_in_nmi_spool_from_list(&ghes_sea, FIX_APEI_GHES_SEA); 1142 raw_spin_unlock(&ghes_notify_lock_sea); 1143 1144 return rv; 1145} 1146 1147static void ghes_sea_add(struct ghes *ghes) 1148{ 1149 mutex_lock(&ghes_list_mutex); 1150 list_add_rcu(&ghes->list, &ghes_sea); 1151 mutex_unlock(&ghes_list_mutex); 1152} 1153 1154static void ghes_sea_remove(struct ghes *ghes) 1155{ 1156 mutex_lock(&ghes_list_mutex); 1157 list_del_rcu(&ghes->list); 1158 mutex_unlock(&ghes_list_mutex); 1159 synchronize_rcu(); 1160} 1161#else /* CONFIG_ACPI_APEI_SEA */ 1162static inline void ghes_sea_add(struct ghes *ghes) { } 1163static inline void ghes_sea_remove(struct ghes *ghes) { } 1164#endif /* CONFIG_ACPI_APEI_SEA */ 1165 1166#ifdef CONFIG_HAVE_ACPI_APEI_NMI 1167/* 1168 * NMI may be triggered on any CPU, so ghes_in_nmi is used for 1169 * having only one concurrent reader. 1170 */ 1171static atomic_t ghes_in_nmi = ATOMIC_INIT(0); 1172 1173static LIST_HEAD(ghes_nmi); 1174 1175static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs) 1176{ 1177 static DEFINE_RAW_SPINLOCK(ghes_notify_lock_nmi); 1178 int ret = NMI_DONE; 1179 1180 if (!atomic_add_unless(&ghes_in_nmi, 1, 1)) 1181 return ret; 1182 1183 raw_spin_lock(&ghes_notify_lock_nmi); 1184 if (!ghes_in_nmi_spool_from_list(&ghes_nmi, FIX_APEI_GHES_NMI)) 1185 ret = NMI_HANDLED; 1186 raw_spin_unlock(&ghes_notify_lock_nmi); 1187 1188 atomic_dec(&ghes_in_nmi); 1189 return ret; 1190} 1191 1192static void ghes_nmi_add(struct ghes *ghes) 1193{ 1194 mutex_lock(&ghes_list_mutex); 1195 if (list_empty(&ghes_nmi)) 1196 register_nmi_handler(NMI_LOCAL, ghes_notify_nmi, 0, "ghes"); 1197 list_add_rcu(&ghes->list, &ghes_nmi); 1198 mutex_unlock(&ghes_list_mutex); 1199} 1200 1201static void ghes_nmi_remove(struct ghes *ghes) 1202{ 1203 mutex_lock(&ghes_list_mutex); 1204 list_del_rcu(&ghes->list); 1205 if (list_empty(&ghes_nmi)) 1206 unregister_nmi_handler(NMI_LOCAL, "ghes"); 1207 mutex_unlock(&ghes_list_mutex); 1208 /* 1209 * To synchronize with NMI handler, ghes can only be 1210 * freed after NMI handler finishes. 1211 */ 1212 synchronize_rcu(); 1213} 1214#else /* CONFIG_HAVE_ACPI_APEI_NMI */ 1215static inline void ghes_nmi_add(struct ghes *ghes) { } 1216static inline void ghes_nmi_remove(struct ghes *ghes) { } 1217#endif /* CONFIG_HAVE_ACPI_APEI_NMI */ 1218 1219static void ghes_nmi_init_cxt(void) 1220{ 1221 init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq); 1222} 1223 1224static int __ghes_sdei_callback(struct ghes *ghes, 1225 enum fixed_addresses fixmap_idx) 1226{ 1227 if (!ghes_in_nmi_queue_one_entry(ghes, fixmap_idx)) { 1228 irq_work_queue(&ghes_proc_irq_work); 1229 1230 return 0; 1231 } 1232 1233 return -ENOENT; 1234} 1235 1236static int ghes_sdei_normal_callback(u32 event_num, struct pt_regs *regs, 1237 void *arg) 1238{ 1239 static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sdei_normal); 1240 struct ghes *ghes = arg; 1241 int err; 1242 1243 raw_spin_lock(&ghes_notify_lock_sdei_normal); 1244 err = __ghes_sdei_callback(ghes, FIX_APEI_GHES_SDEI_NORMAL); 1245 raw_spin_unlock(&ghes_notify_lock_sdei_normal); 1246 1247 return err; 1248} 1249 1250static int ghes_sdei_critical_callback(u32 event_num, struct pt_regs *regs, 1251 void *arg) 1252{ 1253 static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sdei_critical); 1254 struct ghes *ghes = arg; 1255 int err; 1256 1257 raw_spin_lock(&ghes_notify_lock_sdei_critical); 1258 err = __ghes_sdei_callback(ghes, FIX_APEI_GHES_SDEI_CRITICAL); 1259 raw_spin_unlock(&ghes_notify_lock_sdei_critical); 1260 1261 return err; 1262} 1263 1264static int apei_sdei_register_ghes(struct ghes *ghes) 1265{ 1266 if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE)) 1267 return -EOPNOTSUPP; 1268 1269 return sdei_register_ghes(ghes, ghes_sdei_normal_callback, 1270 ghes_sdei_critical_callback); 1271} 1272 1273static int apei_sdei_unregister_ghes(struct ghes *ghes) 1274{ 1275 if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE)) 1276 return -EOPNOTSUPP; 1277 1278 return sdei_unregister_ghes(ghes); 1279} 1280 1281static int ghes_probe(struct platform_device *ghes_dev) 1282{ 1283 struct acpi_hest_generic *generic; 1284 struct ghes *ghes = NULL; 1285 unsigned long flags; 1286 1287 int rc = -EINVAL; 1288 1289 generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data; 1290 if (!generic->enabled) 1291 return -ENODEV; 1292 1293 switch (generic->notify.type) { 1294 case ACPI_HEST_NOTIFY_POLLED: 1295 case ACPI_HEST_NOTIFY_EXTERNAL: 1296 case ACPI_HEST_NOTIFY_SCI: 1297 case ACPI_HEST_NOTIFY_GSIV: 1298 case ACPI_HEST_NOTIFY_GPIO: 1299 break; 1300 1301 case ACPI_HEST_NOTIFY_SEA: 1302 if (!IS_ENABLED(CONFIG_ACPI_APEI_SEA)) { 1303 pr_warn(GHES_PFX "Generic hardware error source: %d notified via SEA is not supported\n", 1304 generic->header.source_id); 1305 rc = -ENOTSUPP; 1306 goto err; 1307 } 1308 break; 1309 case ACPI_HEST_NOTIFY_NMI: 1310 if (!IS_ENABLED(CONFIG_HAVE_ACPI_APEI_NMI)) { 1311 pr_warn(GHES_PFX "Generic hardware error source: %d notified via NMI interrupt is not supported!\n", 1312 generic->header.source_id); 1313 goto err; 1314 } 1315 break; 1316 case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED: 1317 if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE)) { 1318 pr_warn(GHES_PFX "Generic hardware error source: %d notified via SDE Interface is not supported!\n", 1319 generic->header.source_id); 1320 goto err; 1321 } 1322 break; 1323 case ACPI_HEST_NOTIFY_LOCAL: 1324 pr_warn(GHES_PFX "Generic hardware error source: %d notified via local interrupt is not supported!\n", 1325 generic->header.source_id); 1326 goto err; 1327 default: 1328 pr_warn(FW_WARN GHES_PFX "Unknown notification type: %u for generic hardware error source: %d\n", 1329 generic->notify.type, generic->header.source_id); 1330 goto err; 1331 } 1332 1333 rc = -EIO; 1334 if (generic->error_block_length < 1335 sizeof(struct acpi_hest_generic_status)) { 1336 pr_warn(FW_BUG GHES_PFX "Invalid error block length: %u for generic hardware error source: %d\n", 1337 generic->error_block_length, generic->header.source_id); 1338 goto err; 1339 } 1340 ghes = ghes_new(generic); 1341 if (IS_ERR(ghes)) { 1342 rc = PTR_ERR(ghes); 1343 ghes = NULL; 1344 goto err; 1345 } 1346 1347 switch (generic->notify.type) { 1348 case ACPI_HEST_NOTIFY_POLLED: 1349 timer_setup(&ghes->timer, ghes_poll_func, 0); 1350 ghes_add_timer(ghes); 1351 break; 1352 case ACPI_HEST_NOTIFY_EXTERNAL: 1353 /* External interrupt vector is GSI */ 1354 rc = acpi_gsi_to_irq(generic->notify.vector, &ghes->irq); 1355 if (rc) { 1356 pr_err(GHES_PFX "Failed to map GSI to IRQ for generic hardware error source: %d\n", 1357 generic->header.source_id); 1358 goto err; 1359 } 1360 rc = request_irq(ghes->irq, ghes_irq_func, IRQF_SHARED, 1361 "GHES IRQ", ghes); 1362 if (rc) { 1363 pr_err(GHES_PFX "Failed to register IRQ for generic hardware error source: %d\n", 1364 generic->header.source_id); 1365 goto err; 1366 } 1367 break; 1368 1369 case ACPI_HEST_NOTIFY_SCI: 1370 case ACPI_HEST_NOTIFY_GSIV: 1371 case ACPI_HEST_NOTIFY_GPIO: 1372 mutex_lock(&ghes_list_mutex); 1373 if (list_empty(&ghes_hed)) 1374 register_acpi_hed_notifier(&ghes_notifier_hed); 1375 list_add_rcu(&ghes->list, &ghes_hed); 1376 mutex_unlock(&ghes_list_mutex); 1377 break; 1378 1379 case ACPI_HEST_NOTIFY_SEA: 1380 ghes_sea_add(ghes); 1381 break; 1382 case ACPI_HEST_NOTIFY_NMI: 1383 ghes_nmi_add(ghes); 1384 break; 1385 case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED: 1386 rc = apei_sdei_register_ghes(ghes); 1387 if (rc) 1388 goto err; 1389 break; 1390 default: 1391 BUG(); 1392 } 1393 1394 platform_set_drvdata(ghes_dev, ghes); 1395 1396 ghes_edac_register(ghes, &ghes_dev->dev); 1397 1398 /* Handle any pending errors right away */ 1399 spin_lock_irqsave(&ghes_notify_lock_irq, flags); 1400 ghes_proc(ghes); 1401 spin_unlock_irqrestore(&ghes_notify_lock_irq, flags); 1402 1403 return 0; 1404 1405err: 1406 if (ghes) { 1407 ghes_fini(ghes); 1408 kfree(ghes); 1409 } 1410 return rc; 1411} 1412 1413static int ghes_remove(struct platform_device *ghes_dev) 1414{ 1415 int rc; 1416 struct ghes *ghes; 1417 struct acpi_hest_generic *generic; 1418 1419 ghes = platform_get_drvdata(ghes_dev); 1420 generic = ghes->generic; 1421 1422 ghes->flags |= GHES_EXITING; 1423 switch (generic->notify.type) { 1424 case ACPI_HEST_NOTIFY_POLLED: 1425 del_timer_sync(&ghes->timer); 1426 break; 1427 case ACPI_HEST_NOTIFY_EXTERNAL: 1428 free_irq(ghes->irq, ghes); 1429 break; 1430 1431 case ACPI_HEST_NOTIFY_SCI: 1432 case ACPI_HEST_NOTIFY_GSIV: 1433 case ACPI_HEST_NOTIFY_GPIO: 1434 mutex_lock(&ghes_list_mutex); 1435 list_del_rcu(&ghes->list); 1436 if (list_empty(&ghes_hed)) 1437 unregister_acpi_hed_notifier(&ghes_notifier_hed); 1438 mutex_unlock(&ghes_list_mutex); 1439 synchronize_rcu(); 1440 break; 1441 1442 case ACPI_HEST_NOTIFY_SEA: 1443 ghes_sea_remove(ghes); 1444 break; 1445 case ACPI_HEST_NOTIFY_NMI: 1446 ghes_nmi_remove(ghes); 1447 break; 1448 case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED: 1449 rc = apei_sdei_unregister_ghes(ghes); 1450 if (rc) 1451 return rc; 1452 break; 1453 default: 1454 BUG(); 1455 break; 1456 } 1457 1458 ghes_fini(ghes); 1459 1460 ghes_edac_unregister(ghes); 1461 1462 kfree(ghes); 1463 1464 platform_set_drvdata(ghes_dev, NULL); 1465 1466 return 0; 1467} 1468 1469static struct platform_driver ghes_platform_driver = { 1470 .driver = { 1471 .name = "GHES", 1472 }, 1473 .probe = ghes_probe, 1474 .remove = ghes_remove, 1475}; 1476 1477void __init ghes_init(void) 1478{ 1479 int rc; 1480 1481 sdei_init(); 1482 1483 if (acpi_disabled) 1484 return; 1485 1486 switch (hest_disable) { 1487 case HEST_NOT_FOUND: 1488 return; 1489 case HEST_DISABLED: 1490 pr_info(GHES_PFX "HEST is not enabled!\n"); 1491 return; 1492 default: 1493 break; 1494 } 1495 1496 if (ghes_disable) { 1497 pr_info(GHES_PFX "GHES is not enabled!\n"); 1498 return; 1499 } 1500 1501 ghes_nmi_init_cxt(); 1502 1503 rc = platform_driver_register(&ghes_platform_driver); 1504 if (rc) 1505 return; 1506 1507 rc = apei_osc_setup(); 1508 if (rc == 0 && osc_sb_apei_support_acked) 1509 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit and WHEA _OSC.\n"); 1510 else if (rc == 0 && !osc_sb_apei_support_acked) 1511 pr_info(GHES_PFX "APEI firmware first mode is enabled by WHEA _OSC.\n"); 1512 else if (rc && osc_sb_apei_support_acked) 1513 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit.\n"); 1514 else 1515 pr_info(GHES_PFX "Failed to enable APEI firmware first mode.\n"); 1516} 1517