arch/parisc/kernel/pdt.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Page Deallocation Table (PDT) support
   4  *
   5  *    The Page Deallocation Table (PDT) is maintained by firmware and holds a
   6  *    list of memory addresses in which memory errors were detected.
   7  *    The list contains both single-bit (correctable) and double-bit
   8  *    (uncorrectable) errors.
   9  *
  10  *    Copyright 2017 by Helge Deller <deller@gmx.de>
  11  *
  12  *    possible future enhancements:
  13  *    - add userspace interface via procfs or sysfs to clear PDT
  14  */
  15
  16 #include <linux/memblock.h>
  17 #include <linux/seq_file.h>
  18 #include <linux/kthread.h>
  19 #include <linux/initrd.h>
  20 #include <linux/pgtable.h>
  21 #include <linux/swap.h>
  22 #include <linux/swapops.h>
  23
  24 #include <asm/pdc.h>
  25 #include <asm/pdcpat.h>
  26 #include <asm/sections.h>
  27
  28 enum pdt_access_type {
  29         PDT_NONE,
  30         PDT_PDC,
  31         PDT_PAT_NEW,
  32         PDT_PAT_CELL
  33 };
  34
  35 static enum pdt_access_type pdt_type;
  36
  37 /* PDT poll interval: 1 minute if errors, 5 minutes if everything OK. */
  38 #define PDT_POLL_INTERVAL_DEFAULT       (5*60*HZ)
  39 #define PDT_POLL_INTERVAL_SHORT         (1*60*HZ)
  40 static unsigned long pdt_poll_interval = PDT_POLL_INTERVAL_DEFAULT;
  41
  42 /* global PDT status information */
  43 static struct pdc_mem_retinfo pdt_status;
  44
  45 #define MAX_PDT_TABLE_SIZE      PAGE_SIZE
  46 #define MAX_PDT_ENTRIES         (MAX_PDT_TABLE_SIZE / sizeof(unsigned long))
  47 static unsigned long pdt_entry[MAX_PDT_ENTRIES] __page_aligned_bss;
  48
  49 /*
  50  * Constants for the pdt_entry format:
  51  * A pdt_entry holds the physical address in bits 0-57, bits 58-61 are
  52  * reserved, bit 62 is the perm bit and bit 63 is the error_type bit.
  53  * The perm bit indicates whether the error have been verified as a permanent
  54  * error (value of 1) or has not been verified, and may be transient (value
  55  * of 0). The error_type bit indicates whether the error is a single bit error
  56  * (value of 1) or a multiple bit error.
  57  * On non-PAT machines phys_addr is encoded in bits 0-59 and error_type in bit
  58  * 63. Those machines don't provide the perm bit.
  59  */
  60
  61 #define PDT_ADDR_PHYS_MASK      (pdt_type != PDT_PDC ? ~0x3f : ~0x0f)
  62 #define PDT_ADDR_PERM_ERR       (pdt_type != PDT_PDC ? 2UL : 0UL)
  63 #define PDT_ADDR_SINGLE_ERR     1UL
  64
  65 /* report PDT entries via /proc/meminfo */
  66 void arch_report_meminfo(struct seq_file *m)
  67 {
  68         if (pdt_type == PDT_NONE)
  69                 return;
  70
  71         seq_printf(m, "PDT_max_entries: %7lu\n",
  72                         pdt_status.pdt_size);
  73         seq_printf(m, "PDT_cur_entries: %7lu\n",
  74                         pdt_status.pdt_entries);
  75 }
  76
  77 static int get_info_pat_new(void)
  78 {
  79         struct pdc_pat_mem_retinfo pat_rinfo;
  80         int ret;
  81
  82         /* newer PAT machines like C8000 report info for all cells */
  83         if (is_pdc_pat())
  84                 ret = pdc_pat_mem_pdt_info(&pat_rinfo);
  85         else
  86                 return PDC_BAD_PROC;
  87
  88         pdt_status.pdt_size = pat_rinfo.max_pdt_entries;
  89         pdt_status.pdt_entries = pat_rinfo.current_pdt_entries;
  90         pdt_status.pdt_status = 0;
  91         pdt_status.first_dbe_loc = pat_rinfo.first_dbe_loc;
  92         pdt_status.good_mem = pat_rinfo.good_mem;
  93
  94         return ret;
  95 }
  96
  97 static int get_info_pat_cell(void)
  98 {
  99         struct pdc_pat_mem_cell_pdt_retinfo cell_rinfo;
 100         int ret;
 101
 102         /* older PAT machines like rp5470 report cell info only */
 103         if (is_pdc_pat())
 104                 ret = pdc_pat_mem_pdt_cell_info(&cell_rinfo, parisc_cell_num);
 105         else
 106                 return PDC_BAD_PROC;
 107
 108         pdt_status.pdt_size = cell_rinfo.max_pdt_entries;
 109         pdt_status.pdt_entries = cell_rinfo.current_pdt_entries;
 110         pdt_status.pdt_status = 0;
 111         pdt_status.first_dbe_loc = cell_rinfo.first_dbe_loc;
 112         pdt_status.good_mem = cell_rinfo.good_mem;
 113
 114         return ret;
 115 }
 116
 117 static void report_mem_err(unsigned long pde)
 118 {
 119         struct pdc_pat_mem_phys_mem_location loc;
 120         unsigned long addr;
 121         char dimm_txt[32];
 122
 123         addr = pde & PDT_ADDR_PHYS_MASK;
 124
 125         /* show DIMM slot description on PAT machines */
 126         if (is_pdc_pat()) {
 127                 pdc_pat_mem_get_dimm_phys_location(&loc, addr);
 128                 sprintf(dimm_txt, "DIMM slot %02x, ", loc.dimm_slot);
 129         } else
 130                 dimm_txt[0] = 0;
 131
 132         pr_warn("PDT: BAD MEMORY at 0x%08lx, %s%s%s-bit error.\n",
 133                 addr, dimm_txt,
 134                 pde & PDT_ADDR_PERM_ERR ? "permanent ":"",
 135                 pde & PDT_ADDR_SINGLE_ERR ? "single":"multi");
 136 }
 137
 138
 139 /*
 140  * pdc_pdt_init()
 141  *
 142  * Initialize kernel PDT structures, read initial PDT table from firmware,
 143  * report all current PDT entries and mark bad memory with memblock_reserve()
 144  * to avoid that the kernel will use broken memory areas.
 145  *
 146  */
 147 void __init pdc_pdt_init(void)
 148 {
 149         int ret, i;
 150         unsigned long entries;
 151         struct pdc_mem_read_pdt pdt_read_ret;
 152
 153         pdt_type = PDT_PAT_NEW;
 154         ret = get_info_pat_new();
 155
 156         if (ret != PDC_OK) {
 157                 pdt_type = PDT_PAT_CELL;
 158                 ret = get_info_pat_cell();
 159         }
 160
 161         if (ret != PDC_OK) {
 162                 pdt_type = PDT_PDC;
 163                 /* non-PAT machines provide the standard PDC call */
 164                 ret = pdc_mem_pdt_info(&pdt_status);
 165         }
 166
 167         if (ret != PDC_OK) {
 168                 pdt_type = PDT_NONE;
 169                 pr_info("PDT: Firmware does not provide any page deallocation"
 170                         " information.\n");
 171                 return;
 172         }
 173
 174         entries = pdt_status.pdt_entries;
 175         if (WARN_ON(entries > MAX_PDT_ENTRIES))
 176                 entries = pdt_status.pdt_entries = MAX_PDT_ENTRIES;
 177
 178         pr_info("PDT: type %s, size %lu, entries %lu, status %lu, dbe_loc 0x%lx,"
 179                 " good_mem %lu MB\n",
 180                         pdt_type == PDT_PDC ? __stringify(PDT_PDC) :
 181                         pdt_type == PDT_PAT_CELL ? __stringify(PDT_PAT_CELL)
 182                                                  : __stringify(PDT_PAT_NEW),
 183                         pdt_status.pdt_size, pdt_status.pdt_entries,
 184                         pdt_status.pdt_status, pdt_status.first_dbe_loc,
 185                         pdt_status.good_mem / 1024 / 1024);
 186
 187         if (entries == 0) {
 188                 pr_info("PDT: Firmware reports all memory OK.\n");
 189                 return;
 190         }
 191
 192         if (pdt_status.first_dbe_loc &&
 193                 pdt_status.first_dbe_loc <= __pa((unsigned long)&_end))
 194                 pr_crit("CRITICAL: Bad memory inside kernel image memory area!\n");
 195
 196         pr_warn("PDT: Firmware reports %lu entries of faulty memory:\n",
 197                 entries);
 198
 199         if (pdt_type == PDT_PDC)
 200                 ret = pdc_mem_pdt_read_entries(&pdt_read_ret, pdt_entry);
 201         else {
 202 #ifdef CONFIG_64BIT
 203                 struct pdc_pat_mem_read_pd_retinfo pat_pret;
 204
 205                 if (pdt_type == PDT_PAT_CELL)
 206                         ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry,
 207                                 MAX_PDT_ENTRIES);
 208                 else
 209                         ret = pdc_pat_mem_read_pd_pdt(&pat_pret, pdt_entry,
 210                                 MAX_PDT_TABLE_SIZE, 0);
 211 #else
 212                 ret = PDC_BAD_PROC;
 213 #endif
 214         }
 215
 216         if (ret != PDC_OK) {
 217                 pdt_type = PDT_NONE;
 218                 pr_warn("PDT: Get PDT entries failed with %d\n", ret);
 219                 return;
 220         }
 221
 222         for (i = 0; i < pdt_status.pdt_entries; i++) {
 223                 unsigned long addr;
 224
 225                 report_mem_err(pdt_entry[i]);
 226
 227                 addr = pdt_entry[i] & PDT_ADDR_PHYS_MASK;
 228                 if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) &&
 229                         addr >= initrd_start && addr < initrd_end)
 230                         pr_crit("CRITICAL: initrd possibly broken "
 231                                 "due to bad memory!\n");
 232
 233                 /* mark memory page bad */
 234                 memblock_reserve(pdt_entry[i] & PAGE_MASK, PAGE_SIZE);
 235                 num_poisoned_pages_inc();
 236         }
 237 }
 238
 239
 240 /*
 241  * This is the PDT kernel thread main loop.
 242  */
 243
 244 static int pdt_mainloop(void *unused)
 245 {
 246         struct pdc_mem_read_pdt pdt_read_ret;
 247         struct pdc_pat_mem_read_pd_retinfo pat_pret __maybe_unused;
 248         unsigned long old_num_entries;
 249         unsigned long *bad_mem_ptr;
 250         int num, ret;
 251
 252         for (;;) {
 253                 set_current_state(TASK_INTERRUPTIBLE);
 254
 255                 old_num_entries = pdt_status.pdt_entries;
 256
 257                 schedule_timeout(pdt_poll_interval);
 258                 if (kthread_should_stop())
 259                         break;
 260
 261                 /* Do we have new PDT entries? */
 262                 switch (pdt_type) {
 263                 case PDT_PAT_NEW:
 264                         ret = get_info_pat_new();
 265                         break;
 266                 case PDT_PAT_CELL:
 267                         ret = get_info_pat_cell();
 268                         break;
 269                 default:
 270                         ret = pdc_mem_pdt_info(&pdt_status);
 271                         break;
 272                 }
 273
 274                 if (ret != PDC_OK) {
 275                         pr_warn("PDT: unexpected failure %d\n", ret);
 276                         return -EINVAL;
 277                 }
 278
 279                 /* if no new PDT entries, just wait again */
 280                 num = pdt_status.pdt_entries - old_num_entries;
 281                 if (num <= 0)
 282                         continue;
 283
 284                 /* decrease poll interval in case we found memory errors */
 285                 if (pdt_status.pdt_entries &&
 286                         pdt_poll_interval == PDT_POLL_INTERVAL_DEFAULT)
 287                         pdt_poll_interval = PDT_POLL_INTERVAL_SHORT;
 288
 289                 /* limit entries to get */
 290                 if (num > MAX_PDT_ENTRIES) {
 291                         num = MAX_PDT_ENTRIES;
 292                         pdt_status.pdt_entries = old_num_entries + num;
 293                 }
 294
 295                 /* get new entries */
 296                 switch (pdt_type) {
 297 #ifdef CONFIG_64BIT
 298                 case PDT_PAT_CELL:
 299                         if (pdt_status.pdt_entries > MAX_PDT_ENTRIES) {
 300                                 pr_crit("PDT: too many entries.\n");
 301                                 return -ENOMEM;
 302                         }
 303                         ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry,
 304                                 MAX_PDT_ENTRIES);
 305                         bad_mem_ptr = &pdt_entry[old_num_entries];
 306                         break;
 307                 case PDT_PAT_NEW:
 308                         ret = pdc_pat_mem_read_pd_pdt(&pat_pret,
 309                                 pdt_entry,
 310                                 num * sizeof(unsigned long),
 311                                 old_num_entries * sizeof(unsigned long));
 312                         bad_mem_ptr = &pdt_entry[0];
 313                         break;
 314 #endif
 315                 default:
 316                         ret = pdc_mem_pdt_read_entries(&pdt_read_ret,
 317                                 pdt_entry);
 318                         bad_mem_ptr = &pdt_entry[old_num_entries];
 319                         break;
 320                 }
 321
 322                 /* report and mark memory broken */
 323                 while (num--) {
 324                         unsigned long pde = *bad_mem_ptr++;
 325
 326                         report_mem_err(pde);
 327
 328 #ifdef CONFIG_MEMORY_FAILURE
 329                         if ((pde & PDT_ADDR_PERM_ERR) ||
 330                             ((pde & PDT_ADDR_SINGLE_ERR) == 0))
 331                                 memory_failure(pde >> PAGE_SHIFT, 0);
 332                         else
 333                                 soft_offline_page(pde >> PAGE_SHIFT, 0);
 334 #else
 335                         pr_crit("PDT: memory error at 0x%lx ignored.\n"
 336                                 "Rebuild kernel with CONFIG_MEMORY_FAILURE=y "
 337                                 "for real handling.\n",
 338                                 pde & PDT_ADDR_PHYS_MASK);
 339 #endif
 340
 341                 }
 342         }
 343
 344         return 0;
 345 }
 346
 347
 348 static int __init pdt_initcall(void)
 349 {
 350         struct task_struct *kpdtd_task;
 351
 352         if (pdt_type == PDT_NONE)
 353                 return -ENODEV;
 354
 355         kpdtd_task = kthread_create(pdt_mainloop, NULL, "kpdtd");
 356         if (IS_ERR(kpdtd_task))
 357                 return PTR_ERR(kpdtd_task);
 358
 359         wake_up_process(kpdtd_task);
 360
 361         return 0;
 362 }
 363
 364 late_initcall(pdt_initcall);