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
29enum pdt_access_type {
30	PDT_NONE,
31	PDT_PDC,
32	PDT_PAT_NEW,
33	PDT_PAT_CELL
34};
35
36static 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)
41static unsigned long pdt_poll_interval = PDT_POLL_INTERVAL_DEFAULT;
42
43/* global PDT status information */
44static 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))
48static 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 */
67void 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
78static 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
98static 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
118static 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 */
148void __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
245static 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
349static 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
361late_initcall(pdt_initcall);
362