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 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  */
 109 static 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  */
 121 bool ghes_disable;
 122 module_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  */
 132 static LIST_HEAD(ghes_hed);
 133 static 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  */
 144 static DEFINE_SPINLOCK(ghes_notify_lock_irq);
 145
 146 struct ghes_vendor_record_entry {
 147         struct work_struct work;
 148         int error_severity;
 149         char vendor_record[];
 150 };
 151
 152 static struct gen_pool *ghes_estatus_pool;
 153 static unsigned long ghes_estatus_pool_size_request;
 154
 155 static struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
 156 static atomic_t ghes_estatus_cache_alloced;
 157
 158 static int ghes_panic_timeout __read_mostly = 30;
 159
 160 static 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
 172 static 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
 180 int 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
 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)) {
 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, 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
 500 static 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  */
 560 static 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
 591 static BLOCKING_NOTIFIER_HEAD(vendor_record_notify_list);
 592
 593 int ghes_register_vendor_record_notifier(struct notifier_block *nb)
 594 {
 595         return blocking_notifier_chain_register(&vendor_record_notify_list, nb);
 596 }
 597 EXPORT_SYMBOL_GPL(ghes_register_vendor_record_notifier);
 598
 599 void ghes_unregister_vendor_record_notifier(struct notifier_block *nb)
 600 {
 601         blocking_notifier_chain_unregister(&vendor_record_notify_list, nb);
 602 }
 603 EXPORT_SYMBOL_GPL(ghes_unregister_vendor_record_notifier);
 604
 605 static 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
 621 static 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
 641 static 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
 688 static 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
 710 static 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  */
 734 static 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
 763 static 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
 793 static 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
 803 static 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
 811 static 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
 857 static 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
 871 static 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
 890 out:
 891         ghes_clear_estatus(ghes, estatus, buf_paddr, FIX_APEI_GHES_IRQ);
 892
 893         return rc;
 894 }
 895
 896 static 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
 911 static 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
 923 static 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
 938 static 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
 957 static 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  */
 972 static struct llist_head ghes_estatus_llist;
 973 static struct irq_work ghes_proc_irq_work;
 974
 975 static 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
1022 static 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
1045 static 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
1102 no_work:
1103         gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node,
1104                       node_len);
1105
1106         return rc;
1107 }
1108
1109 static 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
1129 static 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  */
1135 int 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
1147 static 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
1154 static 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 */
1162 static inline void ghes_sea_add(struct ghes *ghes) { }
1163 static 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  */
1171 static atomic_t ghes_in_nmi = ATOMIC_INIT(0);
1172
1173 static LIST_HEAD(ghes_nmi);
1174
1175 static 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
1192 static 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
1201 static 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 */
1215 static inline void ghes_nmi_add(struct ghes *ghes) { }
1216 static inline void ghes_nmi_remove(struct ghes *ghes) { }
1217 #endif /* CONFIG_HAVE_ACPI_APEI_NMI */
1218
1219 static void ghes_nmi_init_cxt(void)
1220 {
1221         init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq);
1222 }
1223
1224 static 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
1236 static 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
1250 static 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
1264 static 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
1273 static 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
1281 static 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
1405 err:
1406         if (ghes) {
1407                 ghes_fini(ghes);
1408                 kfree(ghes);
1409         }
1410         return rc;
1411 }
1412
1413 static 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
1469 static struct platform_driver ghes_platform_driver = {
1470         .driver         = {
1471                 .name   = "GHES",
1472         },
1473         .probe          = ghes_probe,
1474         .remove         = ghes_remove,
1475 };
1476
1477 void __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 }