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
  45static struct fw_dump fw_dump;
  46
  47static void __init fadump_reserve_crash_area(u64 base);
  48
  49#ifndef CONFIG_PRESERVE_FA_DUMP
  50
  51static struct kobject *fadump_kobj;
  52
  53static atomic_t cpus_in_fadump;
  54static DEFINE_MUTEX(fadump_mutex);
  55
  56static 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))
  61static struct fadump_memory_range rngs[RESERVED_RNGS_CNT];
  62static struct fadump_mrange_info
  63reserved_mrange_info = { "reserved", rngs, RESERVED_RNGS_SZ, 0, RESERVED_RNGS_CNT, true };
  64
  65static void __init early_init_dt_scan_reserved_ranges(unsigned long node);
  66
  67#ifdef CONFIG_CMA
  68static 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 */
  83static 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
 133static int __init fadump_cma_init(void) { return 1; }
 134#endif /* CONFIG_CMA */
 135
 136/* Scan the Firmware Assisted dump configuration details. */
 137int __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 */
 165int 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
 183int should_fadump_crash(void)
 184{
 185	if (!fw_dump.dump_registered || !fw_dump.fadumphdr_addr)
 186		return 0;
 187	return 1;
 188}
 189
 190int 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 */
 199static 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 */
 229bool 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 */
 251bool 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. */
 261static 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 */
 302static __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, NULL, NULL);
 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 */
 363static 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
 389static 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 */
 410static 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
 435static 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 */
 477static 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 */
 503static 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
 530out:
 531	return ret;
 532}
 533
 534int __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;
 655error_out:
 656	fw_dump.fadump_enabled = 0;
 657	fw_dump.reserve_dump_area_size = 0;
 658	return 0;
 659}
 660
 661/* Look for fadump= cmdline option. */
 662static int __init early_fadump_param(char *p)
 663{
 664	if (!p)
 665		return 1;
 666
 667	if (strncmp(p, "on", 2) == 0)
 668		fw_dump.fadump_enabled = 1;
 669	else if (strncmp(p, "off", 3) == 0)
 670		fw_dump.fadump_enabled = 0;
 671	else if (strncmp(p, "nocma", 5) == 0) {
 672		fw_dump.fadump_enabled = 1;
 673		fw_dump.nocma = 1;
 674	}
 675
 676	return 0;
 677}
 678early_param("fadump", early_fadump_param);
 679
 680/*
 681 * Look for fadump_reserve_mem= cmdline option
 682 * TODO: Remove references to 'fadump_reserve_mem=' parameter,
 683 *       the sooner 'crashkernel=' parameter is accustomed to.
 684 */
 685static int __init early_fadump_reserve_mem(char *p)
 686{
 687	if (p)
 688		fw_dump.reserve_bootvar = memparse(p, &p);
 689	return 0;
 690}
 691early_param("fadump_reserve_mem", early_fadump_reserve_mem);
 692
 693void crash_fadump(struct pt_regs *regs, const char *str)
 694{
 695	unsigned int msecs;
 696	struct fadump_crash_info_header *fdh = NULL;
 697	int old_cpu, this_cpu;
 698	/* Do not include first CPU */
 699	unsigned int ncpus = num_online_cpus() - 1;
 700
 701	if (!should_fadump_crash())
 702		return;
 703
 704	/*
 705	 * old_cpu == -1 means this is the first CPU which has come here,
 706	 * go ahead and trigger fadump.
 707	 *
 708	 * old_cpu != -1 means some other CPU has already on it's way
 709	 * to trigger fadump, just keep looping here.
 710	 */
 711	this_cpu = smp_processor_id();
 712	old_cpu = cmpxchg(&crashing_cpu, -1, this_cpu);
 713
 714	if (old_cpu != -1) {
 715		atomic_inc(&cpus_in_fadump);
 716
 717		/*
 718		 * We can't loop here indefinitely. Wait as long as fadump
 719		 * is in force. If we race with fadump un-registration this
 720		 * loop will break and then we go down to normal panic path
 721		 * and reboot. If fadump is in force the first crashing
 722		 * cpu will definitely trigger fadump.
 723		 */
 724		while (fw_dump.dump_registered)
 725			cpu_relax();
 726		return;
 727	}
 728
 729	fdh = __va(fw_dump.fadumphdr_addr);
 730	fdh->crashing_cpu = crashing_cpu;
 731	crash_save_vmcoreinfo();
 732
 733	if (regs)
 734		fdh->regs = *regs;
 735	else
 736		ppc_save_regs(&fdh->regs);
 737
 738	fdh->cpu_mask = *cpu_online_mask;
 739
 740	/*
 741	 * If we came in via system reset, wait a while for the secondary
 742	 * CPUs to enter.
 743	 */
 744	if (TRAP(&(fdh->regs)) == INTERRUPT_SYSTEM_RESET) {
 745		msecs = CRASH_TIMEOUT;
 746		while ((atomic_read(&cpus_in_fadump) < ncpus) && (--msecs > 0))
 747			mdelay(1);
 748	}
 749
 750	fw_dump.ops->fadump_trigger(fdh, str);
 751}
 752
 753u32 *__init fadump_regs_to_elf_notes(u32 *buf, struct pt_regs *regs)
 754{
 755	struct elf_prstatus prstatus;
 756
 757	memset(&prstatus, 0, sizeof(prstatus));
 758	/*
 759	 * FIXME: How do i get PID? Do I really need it?
 760	 * prstatus.pr_pid = ????
 761	 */
 762	elf_core_copy_regs(&prstatus.pr_reg, regs);
 763	buf = append_elf_note(buf, CRASH_CORE_NOTE_NAME, NT_PRSTATUS,
 764			      &prstatus, sizeof(prstatus));
 765	return buf;
 766}
 767
 768void __init fadump_update_elfcore_header(char *bufp)
 769{
 770	struct elf_phdr *phdr;
 771
 772	bufp += sizeof(struct elfhdr);
 773
 774	/* First note is a place holder for cpu notes info. */
 775	phdr = (struct elf_phdr *)bufp;
 776
 777	if (phdr->p_type == PT_NOTE) {
 778		phdr->p_paddr	= __pa(fw_dump.cpu_notes_buf_vaddr);
 779		phdr->p_offset	= phdr->p_paddr;
 780		phdr->p_filesz	= fw_dump.cpu_notes_buf_size;
 781		phdr->p_memsz = fw_dump.cpu_notes_buf_size;
 782	}
 783	return;
 784}
 785
 786static void *__init fadump_alloc_buffer(unsigned long size)
 787{
 788	unsigned long count, i;
 789	struct page *page;
 790	void *vaddr;
 791
 792	vaddr = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
 793	if (!vaddr)
 794		return NULL;
 795
 796	count = PAGE_ALIGN(size) / PAGE_SIZE;
 797	page = virt_to_page(vaddr);
 798	for (i = 0; i < count; i++)
 799		mark_page_reserved(page + i);
 800	return vaddr;
 801}
 802
 803static void fadump_free_buffer(unsigned long vaddr, unsigned long size)
 804{
 805	free_reserved_area((void *)vaddr, (void *)(vaddr + size), -1, NULL);
 806}
 807
 808s32 __init fadump_setup_cpu_notes_buf(u32 num_cpus)
 809{
 810	/* Allocate buffer to hold cpu crash notes. */
 811	fw_dump.cpu_notes_buf_size = num_cpus * sizeof(note_buf_t);
 812	fw_dump.cpu_notes_buf_size = PAGE_ALIGN(fw_dump.cpu_notes_buf_size);
 813	fw_dump.cpu_notes_buf_vaddr =
 814		(unsigned long)fadump_alloc_buffer(fw_dump.cpu_notes_buf_size);
 815	if (!fw_dump.cpu_notes_buf_vaddr) {
 816		pr_err("Failed to allocate %ld bytes for CPU notes buffer\n",
 817		       fw_dump.cpu_notes_buf_size);
 818		return -ENOMEM;
 819	}
 820
 821	pr_debug("Allocated buffer for cpu notes of size %ld at 0x%lx\n",
 822		 fw_dump.cpu_notes_buf_size,
 823		 fw_dump.cpu_notes_buf_vaddr);
 824	return 0;
 825}
 826
 827void fadump_free_cpu_notes_buf(void)
 828{
 829	if (!fw_dump.cpu_notes_buf_vaddr)
 830		return;
 831
 832	fadump_free_buffer(fw_dump.cpu_notes_buf_vaddr,
 833			   fw_dump.cpu_notes_buf_size);
 834	fw_dump.cpu_notes_buf_vaddr = 0;
 835	fw_dump.cpu_notes_buf_size = 0;
 836}
 837
 838static void fadump_free_mem_ranges(struct fadump_mrange_info *mrange_info)
 839{
 840	if (mrange_info->is_static) {
 841		mrange_info->mem_range_cnt = 0;
 842		return;
 843	}
 844
 845	kfree(mrange_info->mem_ranges);
 846	memset((void *)((u64)mrange_info + RNG_NAME_SZ), 0,
 847	       (sizeof(struct fadump_mrange_info) - RNG_NAME_SZ));
 848}
 849
 850/*
 851 * Allocate or reallocate mem_ranges array in incremental units
 852 * of PAGE_SIZE.
 853 */
 854static int fadump_alloc_mem_ranges(struct fadump_mrange_info *mrange_info)
 855{
 856	struct fadump_memory_range *new_array;
 857	u64 new_size;
 858
 859	new_size = mrange_info->mem_ranges_sz + PAGE_SIZE;
 860	pr_debug("Allocating %llu bytes of memory for %s memory ranges\n",
 861		 new_size, mrange_info->name);
 862
 863	new_array = krealloc(mrange_info->mem_ranges, new_size, GFP_KERNEL);
 864	if (new_array == NULL) {
 865		pr_err("Insufficient memory for setting up %s memory ranges\n",
 866		       mrange_info->name);
 867		fadump_free_mem_ranges(mrange_info);
 868		return -ENOMEM;
 869	}
 870
 871	mrange_info->mem_ranges = new_array;
 872	mrange_info->mem_ranges_sz = new_size;
 873	mrange_info->max_mem_ranges = (new_size /
 874				       sizeof(struct fadump_memory_range));
 875	return 0;
 876}
 877static inline int fadump_add_mem_range(struct fadump_mrange_info *mrange_info,
 878				       u64 base, u64 end)
 879{
 880	struct fadump_memory_range *mem_ranges = mrange_info->mem_ranges;
 881	bool is_adjacent = false;
 882	u64 start, size;
 883
 884	if (base == end)
 885		return 0;
 886
 887	/*
 888	 * Fold adjacent memory ranges to bring down the memory ranges/
 889	 * PT_LOAD segments count.
 890	 */
 891	if (mrange_info->mem_range_cnt) {
 892		start = mem_ranges[mrange_info->mem_range_cnt - 1].base;
 893		size  = mem_ranges[mrange_info->mem_range_cnt - 1].size;
 894
 895		/*
 896		 * Boot memory area needs separate PT_LOAD segment(s) as it
 897		 * is moved to a different location at the time of crash.
 898		 * So, fold only if the region is not boot memory area.
 899		 */
 900		if ((start + size) == base && start >= fw_dump.boot_mem_top)
 901			is_adjacent = true;
 902	}
 903	if (!is_adjacent) {
 904		/* resize the array on reaching the limit */
 905		if (mrange_info->mem_range_cnt == mrange_info->max_mem_ranges) {
 906			int ret;
 907
 908			if (mrange_info->is_static) {
 909				pr_err("Reached array size limit for %s memory ranges\n",
 910				       mrange_info->name);
 911				return -ENOSPC;
 912			}
 913
 914			ret = fadump_alloc_mem_ranges(mrange_info);
 915			if (ret)
 916				return ret;
 917
 918			/* Update to the new resized array */
 919			mem_ranges = mrange_info->mem_ranges;
 920		}
 921
 922		start = base;
 923		mem_ranges[mrange_info->mem_range_cnt].base = start;
 924		mrange_info->mem_range_cnt++;
 925	}
 926
 927	mem_ranges[mrange_info->mem_range_cnt - 1].size = (end - start);
 928	pr_debug("%s_memory_range[%d] [%#016llx-%#016llx], %#llx bytes\n",
 929		 mrange_info->name, (mrange_info->mem_range_cnt - 1),
 930		 start, end - 1, (end - start));
 931	return 0;
 932}
 933
 934static int fadump_exclude_reserved_area(u64 start, u64 end)
 935{
 936	u64 ra_start, ra_end;
 937	int ret = 0;
 938
 939	ra_start = fw_dump.reserve_dump_area_start;
 940	ra_end = ra_start + fw_dump.reserve_dump_area_size;
 941
 942	if ((ra_start < end) && (ra_end > start)) {
 943		if ((start < ra_start) && (end > ra_end)) {
 944			ret = fadump_add_mem_range(&crash_mrange_info,
 945						   start, ra_start);
 946			if (ret)
 947				return ret;
 948
 949			ret = fadump_add_mem_range(&crash_mrange_info,
 950						   ra_end, end);
 951		} else if (start < ra_start) {
 952			ret = fadump_add_mem_range(&crash_mrange_info,
 953						   start, ra_start);
 954		} else if (ra_end < end) {
 955			ret = fadump_add_mem_range(&crash_mrange_info,
 956						   ra_end, end);
 957		}
 958	} else
 959		ret = fadump_add_mem_range(&crash_mrange_info, start, end);
 960
 961	return ret;
 962}
 963
 964static int fadump_init_elfcore_header(char *bufp)
 965{
 966	struct elfhdr *elf;
 967
 968	elf = (struct elfhdr *) bufp;
 969	bufp += sizeof(struct elfhdr);
 970	memcpy(elf->e_ident, ELFMAG, SELFMAG);
 971	elf->e_ident[EI_CLASS] = ELF_CLASS;
 972	elf->e_ident[EI_DATA] = ELF_DATA;
 973	elf->e_ident[EI_VERSION] = EV_CURRENT;
 974	elf->e_ident[EI_OSABI] = ELF_OSABI;
 975	memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
 976	elf->e_type = ET_CORE;
 977	elf->e_machine = ELF_ARCH;
 978	elf->e_version = EV_CURRENT;
 979	elf->e_entry = 0;
 980	elf->e_phoff = sizeof(struct elfhdr);
 981	elf->e_shoff = 0;
 982
 983	if (IS_ENABLED(CONFIG_PPC64_ELF_ABI_V2))
 984		elf->e_flags = 2;
 985	else if (IS_ENABLED(CONFIG_PPC64_ELF_ABI_V1))
 986		elf->e_flags = 1;
 987	else
 988		elf->e_flags = 0;
 989
 990	elf->e_ehsize = sizeof(struct elfhdr);
 991	elf->e_phentsize = sizeof(struct elf_phdr);
 992	elf->e_phnum = 0;
 993	elf->e_shentsize = 0;
 994	elf->e_shnum = 0;
 995	elf->e_shstrndx = 0;
 996
 997	return 0;
 998}
 999
