arch/powerpc/kernel/fadump.c

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