2 * UEFI Common Platform Error Record (CPER) support
4 * Copyright (C) 2010, Intel Corp.
5 * Author: Huang Ying <ying.huang@intel.com>
7 * CPER is the format used to describe platform hardware error by
8 * various APEI tables, such as ERST, BERT and HEST etc.
10 * For more information about CPER, please refer to Appendix N of UEFI
11 * Specification version 2.3.
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License version
15 * 2 as published by the Free Software Foundation.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/time.h>
30 #include <linux/cper.h>
31 #include <linux/acpi.h>
34 * CPER record ID need to be unique even after reboot, because record
35 * ID is used as index for ERST storage, while CPER records from
36 * multiple boot may co-exist in ERST.
38 u64 cper_next_record_id(void)
40 static atomic64_t seq;
42 if (!atomic64_read(&seq))
43 atomic64_set(&seq, ((u64)get_seconds()) << 32);
45 return atomic64_inc_return(&seq);
47 EXPORT_SYMBOL_GPL(cper_next_record_id);
49 static const char *cper_severity_strs[] = {
56 static const char *cper_severity_str(unsigned int severity)
58 return severity < ARRAY_SIZE(cper_severity_strs) ?
59 cper_severity_strs[severity] : "unknown";
63 * cper_print_bits - print strings for set bits
64 * @pfx: prefix for each line, including log level and prefix string
66 * @strs: string array, indexed by bit position
67 * @strs_size: size of the string array: @strs
69 * For each set bit in @bits, print the corresponding string in @strs.
70 * If the output length is longer than 80, multiple line will be
71 * printed, with @pfx is printed at the beginning of each line.
73 static void cper_print_bits(const char *pfx, unsigned int bits,
74 const char *strs[], unsigned int strs_size)
80 for (i = 0; i < strs_size; i++) {
81 if (!(bits & (1U << i)))
84 if (len && len + strlen(str) + 2 > 80) {
89 len = snprintf(buf, sizeof(buf), "%s%s", pfx, str);
91 len += snprintf(buf+len, sizeof(buf)-len, ", %s", str);
97 static const char *cper_proc_type_strs[] = {
102 static const char *cper_proc_isa_strs[] = {
108 static const char *cper_proc_error_type_strs[] = {
112 "micro-architectural error",
115 static const char *cper_proc_op_strs[] = {
116 "unknown or generic",
119 "instruction execution",
122 static const char *cper_proc_flag_strs[] = {
129 static void cper_print_proc_generic(const char *pfx,
130 const struct cper_sec_proc_generic *proc)
132 if (proc->validation_bits & CPER_PROC_VALID_TYPE)
133 printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type,
134 proc->proc_type < ARRAY_SIZE(cper_proc_type_strs) ?
135 cper_proc_type_strs[proc->proc_type] : "unknown");
136 if (proc->validation_bits & CPER_PROC_VALID_ISA)
137 printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa,
138 proc->proc_isa < ARRAY_SIZE(cper_proc_isa_strs) ?
139 cper_proc_isa_strs[proc->proc_isa] : "unknown");
140 if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) {
141 printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type);
142 cper_print_bits(pfx, proc->proc_error_type,
143 cper_proc_error_type_strs,
144 ARRAY_SIZE(cper_proc_error_type_strs));
146 if (proc->validation_bits & CPER_PROC_VALID_OPERATION)
147 printk("%s""operation: %d, %s\n", pfx, proc->operation,
148 proc->operation < ARRAY_SIZE(cper_proc_op_strs) ?
149 cper_proc_op_strs[proc->operation] : "unknown");
150 if (proc->validation_bits & CPER_PROC_VALID_FLAGS) {
151 printk("%s""flags: 0x%02x\n", pfx, proc->flags);
152 cper_print_bits(pfx, proc->flags, cper_proc_flag_strs,
153 ARRAY_SIZE(cper_proc_flag_strs));
155 if (proc->validation_bits & CPER_PROC_VALID_LEVEL)
156 printk("%s""level: %d\n", pfx, proc->level);
157 if (proc->validation_bits & CPER_PROC_VALID_VERSION)
158 printk("%s""version_info: 0x%016llx\n", pfx, proc->cpu_version);
159 if (proc->validation_bits & CPER_PROC_VALID_ID)
160 printk("%s""processor_id: 0x%016llx\n", pfx, proc->proc_id);
161 if (proc->validation_bits & CPER_PROC_VALID_TARGET_ADDRESS)
162 printk("%s""target_address: 0x%016llx\n",
163 pfx, proc->target_addr);
164 if (proc->validation_bits & CPER_PROC_VALID_REQUESTOR_ID)
165 printk("%s""requestor_id: 0x%016llx\n",
166 pfx, proc->requestor_id);
167 if (proc->validation_bits & CPER_PROC_VALID_RESPONDER_ID)
168 printk("%s""responder_id: 0x%016llx\n",
169 pfx, proc->responder_id);
170 if (proc->validation_bits & CPER_PROC_VALID_IP)
171 printk("%s""IP: 0x%016llx\n", pfx, proc->ip);
174 static const char *cper_mem_err_type_strs[] = {
179 "single-symbol chipkill ECC",
180 "multi-symbol chipkill ECC",
188 "scrub corrected error",
189 "scrub uncorrected error",
192 static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem)
194 if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS)
195 printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status);
196 if (mem->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS)
197 printk("%s""physical_address: 0x%016llx\n",
198 pfx, mem->physical_addr);
199 if (mem->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS_MASK)
200 printk("%s""physical_address_mask: 0x%016llx\n",
201 pfx, mem->physical_addr_mask);
202 if (mem->validation_bits & CPER_MEM_VALID_NODE)
203 printk("%s""node: %d\n", pfx, mem->node);
204 if (mem->validation_bits & CPER_MEM_VALID_CARD)
205 printk("%s""card: %d\n", pfx, mem->card);
206 if (mem->validation_bits & CPER_MEM_VALID_MODULE)
207 printk("%s""module: %d\n", pfx, mem->module);
208 if (mem->validation_bits & CPER_MEM_VALID_BANK)
209 printk("%s""bank: %d\n", pfx, mem->bank);
210 if (mem->validation_bits & CPER_MEM_VALID_DEVICE)
211 printk("%s""device: %d\n", pfx, mem->device);
212 if (mem->validation_bits & CPER_MEM_VALID_ROW)
213 printk("%s""row: %d\n", pfx, mem->row);
214 if (mem->validation_bits & CPER_MEM_VALID_COLUMN)
215 printk("%s""column: %d\n", pfx, mem->column);
216 if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION)
217 printk("%s""bit_position: %d\n", pfx, mem->bit_pos);
218 if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID)
219 printk("%s""requestor_id: 0x%016llx\n", pfx, mem->requestor_id);
220 if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID)
221 printk("%s""responder_id: 0x%016llx\n", pfx, mem->responder_id);
222 if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID)
223 printk("%s""target_id: 0x%016llx\n", pfx, mem->target_id);
224 if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) {
225 u8 etype = mem->error_type;
226 printk("%s""error_type: %d, %s\n", pfx, etype,
227 etype < ARRAY_SIZE(cper_mem_err_type_strs) ?
228 cper_mem_err_type_strs[etype] : "unknown");
232 static const char *cper_pcie_port_type_strs[] = {
234 "legacy PCI end point",
238 "upstream switch port",
239 "downstream switch port",
240 "PCIe to PCI/PCI-X bridge",
241 "PCI/PCI-X to PCIe bridge",
242 "root complex integrated endpoint device",
243 "root complex event collector",
246 static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie)
248 if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE)
249 printk("%s""port_type: %d, %s\n", pfx, pcie->port_type,
250 pcie->port_type < ARRAY_SIZE(cper_pcie_port_type_strs) ?
251 cper_pcie_port_type_strs[pcie->port_type] : "unknown");
252 if (pcie->validation_bits & CPER_PCIE_VALID_VERSION)
253 printk("%s""version: %d.%d\n", pfx,
254 pcie->version.major, pcie->version.minor);
255 if (pcie->validation_bits & CPER_PCIE_VALID_COMMAND_STATUS)
256 printk("%s""command: 0x%04x, status: 0x%04x\n", pfx,
257 pcie->command, pcie->status);
258 if (pcie->validation_bits & CPER_PCIE_VALID_DEVICE_ID) {
260 printk("%s""device_id: %04x:%02x:%02x.%x\n", pfx,
261 pcie->device_id.segment, pcie->device_id.bus,
262 pcie->device_id.device, pcie->device_id.function);
263 printk("%s""slot: %d\n", pfx,
264 pcie->device_id.slot >> CPER_PCIE_SLOT_SHIFT);
265 printk("%s""secondary_bus: 0x%02x\n", pfx,
266 pcie->device_id.secondary_bus);
267 printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx,
268 pcie->device_id.vendor_id, pcie->device_id.device_id);
269 p = pcie->device_id.class_code;
270 printk("%s""class_code: %02x%02x%02x\n", pfx, p[0], p[1], p[2]);
272 if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER)
273 printk("%s""serial number: 0x%04x, 0x%04x\n", pfx,
274 pcie->serial_number.lower, pcie->serial_number.upper);
275 if (pcie->validation_bits & CPER_PCIE_VALID_BRIDGE_CONTROL_STATUS)
277 "%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n",
278 pfx, pcie->bridge.secondary_status, pcie->bridge.control);
281 static const char *apei_estatus_section_flag_strs[] = {
283 "containment warning",
285 "threshold exceeded",
286 "resource not accessible",
290 static void apei_estatus_print_section(
291 const char *pfx, const struct acpi_hest_generic_data *gdata, int sec_no)
293 uuid_le *sec_type = (uuid_le *)gdata->section_type;
296 severity = gdata->error_severity;
297 printk("%s""section: %d, severity: %d, %s\n", pfx, sec_no, severity,
298 cper_severity_str(severity));
299 printk("%s""flags: 0x%02x\n", pfx, gdata->flags);
300 cper_print_bits(pfx, gdata->flags, apei_estatus_section_flag_strs,
301 ARRAY_SIZE(apei_estatus_section_flag_strs));
302 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID)
303 printk("%s""fru_id: %pUl\n", pfx, (uuid_le *)gdata->fru_id);
304 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT)
305 printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text);
307 if (!uuid_le_cmp(*sec_type, CPER_SEC_PROC_GENERIC)) {
308 struct cper_sec_proc_generic *proc_err = (void *)(gdata + 1);
309 printk("%s""section_type: general processor error\n", pfx);
310 if (gdata->error_data_length >= sizeof(*proc_err))
311 cper_print_proc_generic(pfx, proc_err);
313 goto err_section_too_small;
314 } else if (!uuid_le_cmp(*sec_type, CPER_SEC_PLATFORM_MEM)) {
315 struct cper_sec_mem_err *mem_err = (void *)(gdata + 1);
316 printk("%s""section_type: memory error\n", pfx);
317 if (gdata->error_data_length >= sizeof(*mem_err))
318 cper_print_mem(pfx, mem_err);
320 goto err_section_too_small;
321 } else if (!uuid_le_cmp(*sec_type, CPER_SEC_PCIE)) {
322 struct cper_sec_pcie *pcie = (void *)(gdata + 1);
323 printk("%s""section_type: PCIe error\n", pfx);
324 if (gdata->error_data_length >= sizeof(*pcie))
325 cper_print_pcie(pfx, pcie);
327 goto err_section_too_small;
329 printk("%s""section type: unknown, %pUl\n", pfx, sec_type);
333 err_section_too_small:
334 pr_err(FW_WARN "error section length is too small\n");
337 void apei_estatus_print(const char *pfx,
338 const struct acpi_hest_generic_status *estatus)
340 struct acpi_hest_generic_data *gdata;
341 unsigned int data_len, gedata_len;
345 printk("%s""APEI generic hardware error status\n", pfx);
346 severity = estatus->error_severity;
347 printk("%s""severity: %d, %s\n", pfx, severity,
348 cper_severity_str(severity));
349 data_len = estatus->data_length;
350 gdata = (struct acpi_hest_generic_data *)(estatus + 1);
351 while (data_len > sizeof(*gdata)) {
352 gedata_len = gdata->error_data_length;
353 apei_estatus_print_section(pfx, gdata, sec_no);
354 data_len -= gedata_len + sizeof(*gdata);
358 EXPORT_SYMBOL_GPL(apei_estatus_print);
360 int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus)
362 if (estatus->data_length &&
363 estatus->data_length < sizeof(struct acpi_hest_generic_data))
365 if (estatus->raw_data_length &&
366 estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length)
371 EXPORT_SYMBOL_GPL(apei_estatus_check_header);
373 int apei_estatus_check(const struct acpi_hest_generic_status *estatus)
375 struct acpi_hest_generic_data *gdata;
376 unsigned int data_len, gedata_len;
379 rc = apei_estatus_check_header(estatus);
382 data_len = estatus->data_length;
383 gdata = (struct acpi_hest_generic_data *)(estatus + 1);
384 while (data_len > sizeof(*gdata)) {
385 gedata_len = gdata->error_data_length;
386 if (gedata_len > data_len - sizeof(*gdata))
388 data_len -= gedata_len + sizeof(*gdata);
395 EXPORT_SYMBOL_GPL(apei_estatus_check);