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 static char rcd_decode_str[CPER_REC_LEN]; 29 30 /* 31 * CPER record ID need to be unique even after reboot, because record 32 * ID is used as index for ERST storage, while CPER records from 33 * multiple boot may co-exist in ERST. 34 */ 35 u64 cper_next_record_id(void) 36 { 37 static atomic64_t seq; 38 39 if (!atomic64_read(&seq)) { 40 time64_t time = ktime_get_real_seconds(); 41 42 /* 43 * This code is unlikely to still be needed in year 2106, 44 * but just in case, let's use a few more bits for timestamps 45 * after y2038 to be sure they keep increasing monotonically 46 * for the next few hundred years... 47 */ 48 if (time < 0x80000000) 49 atomic64_set(&seq, (ktime_get_real_seconds()) << 32); 50 else 51 atomic64_set(&seq, 0x8000000000000000ull | 52 ktime_get_real_seconds() << 24); 53 } 54 55 return atomic64_inc_return(&seq); 56 } 57 EXPORT_SYMBOL_GPL(cper_next_record_id); 58 59 static const char * const severity_strs[] = { 60 "recoverable", 61 "fatal", 62 "corrected", 63 "info", 64 }; 65 66 const char *cper_severity_str(unsigned int severity) 67 { 68 return severity < ARRAY_SIZE(severity_strs) ? 69 severity_strs[severity] : "unknown"; 70 } 71 EXPORT_SYMBOL_GPL(cper_severity_str); 72 73 /* 74 * cper_print_bits - print strings for set bits 75 * @pfx: prefix for each line, including log level and prefix string 76 * @bits: bit mask 77 * @strs: string array, indexed by bit position 78 * @strs_size: size of the string array: @strs 79 * 80 * For each set bit in @bits, print the corresponding string in @strs. 81 * If the output length is longer than 80, multiple line will be 82 * printed, with @pfx is printed at the beginning of each line. 83 */ 84 void cper_print_bits(const char *pfx, unsigned int bits, 85 const char * const strs[], unsigned int strs_size) 86 { 87 int i, len = 0; 88 const char *str; 89 char buf[84]; 90 91 for (i = 0; i < strs_size; i++) { 92 if (!(bits & (1U << i))) 93 continue; 94 str = strs[i]; 95 if (!str) 96 continue; 97 if (len && len + strlen(str) + 2 > 80) { 98 printk("%s\n", buf); 99 len = 0; 100 } 101 if (!len) 102 len = snprintf(buf, sizeof(buf), "%s%s", pfx, str); 103 else 104 len += snprintf(buf+len, sizeof(buf)-len, ", %s", str); 105 } 106 if (len) 107 printk("%s\n", buf); 108 } 109 110 static const char * const proc_type_strs[] = { 111 "IA32/X64", 112 "IA64", 113 "ARM", 114 }; 115 116 static const char * const proc_isa_strs[] = { 117 "IA32", 118 "IA64", 119 "X64", 120 "ARM A32/T32", 121 "ARM A64", 122 }; 123 124 const char * const cper_proc_error_type_strs[] = { 125 "cache error", 126 "TLB error", 127 "bus error", 128 "micro-architectural error", 129 }; 130 131 static const char * const proc_op_strs[] = { 132 "unknown or generic", 133 "data read", 134 "data write", 135 "instruction execution", 136 }; 137 138 static const char * const proc_flag_strs[] = { 139 "restartable", 140 "precise IP", 141 "overflow", 142 "corrected", 143 }; 144 145 static void cper_print_proc_generic(const char *pfx, 146 const struct cper_sec_proc_generic *proc) 147 { 148 if (proc->validation_bits & CPER_PROC_VALID_TYPE) 149 printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type, 150 proc->proc_type < ARRAY_SIZE(proc_type_strs) ? 151 proc_type_strs[proc->proc_type] : "unknown"); 152 if (proc->validation_bits & CPER_PROC_VALID_ISA) 153 printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa, 154 proc->proc_isa < ARRAY_SIZE(proc_isa_strs) ? 155 proc_isa_strs[proc->proc_isa] : "unknown"); 156 if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) { 157 printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type); 158 cper_print_bits(pfx, proc->proc_error_type, 159 cper_proc_error_type_strs, 160 ARRAY_SIZE(cper_proc_error_type_strs)); 161 } 162 if (proc->validation_bits & CPER_PROC_VALID_OPERATION) 163 printk("%s""operation: %d, %s\n", pfx, proc->operation, 164 proc->operation < ARRAY_SIZE(proc_op_strs) ? 165 proc_op_strs[proc->operation] : "unknown"); 166 if (proc->validation_bits & CPER_PROC_VALID_FLAGS) { 167 printk("%s""flags: 0x%02x\n", pfx, proc->flags); 168 cper_print_bits(pfx, proc->flags, proc_flag_strs, 169 ARRAY_SIZE(proc_flag_strs)); 170 } 171 if (proc->validation_bits & CPER_PROC_VALID_LEVEL) 172 printk("%s""level: %d\n", pfx, proc->level); 173 if (proc->validation_bits & CPER_PROC_VALID_VERSION) 174 printk("%s""version_info: 0x%016llx\n", pfx, proc->cpu_version); 175 if (proc->validation_bits & CPER_PROC_VALID_ID) 176 printk("%s""processor_id: 0x%016llx\n", pfx, proc->proc_id); 177 if (proc->validation_bits & CPER_PROC_VALID_TARGET_ADDRESS) 178 printk("%s""target_address: 0x%016llx\n", 179 pfx, proc->target_addr); 180 if (proc->validation_bits & CPER_PROC_VALID_REQUESTOR_ID) 181 printk("%s""requestor_id: 0x%016llx\n", 182 pfx, proc->requestor_id); 183 if (proc->validation_bits & CPER_PROC_VALID_RESPONDER_ID) 184 printk("%s""responder_id: 0x%016llx\n", 185 pfx, proc->responder_id); 186 if (proc->validation_bits & CPER_PROC_VALID_IP) 187 printk("%s""IP: 0x%016llx\n", pfx, proc->ip); 188 } 189 190 static const char * const mem_err_type_strs[] = { 191 "unknown", 192 "no error", 193 "single-bit ECC", 194 "multi-bit ECC", 195 "single-symbol chipkill ECC", 196 "multi-symbol chipkill ECC", 197 "master abort", 198 "target abort", 199 "parity error", 200 "watchdog timeout", 201 "invalid address", 202 "mirror Broken", 203 "memory sparing", 204 "scrub corrected error", 205 "scrub uncorrected error", 206 "physical memory map-out event", 207 }; 208 209 const char *cper_mem_err_type_str(unsigned int etype) 210 { 211 return etype < ARRAY_SIZE(mem_err_type_strs) ? 212 mem_err_type_strs[etype] : "unknown"; 213 } 214 EXPORT_SYMBOL_GPL(cper_mem_err_type_str); 215 216 static int cper_mem_err_location(struct cper_mem_err_compact *mem, char *msg) 217 { 218 u32 len, n; 219 220 if (!msg) 221 return 0; 222 223 n = 0; 224 len = CPER_REC_LEN - 1; 225 if (mem->validation_bits & CPER_MEM_VALID_NODE) 226 n += scnprintf(msg + n, len - n, "node: %d ", mem->node); 227 if (mem->validation_bits & CPER_MEM_VALID_CARD) 228 n += scnprintf(msg + n, len - n, "card: %d ", mem->card); 229 if (mem->validation_bits & CPER_MEM_VALID_MODULE) 230 n += scnprintf(msg + n, len - n, "module: %d ", mem->module); 231 if (mem->validation_bits & CPER_MEM_VALID_RANK_NUMBER) 232 n += scnprintf(msg + n, len - n, "rank: %d ", mem->rank); 233 if (mem->validation_bits & CPER_MEM_VALID_BANK) 234 n += scnprintf(msg + n, len - n, "bank: %d ", mem->bank); 235 if (mem->validation_bits & CPER_MEM_VALID_DEVICE) 236 n += scnprintf(msg + n, len - n, "device: %d ", mem->device); 237 if (mem->validation_bits & CPER_MEM_VALID_ROW) 238 n += scnprintf(msg + n, len - n, "row: %d ", mem->row); 239 if (mem->validation_bits & CPER_MEM_VALID_COLUMN) 240 n += scnprintf(msg + n, len - n, "column: %d ", mem->column); 241 if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION) 242 n += scnprintf(msg + n, len - n, "bit_position: %d ", 243 mem->bit_pos); 244 if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID) 245 n += scnprintf(msg + n, len - n, "requestor_id: 0x%016llx ", 246 mem->requestor_id); 247 if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID) 248 n += scnprintf(msg + n, len - n, "responder_id: 0x%016llx ", 249 mem->responder_id); 250 if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID) 251 scnprintf(msg + n, len - n, "target_id: 0x%016llx ", 252 mem->target_id); 253 254 msg[n] = '\0'; 255 return n; 256 } 257 258 static int cper_dimm_err_location(struct cper_mem_err_compact *mem, char *msg) 259 { 260 u32 len, n; 261 const char *bank = NULL, *device = NULL; 262 263 if (!msg || !(mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE)) 264 return 0; 265 266 n = 0; 267 len = CPER_REC_LEN - 1; 268 dmi_memdev_name(mem->mem_dev_handle, &bank, &device); 269 if (bank && device) 270 n = snprintf(msg, len, "DIMM location: %s %s ", bank, device); 271 else 272 n = snprintf(msg, len, 273 "DIMM location: not present. DMI handle: 0x%.4x ", 274 mem->mem_dev_handle); 275 276 msg[n] = '\0'; 277 return n; 278 } 279 280 void cper_mem_err_pack(const struct cper_sec_mem_err *mem, 281 struct cper_mem_err_compact *cmem) 282 { 283 cmem->validation_bits = mem->validation_bits; 284 cmem->node = mem->node; 285 cmem->card = mem->card; 286 cmem->module = mem->module; 287 cmem->bank = mem->bank; 288 cmem->device = mem->device; 289 cmem->row = mem->row; 290 cmem->column = mem->column; 291 cmem->bit_pos = mem->bit_pos; 292 cmem->requestor_id = mem->requestor_id; 293 cmem->responder_id = mem->responder_id; 294 cmem->target_id = mem->target_id; 295 cmem->rank = mem->rank; 296 cmem->mem_array_handle = mem->mem_array_handle; 297 cmem->mem_dev_handle = mem->mem_dev_handle; 298 } 299 300 const char *cper_mem_err_unpack(struct trace_seq *p, 301 struct cper_mem_err_compact *cmem) 302 { 303 const char *ret = trace_seq_buffer_ptr(p); 304 305 if (cper_mem_err_location(cmem, rcd_decode_str)) 306 trace_seq_printf(p, "%s", rcd_decode_str); 307 if (cper_dimm_err_location(cmem, rcd_decode_str)) 308 trace_seq_printf(p, "%s", rcd_decode_str); 309 trace_seq_putc(p, '\0'); 310 311 return ret; 312 } 313 314 static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem, 315 int len) 316 { 317 struct cper_mem_err_compact cmem; 318 319 /* Don't trust UEFI 2.1/2.2 structure with bad validation bits */ 320 if (len == sizeof(struct cper_sec_mem_err_old) && 321 (mem->validation_bits & ~(CPER_MEM_VALID_RANK_NUMBER - 1))) { 322 pr_err(FW_WARN "valid bits set for fields beyond structure\n"); 323 return; 324 } 325 if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS) 326 printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status); 327 if (mem->validation_bits & CPER_MEM_VALID_PA) 328 printk("%s""physical_address: 0x%016llx\n", 329 pfx, mem->physical_addr); 330 if (mem->validation_bits & CPER_MEM_VALID_PA_MASK) 331 printk("%s""physical_address_mask: 0x%016llx\n", 332 pfx, mem->physical_addr_mask); 333 cper_mem_err_pack(mem, &cmem); 334 if (cper_mem_err_location(&cmem, rcd_decode_str)) 335 printk("%s%s\n", pfx, rcd_decode_str); 336 if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) { 337 u8 etype = mem->error_type; 338 printk("%s""error_type: %d, %s\n", pfx, etype, 339 cper_mem_err_type_str(etype)); 340 } 341 if (cper_dimm_err_location(&cmem, rcd_decode_str)) 342 printk("%s%s\n", pfx, rcd_decode_str); 343 } 344 345 static const char * const pcie_port_type_strs[] = { 346 "PCIe end point", 347 "legacy PCI end point", 348 "unknown", 349 "unknown", 350 "root port", 351 "upstream switch port", 352 "downstream switch port", 353 "PCIe to PCI/PCI-X bridge", 354 "PCI/PCI-X to PCIe bridge", 355 "root complex integrated endpoint device", 356 "root complex event collector", 357 }; 358 359 static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie, 360 const struct acpi_hest_generic_data *gdata) 361 { 362 if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE) 363 printk("%s""port_type: %d, %s\n", pfx, pcie->port_type, 364 pcie->port_type < ARRAY_SIZE(pcie_port_type_strs) ? 365 pcie_port_type_strs[pcie->port_type] : "unknown"); 366 if (pcie->validation_bits & CPER_PCIE_VALID_VERSION) 367 printk("%s""version: %d.%d\n", pfx, 368 pcie->version.major, pcie->version.minor); 369 if (pcie->validation_bits & CPER_PCIE_VALID_COMMAND_STATUS) 370 printk("%s""command: 0x%04x, status: 0x%04x\n", pfx, 371 pcie->command, pcie->status); 372 if (pcie->validation_bits & CPER_PCIE_VALID_DEVICE_ID) { 373 const __u8 *p; 374 printk("%s""device_id: %04x:%02x:%02x.%x\n", pfx, 375 pcie->device_id.segment, pcie->device_id.bus, 376 pcie->device_id.device, pcie->device_id.function); 377 printk("%s""slot: %d\n", pfx, 378 pcie->device_id.slot >> CPER_PCIE_SLOT_SHIFT); 379 printk("%s""secondary_bus: 0x%02x\n", pfx, 380 pcie->device_id.secondary_bus); 381 printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx, 382 pcie->device_id.vendor_id, pcie->device_id.device_id); 383 p = pcie->device_id.class_code; 384 printk("%s""class_code: %02x%02x%02x\n", pfx, p[0], p[1], p[2]); 385 } 386 if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER) 387 printk("%s""serial number: 0x%04x, 0x%04x\n", pfx, 388 pcie->serial_number.lower, pcie->serial_number.upper); 389 if (pcie->validation_bits & CPER_PCIE_VALID_BRIDGE_CONTROL_STATUS) 390 printk( 391 "%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n", 392 pfx, pcie->bridge.secondary_status, pcie->bridge.control); 393 394 /* Fatal errors call __ghes_panic() before AER handler prints this */ 395 if ((pcie->validation_bits & CPER_PCIE_VALID_AER_INFO) && 396 (gdata->error_severity & CPER_SEV_FATAL)) { 397 struct aer_capability_regs *aer; 398 399 aer = (struct aer_capability_regs *)pcie->aer_info; 400 printk("%saer_uncor_status: 0x%08x, aer_uncor_mask: 0x%08x\n", 401 pfx, aer->uncor_status, aer->uncor_mask); 402 printk("%saer_uncor_severity: 0x%08x\n", 403 pfx, aer->uncor_severity); 404 printk("%sTLP Header: %08x %08x %08x %08x\n", pfx, 405 aer->header_log.dw0, aer->header_log.dw1, 406 aer->header_log.dw2, aer->header_log.dw3); 407 } 408 } 409 410 static void cper_print_tstamp(const char *pfx, 411 struct acpi_hest_generic_data_v300 *gdata) 412 { 413 __u8 hour, min, sec, day, mon, year, century, *timestamp; 414 415 if (gdata->validation_bits & ACPI_HEST_GEN_VALID_TIMESTAMP) { 416 timestamp = (__u8 *)&(gdata->time_stamp); 417 sec = bcd2bin(timestamp[0]); 418 min = bcd2bin(timestamp[1]); 419 hour = bcd2bin(timestamp[2]); 420 day = bcd2bin(timestamp[4]); 421 mon = bcd2bin(timestamp[5]); 422 year = bcd2bin(timestamp[6]); 423 century = bcd2bin(timestamp[7]); 424 425 printk("%s%ststamp: %02d%02d-%02d-%02d %02d:%02d:%02d\n", pfx, 426 (timestamp[3] & 0x1 ? "precise " : "imprecise "), 427 century, year, mon, day, hour, min, sec); 428 } 429 } 430 431 static void 432 cper_estatus_print_section(const char *pfx, struct acpi_hest_generic_data *gdata, 433 int sec_no) 434 { 435 guid_t *sec_type = (guid_t *)gdata->section_type; 436 __u16 severity; 437 char newpfx[64]; 438 439 if (acpi_hest_get_version(gdata) >= 3) 440 cper_print_tstamp(pfx, (struct acpi_hest_generic_data_v300 *)gdata); 441 442 severity = gdata->error_severity; 443 printk("%s""Error %d, type: %s\n", pfx, sec_no, 444 cper_severity_str(severity)); 445 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID) 446 printk("%s""fru_id: %pUl\n", pfx, gdata->fru_id); 447 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT) 448 printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text); 449 450 snprintf(newpfx, sizeof(newpfx), "%s ", pfx); 451 if (guid_equal(sec_type, &CPER_SEC_PROC_GENERIC)) { 452 struct cper_sec_proc_generic *proc_err = acpi_hest_get_payload(gdata); 453 454 printk("%s""section_type: general processor error\n", newpfx); 455 if (gdata->error_data_length >= sizeof(*proc_err)) 456 cper_print_proc_generic(newpfx, proc_err); 457 else 458 goto err_section_too_small; 459 } else if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) { 460 struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); 461 462 printk("%s""section_type: memory error\n", newpfx); 463 if (gdata->error_data_length >= 464 sizeof(struct cper_sec_mem_err_old)) 465 cper_print_mem(newpfx, mem_err, 466 gdata->error_data_length); 467 else 468 goto err_section_too_small; 469 } else if (guid_equal(sec_type, &CPER_SEC_PCIE)) { 470 struct cper_sec_pcie *pcie = acpi_hest_get_payload(gdata); 471 472 printk("%s""section_type: PCIe error\n", newpfx); 473 if (gdata->error_data_length >= sizeof(*pcie)) 474 cper_print_pcie(newpfx, pcie, gdata); 475 else 476 goto err_section_too_small; 477 #if defined(CONFIG_ARM64) || defined(CONFIG_ARM) 478 } else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) { 479 struct cper_sec_proc_arm *arm_err = acpi_hest_get_payload(gdata); 480 481 printk("%ssection_type: ARM processor error\n", newpfx); 482 if (gdata->error_data_length >= sizeof(*arm_err)) 483 cper_print_proc_arm(newpfx, arm_err); 484 else 485 goto err_section_too_small; 486 #endif 487 #if defined(CONFIG_UEFI_CPER_X86) 488 } else if (guid_equal(sec_type, &CPER_SEC_PROC_IA)) { 489 struct cper_sec_proc_ia *ia_err = acpi_hest_get_payload(gdata); 490 491 printk("%ssection_type: IA32/X64 processor error\n", newpfx); 492 if (gdata->error_data_length >= sizeof(*ia_err)) 493 cper_print_proc_ia(newpfx, ia_err); 494 else 495 goto err_section_too_small; 496 #endif 497 } else { 498 const void *err = acpi_hest_get_payload(gdata); 499 500 printk("%ssection type: unknown, %pUl\n", newpfx, sec_type); 501 printk("%ssection length: %#x\n", newpfx, 502 gdata->error_data_length); 503 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, err, 504 gdata->error_data_length, true); 505 } 506 507 return; 508 509 err_section_too_small: 510 pr_err(FW_WARN "error section length is too small\n"); 511 } 512 513 void cper_estatus_print(const char *pfx, 514 const struct acpi_hest_generic_status *estatus) 515 { 516 struct acpi_hest_generic_data *gdata; 517 int sec_no = 0; 518 char newpfx[64]; 519 __u16 severity; 520 521 severity = estatus->error_severity; 522 if (severity == CPER_SEV_CORRECTED) 523 printk("%s%s\n", pfx, 524 "It has been corrected by h/w " 525 "and requires no further action"); 526 printk("%s""event severity: %s\n", pfx, cper_severity_str(severity)); 527 snprintf(newpfx, sizeof(newpfx), "%s ", pfx); 528 529 apei_estatus_for_each_section(estatus, gdata) { 530 cper_estatus_print_section(newpfx, gdata, sec_no); 531 sec_no++; 532 } 533 } 534 EXPORT_SYMBOL_GPL(cper_estatus_print); 535 536 int cper_estatus_check_header(const struct acpi_hest_generic_status *estatus) 537 { 538 if (estatus->data_length && 539 estatus->data_length < sizeof(struct acpi_hest_generic_data)) 540 return -EINVAL; 541 if (estatus->raw_data_length && 542 estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length) 543 return -EINVAL; 544 545 return 0; 546 } 547 EXPORT_SYMBOL_GPL(cper_estatus_check_header); 548 549 int cper_estatus_check(const struct acpi_hest_generic_status *estatus) 550 { 551 struct acpi_hest_generic_data *gdata; 552 unsigned int data_len, record_size; 553 int rc; 554 555 rc = cper_estatus_check_header(estatus); 556 if (rc) 557 return rc; 558 559 data_len = estatus->data_length; 560 561 apei_estatus_for_each_section(estatus, gdata) { 562 if (sizeof(struct acpi_hest_generic_data) > data_len) 563 return -EINVAL; 564 565 record_size = acpi_hest_get_record_size(gdata); 566 if (record_size > data_len) 567 return -EINVAL; 568 569 data_len -= record_size; 570 } 571 if (data_len) 572 return -EINVAL; 573 574 return 0; 575 } 576 EXPORT_SYMBOL_GPL(cper_estatus_check); 577