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 52int erst_disable; 53EXPORT_SYMBOL_GPL(erst_disable); 54 55static struct acpi_table_erst *erst_tab; 56 57/* ERST Error Log Address Range atrributes */ 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 */ 66static 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 */ 81static DEFINE_RAW_SPINLOCK(erst_lock); 82 83static 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 100static 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 112static 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 118static 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 124static 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 130static 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 137static 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 144static 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 158static 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 172static 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 189static 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 218static 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 236static 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 243static 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 249static 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 255static 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 289static 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 368static 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 374static 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 396static 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 408ssize_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} 422EXPORT_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 427struct erst_record_id_cache { 428 struct mutex lock; 429 u64 *entries; 430 int len; 431 int size; 432 int refcount; 433}; 434 435static struct erst_record_id_cache erst_record_id_cache = { 436 .lock = __MUTEX_INITIALIZER(erst_record_id_cache.lock), 437 .refcount = 0, 438}; 439 440static 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 454int 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} 471EXPORT_SYMBOL_GPL(erst_get_record_id_begin); 472 473/* erst_record_id_cache.lock must be held by caller */ 474static 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; 482retry: 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 */ 540int 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 } 577out_unlock: 578 mutex_unlock(&erst_record_id_cache.lock); 579 580 return rc; 581} 582EXPORT_SYMBOL_GPL(erst_get_record_id_next); 583 584/* erst_record_id_cache.lock must be held by caller */ 585static 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 604void 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} 619EXPORT_SYMBOL_GPL(erst_get_record_id_end); 620 621static 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 660static 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 703static 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 */ 743static void pr_unimpl_nvram(void) 744{ 745 if (printk_ratelimit()) 746 pr_warn("NVRAM ERST Log Address Range not implemented yet.\n"); 747} 748 749static 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 755static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset) 756{ 757 pr_unimpl_nvram(); 758 return -ENOSYS; 759} 760 761static int __erst_clear_from_nvram(u64 record_id) 762{ 763 pr_unimpl_nvram(); 764 return -ENOSYS; 765} 766 767int 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} 802EXPORT_SYMBOL_GPL(erst_write); 803 804static 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 820static 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 */ 843ssize_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} 857EXPORT_SYMBOL_GPL(erst_read); 858 859int erst_clear(u64 record_id) 860{ 861 int rc, i; 862 unsigned long flags; 863 u64 *entries; 864 865 if (erst_disable) 866 return -ENODEV; 867 868 rc = mutex_lock_interruptible(&erst_record_id_cache.lock); 869 if (rc) 870 return rc; 871 raw_spin_lock_irqsave(&erst_lock, flags); 872 if (erst_erange.attr & ERST_RANGE_NVRAM) 873 rc = __erst_clear_from_nvram(record_id); 874 else 875 rc = __erst_clear_from_storage(record_id); 876 raw_spin_unlock_irqrestore(&erst_lock, flags); 877 if (rc) 878 goto out; 879 entries = erst_record_id_cache.entries; 880 for (i = 0; i < erst_record_id_cache.len; i++) { 881 if (entries[i] == record_id) 882 entries[i] = APEI_ERST_INVALID_RECORD_ID; 883 } 884 __erst_record_id_cache_compact(); 885out: 886 mutex_unlock(&erst_record_id_cache.lock); 887 return rc; 888} 889EXPORT_SYMBOL_GPL(erst_clear); 890 891static int __init setup_erst_disable(char *str) 892{ 893 erst_disable = 1; 894 return 1; 895} 896 897__setup("erst_disable", setup_erst_disable); 898 899static int erst_check_table(struct acpi_table_erst *erst_tab) 900{ 901 if ((erst_tab->header_length != 902 (sizeof(struct acpi_table_erst) - sizeof(erst_tab->header))) 903 && (erst_tab->header_length != sizeof(struct acpi_table_erst))) 904 return -EINVAL; 905 if (erst_tab->header.length < sizeof(struct acpi_table_erst)) 906 return -EINVAL; 907 if (erst_tab->entries != 908 (erst_tab->header.length - sizeof(struct acpi_table_erst)) / 909 sizeof(struct acpi_erst_entry)) 910 return -EINVAL; 911 912 return 0; 913} 914 915static int erst_open_pstore(struct pstore_info *psi); 916static int erst_close_pstore(struct pstore_info *psi); 917static ssize_t erst_reader(struct pstore_record *record); 918static int erst_writer(struct pstore_record *record); 919static int erst_clearer(struct pstore_record *record); 920 921static struct pstore_info erst_info = { 922 .owner = THIS_MODULE, 923 .name = "erst", 924 .flags = PSTORE_FLAGS_DMESG, 925 .open = erst_open_pstore, 926 .close = erst_close_pstore, 927 .read = erst_reader, 928 .write = erst_writer, 929 .erase = erst_clearer 930}; 931 932#define CPER_CREATOR_PSTORE \ 933 GUID_INIT(0x75a574e3, 0x5052, 0x4b29, 0x8a, 0x8e, 0xbe, 0x2c, \ 934 0x64, 0x90, 0xb8, 0x9d) 935#define CPER_SECTION_TYPE_DMESG \ 936 GUID_INIT(0xc197e04e, 0xd545, 0x4a70, 0x9c, 0x17, 0xa5, 0x54, \ 937 0x94, 0x19, 0xeb, 0x12) 938#define CPER_SECTION_TYPE_DMESG_Z \ 939 GUID_INIT(0x4f118707, 0x04dd, 0x4055, 0xb5, 0xdd, 0x95, 0x6d, \ 940 0x34, 0xdd, 0xfa, 0xc6) 941#define CPER_SECTION_TYPE_MCE \ 942 GUID_INIT(0xfe08ffbe, 0x95e4, 0x4be7, 0xbc, 0x73, 0x40, 0x96, \ 943 0x04, 0x4a, 0x38, 0xfc) 944 945struct cper_pstore_record { 946 struct cper_record_header hdr; 947 struct cper_section_descriptor sec_hdr; 948 char data[]; 949} __packed; 950 951static int reader_pos; 952 953static int erst_open_pstore(struct pstore_info *psi) 954{ 955 int rc; 956 957 if (erst_disable) 958 return -ENODEV; 959 960 rc = erst_get_record_id_begin(&reader_pos); 961 962 return rc; 963} 964 965static int erst_close_pstore(struct pstore_info *psi) 966{ 967 erst_get_record_id_end(); 968 969 return 0; 970} 971 972static ssize_t erst_reader(struct pstore_record *record) 973{ 974 int rc; 975 ssize_t len = 0; 976 u64 record_id; 977 struct cper_pstore_record *rcd; 978 size_t rcd_len = sizeof(*rcd) + erst_info.bufsize; 979 980 if (erst_disable) 981 return -ENODEV; 982 983 rcd = kmalloc(rcd_len, GFP_KERNEL); 984 if (!rcd) { 985 rc = -ENOMEM; 986 goto out; 987 } 988skip: 989 rc = erst_get_record_id_next(&reader_pos, &record_id); 990 if (rc) 991 goto out; 992 993 /* no more record */ 994 if (record_id == APEI_ERST_INVALID_RECORD_ID) { 995 rc = -EINVAL; 996 goto out; 997 } 998 999 len = erst_read(record_id, &rcd->hdr, rcd_len); 1000 /* The record may be cleared by others, try read next record */ 1001 if (len == -ENOENT) 1002 goto skip; 1003 else if (len < 0 || len < sizeof(*rcd)) { 1004 rc = -EIO; 1005 goto out; 1006 } 1007 if (!guid_equal(&rcd->hdr.creator_id, &CPER_CREATOR_PSTORE)) 1008 goto skip; 1009 1010 record->buf = kmalloc(len, GFP_KERNEL); 1011 if (record->buf == NULL) { 1012 rc = -ENOMEM; 1013 goto out; 1014 } 1015 memcpy(record->buf, rcd->data, len - sizeof(*rcd)); 1016 record->id = record_id; 1017 record->compressed = false; 1018 record->ecc_notice_size = 0; 1019 if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_DMESG_Z)) { 1020 record->type = PSTORE_TYPE_DMESG; 1021 record->compressed = true; 1022 } else if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_DMESG)) 1023 record->type = PSTORE_TYPE_DMESG; 1024 else if (guid_equal(&rcd->sec_hdr.section_type, &CPER_SECTION_TYPE_MCE)) 1025 record->type = PSTORE_TYPE_MCE; 1026 else 1027 record->type = PSTORE_TYPE_MAX; 1028 1029 if (rcd->hdr.validation_bits & CPER_VALID_TIMESTAMP) 1030 record->time.tv_sec = rcd->hdr.timestamp; 1031 else 1032 record->time.tv_sec = 0; 1033 record->time.tv_nsec = 0; 1034 1035out: 1036 kfree(rcd); 1037 return (rc < 0) ? rc : (len - sizeof(*rcd)); 1038} 1039 1040static int erst_writer(struct pstore_record *record) 1041{ 1042 struct cper_pstore_record *rcd = (struct cper_pstore_record *) 1043 (erst_info.buf - sizeof(*rcd)); 1044 int ret; 1045 1046 memset(rcd, 0, sizeof(*rcd)); 1047 memcpy(rcd->hdr.signature, CPER_SIG_RECORD, CPER_SIG_SIZE); 1048 rcd->hdr.revision = CPER_RECORD_REV; 1049 rcd->hdr.signature_end = CPER_SIG_END; 1050 rcd->hdr.section_count = 1; 1051 rcd->hdr.error_severity = CPER_SEV_FATAL; 1052 /* timestamp valid. platform_id, partition_id are invalid */ 1053 rcd->hdr.validation_bits = CPER_VALID_TIMESTAMP; 1054 rcd->hdr.timestamp = ktime_get_real_seconds(); 1055 rcd->hdr.record_length = sizeof(*rcd) + record->size; 1056 rcd->hdr.creator_id = CPER_CREATOR_PSTORE; 1057 rcd->hdr.notification_type = CPER_NOTIFY_MCE; 1058 rcd->hdr.record_id = cper_next_record_id(); 1059 rcd->hdr.flags = CPER_HW_ERROR_FLAGS_PREVERR; 1060 1061 rcd->sec_hdr.section_offset = sizeof(*rcd); 1062 rcd->sec_hdr.section_length = record->size; 1063 rcd->sec_hdr.revision = CPER_SEC_REV; 1064 /* fru_id and fru_text is invalid */ 1065 rcd->sec_hdr.validation_bits = 0; 1066 rcd->sec_hdr.flags = CPER_SEC_PRIMARY; 1067 switch (record->type) { 1068 case PSTORE_TYPE_DMESG: 1069 if (record->compressed) 1070 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG_Z; 1071 else 1072 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_DMESG; 1073 break; 1074 case PSTORE_TYPE_MCE: 1075 rcd->sec_hdr.section_type = CPER_SECTION_TYPE_MCE; 1076 break; 1077 default: 1078 return -EINVAL; 1079 } 1080 rcd->sec_hdr.section_severity = CPER_SEV_FATAL; 1081 1082 ret = erst_write(&rcd->hdr); 1083 record->id = rcd->hdr.record_id; 1084 1085 return ret; 1086} 1087 1088static int erst_clearer(struct pstore_record *record) 1089{ 1090 return erst_clear(record->id); 1091} 1092 1093static int __init erst_init(void) 1094{ 1095 int rc = 0; 1096 acpi_status status; 1097 struct apei_exec_context ctx; 1098 struct apei_resources erst_resources; 1099 struct resource *r; 1100 char *buf; 1101 1102 if (acpi_disabled) 1103 goto err; 1104 1105 if (erst_disable) { 1106 pr_info( 1107 "Error Record Serialization Table (ERST) support is disabled.\n"); 1108 goto err; 1109 } 1110 1111 status = acpi_get_table(ACPI_SIG_ERST, 0, 1112 (struct acpi_table_header **)&erst_tab); 1113 if (status == AE_NOT_FOUND) 1114 goto err; 1115 else if (ACPI_FAILURE(status)) { 1116 const char *msg = acpi_format_exception(status); 1117 pr_err("Failed to get table, %s\n", msg); 1118 rc = -EINVAL; 1119 goto err; 1120 } 1121 1122 rc = erst_check_table(erst_tab); 1123 if (rc) { 1124 pr_err(FW_BUG "ERST table is invalid.\n"); 1125 goto err_put_erst_tab; 1126 } 1127 1128 apei_resources_init(&erst_resources); 1129 erst_exec_ctx_init(&ctx); 1130 rc = apei_exec_collect_resources(&ctx, &erst_resources); 1131 if (rc) 1132 goto err_fini; 1133 rc = apei_resources_request(&erst_resources, "APEI ERST"); 1134 if (rc) 1135 goto err_fini; 1136 rc = apei_exec_pre_map_gars(&ctx); 1137 if (rc) 1138 goto err_release; 1139 rc = erst_get_erange(&erst_erange); 1140 if (rc) { 1141 if (rc == -ENODEV) 1142 pr_info( 1143 "The corresponding hardware device or firmware implementation " 1144 "is not available.\n"); 1145 else 1146 pr_err("Failed to get Error Log Address Range.\n"); 1147 goto err_unmap_reg; 1148 } 1149 1150 r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST"); 1151 if (!r) { 1152 pr_err("Can not request [mem %#010llx-%#010llx] for ERST.\n", 1153 (unsigned long long)erst_erange.base, 1154 (unsigned long long)erst_erange.base + erst_erange.size - 1); 1155 rc = -EIO; 1156 goto err_unmap_reg; 1157 } 1158 rc = -ENOMEM; 1159 erst_erange.vaddr = ioremap_cache(erst_erange.base, 1160 erst_erange.size); 1161 if (!erst_erange.vaddr) 1162 goto err_release_erange; 1163 1164 pr_info( 1165 "Error Record Serialization Table (ERST) support is initialized.\n"); 1166 1167 buf = kmalloc(erst_erange.size, GFP_KERNEL); 1168 if (buf) { 1169 erst_info.buf = buf + sizeof(struct cper_pstore_record); 1170 erst_info.bufsize = erst_erange.size - 1171 sizeof(struct cper_pstore_record); 1172 rc = pstore_register(&erst_info); 1173 if (rc) { 1174 if (rc != -EPERM) 1175 pr_info( 1176 "Could not register with persistent store.\n"); 1177 erst_info.buf = NULL; 1178 erst_info.bufsize = 0; 1179 kfree(buf); 1180 } 1181 } else 1182 pr_err( 1183 "Failed to allocate %lld bytes for persistent store error log.\n", 1184 erst_erange.size); 1185 1186 /* Cleanup ERST Resources */ 1187 apei_resources_fini(&erst_resources); 1188 1189 return 0; 1190 1191err_release_erange: 1192 release_mem_region(erst_erange.base, erst_erange.size); 1193err_unmap_reg: 1194 apei_exec_post_unmap_gars(&ctx); 1195err_release: 1196 apei_resources_release(&erst_resources); 1197err_fini: 1198 apei_resources_fini(&erst_resources); 1199err_put_erst_tab: 1200 acpi_put_table((struct acpi_table_header *)erst_tab); 1201err: 1202 erst_disable = 1; 1203 return rc; 1204} 1205 1206device_initcall(erst_init); 1207