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