1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * UEFI Common Platform Error Record (CPER) support 4 * 5 * Copyright (C) 2010, Intel Corp. 6 * Author: Huang Ying <ying.huang@intel.com> 7 * 8 * CPER is the format used to describe platform hardware error by 9 * various tables, such as ERST, BERT and HEST etc. 10 * 11 * For more information about CPER, please refer to Appendix N of UEFI 12 * Specification version 2.4. 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/time.h> 18 #include <linux/cper.h> 19 #include <linux/dmi.h> 20 #include <linux/acpi.h> 21 #include <linux/pci.h> 22 #include <linux/aer.h> 23 #include <linux/printk.h> 24 #include <linux/bcd.h> 25 #include <acpi/ghes.h> 26 #include <ras/ras_event.h> 27 28 /* 29 * CPER record ID need to be unique even after reboot, because record 30 * ID is used as index for ERST storage, while CPER records from 31 * multiple boot may co-exist in ERST. 32 */ 33 u64 cper_next_record_id(void) 34 { 35 static atomic64_t seq; 36 37 if (!atomic64_read(&seq)) { 38 time64_t time = ktime_get_real_seconds(); 39 40 /* 41 * This code is unlikely to still be needed in year 2106, 42 * but just in case, let's use a few more bits for timestamps 43 * after y2038 to be sure they keep increasing monotonically 44 * for the next few hundred years... 45 */ 46 if (time < 0x80000000) 47 atomic64_set(&seq, (ktime_get_real_seconds()) << 32); 48 else 49 atomic64_set(&seq, 0x8000000000000000ull | 50 ktime_get_real_seconds() << 24); 51 } 52 53 return atomic64_inc_return(&seq); 54 } 55 EXPORT_SYMBOL_GPL(cper_next_record_id); 56 57 static const char * const severity_strs[] = { 58 "recoverable", 59 "fatal", 60 "corrected", 61 "info", 62 }; 63 64 const char *cper_severity_str(unsigned int severity) 65 { 66 return severity < ARRAY_SIZE(severity_strs) ? 67 severity_strs[severity] : "unknown"; 68 } 69 EXPORT_SYMBOL_GPL(cper_severity_str); 70 71 /* 72 * cper_print_bits - print strings for set bits 73 * @pfx: prefix for each line, including log level and prefix string 74 * @bits: bit mask 75 * @strs: string array, indexed by bit position 76 * @strs_size: size of the string array: @strs 77 * 78 * For each set bit in @bits, print the corresponding string in @strs. 79 * If the output length is longer than 80, multiple line will be 80 * printed, with @pfx is printed at the beginning of each line. 81 */ 82 void cper_print_bits(const char *pfx, unsigned int bits, 83 const char * const strs[], unsigned int strs_size) 84 { 85 int i, len = 0; 86 const char *str; 87 char buf[84]; 88 89 for (i = 0; i < strs_size; i++) { 90 if (!(bits & (1U << i))) 91 continue; 92 str = strs[i]; 93 if (!str) 94 continue; 95 if (len && len + strlen(str) + 2 > 80) { 96 printk("%s\n", buf); 97 len = 0; 98 } 99 if (!len) 100 len = snprintf(buf, sizeof(buf), "%s%s", pfx, str); 101 else 102 len += scnprintf(buf+len, sizeof(buf)-len, ", %s", str); 103 } 104 if (len) 105 printk("%s\n", buf); 106 } 107 108 static const char * const proc_type_strs[] = { 109 "IA32/X64", 110 "IA64", 111 "ARM", 112 }; 113 114 static const char * const proc_isa_strs[] = { 115 "IA32", 116 "IA64", 117 "X64", 118 "ARM A32/T32", 119 "ARM A64", 120 }; 121 122 const char * const cper_proc_error_type_strs[] = { 123 "cache error", 124 "TLB error", 125 "bus error", 126 "micro-architectural error", 127 }; 128 129 static const char * const proc_op_strs[] = { 130 "unknown or generic", 131 "data read", 132 "data write", 133 "instruction execution", 134 }; 135 136 static const char * const proc_flag_strs[] = { 137 "restartable", 138 "precise IP", 139 "overflow", 140 "corrected", 141 }; 142 143 static void cper_print_proc_generic(const char *pfx, 144 const struct cper_sec_proc_generic *proc) 145 { 146 if (proc->validation_bits & CPER_PROC_VALID_TYPE) 147 printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type, 148 proc->proc_type < ARRAY_SIZE(proc_type_strs) ? 149 proc_type_strs[proc->proc_type] : "unknown"); 150 if (proc->validation_bits & CPER_PROC_VALID_ISA) 151 printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa, 152 proc->proc_isa < ARRAY_SIZE(proc_isa_strs) ? 153 proc_isa_strs[proc->proc_isa] : "unknown"); 154 if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) { 155 printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type); 156 cper_print_bits(pfx, proc->proc_error_type, 157 cper_proc_error_type_strs, 158 ARRAY_SIZE(cper_proc_error_type_strs)); 159 } 160 if (proc->validation_bits & CPER_PROC_VALID_OPERATION) 161 printk("%s""operation: %d, %s\n", pfx, proc->operation, 162 proc->operation < ARRAY_SIZE(proc_op_strs) ? 163 proc_op_strs[proc->operation] : "unknown"); 164 if (proc->validation_bits & CPER_PROC_VALID_FLAGS) { 165 printk("%s""flags: 0x%02x\n", pfx, proc->flags); 166 cper_print_bits(pfx, proc->flags, proc_flag_strs, 167 ARRAY_SIZE(proc_flag_strs)); 168 } 169 if (proc->validation_bits & CPER_PROC_VALID_LEVEL) 170 printk("%s""level: %d\n", pfx, proc->level); 171 if (proc->validation_bits & CPER_PROC_VALID_VERSION) 172 printk("%s""version_info: 0x%016llx\n", pfx, proc->cpu_version); 173 if (proc->validation_bits & CPER_PROC_VALID_ID) 174 printk("%s""processor_id: 0x%016llx\n", pfx, proc->proc_id); 175 if (proc->validation_bits & CPER_PROC_VALID_TARGET_ADDRESS) 176 printk("%s""target_address: 0x%016llx\n", 177 pfx, proc->target_addr); 178 if (proc->validation_bits & CPER_PROC_VALID_REQUESTOR_ID) 179 printk("%s""requestor_id: 0x%016llx\n", 180 pfx, proc->requestor_id); 181 if (proc->validation_bits & CPER_PROC_VALID_RESPONDER_ID) 182 printk("%s""responder_id: 0x%016llx\n", 183 pfx, proc->responder_id); 184 if (proc->validation_bits & CPER_PROC_VALID_IP) 185 printk("%s""IP: 0x%016llx\n", pfx, proc->ip); 186 } 187 188 static const char * const mem_err_type_strs[] = { 189 "unknown", 190 "no error", 191 "single-bit ECC", 192 "multi-bit ECC", 193 "single-symbol chipkill ECC", 194 "multi-symbol chipkill ECC", 195 "master abort", 196 "target abort", 197 "parity error", 198 "watchdog timeout", 199 "invalid address", 200 "mirror Broken", 201 "memory sparing", 202 "scrub corrected error", 203 "scrub uncorrected error", 204 "physical memory map-out event", 205 }; 206 207 const char *cper_mem_err_type_str(unsigned int etype) 208 { 209 return etype < ARRAY_SIZE(mem_err_type_strs) ? 210 mem_err_type_strs[etype] : "unknown"; 211 } 212 EXPORT_SYMBOL_GPL(cper_mem_err_type_str); 213 214 const char *cper_mem_err_status_str(u64 status) 215 { 216 switch ((status >> 8) & 0xff) { 217 case 1: return "Error detected internal to the component"; 218 case 4: return "Storage error in DRAM memory"; 219 case 5: return "Storage error in TLB"; 220 case 6: return "Storage error in cache"; 221 case 7: return "Error in one or more functional units"; 222 case 8: return "Component failed self test"; 223 case 9: return "Overflow or undervalue of internal queue"; 224 case 16: return "Error detected in the bus"; 225 case 17: return "Virtual address not found on IO-TLB or IO-PDIR"; 226 case 18: return "Improper access error"; 227 case 19: return "Access to a memory address which is not mapped to any component"; 228 case 20: return "Loss of Lockstep"; 229 case 21: return "Response not associated with a request"; 230 case 22: return "Bus parity error - must also set the A, C, or D Bits"; 231 case 23: return "Detection of a protocol error"; 232 case 24: return "Detection of a PATH_ERROR"; 233 case 25: return "Bus operation timeout"; 234 case 26: return "A read was issued to data that has been poisoned"; 235 default: return "Reserved"; 236 } 237 } 238 EXPORT_SYMBOL_GPL(cper_mem_err_status_str); 239 240 int cper_mem_err_location(struct cper_mem_err_compact *mem, char *msg) 241 { 242 u32 len, n; 243 244 if (!msg) 245 return 0; 246 247 n = 0; 248 len = CPER_REC_LEN; 249 if (mem->validation_bits & CPER_MEM_VALID_NODE) 250 n += scnprintf(msg + n, len - n, "node:%d ", mem->node); 251 if (mem->validation_bits & CPER_MEM_VALID_CARD) 252 n += scnprintf(msg + n, len - n, "card:%d ", mem->card); 253 if (mem->validation_bits & CPER_MEM_VALID_MODULE) 254 n += scnprintf(msg + n, len - n, "module:%d ", mem->module); 255 if (mem->validation_bits & CPER_MEM_VALID_RANK_NUMBER) 256 n += scnprintf(msg + n, len - n, "rank:%d ", mem->rank); 257 if (mem->validation_bits & CPER_MEM_VALID_BANK) 258 n += scnprintf(msg + n, len - n, "bank:%d ", mem->bank); 259 if (mem->validation_bits & CPER_MEM_VALID_BANK_GROUP) 260 n += scnprintf(msg + n, len - n, "bank_group:%d ", 261 mem->bank >> CPER_MEM_BANK_GROUP_SHIFT); 262 if (mem->validation_bits & CPER_MEM_VALID_BANK_ADDRESS) 263 n += scnprintf(msg + n, len - n, "bank_address:%d ", 264 mem->bank & CPER_MEM_BANK_ADDRESS_MASK); 265 if (mem->validation_bits & CPER_MEM_VALID_DEVICE) 266 n += scnprintf(msg + n, len - n, "device:%d ", mem->device); 267 if (mem->validation_bits & (CPER_MEM_VALID_ROW | CPER_MEM_VALID_ROW_EXT)) { 268 u32 row = mem->row; 269 270 row |= cper_get_mem_extension(mem->validation_bits, mem->extended); 271 n += scnprintf(msg + n, len - n, "row:%d ", row); 272 } 273 if (mem->validation_bits & CPER_MEM_VALID_COLUMN) 274 n += scnprintf(msg + n, len - n, "column:%d ", mem->column); 275 if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION) 276 n += scnprintf(msg + n, len - n, "bit_position:%d ", 277 mem->bit_pos); 278 if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID) 279 n += scnprintf(msg + n, len - n, "requestor_id:0x%016llx ", 280 mem->requestor_id); 281 if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID) 282 n += scnprintf(msg + n, len - n, "responder_id:0x%016llx ", 283 mem->responder_id); 284 if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID) 285 n += scnprintf(msg + n, len - n, "target_id:0x%016llx ", 286 mem->target_id); 287 if (mem->validation_bits & CPER_MEM_VALID_CHIP_ID) 288 n += scnprintf(msg + n, len - n, "chip_id:%d ", 289 mem->extended >> CPER_MEM_CHIP_ID_SHIFT); 290 291 return n; 292 } 293 294 int cper_dimm_err_location(struct cper_mem_err_compact *mem, char *msg) 295 { 296 u32 len, n; 297 const char *bank = NULL, *device = NULL; 298 299 if (!msg || !(mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE)) 300 return 0; 301 302 len = CPER_REC_LEN; 303 dmi_memdev_name(mem->mem_dev_handle, &bank, &device); 304 if (bank && device) 305 n = snprintf(msg, len, "DIMM location: %s %s ", bank, device); 306 else 307 n = snprintf(msg, len, 308 "DIMM location: not present. DMI handle: 0x%.4x ", 309 mem->mem_dev_handle); 310 311 return n; 312 } 313 314 void cper_mem_err_pack(const struct cper_sec_mem_err *mem, 315 struct cper_mem_err_compact *cmem) 316 { 317 cmem->validation_bits = mem->validation_bits; 318 cmem->node = mem->node; 319 cmem->card = mem->card; 320 cmem->module = mem->module; 321 cmem->bank = mem->bank; 322 cmem->device = mem->device; 323 cmem->row = mem->row; 324 cmem->column = mem->column; 325 cmem->bit_pos = mem->bit_pos; 326 cmem->requestor_id = mem->requestor_id; 327 cmem->responder_id = mem->responder_id; 328 cmem->target_id = mem->target_id; 329 cmem->extended = mem->extended; 330 cmem->rank = mem->rank; 331 cmem->mem_array_handle = mem->mem_array_handle; 332 cmem->mem_dev_handle = mem->mem_dev_handle; 333 } 334 335 const char *cper_mem_err_unpack(struct trace_seq *p, 336 struct cper_mem_err_compact *cmem) 337 { 338 const char *ret = trace_seq_buffer_ptr(p); 339 char rcd_decode_str[CPER_REC_LEN]; 340 341 if (cper_mem_err_location(cmem, rcd_decode_str)) 342 trace_seq_printf(p, "%s", rcd_decode_str); 343 if (cper_dimm_err_location(cmem, rcd_decode_str)) 344 trace_seq_printf(p, "%s", rcd_decode_str); 345 trace_seq_putc(p, '\0'); 346 347 return ret; 348 } 349 350 static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem, 351 int len) 352 { 353 struct cper_mem_err_compact cmem; 354 char rcd_decode_str[CPER_REC_LEN]; 355 356 /* Don't trust UEFI 2.1/2.2 structure with bad validation bits */ 357 if (len == sizeof(struct cper_sec_mem_err_old) && 358 (mem->validation_bits & ~(CPER_MEM_VALID_RANK_NUMBER - 1))) { 359 pr_err(FW_WARN "valid bits set for fields beyond structure\n"); 360 return; 361 } 362 if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS) 363 printk("%s error_status: %s (0x%016llx)\n", 364 pfx, cper_mem_err_status_str(mem->error_status), 365 mem->error_status); 366 if (mem->validation_bits & CPER_MEM_VALID_PA) 367 printk("%s""physical_address: 0x%016llx\n", 368 pfx, mem->physical_addr); 369 if (mem->validation_bits & CPER_MEM_VALID_PA_MASK) 370 printk("%s""physical_address_mask: 0x%016llx\n", 371 pfx, mem->physical_addr_mask); 372 cper_mem_err_pack(mem, &cmem); 373 if (cper_mem_err_location(&cmem, rcd_decode_str)) 374 printk("%s%s\n", pfx, rcd_decode_str); 375 if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) { 376 u8 etype = mem->error_type; 377 printk("%s""error_type: %d, %s\n", pfx, etype, 378 cper_mem_err_type_str(etype)); 379 } 380 if (cper_dimm_err_location(&cmem, rcd_decode_str)) 381 printk("%s%s\n", pfx, rcd_decode_str); 382 } 383 384 static const char * const pcie_port_type_strs[] = { 385 "PCIe end point", 386 "legacy PCI end point", 387 "unknown", 388 "unknown", 389 "root port", 390 "upstream switch port", 391 "downstream switch port", 392 "PCIe to PCI/PCI-X bridge", 393 "PCI/PCI-X to PCIe bridge", 394 "root complex integrated endpoint device", 395 "root complex event collector", 396 }; 397 398 static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie, 399 const struct acpi_hest_generic_data *gdata) 400 { 401 if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE) 402 printk("%s""port_type: %d, %s\n", pfx, pcie->port_type, 403 pcie->port_type < ARRAY_SIZE(pcie_port_type_strs) ? 404 pcie_port_type_strs[pcie->port_type] : "unknown"); 405 if (pcie->validation_bits & CPER_PCIE_VALID_VERSION) 406 printk("%s""version: %d.%d\n", pfx, 407 pcie->version.major, pcie->version.minor); 408 if (pcie->validation_bits & CPER_PCIE_VALID_COMMAND_STATUS) 409 printk("%s""command: 0x%04x, status: 0x%04x\n", pfx, 410 pcie->command, pcie->status); 411 if (pcie->validation_bits & CPER_PCIE_VALID_DEVICE_ID) { 412 const __u8 *p; 413 printk("%s""device_id: %04x:%02x:%02x.%x\n", pfx, 414 pcie->device_id.segment, pcie->device_id.bus, 415 pcie->device_id.device, pcie->device_id.function); 416 printk("%s""slot: %d\n", pfx, 417 pcie->device_id.slot >> CPER_PCIE_SLOT_SHIFT); 418 printk("%s""secondary_bus: 0x%02x\n", pfx, 419 pcie->device_id.secondary_bus); 420 printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx, 421 pcie->device_id.vendor_id, pcie->device_id.device_id); 422 p = pcie->device_id.class_code; 423 printk("%s""class_code: %02x%02x%02x\n", pfx, p[2], p[1], p[0]); 424 } 425 if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER) 426 printk("%s""serial number: 0x%04x, 0x%04x\n", pfx, 427 pcie->serial_number.lower, pcie->serial_number.upper); 428 if (pcie->validation_bits & CPER_PCIE_VALID_BRIDGE_CONTROL_STATUS) 429 printk( 430 "%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n", 431 pfx, pcie->bridge.secondary_status, pcie->bridge.control); 432 433 /* Fatal errors call __ghes_panic() before AER handler prints this */ 434 if ((pcie->validation_bits & CPER_PCIE_VALID_AER_INFO) && 435 (gdata->error_severity & CPER_SEV_FATAL)) { 436 struct aer_capability_regs *aer; 437 438 aer = (struct aer_capability_regs *)pcie->aer_info; 439 printk("%saer_uncor_status: 0x%08x, aer_uncor_mask: 0x%08x\n", 440 pfx, aer->uncor_status, aer->uncor_mask); 441 printk("%saer_uncor_severity: 0x%08x\n", 442 pfx, aer->uncor_severity); 443 printk("%sTLP Header: %08x %08x %08x %08x\n", pfx, 444 aer->header_log.dw0, aer->header_log.dw1, 445 aer->header_log.dw2, aer->header_log.dw3); 446 } 447 } 448 449 static const char * const fw_err_rec_type_strs[] = { 450 "IPF SAL Error Record", 451 "SOC Firmware Error Record Type1 (Legacy CrashLog Support)", 452 "SOC Firmware Error Record Type2", 453 }; 454 455 static void cper_print_fw_err(const char *pfx, 456 struct acpi_hest_generic_data *gdata, 457 const struct cper_sec_fw_err_rec_ref *fw_err) 458 { 459 void *buf = acpi_hest_get_payload(gdata); 460 u32 offset, length = gdata->error_data_length; 461 462 printk("%s""Firmware Error Record Type: %s\n", pfx, 463 fw_err->record_type < ARRAY_SIZE(fw_err_rec_type_strs) ? 464 fw_err_rec_type_strs[fw_err->record_type] : "unknown"); 465 printk("%s""Revision: %d\n", pfx, fw_err->revision); 466 467 /* Record Type based on UEFI 2.7 */ 468 if (fw_err->revision == 0) { 469 printk("%s""Record Identifier: %08llx\n", pfx, 470 fw_err->record_identifier); 471 } else if (fw_err->revision == 2) { 472 printk("%s""Record Identifier: %pUl\n", pfx, 473 &fw_err->record_identifier_guid); 474 } 475 476 /* 477 * The FW error record may contain trailing data beyond the 478 * structure defined by the specification. As the fields 479 * defined (and hence the offset of any trailing data) vary 480 * with the revision, set the offset to account for this 481 * variation. 482 */ 483 if (fw_err->revision == 0) { 484 /* record_identifier_guid not defined */ 485 offset = offsetof(struct cper_sec_fw_err_rec_ref, 486 record_identifier_guid); 487 } else if (fw_err->revision == 1) { 488 /* record_identifier not defined */ 489 offset = offsetof(struct cper_sec_fw_err_rec_ref, 490 record_identifier); 491 } else { 492 offset = sizeof(*fw_err); 493 } 494 495 buf += offset; 496 length -= offset; 497 498 print_hex_dump(pfx, "", DUMP_PREFIX_OFFSET, 16, 4, buf, length, true); 499 } 500 501 static void cper_print_tstamp(const char *pfx, 502 struct acpi_hest_generic_data_v300 *gdata) 503 { 504 __u8 hour, min, sec, day, mon, year, century, *timestamp; 505 506 if (gdata->validation_bits & ACPI_HEST_GEN_VALID_TIMESTAMP) { 507 timestamp = (__u8 *)&(gdata->time_stamp); 508 sec = bcd2bin(timestamp[0]); 509 min = bcd2bin(timestamp[1]); 510 hour = bcd2bin(timestamp[2]); 511 day = bcd2bin(timestamp[4]); 512 mon = bcd2bin(timestamp[5]); 513 year = bcd2bin(timestamp[6]); 514 century = bcd2bin(timestamp[7]); 515 516 printk("%s%ststamp: %02d%02d-%02d-%02d %02d:%02d:%02d\n", pfx, 517 (timestamp[3] & 0x1 ? "precise " : "imprecise "), 518 century, year, mon, day, hour, min, sec); 519 } 520 } 521 522 static void 523 cper_estatus_print_section(const char *pfx, struct acpi_hest_generic_data *gdata, 524 int sec_no) 525 { 526 guid_t *sec_type = (guid_t *)gdata->section_type; 527 __u16 severity; 528 char newpfx[64]; 529 530 if (acpi_hest_get_version(gdata) >= 3) 531 cper_print_tstamp(pfx, (struct acpi_hest_generic_data_v300 *)gdata); 532 533 severity = gdata->error_severity; 534 printk("%s""Error %d, type: %s\n", pfx, sec_no, 535 cper_severity_str(severity)); 536 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID) 537 printk("%s""fru_id: %pUl\n", pfx, gdata->fru_id); 538 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT) 539 printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text); 540 541 snprintf(newpfx, sizeof(newpfx), "%s ", pfx); 542 if (guid_equal(sec_type, &CPER_SEC_PROC_GENERIC)) { 543 struct cper_sec_proc_generic *proc_err = acpi_hest_get_payload(gdata); 544 545 printk("%s""section_type: general processor error\n", newpfx); 546 if (gdata->error_data_length >= sizeof(*proc_err)) 547 cper_print_proc_generic(newpfx, proc_err); 548 else 549 goto err_section_too_small; 550 } else if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) { 551 struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); 552 553 printk("%s""section_type: memory error\n", newpfx); 554 if (gdata->error_data_length >= 555 sizeof(struct cper_sec_mem_err_old)) 556 cper_print_mem(newpfx, mem_err, 557 gdata->error_data_length); 558 else 559 goto err_section_too_small; 560 } else if (guid_equal(sec_type, &CPER_SEC_PCIE)) { 561 struct cper_sec_pcie *pcie = acpi_hest_get_payload(gdata); 562 563 printk("%s""section_type: PCIe error\n", newpfx); 564 if (gdata->error_data_length >= sizeof(*pcie)) 565 cper_print_pcie(newpfx, pcie, gdata); 566 else 567 goto err_section_too_small; 568 #if defined(CONFIG_ARM64) || defined(CONFIG_ARM) 569 } else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) { 570 struct cper_sec_proc_arm *arm_err = acpi_hest_get_payload(gdata); 571 572 printk("%ssection_type: ARM processor error\n", newpfx); 573 if (gdata->error_data_length >= sizeof(*arm_err)) 574 cper_print_proc_arm(newpfx, arm_err); 575 else 576 goto err_section_too_small; 577 #endif 578 #if defined(CONFIG_UEFI_CPER_X86) 579 } else if (guid_equal(sec_type, &CPER_SEC_PROC_IA)) { 580 struct cper_sec_proc_ia *ia_err = acpi_hest_get_payload(gdata); 581 582 printk("%ssection_type: IA32/X64 processor error\n", newpfx); 583 if (gdata->error_data_length >= sizeof(*ia_err)) 584 cper_print_proc_ia(newpfx, ia_err); 585 else 586 goto err_section_too_small; 587 #endif 588 } else if (guid_equal(sec_type, &CPER_SEC_FW_ERR_REC_REF)) { 589 struct cper_sec_fw_err_rec_ref *fw_err = acpi_hest_get_payload(gdata); 590 591 printk("%ssection_type: Firmware Error Record Reference\n", 592 newpfx); 593 /* The minimal FW Error Record contains 16 bytes */ 594 if (gdata->error_data_length >= SZ_16) 595 cper_print_fw_err(newpfx, gdata, fw_err); 596 else 597 goto err_section_too_small; 598 } else { 599 const void *err = acpi_hest_get_payload(gdata); 600 601 printk("%ssection type: unknown, %pUl\n", newpfx, sec_type); 602 printk("%ssection length: %#x\n", newpfx, 603 gdata->error_data_length); 604 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, err, 605 gdata->error_data_length, true); 606 } 607 608 return; 609 610 err_section_too_small: 611 pr_err(FW_WARN "error section length is too small\n"); 612 } 613 614 void cper_estatus_print(const char *pfx, 615 const struct acpi_hest_generic_status *estatus) 616 { 617 struct acpi_hest_generic_data *gdata; 618 int sec_no = 0; 619 char newpfx[64]; 620 __u16 severity; 621 622 severity = estatus->error_severity; 623 if (severity == CPER_SEV_CORRECTED) 624 printk("%s%s\n", pfx, 625 "It has been corrected by h/w " 626 "and requires no further action"); 627 printk("%s""event severity: %s\n", pfx, cper_severity_str(severity)); 628 snprintf(newpfx, sizeof(newpfx), "%s ", pfx); 629 630 apei_estatus_for_each_section(estatus, gdata) { 631 cper_estatus_print_section(newpfx, gdata, sec_no); 632 sec_no++; 633 } 634 } 635 EXPORT_SYMBOL_GPL(cper_estatus_print); 636 637 int cper_estatus_check_header(const struct acpi_hest_generic_status *estatus) 638 { 639 if (estatus->data_length && 640 estatus->data_length < sizeof(struct acpi_hest_generic_data)) 641 return -EINVAL; 642 if (estatus->raw_data_length && 643 estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length) 644 return -EINVAL; 645 646 return 0; 647 } 648 EXPORT_SYMBOL_GPL(cper_estatus_check_header); 649 650 int cper_estatus_check(const struct acpi_hest_generic_status *estatus) 651 { 652 struct acpi_hest_generic_data *gdata; 653 unsigned int data_len, record_size; 654 int rc; 655 656 rc = cper_estatus_check_header(estatus); 657 if (rc) 658 return rc; 659 660 data_len = estatus->data_length; 661 662 apei_estatus_for_each_section(estatus, gdata) { 663 if (acpi_hest_get_size(gdata) > data_len) 664 return -EINVAL; 665 666 record_size = acpi_hest_get_record_size(gdata); 667 if (record_size > data_len) 668 return -EINVAL; 669 670 data_len -= record_size; 671 } 672 if (data_len) 673 return -EINVAL; 674 675 return 0; 676 } 677 EXPORT_SYMBOL_GPL(cper_estatus_check); 678