Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Helge Deller | 1168 | 99.91% | 5 | 83.33% |
Greg Kroah-Hartman | 1 | 0.09% | 1 | 16.67% |
Total | 1169 | 6 |
// SPDX-License-Identifier: GPL-2.0 /* * Page Deallocation Table (PDT) support * * The Page Deallocation Table (PDT) is maintained by firmware and holds a * list of memory addresses in which memory errors were detected. * The list contains both single-bit (correctable) and double-bit * (uncorrectable) errors. * * Copyright 2017 by Helge Deller <deller@gmx.de> * * possible future enhancements: * - add userspace interface via procfs or sysfs to clear PDT */ #include <linux/memblock.h> #include <linux/seq_file.h> #include <linux/kthread.h> #include <linux/initrd.h> #include <asm/pdc.h> #include <asm/pdcpat.h> #include <asm/sections.h> #include <asm/pgtable.h> enum pdt_access_type { PDT_NONE, PDT_PDC, PDT_PAT_NEW, PDT_PAT_CELL }; static enum pdt_access_type pdt_type; /* PDT poll interval: 1 minute if errors, 5 minutes if everything OK. */ #define PDT_POLL_INTERVAL_DEFAULT (5*60*HZ) #define PDT_POLL_INTERVAL_SHORT (1*60*HZ) static unsigned long pdt_poll_interval = PDT_POLL_INTERVAL_DEFAULT; /* global PDT status information */ static struct pdc_mem_retinfo pdt_status; #define MAX_PDT_TABLE_SIZE PAGE_SIZE #define MAX_PDT_ENTRIES (MAX_PDT_TABLE_SIZE / sizeof(unsigned long)) static unsigned long pdt_entry[MAX_PDT_ENTRIES] __page_aligned_bss; /* * Constants for the pdt_entry format: * A pdt_entry holds the physical address in bits 0-57, bits 58-61 are * reserved, bit 62 is the perm bit and bit 63 is the error_type bit. * The perm bit indicates whether the error have been verified as a permanent * error (value of 1) or has not been verified, and may be transient (value * of 0). The error_type bit indicates whether the error is a single bit error * (value of 1) or a multiple bit error. * On non-PAT machines phys_addr is encoded in bits 0-59 and error_type in bit * 63. Those machines don't provide the perm bit. */ #define PDT_ADDR_PHYS_MASK (pdt_type != PDT_PDC ? ~0x3f : ~0x0f) #define PDT_ADDR_PERM_ERR (pdt_type != PDT_PDC ? 2UL : 0UL) #define PDT_ADDR_SINGLE_ERR 1UL /* report PDT entries via /proc/meminfo */ void arch_report_meminfo(struct seq_file *m) { if (pdt_type == PDT_NONE) return; seq_printf(m, "PDT_max_entries: %7lu\n", pdt_status.pdt_size); seq_printf(m, "PDT_cur_entries: %7lu\n", pdt_status.pdt_entries); } static int get_info_pat_new(void) { struct pdc_pat_mem_retinfo pat_rinfo; int ret; /* newer PAT machines like C8000 report info for all cells */ if (is_pdc_pat()) ret = pdc_pat_mem_pdt_info(&pat_rinfo); else return PDC_BAD_PROC; pdt_status.pdt_size = pat_rinfo.max_pdt_entries; pdt_status.pdt_entries = pat_rinfo.current_pdt_entries; pdt_status.pdt_status = 0; pdt_status.first_dbe_loc = pat_rinfo.first_dbe_loc; pdt_status.good_mem = pat_rinfo.good_mem; return ret; } static int get_info_pat_cell(void) { struct pdc_pat_mem_cell_pdt_retinfo cell_rinfo; int ret; /* older PAT machines like rp5470 report cell info only */ if (is_pdc_pat()) ret = pdc_pat_mem_pdt_cell_info(&cell_rinfo, parisc_cell_num); else return PDC_BAD_PROC; pdt_status.pdt_size = cell_rinfo.max_pdt_entries; pdt_status.pdt_entries = cell_rinfo.current_pdt_entries; pdt_status.pdt_status = 0; pdt_status.first_dbe_loc = cell_rinfo.first_dbe_loc; pdt_status.good_mem = cell_rinfo.good_mem; return ret; } static void report_mem_err(unsigned long pde) { struct pdc_pat_mem_phys_mem_location loc; unsigned long addr; char dimm_txt[32]; addr = pde & PDT_ADDR_PHYS_MASK; /* show DIMM slot description on PAT machines */ if (is_pdc_pat()) { pdc_pat_mem_get_dimm_phys_location(&loc, addr); sprintf(dimm_txt, "DIMM slot %02x, ", loc.dimm_slot); } else dimm_txt[0] = 0; pr_warn("PDT: BAD MEMORY at 0x%08lx, %s%s%s-bit error.\n", addr, dimm_txt, pde & PDT_ADDR_PERM_ERR ? "permanent ":"", pde & PDT_ADDR_SINGLE_ERR ? "single":"multi"); } /* * pdc_pdt_init() * * Initialize kernel PDT structures, read initial PDT table from firmware, * report all current PDT entries and mark bad memory with memblock_reserve() * to avoid that the kernel will use broken memory areas. * */ void __init pdc_pdt_init(void) { int ret, i; unsigned long entries; struct pdc_mem_read_pdt pdt_read_ret; pdt_type = PDT_PAT_NEW; ret = get_info_pat_new(); if (ret != PDC_OK) { pdt_type = PDT_PAT_CELL; ret = get_info_pat_cell(); } if (ret != PDC_OK) { pdt_type = PDT_PDC; /* non-PAT machines provide the standard PDC call */ ret = pdc_mem_pdt_info(&pdt_status); } if (ret != PDC_OK) { pdt_type = PDT_NONE; pr_info("PDT: Firmware does not provide any page deallocation" " information.\n"); return; } entries = pdt_status.pdt_entries; if (WARN_ON(entries > MAX_PDT_ENTRIES)) entries = pdt_status.pdt_entries = MAX_PDT_ENTRIES; pr_info("PDT: type %s, size %lu, entries %lu, status %lu, dbe_loc 0x%lx," " good_mem %lu MB\n", pdt_type == PDT_PDC ? __stringify(PDT_PDC) : pdt_type == PDT_PAT_CELL ? __stringify(PDT_PAT_CELL) : __stringify(PDT_PAT_NEW), pdt_status.pdt_size, pdt_status.pdt_entries, pdt_status.pdt_status, pdt_status.first_dbe_loc, pdt_status.good_mem / 1024 / 1024); if (entries == 0) { pr_info("PDT: Firmware reports all memory OK.\n"); return; } if (pdt_status.first_dbe_loc && pdt_status.first_dbe_loc <= __pa((unsigned long)&_end)) pr_crit("CRITICAL: Bad memory inside kernel image memory area!\n"); pr_warn("PDT: Firmware reports %lu entries of faulty memory:\n", entries); if (pdt_type == PDT_PDC) ret = pdc_mem_pdt_read_entries(&pdt_read_ret, pdt_entry); else { #ifdef CONFIG_64BIT struct pdc_pat_mem_read_pd_retinfo pat_pret; if (pdt_type == PDT_PAT_CELL) ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry, MAX_PDT_ENTRIES); else ret = pdc_pat_mem_read_pd_pdt(&pat_pret, pdt_entry, MAX_PDT_TABLE_SIZE, 0); #else ret = PDC_BAD_PROC; #endif } if (ret != PDC_OK) { pdt_type = PDT_NONE; pr_warn("PDT: Get PDT entries failed with %d\n", ret); return; } for (i = 0; i < pdt_status.pdt_entries; i++) { unsigned long addr; report_mem_err(pdt_entry[i]); addr = pdt_entry[i] & PDT_ADDR_PHYS_MASK; if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && addr >= initrd_start && addr < initrd_end) pr_crit("CRITICAL: initrd possibly broken " "due to bad memory!\n"); /* mark memory page bad */ memblock_reserve(pdt_entry[i] & PAGE_MASK, PAGE_SIZE); } } /* * This is the PDT kernel thread main loop. */ static int pdt_mainloop(void *unused) { struct pdc_mem_read_pdt pdt_read_ret; struct pdc_pat_mem_read_pd_retinfo pat_pret __maybe_unused; unsigned long old_num_entries; unsigned long *bad_mem_ptr; int num, ret; for (;;) { set_current_state(TASK_INTERRUPTIBLE); old_num_entries = pdt_status.pdt_entries; schedule_timeout(pdt_poll_interval); if (kthread_should_stop()) break; /* Do we have new PDT entries? */ switch (pdt_type) { case PDT_PAT_NEW: ret = get_info_pat_new(); break; case PDT_PAT_CELL: ret = get_info_pat_cell(); break; default: ret = pdc_mem_pdt_info(&pdt_status); break; } if (ret != PDC_OK) { pr_warn("PDT: unexpected failure %d\n", ret); return -EINVAL; } /* if no new PDT entries, just wait again */ num = pdt_status.pdt_entries - old_num_entries; if (num <= 0) continue; /* decrease poll interval in case we found memory errors */ if (pdt_status.pdt_entries && pdt_poll_interval == PDT_POLL_INTERVAL_DEFAULT) pdt_poll_interval = PDT_POLL_INTERVAL_SHORT; /* limit entries to get */ if (num > MAX_PDT_ENTRIES) { num = MAX_PDT_ENTRIES; pdt_status.pdt_entries = old_num_entries + num; } /* get new entries */ switch (pdt_type) { #ifdef CONFIG_64BIT case PDT_PAT_CELL: if (pdt_status.pdt_entries > MAX_PDT_ENTRIES) { pr_crit("PDT: too many entries.\n"); return -ENOMEM; } ret = pdc_pat_mem_read_cell_pdt(&pat_pret, pdt_entry, MAX_PDT_ENTRIES); bad_mem_ptr = &pdt_entry[old_num_entries]; break; case PDT_PAT_NEW: ret = pdc_pat_mem_read_pd_pdt(&pat_pret, pdt_entry, num * sizeof(unsigned long), old_num_entries * sizeof(unsigned long)); bad_mem_ptr = &pdt_entry[0]; break; #endif default: ret = pdc_mem_pdt_read_entries(&pdt_read_ret, pdt_entry); bad_mem_ptr = &pdt_entry[old_num_entries]; break; } /* report and mark memory broken */ while (num--) { unsigned long pde = *bad_mem_ptr++; report_mem_err(pde); #ifdef CONFIG_MEMORY_FAILURE if ((pde & PDT_ADDR_PERM_ERR) || ((pde & PDT_ADDR_SINGLE_ERR) == 0)) memory_failure(pde >> PAGE_SHIFT, 0); else soft_offline_page( pfn_to_page(pde >> PAGE_SHIFT), 0); #else pr_crit("PDT: memory error at 0x%lx ignored.\n" "Rebuild kernel with CONFIG_MEMORY_FAILURE=y " "for real handling.\n", pde & PDT_ADDR_PHYS_MASK); #endif } } return 0; } static int __init pdt_initcall(void) { struct task_struct *kpdtd_task; if (pdt_type == PDT_NONE) return -ENODEV; kpdtd_task = kthread_create(pdt_mainloop, NULL, "kpdtd"); if (IS_ERR(kpdtd_task)) return PTR_ERR(kpdtd_task); wake_up_process(kpdtd_task); return 0; } late_initcall(pdt_initcall);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1