arch/powerpc/kernel/fadump.c

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

DEFINITIONS
