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); 365