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