drivers/acpi/apei/ghes.c

   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
  97 static ATOMIC_NOTIFIER_HEAD(ghes_report_chain);
  98
  99 static inline bool is_hest_type_generic_v2(struct ghes *ghes)
 100 {
 101         return ghes->generic->header.type == ACPI_HEST_TYPE_GENERIC_ERROR_V2;
 102 }
 103
 104 /*
 105  * This driver isn't really modular, however for the time being,
 106  * continuing to use module_param is the easiest way to remain
 107  * compatible with existing boot arg use cases.
 108  */
 109 bool ghes_disable;
 110 module_param_named(disable, ghes_disable, bool, 0);
 111
 112 /*
 113  * "ghes.edac_force_enable" forcibly enables ghes_edac and skips the platform
 114  * check.
 115  */
 116 static bool ghes_edac_force_enable;
 117 module_param_named(edac_force_enable, ghes_edac_force_enable, bool, 0);
 118
 119 /*
 120  * All error sources notified with HED (Hardware Error Device) share a
 121  * single notifier callback, so they need to be linked and checked one
 122  * by one. This holds true for NMI too.
 123  *
 124  * RCU is used for these lists, so ghes_list_mutex is only used for
 125  * list changing, not for traversing.
 126  */
 127 static LIST_HEAD(ghes_hed);
 128 static DEFINE_MUTEX(ghes_list_mutex);
 129
 130 /*
 131  * A list of GHES devices which are given to the corresponding EDAC driver
 132  * ghes_edac for further use.
 133  */
 134 static LIST_HEAD(ghes_devs);
 135 static DEFINE_MUTEX(ghes_devs_mutex);
 136
 137 /*
 138  * Because the memory area used to transfer hardware error information
 139  * from BIOS to Linux can be determined only in NMI, IRQ or timer
 140  * handler, but general ioremap can not be used in atomic context, so
 141  * the fixmap is used instead.
 142  *
 143  * This spinlock is used to prevent the fixmap entry from being used
 144  * simultaneously.
 145  */
 146 static DEFINE_SPINLOCK(ghes_notify_lock_irq);
 147
 148 struct ghes_vendor_record_entry {
 149         struct work_struct work;
 150         int error_severity;
 151         char vendor_record[];
 152 };
 153
 154 static struct gen_pool *ghes_estatus_pool;
 155
 156 static struct ghes_estatus_cache __rcu *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
 157 static atomic_t ghes_estatus_cache_alloced;
 158
 159 static int ghes_panic_timeout __read_mostly = 30;
 160
 161 static void __iomem *ghes_map(u64 pfn, enum fixed_addresses fixmap_idx)
 162 {
 163         phys_addr_t paddr;
 164         pgprot_t prot;
 165
 166         paddr = PFN_PHYS(pfn);
 167         prot = arch_apei_get_mem_attribute(paddr);
 168         __set_fixmap(fixmap_idx, paddr, prot);
 169
 170         return (void __iomem *) __fix_to_virt(fixmap_idx);
 171 }
 172
 173 static void ghes_unmap(void __iomem *vaddr, enum fixed_addresses fixmap_idx)
 174 {
 175         int _idx = virt_to_fix((unsigned long)vaddr);
 176
 177         WARN_ON_ONCE(fixmap_idx != _idx);
 178         clear_fixmap(fixmap_idx);
 179 }
 180
 181 int ghes_estatus_pool_init(unsigned int num_ghes)
 182 {
 183         unsigned long addr, len;
 184         int rc;
 185
 186         ghes_estatus_pool = gen_pool_create(GHES_ESTATUS_POOL_MIN_ALLOC_ORDER, -1);
 187         if (!ghes_estatus_pool)
 188                 return -ENOMEM;
 189
 190         len = GHES_ESTATUS_CACHE_AVG_SIZE * GHES_ESTATUS_CACHE_ALLOCED_MAX;
 191         len += (num_ghes * GHES_ESOURCE_PREALLOC_MAX_SIZE);
 192
 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
 203 err_pool_add:
 204         vfree((void *)addr);
 205
 206 err_pool_alloc:
 207         gen_pool_destroy(ghes_estatus_pool);
 208
 209         return -ENOMEM;
 210 }
 211
 212 static int map_gen_v2(struct ghes *ghes)
 213 {
 214         return apei_map_generic_address(&ghes->generic_v2->read_ack_register);
 215 }
 216
 217 static void unmap_gen_v2(struct ghes *ghes)
 218 {
 219         apei_unmap_generic_address(&ghes->generic_v2->read_ack_register);
 220 }
 221
 222 static 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
 237 static 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
 273 err_unmap_status_addr:
 274         apei_unmap_generic_address(&generic->error_status_address);
 275 err_unmap_read_ack_addr:
 276         if (is_hest_type_generic_v2(ghes))
 277                 unmap_gen_v2(ghes);
 278 err_free:
 279         kfree(ghes);
 280         return ERR_PTR(rc);
 281 }
 282
 283 static 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
 291 static 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
 308 static 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. */
 333 static 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. */
 357 static 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
 385 static 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
 399 static 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
 417 static 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  */
 443 static 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
 458 static 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) && !arch_is_platform_page(physical_addr)) {
 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
 477 static bool ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata,
 478                                        int sev)
 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 = 0;
 493
 494         if (flags != -1)
 495                 return ghes_do_memory_failure(mem_err->physical_addr, flags);
 496
 497         return false;
 498 }
 499
 500 static bool ghes_handle_arm_hw_error(struct acpi_hest_generic_data *gdata, int sev)
 501 {
 502         struct cper_sec_proc_arm *err = acpi_hest_get_payload(gdata);
 503         bool queued = false;
 504         int sec_sev, i;
 505         char *p;
 506
 507         log_arm_hw_error(err);
 508
 509         sec_sev = ghes_severity(gdata->error_severity);
 510         if (sev != GHES_SEV_RECOVERABLE || sec_sev != GHES_SEV_RECOVERABLE)
 511                 return false;
 512
 513         p = (char *)(err + 1);
 514         for (i = 0; i < err->err_info_num; i++) {
 515                 struct cper_arm_err_info *err_info = (struct cper_arm_err_info *)p;
 516                 bool is_cache = (err_info->type == CPER_ARM_CACHE_ERROR);
 517                 bool has_pa = (err_info->validation_bits & CPER_ARM_INFO_VALID_PHYSICAL_ADDR);
 518                 const char *error_type = "unknown error";
 519
 520                 /*
 521                  * The field (err_info->error_info & BIT(26)) is fixed to set to
 522                  * 1 in some old firmware of HiSilicon Kunpeng920. We assume that
 523                  * firmware won't mix corrected errors in an uncorrected section,
 524                  * and don't filter out 'corrected' error here.
 525                  */
 526                 if (is_cache && has_pa) {
 527                         queued = ghes_do_memory_failure(err_info->physical_fault_addr, 0);
 528                         p += err_info->length;
 529                         continue;
 530                 }
 531
 532                 if (err_info->type < ARRAY_SIZE(cper_proc_error_type_strs))
 533                         error_type = cper_proc_error_type_strs[err_info->type];
 534
 535                 pr_warn_ratelimited(FW_WARN GHES_PFX
 536                                     "Unhandled processor error type: %s\n",
 537                                     error_type);
 538                 p += err_info->length;
 539         }
 540
 541         return queued;
 542 }
 543
 544 /*
 545  * PCIe AER errors need to be sent to the AER driver for reporting and
 546  * recovery. The GHES severities map to the following AER severities and
 547  * require the following handling:
 548  *
 549  * GHES_SEV_CORRECTABLE -> AER_CORRECTABLE
 550  *     These need to be reported by the AER driver but no recovery is
 551  *     necessary.
 552  * GHES_SEV_RECOVERABLE -> AER_NONFATAL
 553  * GHES_SEV_RECOVERABLE && CPER_SEC_RESET -> AER_FATAL
 554  *     These both need to be reported and recovered from by the AER driver.
 555  * GHES_SEV_PANIC does not make it to this handling since the kernel must
 556  *     panic.
 557  */
 558 static void ghes_handle_aer(struct acpi_hest_generic_data *gdata)
 559 {
 560 #ifdef CONFIG_ACPI_APEI_PCIEAER
 561         struct cper_sec_pcie *pcie_err = acpi_hest_get_payload(gdata);
 562
 563         if (pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID &&
 564             pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) {
 565                 unsigned int devfn;
 566                 int aer_severity;
 567
 568                 devfn = PCI_DEVFN(pcie_err->device_id.device,
 569                                   pcie_err->device_id.function);
 570                 aer_severity = cper_severity_to_aer(gdata->error_severity);
 571
 572                 /*
 573                  * If firmware reset the component to contain
 574                  * the error, we must reinitialize it before
 575                  * use, so treat it as a fatal AER error.
 576                  */
 577                 if (gdata->flags & CPER_SEC_RESET)
 578                         aer_severity = AER_FATAL;
 579
 580                 aer_recover_queue(pcie_err->device_id.segment,
 581                                   pcie_err->device_id.bus,
 582                                   devfn, aer_severity,
 583                                   (struct aer_capability_regs *)
 584                                   pcie_err->aer_info);
 585         }
 586 #endif
 587 }
 588
 589 static BLOCKING_NOTIFIER_HEAD(vendor_record_notify_list);
 590
 591 int ghes_register_vendor_record_notifier(struct notifier_block *nb)
 592 {
 593         return blocking_notifier_chain_register(&vendor_record_notify_list, nb);
 594 }
 595 EXPORT_SYMBOL_GPL(ghes_register_vendor_record_notifier);
 596
 597 void ghes_unregister_vendor_record_notifier(struct notifier_block *nb)
 598 {
 599         blocking_notifier_chain_unregister(&vendor_record_notify_list, nb);
 600 }
 601 EXPORT_SYMBOL_GPL(ghes_unregister_vendor_record_notifier);
 602
 603 static void ghes_vendor_record_work_func(struct work_struct *work)
 604 {
 605         struct ghes_vendor_record_entry *entry;
 606         struct acpi_hest_generic_data *gdata;
 607         u32 len;
 608
 609         entry = container_of(work, struct ghes_vendor_record_entry, work);
 610         gdata = GHES_GDATA_FROM_VENDOR_ENTRY(entry);
 611
 612         blocking_notifier_call_chain(&vendor_record_notify_list,
 613                                      entry->error_severity, gdata);
 614
 615         len = GHES_VENDOR_ENTRY_LEN(acpi_hest_get_record_size(gdata));
 616         gen_pool_free(ghes_estatus_pool, (unsigned long)entry, len);
 617 }
 618
 619 static void ghes_defer_non_standard_event(struct acpi_hest_generic_data *gdata,
 620                                           int sev)
 621 {
 622         struct acpi_hest_generic_data *copied_gdata;
 623         struct ghes_vendor_record_entry *entry;
 624         u32 len;
 625
 626         len = GHES_VENDOR_ENTRY_LEN(acpi_hest_get_record_size(gdata));
 627         entry = (void *)gen_pool_alloc(ghes_estatus_pool, len);
 628         if (!entry)
 629                 return;
 630
 631         copied_gdata = GHES_GDATA_FROM_VENDOR_ENTRY(entry);
 632         memcpy(copied_gdata, gdata, acpi_hest_get_record_size(gdata));
 633         entry->error_severity = sev;
 634
 635         INIT_WORK(&entry->work, ghes_vendor_record_work_func);
 636         schedule_work(&entry->work);
 637 }
 638
 639 static bool ghes_do_proc(struct ghes *ghes,
 640                          const struct acpi_hest_generic_status *estatus)
 641 {
 642         int sev, sec_sev;
 643         struct acpi_hest_generic_data *gdata;
 644         guid_t *sec_type;
 645         const guid_t *fru_id = &guid_null;
 646         char *fru_text = "";
 647         bool queued = false;
 648
 649         sev = ghes_severity(estatus->error_severity);
 650         apei_estatus_for_each_section(estatus, gdata) {
 651                 sec_type = (guid_t *)gdata->section_type;
 652                 sec_sev = ghes_severity(gdata->error_severity);
 653                 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID)
 654                         fru_id = (guid_t *)gdata->fru_id;
 655
 656                 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT)
 657                         fru_text = gdata->fru_text;
 658
 659                 if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) {
 660                         struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata);
 661
 662                         atomic_notifier_call_chain(&ghes_report_chain, sev, mem_err);
 663
 664                         arch_apei_report_mem_error(sev, mem_err);
 665                         queued = ghes_handle_memory_failure(gdata, sev);
 666                 }
 667                 else if (guid_equal(sec_type, &CPER_SEC_PCIE)) {
 668                         ghes_handle_aer(gdata);
 669                 }
 670                 else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) {
 671                         queued = ghes_handle_arm_hw_error(gdata, sev);
 672                 } else {
 673                         void *err = acpi_hest_get_payload(gdata);
 674
 675                         ghes_defer_non_standard_event(gdata, sev);
 676                         log_non_standard_event(sec_type, fru_id, fru_text,
 677                                                sec_sev, err,
 678                                                gdata->error_data_length);
 679                 }
 680         }
 681
 682         return queued;
 683 }
 684
 685 static void __ghes_print_estatus(const char *pfx,
 686                                  const struct acpi_hest_generic *generic,
 687                                  const struct acpi_hest_generic_status *estatus)
 688 {
 689         static atomic_t seqno;
 690         unsigned int curr_seqno;
 691         char pfx_seq[64];
 692
 693         if (pfx == NULL) {
 694                 if (ghes_severity(estatus->error_severity) <=
 695                     GHES_SEV_CORRECTED)
 696                         pfx = KERN_WARNING;
 697                 else
 698                         pfx = KERN_ERR;
 699         }
 700         curr_seqno = atomic_inc_return(&seqno);
 701         snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}" HW_ERR, pfx, curr_seqno);
 702         printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
 703                pfx_seq, generic->header.source_id);
 704         cper_estatus_print(pfx_seq, estatus);
 705 }
 706
 707 static int ghes_print_estatus(const char *pfx,
 708                               const struct acpi_hest_generic *generic,
 709                               const struct acpi_hest_generic_status *estatus)
 710 {
 711         /* Not more than 2 messages every 5 seconds */
 712         static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2);
 713         static DEFINE_RATELIMIT_STATE(ratelimit_uncorrected, 5*HZ, 2);
 714         struct ratelimit_state *ratelimit;
 715
 716         if (ghes_severity(estatus->error_severity) <= GHES_SEV_CORRECTED)
 717                 ratelimit = &ratelimit_corrected;
 718         else
 719                 ratelimit = &ratelimit_uncorrected;
 720         if (__ratelimit(ratelimit)) {
 721                 __ghes_print_estatus(pfx, generic, estatus);
 722                 return 1;
 723         }
 724         return 0;
 725 }
 726
 727 /*
 728  * GHES error status reporting throttle, to report more kinds of
 729  * errors, instead of just most frequently occurred errors.
 730  */
 731 static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus)
 732 {
 733         u32 len;
 734         int i, cached = 0;
 735         unsigned long long now;
 736         struct ghes_estatus_cache *cache;
 737         struct acpi_hest_generic_status *cache_estatus;
 738
 739         len = cper_estatus_len(estatus);
 740         rcu_read_lock();
 741         for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
 742                 cache = rcu_dereference(ghes_estatus_caches[i]);
 743                 if (cache == NULL)
 744                         continue;
 745                 if (len != cache->estatus_len)
 746                         continue;
 747                 cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
 748                 if (memcmp(estatus, cache_estatus, len))
 749                         continue;
 750                 atomic_inc(&cache->count);
 751                 now = sched_clock();
 752                 if (now - cache->time_in < GHES_ESTATUS_IN_CACHE_MAX_NSEC)
 753                         cached = 1;
 754                 break;
 755         }
 756         rcu_read_unlock();
 757         return cached;
 758 }
 759
 760 static struct ghes_estatus_cache *ghes_estatus_cache_alloc(
 761         struct acpi_hest_generic *generic,
 762         struct acpi_hest_generic_status *estatus)
 763 {
 764         int alloced;
 765         u32 len, cache_len;
 766         struct ghes_estatus_cache *cache;
 767         struct acpi_hest_generic_status *cache_estatus;
 768
 769         alloced = atomic_add_return(1, &ghes_estatus_cache_alloced);
 770         if (alloced > GHES_ESTATUS_CACHE_ALLOCED_MAX) {
 771                 atomic_dec(&ghes_estatus_cache_alloced);
 772                 return NULL;
 773         }
 774         len = cper_estatus_len(estatus);
 775         cache_len = GHES_ESTATUS_CACHE_LEN(len);
 776         cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len);
 777         if (!cache) {
 778                 atomic_dec(&ghes_estatus_cache_alloced);
 779                 return NULL;
 780         }
 781         cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
 782         memcpy(cache_estatus, estatus, len);
 783         cache->estatus_len = len;
 784         atomic_set(&cache->count, 0);
 785         cache->generic = generic;
 786         cache->time_in = sched_clock();
 787         return cache;
 788 }
 789
 790 static void ghes_estatus_cache_rcu_free(struct rcu_head *head)
 791 {
 792         struct ghes_estatus_cache *cache;
 793         u32 len;
 794
 795         cache = container_of(head, struct ghes_estatus_cache, rcu);
 796         len = cper_estatus_len(GHES_ESTATUS_FROM_CACHE(cache));
 797         len = GHES_ESTATUS_CACHE_LEN(len);
 798         gen_pool_free(ghes_estatus_pool, (unsigned long)cache, len);
 799         atomic_dec(&ghes_estatus_cache_alloced);
 800 }
 801
 802 static void
 803 ghes_estatus_cache_add(struct acpi_hest_generic *generic,
 804                        struct acpi_hest_generic_status *estatus)
 805 {
 806         unsigned long long now, duration, period, max_period = 0;
 807         struct ghes_estatus_cache *cache, *new_cache;
 808         struct ghes_estatus_cache __rcu *victim;
 809         int i, slot = -1, count;
 810
 811         new_cache = ghes_estatus_cache_alloc(generic, estatus);
 812         if (!new_cache)
 813                 return;
 814
 815         rcu_read_lock();
 816         now = sched_clock();
 817         for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
 818                 cache = rcu_dereference(ghes_estatus_caches[i]);
 819                 if (cache == NULL) {
 820                         slot = i;
 821                         break;
 822                 }
 823                 duration = now - cache->time_in;
 824                 if (duration >= GHES_ESTATUS_IN_CACHE_MAX_NSEC) {
 825                         slot = i;
 826                         break;
 827                 }
 828                 count = atomic_read(&cache->count);
 829                 period = duration;
 830                 do_div(period, (count + 1));
 831                 if (period > max_period) {
 832                         max_period = period;
 833                         slot = i;
 834                 }
 835         }
 836         rcu_read_unlock();
 837
 838         if (slot != -1) {
 839                 /*
 840                  * Use release semantics to ensure that ghes_estatus_cached()
 841                  * running on another CPU will see the updated cache fields if
 842                  * it can see the new value of the pointer.
 843                  */
 844                 victim = xchg_release(&ghes_estatus_caches[slot],
 845                                       RCU_INITIALIZER(new_cache));
 846
 847                 /*
 848                  * At this point, victim may point to a cached item different
 849                  * from the one based on which we selected the slot. Instead of
 850                  * going to the loop again to pick another slot, let's just
 851                  * drop the other item anyway: this may cause a false cache
 852                  * miss later on, but that won't cause any problems.
 853                  */
 854                 if (victim)
 855                         call_rcu(&unrcu_pointer(victim)->rcu,
 856                                  ghes_estatus_cache_rcu_free);
 857         }
 858 }
 859
 860 static void __ghes_panic(struct ghes *ghes,
 861                          struct acpi_hest_generic_status *estatus,
 862                          u64 buf_paddr, enum fixed_addresses fixmap_idx)
 863 {
 864         __ghes_print_estatus(KERN_EMERG, ghes->generic, estatus);
 865
 866         ghes_clear_estatus(ghes, estatus, buf_paddr, fixmap_idx);
 867
 868         /* reboot to log the error! */
 869         if (!panic_timeout)
 870                 panic_timeout = ghes_panic_timeout;
 871         panic("Fatal hardware error!");
 872 }
 873
 874 static int ghes_proc(struct ghes *ghes)
 875 {
 876         struct acpi_hest_generic_status *estatus = ghes->estatus;
 877         u64 buf_paddr;
 878         int rc;
 879
 880         rc = ghes_read_estatus(ghes, estatus, &buf_paddr, FIX_APEI_GHES_IRQ);
 881         if (rc)
 882                 goto out;
 883
 884         if (ghes_severity(estatus->error_severity) >= GHES_SEV_PANIC)
 885                 __ghes_panic(ghes, estatus, buf_paddr, FIX_APEI_GHES_IRQ);
 886
 887         if (!ghes_estatus_cached(estatus)) {
 888                 if (ghes_print_estatus(NULL, ghes->generic, estatus))
 889                         ghes_estatus_cache_add(ghes->generic, estatus);
 890         }
 891         ghes_do_proc(ghes, estatus);
 892
 893 out:
 894         ghes_clear_estatus(ghes, estatus, buf_paddr, FIX_APEI_GHES_IRQ);
 895
 896         return rc;
 897 }
 898
 899 static void ghes_add_timer(struct ghes *ghes)
 900 {
 901         struct acpi_hest_generic *g = ghes->generic;
 902         unsigned long expire;
 903
 904         if (!g->notify.poll_interval) {
 905                 pr_warn(FW_WARN GHES_PFX "Poll interval is 0 for generic hardware error source: %d, disabled.\n",
 906                         g->header.source_id);
 907                 return;
 908         }
 909         expire = jiffies + msecs_to_jiffies(g->notify.poll_interval);
 910         ghes->timer.expires = round_jiffies_relative(expire);
 911         add_timer(&ghes->timer);
 912 }
 913
 914 static void ghes_poll_func(struct timer_list *t)
 915 {
 916         struct ghes *ghes = from_timer(ghes, t, timer);
 917         unsigned long flags;
 918
 919         spin_lock_irqsave(&ghes_notify_lock_irq, flags);
 920         ghes_proc(ghes);
 921         spin_unlock_irqrestore(&ghes_notify_lock_irq, flags);
 922         if (!(ghes->flags & GHES_EXITING))
 923                 ghes_add_timer(ghes);
 924 }
 925
 926 static irqreturn_t ghes_irq_func(int irq, void *data)
 927 {
 928         struct ghes *ghes = data;
 929         unsigned long flags;
 930         int rc;
 931
 932         spin_lock_irqsave(&ghes_notify_lock_irq, flags);
 933         rc = ghes_proc(ghes);
 934         spin_unlock_irqrestore(&ghes_notify_lock_irq, flags);
 935         if (rc)
 936                 return IRQ_NONE;
 937
 938         return IRQ_HANDLED;
 939 }
 940
 941 static int ghes_notify_hed(struct notifier_block *this, unsigned long event,
 942                            void *data)
 943 {
 944         struct ghes *ghes;
 945         unsigned long flags;
 946         int ret = NOTIFY_DONE;
 947
 948         spin_lock_irqsave(&ghes_notify_lock_irq, flags);
 949         rcu_read_lock();
 950         list_for_each_entry_rcu(ghes, &ghes_hed, list) {
 951                 if (!ghes_proc(ghes))
 952                         ret = NOTIFY_OK;
 953         }
 954         rcu_read_unlock();
 955         spin_unlock_irqrestore(&ghes_notify_lock_irq, flags);
 956
 957         return ret;
 958 }
 959
 960 static struct notifier_block ghes_notifier_hed = {
 961         .notifier_call = ghes_notify_hed,
 962 };
 963
 964 /*
 965  * Handlers for CPER records may not be NMI safe. For example,
 966  * memory_failure_queue() takes spinlocks and calls schedule_work_on().
 967  * In any NMI-like handler, memory from ghes_estatus_pool is used to save
 968  * estatus, and added to the ghes_estatus_llist. irq_work_queue() causes
 969  * ghes_proc_in_irq() to run in IRQ context where each estatus in
 970  * ghes_estatus_llist is processed.
 971  *
 972  * Memory from the ghes_estatus_pool is also used with the ghes_estatus_cache
 973  * to suppress frequent messages.
 974  */
 975 static struct llist_head ghes_estatus_llist;
 976 static struct irq_work ghes_proc_irq_work;
 977
 978 static void ghes_proc_in_irq(struct irq_work *irq_work)
 979 {
 980         struct llist_node *llnode, *next;
 981         struct ghes_estatus_node *estatus_node;
 982         struct acpi_hest_generic *generic;
 983         struct acpi_hest_generic_status *estatus;
 984         bool task_work_pending;
 985         u32 len, node_len;
 986         int ret;
 987
 988         llnode = llist_del_all(&ghes_estatus_llist);
 989         /*
 990          * Because the time order of estatus in list is reversed,
 991          * revert it back to proper order.
 992          */
 993         llnode = llist_reverse_order(llnode);
 994         while (llnode) {
 995                 next = llnode->next;
 996                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
 997                                            llnode);
 998                 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
 999                 len = cper_estatus_len(estatus);
1000                 node_len = GHES_ESTATUS_NODE_LEN(len);
1001                 task_work_pending = ghes_do_proc(estatus_node->ghes, estatus);
1002                 if (!ghes_estatus_cached(estatus)) {
1003                         generic = estatus_node->generic;
1004                         if (ghes_print_estatus(NULL, generic, estatus))
1005                                 ghes_estatus_cache_add(generic, estatus);
1006                 }
1007
1008                 if (task_work_pending && current->mm) {
1009                         estatus_node->task_work.func = ghes_kick_task_work;
1010                         estatus_node->task_work_cpu = smp_processor_id();
1011                         ret = task_work_add(current, &estatus_node->task_work,
1012                                             TWA_RESUME);
1013                         if (ret)
1014                                 estatus_node->task_work.func = NULL;
1015                 }
1016
1017                 if (!estatus_node->task_work.func)
1018                         gen_pool_free(ghes_estatus_pool,
1019                                       (unsigned long)estatus_node, node_len);
1020
1021                 llnode = next;
1022         }
1023 }
1024
1025 static void ghes_print_queued_estatus(void)
1026 {
1027         struct llist_node *llnode;
1028         struct ghes_estatus_node *estatus_node;
1029         struct acpi_hest_generic *generic;
1030         struct acpi_hest_generic_status *estatus;
1031
1032         llnode = llist_del_all(&ghes_estatus_llist);
1033         /*
1034          * Because the time order of estatus in list is reversed,
1035          * revert it back to proper order.
1036          */
1037         llnode = llist_reverse_order(llnode);
1038         while (llnode) {
1039                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
1040                                            llnode);
1041                 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
1042                 generic = estatus_node->generic;
1043                 ghes_print_estatus(NULL, generic, estatus);
1044                 llnode = llnode->next;
1045         }
1046 }
1047
1048 static int ghes_in_nmi_queue_one_entry(struct ghes *ghes,
1049                                        enum fixed_addresses fixmap_idx)
1050 {
1051         struct acpi_hest_generic_status *estatus, tmp_header;
1052         struct ghes_estatus_node *estatus_node;
1053         u32 len, node_len;
1054         u64 buf_paddr;
1055         int sev, rc;
1056
1057         if (!IS_ENABLED(CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG))
1058                 return -EOPNOTSUPP;
1059
1060         rc = __ghes_peek_estatus(ghes, &tmp_header, &buf_paddr, fixmap_idx);
1061         if (rc) {
1062                 ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx);
1063                 return rc;
1064         }
1065
1066         rc = __ghes_check_estatus(ghes, &tmp_header);
1067         if (rc) {
1068                 ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx);
1069                 return rc;
1070         }
1071
1072         len = cper_estatus_len(&tmp_header);
1073         node_len = GHES_ESTATUS_NODE_LEN(len);
1074         estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool, node_len);
1075         if (!estatus_node)
1076                 return -ENOMEM;
1077
1078         estatus_node->ghes = ghes;
1079         estatus_node->generic = ghes->generic;
1080         estatus_node->task_work.func = NULL;
1081         estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
1082
1083         if (__ghes_read_estatus(estatus, buf_paddr, fixmap_idx, len)) {
1084                 ghes_clear_estatus(ghes, estatus, buf_paddr, fixmap_idx);
1085                 rc = -ENOENT;
1086                 goto no_work;
1087         }
1088
1089         sev = ghes_severity(estatus->error_severity);
1090         if (sev >= GHES_SEV_PANIC) {
1091                 ghes_print_queued_estatus();
1092                 __ghes_panic(ghes, estatus, buf_paddr, fixmap_idx);
1093         }
1094
1095         ghes_clear_estatus(ghes, &tmp_header, buf_paddr, fixmap_idx);
1096
1097         /* This error has been reported before, don't process it again. */
1098         if (ghes_estatus_cached(estatus))
1099                 goto no_work;
1100
1101         llist_add(&estatus_node->llnode, &ghes_estatus_llist);
1102
1103         return rc;
1104
1105 no_work:
1106         gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node,
1107                       node_len);
1108
1109         return rc;
1110 }
1111
1112 static int ghes_in_nmi_spool_from_list(struct list_head *rcu_list,
1113                                        enum fixed_addresses fixmap_idx)
1114 {
1115         int ret = -ENOENT;
1116         struct ghes *ghes;
1117
1118         rcu_read_lock();
1119         list_for_each_entry_rcu(ghes, rcu_list, list) {
1120                 if (!ghes_in_nmi_queue_one_entry(ghes, fixmap_idx))
1121                         ret = 0;
1122         }
1123         rcu_read_unlock();
1124
1125         if (IS_ENABLED(CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG) && !ret)
1126                 irq_work_queue(&ghes_proc_irq_work);
1127
1128         return ret;
1129 }
1130
1131 #ifdef CONFIG_ACPI_APEI_SEA
1132 static LIST_HEAD(ghes_sea);
1133
1134 /*
1135  * Return 0 only if one of the SEA error sources successfully reported an error
1136  * record sent from the firmware.
1137  */
1138 int ghes_notify_sea(void)
1139 {
1140         static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sea);
1141         int rv;
1142
1143         raw_spin_lock(&ghes_notify_lock_sea);
1144         rv = ghes_in_nmi_spool_from_list(&ghes_sea, FIX_APEI_GHES_SEA);
1145         raw_spin_unlock(&ghes_notify_lock_sea);
1146
1147         return rv;
1148 }
1149
1150 static void ghes_sea_add(struct ghes *ghes)
1151 {
1152         mutex_lock(&ghes_list_mutex);
1153         list_add_rcu(&ghes->list, &ghes_sea);
1154         mutex_unlock(&ghes_list_mutex);
1155 }
1156
1157 static void ghes_sea_remove(struct ghes *ghes)
1158 {
1159         mutex_lock(&ghes_list_mutex);
1160         list_del_rcu(&ghes->list);
1161         mutex_unlock(&ghes_list_mutex);
1162         synchronize_rcu();
1163 }
1164 #else /* CONFIG_ACPI_APEI_SEA */
1165 static inline void ghes_sea_add(struct ghes *ghes) { }
1166 static inline void ghes_sea_remove(struct ghes *ghes) { }
1167 #endif /* CONFIG_ACPI_APEI_SEA */
1168
1169 #ifdef CONFIG_HAVE_ACPI_APEI_NMI
1170 /*
1171  * NMI may be triggered on any CPU, so ghes_in_nmi is used for
1172  * having only one concurrent reader.
1173  */
1174 static atomic_t ghes_in_nmi = ATOMIC_INIT(0);
1175
1176 static LIST_HEAD(ghes_nmi);
1177
1178 static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
1179 {
1180         static DEFINE_RAW_SPINLOCK(ghes_notify_lock_nmi);
1181         int ret = NMI_DONE;
1182
1183         if (!atomic_add_unless(&ghes_in_nmi, 1, 1))
1184                 return ret;
1185
1186         raw_spin_lock(&ghes_notify_lock_nmi);
1187         if (!ghes_in_nmi_spool_from_list(&ghes_nmi, FIX_APEI_GHES_NMI))
1188                 ret = NMI_HANDLED;
1189         raw_spin_unlock(&ghes_notify_lock_nmi);
1190
1191         atomic_dec(&ghes_in_nmi);
1192         return ret;
1193 }
1194
1195 static void ghes_nmi_add(struct ghes *ghes)
1196 {
1197         mutex_lock(&ghes_list_mutex);
1198         if (list_empty(&ghes_nmi))
1199                 register_nmi_handler(NMI_LOCAL, ghes_notify_nmi, 0, "ghes");
1200         list_add_rcu(&ghes->list, &ghes_nmi);
1201         mutex_unlock(&ghes_list_mutex);
1202 }
1203
1204 static void ghes_nmi_remove(struct ghes *ghes)
1205 {
1206         mutex_lock(&ghes_list_mutex);
1207         list_del_rcu(&ghes->list);
1208         if (list_empty(&ghes_nmi))
1209                 unregister_nmi_handler(NMI_LOCAL, "ghes");
1210         mutex_unlock(&ghes_list_mutex);
1211         /*
1212          * To synchronize with NMI handler, ghes can only be
1213          * freed after NMI handler finishes.
1214          */
1215         synchronize_rcu();
1216 }
1217 #else /* CONFIG_HAVE_ACPI_APEI_NMI */
1218 static inline void ghes_nmi_add(struct ghes *ghes) { }
1219 static inline void ghes_nmi_remove(struct ghes *ghes) { }
1220 #endif /* CONFIG_HAVE_ACPI_APEI_NMI */
1221
1222 static void ghes_nmi_init_cxt(void)
1223 {
1224         init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq);
1225 }
1226
1227 static int __ghes_sdei_callback(struct ghes *ghes,
1228                                 enum fixed_addresses fixmap_idx)
1229 {
1230         if (!ghes_in_nmi_queue_one_entry(ghes, fixmap_idx)) {
1231                 irq_work_queue(&ghes_proc_irq_work);
1232
1233                 return 0;
1234         }
1235
1236         return -ENOENT;
1237 }
1238
1239 static int ghes_sdei_normal_callback(u32 event_num, struct pt_regs *regs,
1240                                       void *arg)
1241 {
1242         static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sdei_normal);
1243         struct ghes *ghes = arg;
1244         int err;
1245
1246         raw_spin_lock(&ghes_notify_lock_sdei_normal);
1247         err = __ghes_sdei_callback(ghes, FIX_APEI_GHES_SDEI_NORMAL);
1248         raw_spin_unlock(&ghes_notify_lock_sdei_normal);
1249
1250         return err;
1251 }
1252
1253 static int ghes_sdei_critical_callback(u32 event_num, struct pt_regs *regs,
1254                                        void *arg)
1255 {
1256         static DEFINE_RAW_SPINLOCK(ghes_notify_lock_sdei_critical);
1257         struct ghes *ghes = arg;
1258         int err;
1259
1260         raw_spin_lock(&ghes_notify_lock_sdei_critical);
1261         err = __ghes_sdei_callback(ghes, FIX_APEI_GHES_SDEI_CRITICAL);
1262         raw_spin_unlock(&ghes_notify_lock_sdei_critical);
1263
1264         return err;
1265 }
1266
1267 static int apei_sdei_register_ghes(struct ghes *ghes)
1268 {
1269         if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE))
1270                 return -EOPNOTSUPP;
1271
1272         return sdei_register_ghes(ghes, ghes_sdei_normal_callback,
1273                                  ghes_sdei_critical_callback);
1274 }
1275
1276 static int apei_sdei_unregister_ghes(struct ghes *ghes)
1277 {
1278         if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE))
1279                 return -EOPNOTSUPP;
1280
1281         return sdei_unregister_ghes(ghes);
1282 }
1283
1284 static int ghes_probe(struct platform_device *ghes_dev)
1285 {
1286         struct acpi_hest_generic *generic;
1287         struct ghes *ghes = NULL;
1288         unsigned long flags;
1289
1290         int rc = -EINVAL;
1291
1292         generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data;
1293         if (!generic->enabled)
1294                 return -ENODEV;
1295
1296         switch (generic->notify.type) {
1297         case ACPI_HEST_NOTIFY_POLLED:
1298         case ACPI_HEST_NOTIFY_EXTERNAL:
1299         case ACPI_HEST_NOTIFY_SCI:
1300         case ACPI_HEST_NOTIFY_GSIV:
1301         case ACPI_HEST_NOTIFY_GPIO:
1302                 break;
1303
1304         case ACPI_HEST_NOTIFY_SEA:
1305                 if (!IS_ENABLED(CONFIG_ACPI_APEI_SEA)) {
1306                         pr_warn(GHES_PFX "Generic hardware error source: %d notified via SEA is not supported\n",
1307                                 generic->header.source_id);
1308                         rc = -ENOTSUPP;
1309                         goto err;
1310                 }
1311                 break;
1312         case ACPI_HEST_NOTIFY_NMI:
1313                 if (!IS_ENABLED(CONFIG_HAVE_ACPI_APEI_NMI)) {
1314                         pr_warn(GHES_PFX "Generic hardware error source: %d notified via NMI interrupt is not supported!\n",
1315                                 generic->header.source_id);
1316                         goto err;
1317                 }
1318                 break;
1319         case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED:
1320                 if (!IS_ENABLED(CONFIG_ARM_SDE_INTERFACE)) {
1321                         pr_warn(GHES_PFX "Generic hardware error source: %d notified via SDE Interface is not supported!\n",
1322                                 generic->header.source_id);
1323                         goto err;
1324                 }
1325                 break;
1326         case ACPI_HEST_NOTIFY_LOCAL:
1327                 pr_warn(GHES_PFX "Generic hardware error source: %d notified via local interrupt is not supported!\n",
1328                         generic->header.source_id);
1329                 goto err;
1330         default:
1331                 pr_warn(FW_WARN GHES_PFX "Unknown notification type: %u for generic hardware error source: %d\n",
1332                         generic->notify.type, generic->header.source_id);
1333                 goto err;
1334         }
1335
1336         rc = -EIO;
1337         if (generic->error_block_length <
1338             sizeof(struct acpi_hest_generic_status)) {
1339                 pr_warn(FW_BUG GHES_PFX "Invalid error block length: %u for generic hardware error source: %d\n",
1340                         generic->error_block_length, generic->header.source_id);
1341                 goto err;
1342         }
1343         ghes = ghes_new(generic);
1344         if (IS_ERR(ghes)) {
1345                 rc = PTR_ERR(ghes);
1346                 ghes = NULL;
1347                 goto err;
1348         }
1349
1350         switch (generic->notify.type) {
1351         case ACPI_HEST_NOTIFY_POLLED:
1352                 timer_setup(&ghes->timer, ghes_poll_func, 0);
1353                 ghes_add_timer(ghes);
1354                 break;
1355         case ACPI_HEST_NOTIFY_EXTERNAL:
1356                 /* External interrupt vector is GSI */
1357                 rc = acpi_gsi_to_irq(generic->notify.vector, &ghes->irq);
1358                 if (rc) {
1359                         pr_err(GHES_PFX "Failed to map GSI to IRQ for generic hardware error source: %d\n",
1360                                generic->header.source_id);
1361                         goto err;
1362                 }
1363                 rc = request_irq(ghes->irq, ghes_irq_func, IRQF_SHARED,
1364                                  "GHES IRQ", ghes);
1365                 if (rc) {
1366                         pr_err(GHES_PFX "Failed to register IRQ for generic hardware error source: %d\n",
1367                                generic->header.source_id);
1368                         goto err;
1369                 }
1370                 break;
1371
1372         case ACPI_HEST_NOTIFY_SCI:
1373         case ACPI_HEST_NOTIFY_GSIV:
1374         case ACPI_HEST_NOTIFY_GPIO:
1375                 mutex_lock(&ghes_list_mutex);
1376                 if (list_empty(&ghes_hed))
1377                         register_acpi_hed_notifier(&ghes_notifier_hed);
1378                 list_add_rcu(&ghes->list, &ghes_hed);
1379                 mutex_unlock(&ghes_list_mutex);
1380                 break;
1381
1382         case ACPI_HEST_NOTIFY_SEA:
1383                 ghes_sea_add(ghes);
1384                 break;
1385         case ACPI_HEST_NOTIFY_NMI:
1386                 ghes_nmi_add(ghes);
1387                 break;
1388         case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED:
1389                 rc = apei_sdei_register_ghes(ghes);
1390                 if (rc)
1391                         goto err;
1392                 break;
1393         default:
1394                 BUG();
1395         }
1396
1397         platform_set_drvdata(ghes_dev, ghes);
1398
1399         ghes->dev = &ghes_dev->dev;
1400
1401         mutex_lock(&ghes_devs_mutex);
1402         list_add_tail(&ghes->elist, &ghes_devs);
1403         mutex_unlock(&ghes_devs_mutex);
1404
1405         /* Handle any pending errors right away */
1406         spin_lock_irqsave(&ghes_notify_lock_irq, flags);
1407         ghes_proc(ghes);
1408         spin_unlock_irqrestore(&ghes_notify_lock_irq, flags);
1409
1410         return 0;
1411
1412 err:
1413         if (ghes) {
1414                 ghes_fini(ghes);
1415                 kfree(ghes);
1416         }
1417         return rc;
1418 }
1419
1420 static int ghes_remove(struct platform_device *ghes_dev)
1421 {
1422         int rc;
1423         struct ghes *ghes;
1424         struct acpi_hest_generic *generic;
1425
1426         ghes = platform_get_drvdata(ghes_dev);
1427         generic = ghes->generic;
1428
1429         ghes->flags |= GHES_EXITING;
1430         switch (generic->notify.type) {
1431         case ACPI_HEST_NOTIFY_POLLED:
1432                 timer_shutdown_sync(&ghes->timer);
1433                 break;
1434         case ACPI_HEST_NOTIFY_EXTERNAL:
1435                 free_irq(ghes->irq, ghes);
1436                 break;
1437
1438         case ACPI_HEST_NOTIFY_SCI:
1439         case ACPI_HEST_NOTIFY_GSIV:
1440         case ACPI_HEST_NOTIFY_GPIO:
1441                 mutex_lock(&ghes_list_mutex);
1442                 list_del_rcu(&ghes->list);
1443                 if (list_empty(&ghes_hed))
1444                         unregister_acpi_hed_notifier(&ghes_notifier_hed);
1445                 mutex_unlock(&ghes_list_mutex);
1446                 synchronize_rcu();
1447                 break;
1448
1449         case ACPI_HEST_NOTIFY_SEA:
1450                 ghes_sea_remove(ghes);
1451                 break;
1452         case ACPI_HEST_NOTIFY_NMI:
1453                 ghes_nmi_remove(ghes);
1454                 break;
1455         case ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED:
1456                 rc = apei_sdei_unregister_ghes(ghes);
1457                 if (rc)
1458                         return rc;
1459                 break;
1460         default:
1461                 BUG();
1462                 break;
1463         }
1464
1465         ghes_fini(ghes);
1466
1467         mutex_lock(&ghes_devs_mutex);
1468         list_del(&ghes->elist);
1469         mutex_unlock(&ghes_devs_mutex);
1470
1471         kfree(ghes);
1472
1473         return 0;
1474 }
1475
1476 static struct platform_driver ghes_platform_driver = {
1477         .driver         = {
1478                 .name   = "GHES",
1479         },
1480         .probe          = ghes_probe,
1481         .remove         = ghes_remove,
1482 };
1483
1484 void __init acpi_ghes_init(void)
1485 {
1486         int rc;
1487
1488         sdei_init();
1489
1490         if (acpi_disabled)
1491                 return;
1492
1493         switch (hest_disable) {
1494         case HEST_NOT_FOUND:
1495                 return;
1496         case HEST_DISABLED:
1497                 pr_info(GHES_PFX "HEST is not enabled!\n");
1498                 return;
1499         default:
1500                 break;
1501         }
1502
1503         if (ghes_disable) {
1504                 pr_info(GHES_PFX "GHES is not enabled!\n");
1505                 return;
1506         }
1507
1508         ghes_nmi_init_cxt();
1509
1510         rc = platform_driver_register(&ghes_platform_driver);
1511         if (rc)
1512                 return;
1513
1514         rc = apei_osc_setup();
1515         if (rc == 0 && osc_sb_apei_support_acked)
1516                 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit and WHEA _OSC.\n");
1517         else if (rc == 0 && !osc_sb_apei_support_acked)
1518                 pr_info(GHES_PFX "APEI firmware first mode is enabled by WHEA _OSC.\n");
1519         else if (rc && osc_sb_apei_support_acked)
1520                 pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit.\n");
1521         else
1522                 pr_info(GHES_PFX "Failed to enable APEI firmware first mode.\n");
1523 }
1524
1525 /*
1526  * Known x86 systems that prefer GHES error reporting:
1527  */
1528 static struct acpi_platform_list plat_list[] = {
1529         {"HPE   ", "Server  ", 0, ACPI_SIG_FADT, all_versions},
1530         { } /* End */
1531 };
1532
1533 struct list_head *ghes_get_devices(void)
1534 {
1535         int idx = -1;
1536
1537         if (IS_ENABLED(CONFIG_X86)) {
1538                 idx = acpi_match_platform_list(plat_list);
1539                 if (idx < 0) {
1540                         if (!ghes_edac_force_enable)
1541                                 return NULL;
1542
1543                         pr_warn_once("Force-loading ghes_edac on an unsupported platform. You're on your own!\n");
1544                 }
1545         } else if (list_empty(&ghes_devs)) {
1546                 return NULL;
1547         }
1548
1549         return &ghes_devs;
1550 }
1551 EXPORT_SYMBOL_GPL(ghes_get_devices);
1552
1553 void ghes_register_report_chain(struct notifier_block *nb)
1554 {
1555         atomic_notifier_chain_register(&ghes_report_chain, nb);
1556 }
1557 EXPORT_SYMBOL_GPL(ghes_register_report_chain);
1558
1559 void ghes_unregister_report_chain(struct notifier_block *nb)
1560 {
1561         atomic_notifier_chain_unregister(&ghes_report_chain, nb);
1562 }
1563 EXPORT_SYMBOL_GPL(ghes_unregister_report_chain);