1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * APEI Error Record Serialization Table support 4 * 5 * ERST is a way provided by APEI to save and retrieve hardware error 6 * information to and from a persistent store. 7 * 8 * For more information about ERST, please refer to ACPI Specification 9 * version 4.0, section 17.4. 10 * 11 * Copyright 2010 Intel Corp. 12 * Author: Huang Ying <ying.huang@intel.com> 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/delay.h> 19 #include <linux/io.h> 20 #include <linux/acpi.h> 21 #include <linux/uaccess.h> 22 #include <linux/cper.h> 23 #include <linux/nmi.h> 24 #include <linux/hardirq.h> 25 #include <linux/pstore.h> 26 #include <linux/vmalloc.h> 27 #include <linux/mm.h> /* kvfree() */ 28 #include <acpi/apei.h> 29 30 #include "apei-internal.h" 31 32 #undef pr_fmt 33 #define pr_fmt(fmt) "ERST: " fmt 34 35 /* ERST command status */ 36 #define ERST_STATUS_SUCCESS 0x0 37 #define ERST_STATUS_NOT_ENOUGH_SPACE 0x1 38 #define ERST_STATUS_HARDWARE_NOT_AVAILABLE 0x2 39 #define ERST_STATUS_FAILED 0x3 40 #define ERST_STATUS_RECORD_STORE_EMPTY 0x4 41 #define ERST_STATUS_RECORD_NOT_FOUND 0x5 42 43 #define ERST_TAB_ENTRY(tab) \ 44 ((struct acpi_whea_header *)((char *)(tab) + \ 45 sizeof(struct acpi_table_erst))) 46 47 #define SPIN_UNIT 100 /* 100ns */ 48 /* Firmware should respond within 1 milliseconds */ 49 #define FIRMWARE_TIMEOUT (1 * NSEC_PER_MSEC) 50 #define FIRMWARE_MAX_STALL 50 /* 50us */ 51 52 int erst_disable; 53 EXPORT_SYMBOL_GPL(erst_disable); 54 55 static struct acpi_table_erst *erst_tab; 56 57 /* ERST Error Log Address Range attributes */ 58 #define ERST_RANGE_RESERVED 0x0001 59 #define ERST_RANGE_NVRAM 0x0002 60 #define ERST_RANGE_SLOW 0x0004 61 62 /* 63 * ERST Error Log Address Range, used as buffer for reading/writing 64 * error records. 65 */ 66 static struct erst_erange { 67 u64 base; 68 u64 size; 69 void __iomem *vaddr; 70 u32 attr; 71 } erst_erange; 72 73 /* 74 * Prevent ERST interpreter to run simultaneously, because the 75 * corresponding firmware implementation may not work properly when 76 * invoked simultaneously. 77 * 78 * It is used to provide exclusive accessing for ERST Error Log 79 * Address Range too. 80 */ 81 static DEFINE_RAW_SPINLOCK(erst_lock); 82 83 static inline int erst_errno(int command_status) 84 { 85 switch (command_status) { 86 case ERST_STATUS_SUCCESS: 87 return 0; 88 case ERST_STATUS_HARDWARE_NOT_AVAILABLE: 89 return -ENODEV; 90 case ERST_STATUS_NOT_ENOUGH_SPACE: 91 return -ENOSPC; 92 case ERST_STATUS_RECORD_STORE_EMPTY: 93 case ERST_STATUS_RECORD_NOT_FOUND: 94 return -ENOENT; 95 default: 96 return -EINVAL; 97 } 98 } 99 100 static int erst_timedout(u64 *t, u64 spin_unit) 101 { 102 if ((s64)*t < spin_unit) { 103 pr_warn(FW_WARN "Firmware does not respond in time.\n"); 104 return 1; 105 } 106 *t -= spin_unit; 107 ndelay(spin_unit); 108 touch_nmi_watchdog(); 109 return 0; 110 } 111 112 static int erst_exec_load_var1(struct apei_exec_context *ctx, 113 struct acpi_whea_header *entry) 114 { 115 return __apei_exec_read_register(entry, &ctx->var1); 116 } 117 118 static int erst_exec_load_var2(struct apei_exec_context *ctx, 119 struct acpi_whea_header *entry) 120 { 121 return __apei_exec_read_register(entry, &ctx->var2); 122 } 123 124 static int erst_exec_store_var1(struct apei_exec_context *ctx, 125 struct acpi_whea_header *entry) 126 { 127 return __apei_exec_write_register(entry, ctx->var1); 128 } 129 130 static int erst_exec_add(struct apei_exec_context *ctx, 131 struct acpi_whea_header *entry) 132 { 133 ctx->var1 += ctx->var2; 134 return 0; 135 } 136 137 static int erst_exec_subtract(struct apei_exec_context *ctx, 138 struct acpi_whea_header *entry) 139 { 140 ctx->var1 -= ctx->var2; 141 return 0; 142 } 143 144 static int erst_exec_add_value(struct apei_exec_context *ctx, 145 struct acpi_whea_header *entry) 146 { 147 int rc; 148 u64 val; 149 150 rc = __apei_exec_read_register(entry, &val); 151 if (rc) 152 return rc; 153 val += ctx->value; 154 rc = __apei_exec_write_register(entry, val); 155 return rc; 156 } 157 158 static int erst_exec_subtract_value(struct apei_exec_context *ctx, 159 struct acpi_whea_header *entry) 160 { 161 int rc; 162 u64 val; 163 164 rc = __apei_exec_read_register(entry, &val); 165 if (rc) 166 return rc; 167 val -= ctx->value; 168 rc = __apei_exec_write_register(entry, val); 169 return rc; 170 } 171 172 static int erst_exec_stall(struct apei_exec_context *ctx, 173 struct acpi_whea_header *entry) 174 { 175 u64 stall_time; 176 177 if (ctx->value > FIRMWARE_MAX_STALL) { 178 if (!in_nmi()) 179 pr_warn(FW_WARN 180 "Too long stall time for stall instruction: 0x%llx.\n", 181 ctx->value); 182 stall_time = FIRMWARE_MAX_STALL; 183 } else 184 stall_time = ctx->value; 185 udelay(stall_time); 186 return 0; 187 } 188 189 static int erst_exec_stall_while_true(struct apei_exec_context *ctx, 190 struct acpi_whea_header *entry) 191 { 192 int rc; 193 u64 val; 194 u64 timeout = FIRMWARE_TIMEOUT; 195 u64 stall_time; 196 197 if (ctx->var1 > FIRMWARE_MAX_STALL) { 198 if (!in_nmi()) 199 pr_warn(FW_WARN 200 "Too long stall time for stall while true instruction: 0x%llx.\n", 201 ctx->var1); 202 stall_time = FIRMWARE_MAX_STALL; 203 } else 204 stall_time = ctx->var1; 205 206 for (;;) { 207 rc = __apei_exec_read_register(entry, &val); 208 if (rc) 209 return rc; 210 if (val != ctx->value) 211 break; 212 if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC)) 213 return -EIO; 214 } 215 return 0; 216 } 217 218 static int erst_exec_skip_next_instruction_if_true( 219 struct apei_exec_context *ctx, 220 struct acpi_whea_header *entry) 221 { 222 int rc; 223 u64 val; 224 225 rc = __apei_exec_read_register(entry, &val); 226 if (rc) 227 return rc; 228 if (val == ctx->value) { 229 ctx->ip += 2; 230 return APEI_EXEC_SET_IP; 231 } 232 233 return 0; 234 } 235 236 static int erst_exec_goto(struct apei_exec_context *ctx, 237 struct acpi_whea_header *entry) 238 { 239 ctx->ip = ctx->value; 240 return APEI_EXEC_SET_IP; 241 } 242 243 static int erst_exec_set_src_address_base(struct apei_exec_context *ctx, 244 struct acpi_whea_header *entry) 245 { 246 return __apei_exec_read_register(entry, &ctx->src_base); 247 } 248 249 static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx, 250 struct acpi_whea_header *entry) 251 { 252 return __apei_exec_read_register(entry, &ctx->dst_base); 253 } 254 255 static int erst_exec_move_data(struct apei_exec_context *ctx, 256 struct acpi_whea_header *entry) 257 { 258 int rc; 259 u64 offset; 260 void *src, *dst; 261 262 /* ioremap does not work in interrupt context */ 263 if (in_interrupt()) { 264 pr_warn("MOVE_DATA can not be used in interrupt context.\n"); 265 return -EBUSY; 266 } 267 268 rc = __apei_exec_read_register(entry, &offset); 269 if (rc) 270 return rc; 271 272 src = ioremap(ctx->src_base + offset, ctx->var2); 273 if (!src) 274 return -ENOMEM; 275 dst = ioremap(ctx->dst_base + offset, ctx->var2); 276 if (!dst) { 277 iounmap(src); 278 return -ENOMEM; 279 } 280 281 memmove(dst, src, ctx->var2); 282 283 iounmap(src); 284 iounmap(dst); 285 286 return 0; 287 } 288 289 static struct apei_exec_ins_type erst_ins_type[] = { 290 [ACPI_ERST_READ_REGISTER] = { 291 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 292 .run = apei_exec_read_register, 293 }, 294 [ACPI_ERST_READ_REGISTER_VALUE] = { 295 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 296 .run = apei_exec_read_register_value, 297 }, 298 [ACPI_ERST_WRITE_REGISTER] = { 299 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 300 .run = apei_exec_write_register, 301 }, 302 [ACPI_ERST_WRITE_REGISTER_VALUE] = { 303 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 304 .run = apei_exec_write_register_value, 305 }, 306 [ACPI_ERST_NOOP] = { 307 .flags = 0, 308 .run = apei_exec_noop, 309 }, 310 [ACPI_ERST_LOAD_VAR1] = { 311 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 312 .run = erst_exec_load_var1, 313 }, 314 [ACPI_ERST_LOAD_VAR2] = { 315 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 316 .run = erst_exec_load_var2, 317 }, 318 [ACPI_ERST_STORE_VAR1] = { 319 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 320 .run = erst_exec_store_var1, 321 }, 322 [ACPI_ERST_ADD] = { 323 .flags = 0, 324 .run = erst_exec_add, 325 }, 326 [ACPI_ERST_SUBTRACT] = { 327 .flags = 0, 328 .run = erst_exec_subtract, 329 }, 330 [ACPI_ERST_ADD_VALUE] = { 331 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 332 .run = erst_exec_add_value, 333 }, 334 [ACPI_ERST_SUBTRACT_VALUE] = { 335 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 336 .run = erst_exec_subtract_value, 337 }, 338 [ACPI_ERST_STALL] = { 339 .flags = 0, 340 .run = erst_exec_stall, 341 }, 342 [ACPI_ERST_STALL_WHILE_TRUE] = { 343 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 344 .run = erst_exec_stall_while_true, 345 }, 346 [ACPI_ERST_SKIP_NEXT_IF_TRUE] = { 347 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 348 .run = erst_exec_skip_next_instruction_if_true, 349 }, 350 [ACPI_ERST_GOTO] = { 351 .flags = 0, 352 .run = erst_exec_goto, 353 }, 354 [ACPI_ERST_SET_SRC_ADDRESS_BASE] = { 355 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 356 .run = erst_exec_set_src_address_base, 357 }, 358 [ACPI_ERST_SET_DST_ADDRESS_BASE] = { 359 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 360 .run = erst_exec_set_dst_address_base, 361 }, 362 [ACPI_ERST_MOVE_DATA] = { 363 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 364 .run = erst_exec_move_data, 365 }, 366 }; 367 368 static inline void erst_exec_ctx_init(struct apei_exec_context *ctx) 369 { 370 apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type), 371 ERST_TAB_ENTRY(erst_tab), erst_tab->entries); 372 } 373 374 static int erst_get_erange(struct erst_erange *range) 375 { 376 struct apei_exec_context ctx; 377 int rc; 378 379 erst_exec_ctx_init(&ctx); 380 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE); 381 if (rc) 382 return rc; 383 range->base = apei_exec_ctx_get_output(&ctx); 384 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH); 385 if (rc) 386 return rc; 387 range->size = apei_exec_ctx_get_output(&ctx); 388 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES); 389 if (rc) 390 return rc; 391 range->attr = apei_exec_ctx_get_output(&ctx); 392 393 return 0; 394 } 395 396 static ssize_t __erst_get_record_count(void) 397 { 398 struct apei_exec_context ctx; 399 int rc; 400 401 erst_exec_ctx_init(&ctx); 402 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT); 403 if (rc) 404 return rc; 405 return apei_exec_ctx_get_output(&ctx); 406 } 407 408 ssize_t erst_get_record_count(void) 409 { 410 ssize_t count; 411 unsigned long flags; 412 413 if (erst_disable) 414 return -ENODEV; 415 416 raw_spin_lock_irqsave(&erst_lock, flags); 417 count = __erst_get_record_count(); 418 raw_spin_unlock_irqrestore(&erst_lock, flags); 419 420 return count; 421 } 422 EXPORT_SYMBOL_GPL(erst_get_record_count); 423 424 #define ERST_RECORD_ID_CACHE_SIZE_MIN 16 425 #define ERST_RECORD_ID_CACHE_SIZE_MAX 1024 426 427 struct erst_record_id_cache { 428 struct mutex lock; 429 u64 *entries; 430 int len; 431 int size; 432 int refcount; 433 }; 434 435 static struct erst_record_id_cache erst_record_id_cache = { 436 .lock = __MUTEX_INITIALIZER(erst_record_id_cache.lock), 437 .refcount = 0, 438 }; 439 440 static int __erst_get_next_record_id(u64 *record_id) 441 { 442 struct apei_exec_context ctx; 443 int rc; 444 445 erst_exec_ctx_init(&ctx); 446 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID); 447 if (rc) 448 return rc; 449 *record_id = apei_exec_ctx_get_output(&ctx); 450 451 return 0; 452 } 453 454 int erst_get_record_id_begin(int *pos) 455 { 456 int rc; 457 458 if (erst_disable) 459 return -ENODEV; 460 461 rc = mutex_lock_interruptible(&erst_record_id_cache.lock); 462 if (rc) 463 return rc; 464 erst_record_id_cache.refcount++; 465 mutex_unlock(&erst_record_id_cache.lock); 466 467 *pos = 0; 468 469 return 0; 470 } 471 EXPORT_SYMBOL_GPL(erst_get_record_id_begin); 472 473 /* erst_record_id_cache.lock must be held by caller */ 474 static int __erst_record_id_cache_add_one(void) 475 { 476 u64 id, prev_id, first_id; 477 int i, rc; 478 u64 *entries; 479 unsigned long flags; 480 481 id = prev_id = first_id = APEI_ERST_INVALID_RECORD_ID; 482 retry: 483 raw_spin_lock_irqsave(&erst_lock, flags); 484 rc = __erst_get_next_record_id(&id); 485 raw_spin_unlock_irqrestore(&erst_lock, flags); 486 if (rc == -ENOENT) 487 return 0; 488 if (rc) 489 return rc; 490 if (id == APEI_ERST_INVALID_RECORD_ID) 491 return 0; 492 /* can not skip current ID, or loop back to first ID */ 493 if (id == prev_id || id == first_id) 494 return 0; 495 if (first_id == APEI_ERST_INVALID_RECORD_ID) 496 first_id = id; 497 prev_id = id; 498 499 entries = erst_record_id_cache.entries; 500 for (i = 0; i < erst_record_id_cache.len; i++) { 501 if (entries[i] == id) 502 break; 503 } 504 /* record id already in cache, try next */ 505 if (i < erst_record_id_cache.len) 506 goto retry; 507 if (erst_record_id_cache.len >= erst_record_id_cache.size) { 508 int new_size; 509 u64 *new_entries; 510 511 new_size = erst_record_id_cache.size * 2; 512 new_size = clamp_val(new_size, ERST_RECORD_ID_CACHE_SIZE_MIN, 513 ERST_RECORD_ID_CACHE_SIZE_MAX); 514 if (new_size <= erst_record_id_cache.size) { 515 if (printk_ratelimit()) 516 pr_warn(FW_WARN "too many record IDs!\n"); 517 return 0; 518 } 519 new_entries = kvmalloc_array(new_size, sizeof(entries[0]), 520 GFP_KERNEL); 521 if (!new_entries) 522 return -ENOMEM; 523 memcpy(new_entries, entries, 524 erst_record_id_cache.len * sizeof(entries[0])); 525 kvfree(entries); 526 erst_record_id_cache.entries = entries = new_entries; 527 erst_record_id_cache.size = new_size; 528 } 529 entries[i] = id; 530 erst_record_id_cache.len++; 531 532 return 1; 533 } 534 535 /* 536 * Get the record ID of an existing error record on the persistent 537 * storage. If there is no error record on the persistent storage, the 538 * returned record_id is APEI_ERST_INVALID_RECORD_ID. 539 */ 540 int erst_get_record_id_next(int *pos, u64 *record_id) 541 { 542 int rc = 0; 543 u64 *entries; 544 545 if (erst_disable) 546 return -ENODEV; 547 548 /* must be enclosed by erst_get_record_id_begin/end */ 549 BUG_ON(!erst_record_id_cache.refcount); 550 BUG_ON(*pos < 0 || *pos > erst_record_id_cache.len); 551 552 mutex_lock(&erst_record_id_cache.lock); 553 entries = erst_record_id_cache.entries; 554 for (; *pos < erst_record_id_cache.len; (*pos)++) 555 if (entries[*pos] != APEI_ERST_INVALID_RECORD_ID) 556 break; 557 /* found next record id in cache */ 558 if (*pos < erst_record_id_cache.len) { 559 *record_id = entries[*pos]; 560 (*pos)++; 561 goto out_unlock; 562 } 563 564 /* Try to add one more record ID to cache */ 565 rc = __erst_record_id_cache_add_one(); 566 if (rc < 0) 567 goto out_unlock; 568 /* successfully add one new ID */ 569 if (rc == 1) { 570 *record_id = erst_record_id_cache.entries[*pos]; 571 (*pos)++; 572 rc = 0; 573 } else { 574 *pos = -1; 575 *record_id = APEI_ERST_INVALID_RECORD_ID; 576 } 577 out_unlock: 578 mutex_unlock(&erst_record_id_cache.lock); 579 580 return rc; 581 } 582 EXPORT_SYMBOL_GPL(erst_get_record_id_next); 583 584 /* erst_record_id_cache.lock must be held by caller */ 585 static void __erst_record_id_cache_compact(void) 586 { 587 int i, wpos = 0; 588 u64 *entries; 589 590 if (erst_record_id_cache.refcount) 591 return; 592 593 entries = erst_record_id_cache.entries; 594 for (i = 0; i < erst_record_id_cache.len; i++) { 595 if (entries[i] == APEI_ERST_INVALID_RECORD_ID) 596 continue; 597 if (wpos != i) 598 entries[wpos] = entries[i]; 599 wpos++; 600 } 601 erst_record_id_cache.len = wpos; 602 } 603 604 void erst_get_record_id_end(void) 605 { 606 /* 607 * erst_disable != 0 should be detected by invoker via the 608 * return value of erst_get_record_id_begin/next, so this 609 * function should not be called for erst_disable != 0. 610 */ 611 BUG_ON(erst_disable); 612 613 mutex_lock(&erst_record_id_cache.lock); 614 erst_record_id_cache.refcount--; 615 BUG_ON(erst_record_id_cache.refcount < 0); 616 __erst_record_id_cache_compact(); 617 mutex_unlock(&erst_record_id_cache.lock); 618 } 619 EXPORT_SYMBOL_GPL(erst_get_record_id_end); 620 621 static int __erst_write_to_storage(u64 offset) 622 { 623 struct apei_exec_context ctx; 624 u64 timeout = FIRMWARE_TIMEOUT; 625 u64 val; 626 int rc; 627 628 erst_exec_ctx_init(&ctx); 629 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_WRITE); 630 if (rc) 631 return rc; 632 apei_exec_ctx_set_input(&ctx, offset); 633 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET); 634 if (rc) 635 return rc; 636 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 637 if (rc) 638 return rc; 639 for (;;) { 640 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 641 if (rc) 642 return rc; 643 val = apei_exec_ctx_get_output(&ctx); 644 if (!val) 645 break; 646 if (erst_timedout(&timeout, SPIN_UNIT)) 647 return -EIO; 648 } 649 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 650 if (rc) 651 return rc; 652 val = apei_exec_ctx_get_output(&ctx); 653 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END); 654 if (rc) 655 return rc; 656 657 return erst_errno(val); 658 } 659 660 static int __erst_read_from_storage(u64 record_id, u64 offset) 661 { 662 struct apei_exec_context ctx; 663 u64 timeout = FIRMWARE_TIMEOUT; 664 u64 val; 665 int rc; 666 667 erst_exec_ctx_init(&ctx); 668 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_READ); 669 if (rc) 670 return rc; 671 apei_exec_ctx_set_input(&ctx, offset); 672 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET); 673 if (rc) 674 return rc; 675 apei_exec_ctx_set_input(&ctx, record_id); 676 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID); 677 if (rc) 678 return rc; 679 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 680 if (rc) 681 return rc; 682 for (;;) { 683 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 684 if (rc) 685 return rc; 686 val = apei_exec_ctx_get_output(&ctx); 687 if (!val) 688 break; 689 if (erst_timedout(&timeout, SPIN_UNIT)) 690 return -EIO; 691 } 692 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 693 if (rc) 694 return rc; 695 val = apei_exec_ctx_get_output(&ctx); 696 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END); 697 if (rc) 698 return rc; 699 700 return erst_errno(val); 701 } 702 703 static int __erst_clear_from_storage(u64 record_id) 704 { 705 struct apei_exec_context ctx; 706 u64 timeout = FIRMWARE_TIMEOUT; 707 u64 val; 708 int rc; 709 710 erst_exec_ctx_init(&ctx); 711 rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_CLEAR); 712 if (rc) 713 return rc; 714 apei_exec_ctx_set_input(&ctx, record_id); 715 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID); 716 if (rc) 717 return rc; 718 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 719 if (rc) 720 return rc; 721 for (;;) { 722 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 723 if (rc) 724 return rc; 725 val = apei_exec_ctx_get_output(&ctx); 726 if (!val) 727 break; 728 if (erst_timedout(&timeout, SPIN_UNIT)) 729 return -EIO; 730 } 731 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 732 if (rc) 733 return rc; 734 val = apei_exec_ctx_get_output(&ctx); 735 rc = apei_exec_run_optional(&ctx, ACPI_ERST_END); 736 if (rc) 737 return rc; 738 739 return erst_errno(val); 740 } 741 742 /* NVRAM ERST Error Log Address Range is not supported yet */ 743 static void pr_unimpl_nvram(void) 744 { 745 if (printk_ratelimit()) 746 pr_warn("NVRAM ERST Log Address Range not implemented yet.\n"); 747 } 748 749 static int __erst_write_to_nvram(const struct cper_record_header *record) 750 { 751 /* do not print message, because printk is not safe for NMI */ 752 return -ENOSYS; 753 } 754 755 static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset) 756 { 757 pr_unimpl_nvram(); 758 return -ENOSYS; 759 } 760 761 static int __erst_clear_from_nvram(u64 record_id) 762 { 763 pr_unimpl_nvram(); 764 return -ENOSYS; 765 } 766 767 int erst_write(const struct cper_record_header *record) 768 { 769 int rc; 770 unsigned long flags; 771 struct cper_record_header *rcd_erange; 772 773 if (erst_disable) 774 return -ENODEV; 775 776 if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE)) 777 return -EINVAL; 778 779 if (erst_erange.attr & ERST_RANGE_NVRAM) { 780 if (!raw_spin_trylock_irqsave(&erst_lock, flags)) 781 return -EBUSY; 782 rc = __erst_write_to_nvram(record); 783 raw_spin_unlock_irqrestore(&erst_lock, flags); 784 return rc; 785 } 786 787 if (record->record_length > erst_erange.size) 788 return -EINVAL; 789 790 if (!raw_spin_trylock_irqsave(&erst_lock, flags)) 791 return -EBUSY; 792 memcpy(erst_erange.vaddr, record, record->record_length); 793 rcd_erange = erst_erange.vaddr; 794 /* signature for serialization system */ 795 memcpy(&rcd_erange->persistence_information, "ER", 2); 796 797 rc = __erst_write_to_storage(0); 798 raw_spin_unlock_irqrestore(&erst_lock, flags); 799 800 return rc; 801 } 802 EXPORT_SYMBOL_GPL(erst_write); 803 804 static int __erst_read_to_erange(u64 record_id, u64 *offset) 805 { 806 int rc; 807 808 if (erst_erange.attr & ERST_RANGE_NVRAM) 809 return __erst_read_to_erange_from_nvram( 810 record_id, offset); 811 812 rc = __erst_read_from_storage(record_id, 0); 813 if (rc) 814 return rc; 815 *offset = 0; 816 817 return 0; 818 } 819 820 static ssize_t __erst_read(u64 record_id, struct cper_record_header *record, 821 size_t buflen) 822 { 823 int rc; 824 u64 offset, len = 0; 825 struct cper_record_header *rcd_tmp; 826 827 rc = __erst_read_to_erange(record_id, &offset); 828 if (rc) 829 return rc; 830 rcd_tmp = erst_erange.vaddr + offset; 831 len = rcd_tmp->record_length; 832 if (len <= buflen) 833 memcpy(record, rcd_tmp, len); 834 835 return len; 836 } 837 838 /* 839 * If return value > buflen, the buffer size is not big enough, 840 * else if return value < 0, something goes wrong, 841 * else everything is OK, and return value is record length 842 */ 843 ssize_t erst_read(u64 record_id, struct cper_record_header *record, 844 size_t buflen) 845 { 846 ssize_t len; 847 unsigned long flags; 848 849 if (erst_disable) 850 return -ENODEV; 851 852 raw_spin_lock_irqsave(&erst_lock, flags); 853 len = __erst_read(record_id, record, buflen); 854 raw_spin_unlock_irqrestore(&erst_lock, flags); 855 return len; 856 } 857 EXPORT_SYMBOL_GPL(erst_read); 858 859 static void erst_clear_cache(u64 record_id) 860 { 861 int i; 862 u64 *entries; 863 864 mutex_lock(&erst_record_id_cache.lock); 865 866 entries = erst_record_id_cache.entries; 867 for (i = 0; i < erst_record_id_cache.len; i++) { 868 if (entries[i] == record_id) 869 entries[i] = APEI_ERST_INVALID_RECORD_ID; 870 } 871 __erst_record_id_cache_compact(); 872 873 mutex_unlock(&erst_record_id_cache.lock); 874 } 875 876 ssize_t erst_read_record(u64 record_id, struct cper_record_header *record, 877 size_t buflen, size_t recordlen, const guid_t *creatorid) 878 { 879 ssize_t len; 880 881 /* 882 * if creatorid is NULL, read any record for erst-dbg module 883 */ 884 if (creatorid == NULL) { 885 len = erst_read(record_id, record, buflen); 886 if (len == -ENOENT) 887 erst_clear_cache(record_id); 888 889 return len; 890 } 891 892 len = erst_read(record_id, record, buflen); 893 /* 894 * if erst_read return value is -ENOENT skip to next record_id, 895 * and clear the record_id cache. 896 */ 897 if (len == -ENOENT) { 898 erst_clear_cache(record_id); 899 goto out; 900 } 901 902 if (len < 0) 903 goto out; 904 905 /* 906 * if erst_read return value is less than record head length, 907 * consider it as -EIO, and clear the record_id cache. 908 */ 909 if (len < recordlen) { 910 len = -EIO; 911 erst_clear_cache(record_id); 912 goto out; 913 } 914 915 /* 916 * if creatorid is not wanted, consider it as not found, 917 * for skipping to next record_id. 918 */ 919 if (!guid_equal(&record->creator_id, creatorid)) 920 len = -ENOENT; 921 922 out: 923 return len; 924 } 925 EXPORT_SYMBOL_GPL(erst_read_record); 926 927 int erst_clear(u64 record_id) 928 { 929 int rc, i; 930 unsigned long flags; 931 u64 *entries; 932 933 if (erst_disable) 934 return -ENODEV; 935 936 rc = mutex_lock_interruptible(&erst_record_id_cache.lock); 937 if (rc) 938 return rc; 939 raw_spin_lock_irqsave(&erst_lock, flags); 940 if (erst_erange.attr & ERST_RANGE_NVRAM) 941 rc = __erst_clear_from_nvram(record_id); 942 else 943 rc = __erst_clear_from_storage(record_id); 944 raw_spin_unlock_irqrestore(&erst_lock, flags); 945 if (rc) 946 goto out; 947 entries = erst_record_id_cache.entries; 948 for (i = 0; i < erst_record_id_cache.len; i++) { 949 if (entries[i] == record_id) 950 entries[i] = APEI_ERST_INVALID_RECORD_ID; 951 } 952 __erst_record_id_cache_compact(); 953 out: 954 mutex_unlock(&erst_record_id_cache.lock); 955 return rc; 956 } 957 EXPORT_SYMBOL_GPL(erst_clear); 958 959 static int __init setup_erst_disable(char *str) 960 { 961 erst_disable = 1; 962 return 1; 963 } 964 965 __setup("erst_disable", setup_erst_disable); 966 967 static int erst_check_table(struct acpi_table_erst *erst_tab) 968 { 969 if ((erst_tab->header_length != 970 (sizeof(struct acpi_table_erst) - sizeof(erst_tab->header))) 971 && (erst_tab->header_length != sizeof(struct acpi_table_erst))) 972 return -EINVAL; 973 if (erst_tab->header.length < sizeof(struct acpi_table_erst)) 974 return -EINVAL; 975 if (erst_tab->entries != 976 (erst_tab->header.length - sizeof(struct acpi_table_erst)) / 977 sizeof(struct acpi_erst_entry)) 978 return -EINVAL; 979 980 return 0; 981 } 982 983 static int erst_open_pstore(struct pstore_info *psi); 984 static int erst_close_pstore(struct pstore_info *psi); 985 static ssize_t erst_reader(struct pstore_record *record); 986 static int erst_writer(struct pstore_record *record); 987 static int erst_clearer(struct pstore_record *record); 988 989 static struct pstore_info erst_info = { 990 .owner = THIS_MODULE, 991 .name = "erst", 992 .flags = PSTORE_FLAGS_DMESG, 993 .open = erst_open_pstore, 994 .close = erst_close_pstore, 995 .read = erst_reader, 996 .write = erst_writer, 997 .erase = erst_clearer 998 }; 999 1000 #define CPER_CREATOR_PSTORE \ 1001 GUID_INIT(0x75a574e3, 0x5052, 0x4b29, 0x8a, 0x8e, 0xbe, 0x2c, \ 1002 0x64, 0x90, 0xb8, 0x9d) 1003 #define CPER_SECTION_TYPE_DMESG \ 1004 GUID_INIT(0xc197e04e, 0xd545, 0x4a70, 0x9c, 0x17, 0xa5, 0x54, \ 1005 0x94, 0x19, 0xeb, 0x12) 1006 #define CPER_SECTION_TYPE_DMESG_Z \ 1007 GUID_INIT(0x4f118707, 0x04dd, 0x4055, 0xb5, 0xdd, 0x95, 0x6d, \ 1008 0x34, 0xdd, 0xfa, 0xc6) 1009 #define CPER_SECTION_TYPE_MCE \ 1010 GUID_INIT(0xfe08ffbe, 0x95e4, 0x4be7, 0xbc, 0x73, 0x40, 0x96, \ 1011 0x04, 0x4a, 0x38, 0xfc) 1012 1013 struct cper_pstore_record { 1014 struct cper_record_header hdr; 1015 struct cper_section_descriptor sec_hdr; 1016 char data[]; 1017 } __packed; 1018 1019 static int reader_pos; 1020 1021 static int erst_open_pstore(struct pstore_info *psi) 1022 { 1023 if (erst_disable) 1024 return -ENODEV; 1025 1026 return erst_get_record_id_begin(&reader_pos); 1027 } 1028 1029 static int erst_close_pstore(struct pstore_info *psi) 1030 { 1031 erst_get_record_id_end(); 1032 1033 return 0; 1034 } 1035 1036 static ssize_t erst_reader(struct pstore_record *record) 1037 { 1038 int rc; 1039 ssize_t len = 0; 1040 u64 record_id; 1041 struct cper_pstore_record *rcd; 1042 size_t rcd_len = sizeof(*rcd) + erst_info.bufsize; 1043 1044 if (erst_disable) 1045 return -ENODEV; 1046 1047 rcd = kmalloc(rcd_len, GFP_KERNEL); 1048 if (!rcd) { 1049 rc = -ENOMEM; 1050 goto out; 1051 } 1052 skip: 1053 rc = erst_get_record_id_next(&reader_pos, &record_id); 1054 if (rc) 1055 goto out; 1056 1057 /* no more record */ 1058 if (record_id == APEI_ERST_INVALID_RECORD_ID) { 1059 rc = -EINVAL; 1060 goto out; 1061 } 1062 1063 len = erst_read_record(record_id, &rcd->hdr, rcd_len, sizeof(*rcd), 1064 &CPER_CREATOR_PSTORE); 1065 /* The record may be cleared by others, try read next record */ 1066 if (len == -ENOENT) 1067 goto skip; 1068 else if (len < 0) 1069 goto out; 1070 1071 record->buf = kmalloc(len, GFP_KERNEL); 1072 if (record->buf == NULL) { 1073 rc = -ENOMEM; 1074 goto out; 1075 } 1076 memcpy(record->buf, rcd->data, len - sizeof(*rcd)); 1077 record->id = record_id; 1078 record->compressed = false; 1079 record->ecc_notice_size = 0; 1080 if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_DMESG_Z)) { 1081 record->type = PSTORE_TYPE_DMESG; 1082 record->compressed = true; 1083 } else if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_DMESG)) 1084 record->type = PSTORE_TYPE_DMESG; 1085 else if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_MCE)) 1086 record->type = PSTORE_TYPE_MCE; 1087 else 1088 record->type = PSTORE_TYPE_MAX; 1089 1090 if (rcd->hdr.validation_bits & CPER_VALID_TIMESTAMP) 1091 record->time.tv_sec = rcd->hdr.timestamp; 1092 else 1093 record->time.tv_sec = 0; 1094 record->time.tv_nsec = 0; 1095 1096 out: 1097 kfree(rcd); 1098 return (rc < 0) ? rc : (len - sizeof(*rcd)); 1099 } 1100 1101 static int erst_writer(struct pstore_record *record) 1102 { 1103 struct cper_pstore_record *rcd = (struct cper_pstore_record *) 1104 (erst_info.buf - sizeof(*rcd)); 1105 int ret; 1106 1107 memset(rcd, 0, sizeof(*rcd)); 1108 memcpy(rcd->hdr.signature, CPER_SIG_RECORD, CPER_SIG_SIZE); 1109 rcd->hdr.revision = CPER_RECORD_REV; 1110 rcd->hdr.signature_end = CPER_SIG_END; 1111 rcd->hdr.section_count = 1; 1112 rcd->hdr.error_severity = CPER_SEV_FATAL; 1113 /* timestamp valid. platform_id, partition_id are invalid */ 1114 rcd->hdr.validation_bits = CPER_VALID_TIMESTAMP; 1115 rcd->hdr.timestamp = ktime_get_real_seconds(); 1116 rcd->hdr.record_length = sizeof(*rcd) + record->size; 1117 rcd->hdr.creator_id = CPER_CREATOR_PSTORE; 1118 rcd->hdr.notification_type = CPER_NOTIFY_MCE; 1119 rcd->hdr.record_id = cper_next_record_id(); 1120 rcd->hdr.flags = CPER_HW_ERROR_FLAGS_PREVERR; 1121 1122 rcd->sec_hdr.section_offset = sizeof(*rcd); 1123 rcd->sec_hdr.section_length = record->size; 1124 rcd->sec_hdr.revision = CPER_SEC_REV; 1125 /* fru_id and fru_text is invalid */ 1126 rcd->sec_hdr.validation_bits = 0; 1127 rcd->sec_hdr.flags = CPER_SEC_PRIMARY; 1128 switch (record->type) { 1129 case PSTORE_TYPE_DMESG: 1130 if (record->compressed) 1131 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG_Z; 1132 else 1133 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG; 1134 break; 1135 case PSTORE_TYPE_MCE: 1136 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_MCE; 1137 break; 1138 default: 1139 return -EINVAL; 1140 } 1141 rcd->sec_hdr.section_severity = CPER_SEV_FATAL; 1142 1143 ret = erst_write(&rcd->hdr); 1144 record->id = rcd->hdr.record_id; 1145 1146 return ret; 1147 } 1148 1149 static int erst_clearer(struct pstore_record *record) 1150 { 1151 return erst_clear(record->id); 1152 } 1153 1154 static int __init erst_init(void) 1155 { 1156 int rc = 0; 1157 acpi_status status; 1158 struct apei_exec_context ctx; 1159 struct apei_resources erst_resources; 1160 struct resource *r; 1161 char *buf; 1162 1163 if (acpi_disabled) 1164 goto err; 1165 1166 if (erst_disable) { 1167 pr_info( 1168 "Error Record Serialization Table (ERST) support is disabled.\n"); 1169 goto err; 1170 } 1171 1172 status = acpi_get_table(ACPI_SIG_ERST, 0, 1173 (struct acpi_table_header **)&erst_tab); 1174 if (status == AE_NOT_FOUND) 1175 goto err; 1176 else if (ACPI_FAILURE(status)) { 1177 const char *msg = acpi_format_exception(status); 1178 pr_err("Failed to get table, %s\n", msg); 1179 rc = -EINVAL; 1180 goto err; 1181 } 1182 1183 rc = erst_check_table(erst_tab); 1184 if (rc) { 1185 pr_err(FW_BUG "ERST table is invalid.\n"); 1186 goto err_put_erst_tab; 1187 } 1188 1189 apei_resources_init(&erst_resources); 1190 erst_exec_ctx_init(&ctx); 1191 rc = apei_exec_collect_resources(&ctx, &erst_resources); 1192 if (rc) 1193 goto err_fini; 1194 rc = apei_resources_request(&erst_resources, "APEI ERST"); 1195 if (rc) 1196 goto err_fini; 1197 rc = apei_exec_pre_map_gars(&ctx); 1198 if (rc) 1199 goto err_release; 1200 rc = erst_get_erange(&erst_erange); 1201 if (rc) { 1202 if (rc == -ENODEV) 1203 pr_info( 1204 "The corresponding hardware device or firmware implementation " 1205 "is not available.\n"); 1206 else 1207 pr_err("Failed to get Error Log Address Range.\n"); 1208 goto err_unmap_reg; 1209 } 1210 1211 r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST"); 1212 if (!r) { 1213 pr_err("Can not request [mem %#010llx-%#010llx] for ERST.\n", 1214 (unsigned long long)erst_erange.base, 1215 (unsigned long long)erst_erange.base + erst_erange.size - 1); 1216 rc = -EIO; 1217 goto err_unmap_reg; 1218 } 1219 rc = -ENOMEM; 1220 erst_erange.vaddr = ioremap_cache(erst_erange.base, 1221 erst_erange.size); 1222 if (!erst_erange.vaddr) 1223 goto err_release_erange; 1224 1225 pr_info( 1226 "Error Record Serialization Table (ERST) support is initialized.\n"); 1227 1228 buf = kmalloc(erst_erange.size, GFP_KERNEL); 1229 if (buf) { 1230 erst_info.buf = buf + sizeof(struct cper_pstore_record); 1231 erst_info.bufsize = erst_erange.size - 1232 sizeof(struct cper_pstore_record); 1233 rc = pstore_register(&erst_info); 1234 if (rc) { 1235 if (rc != -EPERM) 1236 pr_info( 1237 "Could not register with persistent store.\n"); 1238 erst_info.buf = NULL; 1239 erst_info.bufsize = 0; 1240 kfree(buf); 1241 } 1242 } else 1243 pr_err( 1244 "Failed to allocate %lld bytes for persistent store error log.\n", 1245 erst_erange.size); 1246 1247 /* Cleanup ERST Resources */ 1248 apei_resources_fini(&erst_resources); 1249 1250 return 0; 1251 1252 err_release_erange: 1253 release_mem_region(erst_erange.base, erst_erange.size); 1254 err_unmap_reg: 1255 apei_exec_post_unmap_gars(&ctx); 1256 err_release: 1257 apei_resources_release(&erst_resources); 1258 err_fini: 1259 apei_resources_fini(&erst_resources); 1260 err_put_erst_tab: 1261 acpi_put_table((struct acpi_table_header *)erst_tab); 1262 err: 1263 erst_disable = 1; 1264 return rc; 1265 } 1266 1267 device_initcall(erst_init); 1268