1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Firmware Assisted dump: A robust mechanism to get reliable kernel crash 4 * dump with assistance from firmware. This approach does not use kexec, 5 * instead firmware assists in booting the kdump kernel while preserving 6 * memory contents. The most of the code implementation has been adapted 7 * from phyp assisted dump implementation written by Linas Vepstas and 8 * Manish Ahuja 9 * 10 * Copyright 2011 IBM Corporation 11 * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com> 12 */ 13 14 #undef DEBUG 15 #define pr_fmt(fmt) "fadump: " fmt 16 17 #include <linux/string.h> 18 #include <linux/memblock.h> 19 #include <linux/delay.h> 20 #include <linux/seq_file.h> 21 #include <linux/crash_dump.h> 22 #include <linux/kobject.h> 23 #include <linux/sysfs.h> 24 #include <linux/slab.h> 25 #include <linux/cma.h> 26 #include <linux/hugetlb.h> 27 #include <linux/debugfs.h> 28 29 #include <asm/page.h> 30 #include <asm/prom.h> 31 #include <asm/fadump.h> 32 #include <asm/fadump-internal.h> 33 #include <asm/setup.h> 34 #include <asm/interrupt.h> 35 36 /* 37 * The CPU who acquired the lock to trigger the fadump crash should 38 * wait for other CPUs to enter. 39 * 40 * The timeout is in milliseconds. 41 */ 42 #define CRASH_TIMEOUT 500 43 44 static struct fw_dump fw_dump; 45 46 static void __init fadump_reserve_crash_area(u64 base); 47 48 #ifndef CONFIG_PRESERVE_FA_DUMP 49 50 static struct kobject *fadump_kobj; 51 52 static atomic_t cpus_in_fadump; 53 static DEFINE_MUTEX(fadump_mutex); 54 55 static struct fadump_mrange_info crash_mrange_info = { "crash", NULL, 0, 0, 0, false }; 56 57 #define RESERVED_RNGS_SZ 16384 /* 16K - 128 entries */ 58 #define RESERVED_RNGS_CNT (RESERVED_RNGS_SZ / \ 59 sizeof(struct fadump_memory_range)) 60 static struct fadump_memory_range rngs[RESERVED_RNGS_CNT]; 61 static struct fadump_mrange_info 62 reserved_mrange_info = { "reserved", rngs, RESERVED_RNGS_SZ, 0, RESERVED_RNGS_CNT, true }; 63 64 static void __init early_init_dt_scan_reserved_ranges(unsigned long node); 65 66 #ifdef CONFIG_CMA 67 static struct cma *fadump_cma; 68 69 /* 70 * fadump_cma_init() - Initialize CMA area from a fadump reserved memory 71 * 72 * This function initializes CMA area from fadump reserved memory. 73 * The total size of fadump reserved memory covers for boot memory size 74 * + cpu data size + hpte size and metadata. 75 * Initialize only the area equivalent to boot memory size for CMA use. 76 * The reamining portion of fadump reserved memory will be not given 77 * to CMA and pages for thoes will stay reserved. boot memory size is 78 * aligned per CMA requirement to satisy cma_init_reserved_mem() call. 79 * But for some reason even if it fails we still have the memory reservation 80 * with us and we can still continue doing fadump. 81 */ 82 static int __init fadump_cma_init(void) 83 { 84 unsigned long long base, size; 85 int rc; 86 87 if (!fw_dump.fadump_enabled) 88 return 0; 89 90 /* 91 * Do not use CMA if user has provided fadump=nocma kernel parameter. 92 * Return 1 to continue with fadump old behaviour. 93 */ 94 if (fw_dump.nocma) 95 return 1; 96 97 base = fw_dump.reserve_dump_area_start; 98 size = fw_dump.boot_memory_size; 99 100 if (!size) 101 return 0; 102 103 rc = cma_init_reserved_mem(base, size, 0, "fadump_cma", &fadump_cma); 104 if (rc) { 105 pr_err("Failed to init cma area for firmware-assisted dump,%d\n", rc); 106 /* 107 * Though the CMA init has failed we still have memory 108 * reservation with us. The reserved memory will be 109 * blocked from production system usage. Hence return 1, 110 * so that we can continue with fadump. 111 */ 112 return 1; 113 } 114 115 /* 116 * If CMA activation fails, keep the pages reserved, instead of 117 * exposing them to buddy allocator. Same as 'fadump=nocma' case. 118 */ 119 cma_reserve_pages_on_error(fadump_cma); 120 121 /* 122 * So we now have successfully initialized cma area for fadump. 123 */ 124 pr_info("Initialized 0x%lx bytes cma area at %ldMB from 0x%lx " 125 "bytes of memory reserved for firmware-assisted dump\n", 126 cma_get_size(fadump_cma), 127 (unsigned long)cma_get_base(fadump_cma) >> 20, 128 fw_dump.reserve_dump_area_size); 129 return 1; 130 } 131 #else 132 static int __init fadump_cma_init(void) { return 1; } 133 #endif /* CONFIG_CMA */ 134 135 /* Scan the Firmware Assisted dump configuration details. */ 136 int __init early_init_dt_scan_fw_dump(unsigned long node, const char *uname, 137 int depth, void *data) 138 { 139 if (depth == 0) { 140 early_init_dt_scan_reserved_ranges(node); 141 return 0; 142 } 143 144 if (depth != 1) 145 return 0; 146 147 if (strcmp(uname, "rtas") == 0) { 148 rtas_fadump_dt_scan(&fw_dump, node); 149 return 1; 150 } 151 152 if (strcmp(uname, "ibm,opal") == 0) { 153 opal_fadump_dt_scan(&fw_dump, node); 154 return 1; 155 } 156 157 return 0; 158 } 159 160 /* 161 * If fadump is registered, check if the memory provided 162 * falls within boot memory area and reserved memory area. 163 */ 164 int is_fadump_memory_area(u64 addr, unsigned long size) 165 { 166 u64 d_start, d_end; 167 168 if (!fw_dump.dump_registered) 169 return 0; 170 171 if (!size) 172 return 0; 173 174 d_start = fw_dump.reserve_dump_area_start; 175 d_end = d_start + fw_dump.reserve_dump_area_size; 176 if (((addr + size) > d_start) && (addr <= d_end)) 177 return 1; 178 179 return (addr <= fw_dump.boot_mem_top); 180 } 181 182 int should_fadump_crash(void) 183 { 184 if (!fw_dump.dump_registered || !fw_dump.fadumphdr_addr) 185 return 0; 186 return 1; 187 } 188 189 int is_fadump_active(void) 190 { 191 return fw_dump.dump_active; 192 } 193 194 /* 195 * Returns true, if there are no holes in memory area between d_start to d_end, 196 * false otherwise. 197 */ 198 static bool is_fadump_mem_area_contiguous(u64 d_start, u64 d_end) 199 { 200 phys_addr_t reg_start, reg_end; 201 bool ret = false; 202 u64 i, start, end; 203 204 for_each_mem_range(i, ®_start, ®_end) { 205 start = max_t(u64, d_start, reg_start); 206 end = min_t(u64, d_end, reg_end); 207 if (d_start < end) { 208 /* Memory hole from d_start to start */ 209 if (start > d_start) 210 break; 211 212 if (end == d_end) { 213 ret = true; 214 break; 215 } 216 217 d_start = end + 1; 218 } 219 } 220 221 return ret; 222 } 223 224 /* 225 * Returns true, if there are no holes in boot memory area, 226 * false otherwise. 227 */ 228 bool is_fadump_boot_mem_contiguous(void) 229 { 230 unsigned long d_start, d_end; 231 bool ret = false; 232 int i; 233 234 for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) { 235 d_start = fw_dump.boot_mem_addr[i]; 236 d_end = d_start + fw_dump.boot_mem_sz[i]; 237 238 ret = is_fadump_mem_area_contiguous(d_start, d_end); 239 if (!ret) 240 break; 241 } 242 243 return ret; 244 } 245 246 /* 247 * Returns true, if there are no holes in reserved memory area, 248 * false otherwise. 249 */ 250 bool is_fadump_reserved_mem_contiguous(void) 251 { 252 u64 d_start, d_end; 253 254 d_start = fw_dump.reserve_dump_area_start; 255 d_end = d_start + fw_dump.reserve_dump_area_size; 256 return is_fadump_mem_area_contiguous(d_start, d_end); 257 } 258 259 /* Print firmware assisted dump configurations for debugging purpose. */ 260 static void __init fadump_show_config(void) 261 { 262 int i; 263 264 pr_debug("Support for firmware-assisted dump (fadump): %s\n", 265 (fw_dump.fadump_supported ? "present" : "no support")); 266 267 if (!fw_dump.fadump_supported) 268 return; 269 270 pr_debug("Fadump enabled : %s\n", 271 (fw_dump.fadump_enabled ? "yes" : "no")); 272 pr_debug("Dump Active : %s\n", 273 (fw_dump.dump_active ? "yes" : "no")); 274 pr_debug("Dump section sizes:\n"); 275 pr_debug(" CPU state data size: %lx\n", fw_dump.cpu_state_data_size); 276 pr_debug(" HPTE region size : %lx\n", fw_dump.hpte_region_size); 277 pr_debug(" Boot memory size : %lx\n", fw_dump.boot_memory_size); 278 pr_debug(" Boot memory top : %llx\n", fw_dump.boot_mem_top); 279 pr_debug("Boot memory regions cnt: %llx\n", fw_dump.boot_mem_regs_cnt); 280 for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) { 281 pr_debug("[%03d] base = %llx, size = %llx\n", i, 282 fw_dump.boot_mem_addr[i], fw_dump.boot_mem_sz[i]); 283 } 284 } 285 286 /** 287 * fadump_calculate_reserve_size(): reserve variable boot area 5% of System RAM 288 * 289 * Function to find the largest memory size we need to reserve during early 290 * boot process. This will be the size of the memory that is required for a 291 * kernel to boot successfully. 292 * 293 * This function has been taken from phyp-assisted dump feature implementation. 294 * 295 * returns larger of 256MB or 5% rounded down to multiples of 256MB. 296 * 297 * TODO: Come up with better approach to find out more accurate memory size 298 * that is required for a kernel to boot successfully. 299 * 300 */ 301 static __init u64 fadump_calculate_reserve_size(void) 302 { 303 u64 base, size, bootmem_min; 304 int ret; 305 306 if (fw_dump.reserve_bootvar) 307 pr_warn("'fadump_reserve_mem=' parameter is deprecated in favor of 'crashkernel=' parameter.\n"); 308 309 /* 310 * Check if the size is specified through crashkernel= cmdline 311 * option. If yes, then use that but ignore base as fadump reserves 312 * memory at a predefined offset. 313 */ 314 ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(), 315 &size, &base); 316 if (ret == 0 && size > 0) { 317 unsigned long max_size; 318 319 if (fw_dump.reserve_bootvar) 320 pr_info("Using 'crashkernel=' parameter for memory reservation.\n"); 321 322 fw_dump.reserve_bootvar = (unsigned long)size; 323 324 /* 325 * Adjust if the boot memory size specified is above 326 * the upper limit. 327 */ 328 max_size = memblock_phys_mem_size() / MAX_BOOT_MEM_RATIO; 329 if (fw_dump.reserve_bootvar > max_size) { 330 fw_dump.reserve_bootvar = max_size; 331 pr_info("Adjusted boot memory size to %luMB\n", 332 (fw_dump.reserve_bootvar >> 20)); 333 } 334 335 return fw_dump.reserve_bootvar; 336 } else if (fw_dump.reserve_bootvar) { 337 /* 338 * 'fadump_reserve_mem=' is being used to reserve memory 339 * for firmware-assisted dump. 340 */ 341 return fw_dump.reserve_bootvar; 342 } 343 344 /* divide by 20 to get 5% of value */ 345 size = memblock_phys_mem_size() / 20; 346 347 /* round it down in multiples of 256 */ 348 size = size & ~0x0FFFFFFFUL; 349 350 /* Truncate to memory_limit. We don't want to over reserve the memory.*/ 351 if (memory_limit && size > memory_limit) 352 size = memory_limit; 353 354 bootmem_min = fw_dump.ops->fadump_get_bootmem_min(); 355 return (size > bootmem_min ? size : bootmem_min); 356 } 357 358 /* 359 * Calculate the total memory size required to be reserved for 360 * firmware-assisted dump registration. 361 */ 362 static unsigned long __init get_fadump_area_size(void) 363 { 364 unsigned long size = 0; 365 366 size += fw_dump.cpu_state_data_size; 367 size += fw_dump.hpte_region_size; 368 size += fw_dump.boot_memory_size; 369 size += sizeof(struct fadump_crash_info_header); 370 size += sizeof(struct elfhdr); /* ELF core header.*/ 371 size += sizeof(struct elf_phdr); /* place holder for cpu notes */ 372 /* Program headers for crash memory regions. */ 373 size += sizeof(struct elf_phdr) * (memblock_num_regions(memory) + 2); 374 375 size = PAGE_ALIGN(size); 376 377 /* This is to hold kernel metadata on platforms that support it */ 378 size += (fw_dump.ops->fadump_get_metadata_size ? 379 fw_dump.ops->fadump_get_metadata_size() : 0); 380 return size; 381 } 382 383 static int __init add_boot_mem_region(unsigned long rstart, 384 unsigned long rsize) 385 { 386 int i = fw_dump.boot_mem_regs_cnt++; 387 388 if (fw_dump.boot_mem_regs_cnt > FADUMP_MAX_MEM_REGS) { 389 fw_dump.boot_mem_regs_cnt = FADUMP_MAX_MEM_REGS; 390 return 0; 391 } 392 393 pr_debug("Added boot memory range[%d] [%#016lx-%#016lx)\n", 394 i, rstart, (rstart + rsize)); 395 fw_dump.boot_mem_addr[i] = rstart; 396 fw_dump.boot_mem_sz[i] = rsize; 397 return 1; 398 } 399 400 /* 401 * Firmware usually has a hard limit on the data it can copy per region. 402 * Honour that by splitting a memory range into multiple regions. 403 */ 404 static int __init add_boot_mem_regions(unsigned long mstart, 405 unsigned long msize) 406 { 407 unsigned long rstart, rsize, max_size; 408 int ret = 1; 409 410 rstart = mstart; 411 max_size = fw_dump.max_copy_size ? fw_dump.max_copy_size : msize; 412 while (msize) { 413 if (msize > max_size) 414 rsize = max_size; 415 else 416 rsize = msize; 417 418 ret = add_boot_mem_region(rstart, rsize); 419 if (!ret) 420 break; 421 422 msize -= rsize; 423 rstart += rsize; 424 } 425 426 return ret; 427 } 428 429 static int __init fadump_get_boot_mem_regions(void) 430 { 431 unsigned long size, cur_size, hole_size, last_end; 432 unsigned long mem_size = fw_dump.boot_memory_size; 433 phys_addr_t reg_start, reg_end; 434 int ret = 1; 435 u64 i; 436 437 fw_dump.boot_mem_regs_cnt = 0; 438 439 last_end = 0; 440 hole_size = 0; 441 cur_size = 0; 442 for_each_mem_range(i, ®_start, ®_end) { 443 size = reg_end - reg_start; 444 hole_size += (reg_start - last_end); 445 446 if ((cur_size + size) >= mem_size) { 447 size = (mem_size - cur_size); 448 ret = add_boot_mem_regions(reg_start, size); 449 break; 450 } 451 452 mem_size -= size; 453 cur_size += size; 454 ret = add_boot_mem_regions(reg_start, size); 455 if (!ret) 456 break; 457 458 last_end = reg_end; 459 } 460 fw_dump.boot_mem_top = PAGE_ALIGN(fw_dump.boot_memory_size + hole_size); 461 462 return ret; 463 } 464 465 /* 466 * Returns true, if the given range overlaps with reserved memory ranges 467 * starting at idx. Also, updates idx to index of overlapping memory range 468 * with the given memory range. 469 * False, otherwise. 470 */ 471 static bool __init overlaps_reserved_ranges(u64 base, u64 end, int *idx) 472 { 473 bool ret = false; 474 int i; 475 476 for (i = *idx; i < reserved_mrange_info.mem_range_cnt; i++) { 477 u64 rbase = reserved_mrange_info.mem_ranges[i].base; 478 u64 rend = rbase + reserved_mrange_info.mem_ranges[i].size; 479 480 if (end <= rbase) 481 break; 482 483 if ((end > rbase) && (base < rend)) { 484 *idx = i; 485 ret = true; 486 break; 487 } 488 } 489 490 return ret; 491 } 492 493 /* 494 * Locate a suitable memory area to reserve memory for FADump. While at it, 495 * lookup reserved-ranges & avoid overlap with them, as they are used by F/W. 496 */ 497 static u64 __init fadump_locate_reserve_mem(u64 base, u64 size) 498 { 499 struct fadump_memory_range *mrngs; 500 phys_addr_t mstart, mend; 501 int idx = 0; 502 u64 i, ret = 0; 503 504 mrngs = reserved_mrange_info.mem_ranges; 505 for_each_free_mem_range(i, NUMA_NO_NODE, MEMBLOCK_NONE, 506 &mstart, &mend, NULL) { 507 pr_debug("%llu) mstart: %llx, mend: %llx, base: %llx\n", 508 i, mstart, mend, base); 509 510 if (mstart > base) 511 base = PAGE_ALIGN(mstart); 512 513 while ((mend > base) && ((mend - base) >= size)) { 514 if (!overlaps_reserved_ranges(base, base+size, &idx)) { 515 ret = base; 516 goto out; 517 } 518 519 base = mrngs[idx].base + mrngs[idx].size; 520 base = PAGE_ALIGN(base); 521 } 522 } 523 524 out: 525 return ret; 526 } 527 528 int __init fadump_reserve_mem(void) 529 { 530 u64 base, size, mem_boundary, bootmem_min; 531 int ret = 1; 532 533 if (!fw_dump.fadump_enabled) 534 return 0; 535 536 if (!fw_dump.fadump_supported) { 537 pr_info("Firmware-Assisted Dump is not supported on this hardware\n"); 538 goto error_out; 539 } 540 541 /* 542 * Initialize boot memory size 543 * If dump is active then we have already calculated the size during 544 * first kernel. 545 */ 546 if (!fw_dump.dump_active) { 547 fw_dump.boot_memory_size = 548 PAGE_ALIGN(fadump_calculate_reserve_size()); 549 #ifdef CONFIG_CMA 550 if (!fw_dump.nocma) { 551 fw_dump.boot_memory_size = 552 ALIGN(fw_dump.boot_memory_size, 553 CMA_MIN_ALIGNMENT_BYTES); 554 } 555 #endif 556 557 bootmem_min = fw_dump.ops->fadump_get_bootmem_min(); 558 if (fw_dump.boot_memory_size < bootmem_min) { 559 pr_err("Can't enable fadump with boot memory size (0x%lx) less than 0x%llx\n", 560 fw_dump.boot_memory_size, bootmem_min); 561 goto error_out; 562 } 563 564 if (!fadump_get_boot_mem_regions()) { 565 pr_err("Too many holes in boot memory area to enable fadump\n"); 566 goto error_out; 567 } 568 } 569 570 /* 571 * Calculate the memory boundary. 572 * If memory_limit is less than actual memory boundary then reserve 573 * the memory for fadump beyond the memory_limit and adjust the 574 * memory_limit accordingly, so that the running kernel can run with 575 * specified memory_limit. 576 */ 577 if (memory_limit && memory_limit < memblock_end_of_DRAM()) { 578 size = get_fadump_area_size(); 579 if ((memory_limit + size) < memblock_end_of_DRAM()) 580 memory_limit += size; 581 else 582 memory_limit = memblock_end_of_DRAM(); 583 printk(KERN_INFO "Adjusted memory_limit for firmware-assisted" 584 " dump, now %#016llx\n", memory_limit); 585 } 586 if (memory_limit) 587 mem_boundary = memory_limit; 588 else 589 mem_boundary = memblock_end_of_DRAM(); 590 591 base = fw_dump.boot_mem_top; 592 size = get_fadump_area_size(); 593 fw_dump.reserve_dump_area_size = size; 594 if (fw_dump.dump_active) { 595 pr_info("Firmware-assisted dump is active.\n"); 596 597 #ifdef CONFIG_HUGETLB_PAGE 598 /* 599 * FADump capture kernel doesn't care much about hugepages. 600 * In fact, handling hugepages in capture kernel is asking for 601 * trouble. So, disable HugeTLB support when fadump is active. 602 */ 603 hugetlb_disabled = true; 604 #endif 605 /* 606 * If last boot has crashed then reserve all the memory 607 * above boot memory size so that we don't touch it until 608 * dump is written to disk by userspace tool. This memory 609 * can be released for general use by invalidating fadump. 610 */ 611 fadump_reserve_crash_area(base); 612 613 pr_debug("fadumphdr_addr = %#016lx\n", fw_dump.fadumphdr_addr); 614 pr_debug("Reserve dump area start address: 0x%lx\n", 615 fw_dump.reserve_dump_area_start); 616 } else { 617 /* 618 * Reserve memory at an offset closer to bottom of the RAM to 619 * minimize the impact of memory hot-remove operation. 620 */ 621 base = fadump_locate_reserve_mem(base, size); 622 623 if (!base || (base + size > mem_boundary)) { 624 pr_err("Failed to find memory chunk for reservation!\n"); 625 goto error_out; 626 } 627 fw_dump.reserve_dump_area_start = base; 628 629 /* 630 * Calculate the kernel metadata address and register it with 631 * f/w if the platform supports. 632 */ 633 if (fw_dump.ops->fadump_setup_metadata && 634 (fw_dump.ops->fadump_setup_metadata(&fw_dump) < 0)) 635 goto error_out; 636 637 if (memblock_reserve(base, size)) { 638 pr_err("Failed to reserve memory!\n"); 639 goto error_out; 640 } 641 642 pr_info("Reserved %lldMB of memory at %#016llx (System RAM: %lldMB)\n", 643 (size >> 20), base, (memblock_phys_mem_size() >> 20)); 644 645 ret = fadump_cma_init(); 646 } 647 648 return ret; 649 error_out: 650 fw_dump.fadump_enabled = 0; 651 return 0; 652 } 653 654 /* Look for fadump= cmdline option. */ 655 static int __init early_fadump_param(char *p) 656 { 657 if (!p) 658 return 1; 659 660 if (strncmp(p, "on", 2) == 0) 661 fw_dump.fadump_enabled = 1; 662 else if (strncmp(p, "off", 3) == 0) 663 fw_dump.fadump_enabled = 0; 664 else if (strncmp(p, "nocma", 5) == 0) { 665 fw_dump.fadump_enabled = 1; 666 fw_dump.nocma = 1; 667 } 668 669 return 0; 670 } 671 early_param("fadump", early_fadump_param); 672 673 /* 674 * Look for fadump_reserve_mem= cmdline option 675 * TODO: Remove references to 'fadump_reserve_mem=' parameter, 676 * the sooner 'crashkernel=' parameter is accustomed to. 677 */ 678 static int __init early_fadump_reserve_mem(char *p) 679 { 680 if (p) 681 fw_dump.reserve_bootvar = memparse(p, &p); 682 return 0; 683 } 684 early_param("fadump_reserve_mem", early_fadump_reserve_mem); 685 686 void crash_fadump(struct pt_regs *regs, const char *str) 687 { 688 unsigned int msecs; 689 struct fadump_crash_info_header *fdh = NULL; 690 int old_cpu, this_cpu; 691 /* Do not include first CPU */ 692 unsigned int ncpus = num_online_cpus() - 1; 693 694 if (!should_fadump_crash()) 695 return; 696 697 /* 698 * old_cpu == -1 means this is the first CPU which has come here, 699 * go ahead and trigger fadump. 700 * 701 * old_cpu != -1 means some other CPU has already on it's way 702 * to trigger fadump, just keep looping here. 703 */ 704 this_cpu = smp_processor_id(); 705 old_cpu = cmpxchg(&crashing_cpu, -1, this_cpu); 706 707 if (old_cpu != -1) { 708 atomic_inc(&cpus_in_fadump); 709 710 /* 711 * We can't loop here indefinitely. Wait as long as fadump 712 * is in force. If we race with fadump un-registration this 713 * loop will break and then we go down to normal panic path 714 * and reboot. If fadump is in force the first crashing 715 * cpu will definitely trigger fadump. 716 */ 717 while (fw_dump.dump_registered) 718 cpu_relax(); 719 return; 720 } 721 722 fdh = __va(fw_dump.fadumphdr_addr); 723 fdh->crashing_cpu = crashing_cpu; 724 crash_save_vmcoreinfo(); 725 726 if (regs) 727 fdh->regs = *regs; 728 else 729 ppc_save_regs(&fdh->regs); 730 731 fdh->online_mask = *cpu_online_mask; 732 733 /* 734 * If we came in via system reset, wait a while for the secondary 735 * CPUs to enter. 736 */ 737 if (TRAP(&(fdh->regs)) == INTERRUPT_SYSTEM_RESET) { 738 msecs = CRASH_TIMEOUT; 739 while ((atomic_read(&cpus_in_fadump) < ncpus) && (--msecs > 0)) 740 mdelay(1); 741 } 742 743 fw_dump.ops->fadump_trigger(fdh, str); 744 } 745 746 u32 *__init fadump_regs_to_elf_notes(u32 *buf, struct pt_regs *regs) 747 { 748 struct elf_prstatus prstatus; 749 750 memset(&prstatus, 0, sizeof(prstatus)); 751 /* 752 * FIXME: How do i get PID? Do I really need it? 753 * prstatus.pr_pid = ???? 754 */ 755 elf_core_copy_kernel_regs(&prstatus.pr_reg, regs); 756 buf = append_elf_note(buf, CRASH_CORE_NOTE_NAME, NT_PRSTATUS, 757 &prstatus, sizeof(prstatus)); 758 return buf; 759 } 760 761 void __init fadump_update_elfcore_header(char *bufp) 762 { 763 struct elf_phdr *phdr; 764 765 bufp += sizeof(struct elfhdr); 766 767 /* First note is a place holder for cpu notes info. */ 768 phdr = (struct elf_phdr *)bufp; 769 770 if (phdr->p_type == PT_NOTE) { 771 phdr->p_paddr = __pa(fw_dump.cpu_notes_buf_vaddr); 772 phdr->p_offset = phdr->p_paddr; 773 phdr->p_filesz = fw_dump.cpu_notes_buf_size; 774 phdr->p_memsz = fw_dump.cpu_notes_buf_size; 775 } 776 return; 777 } 778 779 static void *__init fadump_alloc_buffer(unsigned long size) 780 { 781 unsigned long count, i; 782 struct page *page; 783 void *vaddr; 784 785 vaddr = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO); 786 if (!vaddr) 787 return NULL; 788 789 count = PAGE_ALIGN(size) / PAGE_SIZE; 790 page = virt_to_page(vaddr); 791 for (i = 0; i < count; i++) 792 mark_page_reserved(page + i); 793 return vaddr; 794 } 795 796 static void fadump_free_buffer(unsigned long vaddr, unsigned long size) 797 { 798 free_reserved_area((void *)vaddr, (void *)(vaddr + size), -1, NULL); 799 } 800 801 s32 __init fadump_setup_cpu_notes_buf(u32 num_cpus) 802 { 803 /* Allocate buffer to hold cpu crash notes. */ 804 fw_dump.cpu_notes_buf_size = num_cpus * sizeof(note_buf_t); 805 fw_dump.cpu_notes_buf_size = PAGE_ALIGN(fw_dump.cpu_notes_buf_size); 806 fw_dump.cpu_notes_buf_vaddr = 807 (unsigned long)fadump_alloc_buffer(fw_dump.cpu_notes_buf_size); 808 if (!fw_dump.cpu_notes_buf_vaddr) { 809 pr_err("Failed to allocate %ld bytes for CPU notes buffer\n", 810 fw_dump.cpu_notes_buf_size); 811 return -ENOMEM; 812 } 813 814 pr_debug("Allocated buffer for cpu notes of size %ld at 0x%lx\n", 815 fw_dump.cpu_notes_buf_size, 816 fw_dump.cpu_notes_buf_vaddr); 817 return 0; 818 } 819 820 void fadump_free_cpu_notes_buf(void) 821 { 822 if (!fw_dump.cpu_notes_buf_vaddr) 823 return; 824 825 fadump_free_buffer(fw_dump.cpu_notes_buf_vaddr, 826 fw_dump.cpu_notes_buf_size); 827 fw_dump.cpu_notes_buf_vaddr = 0; 828 fw_dump.cpu_notes_buf_size = 0; 829 } 830 831 static void fadump_free_mem_ranges(struct fadump_mrange_info *mrange_info) 832 { 833 if (mrange_info->is_static) { 834 mrange_info->mem_range_cnt = 0; 835 return; 836 } 837 838 kfree(mrange_info->mem_ranges); 839 memset((void *)((u64)mrange_info + RNG_NAME_SZ), 0, 840 (sizeof(struct fadump_mrange_info) - RNG_NAME_SZ)); 841 } 842 843 /* 844 * Allocate or reallocate mem_ranges array in incremental units 845 * of PAGE_SIZE. 846 */ 847 static int fadump_alloc_mem_ranges(struct fadump_mrange_info *mrange_info) 848 { 849 struct fadump_memory_range *new_array; 850 u64 new_size; 851 852 new_size = mrange_info->mem_ranges_sz + PAGE_SIZE; 853 pr_debug("Allocating %llu bytes of memory for %s memory ranges\n", 854 new_size, mrange_info->name); 855 856 new_array = krealloc(mrange_info->mem_ranges, new_size, GFP_KERNEL); 857 if (new_array == NULL) { 858 pr_err("Insufficient memory for setting up %s memory ranges\n", 859 mrange_info->name); 860 fadump_free_mem_ranges(mrange_info); 861 return -ENOMEM; 862 } 863 864 mrange_info->mem_ranges = new_array; 865 mrange_info->mem_ranges_sz = new_size; 866 mrange_info->max_mem_ranges = (new_size / 867 sizeof(struct fadump_memory_range)); 868 return 0; 869 } 870 871 static inline int fadump_add_mem_range(struct fadump_mrange_info *mrange_info, 872 u64 base, u64 end) 873 { 874 struct fadump_memory_range *mem_ranges = mrange_info->mem_ranges; 875 bool is_adjacent = false; 876 u64 start, size; 877 878 if (base == end) 879 return 0; 880 881 /* 882 * Fold adjacent memory ranges to bring down the memory ranges/ 883 * PT_LOAD segments count. 884 */ 885 if (mrange_info->mem_range_cnt) { 886 start = mem_ranges[mrange_info->mem_range_cnt - 1].base; 887 size = mem_ranges[mrange_info->mem_range_cnt - 1].size; 888 889 if ((start + size) == base) 890 is_adjacent = true; 891 } 892 if (!is_adjacent) { 893 /* resize the array on reaching the limit */ 894 if (mrange_info->mem_range_cnt == mrange_info->max_mem_ranges) { 895 int ret; 896 897 if (mrange_info->is_static) { 898 pr_err("Reached array size limit for %s memory ranges\n", 899 mrange_info->name); 900 return -ENOSPC; 901 } 902 903 ret = fadump_alloc_mem_ranges(mrange_info); 904 if (ret) 905 return ret; 906 907 /* Update to the new resized array */ 908 mem_ranges = mrange_info->mem_ranges; 909 } 910 911 start = base; 912 mem_ranges[mrange_info->mem_range_cnt].base = start; 913 mrange_info->mem_range_cnt++; 914 } 915 916 mem_ranges[mrange_info->mem_range_cnt - 1].size = (end - start); 917 pr_debug("%s_memory_range[%d] [%#016llx-%#016llx], %#llx bytes\n", 918 mrange_info->name, (mrange_info->mem_range_cnt - 1), 919 start, end - 1, (end - start)); 920 return 0; 921 } 922 923 static int fadump_exclude_reserved_area(u64 start, u64 end) 924 { 925 u64 ra_start, ra_end; 926 int ret = 0; 927 928 ra_start = fw_dump.reserve_dump_area_start; 929 ra_end = ra_start + fw_dump.reserve_dump_area_size; 930 931 if ((ra_start < end) && (ra_end > start)) { 932 if ((start < ra_start) && (end > ra_end)) { 933 ret = fadump_add_mem_range(&crash_mrange_info, 934 start, ra_start); 935 if (ret) 936 return ret; 937 938 ret = fadump_add_mem_range(&crash_mrange_info, 939 ra_end, end); 940 } else if (start < ra_start) { 941 ret = fadump_add_mem_range(&crash_mrange_info, 942 start, ra_start); 943 } else if (ra_end < end) { 944 ret = fadump_add_mem_range(&crash_mrange_info, 945 ra_end, end); 946 } 947 } else 948 ret = fadump_add_mem_range(&crash_mrange_info, start, end); 949 950 return ret; 951 } 952 953 static int fadump_init_elfcore_header(char *bufp) 954 { 955 struct elfhdr *elf; 956 957 elf = (struct elfhdr *) bufp; 958 bufp += sizeof(struct elfhdr); 959 memcpy(elf->e_ident, ELFMAG, SELFMAG); 960 elf->e_ident[EI_CLASS] = ELF_CLASS; 961 elf->e_ident[EI_DATA] = ELF_DATA; 962 elf->e_ident[EI_VERSION] = EV_CURRENT; 963 elf->e_ident[EI_OSABI] = ELF_OSABI; 964 memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); 965 elf->e_type = ET_CORE; 966 elf->e_machine = ELF_ARCH; 967 elf->e_version = EV_CURRENT; 968 elf->e_entry = 0; 969 elf->e_phoff = sizeof(struct elfhdr); 970 elf->e_shoff = 0; 971 #if defined(_CALL_ELF) 972 elf->e_flags = _CALL_ELF; 973 #else 974 elf->e_flags = 0; 975 #endif 976 elf->e_ehsize = sizeof(struct elfhdr); 977 elf->e_phentsize = sizeof(struct elf_phdr); 978 elf->e_phnum = 0; 979 elf->e_shentsize = 0; 980 elf->e_shnum = 0; 981 elf->e_shstrndx = 0; 982 983 return 0; 984 } 985 986 /* 987 * Traverse through memblock structure and setup crash memory ranges. These 988 * ranges will be used create PT_LOAD program headers in elfcore header. 989 */ 990 static int fadump_setup_crash_memory_ranges(void) 991 { 992 u64 i, start, end; 993 int ret; 994 995 pr_debug("Setup crash memory ranges.\n"); 996 crash_mrange_info.mem_range_cnt = 0; 997 998 /* 999 * Boot memory region(s) registered with firmware are moved to 1000 * different location at the time of crash. Create separate program 1001 * header(s) for this memory chunk(s) with the correct offset. 1002 */ 1003 for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) { 1004 start = fw_dump.boot_mem_addr[i]; 1005 end = start + fw_dump.boot_mem_sz[i]; 1006 ret = fadump_add_mem_range(&crash_mrange_info, start, end); 1007 if (ret) 1008 return ret; 1009 } 1010 1011 for_each_mem_range(i, &start, &end) { 1012 /* 1013 * skip the memory chunk that is already added 1014 * (0 through boot_memory_top). 1015 */ 1016 if (start < fw_dump.boot_mem_top) { 1017 if (end > fw_dump.boot_mem_top) 1018 start = fw_dump.boot_mem_top; 1019 else 1020 continue; 1021 } 1022 1023 /* add this range excluding the reserved dump area. */ 1024 ret = fadump_exclude_reserved_area(start, end); 1025 if (ret) 1026 return ret; 1027 } 1028 1029 return 0; 1030 } 1031 1032 /* 1033 * If the given physical address falls within the boot memory region then 1034 * return the relocated address that points to the dump region reserved 1035 * for saving initial boot memory contents. 1036 */ 1037 static inline unsigned long fadump_relocate(unsigned long paddr) 1038 { 1039 unsigned long raddr, rstart, rend, rlast, hole_size; 1040 int i; 1041 1042 hole_size = 0; 1043 rlast = 0; 1044 raddr = paddr; 1045 for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) { 1046 rstart = fw_dump.boot_mem_addr[i]; 1047 rend = rstart + fw_dump.boot_mem_sz[i]; 1048 hole_size += (rstart - rlast); 1049 1050 if (paddr >= rstart && paddr < rend) { 1051 raddr += fw_dump.boot_mem_dest_addr - hole_size; 1052 break; 1053 } 1054 1055 rlast = rend; 1056 } 1057 1058 pr_debug("vmcoreinfo: paddr = 0x%lx, raddr = 0x%lx\n", paddr, raddr); 1059 return raddr; 1060 } 1061 1062 static int fadump_create_elfcore_headers(char *bufp) 1063 { 1064 unsigned long long raddr, offset; 1065 struct elf_phdr *phdr; 1066 struct elfhdr *elf; 1067 int i, j; 1068 1069 fadump_init_elfcore_header(bufp); 1070 elf = (struct elfhdr *)bufp; 1071 bufp += sizeof(struct elfhdr); 1072 1073 /* 1074 * setup ELF PT_NOTE, place holder for cpu notes info. The notes info 1075 * will be populated during second kernel boot after crash. Hence 1076 * this PT_NOTE will always be the first elf note. 1077 * 1078 * NOTE: Any new ELF note addition should be placed after this note. 1079 */ 1080 phdr = (struct elf_phdr *)bufp; 1081 bufp += sizeof(struct elf_phdr); 1082 phdr->p_type = PT_NOTE; 1083 phdr->p_flags = 0; 1084 phdr->p_vaddr = 0; 1085 phdr->p_align = 0; 1086 1087 phdr->p_offset = 0; 1088 phdr->p_paddr = 0; 1089 phdr->p_filesz = 0; 1090 phdr->p_memsz = 0; 1091 1092 (elf->e_phnum)++; 1093 1094 /* setup ELF PT_NOTE for vmcoreinfo */ 1095 phdr = (struct elf_phdr *)bufp; 1096 bufp += sizeof(struct elf_phdr); 1097 phdr->p_type = PT_NOTE; 1098 phdr->p_flags = 0; 1099 phdr->p_vaddr = 0; 1100 phdr->p_align = 0; 1101 1102 phdr->p_paddr = fadump_relocate(paddr_vmcoreinfo_note()); 1103 phdr->p_offset = phdr->p_paddr; 1104 phdr->p_memsz = phdr->p_filesz = VMCOREINFO_NOTE_SIZE; 1105 1106 /* Increment number of program headers. */ 1107 (elf->e_phnum)++; 1108 1109 /* setup PT_LOAD sections. */ 1110 j = 0; 1111 offset = 0; 1112 raddr = fw_dump.boot_mem_addr[0]; 1113 for (i = 0; i < crash_mrange_info.mem_range_cnt; i++) { 1114 u64 mbase, msize; 1115 1116 mbase = crash_mrange_info.mem_ranges[i].base; 1117 msize = crash_mrange_info.mem_ranges[i].size; 1118 if (!msize) 1119 continue; 1120 1121 phdr = (struct elf_phdr *)bufp; 1122 bufp += sizeof(struct elf_phdr); 1123 phdr->p_type = PT_LOAD; 1124 phdr->p_flags = PF_R|PF_W|PF_X; 1125 phdr->p_offset = mbase; 1126 1127 if (mbase == raddr) { 1128 /* 1129 * The entire real memory region will be moved by 1130 * firmware to the specified destination_address. 1131 * Hence set the correct offset. 1132 */ 1133 phdr->p_offset = fw_dump.boot_mem_dest_addr + offset; 1134 if (j < (fw_dump.boot_mem_regs_cnt - 1)) { 1135 offset += fw_dump.boot_mem_sz[j]; 1136 raddr = fw_dump.boot_mem_addr[++j]; 1137 } 1138 } 1139 1140 phdr->p_paddr = mbase; 1141 phdr->p_vaddr = (unsigned long)__va(mbase); 1142 phdr->p_filesz = msize; 1143 phdr->p_memsz = msize; 1144 phdr->p_align = 0; 1145 1146 /* Increment number of program headers. */ 1147 (elf->e_phnum)++; 1148 } 1149 return 0; 1150 } 1151 1152 static unsigned long init_fadump_header(unsigned long addr) 1153 { 1154 struct fadump_crash_info_header *fdh; 1155 1156 if (!addr) 1157 return 0; 1158 1159 fdh = __va(addr); 1160 addr += sizeof(struct fadump_crash_info_header); 1161 1162 memset(fdh, 0, sizeof(struct fadump_crash_info_header)); 1163 fdh->magic_number = FADUMP_CRASH_INFO_MAGIC; 1164 fdh->elfcorehdr_addr = addr; 1165 /* We will set the crashing cpu id in crash_fadump() during crash. */ 1166 fdh->crashing_cpu = FADUMP_CPU_UNKNOWN; 1167 1168 return addr; 1169 } 1170 1171 static int register_fadump(void) 1172 { 1173 unsigned long addr; 1174 void *vaddr; 1175 int ret; 1176 1177 /* 1178 * If no memory is reserved then we can not register for firmware- 1179 * assisted dump. 1180 */ 1181 if (!fw_dump.reserve_dump_area_size) 1182 return -ENODEV; 1183 1184 ret = fadump_setup_crash_memory_ranges(); 1185 if (ret) 1186 return ret; 1187 1188 addr = fw_dump.fadumphdr_addr; 1189 1190 /* Initialize fadump crash info header. */ 1191 addr = init_fadump_header(addr); 1192 vaddr = __va(addr); 1193 1194 pr_debug("Creating ELF core headers at %#016lx\n", addr); 1195 fadump_create_elfcore_headers(vaddr); 1196 1197 /* register the future kernel dump with firmware. */ 1198 pr_debug("Registering for firmware-assisted kernel dump...\n"); 1199 return fw_dump.ops->fadump_register(&fw_dump); 1200 } 1201 1202 void fadump_cleanup(void) 1203 { 1204 if (!fw_dump.fadump_supported) 1205 return; 1206 1207 /* Invalidate the registration only if dump is active. */ 1208 if (fw_dump.dump_active) { 1209 pr_debug("Invalidating firmware-assisted dump registration\n"); 1210 fw_dump.ops->fadump_invalidate(&fw_dump); 1211 } else if (fw_dump.dump_registered) { 1212 /* Un-register Firmware-assisted dump if it was registered. */ 1213 fw_dump.ops->fadump_unregister(&fw_dump); 1214 fadump_free_mem_ranges(&crash_mrange_info); 1215 } 1216 1217 if (fw_dump.ops->fadump_cleanup) 1218 fw_dump.ops->fadump_cleanup(&fw_dump); 1219 } 1220 1221 static void fadump_free_reserved_memory(unsigned long start_pfn, 1222 unsigned long end_pfn) 1223 { 1224 unsigned long pfn; 1225 unsigned long time_limit = jiffies + HZ; 1226 1227 pr_info("freeing reserved memory (0x%llx - 0x%llx)\n", 1228 PFN_PHYS(start_pfn), PFN_PHYS(end_pfn)); 1229 1230 for (pfn = start_pfn; pfn < end_pfn; pfn++) { 1231 free_reserved_page(pfn_to_page(pfn)); 1232 1233 if (time_after(jiffies, time_limit)) { 1234 cond_resched(); 1235 time_limit = jiffies + HZ; 1236 } 1237 } 1238 } 1239 1240 /* 1241 * Skip memory holes and free memory that was actually reserved. 1242 */ 1243 static void fadump_release_reserved_area(u64 start, u64 end) 1244 { 1245 unsigned long reg_spfn, reg_epfn; 1246 u64 tstart, tend, spfn, epfn; 1247 int i; 1248 1249 spfn = PHYS_PFN(start); 1250 epfn = PHYS_PFN(end); 1251 1252 for_each_mem_pfn_range(i, MAX_NUMNODES, ®_spfn, ®_epfn, NULL) { 1253 tstart = max_t(u64, spfn, reg_spfn); 1254 tend = min_t(u64, epfn, reg_epfn); 1255 1256 if (tstart < tend) { 1257 fadump_free_reserved_memory(tstart, tend); 1258 1259 if (tend == epfn) 1260 break; 1261 1262 spfn = tend; 1263 } 1264 } 1265 } 1266 1267 /* 1268 * Sort the mem ranges in-place and merge adjacent ranges 1269 * to minimize the memory ranges count. 1270 */ 1271 static void sort_and_merge_mem_ranges(struct fadump_mrange_info *mrange_info) 1272 { 1273 struct fadump_memory_range *mem_ranges; 1274 struct fadump_memory_range tmp_range; 1275 u64 base, size; 1276 int i, j, idx; 1277 1278 if (!reserved_mrange_info.mem_range_cnt) 1279 return; 1280 1281 /* Sort the memory ranges */ 1282 mem_ranges = mrange_info->mem_ranges; 1283 for (i = 0; i < mrange_info->mem_range_cnt; i++) { 1284 idx = i; 1285 for (j = (i + 1); j < mrange_info->mem_range_cnt; j++) { 1286 if (mem_ranges[idx].base > mem_ranges[j].base) 1287 idx = j; 1288 } 1289 if (idx != i) { 1290 tmp_range = mem_ranges[idx]; 1291 mem_ranges[idx] = mem_ranges[i]; 1292 mem_ranges[i] = tmp_range; 1293 } 1294 } 1295 1296 /* Merge adjacent reserved ranges */ 1297 idx = 0; 1298 for (i = 1; i < mrange_info->mem_range_cnt; i++) { 1299 base = mem_ranges[i-1].base; 1300 size = mem_ranges[i-1].size; 1301 if (mem_ranges[i].base == (base + size)) 1302 mem_ranges[idx].size += mem_ranges[i].size; 1303 else { 1304 idx++; 1305 if (i == idx) 1306 continue; 1307 1308 mem_ranges[idx] = mem_ranges[i]; 1309 } 1310 } 1311 mrange_info->mem_range_cnt = idx + 1; 1312 } 1313 1314 /* 1315 * Scan reserved-ranges to consider them while reserving/releasing 1316 * memory for FADump. 1317 */ 1318 static void __init early_init_dt_scan_reserved_ranges(unsigned long node) 1319 { 1320 const __be32 *prop; 1321 int len, ret = -1; 1322 unsigned long i; 1323 1324 /* reserved-ranges already scanned */ 1325 if (reserved_mrange_info.mem_range_cnt != 0) 1326 return; 1327 1328 prop = of_get_flat_dt_prop(node, "reserved-ranges", &len); 1329 if (!prop) 1330 return; 1331 1332 /* 1333 * Each reserved range is an (address,size) pair, 2 cells each, 1334 * totalling 4 cells per range. 1335 */ 1336 for (i = 0; i < len / (sizeof(*prop) * 4); i++) { 1337 u64 base, size; 1338 1339 base = of_read_number(prop + (i * 4) + 0, 2); 1340 size = of_read_number(prop + (i * 4) + 2, 2); 1341 1342 if (size) { 1343 ret = fadump_add_mem_range(&reserved_mrange_info, 1344 base, base + size); 1345 if (ret < 0) { 1346 pr_warn("some reserved ranges are ignored!\n"); 1347 break; 1348 } 1349 } 1350 } 1351 1352 /* Compact reserved ranges */ 1353 sort_and_merge_mem_ranges(&reserved_mrange_info); 1354 } 1355 1356 /* 1357 * Release the memory that was reserved during early boot to preserve the 1358 * crash'ed kernel's memory contents except reserved dump area (permanent 1359 * reservation) and reserved ranges used by F/W. The released memory will 1360 * be available for general use. 1361 */ 1362 static void fadump_release_memory(u64 begin, u64 end) 1363 { 1364 u64 ra_start, ra_end, tstart; 1365 int i, ret; 1366 1367 ra_start = fw_dump.reserve_dump_area_start; 1368 ra_end = ra_start + fw_dump.reserve_dump_area_size; 1369 1370 /* 1371 * If reserved ranges array limit is hit, overwrite the last reserved 1372 * memory range with reserved dump area to ensure it is excluded from 1373 * the memory being released (reused for next FADump registration). 1374 */ 1375 if (reserved_mrange_info.mem_range_cnt == 1376 reserved_mrange_info.max_mem_ranges) 1377 reserved_mrange_info.mem_range_cnt--; 1378 1379 ret = fadump_add_mem_range(&reserved_mrange_info, ra_start, ra_end); 1380 if (ret != 0) 1381 return; 1382 1383 /* Get the reserved ranges list in order first. */ 1384 sort_and_merge_mem_ranges(&reserved_mrange_info); 1385 1386 /* Exclude reserved ranges and release remaining memory */ 1387 tstart = begin; 1388 for (i = 0; i < reserved_mrange_info.mem_range_cnt; i++) { 1389 ra_start = reserved_mrange_info.mem_ranges[i].base; 1390 ra_end = ra_start + reserved_mrange_info.mem_ranges[i].size; 1391 1392 if (tstart >= ra_end) 1393 continue; 1394 1395 if (tstart < ra_start) 1396 fadump_release_reserved_area(tstart, ra_start); 1397 tstart = ra_end; 1398 } 1399 1400 if (tstart < end) 1401 fadump_release_reserved_area(tstart, end); 1402 } 1403 1404 static void fadump_invalidate_release_mem(void) 1405 { 1406 mutex_lock(&fadump_mutex); 1407 if (!fw_dump.dump_active) { 1408 mutex_unlock(&fadump_mutex); 1409 return; 1410 } 1411 1412 fadump_cleanup(); 1413 mutex_unlock(&fadump_mutex); 1414 1415 fadump_release_memory(fw_dump.boot_mem_top, memblock_end_of_DRAM()); 1416 fadump_free_cpu_notes_buf(); 1417 1418 /* 1419 * Setup kernel metadata and initialize the kernel dump 1420 * memory structure for FADump re-registration. 1421 */ 1422 if (fw_dump.ops->fadump_setup_metadata && 1423 (fw_dump.ops->fadump_setup_metadata(&fw_dump) < 0)) 1424 pr_warn("Failed to setup kernel metadata!\n"); 1425 fw_dump.ops->fadump_init_mem_struct(&fw_dump); 1426 } 1427 1428 static ssize_t release_mem_store(struct kobject *kobj, 1429 struct kobj_attribute *attr, 1430 const char *buf, size_t count) 1431 { 1432 int input = -1; 1433 1434 if (!fw_dump.dump_active) 1435 return -EPERM; 1436 1437 if (kstrtoint(buf, 0, &input)) 1438 return -EINVAL; 1439 1440 if (input == 1) { 1441 /* 1442 * Take away the '/proc/vmcore'. We are releasing the dump 1443 * memory, hence it will not be valid anymore. 1444 */ 1445 #ifdef CONFIG_PROC_VMCORE 1446 vmcore_cleanup(); 1447 #endif 1448 fadump_invalidate_release_mem(); 1449 1450 } else 1451 return -EINVAL; 1452 return count; 1453 } 1454 1455 /* Release the reserved memory and disable the FADump */ 1456 static void __init unregister_fadump(void) 1457 { 1458 fadump_cleanup(); 1459 fadump_release_memory(fw_dump.reserve_dump_area_start, 1460 fw_dump.reserve_dump_area_size); 1461 fw_dump.fadump_enabled = 0; 1462 kobject_put(fadump_kobj); 1463 } 1464 1465 static ssize_t enabled_show(struct kobject *kobj, 1466 struct kobj_attribute *attr, 1467 char *buf) 1468 { 1469 return sprintf(buf, "%d\n", fw_dump.fadump_enabled); 1470 } 1471 1472 static ssize_t mem_reserved_show(struct kobject *kobj, 1473 struct kobj_attribute *attr, 1474 char *buf) 1475 { 1476 return sprintf(buf, "%ld\n", fw_dump.reserve_dump_area_size); 1477 } 1478 1479 static ssize_t registered_show(struct kobject *kobj, 1480 struct kobj_attribute *attr, 1481 char *buf) 1482 { 1483 return sprintf(buf, "%d\n", fw_dump.dump_registered); 1484 } 1485 1486 static ssize_t registered_store(struct kobject *kobj, 1487 struct kobj_attribute *attr, 1488 const char *buf, size_t count) 1489 { 1490 int ret = 0; 1491 int input = -1; 1492 1493 if (!fw_dump.fadump_enabled || fw_dump.dump_active) 1494 return -EPERM; 1495 1496 if (kstrtoint(buf, 0, &input)) 1497 return -EINVAL; 1498 1499 mutex_lock(&fadump_mutex); 1500 1501 switch (input) { 1502 case 0: 1503 if (fw_dump.dump_registered == 0) { 1504 goto unlock_out; 1505 } 1506 1507 /* Un-register Firmware-assisted dump */ 1508 pr_debug("Un-register firmware-assisted dump\n"); 1509 fw_dump.ops->fadump_unregister(&fw_dump); 1510 break; 1511 case 1: 1512 if (fw_dump.dump_registered == 1) { 1513 /* Un-register Firmware-assisted dump */ 1514 fw_dump.ops->fadump_unregister(&fw_dump); 1515 } 1516 /* Register Firmware-assisted dump */ 1517 ret = register_fadump(); 1518 break; 1519 default: 1520 ret = -EINVAL; 1521 break; 1522 } 1523 1524 unlock_out: 1525 mutex_unlock(&fadump_mutex); 1526 return ret < 0 ? ret : count; 1527 } 1528 1529 static int fadump_region_show(struct seq_file *m, void *private) 1530 { 1531 if (!fw_dump.fadump_enabled) 1532 return 0; 1533 1534 mutex_lock(&fadump_mutex); 1535 fw_dump.ops->fadump_region_show(&fw_dump, m); 1536 mutex_unlock(&fadump_mutex); 1537 return 0; 1538 } 1539 1540 static struct kobj_attribute release_attr = __ATTR_WO(release_mem); 1541 static struct kobj_attribute enable_attr = __ATTR_RO(enabled); 1542 static struct kobj_attribute register_attr = __ATTR_RW(registered); 1543 static struct kobj_attribute mem_reserved_attr = __ATTR_RO(mem_reserved); 1544 1545 static struct attribute *fadump_attrs[] = { 1546 &enable_attr.attr, 1547 ®ister_attr.attr, 1548 &mem_reserved_attr.attr, 1549 NULL, 1550 }; 1551 1552 ATTRIBUTE_GROUPS(fadump); 1553 1554 DEFINE_SHOW_ATTRIBUTE(fadump_region); 1555 1556 static void __init fadump_init_files(void) 1557 { 1558 int rc = 0; 1559 1560 fadump_kobj = kobject_create_and_add("fadump", kernel_kobj); 1561 if (!fadump_kobj) { 1562 pr_err("failed to create fadump kobject\n"); 1563 return; 1564 } 1565 1566 debugfs_create_file("fadump_region", 0444, arch_debugfs_dir, NULL, 1567 &fadump_region_fops); 1568 1569 if (fw_dump.dump_active) { 1570 rc = sysfs_create_file(fadump_kobj, &release_attr.attr); 1571 if (rc) 1572 pr_err("unable to create release_mem sysfs file (%d)\n", 1573 rc); 1574 } 1575 1576 rc = sysfs_create_groups(fadump_kobj, fadump_groups); 1577 if (rc) { 1578 pr_err("sysfs group creation failed (%d), unregistering FADump", 1579 rc); 1580 unregister_fadump(); 1581 return; 1582 } 1583 1584 /* 1585 * The FADump sysfs are moved from kernel_kobj to fadump_kobj need to 1586 * create symlink at old location to maintain backward compatibility. 1587 * 1588 * - fadump_enabled -> fadump/enabled 1589 * - fadump_registered -> fadump/registered 1590 * - fadump_release_mem -> fadump/release_mem 1591 */ 1592 rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj, 1593 "enabled", "fadump_enabled"); 1594 if (rc) { 1595 pr_err("unable to create fadump_enabled symlink (%d)", rc); 1596 return; 1597 } 1598 1599 rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj, 1600 "registered", 1601 "fadump_registered"); 1602 if (rc) { 1603 pr_err("unable to create fadump_registered symlink (%d)", rc); 1604 sysfs_remove_link(kernel_kobj, "fadump_enabled"); 1605 return; 1606 } 1607 1608 if (fw_dump.dump_active) { 1609 rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, 1610 fadump_kobj, 1611 "release_mem", 1612 "fadump_release_mem"); 1613 if (rc) 1614 pr_err("unable to create fadump_release_mem symlink (%d)", 1615 rc); 1616 } 1617 return; 1618 } 1619 1620 /* 1621 * Prepare for firmware-assisted dump. 1622 */ 1623 int __init setup_fadump(void) 1624 { 1625 if (!fw_dump.fadump_supported) 1626 return 0; 1627 1628 fadump_init_files(); 1629 fadump_show_config(); 1630 1631 if (!fw_dump.fadump_enabled) 1632 return 1; 1633 1634 /* 1635 * If dump data is available then see if it is valid and prepare for 1636 * saving it to the disk. 1637 */ 1638 if (fw_dump.dump_active) { 1639 /* 1640 * if dump process fails then invalidate the registration 1641 * and release memory before proceeding for re-registration. 1642 */ 1643 if (fw_dump.ops->fadump_process(&fw_dump) < 0) 1644 fadump_invalidate_release_mem(); 1645 } 1646 /* Initialize the kernel dump memory structure and register with f/w */ 1647 else if (fw_dump.reserve_dump_area_size) { 1648 fw_dump.ops->fadump_init_mem_struct(&fw_dump); 1649 register_fadump(); 1650 } 1651 1652 /* 1653 * In case of panic, fadump is triggered via ppc_panic_event() 1654 * panic notifier. Setting crash_kexec_post_notifiers to 'true' 1655 * lets panic() function take crash friendly path before panic 1656 * notifiers are invoked. 1657 */ 1658 crash_kexec_post_notifiers = true; 1659 1660 return 1; 1661 } 1662 /* 1663 * Use subsys_initcall_sync() here because there is dependency with 1664 * crash_save_vmcoreinfo_init(), which mush run first to ensure vmcoreinfo initialization 1665 * is done before regisering with f/w. 1666 */ 1667 subsys_initcall_sync(setup_fadump); 1668 #else /* !CONFIG_PRESERVE_FA_DUMP */ 1669 1670 /* Scan the Firmware Assisted dump configuration details. */ 1671 int __init early_init_dt_scan_fw_dump(unsigned long node, const char *uname, 1672 int depth, void *data) 1673 { 1674 if ((depth != 1) || (strcmp(uname, "ibm,opal") != 0)) 1675 return 0; 1676 1677 opal_fadump_dt_scan(&fw_dump, node); 1678 return 1; 1679 } 1680 1681 /* 1682 * When dump is active but PRESERVE_FA_DUMP is enabled on the kernel, 1683 * preserve crash data. The subsequent memory preserving kernel boot 1684 * is likely to process this crash data. 1685 */ 1686 int __init fadump_reserve_mem(void) 1687 { 1688 if (fw_dump.dump_active) { 1689 /* 1690 * If last boot has crashed then reserve all the memory 1691 * above boot memory to preserve crash data. 1692 */ 1693 pr_info("Preserving crash data for processing in next boot.\n"); 1694 fadump_reserve_crash_area(fw_dump.boot_mem_top); 1695 } else 1696 pr_debug("FADump-aware kernel..\n"); 1697 1698 return 1; 1699 } 1700 #endif /* CONFIG_PRESERVE_FA_DUMP */ 1701 1702 /* Preserve everything above the base address */ 1703 static void __init fadump_reserve_crash_area(u64 base) 1704 { 1705 u64 i, mstart, mend, msize; 1706 1707 for_each_mem_range(i, &mstart, &mend) { 1708 msize = mend - mstart; 1709 1710 if ((mstart + msize) < base) 1711 continue; 1712 1713 if (mstart < base) { 1714 msize -= (base - mstart); 1715 mstart = base; 1716 } 1717 1718 pr_info("Reserving %lluMB of memory at %#016llx for preserving crash data", 1719 (msize >> 20), mstart); 1720 memblock_reserve(mstart, msize); 1721 } 1722 } 1723 1724 unsigned long __init arch_reserved_kernel_pages(void) 1725 { 1726 return memblock_reserved_size() / PAGE_SIZE; 1727 } 1728