1 /* 2 * APEI Error Record Serialization Table support 3 * 4 * ERST is a way provided by APEI to save and retrieve hardware error 5 * information to and from a persistent store. 6 * 7 * For more information about ERST, please refer to ACPI Specification 8 * version 4.0, section 17.4. 9 * 10 * Copyright 2010 Intel Corp. 11 * Author: Huang Ying <ying.huang@intel.com> 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/init.h> 30 #include <linux/delay.h> 31 #include <linux/io.h> 32 #include <linux/acpi.h> 33 #include <linux/uaccess.h> 34 #include <linux/cper.h> 35 #include <linux/nmi.h> 36 #include <linux/hardirq.h> 37 #include <acpi/apei.h> 38 39 #include "apei-internal.h" 40 41 #define ERST_PFX "ERST: " 42 43 /* ERST command status */ 44 #define ERST_STATUS_SUCCESS 0x0 45 #define ERST_STATUS_NOT_ENOUGH_SPACE 0x1 46 #define ERST_STATUS_HARDWARE_NOT_AVAILABLE 0x2 47 #define ERST_STATUS_FAILED 0x3 48 #define ERST_STATUS_RECORD_STORE_EMPTY 0x4 49 #define ERST_STATUS_RECORD_NOT_FOUND 0x5 50 51 #define ERST_TAB_ENTRY(tab) \ 52 ((struct acpi_whea_header *)((char *)(tab) + \ 53 sizeof(struct acpi_table_erst))) 54 55 #define SPIN_UNIT 100 /* 100ns */ 56 /* Firmware should respond within 1 miliseconds */ 57 #define FIRMWARE_TIMEOUT (1 * NSEC_PER_MSEC) 58 #define FIRMWARE_MAX_STALL 50 /* 50us */ 59 60 int erst_disable; 61 EXPORT_SYMBOL_GPL(erst_disable); 62 63 static struct acpi_table_erst *erst_tab; 64 65 /* ERST Error Log Address Range atrributes */ 66 #define ERST_RANGE_RESERVED 0x0001 67 #define ERST_RANGE_NVRAM 0x0002 68 #define ERST_RANGE_SLOW 0x0004 69 70 /* 71 * ERST Error Log Address Range, used as buffer for reading/writing 72 * error records. 73 */ 74 static struct erst_erange { 75 u64 base; 76 u64 size; 77 void __iomem *vaddr; 78 u32 attr; 79 } erst_erange; 80 81 /* 82 * Prevent ERST interpreter to run simultaneously, because the 83 * corresponding firmware implementation may not work properly when 84 * invoked simultaneously. 85 * 86 * It is used to provide exclusive accessing for ERST Error Log 87 * Address Range too. 88 */ 89 static DEFINE_SPINLOCK(erst_lock); 90 91 static inline int erst_errno(int command_status) 92 { 93 switch (command_status) { 94 case ERST_STATUS_SUCCESS: 95 return 0; 96 case ERST_STATUS_HARDWARE_NOT_AVAILABLE: 97 return -ENODEV; 98 case ERST_STATUS_NOT_ENOUGH_SPACE: 99 return -ENOSPC; 100 case ERST_STATUS_RECORD_STORE_EMPTY: 101 case ERST_STATUS_RECORD_NOT_FOUND: 102 return -ENOENT; 103 default: 104 return -EINVAL; 105 } 106 } 107 108 static int erst_timedout(u64 *t, u64 spin_unit) 109 { 110 if ((s64)*t < spin_unit) { 111 pr_warning(FW_WARN ERST_PFX 112 "Firmware does not respond in time\n"); 113 return 1; 114 } 115 *t -= spin_unit; 116 ndelay(spin_unit); 117 touch_nmi_watchdog(); 118 return 0; 119 } 120 121 static int erst_exec_load_var1(struct apei_exec_context *ctx, 122 struct acpi_whea_header *entry) 123 { 124 return __apei_exec_read_register(entry, &ctx->var1); 125 } 126 127 static int erst_exec_load_var2(struct apei_exec_context *ctx, 128 struct acpi_whea_header *entry) 129 { 130 return __apei_exec_read_register(entry, &ctx->var2); 131 } 132 133 static int erst_exec_store_var1(struct apei_exec_context *ctx, 134 struct acpi_whea_header *entry) 135 { 136 return __apei_exec_write_register(entry, ctx->var1); 137 } 138 139 static int erst_exec_add(struct apei_exec_context *ctx, 140 struct acpi_whea_header *entry) 141 { 142 ctx->var1 += ctx->var2; 143 return 0; 144 } 145 146 static int erst_exec_subtract(struct apei_exec_context *ctx, 147 struct acpi_whea_header *entry) 148 { 149 ctx->var1 -= ctx->var2; 150 return 0; 151 } 152 153 static int erst_exec_add_value(struct apei_exec_context *ctx, 154 struct acpi_whea_header *entry) 155 { 156 int rc; 157 u64 val; 158 159 rc = __apei_exec_read_register(entry, &val); 160 if (rc) 161 return rc; 162 val += ctx->value; 163 rc = __apei_exec_write_register(entry, val); 164 return rc; 165 } 166 167 static int erst_exec_subtract_value(struct apei_exec_context *ctx, 168 struct acpi_whea_header *entry) 169 { 170 int rc; 171 u64 val; 172 173 rc = __apei_exec_read_register(entry, &val); 174 if (rc) 175 return rc; 176 val -= ctx->value; 177 rc = __apei_exec_write_register(entry, val); 178 return rc; 179 } 180 181 static int erst_exec_stall(struct apei_exec_context *ctx, 182 struct acpi_whea_header *entry) 183 { 184 u64 stall_time; 185 186 if (ctx->value > FIRMWARE_MAX_STALL) { 187 if (!in_nmi()) 188 pr_warning(FW_WARN ERST_PFX 189 "Too long stall time for stall instruction: %llx.\n", 190 ctx->value); 191 stall_time = FIRMWARE_MAX_STALL; 192 } else 193 stall_time = ctx->value; 194 udelay(stall_time); 195 return 0; 196 } 197 198 static int erst_exec_stall_while_true(struct apei_exec_context *ctx, 199 struct acpi_whea_header *entry) 200 { 201 int rc; 202 u64 val; 203 u64 timeout = FIRMWARE_TIMEOUT; 204 u64 stall_time; 205 206 if (ctx->var1 > FIRMWARE_MAX_STALL) { 207 if (!in_nmi()) 208 pr_warning(FW_WARN ERST_PFX 209 "Too long stall time for stall while true instruction: %llx.\n", 210 ctx->var1); 211 stall_time = FIRMWARE_MAX_STALL; 212 } else 213 stall_time = ctx->var1; 214 215 for (;;) { 216 rc = __apei_exec_read_register(entry, &val); 217 if (rc) 218 return rc; 219 if (val != ctx->value) 220 break; 221 if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC)) 222 return -EIO; 223 } 224 return 0; 225 } 226 227 static int erst_exec_skip_next_instruction_if_true( 228 struct apei_exec_context *ctx, 229 struct acpi_whea_header *entry) 230 { 231 int rc; 232 u64 val; 233 234 rc = __apei_exec_read_register(entry, &val); 235 if (rc) 236 return rc; 237 if (val == ctx->value) { 238 ctx->ip += 2; 239 return APEI_EXEC_SET_IP; 240 } 241 242 return 0; 243 } 244 245 static int erst_exec_goto(struct apei_exec_context *ctx, 246 struct acpi_whea_header *entry) 247 { 248 ctx->ip = ctx->value; 249 return APEI_EXEC_SET_IP; 250 } 251 252 static int erst_exec_set_src_address_base(struct apei_exec_context *ctx, 253 struct acpi_whea_header *entry) 254 { 255 return __apei_exec_read_register(entry, &ctx->src_base); 256 } 257 258 static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx, 259 struct acpi_whea_header *entry) 260 { 261 return __apei_exec_read_register(entry, &ctx->dst_base); 262 } 263 264 static int erst_exec_move_data(struct apei_exec_context *ctx, 265 struct acpi_whea_header *entry) 266 { 267 int rc; 268 u64 offset; 269 270 rc = __apei_exec_read_register(entry, &offset); 271 if (rc) 272 return rc; 273 memmove((void *)ctx->dst_base + offset, 274 (void *)ctx->src_base + offset, 275 ctx->var2); 276 277 return 0; 278 } 279 280 static struct apei_exec_ins_type erst_ins_type[] = { 281 [ACPI_ERST_READ_REGISTER] = { 282 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 283 .run = apei_exec_read_register, 284 }, 285 [ACPI_ERST_READ_REGISTER_VALUE] = { 286 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 287 .run = apei_exec_read_register_value, 288 }, 289 [ACPI_ERST_WRITE_REGISTER] = { 290 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 291 .run = apei_exec_write_register, 292 }, 293 [ACPI_ERST_WRITE_REGISTER_VALUE] = { 294 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 295 .run = apei_exec_write_register_value, 296 }, 297 [ACPI_ERST_NOOP] = { 298 .flags = 0, 299 .run = apei_exec_noop, 300 }, 301 [ACPI_ERST_LOAD_VAR1] = { 302 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 303 .run = erst_exec_load_var1, 304 }, 305 [ACPI_ERST_LOAD_VAR2] = { 306 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 307 .run = erst_exec_load_var2, 308 }, 309 [ACPI_ERST_STORE_VAR1] = { 310 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 311 .run = erst_exec_store_var1, 312 }, 313 [ACPI_ERST_ADD] = { 314 .flags = 0, 315 .run = erst_exec_add, 316 }, 317 [ACPI_ERST_SUBTRACT] = { 318 .flags = 0, 319 .run = erst_exec_subtract, 320 }, 321 [ACPI_ERST_ADD_VALUE] = { 322 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 323 .run = erst_exec_add_value, 324 }, 325 [ACPI_ERST_SUBTRACT_VALUE] = { 326 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 327 .run = erst_exec_subtract_value, 328 }, 329 [ACPI_ERST_STALL] = { 330 .flags = 0, 331 .run = erst_exec_stall, 332 }, 333 [ACPI_ERST_STALL_WHILE_TRUE] = { 334 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 335 .run = erst_exec_stall_while_true, 336 }, 337 [ACPI_ERST_SKIP_NEXT_IF_TRUE] = { 338 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 339 .run = erst_exec_skip_next_instruction_if_true, 340 }, 341 [ACPI_ERST_GOTO] = { 342 .flags = 0, 343 .run = erst_exec_goto, 344 }, 345 [ACPI_ERST_SET_SRC_ADDRESS_BASE] = { 346 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 347 .run = erst_exec_set_src_address_base, 348 }, 349 [ACPI_ERST_SET_DST_ADDRESS_BASE] = { 350 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 351 .run = erst_exec_set_dst_address_base, 352 }, 353 [ACPI_ERST_MOVE_DATA] = { 354 .flags = APEI_EXEC_INS_ACCESS_REGISTER, 355 .run = erst_exec_move_data, 356 }, 357 }; 358 359 static inline void erst_exec_ctx_init(struct apei_exec_context *ctx) 360 { 361 apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type), 362 ERST_TAB_ENTRY(erst_tab), erst_tab->entries); 363 } 364 365 static int erst_get_erange(struct erst_erange *range) 366 { 367 struct apei_exec_context ctx; 368 int rc; 369 370 erst_exec_ctx_init(&ctx); 371 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE); 372 if (rc) 373 return rc; 374 range->base = apei_exec_ctx_get_output(&ctx); 375 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH); 376 if (rc) 377 return rc; 378 range->size = apei_exec_ctx_get_output(&ctx); 379 rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES); 380 if (rc) 381 return rc; 382 range->attr = apei_exec_ctx_get_output(&ctx); 383 384 return 0; 385 } 386 387 static ssize_t __erst_get_record_count(void) 388 { 389 struct apei_exec_context ctx; 390 int rc; 391 392 erst_exec_ctx_init(&ctx); 393 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT); 394 if (rc) 395 return rc; 396 return apei_exec_ctx_get_output(&ctx); 397 } 398 399 ssize_t erst_get_record_count(void) 400 { 401 ssize_t count; 402 unsigned long flags; 403 404 if (erst_disable) 405 return -ENODEV; 406 407 spin_lock_irqsave(&erst_lock, flags); 408 count = __erst_get_record_count(); 409 spin_unlock_irqrestore(&erst_lock, flags); 410 411 return count; 412 } 413 EXPORT_SYMBOL_GPL(erst_get_record_count); 414 415 static int __erst_get_next_record_id(u64 *record_id) 416 { 417 struct apei_exec_context ctx; 418 int rc; 419 420 erst_exec_ctx_init(&ctx); 421 rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID); 422 if (rc) 423 return rc; 424 *record_id = apei_exec_ctx_get_output(&ctx); 425 426 return 0; 427 } 428 429 /* 430 * Get the record ID of an existing error record on the persistent 431 * storage. If there is no error record on the persistent storage, the 432 * returned record_id is APEI_ERST_INVALID_RECORD_ID. 433 */ 434 int erst_get_next_record_id(u64 *record_id) 435 { 436 int rc; 437 unsigned long flags; 438 439 if (erst_disable) 440 return -ENODEV; 441 442 spin_lock_irqsave(&erst_lock, flags); 443 rc = __erst_get_next_record_id(record_id); 444 spin_unlock_irqrestore(&erst_lock, flags); 445 446 return rc; 447 } 448 EXPORT_SYMBOL_GPL(erst_get_next_record_id); 449 450 static int __erst_write_to_storage(u64 offset) 451 { 452 struct apei_exec_context ctx; 453 u64 timeout = FIRMWARE_TIMEOUT; 454 u64 val; 455 int rc; 456 457 erst_exec_ctx_init(&ctx); 458 rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_WRITE); 459 if (rc) 460 return rc; 461 apei_exec_ctx_set_input(&ctx, offset); 462 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET); 463 if (rc) 464 return rc; 465 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 466 if (rc) 467 return rc; 468 for (;;) { 469 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 470 if (rc) 471 return rc; 472 val = apei_exec_ctx_get_output(&ctx); 473 if (!val) 474 break; 475 if (erst_timedout(&timeout, SPIN_UNIT)) 476 return -EIO; 477 } 478 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 479 if (rc) 480 return rc; 481 val = apei_exec_ctx_get_output(&ctx); 482 rc = apei_exec_run(&ctx, ACPI_ERST_END); 483 if (rc) 484 return rc; 485 486 return erst_errno(val); 487 } 488 489 static int __erst_read_from_storage(u64 record_id, u64 offset) 490 { 491 struct apei_exec_context ctx; 492 u64 timeout = FIRMWARE_TIMEOUT; 493 u64 val; 494 int rc; 495 496 erst_exec_ctx_init(&ctx); 497 rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_READ); 498 if (rc) 499 return rc; 500 apei_exec_ctx_set_input(&ctx, offset); 501 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET); 502 if (rc) 503 return rc; 504 apei_exec_ctx_set_input(&ctx, record_id); 505 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID); 506 if (rc) 507 return rc; 508 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 509 if (rc) 510 return rc; 511 for (;;) { 512 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 513 if (rc) 514 return rc; 515 val = apei_exec_ctx_get_output(&ctx); 516 if (!val) 517 break; 518 if (erst_timedout(&timeout, SPIN_UNIT)) 519 return -EIO; 520 }; 521 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 522 if (rc) 523 return rc; 524 val = apei_exec_ctx_get_output(&ctx); 525 rc = apei_exec_run(&ctx, ACPI_ERST_END); 526 if (rc) 527 return rc; 528 529 return erst_errno(val); 530 } 531 532 static int __erst_clear_from_storage(u64 record_id) 533 { 534 struct apei_exec_context ctx; 535 u64 timeout = FIRMWARE_TIMEOUT; 536 u64 val; 537 int rc; 538 539 erst_exec_ctx_init(&ctx); 540 rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_CLEAR); 541 if (rc) 542 return rc; 543 apei_exec_ctx_set_input(&ctx, record_id); 544 rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID); 545 if (rc) 546 return rc; 547 rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION); 548 if (rc) 549 return rc; 550 for (;;) { 551 rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS); 552 if (rc) 553 return rc; 554 val = apei_exec_ctx_get_output(&ctx); 555 if (!val) 556 break; 557 if (erst_timedout(&timeout, SPIN_UNIT)) 558 return -EIO; 559 } 560 rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS); 561 if (rc) 562 return rc; 563 val = apei_exec_ctx_get_output(&ctx); 564 rc = apei_exec_run(&ctx, ACPI_ERST_END); 565 if (rc) 566 return rc; 567 568 return erst_errno(val); 569 } 570 571 /* NVRAM ERST Error Log Address Range is not supported yet */ 572 static void pr_unimpl_nvram(void) 573 { 574 if (printk_ratelimit()) 575 pr_warning(ERST_PFX 576 "NVRAM ERST Log Address Range is not implemented yet\n"); 577 } 578 579 static int __erst_write_to_nvram(const struct cper_record_header *record) 580 { 581 /* do not print message, because printk is not safe for NMI */ 582 return -ENOSYS; 583 } 584 585 static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset) 586 { 587 pr_unimpl_nvram(); 588 return -ENOSYS; 589 } 590 591 static int __erst_clear_from_nvram(u64 record_id) 592 { 593 pr_unimpl_nvram(); 594 return -ENOSYS; 595 } 596 597 int erst_write(const struct cper_record_header *record) 598 { 599 int rc; 600 unsigned long flags; 601 struct cper_record_header *rcd_erange; 602 603 if (erst_disable) 604 return -ENODEV; 605 606 if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE)) 607 return -EINVAL; 608 609 if (erst_erange.attr & ERST_RANGE_NVRAM) { 610 if (!spin_trylock_irqsave(&erst_lock, flags)) 611 return -EBUSY; 612 rc = __erst_write_to_nvram(record); 613 spin_unlock_irqrestore(&erst_lock, flags); 614 return rc; 615 } 616 617 if (record->record_length > erst_erange.size) 618 return -EINVAL; 619 620 if (!spin_trylock_irqsave(&erst_lock, flags)) 621 return -EBUSY; 622 memcpy(erst_erange.vaddr, record, record->record_length); 623 rcd_erange = erst_erange.vaddr; 624 /* signature for serialization system */ 625 memcpy(&rcd_erange->persistence_information, "ER", 2); 626 627 rc = __erst_write_to_storage(0); 628 spin_unlock_irqrestore(&erst_lock, flags); 629 630 return rc; 631 } 632 EXPORT_SYMBOL_GPL(erst_write); 633 634 static int __erst_read_to_erange(u64 record_id, u64 *offset) 635 { 636 int rc; 637 638 if (erst_erange.attr & ERST_RANGE_NVRAM) 639 return __erst_read_to_erange_from_nvram( 640 record_id, offset); 641 642 rc = __erst_read_from_storage(record_id, 0); 643 if (rc) 644 return rc; 645 *offset = 0; 646 647 return 0; 648 } 649 650 static ssize_t __erst_read(u64 record_id, struct cper_record_header *record, 651 size_t buflen) 652 { 653 int rc; 654 u64 offset, len = 0; 655 struct cper_record_header *rcd_tmp; 656 657 rc = __erst_read_to_erange(record_id, &offset); 658 if (rc) 659 return rc; 660 rcd_tmp = erst_erange.vaddr + offset; 661 len = rcd_tmp->record_length; 662 if (len <= buflen) 663 memcpy(record, rcd_tmp, len); 664 665 return len; 666 } 667 668 /* 669 * If return value > buflen, the buffer size is not big enough, 670 * else if return value < 0, something goes wrong, 671 * else everything is OK, and return value is record length 672 */ 673 ssize_t erst_read(u64 record_id, struct cper_record_header *record, 674 size_t buflen) 675 { 676 ssize_t len; 677 unsigned long flags; 678 679 if (erst_disable) 680 return -ENODEV; 681 682 spin_lock_irqsave(&erst_lock, flags); 683 len = __erst_read(record_id, record, buflen); 684 spin_unlock_irqrestore(&erst_lock, flags); 685 return len; 686 } 687 EXPORT_SYMBOL_GPL(erst_read); 688 689 /* 690 * If return value > buflen, the buffer size is not big enough, 691 * else if return value = 0, there is no more record to read, 692 * else if return value < 0, something goes wrong, 693 * else everything is OK, and return value is record length 694 */ 695 ssize_t erst_read_next(struct cper_record_header *record, size_t buflen) 696 { 697 int rc; 698 ssize_t len; 699 unsigned long flags; 700 u64 record_id; 701 702 if (erst_disable) 703 return -ENODEV; 704 705 spin_lock_irqsave(&erst_lock, flags); 706 rc = __erst_get_next_record_id(&record_id); 707 if (rc) { 708 spin_unlock_irqrestore(&erst_lock, flags); 709 return rc; 710 } 711 /* no more record */ 712 if (record_id == APEI_ERST_INVALID_RECORD_ID) { 713 spin_unlock_irqrestore(&erst_lock, flags); 714 return 0; 715 } 716 717 len = __erst_read(record_id, record, buflen); 718 spin_unlock_irqrestore(&erst_lock, flags); 719 720 return len; 721 } 722 EXPORT_SYMBOL_GPL(erst_read_next); 723 724 int erst_clear(u64 record_id) 725 { 726 int rc; 727 unsigned long flags; 728 729 if (erst_disable) 730 return -ENODEV; 731 732 spin_lock_irqsave(&erst_lock, flags); 733 if (erst_erange.attr & ERST_RANGE_NVRAM) 734 rc = __erst_clear_from_nvram(record_id); 735 else 736 rc = __erst_clear_from_storage(record_id); 737 spin_unlock_irqrestore(&erst_lock, flags); 738 739 return rc; 740 } 741 EXPORT_SYMBOL_GPL(erst_clear); 742 743 static int __init setup_erst_disable(char *str) 744 { 745 erst_disable = 1; 746 return 0; 747 } 748 749 __setup("erst_disable", setup_erst_disable); 750 751 static int erst_check_table(struct acpi_table_erst *erst_tab) 752 { 753 if (erst_tab->header_length != sizeof(struct acpi_table_erst)) 754 return -EINVAL; 755 if (erst_tab->header.length < sizeof(struct acpi_table_erst)) 756 return -EINVAL; 757 if (erst_tab->entries != 758 (erst_tab->header.length - sizeof(struct acpi_table_erst)) / 759 sizeof(struct acpi_erst_entry)) 760 return -EINVAL; 761 762 return 0; 763 } 764 765 static int __init erst_init(void) 766 { 767 int rc = 0; 768 acpi_status status; 769 struct apei_exec_context ctx; 770 struct apei_resources erst_resources; 771 struct resource *r; 772 773 if (acpi_disabled) 774 goto err; 775 776 if (erst_disable) { 777 pr_info(ERST_PFX 778 "Error Record Serialization Table (ERST) support is disabled.\n"); 779 goto err; 780 } 781 782 status = acpi_get_table(ACPI_SIG_ERST, 0, 783 (struct acpi_table_header **)&erst_tab); 784 if (status == AE_NOT_FOUND) { 785 pr_info(ERST_PFX "Table is not found!\n"); 786 goto err; 787 } else if (ACPI_FAILURE(status)) { 788 const char *msg = acpi_format_exception(status); 789 pr_err(ERST_PFX "Failed to get table, %s\n", msg); 790 rc = -EINVAL; 791 goto err; 792 } 793 794 rc = erst_check_table(erst_tab); 795 if (rc) { 796 pr_err(FW_BUG ERST_PFX "ERST table is invalid\n"); 797 goto err; 798 } 799 800 apei_resources_init(&erst_resources); 801 erst_exec_ctx_init(&ctx); 802 rc = apei_exec_collect_resources(&ctx, &erst_resources); 803 if (rc) 804 goto err_fini; 805 rc = apei_resources_request(&erst_resources, "APEI ERST"); 806 if (rc) 807 goto err_fini; 808 rc = apei_exec_pre_map_gars(&ctx); 809 if (rc) 810 goto err_release; 811 rc = erst_get_erange(&erst_erange); 812 if (rc) { 813 if (rc == -ENODEV) 814 pr_info(ERST_PFX 815 "The corresponding hardware device or firmware implementation " 816 "is not available.\n"); 817 else 818 pr_err(ERST_PFX 819 "Failed to get Error Log Address Range.\n"); 820 goto err_unmap_reg; 821 } 822 823 r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST"); 824 if (!r) { 825 pr_err(ERST_PFX 826 "Can not request iomem region <0x%16llx-0x%16llx> for ERST.\n", 827 (unsigned long long)erst_erange.base, 828 (unsigned long long)erst_erange.base + erst_erange.size); 829 rc = -EIO; 830 goto err_unmap_reg; 831 } 832 rc = -ENOMEM; 833 erst_erange.vaddr = ioremap_cache(erst_erange.base, 834 erst_erange.size); 835 if (!erst_erange.vaddr) 836 goto err_release_erange; 837 838 pr_info(ERST_PFX 839 "Error Record Serialization Table (ERST) support is initialized.\n"); 840 841 return 0; 842 843 err_release_erange: 844 release_mem_region(erst_erange.base, erst_erange.size); 845 err_unmap_reg: 846 apei_exec_post_unmap_gars(&ctx); 847 err_release: 848 apei_resources_release(&erst_resources); 849 err_fini: 850 apei_resources_fini(&erst_resources); 851 err: 852 erst_disable = 1; 853 return rc; 854 } 855 856 device_initcall(erst_init); 857