drivers/ras/amd/fmpm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * FRU (Field-Replaceable Unit) Memory Poison Manager
   4  *
   5  * Copyright (c) 2024, Advanced Micro Devices, Inc.
   6  * All Rights Reserved.
   7  *
   8  * Authors:
   9  *      Naveen Krishna Chatradhi <[email protected]>
  10  *      Muralidhara M K <[email protected]>
  11  *      Yazen Ghannam <[email protected]>
  12  *
  13  * Implementation notes, assumptions, and limitations:
  14  *
  15  * - FRU memory poison section and memory poison descriptor definitions are not yet
  16  *   included in the UEFI specification. So they are defined here. Afterwards, they
  17  *   may be moved to linux/cper.h, if appropriate.
  18  *
  19  * - Platforms based on AMD MI300 systems will be the first to use these structures.
  20  *   There are a number of assumptions made here that will need to be generalized
  21  *   to support other platforms.
  22  *
  23  *   AMD MI300-based platform(s) assumptions:
  24  *   - Memory errors are reported through x86 MCA.
  25  *   - The entire DRAM row containing a memory error should be retired.
  26  *   - There will be (1) FRU memory poison section per CPER.
  27  *   - The FRU will be the CPU package (processor socket).
  28  *   - The default number of memory poison descriptor entries should be (8).
  29  *   - The platform will use ACPI ERST for persistent storage.
  30  *   - All FRU records should be saved to persistent storage. Module init will
  31  *     fail if any FRU record is not successfully written.
  32  *
  33  * - Boot time memory retirement may occur later than ideal due to dependencies
  34  *   on other libraries and drivers. This leaves a gap where bad memory may be
  35  *   accessed during early boot stages.
  36  *
  37  * - Enough memory should be pre-allocated for each FRU record to be able to hold
  38  *   the expected number of descriptor entries. This, mostly empty, record is
  39  *   written to storage during init time. Subsequent writes to the same record
  40  *   should allow the Platform to update the stored record in-place. Otherwise,
  41  *   if the record is extended, then the Platform may need to perform costly memory
  42  *   management operations on the storage. For example, the Platform may spend time
  43  *   in Firmware copying and invalidating memory on a relatively slow SPI ROM.
  44  */
  45
  46 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  47
  48 #include <linux/cper.h>
  49 #include <linux/ras.h>
  50 #include <linux/cpu.h>
  51
  52 #include <acpi/apei.h>
  53
  54 #include <asm/cpu_device_id.h>
  55 #include <asm/mce.h>
  56
  57 #include "../debugfs.h"
  58
  59 #include "atl/internal.h"
  60
  61 #define INVALID_CPU                     UINT_MAX
  62
  63 /* Validation Bits */
  64 #define FMP_VALID_ARCH_TYPE             BIT_ULL(0)
  65 #define FMP_VALID_ARCH                  BIT_ULL(1)
  66 #define FMP_VALID_ID_TYPE               BIT_ULL(2)
  67 #define FMP_VALID_ID                    BIT_ULL(3)
  68 #define FMP_VALID_LIST_ENTRIES          BIT_ULL(4)
  69 #define FMP_VALID_LIST                  BIT_ULL(5)
  70
  71 /* FRU Architecture Types */
  72 #define FMP_ARCH_TYPE_X86_CPUID_1_EAX   0
  73
  74 /* FRU ID Types */
  75 #define FMP_ID_TYPE_X86_PPIN            0
  76
  77 /* FRU Memory Poison Section */
  78 struct cper_sec_fru_mem_poison {
  79         u32 checksum;
  80         u64 validation_bits;
  81         u32 fru_arch_type;
  82         u64 fru_arch;
  83         u32 fru_id_type;
  84         u64 fru_id;
  85         u32 nr_entries;
  86 } __packed;
  87
  88 /* FRU Descriptor ID Types */
  89 #define FPD_HW_ID_TYPE_MCA_IPID         0
  90
  91 /* FRU Descriptor Address Types */
  92 #define FPD_ADDR_TYPE_MCA_ADDR          0
  93
  94 /* Memory Poison Descriptor */
  95 struct cper_fru_poison_desc {
  96         u64 timestamp;
  97         u32 hw_id_type;
  98         u64 hw_id;
  99         u32 addr_type;
 100         u64 addr;
 101 } __packed;
 102
 103 /* Collection of headers and sections for easy pointer use. */
 104 struct fru_rec {
 105         struct cper_record_header       hdr;
 106         struct cper_section_descriptor  sec_desc;
 107         struct cper_sec_fru_mem_poison  fmp;
 108         struct cper_fru_poison_desc     entries[];
 109 } __packed;
 110
 111 /*
 112  * Pointers to the complete CPER record of each FRU.
 113  *
 114  * Memory allocation will include padded space for descriptor entries.
 115  */
 116 static struct fru_rec **fru_records;
 117
 118 /* system physical addresses array */
 119 static u64 *spa_entries;
 120
 121 static struct dentry *fmpm_dfs_dir;
 122 static struct dentry *fmpm_dfs_entries;
 123
 124 #define CPER_CREATOR_FMP                                                \
 125         GUID_INIT(0xcd5c2993, 0xf4b2, 0x41b2, 0xb5, 0xd4, 0xf9, 0xc3,   \
 126                   0xa0, 0x33, 0x08, 0x75)
 127
 128 #define CPER_SECTION_TYPE_FMP                                           \
 129         GUID_INIT(0x5e4706c1, 0x5356, 0x48c6, 0x93, 0x0b, 0x52, 0xf2,   \
 130                   0x12, 0x0a, 0x44, 0x58)
 131
 132 /**
 133  * DOC: max_nr_entries (byte)
 134  * Maximum number of descriptor entries possible for each FRU.
 135  *
 136  * Values between '1' and '255' are valid.
 137  * No input or '0' will default to FMPM_DEFAULT_MAX_NR_ENTRIES.
 138  */
 139 static u8 max_nr_entries;
 140 module_param(max_nr_entries, byte, 0644);
 141 MODULE_PARM_DESC(max_nr_entries,
 142                  "Maximum number of memory poison descriptor entries per FRU");
 143
 144 #define FMPM_DEFAULT_MAX_NR_ENTRIES     8
 145
 146 /* Maximum number of FRUs in the system. */
 147 #define FMPM_MAX_NR_FRU                 256
 148 static unsigned int max_nr_fru;
 149
 150 /* Total length of record including headers and list of descriptor entries. */
 151 static size_t max_rec_len;
 152
 153 #define FMPM_MAX_REC_LEN (sizeof(struct fru_rec) + (sizeof(struct cper_fru_poison_desc) * 255))
 154
 155 /* Total number of SPA entries across all FRUs. */
 156 static unsigned int spa_nr_entries;
 157
 158 /*
 159  * Protect the local records cache in fru_records and prevent concurrent
 160  * writes to storage. This is only needed after init once notifier block
 161  * registration is done.
 162  *
 163  * The majority of a record is fixed at module init and will not change
 164  * during run time. The entries within a record will be updated as new
 165  * errors are reported. The mutex should be held whenever the entries are
 166  * accessed during run time.
 167  */
 168 static DEFINE_MUTEX(fmpm_update_mutex);
 169
 170 #define for_each_fru(i, rec) \
 171         for (i = 0; rec = fru_records[i], i < max_nr_fru; i++)
 172
 173 static inline u32 get_fmp_len(struct fru_rec *rec)
 174 {
 175         return rec->sec_desc.section_length - sizeof(struct cper_section_descriptor);
 176 }
 177
 178 static struct fru_rec *get_fru_record(u64 fru_id)
 179 {
 180         struct fru_rec *rec;
 181         unsigned int i;
 182
 183         for_each_fru(i, rec) {
 184                 if (rec->fmp.fru_id == fru_id)
 185                         return rec;
 186         }
 187
 188         pr_debug("Record not found for FRU 0x%016llx\n", fru_id);
 189
 190         return NULL;
 191 }
 192
 193 /*
 194  * Sum up all bytes within the FRU Memory Poison Section including the Memory
 195  * Poison Descriptor entries.
 196  *
 197  * Don't include the old checksum here. It's a u32 value, so summing each of its
 198  * bytes will give the wrong total.
 199  */
 200 static u32 do_fmp_checksum(struct cper_sec_fru_mem_poison *fmp, u32 len)
 201 {
 202         u32 checksum = 0;
 203         u8 *buf, *end;
 204
 205         /* Skip old checksum. */
 206         buf = (u8 *)fmp + sizeof(u32);
 207         end = buf + len;
 208
 209         while (buf < end)
 210                 checksum += (u8)(*(buf++));
 211
 212         return checksum;
 213 }
 214
 215 static int update_record_on_storage(struct fru_rec *rec)
 216 {
 217         u32 len, checksum;
 218         int ret;
 219
 220         /* Calculate a new checksum. */
 221         len = get_fmp_len(rec);
 222
 223         /* Get the current total. */
 224         checksum = do_fmp_checksum(&rec->fmp, len);
 225
 226         /* Use the complement value. */
 227         rec->fmp.checksum = -checksum;
 228
 229         pr_debug("Writing to storage\n");
 230
 231         ret = erst_write(&rec->hdr);
 232         if (ret) {
 233                 pr_warn("Storage update failed for FRU 0x%016llx\n", rec->fmp.fru_id);
 234
 235                 if (ret == -ENOSPC)
 236                         pr_warn("Not enough space on storage\n");
 237         }
 238
 239         return ret;
 240 }
 241
 242 static bool rec_has_valid_entries(struct fru_rec *rec)
 243 {
 244         if (!(rec->fmp.validation_bits & FMP_VALID_LIST_ENTRIES))
 245                 return false;
 246
 247         if (!(rec->fmp.validation_bits & FMP_VALID_LIST))
 248                 return false;
 249
 250         return true;
 251 }
 252
 253 static bool fpds_equal(struct cper_fru_poison_desc *old, struct cper_fru_poison_desc *new)
 254 {
 255         /*
 256          * Ignore timestamp field.
 257          * The same physical error may be reported multiple times due to stuck bits, etc.
 258          *
 259          * Also, order the checks from most->least likely to fail to shortcut the code.
 260          */
 261         if (old->addr != new->addr)
 262                 return false;
 263
 264         if (old->hw_id != new->hw_id)
 265                 return false;
 266
 267         if (old->addr_type != new->addr_type)
 268                 return false;
 269
 270         if (old->hw_id_type != new->hw_id_type)
 271                 return false;
 272
 273         return true;
 274 }
 275
 276 static bool rec_has_fpd(struct fru_rec *rec, struct cper_fru_poison_desc *fpd)
 277 {
 278         unsigned int i;
 279
 280         for (i = 0; i < rec->fmp.nr_entries; i++) {
 281                 struct cper_fru_poison_desc *fpd_i = &rec->entries[i];
 282
 283                 if (fpds_equal(fpd_i, fpd)) {
 284                         pr_debug("Found duplicate record\n");
 285                         return true;
 286                 }
 287         }
 288
 289         return false;
 290 }
 291
 292 static void save_spa(struct fru_rec *rec, unsigned int entry,
 293                      u64 addr, u64 id, unsigned int cpu)
 294 {
 295         unsigned int i, fru_idx, spa_entry;
 296         struct atl_err a_err;
 297         unsigned long spa;
 298
 299         if (entry >= max_nr_entries) {
 300                 pr_warn_once("FRU descriptor entry %d out-of-bounds (max: %d)\n",
 301                              entry, max_nr_entries);
 302                 return;
 303         }
 304
 305         /* spa_nr_entries is always multiple of max_nr_entries */
 306         for (i = 0; i < spa_nr_entries; i += max_nr_entries) {
 307                 fru_idx = i / max_nr_entries;
 308                 if (fru_records[fru_idx] == rec)
 309                         break;
 310         }
 311
 312         if (i >= spa_nr_entries) {
 313                 pr_warn_once("FRU record %d not found\n", i);
 314                 return;
 315         }
 316
 317         spa_entry = i + entry;
 318         if (spa_entry >= spa_nr_entries) {
 319                 pr_warn_once("spa_entries[] index out-of-bounds\n");
 320                 return;
 321         }
 322
 323         memset(&a_err, 0, sizeof(struct atl_err));
 324
 325         a_err.addr = addr;
 326         a_err.ipid = id;
 327         a_err.cpu  = cpu;
 328
 329         spa = amd_convert_umc_mca_addr_to_sys_addr(&a_err);
 330         if (IS_ERR_VALUE(spa)) {
 331                 pr_debug("Failed to get system address\n");
 332                 return;
 333         }
 334
 335         spa_entries[spa_entry] = spa;
 336         pr_debug("fru_idx: %u, entry: %u, spa_entry: %u, spa: 0x%016llx\n",
 337                  fru_idx, entry, spa_entry, spa_entries[spa_entry]);
 338 }
 339
 340 static void update_fru_record(struct fru_rec *rec, struct mce *m)
 341 {
 342         struct cper_sec_fru_mem_poison *fmp = &rec->fmp;
 343         struct cper_fru_poison_desc fpd, *fpd_dest;
 344         u32 entry = 0;
 345
 346         mutex_lock(&fmpm_update_mutex);
 347
 348         memset(&fpd, 0, sizeof(struct cper_fru_poison_desc));
 349
 350         fpd.timestamp   = m->time;
 351         fpd.hw_id_type = FPD_HW_ID_TYPE_MCA_IPID;
 352         fpd.hw_id       = m->ipid;
 353         fpd.addr_type   = FPD_ADDR_TYPE_MCA_ADDR;
 354         fpd.addr        = m->addr;
 355
 356         /* This is the first entry, so just save it. */
 357         if (!rec_has_valid_entries(rec))
 358                 goto save_fpd;
 359
 360         /* Ignore already recorded errors. */
 361         if (rec_has_fpd(rec, &fpd))
 362                 goto out_unlock;
 363
 364         if (rec->fmp.nr_entries >= max_nr_entries) {
 365                 pr_warn("Exceeded number of entries for FRU 0x%016llx\n", rec->fmp.fru_id);
 366                 goto out_unlock;
 367         }
 368
 369         entry  = fmp->nr_entries;
 370
 371 save_fpd:
 372         save_spa(rec, entry, m->addr, m->ipid, m->extcpu);
 373         fpd_dest  = &rec->entries[entry];
 374         memcpy(fpd_dest, &fpd, sizeof(struct cper_fru_poison_desc));
 375
 376         fmp->nr_entries          = entry + 1;
 377         fmp->validation_bits    |= FMP_VALID_LIST_ENTRIES;
 378         fmp->validation_bits    |= FMP_VALID_LIST;
 379
 380         pr_debug("Updated FRU 0x%016llx entry #%u\n", fmp->fru_id, entry);
 381
 382         update_record_on_storage(rec);
 383
 384 out_unlock:
 385         mutex_unlock(&fmpm_update_mutex);
 386 }
 387
 388 static void retire_dram_row(u64 addr, u64 id, u32 cpu)
 389 {
 390         struct atl_err a_err;
 391
 392         memset(&a_err, 0, sizeof(struct atl_err));
 393
 394         a_err.addr = addr;
 395         a_err.ipid = id;
 396         a_err.cpu  = cpu;
 397
 398         amd_retire_dram_row(&a_err);
 399 }
 400
 401 static int fru_handle_mem_poison(struct notifier_block *nb, unsigned long val, void *data)
 402 {
 403         struct mce *m = (struct mce *)data;
 404         struct fru_rec *rec;
 405
 406         if (!mce_is_memory_error(m))
 407                 return NOTIFY_DONE;
 408
 409         retire_dram_row(m->addr, m->ipid, m->extcpu);
 410
 411         /*
 412          * An invalid FRU ID should not happen on real errors. But it
 413          * could happen from software error injection, etc.
 414          */
 415         rec = get_fru_record(m->ppin);
 416         if (!rec)
 417                 return NOTIFY_DONE;
 418
 419         update_fru_record(rec, m);
 420
 421         return NOTIFY_OK;
 422 }
 423
 424 static struct notifier_block fru_mem_poison_nb = {
 425         .notifier_call  = fru_handle_mem_poison,
 426         .priority       = MCE_PRIO_LOWEST,
 427 };
 428
 429 static void retire_mem_fmp(struct fru_rec *rec)
 430 {
 431         struct cper_sec_fru_mem_poison *fmp = &rec->fmp;
 432         unsigned int i, cpu;
 433
 434         for (i = 0; i < fmp->nr_entries; i++) {
 435                 struct cper_fru_poison_desc *fpd = &rec->entries[i];
 436                 unsigned int err_cpu = INVALID_CPU;
 437
 438                 if (fpd->hw_id_type != FPD_HW_ID_TYPE_MCA_IPID)
 439                         continue;
 440
 441                 if (fpd->addr_type != FPD_ADDR_TYPE_MCA_ADDR)
 442                         continue;
 443
 444                 cpus_read_lock();
 445                 for_each_online_cpu(cpu) {
 446                         if (topology_ppin(cpu) == fmp->fru_id) {
 447                                 err_cpu = cpu;
 448                                 break;
 449                         }
 450                 }
 451                 cpus_read_unlock();
 452
 453                 if (err_cpu == INVALID_CPU)
 454                         continue;
 455
 456                 retire_dram_row(fpd->addr, fpd->hw_id, err_cpu);
 457                 save_spa(rec, i, fpd->addr, fpd->hw_id, err_cpu);
 458         }
 459 }
 460
 461 static void retire_mem_records(void)
 462 {
 463         struct fru_rec *rec;
 464         unsigned int i;
 465
 466         for_each_fru(i, rec) {
 467                 if (!rec_has_valid_entries(rec))
 468                         continue;
 469
 470                 retire_mem_fmp(rec);
 471         }
 472 }
 473
 474 /* Set the CPER Record Header and CPER Section Descriptor fields. */
 475 static void set_rec_fields(struct fru_rec *rec)
 476 {
 477         struct cper_section_descriptor  *sec_desc = &rec->sec_desc;
 478         struct cper_record_header       *hdr      = &rec->hdr;
 479
 480         /*
 481          * This is a saved record created with fewer max_nr_entries.
 482          * Update the record lengths and keep everything else as-is.
 483          */
 484         if (hdr->record_length && hdr->record_length < max_rec_len) {
 485                 pr_debug("Growing record 0x%016llx from %u to %zu bytes\n",
 486                          hdr->record_id, hdr->record_length, max_rec_len);
 487                 goto update_lengths;
 488         }
 489
 490         memcpy(hdr->signature, CPER_SIG_RECORD, CPER_SIG_SIZE);
 491         hdr->revision                   = CPER_RECORD_REV;
 492         hdr->signature_end              = CPER_SIG_END;
 493
 494         /*
 495          * Currently, it is assumed that there is one FRU Memory Poison
 496          * section per CPER. But this may change for other implementations.
 497          */
 498         hdr->section_count              = 1;
 499
 500         /* The logged errors are recoverable. Otherwise, they'd never make it here. */
 501         hdr->error_severity             = CPER_SEV_RECOVERABLE;
 502
 503         hdr->validation_bits            = 0;
 504         hdr->creator_id                 = CPER_CREATOR_FMP;
 505         hdr->notification_type          = CPER_NOTIFY_MCE;
 506         hdr->record_id                  = cper_next_record_id();
 507         hdr->flags                      = CPER_HW_ERROR_FLAGS_PREVERR;
 508
 509         sec_desc->section_offset        = sizeof(struct cper_record_header);
 510         sec_desc->revision              = CPER_SEC_REV;
 511         sec_desc->validation_bits       = 0;
 512         sec_desc->flags                 = CPER_SEC_PRIMARY;
 513         sec_desc->section_type          = CPER_SECTION_TYPE_FMP;
 514         sec_desc->section_severity      = CPER_SEV_RECOVERABLE;
 515
 516 update_lengths:
 517         hdr->record_length              = max_rec_len;
 518         sec_desc->section_length        = max_rec_len - sizeof(struct cper_record_header);
 519 }
 520
 521 static int save_new_records(void)
 522 {
 523         DECLARE_BITMAP(new_records, FMPM_MAX_NR_FRU);
 524         struct fru_rec *rec;
 525         unsigned int i;
 526         int ret = 0;
 527
 528         for_each_fru(i, rec) {
 529                 /* No need to update saved records that match the current record size. */
 530                 if (rec->hdr.record_length == max_rec_len)
 531                         continue;
 532
 533                 if (!rec->hdr.record_length)
 534                         set_bit(i, new_records);
 535
 536                 set_rec_fields(rec);
 537
 538                 ret = update_record_on_storage(rec);
 539                 if (ret)
 540                         goto out_clear;
 541         }
 542
 543         return ret;
 544
 545 out_clear:
 546         for_each_fru(i, rec) {
 547                 if (!test_bit(i, new_records))
 548                         continue;
 549
 550                 erst_clear(rec->hdr.record_id);
 551         }
 552
 553         return ret;
 554 }
 555
 556 /* Check that the record matches expected types for the current system.*/
 557 static bool fmp_is_usable(struct fru_rec *rec)
 558 {
 559         struct cper_sec_fru_mem_poison *fmp = &rec->fmp;
 560         u64 cpuid;
 561
 562         pr_debug("Validation bits: 0x%016llx\n", fmp->validation_bits);
 563
 564         if (!(fmp->validation_bits & FMP_VALID_ARCH_TYPE)) {
 565                 pr_debug("Arch type unknown\n");
 566                 return false;
 567         }
 568
 569         if (fmp->fru_arch_type != FMP_ARCH_TYPE_X86_CPUID_1_EAX) {
 570                 pr_debug("Arch type not 'x86 Family/Model/Stepping'\n");
 571                 return false;
 572         }
 573
 574         if (!(fmp->validation_bits & FMP_VALID_ARCH)) {
 575                 pr_debug("Arch value unknown\n");
 576                 return false;
 577         }
 578
 579         cpuid = cpuid_eax(1);
 580         if (fmp->fru_arch != cpuid) {
 581                 pr_debug("Arch value mismatch: record = 0x%016llx, system = 0x%016llx\n",
 582                          fmp->fru_arch, cpuid);
 583                 return false;
 584         }
 585
 586         if (!(fmp->validation_bits & FMP_VALID_ID_TYPE)) {
 587                 pr_debug("FRU ID type unknown\n");
 588                 return false;
 589         }
 590
 591         if (fmp->fru_id_type != FMP_ID_TYPE_X86_PPIN) {
 592                 pr_debug("FRU ID type is not 'x86 PPIN'\n");
 593                 return false;
 594         }
 595
 596         if (!(fmp->validation_bits & FMP_VALID_ID)) {
 597                 pr_debug("FRU ID value unknown\n");
 598                 return false;
 599         }
 600
 601         return true;
 602 }
 603
 604 static bool fmp_is_valid(struct fru_rec *rec)
 605 {
 606         struct cper_sec_fru_mem_poison *fmp = &rec->fmp;
 607         u32 checksum, len;
 608
 609         len = get_fmp_len(rec);
 610         if (len < sizeof(struct cper_sec_fru_mem_poison)) {
 611                 pr_debug("fmp length is too small\n");
 612                 return false;
 613         }
 614
 615         /* Checksum must sum to zero for the entire section. */
 616         checksum = do_fmp_checksum(fmp, len) + fmp->checksum;
 617         if (checksum) {
 618                 pr_debug("fmp checksum failed: sum = 0x%x\n", checksum);
 619                 print_hex_dump_debug("fmp record: ", DUMP_PREFIX_NONE, 16, 1, fmp, len, false);
 620                 return false;
 621         }
 622
 623         if (!fmp_is_usable(rec))
 624                 return false;
 625
 626         return true;
 627 }
 628
 629 static struct fru_rec *get_valid_record(struct fru_rec *old)
 630 {
 631         struct fru_rec *new;
 632
 633         if (!fmp_is_valid(old)) {
 634                 pr_debug("Ignoring invalid record\n");
 635                 return NULL;
 636         }
 637
 638         new = get_fru_record(old->fmp.fru_id);
 639         if (!new)
 640                 pr_debug("Ignoring record for absent FRU\n");
 641
 642         return new;
 643 }
 644
 645 /*
 646  * Fetch saved records from persistent storage.
 647  *
 648  * For each found record:
 649  * - If it was not created by this module, then ignore it.
 650  * - If it is valid, then copy its data to the local cache.
 651  * - If it is not valid, then erase it.
 652  */
 653 static int get_saved_records(void)
 654 {
 655         struct fru_rec *old, *new;
 656         u64 record_id;
 657         int ret, pos;
 658         ssize_t len;
 659
 660         old = kmalloc(FMPM_MAX_REC_LEN, GFP_KERNEL);
 661         if (!old) {
 662                 ret = -ENOMEM;
 663                 goto out;
 664         }
 665
 666         ret = erst_get_record_id_begin(&pos);
 667         if (ret < 0)
 668                 goto out_end;
 669
 670         while (!erst_get_record_id_next(&pos, &record_id)) {
 671                 if (record_id == APEI_ERST_INVALID_RECORD_ID)
 672                         goto out_end;
 673                 /*
 674                  * Make sure to clear temporary buffer between reads to avoid
 675                  * leftover data from records of various sizes.
 676                  */
 677                 memset(old, 0, FMPM_MAX_REC_LEN);
 678
 679                 len = erst_read_record(record_id, &old->hdr, FMPM_MAX_REC_LEN,
 680                                        sizeof(struct fru_rec), &CPER_CREATOR_FMP);
 681                 if (len < 0)
 682                         continue;
 683
 684                 new = get_valid_record(old);
 685                 if (!new) {
 686                         erst_clear(record_id);
 687                         continue;
 688                 }
 689
 690                 if (len > max_rec_len) {
 691                         unsigned int saved_nr_entries;
 692
 693                         saved_nr_entries  = len - sizeof(struct fru_rec);
 694                         saved_nr_entries /= sizeof(struct cper_fru_poison_desc);
 695
 696                         pr_warn("Saved record found with %u entries.\n", saved_nr_entries);
 697                         pr_warn("Please increase max_nr_entries to %u.\n", saved_nr_entries);
 698
 699                         ret = -EINVAL;
 700                         goto out_end;
 701                 }
 702
 703                 /* Restore the record */
 704                 memcpy(new, old, len);
 705         }
 706
 707 out_end:
 708         erst_get_record_id_end();
 709         kfree(old);
 710 out:
 711         return ret;
 712 }
 713
 714 static void set_fmp_fields(struct fru_rec *rec, unsigned int cpu)
 715 {
 716         struct cper_sec_fru_mem_poison *fmp = &rec->fmp;
 717
 718         fmp->fru_arch_type    = FMP_ARCH_TYPE_X86_CPUID_1_EAX;
 719         fmp->validation_bits |= FMP_VALID_ARCH_TYPE;
 720
 721         /* Assume all CPUs in the system have the same value for now. */
 722         fmp->fru_arch         = cpuid_eax(1);
 723         fmp->validation_bits |= FMP_VALID_ARCH;
 724
 725         fmp->fru_id_type      = FMP_ID_TYPE_X86_PPIN;
 726         fmp->validation_bits |= FMP_VALID_ID_TYPE;
 727
 728         fmp->fru_id           = topology_ppin(cpu);
 729         fmp->validation_bits |= FMP_VALID_ID;
 730 }
 731
 732 static int init_fmps(void)
 733 {
 734         struct fru_rec *rec;
 735         unsigned int i, cpu;
 736         int ret = 0;
 737
 738         for_each_fru(i, rec) {
 739                 unsigned int fru_cpu = INVALID_CPU;
 740
 741                 cpus_read_lock();
 742                 for_each_online_cpu(cpu) {
 743                         if (topology_physical_package_id(cpu) == i) {
 744                                 fru_cpu = cpu;
 745                                 break;
 746                         }
 747                 }
 748                 cpus_read_unlock();
 749
 750                 if (fru_cpu == INVALID_CPU) {
 751                         pr_debug("Failed to find matching CPU for FRU #%u\n", i);
 752                         ret = -ENODEV;
 753                         break;
 754                 }
 755
 756                 set_fmp_fields(rec, fru_cpu);
 757         }
 758
 759         return ret;
 760 }
 761
 762 static int get_system_info(void)
 763 {
 764         /* Only load on MI300A systems for now. */
 765         if (!(boot_cpu_data.x86_model >= 0x90 &&
 766               boot_cpu_data.x86_model <= 0x9f))
 767                 return -ENODEV;
 768
 769         if (!cpu_feature_enabled(X86_FEATURE_AMD_PPIN)) {
 770                 pr_debug("PPIN feature not available\n");
 771                 return -ENODEV;
 772         }
 773
 774         /* Use CPU socket as FRU for MI300 systems. */
 775         max_nr_fru = topology_max_packages();
 776         if (!max_nr_fru)
 777                 return -ENODEV;
 778
 779         if (max_nr_fru > FMPM_MAX_NR_FRU) {
 780                 pr_warn("Too many FRUs to manage: found: %u, max: %u\n",
 781                         max_nr_fru, FMPM_MAX_NR_FRU);
 782                 return -ENODEV;
 783         }
 784
 785         if (!max_nr_entries)
 786                 max_nr_entries = FMPM_DEFAULT_MAX_NR_ENTRIES;
 787
 788         spa_nr_entries = max_nr_fru * max_nr_entries;
 789
 790         max_rec_len  = sizeof(struct fru_rec);
 791         max_rec_len += sizeof(struct cper_fru_poison_desc) * max_nr_entries;
 792
 793         pr_info("max FRUs: %u, max entries: %u, max record length: %lu\n",
 794                  max_nr_fru, max_nr_entries, max_rec_len);
 795
 796         return 0;
 797 }
 798
 799 static void free_records(void)
 800 {
 801         struct fru_rec *rec;
 802         int i;
 803
 804         for_each_fru(i, rec)
 805                 kfree(rec);
 806
 807         kfree(fru_records);
 808         kfree(spa_entries);
 809 }
 810
 811 static int allocate_records(void)
 812 {
 813         int i, ret = 0;
 814
 815         fru_records = kcalloc(max_nr_fru, sizeof(struct fru_rec *), GFP_KERNEL);
 816         if (!fru_records) {
 817                 ret = -ENOMEM;
 818                 goto out;
 819         }
 820
 821         for (i = 0; i < max_nr_fru; i++) {
 822                 fru_records[i] = kzalloc(max_rec_len, GFP_KERNEL);
 823                 if (!fru_records[i]) {
 824                         ret = -ENOMEM;
 825                         goto out_free;
 826                 }
 827         }
 828
 829         spa_entries = kcalloc(spa_nr_entries, sizeof(u64), GFP_KERNEL);
 830         if (!spa_entries) {
 831                 ret = -ENOMEM;
 832                 goto out_free;
 833         }
 834
 835         for (i = 0; i < spa_nr_entries; i++)
 836                 spa_entries[i] = INVALID_SPA;
 837
 838         return ret;
 839
 840 out_free:
 841         while (--i >= 0)
 842                 kfree(fru_records[i]);
 843
 844         kfree(fru_records);
 845 out:
 846         return ret;
 847 }
 848
 849 static void *fmpm_start(struct seq_file *f, loff_t *pos)
 850 {
 851         if (*pos >= (spa_nr_entries + 1))
 852                 return NULL;
 853         return pos;
 854 }
 855
 856 static void *fmpm_next(struct seq_file *f, void *data, loff_t *pos)
 857 {
 858         if (++(*pos) >= (spa_nr_entries + 1))
 859                 return NULL;
 860         return pos;
 861 }
 862
 863 static void fmpm_stop(struct seq_file *f, void *data)
 864 {
 865 }
 866
 867 #define SHORT_WIDTH     8
 868 #define U64_WIDTH       18
 869 #define TIMESTAMP_WIDTH 19
 870 #define LONG_WIDTH      24
 871 #define U64_PAD         (LONG_WIDTH - U64_WIDTH)
 872 #define TS_PAD          (LONG_WIDTH - TIMESTAMP_WIDTH)
 873 static int fmpm_show(struct seq_file *f, void *data)
 874 {
 875         unsigned int fru_idx, entry, spa_entry, line;
 876         struct cper_fru_poison_desc *fpd;
 877         struct fru_rec *rec;
 878
 879         line = *(loff_t *)data;
 880         if (line == 0) {
 881                 seq_printf(f, "%-*s", SHORT_WIDTH, "fru_idx");
 882                 seq_printf(f, "%-*s", LONG_WIDTH,  "fru_id");
 883                 seq_printf(f, "%-*s", SHORT_WIDTH, "entry");
 884                 seq_printf(f, "%-*s", LONG_WIDTH,  "timestamp");
 885                 seq_printf(f, "%-*s", LONG_WIDTH,  "hw_id");
 886                 seq_printf(f, "%-*s", LONG_WIDTH,  "addr");
 887                 seq_printf(f, "%-*s", LONG_WIDTH,  "spa");
 888                 goto out_newline;
 889         }
 890
 891         spa_entry = line - 1;
 892         fru_idx   = spa_entry / max_nr_entries;
 893         entry     = spa_entry % max_nr_entries;
 894
 895         rec = fru_records[fru_idx];
 896         if (!rec)
 897                 goto out;
 898
 899         seq_printf(f, "%-*u",           SHORT_WIDTH, fru_idx);
 900         seq_printf(f, "0x%016llx%-*s",  rec->fmp.fru_id, U64_PAD, "");
 901         seq_printf(f, "%-*u",           SHORT_WIDTH, entry);
 902
 903         mutex_lock(&fmpm_update_mutex);
 904
 905         if (entry >= rec->fmp.nr_entries) {
 906                 seq_printf(f, "%-*s", LONG_WIDTH, "*");
 907                 seq_printf(f, "%-*s", LONG_WIDTH, "*");
 908                 seq_printf(f, "%-*s", LONG_WIDTH, "*");
 909                 seq_printf(f, "%-*s", LONG_WIDTH, "*");
 910                 goto out_unlock;
 911         }
 912
 913         fpd = &rec->entries[entry];
 914
 915         seq_printf(f, "%ptT%-*s",       &fpd->timestamp, TS_PAD,  "");
 916         seq_printf(f, "0x%016llx%-*s",  fpd->hw_id,      U64_PAD, "");
 917         seq_printf(f, "0x%016llx%-*s",  fpd->addr,       U64_PAD, "");
 918
 919         if (spa_entries[spa_entry] == INVALID_SPA)
 920                 seq_printf(f, "%-*s", LONG_WIDTH, "*");
 921         else
 922                 seq_printf(f, "0x%016llx%-*s", spa_entries[spa_entry], U64_PAD, "");
 923
 924 out_unlock:
 925         mutex_unlock(&fmpm_update_mutex);
 926 out_newline:
 927         seq_putc(f, '\n');
 928 out:
 929         return 0;
 930 }
 931
 932 static const struct seq_operations fmpm_seq_ops = {
 933         .start  = fmpm_start,
 934         .next   = fmpm_next,
 935         .stop   = fmpm_stop,
 936         .show   = fmpm_show,
 937 };
 938
 939 static int fmpm_open(struct inode *inode, struct file *file)
 940 {
 941         return seq_open(file, &fmpm_seq_ops);
 942 }
 943
 944 static const struct file_operations fmpm_fops = {
 945         .open           = fmpm_open,
 946         .release        = seq_release,
 947         .read           = seq_read,
 948         .llseek         = seq_lseek,
 949 };
 950
 951 static void setup_debugfs(void)
 952 {
 953         struct dentry *dfs = ras_get_debugfs_root();
 954
 955         if (!dfs)
 956                 return;
 957
 958         fmpm_dfs_dir = debugfs_create_dir("fmpm", dfs);
 959         if (!fmpm_dfs_dir)
 960                 return;
 961
 962         fmpm_dfs_entries = debugfs_create_file("entries", 0400, fmpm_dfs_dir, NULL, &fmpm_fops);
 963         if (!fmpm_dfs_entries)
 964                 debugfs_remove(fmpm_dfs_dir);
 965 }
 966
 967 static const struct x86_cpu_id fmpm_cpuids[] = {
 968         X86_MATCH_VENDOR_FAM(AMD, 0x19, NULL),
 969         { }
 970 };
 971 MODULE_DEVICE_TABLE(x86cpu, fmpm_cpuids);
 972
 973 static int __init fru_mem_poison_init(void)
 974 {
 975         int ret;
 976
 977         if (!x86_match_cpu(fmpm_cpuids)) {
 978                 ret = -ENODEV;
 979                 goto out;
 980         }
 981
 982         if (erst_disable) {
 983                 pr_debug("ERST not available\n");
 984                 ret = -ENODEV;
 985                 goto out;
 986         }
 987
 988         ret = get_system_info();
 989         if (ret)
 990                 goto out;
 991
 992         ret = allocate_records();
 993         if (ret)
 994                 goto out;
 995
 996         ret = init_fmps();
 997         if (ret)
 998                 goto out_free;
 999
1000         ret = get_saved_records();
1001         if (ret)
1002                 goto out_free;
1003
1004         ret = save_new_records();
1005         if (ret)
1006                 goto out_free;
1007
1008         setup_debugfs();
1009
1010         retire_mem_records();
1011
1012         mce_register_decode_chain(&fru_mem_poison_nb);
1013
1014         pr_info("FRU Memory Poison Manager initialized\n");
1015         return 0;
1016
1017 out_free:
1018         free_records();
1019 out:
1020         return ret;
1021 }
1022
1023 static void __exit fru_mem_poison_exit(void)
1024 {
1025         mce_unregister_decode_chain(&fru_mem_poison_nb);
1026         debugfs_remove(fmpm_dfs_dir);
1027         free_records();
1028 }
1029
1030 module_init(fru_mem_poison_init);
1031 module_exit(fru_mem_poison_exit);
1032
1033 MODULE_LICENSE("GPL");
1034 MODULE_DESCRIPTION("FRU Memory Poison Manager");