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