1000/*
1001 * Traverse through memblock structure and setup crash memory ranges. These
1002 * ranges will be used create PT_LOAD program headers in elfcore header.
1003 */
1004static int fadump_setup_crash_memory_ranges(void)
1005{
1006	u64 i, start, end;
1007	int ret;
1008
1009	pr_debug("Setup crash memory ranges.\n");
1010	crash_mrange_info.mem_range_cnt = 0;
1011
1012	/*
1013	 * Boot memory region(s) registered with firmware are moved to
1014	 * different location at the time of crash. Create separate program
1015	 * header(s) for this memory chunk(s) with the correct offset.
1016	 */
1017	for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
1018		start = fw_dump.boot_mem_addr[i];
1019		end = start + fw_dump.boot_mem_sz[i];
1020		ret = fadump_add_mem_range(&crash_mrange_info, start, end);
1021		if (ret)
1022			return ret;
1023	}
1024
1025	for_each_mem_range(i, &start, &end) {
1026		/*
1027		 * skip the memory chunk that is already added
1028		 * (0 through boot_memory_top).
1029		 */
1030		if (start < fw_dump.boot_mem_top) {
1031			if (end > fw_dump.boot_mem_top)
1032				start = fw_dump.boot_mem_top;
1033			else
1034				continue;
1035		}
1036
1037		/* add this range excluding the reserved dump area. */
1038		ret = fadump_exclude_reserved_area(start, end);
1039		if (ret)
1040			return ret;
1041	}
1042
1043	return 0;
1044}
1045
1046/*
1047 * If the given physical address falls within the boot memory region then
1048 * return the relocated address that points to the dump region reserved
1049 * for saving initial boot memory contents.
1050 */
1051static inline unsigned long fadump_relocate(unsigned long paddr)
1052{
1053	unsigned long raddr, rstart, rend, rlast, hole_size;
1054	int i;
1055
1056	hole_size = 0;
1057	rlast = 0;
1058	raddr = paddr;
1059	for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
1060		rstart = fw_dump.boot_mem_addr[i];
1061		rend = rstart + fw_dump.boot_mem_sz[i];
1062		hole_size += (rstart - rlast);
1063
1064		if (paddr >= rstart && paddr < rend) {
1065			raddr += fw_dump.boot_mem_dest_addr - hole_size;
1066			break;
1067		}
1068
1069		rlast = rend;
1070	}
1071
1072	pr_debug("vmcoreinfo: paddr = 0x%lx, raddr = 0x%lx\n", paddr, raddr);
1073	return raddr;
1074}
1075
1076static int fadump_create_elfcore_headers(char *bufp)
1077{
1078	unsigned long long raddr, offset;
1079	struct elf_phdr *phdr;
1080	struct elfhdr *elf;
1081	int i, j;
1082
1083	fadump_init_elfcore_header(bufp);
1084	elf = (struct elfhdr *)bufp;
1085	bufp += sizeof(struct elfhdr);
1086
1087	/*
1088	 * setup ELF PT_NOTE, place holder for cpu notes info. The notes info
1089	 * will be populated during second kernel boot after crash. Hence
1090	 * this PT_NOTE will always be the first elf note.
1091	 *
1092	 * NOTE: Any new ELF note addition should be placed after this note.
1093	 */
1094	phdr = (struct elf_phdr *)bufp;
1095	bufp += sizeof(struct elf_phdr);
1096	phdr->p_type = PT_NOTE;
1097	phdr->p_flags = 0;
1098	phdr->p_vaddr = 0;
1099	phdr->p_align = 0;
1100
1101	phdr->p_offset = 0;
1102	phdr->p_paddr = 0;
1103	phdr->p_filesz = 0;
1104	phdr->p_memsz = 0;
1105
1106	(elf->e_phnum)++;
1107
1108	/* setup ELF PT_NOTE for vmcoreinfo */
1109	phdr = (struct elf_phdr *)bufp;
1110	bufp += sizeof(struct elf_phdr);
1111	phdr->p_type	= PT_NOTE;
1112	phdr->p_flags	= 0;
1113	phdr->p_vaddr	= 0;
1114	phdr->p_align	= 0;
1115
1116	phdr->p_paddr	= fadump_relocate(paddr_vmcoreinfo_note());
1117	phdr->p_offset	= phdr->p_paddr;
1118	phdr->p_memsz	= phdr->p_filesz = VMCOREINFO_NOTE_SIZE;
1119
1120	/* Increment number of program headers. */
1121	(elf->e_phnum)++;
1122
1123	/* setup PT_LOAD sections. */
1124	j = 0;
1125	offset = 0;
1126	raddr = fw_dump.boot_mem_addr[0];
1127	for (i = 0; i < crash_mrange_info.mem_range_cnt; i++) {
1128		u64 mbase, msize;
1129
1130		mbase = crash_mrange_info.mem_ranges[i].base;
1131		msize = crash_mrange_info.mem_ranges[i].size;
1132		if (!msize)
1133			continue;
1134
1135		phdr = (struct elf_phdr *)bufp;
1136		bufp += sizeof(struct elf_phdr);
1137		phdr->p_type	= PT_LOAD;
1138		phdr->p_flags	= PF_R|PF_W|PF_X;
1139		phdr->p_offset	= mbase;
1140
1141		if (mbase == raddr) {
1142			/*
1143			 * The entire real memory region will be moved by
1144			 * firmware to the specified destination_address.
1145			 * Hence set the correct offset.
1146			 */
1147			phdr->p_offset = fw_dump.boot_mem_dest_addr + offset;
1148			if (j < (fw_dump.boot_mem_regs_cnt - 1)) {
1149				offset += fw_dump.boot_mem_sz[j];
1150				raddr = fw_dump.boot_mem_addr[++j];
1151			}
1152		}
1153
1154		phdr->p_paddr = mbase;
1155		phdr->p_vaddr = (unsigned long)__va(mbase);
1156		phdr->p_filesz = msize;
1157		phdr->p_memsz = msize;
1158		phdr->p_align = 0;
1159
1160		/* Increment number of program headers. */
1161		(elf->e_phnum)++;
1162	}
1163	return 0;
1164}
1165
1166static unsigned long init_fadump_header(unsigned long addr)
1167{
1168	struct fadump_crash_info_header *fdh;
1169
1170	if (!addr)
1171		return 0;
1172
1173	fdh = __va(addr);
1174	addr += sizeof(struct fadump_crash_info_header);
1175
1176	memset(fdh, 0, sizeof(struct fadump_crash_info_header));
1177	fdh->magic_number = FADUMP_CRASH_INFO_MAGIC;
1178	fdh->elfcorehdr_addr = addr;
1179	/* We will set the crashing cpu id in crash_fadump() during crash. */
1180	fdh->crashing_cpu = FADUMP_CPU_UNKNOWN;
1181	/*
1182	 * When LPAR is terminated by PYHP, ensure all possible CPUs'
1183	 * register data is processed while exporting the vmcore.
1184	 */
1185	fdh->cpu_mask = *cpu_possible_mask;
1186
1187	return addr;
1188}
1189
1190static int register_fadump(void)
1191{
1192	unsigned long addr;
1193	void *vaddr;
1194	int ret;
1195
1196	/*
1197	 * If no memory is reserved then we can not register for firmware-
1198	 * assisted dump.
1199	 */
1200	if (!fw_dump.reserve_dump_area_size)
1201		return -ENODEV;
1202
1203	ret = fadump_setup_crash_memory_ranges();
1204	if (ret)
1205		return ret;
1206
1207	addr = fw_dump.fadumphdr_addr;
1208
1209	/* Initialize fadump crash info header. */
1210	addr = init_fadump_header(addr);
1211	vaddr = __va(addr);
1212
1213	pr_debug("Creating ELF core headers at %#016lx\n", addr);
1214	fadump_create_elfcore_headers(vaddr);
1215
1216	/* register the future kernel dump with firmware. */
1217	pr_debug("Registering for firmware-assisted kernel dump...\n");
1218	return fw_dump.ops->fadump_register(&fw_dump);
1219}
1220
1221void fadump_cleanup(void)
1222{
1223	if (!fw_dump.fadump_supported)
1224		return;
1225
1226	/* Invalidate the registration only if dump is active. */
1227	if (fw_dump.dump_active) {
1228		pr_debug("Invalidating firmware-assisted dump registration\n");
1229		fw_dump.ops->fadump_invalidate(&fw_dump);
1230	} else if (fw_dump.dump_registered) {
1231		/* Un-register Firmware-assisted dump if it was registered. */
1232		fw_dump.ops->fadump_unregister(&fw_dump);
1233		fadump_free_mem_ranges(&crash_mrange_info);
1234	}
1235
1236	if (fw_dump.ops->fadump_cleanup)
1237		fw_dump.ops->fadump_cleanup(&fw_dump);
1238}
1239
1240static void fadump_free_reserved_memory(unsigned long start_pfn,
1241					unsigned long end_pfn)
1242{
1243	unsigned long pfn;
1244	unsigned long time_limit = jiffies + HZ;
1245
1246	pr_info("freeing reserved memory (0x%llx - 0x%llx)\n",
1247		PFN_PHYS(start_pfn), PFN_PHYS(end_pfn));
1248
1249	for (pfn = start_pfn; pfn < end_pfn; pfn++) {
1250		free_reserved_page(pfn_to_page(pfn));
1251
1252		if (time_after(jiffies, time_limit)) {
1253			cond_resched();
1254			time_limit = jiffies + HZ;
1255		}
1256	}
1257}
1258
1259/*
1260 * Skip memory holes and free memory that was actually reserved.
1261 */
1262static void fadump_release_reserved_area(u64 start, u64 end)
1263{
1264	unsigned long reg_spfn, reg_epfn;
1265	u64 tstart, tend, spfn, epfn;
1266	int i;
1267
1268	spfn = PHYS_PFN(start);
1269	epfn = PHYS_PFN(end);
1270
1271	for_each_mem_pfn_range(i, MAX_NUMNODES, &reg_spfn, &reg_epfn, NULL) {
1272		tstart = max_t(u64, spfn, reg_spfn);
1273		tend   = min_t(u64, epfn, reg_epfn);
1274
1275		if (tstart < tend) {
1276			fadump_free_reserved_memory(tstart, tend);
1277
1278			if (tend == epfn)
1279				break;
1280
1281			spfn = tend;
1282		}
1283	}
1284}
1285
1286/*
1287 * Sort the mem ranges in-place and merge adjacent ranges
1288 * to minimize the memory ranges count.
1289 */
1290static void sort_and_merge_mem_ranges(struct fadump_mrange_info *mrange_info)
1291{
1292	struct fadump_memory_range *mem_ranges;
1293	u64 base, size;
1294	int i, j, idx;
1295
1296	if (!reserved_mrange_info.mem_range_cnt)
1297		return;
1298
1299	/* Sort the memory ranges */
1300	mem_ranges = mrange_info->mem_ranges;
1301	for (i = 0; i < mrange_info->mem_range_cnt; i++) {
1302		idx = i;
1303		for (j = (i + 1); j < mrange_info->mem_range_cnt; j++) {
1304			if (mem_ranges[idx].base > mem_ranges[j].base)
1305				idx = j;
1306		}
1307		if (idx != i)
1308			swap(mem_ranges[idx], mem_ranges[i]);
1309	}
1310
1311	/* Merge adjacent reserved ranges */
1312	idx = 0;
1313	for (i = 1; i < mrange_info->mem_range_cnt; i++) {
1314		base = mem_ranges[i-1].base;
1315		size = mem_ranges[i-1].size;
1316		if (mem_ranges[i].base == (base + size))
1317			mem_ranges[idx].size += mem_ranges[i].size;
1318		else {
1319			idx++;
1320			if (i == idx)
1321				continue;
1322
1323			mem_ranges[idx] = mem_ranges[i];
1324		}
1325	}
1326	mrange_info->mem_range_cnt = idx + 1;
1327}
1328
1329/*
1330 * Scan reserved-ranges to consider them while reserving/releasing
1331 * memory for FADump.
1332 */
1333static void __init early_init_dt_scan_reserved_ranges(unsigned long node)
1334{
1335	const __be32 *prop;
1336	int len, ret = -1;
1337	unsigned long i;
1338
1339	/* reserved-ranges already scanned */
1340	if (reserved_mrange_info.mem_range_cnt != 0)
1341		return;
1342
1343	prop = of_get_flat_dt_prop(node, "reserved-ranges", &len);
1344	if (!prop)
1345		return;
1346
1347	/*
1348	 * Each reserved range is an (address,size) pair, 2 cells each,
1349	 * totalling 4 cells per range.
1350	 */
1351	for (i = 0; i < len / (sizeof(*prop) * 4); i++) {
1352		u64 base, size;
1353
1354		base = of_read_number(prop + (i * 4) + 0, 2);
1355		size = of_read_number(prop + (i * 4) + 2, 2);
1356
1357		if (size) {
1358			ret = fadump_add_mem_range(&reserved_mrange_info,
1359						   base, base + size);
1360			if (ret < 0) {
1361				pr_warn("some reserved ranges are ignored!\n");
1362				break;
1363			}
1364		}
1365	}
1366
1367	/* Compact reserved ranges */
1368	sort_and_merge_mem_ranges(&reserved_mrange_info);
1369}
1370
1371/*
1372 * Release the memory that was reserved during early boot to preserve the
1373 * crash'ed kernel's memory contents except reserved dump area (permanent
1374 * reservation) and reserved ranges used by F/W. The released memory will
1375 * be available for general use.
1376 */
1377static void fadump_release_memory(u64 begin, u64 end)
1378{
1379	u64 ra_start, ra_end, tstart;
1380	int i, ret;
1381
1382	ra_start = fw_dump.reserve_dump_area_start;
1383	ra_end = ra_start + fw_dump.reserve_dump_area_size;
1384
1385	/*
1386	 * If reserved ranges array limit is hit, overwrite the last reserved
1387	 * memory range with reserved dump area to ensure it is excluded from
1388	 * the memory being released (reused for next FADump registration).
1389	 */
1390	if (reserved_mrange_info.mem_range_cnt ==
1391	    reserved_mrange_info.max_mem_ranges)
1392		reserved_mrange_info.mem_range_cnt--;
1393
1394	ret = fadump_add_mem_range(&reserved_mrange_info, ra_start, ra_end);
1395	if (ret != 0)
1396		return;
1397
1398	/* Get the reserved ranges list in order first. */
1399	sort_and_merge_mem_ranges(&reserved_mrange_info);
1400
1401	/* Exclude reserved ranges and release remaining memory */
1402	tstart = begin;
1403	for (i = 0; i < reserved_mrange_info.mem_range_cnt; i++) {
1404		ra_start = reserved_mrange_info.mem_ranges[i].base;
1405		ra_end = ra_start + reserved_mrange_info.mem_ranges[i].size;
1406
1407		if (tstart >= ra_end)
1408			continue;
1409
1410		if (tstart < ra_start)
1411			fadump_release_reserved_area(tstart, ra_start);
1412		tstart = ra_end;
1413	}
1414
1415	if (tstart < end)
1416		fadump_release_reserved_area(tstart, end);
1417}
1418
1419static void fadump_invalidate_release_mem(void)
1420{
1421	mutex_lock(&fadump_mutex);
1422	if (!fw_dump.dump_active) {
1423		mutex_unlock(&fadump_mutex);
1424		return;
1425	}
1426
1427	fadump_cleanup();
1428	mutex_unlock(&fadump_mutex);
1429
1430	fadump_release_memory(fw_dump.boot_mem_top, memblock_end_of_DRAM());
1431	fadump_free_cpu_notes_buf();
1432
1433	/*
1434	 * Setup kernel metadata and initialize the kernel dump
1435	 * memory structure for FADump re-registration.
1436	 */
1437	if (fw_dump.ops->fadump_setup_metadata &&
1438	    (fw_dump.ops->fadump_setup_metadata(&fw_dump) < 0))
1439		pr_warn("Failed to setup kernel metadata!\n");
1440	fw_dump.ops->fadump_init_mem_struct(&fw_dump);
1441}
1442
1443static ssize_t release_mem_store(struct kobject *kobj,
1444				 struct kobj_attribute *attr,
1445				 const char *buf, size_t count)
1446{
1447	int input = -1;
1448
1449	if (!fw_dump.dump_active)
1450		return -EPERM;
1451
1452	if (kstrtoint(buf, 0, &input))
1453		return -EINVAL;
1454
1455	if (input == 1) {
1456		/*
1457		 * Take away the '/proc/vmcore'. We are releasing the dump
1458		 * memory, hence it will not be valid anymore.
1459		 */
1460#ifdef CONFIG_PROC_VMCORE
1461		vmcore_cleanup();
1462#endif
1463		fadump_invalidate_release_mem();
1464
1465	} else
1466		return -EINVAL;
1467	return count;
1468}
1469
1470/* Release the reserved memory and disable the FADump */
1471static void __init unregister_fadump(void)
1472{
1473	fadump_cleanup();
1474	fadump_release_memory(fw_dump.reserve_dump_area_start,
1475			      fw_dump.reserve_dump_area_size);
1476	fw_dump.fadump_enabled = 0;
1477	kobject_put(fadump_kobj);
1478}
1479
1480static ssize_t enabled_show(struct kobject *kobj,
1481			    struct kobj_attribute *attr,
1482			    char *buf)
1483{
1484	return sprintf(buf, "%d\n", fw_dump.fadump_enabled);
1485}
1486
1487static ssize_t mem_reserved_show(struct kobject *kobj,
1488				 struct kobj_attribute *attr,
1489				 char *buf)
1490{
1491	return sprintf(buf, "%ld\n", fw_dump.reserve_dump_area_size);
1492}
1493
1494static ssize_t registered_show(struct kobject *kobj,
1495			       struct kobj_attribute *attr,
1496			       char *buf)
1497{
1498	return sprintf(buf, "%d\n", fw_dump.dump_registered);
1499}
1500
1501static ssize_t registered_store(struct kobject *kobj,
1502				struct kobj_attribute *attr,
1503				const char *buf, size_t count)
1504{
1505	int ret = 0;
1506	int input = -1;
1507
1508	if (!fw_dump.fadump_enabled || fw_dump.dump_active)
1509		return -EPERM;
1510
1511	if (kstrtoint(buf, 0, &input))
1512		return -EINVAL;
1513
1514	mutex_lock(&fadump_mutex);
1515
1516	switch (input) {
1517	case 0:
1518		if (fw_dump.dump_registered == 0) {
1519			goto unlock_out;
1520		}
1521
1522		/* Un-register Firmware-assisted dump */
1523		pr_debug("Un-register firmware-assisted dump\n");
1524		fw_dump.ops->fadump_unregister(&fw_dump);
1525		break;
1526	case 1:
1527		if (fw_dump.dump_registered == 1) {
1528			/* Un-register Firmware-assisted dump */
1529			fw_dump.ops->fadump_unregister(&fw_dump);
1530		}
1531		/* Register Firmware-assisted dump */
1532		ret = register_fadump();
1533		break;
1534	default:
1535		ret = -EINVAL;
1536		break;
1537	}
1538
1539unlock_out:
1540	mutex_unlock(&fadump_mutex);
1541	return ret < 0 ? ret : count;
1542}
1543
1544static int fadump_region_show(struct seq_file *m, void *private)
1545{
1546	if (!fw_dump.fadump_enabled)
1547		return 0;
1548
1549	mutex_lock(&fadump_mutex);
1550	fw_dump.ops->fadump_region_show(&fw_dump, m);
1551	mutex_unlock(&fadump_mutex);
1552	return 0;
1553}
1554
1555static struct kobj_attribute release_attr = __ATTR_WO(release_mem);
1556static struct kobj_attribute enable_attr = __ATTR_RO(enabled);
1557static struct kobj_attribute register_attr = __ATTR_RW(registered);
1558static struct kobj_attribute mem_reserved_attr = __ATTR_RO(mem_reserved);
1559
1560static struct attribute *fadump_attrs[] = {
1561	&enable_attr.attr,
1562	&register_attr.attr,
1563	&mem_reserved_attr.attr,
1564	NULL,
1565};
1566
1567ATTRIBUTE_GROUPS(fadump);
1568
1569DEFINE_SHOW_ATTRIBUTE(fadump_region);
1570
1571static void __init fadump_init_files(void)
1572{
1573	int rc = 0;
1574
1575	fadump_kobj = kobject_create_and_add("fadump", kernel_kobj);
1576	if (!fadump_kobj) {
1577		pr_err("failed to create fadump kobject\n");
1578		return;
1579	}
1580
1581	debugfs_create_file("fadump_region", 0444, arch_debugfs_dir, NULL,
1582			    &fadump_region_fops);
1583
1584	if (fw_dump.dump_active) {
1585		rc = sysfs_create_file(fadump_kobj, &release_attr.attr);
1586		if (rc)
1587			pr_err("unable to create release_mem sysfs file (%d)\n",
1588			       rc);
1589	}
1590
1591	rc = sysfs_create_groups(fadump_kobj, fadump_groups);
1592	if (rc) {
1593		pr_err("sysfs group creation failed (%d), unregistering FADump",
1594		       rc);
1595		unregister_fadump();
1596		return;
1597	}
1598
1599	/*
1600	 * The FADump sysfs are moved from kernel_kobj to fadump_kobj need to
1601	 * create symlink at old location to maintain backward compatibility.
1602	 *
1603	 *      - fadump_enabled -> fadump/enabled
1604	 *      - fadump_registered -> fadump/registered
1605	 *      - fadump_release_mem -> fadump/release_mem
1606	 */
1607	rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj,
1608						  "enabled", "fadump_enabled");
1609	if (rc) {
1610		pr_err("unable to create fadump_enabled symlink (%d)", rc);
1611		return;
1612	}
1613
1614	rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj,
1615						  "registered",
1616						  "fadump_registered");
1617	if (rc) {
1618		pr_err("unable to create fadump_registered symlink (%d)", rc);
1619		sysfs_remove_link(kernel_kobj, "fadump_enabled");
1620		return;
1621	}
1622
1623	if (fw_dump.dump_active) {
1624		rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj,
1625							  fadump_kobj,
1626							  "release_mem",
1627							  "fadump_release_mem");
1628		if (rc)
1629			pr_err("unable to create fadump_release_mem symlink (%d)",
1630			       rc);
1631	}
1632	return;
1633}
1634
1635/*
1636 * Prepare for firmware-assisted dump.
1637 */
1638int __init setup_fadump(void)
1639{
1640	if (!fw_dump.fadump_supported)
1641		return 0;
1642
1643	fadump_init_files();
1644	fadump_show_config();
1645
1646	if (!fw_dump.fadump_enabled)
1647		return 1;
1648
1649	/*
1650	 * If dump data is available then see if it is valid and prepare for
1651	 * saving it to the disk.
1652	 */
1653	if (fw_dump.dump_active) {
1654		/*
1655		 * if dump process fails then invalidate the registration
1656		 * and release memory before proceeding for re-registration.
1657		 */
1658		if (fw_dump.ops->fadump_process(&fw_dump) < 0)
1659			fadump_invalidate_release_mem();
1660	}
1661	/* Initialize the kernel dump memory structure and register with f/w */
1662	else if (fw_dump.reserve_dump_area_size) {
1663		fw_dump.ops->fadump_init_mem_struct(&fw_dump);
1664		register_fadump();
1665	}
1666
1667	/*
1668	 * In case of panic, fadump is triggered via ppc_panic_event()
1669	 * panic notifier. Setting crash_kexec_post_notifiers to 'true'
1670	 * lets panic() function take crash friendly path before panic
1671	 * notifiers are invoked.
1672	 */
1673	crash_kexec_post_notifiers = true;
1674
1675	return 1;
1676}
1677/*
1678 * Use subsys_initcall_sync() here because there is dependency with
1679 * crash_save_vmcoreinfo_init(), which must run first to ensure vmcoreinfo initialization
1680 * is done before registering with f/w.
1681 */
1682subsys_initcall_sync(setup_fadump);
1683#else /* !CONFIG_PRESERVE_FA_DUMP */
1684
1685/* Scan the Firmware Assisted dump configuration details. */
1686int __init early_init_dt_scan_fw_dump(unsigned long node, const char *uname,
1687				      int depth, void *data)
1688{
1689	if ((depth != 1) || (strcmp(uname, "ibm,opal") != 0))
1690		return 0;
1691
1692	opal_fadump_dt_scan(&fw_dump, node);
1693	return 1;
1694}
1695
1696/*
1697 * When dump is active but PRESERVE_FA_DUMP is enabled on the kernel,
1698 * preserve crash data. The subsequent memory preserving kernel boot
1699 * is likely to process this crash data.
1700 */
1701int __init fadump_reserve_mem(void)
1702{
1703	if (fw_dump.dump_active) {
1704		/*
1705		 * If last boot has crashed then reserve all the memory
1706		 * above boot memory to preserve crash data.
1707		 */
1708		pr_info("Preserving crash data for processing in next boot.\n");
1709		fadump_reserve_crash_area(fw_dump.boot_mem_top);
1710	} else
1711		pr_debug("FADump-aware kernel..\n");
1712
1713	return 1;
1714}
1715#endif /* CONFIG_PRESERVE_FA_DUMP */
1716
1717/* Preserve everything above the base address */
1718static void __init fadump_reserve_crash_area(u64 base)
1719{
1720	u64 i, mstart, mend, msize;
1721
1722	for_each_mem_range(i, &mstart, &mend) {
1723		msize  = mend - mstart;
1724
1725		if ((mstart + msize) < base)
1726			continue;
1727
1728		if (mstart < base) {
1729			msize -= (base - mstart);
1730			mstart = base;
1731		}
1732
1733		pr_info("Reserving %lluMB of memory at %#016llx for preserving crash data",
1734			(msize >> 20), mstart);
1735		memblock_reserve(mstart, msize);
1736	}
1737}
1738
1739unsigned long __init arch_reserved_kernel_pages(void)
1740{
1741	return memblock_reserved_size() / PAGE_SIZE;
1742}