~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/parisc/kernel/pdt.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 */
 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 
 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 
 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 
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  */
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 
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 
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp