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 #define INDENT_SP " " 41 42 static char rcd_decode_str[CPER_REC_LEN]; 43 44 /* 45 * CPER record ID need to be unique even after reboot, because record 46 * ID is used as index for ERST storage, while CPER records from 47 * multiple boot may co-exist in ERST. 48 */ 49 u64 cper_next_record_id(void) 50 { 51 static atomic64_t seq; 52 53 if (!atomic64_read(&seq)) 54 atomic64_set(&seq, ((u64)get_seconds()) << 32); 55 56 return atomic64_inc_return(&seq); 57 } 58 EXPORT_SYMBOL_GPL(cper_next_record_id); 59 60 static const char * const severity_strs[] = { 61 "recoverable", 62 "fatal", 63 "corrected", 64 "info", 65 }; 66 67 const char *cper_severity_str(unsigned int severity) 68 { 69 return severity < ARRAY_SIZE(severity_strs) ? 70 severity_strs[severity] : "unknown"; 71 } 72 EXPORT_SYMBOL_GPL(cper_severity_str); 73 74 /* 75 * cper_print_bits - print strings for set bits 76 * @pfx: prefix for each line, including log level and prefix string 77 * @bits: bit mask 78 * @strs: string array, indexed by bit position 79 * @strs_size: size of the string array: @strs 80 * 81 * For each set bit in @bits, print the corresponding string in @strs. 82 * If the output length is longer than 80, multiple line will be 83 * printed, with @pfx is printed at the beginning of each line. 84 */ 85 void cper_print_bits(const char *pfx, unsigned int bits, 86 const char * const strs[], unsigned int strs_size) 87 { 88 int i, len = 0; 89 const char *str; 90 char buf[84]; 91 92 for (i = 0; i < strs_size; i++) { 93 if (!(bits & (1U << i))) 94 continue; 95 str = strs[i]; 96 if (!str) 97 continue; 98 if (len && len + strlen(str) + 2 > 80) { 99 printk("%s\n", buf); 100 len = 0; 101 } 102 if (!len) 103 len = snprintf(buf, sizeof(buf), "%s%s", pfx, str); 104 else 105 len += snprintf(buf+len, sizeof(buf)-len, ", %s", str); 106 } 107 if (len) 108 printk("%s\n", buf); 109 } 110 111 static const char * const proc_type_strs[] = { 112 "IA32/X64", 113 "IA64", 114 "ARM", 115 }; 116 117 static const char * const proc_isa_strs[] = { 118 "IA32", 119 "IA64", 120 "X64", 121 "ARM A32/T32", 122 "ARM A64", 123 }; 124 125 static const char * const proc_error_type_strs[] = { 126 "cache error", 127 "TLB error", 128 "bus error", 129 "micro-architectural error", 130 }; 131 132 static const char * const proc_op_strs[] = { 133 "unknown or generic", 134 "data read", 135 "data write", 136 "instruction execution", 137 }; 138 139 static const char * const proc_flag_strs[] = { 140 "restartable", 141 "precise IP", 142 "overflow", 143 "corrected", 144 }; 145 146 static void cper_print_proc_generic(const char *pfx, 147 const struct cper_sec_proc_generic *proc) 148 { 149 if (proc->validation_bits & CPER_PROC_VALID_TYPE) 150 printk("%s""processor_type: %d, %s\n", pfx, proc->proc_type, 151 proc->proc_type < ARRAY_SIZE(proc_type_strs) ? 152 proc_type_strs[proc->proc_type] : "unknown"); 153 if (proc->validation_bits & CPER_PROC_VALID_ISA) 154 printk("%s""processor_isa: %d, %s\n", pfx, proc->proc_isa, 155 proc->proc_isa < ARRAY_SIZE(proc_isa_strs) ? 156 proc_isa_strs[proc->proc_isa] : "unknown"); 157 if (proc->validation_bits & CPER_PROC_VALID_ERROR_TYPE) { 158 printk("%s""error_type: 0x%02x\n", pfx, proc->proc_error_type); 159 cper_print_bits(pfx, proc->proc_error_type, 160 proc_error_type_strs, 161 ARRAY_SIZE(proc_error_type_strs)); 162 } 163 if (proc->validation_bits & CPER_PROC_VALID_OPERATION) 164 printk("%s""operation: %d, %s\n", pfx, proc->operation, 165 proc->operation < ARRAY_SIZE(proc_op_strs) ? 166 proc_op_strs[proc->operation] : "unknown"); 167 if (proc->validation_bits & CPER_PROC_VALID_FLAGS) { 168 printk("%s""flags: 0x%02x\n", pfx, proc->flags); 169 cper_print_bits(pfx, proc->flags, proc_flag_strs, 170 ARRAY_SIZE(proc_flag_strs)); 171 } 172 if (proc->validation_bits & CPER_PROC_VALID_LEVEL) 173 printk("%s""level: %d\n", pfx, proc->level); 174 if (proc->validation_bits & CPER_PROC_VALID_VERSION) 175 printk("%s""version_info: 0x%016llx\n", pfx, proc->cpu_version); 176 if (proc->validation_bits & CPER_PROC_VALID_ID) 177 printk("%s""processor_id: 0x%016llx\n", pfx, proc->proc_id); 178 if (proc->validation_bits & CPER_PROC_VALID_TARGET_ADDRESS) 179 printk("%s""target_address: 0x%016llx\n", 180 pfx, proc->target_addr); 181 if (proc->validation_bits & CPER_PROC_VALID_REQUESTOR_ID) 182 printk("%s""requestor_id: 0x%016llx\n", 183 pfx, proc->requestor_id); 184 if (proc->validation_bits & CPER_PROC_VALID_RESPONDER_ID) 185 printk("%s""responder_id: 0x%016llx\n", 186 pfx, proc->responder_id); 187 if (proc->validation_bits & CPER_PROC_VALID_IP) 188 printk("%s""IP: 0x%016llx\n", pfx, proc->ip); 189 } 190 191 #if defined(CONFIG_ARM64) || defined(CONFIG_ARM) 192 static const char * const arm_reg_ctx_strs[] = { 193 "AArch32 general purpose registers", 194 "AArch32 EL1 context registers", 195 "AArch32 EL2 context registers", 196 "AArch32 secure context registers", 197 "AArch64 general purpose registers", 198 "AArch64 EL1 context registers", 199 "AArch64 EL2 context registers", 200 "AArch64 EL3 context registers", 201 "Misc. system register structure", 202 }; 203 204 static void cper_print_proc_arm(const char *pfx, 205 const struct cper_sec_proc_arm *proc) 206 { 207 int i, len, max_ctx_type; 208 struct cper_arm_err_info *err_info; 209 struct cper_arm_ctx_info *ctx_info; 210 char newpfx[64]; 211 212 printk("%sMIDR: 0x%016llx\n", pfx, proc->midr); 213 214 len = proc->section_length - (sizeof(*proc) + 215 proc->err_info_num * (sizeof(*err_info))); 216 if (len < 0) { 217 printk("%ssection length: %d\n", pfx, proc->section_length); 218 printk("%ssection length is too small\n", pfx); 219 printk("%sfirmware-generated error record is incorrect\n", pfx); 220 printk("%sERR_INFO_NUM is %d\n", pfx, proc->err_info_num); 221 return; 222 } 223 224 if (proc->validation_bits & CPER_ARM_VALID_MPIDR) 225 printk("%sMultiprocessor Affinity Register (MPIDR): 0x%016llx\n", 226 pfx, proc->mpidr); 227 228 if (proc->validation_bits & CPER_ARM_VALID_AFFINITY_LEVEL) 229 printk("%serror affinity level: %d\n", pfx, 230 proc->affinity_level); 231 232 if (proc->validation_bits & CPER_ARM_VALID_RUNNING_STATE) { 233 printk("%srunning state: 0x%x\n", pfx, proc->running_state); 234 printk("%sPower State Coordination Interface state: %d\n", 235 pfx, proc->psci_state); 236 } 237 238 snprintf(newpfx, sizeof(newpfx), "%s%s", pfx, INDENT_SP); 239 240 err_info = (struct cper_arm_err_info *)(proc + 1); 241 for (i = 0; i < proc->err_info_num; i++) { 242 printk("%sError info structure %d:\n", pfx, i); 243 244 printk("%snum errors: %d\n", pfx, err_info->multiple_error + 1); 245 246 if (err_info->validation_bits & CPER_ARM_INFO_VALID_FLAGS) { 247 if (err_info->flags & CPER_ARM_INFO_FLAGS_FIRST) 248 printk("%sfirst error captured\n", newpfx); 249 if (err_info->flags & CPER_ARM_INFO_FLAGS_LAST) 250 printk("%slast error captured\n", newpfx); 251 if (err_info->flags & CPER_ARM_INFO_FLAGS_PROPAGATED) 252 printk("%spropagated error captured\n", 253 newpfx); 254 if (err_info->flags & CPER_ARM_INFO_FLAGS_OVERFLOW) 255 printk("%soverflow occurred, error info is incomplete\n", 256 newpfx); 257 } 258 259 printk("%serror_type: %d, %s\n", newpfx, err_info->type, 260 err_info->type < ARRAY_SIZE(proc_error_type_strs) ? 261 proc_error_type_strs[err_info->type] : "unknown"); 262 if (err_info->validation_bits & CPER_ARM_INFO_VALID_ERR_INFO) 263 printk("%serror_info: 0x%016llx\n", newpfx, 264 err_info->error_info); 265 if (err_info->validation_bits & CPER_ARM_INFO_VALID_VIRT_ADDR) 266 printk("%svirtual fault address: 0x%016llx\n", 267 newpfx, err_info->virt_fault_addr); 268 if (err_info->validation_bits & CPER_ARM_INFO_VALID_PHYSICAL_ADDR) 269 printk("%sphysical fault address: 0x%016llx\n", 270 newpfx, err_info->physical_fault_addr); 271 err_info += 1; 272 } 273 274 ctx_info = (struct cper_arm_ctx_info *)err_info; 275 max_ctx_type = ARRAY_SIZE(arm_reg_ctx_strs) - 1; 276 for (i = 0; i < proc->context_info_num; i++) { 277 int size = sizeof(*ctx_info) + ctx_info->size; 278 279 printk("%sContext info structure %d:\n", pfx, i); 280 if (len < size) { 281 printk("%ssection length is too small\n", newpfx); 282 printk("%sfirmware-generated error record is incorrect\n", pfx); 283 return; 284 } 285 if (ctx_info->type > max_ctx_type) { 286 printk("%sInvalid context type: %d (max: %d)\n", 287 newpfx, ctx_info->type, max_ctx_type); 288 return; 289 } 290 printk("%sregister context type: %s\n", newpfx, 291 arm_reg_ctx_strs[ctx_info->type]); 292 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, 293 (ctx_info + 1), ctx_info->size, 0); 294 len -= size; 295 ctx_info = (struct cper_arm_ctx_info *)((long)ctx_info + size); 296 } 297 298 if (len > 0) { 299 printk("%sVendor specific error info has %u bytes:\n", pfx, 300 len); 301 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, ctx_info, 302 len, true); 303 } 304 } 305 #endif 306 307 static const char * const mem_err_type_strs[] = { 308 "unknown", 309 "no error", 310 "single-bit ECC", 311 "multi-bit ECC", 312 "single-symbol chipkill ECC", 313 "multi-symbol chipkill ECC", 314 "master abort", 315 "target abort", 316 "parity error", 317 "watchdog timeout", 318 "invalid address", 319 "mirror Broken", 320 "memory sparing", 321 "scrub corrected error", 322 "scrub uncorrected error", 323 "physical memory map-out event", 324 }; 325 326 const char *cper_mem_err_type_str(unsigned int etype) 327 { 328 return etype < ARRAY_SIZE(mem_err_type_strs) ? 329 mem_err_type_strs[etype] : "unknown"; 330 } 331 EXPORT_SYMBOL_GPL(cper_mem_err_type_str); 332 333 static int cper_mem_err_location(struct cper_mem_err_compact *mem, char *msg) 334 { 335 u32 len, n; 336 337 if (!msg) 338 return 0; 339 340 n = 0; 341 len = CPER_REC_LEN - 1; 342 if (mem->validation_bits & CPER_MEM_VALID_NODE) 343 n += scnprintf(msg + n, len - n, "node: %d ", mem->node); 344 if (mem->validation_bits & CPER_MEM_VALID_CARD) 345 n += scnprintf(msg + n, len - n, "card: %d ", mem->card); 346 if (mem->validation_bits & CPER_MEM_VALID_MODULE) 347 n += scnprintf(msg + n, len - n, "module: %d ", mem->module); 348 if (mem->validation_bits & CPER_MEM_VALID_RANK_NUMBER) 349 n += scnprintf(msg + n, len - n, "rank: %d ", mem->rank); 350 if (mem->validation_bits & CPER_MEM_VALID_BANK) 351 n += scnprintf(msg + n, len - n, "bank: %d ", mem->bank); 352 if (mem->validation_bits & CPER_MEM_VALID_DEVICE) 353 n += scnprintf(msg + n, len - n, "device: %d ", mem->device); 354 if (mem->validation_bits & CPER_MEM_VALID_ROW) 355 n += scnprintf(msg + n, len - n, "row: %d ", mem->row); 356 if (mem->validation_bits & CPER_MEM_VALID_COLUMN) 357 n += scnprintf(msg + n, len - n, "column: %d ", mem->column); 358 if (mem->validation_bits & CPER_MEM_VALID_BIT_POSITION) 359 n += scnprintf(msg + n, len - n, "bit_position: %d ", 360 mem->bit_pos); 361 if (mem->validation_bits & CPER_MEM_VALID_REQUESTOR_ID) 362 n += scnprintf(msg + n, len - n, "requestor_id: 0x%016llx ", 363 mem->requestor_id); 364 if (mem->validation_bits & CPER_MEM_VALID_RESPONDER_ID) 365 n += scnprintf(msg + n, len - n, "responder_id: 0x%016llx ", 366 mem->responder_id); 367 if (mem->validation_bits & CPER_MEM_VALID_TARGET_ID) 368 scnprintf(msg + n, len - n, "target_id: 0x%016llx ", 369 mem->target_id); 370 371 msg[n] = '\0'; 372 return n; 373 } 374 375 static int cper_dimm_err_location(struct cper_mem_err_compact *mem, char *msg) 376 { 377 u32 len, n; 378 const char *bank = NULL, *device = NULL; 379 380 if (!msg || !(mem->validation_bits & CPER_MEM_VALID_MODULE_HANDLE)) 381 return 0; 382 383 n = 0; 384 len = CPER_REC_LEN - 1; 385 dmi_memdev_name(mem->mem_dev_handle, &bank, &device); 386 if (bank && device) 387 n = snprintf(msg, len, "DIMM location: %s %s ", bank, device); 388 else 389 n = snprintf(msg, len, 390 "DIMM location: not present. DMI handle: 0x%.4x ", 391 mem->mem_dev_handle); 392 393 msg[n] = '\0'; 394 return n; 395 } 396 397 void cper_mem_err_pack(const struct cper_sec_mem_err *mem, 398 struct cper_mem_err_compact *cmem) 399 { 400 cmem->validation_bits = mem->validation_bits; 401 cmem->node = mem->node; 402 cmem->card = mem->card; 403 cmem->module = mem->module; 404 cmem->bank = mem->bank; 405 cmem->device = mem->device; 406 cmem->row = mem->row; 407 cmem->column = mem->column; 408 cmem->bit_pos = mem->bit_pos; 409 cmem->requestor_id = mem->requestor_id; 410 cmem->responder_id = mem->responder_id; 411 cmem->target_id = mem->target_id; 412 cmem->rank = mem->rank; 413 cmem->mem_array_handle = mem->mem_array_handle; 414 cmem->mem_dev_handle = mem->mem_dev_handle; 415 } 416 417 const char *cper_mem_err_unpack(struct trace_seq *p, 418 struct cper_mem_err_compact *cmem) 419 { 420 const char *ret = trace_seq_buffer_ptr(p); 421 422 if (cper_mem_err_location(cmem, rcd_decode_str)) 423 trace_seq_printf(p, "%s", rcd_decode_str); 424 if (cper_dimm_err_location(cmem, rcd_decode_str)) 425 trace_seq_printf(p, "%s", rcd_decode_str); 426 trace_seq_putc(p, '\0'); 427 428 return ret; 429 } 430 431 static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem, 432 int len) 433 { 434 struct cper_mem_err_compact cmem; 435 436 /* Don't trust UEFI 2.1/2.2 structure with bad validation bits */ 437 if (len == sizeof(struct cper_sec_mem_err_old) && 438 (mem->validation_bits & ~(CPER_MEM_VALID_RANK_NUMBER - 1))) { 439 pr_err(FW_WARN "valid bits set for fields beyond structure\n"); 440 return; 441 } 442 if (mem->validation_bits & CPER_MEM_VALID_ERROR_STATUS) 443 printk("%s""error_status: 0x%016llx\n", pfx, mem->error_status); 444 if (mem->validation_bits & CPER_MEM_VALID_PA) 445 printk("%s""physical_address: 0x%016llx\n", 446 pfx, mem->physical_addr); 447 if (mem->validation_bits & CPER_MEM_VALID_PA_MASK) 448 printk("%s""physical_address_mask: 0x%016llx\n", 449 pfx, mem->physical_addr_mask); 450 cper_mem_err_pack(mem, &cmem); 451 if (cper_mem_err_location(&cmem, rcd_decode_str)) 452 printk("%s%s\n", pfx, rcd_decode_str); 453 if (mem->validation_bits & CPER_MEM_VALID_ERROR_TYPE) { 454 u8 etype = mem->error_type; 455 printk("%s""error_type: %d, %s\n", pfx, etype, 456 cper_mem_err_type_str(etype)); 457 } 458 if (cper_dimm_err_location(&cmem, rcd_decode_str)) 459 printk("%s%s\n", pfx, rcd_decode_str); 460 } 461 462 static const char * const pcie_port_type_strs[] = { 463 "PCIe end point", 464 "legacy PCI end point", 465 "unknown", 466 "unknown", 467 "root port", 468 "upstream switch port", 469 "downstream switch port", 470 "PCIe to PCI/PCI-X bridge", 471 "PCI/PCI-X to PCIe bridge", 472 "root complex integrated endpoint device", 473 "root complex event collector", 474 }; 475 476 static void cper_print_pcie(const char *pfx, const struct cper_sec_pcie *pcie, 477 const struct acpi_hest_generic_data *gdata) 478 { 479 if (pcie->validation_bits & CPER_PCIE_VALID_PORT_TYPE) 480 printk("%s""port_type: %d, %s\n", pfx, pcie->port_type, 481 pcie->port_type < ARRAY_SIZE(pcie_port_type_strs) ? 482 pcie_port_type_strs[pcie->port_type] : "unknown"); 483 if (pcie->validation_bits & CPER_PCIE_VALID_VERSION) 484 printk("%s""version: %d.%d\n", pfx, 485 pcie->version.major, pcie->version.minor); 486 if (pcie->validation_bits & CPER_PCIE_VALID_COMMAND_STATUS) 487 printk("%s""command: 0x%04x, status: 0x%04x\n", pfx, 488 pcie->command, pcie->status); 489 if (pcie->validation_bits & CPER_PCIE_VALID_DEVICE_ID) { 490 const __u8 *p; 491 printk("%s""device_id: %04x:%02x:%02x.%x\n", pfx, 492 pcie->device_id.segment, pcie->device_id.bus, 493 pcie->device_id.device, pcie->device_id.function); 494 printk("%s""slot: %d\n", pfx, 495 pcie->device_id.slot >> CPER_PCIE_SLOT_SHIFT); 496 printk("%s""secondary_bus: 0x%02x\n", pfx, 497 pcie->device_id.secondary_bus); 498 printk("%s""vendor_id: 0x%04x, device_id: 0x%04x\n", pfx, 499 pcie->device_id.vendor_id, pcie->device_id.device_id); 500 p = pcie->device_id.class_code; 501 printk("%s""class_code: %02x%02x%02x\n", pfx, p[0], p[1], p[2]); 502 } 503 if (pcie->validation_bits & CPER_PCIE_VALID_SERIAL_NUMBER) 504 printk("%s""serial number: 0x%04x, 0x%04x\n", pfx, 505 pcie->serial_number.lower, pcie->serial_number.upper); 506 if (pcie->validation_bits & CPER_PCIE_VALID_BRIDGE_CONTROL_STATUS) 507 printk( 508 "%s""bridge: secondary_status: 0x%04x, control: 0x%04x\n", 509 pfx, pcie->bridge.secondary_status, pcie->bridge.control); 510 } 511 512 static void cper_print_tstamp(const char *pfx, 513 struct acpi_hest_generic_data_v300 *gdata) 514 { 515 __u8 hour, min, sec, day, mon, year, century, *timestamp; 516 517 if (gdata->validation_bits & ACPI_HEST_GEN_VALID_TIMESTAMP) { 518 timestamp = (__u8 *)&(gdata->time_stamp); 519 sec = bcd2bin(timestamp[0]); 520 min = bcd2bin(timestamp[1]); 521 hour = bcd2bin(timestamp[2]); 522 day = bcd2bin(timestamp[4]); 523 mon = bcd2bin(timestamp[5]); 524 year = bcd2bin(timestamp[6]); 525 century = bcd2bin(timestamp[7]); 526 527 printk("%s%ststamp: %02d%02d-%02d-%02d %02d:%02d:%02d\n", pfx, 528 (timestamp[3] & 0x1 ? "precise " : "imprecise "), 529 century, year, mon, day, hour, min, sec); 530 } 531 } 532 533 static void 534 cper_estatus_print_section(const char *pfx, struct acpi_hest_generic_data *gdata, 535 int sec_no) 536 { 537 guid_t *sec_type = (guid_t *)gdata->section_type; 538 __u16 severity; 539 char newpfx[64]; 540 541 if (acpi_hest_get_version(gdata) >= 3) 542 cper_print_tstamp(pfx, (struct acpi_hest_generic_data_v300 *)gdata); 543 544 severity = gdata->error_severity; 545 printk("%s""Error %d, type: %s\n", pfx, sec_no, 546 cper_severity_str(severity)); 547 if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID) 548 printk("%s""fru_id: %pUl\n", pfx, gdata->fru_id); 549 if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT) 550 printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text); 551 552 snprintf(newpfx, sizeof(newpfx), "%s%s", pfx, INDENT_SP); 553 if (guid_equal(sec_type, &CPER_SEC_PROC_GENERIC)) { 554 struct cper_sec_proc_generic *proc_err = acpi_hest_get_payload(gdata); 555 556 printk("%s""section_type: general processor error\n", newpfx); 557 if (gdata->error_data_length >= sizeof(*proc_err)) 558 cper_print_proc_generic(newpfx, proc_err); 559 else 560 goto err_section_too_small; 561 } else if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) { 562 struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); 563 564 printk("%s""section_type: memory error\n", newpfx); 565 if (gdata->error_data_length >= 566 sizeof(struct cper_sec_mem_err_old)) 567 cper_print_mem(newpfx, mem_err, 568 gdata->error_data_length); 569 else 570 goto err_section_too_small; 571 } else if (guid_equal(sec_type, &CPER_SEC_PCIE)) { 572 struct cper_sec_pcie *pcie = acpi_hest_get_payload(gdata); 573 574 printk("%s""section_type: PCIe error\n", newpfx); 575 if (gdata->error_data_length >= sizeof(*pcie)) 576 cper_print_pcie(newpfx, pcie, gdata); 577 else 578 goto err_section_too_small; 579 #if defined(CONFIG_ARM64) || defined(CONFIG_ARM) 580 } else if (!uuid_le_cmp(*sec_type, CPER_SEC_PROC_ARM)) { 581 struct cper_sec_proc_arm *arm_err = acpi_hest_get_payload(gdata); 582 583 printk("%ssection_type: ARM processor error\n", newpfx); 584 if (gdata->error_data_length >= sizeof(*arm_err)) 585 cper_print_proc_arm(newpfx, arm_err); 586 else 587 goto err_section_too_small; 588 #endif 589 } else { 590 const void *err = acpi_hest_get_payload(gdata); 591 592 printk("%ssection type: unknown, %pUl\n", newpfx, sec_type); 593 printk("%ssection length: %#x\n", newpfx, 594 gdata->error_data_length); 595 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, err, 596 gdata->error_data_length, true); 597 } 598 599 return; 600 601 err_section_too_small: 602 pr_err(FW_WARN "error section length is too small\n"); 603 } 604 605 void cper_estatus_print(const char *pfx, 606 const struct acpi_hest_generic_status *estatus) 607 { 608 struct acpi_hest_generic_data *gdata; 609 int sec_no = 0; 610 char newpfx[64]; 611 __u16 severity; 612 613 severity = estatus->error_severity; 614 if (severity == CPER_SEV_CORRECTED) 615 printk("%s%s\n", pfx, 616 "It has been corrected by h/w " 617 "and requires no further action"); 618 printk("%s""event severity: %s\n", pfx, cper_severity_str(severity)); 619 snprintf(newpfx, sizeof(newpfx), "%s%s", pfx, INDENT_SP); 620 621 apei_estatus_for_each_section(estatus, gdata) { 622 cper_estatus_print_section(newpfx, gdata, sec_no); 623 sec_no++; 624 } 625 } 626 EXPORT_SYMBOL_GPL(cper_estatus_print); 627 628 int cper_estatus_check_header(const struct acpi_hest_generic_status *estatus) 629 { 630 if (estatus->data_length && 631 estatus->data_length < sizeof(struct acpi_hest_generic_data)) 632 return -EINVAL; 633 if (estatus->raw_data_length && 634 estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length) 635 return -EINVAL; 636 637 return 0; 638 } 639 EXPORT_SYMBOL_GPL(cper_estatus_check_header); 640 641 int cper_estatus_check(const struct acpi_hest_generic_status *estatus) 642 { 643 struct acpi_hest_generic_data *gdata; 644 unsigned int data_len, gedata_len; 645 int rc; 646 647 rc = cper_estatus_check_header(estatus); 648 if (rc) 649 return rc; 650 data_len = estatus->data_length; 651 652 apei_estatus_for_each_section(estatus, gdata) { 653 gedata_len = acpi_hest_get_error_length(gdata); 654 if (gedata_len > data_len - acpi_hest_get_size(gdata)) 655 return -EINVAL; 656 data_len -= acpi_hest_get_record_size(gdata); 657 } 658 if (data_len) 659 return -EINVAL; 660 661 return 0; 662 } 663 EXPORT_SYMBOL_GPL(cper_estatus_check); 664