~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Firmware Assisted dump: A robust mechanism to get reliable kernel crash
3	4	* dump with assistance from firmware. This approach does not use kexec,
..	..	@@ -5,20 +6,6 @@
5	6	* memory contents. The most of the code implementation has been adapted
6	7	* from phyp assisted dump implementation written by Linas Vepstas and
7	8	* Manish Ahuja
8		- *
9		- * This program is free software; you can redistribute it and/or modify
10		- * it under the terms of the GNU General Public License as published by
11		- * the Free Software Foundation; either version 2 of the License, or
12		- * (at your option) any later version.
13		- *
14		- * This program is distributed in the hope that it will be useful,
15		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
16		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		- * GNU General Public License for more details.
18		- *
19		- * You should have received a copy of the GNU General Public License
20		- * along with this program; if not, write to the Free Software
21		- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22	9	*
23	10	* Copyright 2011 IBM Corporation
24	11	* Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
..	..	@@ -35,103 +22,155 @@
35	22	#include <linux/kobject.h>
36	23	#include <linux/sysfs.h>
37	24	#include <linux/slab.h>
	25	+#include <linux/cma.h>
	26	+#include <linux/hugetlb.h>
38	27
39	28	#include <asm/debugfs.h>
40	29	#include <asm/page.h>
41	30	#include <asm/prom.h>
42		-#include <asm/rtas.h>
43	31	#include <asm/fadump.h>
	32	+#include <asm/fadump-internal.h>
44	33	#include <asm/setup.h>
45	34
	35	+/*
	36	+ * The CPU who acquired the lock to trigger the fadump crash should
	37	+ * wait for other CPUs to enter.
	38	+ *
	39	+ * The timeout is in milliseconds.
	40	+ */
	41	+#define CRASH_TIMEOUT 500
	42	+
46	43	static struct fw_dump fw_dump;
47		-static struct fadump_mem_struct fdm;
48		-static const struct fadump_mem_struct *fdm_active;
49	44
	45	+static void __init fadump_reserve_crash_area(u64 base);
	46	+
	47	+struct kobject *fadump_kobj;
	48	+
	49	+#ifndef CONFIG_PRESERVE_FA_DUMP
	50	+
	51	+static atomic_t cpus_in_fadump;
50	52	static DEFINE_MUTEX(fadump_mutex);
51		-struct fad_crash_memory_ranges *crash_memory_ranges;
52		-int crash_memory_ranges_size;
53		-int crash_mem_ranges;
54		-int max_crash_mem_ranges;
55	53
56		-/* Scan the Firmware Assisted dump configuration details. */
57		-int __init early_init_dt_scan_fw_dump(unsigned long node,
58		- const char uname, int depth, void data)
	54	+struct fadump_mrange_info crash_mrange_info = { "crash", NULL, 0, 0, 0, false };
	55	+
	56	+#define RESERVED_RNGS_SZ 16384 /* 16K - 128 entries */
	57	+#define RESERVED_RNGS_CNT (RESERVED_RNGS_SZ / \
	58	+ sizeof(struct fadump_memory_range))
	59	+static struct fadump_memory_range rngs[RESERVED_RNGS_CNT];
	60	+struct fadump_mrange_info reserved_mrange_info = { "reserved", rngs,
	61	+ RESERVED_RNGS_SZ, 0,
	62	+ RESERVED_RNGS_CNT, true };
	63	+
	64	+static void __init early_init_dt_scan_reserved_ranges(unsigned long node);
	65	+
	66	+#ifdef CONFIG_CMA
	67	+static struct cma *fadump_cma;
	68	+
	69	+/*
	70	+ * fadump_cma_init() - Initialize CMA area from a fadump reserved memory
	71	+ *
	72	+ * This function initializes CMA area from fadump reserved memory.
	73	+ * The total size of fadump reserved memory covers for boot memory size
	74	+ * + cpu data size + hpte size and metadata.
	75	+ * Initialize only the area equivalent to boot memory size for CMA use.
	76	+ * The reamining portion of fadump reserved memory will be not given
	77	+ * to CMA and pages for thoes will stay reserved. boot memory size is
	78	+ * aligned per CMA requirement to satisy cma_init_reserved_mem() call.
	79	+ * But for some reason even if it fails we still have the memory reservation
	80	+ * with us and we can still continue doing fadump.
	81	+ */
	82	+int __init fadump_cma_init(void)
59	83	{
60		- const __be32 *sections;
61		- int i, num_sections;
62		- int size;
63		- const __be32 *token;
	84	+ unsigned long long base, size;
	85	+ int rc;
64	86
65		- if (depth != 1 \|\| strcmp(uname, "rtas") != 0)
	87	+ if (!fw_dump.fadump_enabled)
66	88	return 0;
67	89
68	90	/*
69		- * Check if Firmware Assisted dump is supported. if yes, check
70		- * if dump has been initiated on last reboot.
	91	+ * Do not use CMA if user has provided fadump=nocma kernel parameter.
	92	+ * Return 1 to continue with fadump old behaviour.
71	93	*/
72		- token = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump", NULL);
73		- if (!token)
	94	+ if (fw_dump.nocma)
74	95	return 1;
75	96
76		- fw_dump.fadump_supported = 1;
77		- fw_dump.ibm_configure_kernel_dump = be32_to_cpu(*token);
	97	+ base = fw_dump.reserve_dump_area_start;
	98	+ size = fw_dump.boot_memory_size;
78	99
79		- /*
80		- * The 'ibm,kernel-dump' rtas node is present only if there is
81		- * dump data waiting for us.
82		- */
83		- fdm_active = of_get_flat_dt_prop(node, "ibm,kernel-dump", NULL);
84		- if (fdm_active)
85		- fw_dump.dump_active = 1;
	100	+ if (!size)
	101	+ return 0;
86	102
87		- /* Get the sizes required to store dump data for the firmware provided
88		- * dump sections.
89		- * For each dump section type supported, a 32bit cell which defines
90		- * the ID of a supported section followed by two 32 bit cells which
91		- * gives teh size of the section in bytes.
92		- */
93		- sections = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump-sizes",
94		- &size);
95		-
96		- if (!sections)
	103	+ rc = cma_init_reserved_mem(base, size, 0, "fadump_cma", &fadump_cma);
	104	+ if (rc) {
	105	+ pr_err("Failed to init cma area for firmware-assisted dump,%d\n", rc);
	106	+ /*
	107	+ * Though the CMA init has failed we still have memory
	108	+ * reservation with us. The reserved memory will be
	109	+ * blocked from production system usage. Hence return 1,
	110	+ * so that we can continue with fadump.
	111	+ */
97	112	return 1;
98		-
99		- num_sections = size / (3 * sizeof(u32));
100		-
101		- for (i = 0; i < num_sections; i++, sections += 3) {
102		- u32 type = (u32)of_read_number(sections, 1);
103		-
104		- switch (type) {
105		- case FADUMP_CPU_STATE_DATA:
106		- fw_dump.cpu_state_data_size =
107		- of_read_ulong(&sections[1], 2);
108		- break;
109		- case FADUMP_HPTE_REGION:
110		- fw_dump.hpte_region_size =
111		- of_read_ulong(&sections[1], 2);
112		- break;
113		- }
114	113	}
115	114
	115	+ /*
	116	+ * So we now have successfully initialized cma area for fadump.
	117	+ */
	118	+ pr_info("Initialized 0x%lx bytes cma area at %ldMB from 0x%lx "
	119	+ "bytes of memory reserved for firmware-assisted dump\n",
	120	+ cma_get_size(fadump_cma),
	121	+ (unsigned long)cma_get_base(fadump_cma) >> 20,
	122	+ fw_dump.reserve_dump_area_size);
116	123	return 1;
	124	+}
	125	+#else
	126	+static int __init fadump_cma_init(void) { return 1; }
	127	+#endif /* CONFIG_CMA */
	128	+
	129	+/* Scan the Firmware Assisted dump configuration details. */
	130	+int __init early_init_dt_scan_fw_dump(unsigned long node, const char *uname,
	131	+ int depth, void *data)
	132	+{
	133	+ if (depth == 0) {
	134	+ early_init_dt_scan_reserved_ranges(node);
	135	+ return 0;
	136	+ }
	137	+
	138	+ if (depth != 1)
	139	+ return 0;
	140	+
	141	+ if (strcmp(uname, "rtas") == 0) {
	142	+ rtas_fadump_dt_scan(&fw_dump, node);
	143	+ return 1;
	144	+ }
	145	+
	146	+ if (strcmp(uname, "ibm,opal") == 0) {
	147	+ opal_fadump_dt_scan(&fw_dump, node);
	148	+ return 1;
	149	+ }
	150	+
	151	+ return 0;
117	152	}
118	153
119	154	/*
120	155	* If fadump is registered, check if the memory provided
121	156	* falls within boot memory area and reserved memory area.
122	157	*/
123		-int is_fadump_memory_area(u64 addr, ulong size)
	158	+int is_fadump_memory_area(u64 addr, unsigned long size)
124	159	{
125		- u64 d_start = fw_dump.reserve_dump_area_start;
126		- u64 d_end = d_start + fw_dump.reserve_dump_area_size;
	160	+ u64 d_start, d_end;
127	161
128	162	if (!fw_dump.dump_registered)
129	163	return 0;
130	164
	165	+ if (!size)
	166	+ return 0;
	167	+
	168	+ d_start = fw_dump.reserve_dump_area_start;
	169	+ d_end = d_start + fw_dump.reserve_dump_area_size;
131	170	if (((addr + size) > d_start) && (addr <= d_end))
132	171	return 1;
133	172
134		- return (addr + size) > RMA_START && addr <= fw_dump.boot_memory_size;
	173	+ return (addr <= fw_dump.boot_mem_top);
135	174	}
136	175
137	176	int should_fadump_crash(void)
..	..	@@ -147,40 +186,75 @@
147	186	}
148	187
149	188	/*
150		- * Returns 1, if there are no holes in boot memory area,
151		- * 0 otherwise.
	189	+ * Returns true, if there are no holes in memory area between d_start to d_end,
	190	+ * false otherwise.
152	191	*/
153		-static int is_boot_memory_area_contiguous(void)
	192	+static bool is_fadump_mem_area_contiguous(u64 d_start, u64 d_end)
154	193	{
155		- struct memblock_region *reg;
156		- unsigned long tstart, tend;
157		- unsigned long start_pfn = PHYS_PFN(RMA_START);
158		- unsigned long end_pfn = PHYS_PFN(RMA_START + fw_dump.boot_memory_size);
159		- unsigned int ret = 0;
	194	+ phys_addr_t reg_start, reg_end;
	195	+ bool ret = false;
	196	+ u64 i, start, end;
160	197
161		- for_each_memblock(memory, reg) {
162		- tstart = max(start_pfn, memblock_region_memory_base_pfn(reg));
163		- tend = min(end_pfn, memblock_region_memory_end_pfn(reg));
164		- if (tstart < tend) {
165		- /* Memory hole from start_pfn to tstart */
166		- if (tstart > start_pfn)
	198	+ for_each_mem_range(i, &reg_start, &reg_end) {
	199	+ start = max_t(u64, d_start, reg_start);
	200	+ end = min_t(u64, d_end, reg_end);
	201	+ if (d_start < end) {
	202	+ /* Memory hole from d_start to start */
	203	+ if (start > d_start)
167	204	break;
168	205
169		- if (tend == end_pfn) {
170		- ret = 1;
	206	+ if (end == d_end) {
	207	+ ret = true;
171	208	break;
172	209	}
173	210
174		- start_pfn = tend + 1;
	211	+ d_start = end + 1;
175	212	}
176	213	}
177	214
178	215	return ret;
179	216	}
180	217
	218	+/*
	219	+ * Returns true, if there are no holes in boot memory area,
	220	+ * false otherwise.
	221	+ */
	222	+bool is_fadump_boot_mem_contiguous(void)
	223	+{
	224	+ unsigned long d_start, d_end;
	225	+ bool ret = false;
	226	+ int i;
	227	+
	228	+ for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
	229	+ d_start = fw_dump.boot_mem_addr[i];
	230	+ d_end = d_start + fw_dump.boot_mem_sz[i];
	231	+
	232	+ ret = is_fadump_mem_area_contiguous(d_start, d_end);
	233	+ if (!ret)
	234	+ break;
	235	+ }
	236	+
	237	+ return ret;
	238	+}
	239	+
	240	+/*
	241	+ * Returns true, if there are no holes in reserved memory area,
	242	+ * false otherwise.
	243	+ */
	244	+bool is_fadump_reserved_mem_contiguous(void)
	245	+{
	246	+ u64 d_start, d_end;
	247	+
	248	+ d_start = fw_dump.reserve_dump_area_start;
	249	+ d_end = d_start + fw_dump.reserve_dump_area_size;
	250	+ return is_fadump_mem_area_contiguous(d_start, d_end);
	251	+}
	252	+
181	253	/* Print firmware assisted dump configurations for debugging purpose. */
182	254	static void fadump_show_config(void)
183	255	{
	256	+ int i;
	257	+
184	258	pr_debug("Support for firmware-assisted dump (fadump): %s\n",
185	259	(fw_dump.fadump_supported ? "present" : "no support"));
186	260
..	..	@@ -194,62 +268,13 @@
194	268	pr_debug("Dump section sizes:\n");
195	269	pr_debug(" CPU state data size: %lx\n", fw_dump.cpu_state_data_size);
196	270	pr_debug(" HPTE region size : %lx\n", fw_dump.hpte_region_size);
197		- pr_debug("Boot memory size : %lx\n", fw_dump.boot_memory_size);
198		-}
199		-
200		-static unsigned long init_fadump_mem_struct(struct fadump_mem_struct *fdm,
201		- unsigned long addr)
202		-{
203		- if (!fdm)
204		- return 0;
205		-
206		- memset(fdm, 0, sizeof(struct fadump_mem_struct));
207		- addr = addr & PAGE_MASK;
208		-
209		- fdm->header.dump_format_version = cpu_to_be32(0x00000001);
210		- fdm->header.dump_num_sections = cpu_to_be16(3);
211		- fdm->header.dump_status_flag = 0;
212		- fdm->header.offset_first_dump_section =
213		- cpu_to_be32((u32)offsetof(struct fadump_mem_struct, cpu_state_data));
214		-
215		- /*
216		- * Fields for disk dump option.
217		- * We are not using disk dump option, hence set these fields to 0.
218		- */
219		- fdm->header.dd_block_size = 0;
220		- fdm->header.dd_block_offset = 0;
221		- fdm->header.dd_num_blocks = 0;
222		- fdm->header.dd_offset_disk_path = 0;
223		-
224		- /* set 0 to disable an automatic dump-reboot. */
225		- fdm->header.max_time_auto = 0;
226		-
227		- /* Kernel dump sections */
228		- /* cpu state data section. */
229		- fdm->cpu_state_data.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
230		- fdm->cpu_state_data.source_data_type = cpu_to_be16(FADUMP_CPU_STATE_DATA);
231		- fdm->cpu_state_data.source_address = 0;
232		- fdm->cpu_state_data.source_len = cpu_to_be64(fw_dump.cpu_state_data_size);
233		- fdm->cpu_state_data.destination_address = cpu_to_be64(addr);
234		- addr += fw_dump.cpu_state_data_size;
235		-
236		- /* hpte region section */
237		- fdm->hpte_region.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
238		- fdm->hpte_region.source_data_type = cpu_to_be16(FADUMP_HPTE_REGION);
239		- fdm->hpte_region.source_address = 0;
240		- fdm->hpte_region.source_len = cpu_to_be64(fw_dump.hpte_region_size);
241		- fdm->hpte_region.destination_address = cpu_to_be64(addr);
242		- addr += fw_dump.hpte_region_size;
243		-
244		- /* RMA region section */
245		- fdm->rmr_region.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
246		- fdm->rmr_region.source_data_type = cpu_to_be16(FADUMP_REAL_MODE_REGION);
247		- fdm->rmr_region.source_address = cpu_to_be64(RMA_START);
248		- fdm->rmr_region.source_len = cpu_to_be64(fw_dump.boot_memory_size);
249		- fdm->rmr_region.destination_address = cpu_to_be64(addr);
250		- addr += fw_dump.boot_memory_size;
251		-
252		- return addr;
	271	+ pr_debug(" Boot memory size : %lx\n", fw_dump.boot_memory_size);
	272	+ pr_debug(" Boot memory top : %llx\n", fw_dump.boot_mem_top);
	273	+ pr_debug("Boot memory regions cnt: %llx\n", fw_dump.boot_mem_regs_cnt);
	274	+ for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
	275	+ pr_debug("[%03d] base = %llx, size = %llx\n", i,
	276	+ fw_dump.boot_mem_addr[i], fw_dump.boot_mem_sz[i]);
	277	+ }
253	278	}
254	279
255	280	/**
..	..	@@ -267,10 +292,10 @@
267	292	* that is required for a kernel to boot successfully.
268	293	*
269	294	*/
270		-static inline unsigned long fadump_calculate_reserve_size(void)
	295	+static __init u64 fadump_calculate_reserve_size(void)
271	296	{
	297	+ u64 base, size, bootmem_min;
272	298	int ret;
273		- unsigned long long base, size;
274	299
275	300	if (fw_dump.reserve_bootvar)
276	301	pr_warn("'fadump_reserve_mem=' parameter is deprecated in favor of 'crashkernel=' parameter.\n");
..	..	@@ -320,7 +345,8 @@
320	345	if (memory_limit && size > memory_limit)
321	346	size = memory_limit;
322	347
323		- return (size > MIN_BOOT_MEM ? size : MIN_BOOT_MEM);
	348	+ bootmem_min = fw_dump.ops->fadump_get_bootmem_min();
	349	+ return (size > bootmem_min ? size : bootmem_min);
324	350	}
325	351
326	352	/*
..	..	@@ -341,51 +367,199 @@
341	367	size += sizeof(struct elf_phdr) * (memblock_num_regions(memory) + 2);
342	368
343	369	size = PAGE_ALIGN(size);
	370	+
	371	+ /* This is to hold kernel metadata on platforms that support it */
	372	+ size += (fw_dump.ops->fadump_get_metadata_size ?
	373	+ fw_dump.ops->fadump_get_metadata_size() : 0);
344	374	return size;
345	375	}
346	376
347		-static void __init fadump_reserve_crash_area(unsigned long base,
348		- unsigned long size)
	377	+static int __init add_boot_mem_region(unsigned long rstart,
	378	+ unsigned long rsize)
349	379	{
350		- struct memblock_region *reg;
351		- unsigned long mstart, mend, msize;
	380	+ int i = fw_dump.boot_mem_regs_cnt++;
352	381
353		- for_each_memblock(memory, reg) {
354		- mstart = max_t(unsigned long, base, reg->base);
355		- mend = reg->base + reg->size;
356		- mend = min(base + size, mend);
	382	+ if (fw_dump.boot_mem_regs_cnt > FADUMP_MAX_MEM_REGS) {
	383	+ fw_dump.boot_mem_regs_cnt = FADUMP_MAX_MEM_REGS;
	384	+ return 0;
	385	+ }
357	386
358		- if (mstart < mend) {
359		- msize = mend - mstart;
360		- memblock_reserve(mstart, msize);
361		- pr_info("Reserved %ldMB of memory at %#016lx for saving crash dump\n",
362		- (msize >> 20), mstart);
	387	+ pr_debug("Added boot memory range[%d] [%#016lx-%#016lx)\n",
	388	+ i, rstart, (rstart + rsize));
	389	+ fw_dump.boot_mem_addr[i] = rstart;
	390	+ fw_dump.boot_mem_sz[i] = rsize;
	391	+ return 1;
	392	+}
	393	+
	394	+/*
	395	+ * Firmware usually has a hard limit on the data it can copy per region.
	396	+ * Honour that by splitting a memory range into multiple regions.
	397	+ */
	398	+static int __init add_boot_mem_regions(unsigned long mstart,
	399	+ unsigned long msize)
	400	+{
	401	+ unsigned long rstart, rsize, max_size;
	402	+ int ret = 1;
	403	+
	404	+ rstart = mstart;
	405	+ max_size = fw_dump.max_copy_size ? fw_dump.max_copy_size : msize;
	406	+ while (msize) {
	407	+ if (msize > max_size)
	408	+ rsize = max_size;
	409	+ else
	410	+ rsize = msize;
	411	+
	412	+ ret = add_boot_mem_region(rstart, rsize);
	413	+ if (!ret)
	414	+ break;
	415	+
	416	+ msize -= rsize;
	417	+ rstart += rsize;
	418	+ }
	419	+
	420	+ return ret;
	421	+}
	422	+
	423	+static int __init fadump_get_boot_mem_regions(void)
	424	+{
	425	+ unsigned long size, cur_size, hole_size, last_end;
	426	+ unsigned long mem_size = fw_dump.boot_memory_size;
	427	+ phys_addr_t reg_start, reg_end;
	428	+ int ret = 1;
	429	+ u64 i;
	430	+
	431	+ fw_dump.boot_mem_regs_cnt = 0;
	432	+
	433	+ last_end = 0;
	434	+ hole_size = 0;
	435	+ cur_size = 0;
	436	+ for_each_mem_range(i, &reg_start, &reg_end) {
	437	+ size = reg_end - reg_start;
	438	+ hole_size += (reg_start - last_end);
	439	+
	440	+ if ((cur_size + size) >= mem_size) {
	441	+ size = (mem_size - cur_size);
	442	+ ret = add_boot_mem_regions(reg_start, size);
	443	+ break;
	444	+ }
	445	+
	446	+ mem_size -= size;
	447	+ cur_size += size;
	448	+ ret = add_boot_mem_regions(reg_start, size);
	449	+ if (!ret)
	450	+ break;
	451	+
	452	+ last_end = reg_end;
	453	+ }
	454	+ fw_dump.boot_mem_top = PAGE_ALIGN(fw_dump.boot_memory_size + hole_size);
	455	+
	456	+ return ret;
	457	+}
	458	+
	459	+/*
	460	+ * Returns true, if the given range overlaps with reserved memory ranges
	461	+ * starting at idx. Also, updates idx to index of overlapping memory range
	462	+ * with the given memory range.
	463	+ * False, otherwise.
	464	+ */
	465	+static bool overlaps_reserved_ranges(u64 base, u64 end, int *idx)
	466	+{
	467	+ bool ret = false;
	468	+ int i;
	469	+
	470	+ for (i = *idx; i < reserved_mrange_info.mem_range_cnt; i++) {
	471	+ u64 rbase = reserved_mrange_info.mem_ranges[i].base;
	472	+ u64 rend = rbase + reserved_mrange_info.mem_ranges[i].size;
	473	+
	474	+ if (end <= rbase)
	475	+ break;
	476	+
	477	+ if ((end > rbase) && (base < rend)) {
	478	+ *idx = i;
	479	+ ret = true;
	480	+ break;
363	481	}
364	482	}
	483	+
	484	+ return ret;
	485	+}
	486	+
	487	+/*
	488	+ * Locate a suitable memory area to reserve memory for FADump. While at it,
	489	+ * lookup reserved-ranges & avoid overlap with them, as they are used by F/W.
	490	+ */
	491	+static u64 __init fadump_locate_reserve_mem(u64 base, u64 size)
	492	+{
	493	+ struct fadump_memory_range *mrngs;
	494	+ phys_addr_t mstart, mend;
	495	+ int idx = 0;
	496	+ u64 i, ret = 0;
	497	+
	498	+ mrngs = reserved_mrange_info.mem_ranges;
	499	+ for_each_free_mem_range(i, NUMA_NO_NODE, MEMBLOCK_NONE,
	500	+ &mstart, &mend, NULL) {
	501	+ pr_debug("%llu) mstart: %llx, mend: %llx, base: %llx\n",
	502	+ i, mstart, mend, base);
	503	+
	504	+ if (mstart > base)
	505	+ base = PAGE_ALIGN(mstart);
	506	+
	507	+ while ((mend > base) && ((mend - base) >= size)) {
	508	+ if (!overlaps_reserved_ranges(base, base+size, &idx)) {
	509	+ ret = base;
	510	+ goto out;
	511	+ }
	512	+
	513	+ base = mrngs[idx].base + mrngs[idx].size;
	514	+ base = PAGE_ALIGN(base);
	515	+ }
	516	+ }
	517	+
	518	+out:
	519	+ return ret;
365	520	}
366	521
367	522	int __init fadump_reserve_mem(void)
368	523	{
369		- unsigned long base, size, memory_boundary;
	524	+ u64 base, size, mem_boundary, bootmem_min;
	525	+ int ret = 1;
370	526
371	527	if (!fw_dump.fadump_enabled)
372	528	return 0;
373	529
374	530	if (!fw_dump.fadump_supported) {
375		- printk(KERN_INFO "Firmware-assisted dump is not supported on"
376		- " this hardware\n");
377		- fw_dump.fadump_enabled = 0;
378		- return 0;
	531	+ pr_info("Firmware-Assisted Dump is not supported on this hardware\n");
	532	+ goto error_out;
379	533	}
	534	+
380	535	/*
381	536	* Initialize boot memory size
382	537	* If dump is active then we have already calculated the size during
383	538	* first kernel.
384	539	*/
385		- if (fdm_active)
386		- fw_dump.boot_memory_size = be64_to_cpu(fdm_active->rmr_region.source_len);
387		- else
388		- fw_dump.boot_memory_size = fadump_calculate_reserve_size();
	540	+ if (!fw_dump.dump_active) {
	541	+ fw_dump.boot_memory_size =
	542	+ PAGE_ALIGN(fadump_calculate_reserve_size());
	543	+#ifdef CONFIG_CMA
	544	+ if (!fw_dump.nocma) {
	545	+ fw_dump.boot_memory_size =
	546	+ ALIGN(fw_dump.boot_memory_size,
	547	+ FADUMP_CMA_ALIGNMENT);
	548	+ }
	549	+#endif
	550	+
	551	+ bootmem_min = fw_dump.ops->fadump_get_bootmem_min();
	552	+ if (fw_dump.boot_memory_size < bootmem_min) {
	553	+ pr_err("Can't enable fadump with boot memory size (0x%lx) less than 0x%llx\n",
	554	+ fw_dump.boot_memory_size, bootmem_min);
	555	+ goto error_out;
	556	+ }
	557	+
	558	+ if (!fadump_get_boot_mem_regions()) {
	559	+ pr_err("Too many holes in boot memory area to enable fadump\n");
	560	+ goto error_out;
	561	+ }
	562	+ }
389	563
390	564	/*
391	565	* Calculate the memory boundary.
..	..	@@ -404,10 +578,13 @@
404	578	" dump, now %#016llx\n", memory_limit);
405	579	}
406	580	if (memory_limit)
407		- memory_boundary = memory_limit;
	581	+ mem_boundary = memory_limit;
408	582	else
409		- memory_boundary = memblock_end_of_DRAM();
	583	+ mem_boundary = memblock_end_of_DRAM();
410	584
	585	+ base = fw_dump.boot_mem_top;
	586	+ size = get_fadump_area_size();
	587	+ fw_dump.reserve_dump_area_size = size;
411	588	if (fw_dump.dump_active) {
412	589	pr_info("Firmware-assisted dump is active.\n");
413	590
..	..	@@ -421,56 +598,51 @@
421	598	#endif
422	599	/*
423	600	* If last boot has crashed then reserve all the memory
424		- * above boot_memory_size so that we don't touch it until
	601	+ * above boot memory size so that we don't touch it until
425	602	* dump is written to disk by userspace tool. This memory
426		- * will be released for general use once the dump is saved.
	603	+ * can be released for general use by invalidating fadump.
427	604	*/
428		- base = fw_dump.boot_memory_size;
429		- size = memory_boundary - base;
430		- fadump_reserve_crash_area(base, size);
	605	+ fadump_reserve_crash_area(base);
431	606
432		- fw_dump.fadumphdr_addr =
433		- be64_to_cpu(fdm_active->rmr_region.destination_address) +
434		- be64_to_cpu(fdm_active->rmr_region.source_len);
435		- pr_debug("fadumphdr_addr = %p\n",
436		- (void *) fw_dump.fadumphdr_addr);
	607	+ pr_debug("fadumphdr_addr = %#016lx\n", fw_dump.fadumphdr_addr);
	608	+ pr_debug("Reserve dump area start address: 0x%lx\n",
	609	+ fw_dump.reserve_dump_area_start);
437	610	} else {
438		- size = get_fadump_area_size();
439		-
440	611	/*
441	612	* Reserve memory at an offset closer to bottom of the RAM to
442		- * minimize the impact of memory hot-remove operation. We can't
443		- * use memblock_find_in_range() here since it doesn't allocate
444		- * from bottom to top.
	613	+ * minimize the impact of memory hot-remove operation.
445	614	*/
446		- for (base = fw_dump.boot_memory_size;
447		- base <= (memory_boundary - size);
448		- base += size) {
449		- if (memblock_is_region_memory(base, size) &&
450		- !memblock_is_region_reserved(base, size))
451		- break;
	615	+ base = fadump_locate_reserve_mem(base, size);
	616	+
	617	+ if (!base \|\| (base + size > mem_boundary)) {
	618	+ pr_err("Failed to find memory chunk for reservation!\n");
	619	+ goto error_out;
452	620	}
453		- if ((base > (memory_boundary - size)) \|\|
454		- memblock_reserve(base, size)) {
455		- pr_err("Failed to reserve memory\n");
456		- return 0;
	621	+ fw_dump.reserve_dump_area_start = base;
	622	+
	623	+ /*
	624	+ * Calculate the kernel metadata address and register it with
	625	+ * f/w if the platform supports.
	626	+ */
	627	+ if (fw_dump.ops->fadump_setup_metadata &&
	628	+ (fw_dump.ops->fadump_setup_metadata(&fw_dump) < 0))
	629	+ goto error_out;
	630	+
	631	+ if (memblock_reserve(base, size)) {
	632	+ pr_err("Failed to reserve memory!\n");
	633	+ goto error_out;
457	634	}
458	635
459		- pr_info("Reserved %ldMB of memory at %ldMB for firmware-"
460		- "assisted dump (System RAM: %ldMB)\n",
461		- (unsigned long)(size >> 20),
462		- (unsigned long)(base >> 20),
463		- (unsigned long)(memblock_phys_mem_size() >> 20));
	636	+ pr_info("Reserved %lldMB of memory at %#016llx (System RAM: %lldMB)\n",
	637	+ (size >> 20), base, (memblock_phys_mem_size() >> 20));
	638	+
	639	+ ret = fadump_cma_init();
464	640	}
465	641
466		- fw_dump.reserve_dump_area_start = base;
467		- fw_dump.reserve_dump_area_size = size;
468		- return 1;
469		-}
470		-
471		-unsigned long __init arch_reserved_kernel_pages(void)
472		-{
473		- return memblock_reserved_size() / PAGE_SIZE;
	642	+ return ret;
	643	+error_out:
	644	+ fw_dump.fadump_enabled = 0;
	645	+ return 0;
474	646	}
475	647
476	648	/* Look for fadump= cmdline option. */
..	..	@@ -483,6 +655,10 @@
483	655	fw_dump.fadump_enabled = 1;
484	656	else if (strncmp(p, "off", 3) == 0)
485	657	fw_dump.fadump_enabled = 0;
	658	+ else if (strncmp(p, "nocma", 5) == 0) {
	659	+ fw_dump.fadump_enabled = 1;
	660	+ fw_dump.nocma = 1;
	661	+ }
486	662
487	663	return 0;
488	664	}
..	..	@@ -501,63 +677,13 @@
501	677	}
502	678	early_param("fadump_reserve_mem", early_fadump_reserve_mem);
503	679
504		-static int register_fw_dump(struct fadump_mem_struct *fdm)
505		-{
506		- int rc, err;
507		- unsigned int wait_time;
508		-
509		- pr_debug("Registering for firmware-assisted kernel dump...\n");
510		-
511		- /* TODO: Add upper time limit for the delay */
512		- do {
513		- rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
514		- FADUMP_REGISTER, fdm,
515		- sizeof(struct fadump_mem_struct));
516		-
517		- wait_time = rtas_busy_delay_time(rc);
518		- if (wait_time)
519		- mdelay(wait_time);
520		-
521		- } while (wait_time);
522		-
523		- err = -EIO;
524		- switch (rc) {
525		- default:
526		- pr_err("Failed to register. Unknown Error(%d).\n", rc);
527		- break;
528		- case -1:
529		- printk(KERN_ERR "Failed to register firmware-assisted kernel"
530		- " dump. Hardware Error(%d).\n", rc);
531		- break;
532		- case -3:
533		- if (!is_boot_memory_area_contiguous())
534		- pr_err("Can't have holes in boot memory area while "
535		- "registering fadump\n");
536		-
537		- printk(KERN_ERR "Failed to register firmware-assisted kernel"
538		- " dump. Parameter Error(%d).\n", rc);
539		- err = -EINVAL;
540		- break;
541		- case -9:
542		- printk(KERN_ERR "firmware-assisted kernel dump is already "
543		- " registered.");
544		- fw_dump.dump_registered = 1;
545		- err = -EEXIST;
546		- break;
547		- case 0:
548		- printk(KERN_INFO "firmware-assisted kernel dump registration"
549		- " is successful\n");
550		- fw_dump.dump_registered = 1;
551		- err = 0;
552		- break;
553		- }
554		- return err;
555		-}
556		-
557	680	void crash_fadump(struct pt_regs regs, const char str)
558	681	{
	682	+ unsigned int msecs;
559	683	struct fadump_crash_info_header *fdh = NULL;
560	684	int old_cpu, this_cpu;
	685	+ /* Do not include first CPU */
	686	+ unsigned int ncpus = num_online_cpus() - 1;
561	687
562	688	if (!should_fadump_crash())
563	689	return;
..	..	@@ -573,6 +699,8 @@
573	699	old_cpu = cmpxchg(&crashing_cpu, -1, this_cpu);
574	700
575	701	if (old_cpu != -1) {
	702	+ atomic_inc(&cpus_in_fadump);
	703	+
576	704	/*
577	705	* We can't loop here indefinitely. Wait as long as fadump
578	706	* is in force. If we race with fadump un-registration this
..	..	@@ -596,71 +724,20 @@
596	724
597	725	fdh->online_mask = *cpu_online_mask;
598	726
599		- /* Call ibm,os-term rtas call to trigger firmware assisted dump */
600		- rtas_os_term((char *)str);
601		-}
602		-
603		-#define GPR_MASK 0xffffff0000000000
604		-static inline int fadump_gpr_index(u64 id)
605		-{
606		- int i = -1;
607		- char str[3];
608		-
609		- if ((id & GPR_MASK) == REG_ID("GPR")) {
610		- /* get the digits at the end */
611		- id &= ~GPR_MASK;
612		- id >>= 24;
613		- str[2] = '\0';
614		- str[1] = id & 0xff;
615		- str[0] = (id >> 8) & 0xff;
616		- sscanf(str, "%d", &i);
617		- if (i > 31)
618		- i = -1;
	727	+ /*
	728	+ * If we came in via system reset, wait a while for the secondary
	729	+ * CPUs to enter.
	730	+ */
	731	+ if (TRAP(&(fdh->regs)) == 0x100) {
	732	+ msecs = CRASH_TIMEOUT;
	733	+ while ((atomic_read(&cpus_in_fadump) < ncpus) && (--msecs > 0))
	734	+ mdelay(1);
619	735	}
620		- return i;
	736	+
	737	+ fw_dump.ops->fadump_trigger(fdh, str);
621	738	}
622	739
623		-static inline void fadump_set_regval(struct pt_regs *regs, u64 reg_id,
624		- u64 reg_val)
625		-{
626		- int i;
627		-
628		- i = fadump_gpr_index(reg_id);
629		- if (i >= 0)
630		- regs->gpr[i] = (unsigned long)reg_val;
631		- else if (reg_id == REG_ID("NIA"))
632		- regs->nip = (unsigned long)reg_val;
633		- else if (reg_id == REG_ID("MSR"))
634		- regs->msr = (unsigned long)reg_val;
635		- else if (reg_id == REG_ID("CTR"))
636		- regs->ctr = (unsigned long)reg_val;
637		- else if (reg_id == REG_ID("LR"))
638		- regs->link = (unsigned long)reg_val;
639		- else if (reg_id == REG_ID("XER"))
640		- regs->xer = (unsigned long)reg_val;
641		- else if (reg_id == REG_ID("CR"))
642		- regs->ccr = (unsigned long)reg_val;
643		- else if (reg_id == REG_ID("DAR"))
644		- regs->dar = (unsigned long)reg_val;
645		- else if (reg_id == REG_ID("DSISR"))
646		- regs->dsisr = (unsigned long)reg_val;
647		-}
648		-
649		-static struct fadump_reg_entry*
650		-fadump_read_registers(struct fadump_reg_entry reg_entry, struct pt_regs regs)
651		-{
652		- memset(regs, 0, sizeof(struct pt_regs));
653		-
654		- while (be64_to_cpu(reg_entry->reg_id) != REG_ID("CPUEND")) {
655		- fadump_set_regval(regs, be64_to_cpu(reg_entry->reg_id),
656		- be64_to_cpu(reg_entry->reg_value));
657		- reg_entry++;
658		- }
659		- reg_entry++;
660		- return reg_entry;
661		-}
662		-
663		-static u32 fadump_regs_to_elf_notes(u32 buf, struct pt_regs *regs)
	740	+u32 fadump_regs_to_elf_notes(u32 buf, struct pt_regs *regs)
664	741	{
665	742	struct elf_prstatus prstatus;
666	743
..	..	@@ -675,19 +752,17 @@
675	752	return buf;
676	753	}
677	754
678		-static void fadump_update_elfcore_header(char *bufp)
	755	+void fadump_update_elfcore_header(char *bufp)
679	756	{
680		- struct elfhdr *elf;
681	757	struct elf_phdr *phdr;
682	758
683		- elf = (struct elfhdr *)bufp;
684	759	bufp += sizeof(struct elfhdr);
685	760
686	761	/* First note is a place holder for cpu notes info. */
687	762	phdr = (struct elf_phdr *)bufp;
688	763
689	764	if (phdr->p_type == PT_NOTE) {
690		- phdr->p_paddr = fw_dump.cpu_notes_buf;
	765	+ phdr->p_paddr = __pa(fw_dump.cpu_notes_buf_vaddr);
691	766	phdr->p_offset = phdr->p_paddr;
692	767	phdr->p_filesz = fw_dump.cpu_notes_buf_size;
693	768	phdr->p_memsz = fw_dump.cpu_notes_buf_size;
..	..	@@ -695,228 +770,103 @@
695	770	return;
696	771	}
697	772
698		-static void *fadump_cpu_notes_buf_alloc(unsigned long size)
	773	+static void *fadump_alloc_buffer(unsigned long size)
699	774	{
700		- void *vaddr;
	775	+ unsigned long count, i;
701	776	struct page *page;
702		- unsigned long order, count, i;
	777	+ void *vaddr;
703	778
704		- order = get_order(size);
705		- vaddr = (void *)__get_free_pages(GFP_KERNEL\|__GFP_ZERO, order);
	779	+ vaddr = alloc_pages_exact(size, GFP_KERNEL \| __GFP_ZERO);
706	780	if (!vaddr)
707	781	return NULL;
708	782
709		- count = 1 << order;
	783	+ count = PAGE_ALIGN(size) / PAGE_SIZE;
710	784	page = virt_to_page(vaddr);
711	785	for (i = 0; i < count; i++)
712		- SetPageReserved(page + i);
	786	+ mark_page_reserved(page + i);
713	787	return vaddr;
714	788	}
715	789
716		-static void fadump_cpu_notes_buf_free(unsigned long vaddr, unsigned long size)
	790	+static void fadump_free_buffer(unsigned long vaddr, unsigned long size)
717	791	{
718		- struct page *page;
719		- unsigned long order, count, i;
720		-
721		- order = get_order(size);
722		- count = 1 << order;
723		- page = virt_to_page(vaddr);
724		- for (i = 0; i < count; i++)
725		- ClearPageReserved(page + i);
726		- __free_pages(page, order);
	792	+ free_reserved_area((void )vaddr, (void )(vaddr + size), -1, NULL);
727	793	}
728	794
729		-/*
730		- * Read CPU state dump data and convert it into ELF notes.
731		- * The CPU dump starts with magic number "REGSAVE". NumCpusOffset should be
732		- * used to access the data to allow for additional fields to be added without
733		- * affecting compatibility. Each list of registers for a CPU starts with
734		- * "CPUSTRT" and ends with "CPUEND". Each register entry is of 16 bytes,
735		- * 8 Byte ASCII identifier and 8 Byte register value. The register entry
736		- * with identifier "CPUSTRT" and "CPUEND" contains 4 byte cpu id as part
737		- * of register value. For more details refer to PAPR document.
738		- *
739		- * Only for the crashing cpu we ignore the CPU dump data and get exact
740		- * state from fadump crash info structure populated by first kernel at the
741		- * time of crash.
742		- */
743		-static int __init fadump_build_cpu_notes(const struct fadump_mem_struct *fdm)
	795	+s32 fadump_setup_cpu_notes_buf(u32 num_cpus)
744	796	{
745		- struct fadump_reg_save_area_header *reg_header;
746		- struct fadump_reg_entry *reg_entry;
747		- struct fadump_crash_info_header *fdh = NULL;
748		- void *vaddr;
749		- unsigned long addr;
750		- u32 num_cpus, *note_buf;
751		- struct pt_regs regs;
752		- int i, rc = 0, cpu = 0;
753		-
754		- if (!fdm->cpu_state_data.bytes_dumped)
755		- return -EINVAL;
756		-
757		- addr = be64_to_cpu(fdm->cpu_state_data.destination_address);
758		- vaddr = __va(addr);
759		-
760		- reg_header = vaddr;
761		- if (be64_to_cpu(reg_header->magic_number) != REGSAVE_AREA_MAGIC) {
762		- printk(KERN_ERR "Unable to read register save area.\n");
763		- return -ENOENT;
764		- }
765		- pr_debug("--------CPU State Data------------\n");
766		- pr_debug("Magic Number: %llx\n", be64_to_cpu(reg_header->magic_number));
767		- pr_debug("NumCpuOffset: %x\n", be32_to_cpu(reg_header->num_cpu_offset));
768		-
769		- vaddr += be32_to_cpu(reg_header->num_cpu_offset);
770		- num_cpus = be32_to_cpu(((__be32 )(vaddr)));
771		- pr_debug("NumCpus : %u\n", num_cpus);
772		- vaddr += sizeof(u32);
773		- reg_entry = (struct fadump_reg_entry *)vaddr;
774		-
775	797	/* Allocate buffer to hold cpu crash notes. */
776	798	fw_dump.cpu_notes_buf_size = num_cpus * sizeof(note_buf_t);
777	799	fw_dump.cpu_notes_buf_size = PAGE_ALIGN(fw_dump.cpu_notes_buf_size);
778		- note_buf = fadump_cpu_notes_buf_alloc(fw_dump.cpu_notes_buf_size);
779		- if (!note_buf) {
780		- printk(KERN_ERR "Failed to allocate 0x%lx bytes for "
781		- "cpu notes buffer\n", fw_dump.cpu_notes_buf_size);
	800	+ fw_dump.cpu_notes_buf_vaddr =
	801	+ (unsigned long)fadump_alloc_buffer(fw_dump.cpu_notes_buf_size);
	802	+ if (!fw_dump.cpu_notes_buf_vaddr) {
	803	+ pr_err("Failed to allocate %ld bytes for CPU notes buffer\n",
	804	+ fw_dump.cpu_notes_buf_size);
782	805	return -ENOMEM;
783	806	}
784		- fw_dump.cpu_notes_buf = __pa(note_buf);
785	807
786		- pr_debug("Allocated buffer for cpu notes of size %ld at %p\n",
787		- (num_cpus * sizeof(note_buf_t)), note_buf);
788		-
789		- if (fw_dump.fadumphdr_addr)
790		- fdh = __va(fw_dump.fadumphdr_addr);
791		-
792		- for (i = 0; i < num_cpus; i++) {
793		- if (be64_to_cpu(reg_entry->reg_id) != REG_ID("CPUSTRT")) {
794		- printk(KERN_ERR "Unable to read CPU state data\n");
795		- rc = -ENOENT;
796		- goto error_out;
797		- }
798		- /* Lower 4 bytes of reg_value contains logical cpu id */
799		- cpu = be64_to_cpu(reg_entry->reg_value) & FADUMP_CPU_ID_MASK;
800		- if (fdh && !cpumask_test_cpu(cpu, &fdh->online_mask)) {
801		- SKIP_TO_NEXT_CPU(reg_entry);
802		- continue;
803		- }
804		- pr_debug("Reading register data for cpu %d...\n", cpu);
805		- if (fdh && fdh->crashing_cpu == cpu) {
806		- regs = fdh->regs;
807		- note_buf = fadump_regs_to_elf_notes(note_buf, &regs);
808		- SKIP_TO_NEXT_CPU(reg_entry);
809		- } else {
810		- reg_entry++;
811		- reg_entry = fadump_read_registers(reg_entry, &regs);
812		- note_buf = fadump_regs_to_elf_notes(note_buf, &regs);
813		- }
814		- }
815		- final_note(note_buf);
816		-
817		- if (fdh) {
818		- pr_debug("Updating elfcore header (%llx) with cpu notes\n",
819		- fdh->elfcorehdr_addr);
820		- fadump_update_elfcore_header((char *)__va(fdh->elfcorehdr_addr));
821		- }
	808	+ pr_debug("Allocated buffer for cpu notes of size %ld at 0x%lx\n",
	809	+ fw_dump.cpu_notes_buf_size,
	810	+ fw_dump.cpu_notes_buf_vaddr);
822	811	return 0;
	812	+}
823	813
824		-error_out:
825		- fadump_cpu_notes_buf_free((unsigned long)__va(fw_dump.cpu_notes_buf),
826		- fw_dump.cpu_notes_buf_size);
827		- fw_dump.cpu_notes_buf = 0;
	814	+void fadump_free_cpu_notes_buf(void)
	815	+{
	816	+ if (!fw_dump.cpu_notes_buf_vaddr)
	817	+ return;
	818	+
	819	+ fadump_free_buffer(fw_dump.cpu_notes_buf_vaddr,
	820	+ fw_dump.cpu_notes_buf_size);
	821	+ fw_dump.cpu_notes_buf_vaddr = 0;
828	822	fw_dump.cpu_notes_buf_size = 0;
829		- return rc;
	823	+}
830	824
	825	+static void fadump_free_mem_ranges(struct fadump_mrange_info *mrange_info)
	826	+{
	827	+ if (mrange_info->is_static) {
	828	+ mrange_info->mem_range_cnt = 0;
	829	+ return;
	830	+ }
	831	+
	832	+ kfree(mrange_info->mem_ranges);
	833	+ memset((void *)((u64)mrange_info + RNG_NAME_SZ), 0,
	834	+ (sizeof(struct fadump_mrange_info) - RNG_NAME_SZ));
831	835	}
832	836
833	837	/*
834		- * Validate and process the dump data stored by firmware before exporting
835		- * it through '/proc/vmcore'.
836		- */
837		-static int __init process_fadump(const struct fadump_mem_struct *fdm_active)
838		-{
839		- struct fadump_crash_info_header *fdh;
840		- int rc = 0;
841		-
842		- if (!fdm_active \|\| !fw_dump.fadumphdr_addr)
843		- return -EINVAL;
844		-
845		- /* Check if the dump data is valid. */
846		- if ((be16_to_cpu(fdm_active->header.dump_status_flag) == FADUMP_ERROR_FLAG) \|\|
847		- (fdm_active->cpu_state_data.error_flags != 0) \|\|
848		- (fdm_active->rmr_region.error_flags != 0)) {
849		- printk(KERN_ERR "Dump taken by platform is not valid\n");
850		- return -EINVAL;
851		- }
852		- if ((fdm_active->rmr_region.bytes_dumped !=
853		- fdm_active->rmr_region.source_len) \|\|
854		- !fdm_active->cpu_state_data.bytes_dumped) {
855		- printk(KERN_ERR "Dump taken by platform is incomplete\n");
856		- return -EINVAL;
857		- }
858		-
859		- /* Validate the fadump crash info header */
860		- fdh = __va(fw_dump.fadumphdr_addr);
861		- if (fdh->magic_number != FADUMP_CRASH_INFO_MAGIC) {
862		- printk(KERN_ERR "Crash info header is not valid.\n");
863		- return -EINVAL;
864		- }
865		-
866		- rc = fadump_build_cpu_notes(fdm_active);
867		- if (rc)
868		- return rc;
869		-
870		- /*
871		- * We are done validating dump info and elfcore header is now ready
872		- * to be exported. set elfcorehdr_addr so that vmcore module will
873		- * export the elfcore header through '/proc/vmcore'.
874		- */
875		- elfcorehdr_addr = fdh->elfcorehdr_addr;
876		-
877		- return 0;
878		-}
879		-
880		-static void free_crash_memory_ranges(void)
881		-{
882		- kfree(crash_memory_ranges);
883		- crash_memory_ranges = NULL;
884		- crash_memory_ranges_size = 0;
885		- max_crash_mem_ranges = 0;
886		-}
887		-
888		-/*
889		- * Allocate or reallocate crash memory ranges array in incremental units
	838	+ * Allocate or reallocate mem_ranges array in incremental units
890	839	* of PAGE_SIZE.
891	840	*/
892		-static int allocate_crash_memory_ranges(void)
	841	+static int fadump_alloc_mem_ranges(struct fadump_mrange_info *mrange_info)
893	842	{
894		- struct fad_crash_memory_ranges *new_array;
	843	+ struct fadump_memory_range *new_array;
895	844	u64 new_size;
896	845
897		- new_size = crash_memory_ranges_size + PAGE_SIZE;
898		- pr_debug("Allocating %llu bytes of memory for crash memory ranges\n",
899		- new_size);
	846	+ new_size = mrange_info->mem_ranges_sz + PAGE_SIZE;
	847	+ pr_debug("Allocating %llu bytes of memory for %s memory ranges\n",
	848	+ new_size, mrange_info->name);
900	849
901		- new_array = krealloc(crash_memory_ranges, new_size, GFP_KERNEL);
	850	+ new_array = krealloc(mrange_info->mem_ranges, new_size, GFP_KERNEL);
902	851	if (new_array == NULL) {
903		- pr_err("Insufficient memory for setting up crash memory ranges\n");
904		- free_crash_memory_ranges();
	852	+ pr_err("Insufficient memory for setting up %s memory ranges\n",
	853	+ mrange_info->name);
	854	+ fadump_free_mem_ranges(mrange_info);
905	855	return -ENOMEM;
906	856	}
907	857
908		- crash_memory_ranges = new_array;
909		- crash_memory_ranges_size = new_size;
910		- max_crash_mem_ranges = (new_size /
911		- sizeof(struct fad_crash_memory_ranges));
	858	+ mrange_info->mem_ranges = new_array;
	859	+ mrange_info->mem_ranges_sz = new_size;
	860	+ mrange_info->max_mem_ranges = (new_size /
	861	+ sizeof(struct fadump_memory_range));
912	862	return 0;
913	863	}
914		-
915		-static inline int fadump_add_crash_memory(unsigned long long base,
916		- unsigned long long end)
	864	+static inline int fadump_add_mem_range(struct fadump_mrange_info *mrange_info,
	865	+ u64 base, u64 end)
917	866	{
918		- u64 start, size;
	867	+ struct fadump_memory_range *mem_ranges = mrange_info->mem_ranges;
919	868	bool is_adjacent = false;
	869	+ u64 start, size;
920	870
921	871	if (base == end)
922	872	return 0;
..	..	@@ -925,38 +875,52 @@
925	875	* Fold adjacent memory ranges to bring down the memory ranges/
926	876	* PT_LOAD segments count.
927	877	*/
928		- if (crash_mem_ranges) {
929		- start = crash_memory_ranges[crash_mem_ranges - 1].base;
930		- size = crash_memory_ranges[crash_mem_ranges - 1].size;
	878	+ if (mrange_info->mem_range_cnt) {
	879	+ start = mem_ranges[mrange_info->mem_range_cnt - 1].base;
	880	+ size = mem_ranges[mrange_info->mem_range_cnt - 1].size;
931	881
932		- if ((start + size) == base)
	882	+ /*
	883	+ * Boot memory area needs separate PT_LOAD segment(s) as it
	884	+ * is moved to a different location at the time of crash.
	885	+ * So, fold only if the region is not boot memory area.
	886	+ */
	887	+ if ((start + size) == base && start >= fw_dump.boot_mem_top)
933	888	is_adjacent = true;
934	889	}
935	890	if (!is_adjacent) {
936	891	/* resize the array on reaching the limit */
937		- if (crash_mem_ranges == max_crash_mem_ranges) {
	892	+ if (mrange_info->mem_range_cnt == mrange_info->max_mem_ranges) {
938	893	int ret;
939	894
940		- ret = allocate_crash_memory_ranges();
	895	+ if (mrange_info->is_static) {
	896	+ pr_err("Reached array size limit for %s memory ranges\n",
	897	+ mrange_info->name);
	898	+ return -ENOSPC;
	899	+ }
	900	+
	901	+ ret = fadump_alloc_mem_ranges(mrange_info);
941	902	if (ret)
942	903	return ret;
	904	+
	905	+ /* Update to the new resized array */
	906	+ mem_ranges = mrange_info->mem_ranges;
943	907	}
944	908
945	909	start = base;
946		- crash_memory_ranges[crash_mem_ranges].base = start;
947		- crash_mem_ranges++;
	910	+ mem_ranges[mrange_info->mem_range_cnt].base = start;
	911	+ mrange_info->mem_range_cnt++;
948	912	}
949	913
950		- crash_memory_ranges[crash_mem_ranges - 1].size = (end - start);
951		- pr_debug("crash_memory_range[%d] [%#016llx-%#016llx], %#llx bytes\n",
952		- (crash_mem_ranges - 1), start, end - 1, (end - start));
	914	+ mem_ranges[mrange_info->mem_range_cnt - 1].size = (end - start);
	915	+ pr_debug("%s_memory_range[%d] [%#016llx-%#016llx], %#llx bytes\n",
	916	+ mrange_info->name, (mrange_info->mem_range_cnt - 1),
	917	+ start, end - 1, (end - start));
953	918	return 0;
954	919	}
955	920
956		-static int fadump_exclude_reserved_area(unsigned long long start,
957		- unsigned long long end)
	921	+static int fadump_exclude_reserved_area(u64 start, u64 end)
958	922	{
959		- unsigned long long ra_start, ra_end;
	923	+ u64 ra_start, ra_end;
960	924	int ret = 0;
961	925
962	926	ra_start = fw_dump.reserve_dump_area_start;
..	..	@@ -964,18 +928,22 @@
964	928
965	929	if ((ra_start < end) && (ra_end > start)) {
966	930	if ((start < ra_start) && (end > ra_end)) {
967		- ret = fadump_add_crash_memory(start, ra_start);
	931	+ ret = fadump_add_mem_range(&crash_mrange_info,
	932	+ start, ra_start);
968	933	if (ret)
969	934	return ret;
970	935
971		- ret = fadump_add_crash_memory(ra_end, end);
	936	+ ret = fadump_add_mem_range(&crash_mrange_info,
	937	+ ra_end, end);
972	938	} else if (start < ra_start) {
973		- ret = fadump_add_crash_memory(start, ra_start);
	939	+ ret = fadump_add_mem_range(&crash_mrange_info,
	940	+ start, ra_start);
974	941	} else if (ra_end < end) {
975		- ret = fadump_add_crash_memory(ra_end, end);
	942	+ ret = fadump_add_mem_range(&crash_mrange_info,
	943	+ ra_end, end);
976	944	}
977	945	} else
978		- ret = fadump_add_crash_memory(start, end);
	946	+ ret = fadump_add_mem_range(&crash_mrange_info, start, end);
979	947
980	948	return ret;
981	949	}
..	..	@@ -1019,37 +987,33 @@
1019	987	*/
1020	988	static int fadump_setup_crash_memory_ranges(void)
1021	989	{
1022		- struct memblock_region *reg;
1023		- unsigned long long start, end;
	990	+ u64 i, start, end;
1024	991	int ret;
1025	992
1026	993	pr_debug("Setup crash memory ranges.\n");
1027		- crash_mem_ranges = 0;
	994	+ crash_mrange_info.mem_range_cnt = 0;
1028	995
1029	996	/*
1030		- * add the first memory chunk (RMA_START through boot_memory_size) as
1031		- * a separate memory chunk. The reason is, at the time crash firmware
1032		- * will move the content of this memory chunk to different location
1033		- * specified during fadump registration. We need to create a separate
1034		- * program header for this chunk with the correct offset.
	997	+ * Boot memory region(s) registered with firmware are moved to
	998	+ * different location at the time of crash. Create separate program
	999	+ * header(s) for this memory chunk(s) with the correct offset.
1035	1000	*/
1036		- ret = fadump_add_crash_memory(RMA_START, fw_dump.boot_memory_size);
1037		- if (ret)
1038		- return ret;
	1001	+ for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
	1002	+ start = fw_dump.boot_mem_addr[i];
	1003	+ end = start + fw_dump.boot_mem_sz[i];
	1004	+ ret = fadump_add_mem_range(&crash_mrange_info, start, end);
	1005	+ if (ret)
	1006	+ return ret;
	1007	+ }
1039	1008
1040		- for_each_memblock(memory, reg) {
1041		- start = (unsigned long long)reg->base;
1042		- end = start + (unsigned long long)reg->size;
1043		-
	1009	+ for_each_mem_range(i, &start, &end) {
1044	1010	/*
1045		- * skip the first memory chunk that is already added (RMA_START
1046		- * through boot_memory_size). This logic needs a relook if and
1047		- * when RMA_START changes to a non-zero value.
	1011	+ * skip the memory chunk that is already added
	1012	+ * (0 through boot_memory_top).
1048	1013	*/
1049		- BUILD_BUG_ON(RMA_START != 0);
1050		- if (start < fw_dump.boot_memory_size) {
1051		- if (end > fw_dump.boot_memory_size)
1052		- start = fw_dump.boot_memory_size;
	1014	+ if (start < fw_dump.boot_mem_top) {
	1015	+ if (end > fw_dump.boot_mem_top)
	1016	+ start = fw_dump.boot_mem_top;
1053	1017	else
1054	1018	continue;
1055	1019	}
..	..	@@ -1070,17 +1034,35 @@
1070	1034	*/
1071	1035	static inline unsigned long fadump_relocate(unsigned long paddr)
1072	1036	{
1073		- if (paddr > RMA_START && paddr < fw_dump.boot_memory_size)
1074		- return be64_to_cpu(fdm.rmr_region.destination_address) + paddr;
1075		- else
1076		- return paddr;
	1037	+ unsigned long raddr, rstart, rend, rlast, hole_size;
	1038	+ int i;
	1039	+
	1040	+ hole_size = 0;
	1041	+ rlast = 0;
	1042	+ raddr = paddr;
	1043	+ for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
	1044	+ rstart = fw_dump.boot_mem_addr[i];
	1045	+ rend = rstart + fw_dump.boot_mem_sz[i];
	1046	+ hole_size += (rstart - rlast);
	1047	+
	1048	+ if (paddr >= rstart && paddr < rend) {
	1049	+ raddr += fw_dump.boot_mem_dest_addr - hole_size;
	1050	+ break;
	1051	+ }
	1052	+
	1053	+ rlast = rend;
	1054	+ }
	1055	+
	1056	+ pr_debug("vmcoreinfo: paddr = 0x%lx, raddr = 0x%lx\n", paddr, raddr);
	1057	+ return raddr;
1077	1058	}
1078	1059
1079	1060	static int fadump_create_elfcore_headers(char *bufp)
1080	1061	{
1081		- struct elfhdr *elf;
	1062	+ unsigned long long raddr, offset;
1082	1063	struct elf_phdr *phdr;
1083		- int i;
	1064	+ struct elfhdr *elf;
	1065	+ int i, j;
1084	1066
1085	1067	fadump_init_elfcore_header(bufp);
1086	1068	elf = (struct elfhdr *)bufp;
..	..	@@ -1123,12 +1105,14 @@
1123	1105	(elf->e_phnum)++;
1124	1106
1125	1107	/* setup PT_LOAD sections. */
	1108	+ j = 0;
	1109	+ offset = 0;
	1110	+ raddr = fw_dump.boot_mem_addr[0];
	1111	+ for (i = 0; i < crash_mrange_info.mem_range_cnt; i++) {
	1112	+ u64 mbase, msize;
1126	1113
1127		- for (i = 0; i < crash_mem_ranges; i++) {
1128		- unsigned long long mbase, msize;
1129		- mbase = crash_memory_ranges[i].base;
1130		- msize = crash_memory_ranges[i].size;
1131		-
	1114	+ mbase = crash_mrange_info.mem_ranges[i].base;
	1115	+ msize = crash_mrange_info.mem_ranges[i].size;
1132	1116	if (!msize)
1133	1117	continue;
1134	1118
..	..	@@ -1138,13 +1122,17 @@
1138	1122	phdr->p_flags = PF_R\|PF_W\|PF_X;
1139	1123	phdr->p_offset = mbase;
1140	1124
1141		- if (mbase == RMA_START) {
	1125	+ if (mbase == raddr) {
1142	1126	/*
1143		- * The entire RMA region will be moved by firmware
1144		- * to the specified destination_address. Hence set
1145		- * the correct offset.
	1127	+ * The entire real memory region will be moved by
	1128	+ * firmware to the specified destination_address.
	1129	+ * Hence set the correct offset.
1146	1130	*/
1147		- phdr->p_offset = be64_to_cpu(fdm.rmr_region.destination_address);
	1131	+ phdr->p_offset = fw_dump.boot_mem_dest_addr + offset;
	1132	+ if (j < (fw_dump.boot_mem_regs_cnt - 1)) {
	1133	+ offset += fw_dump.boot_mem_sz[j];
	1134	+ raddr = fw_dump.boot_mem_addr[++j];
	1135	+ }
1148	1136	}
1149	1137
1150	1138	phdr->p_paddr = mbase;
..	..	@@ -1166,7 +1154,6 @@
1166	1154	if (!addr)
1167	1155	return 0;
1168	1156
1169		- fw_dump.fadumphdr_addr = addr;
1170	1157	fdh = __va(addr);
1171	1158	addr += sizeof(struct fadump_crash_info_header);
1172	1159
..	..	@@ -1174,7 +1161,7 @@
1174	1161	fdh->magic_number = FADUMP_CRASH_INFO_MAGIC;
1175	1162	fdh->elfcorehdr_addr = addr;
1176	1163	/* We will set the crashing cpu id in crash_fadump() during crash. */
1177		- fdh->crashing_cpu = CPU_UNKNOWN;
	1164	+ fdh->crashing_cpu = FADUMP_CPU_UNKNOWN;
1178	1165
1179	1166	return addr;
1180	1167	}
..	..	@@ -1196,7 +1183,8 @@
1196	1183	if (ret)
1197	1184	return ret;
1198	1185
1199		- addr = be64_to_cpu(fdm.rmr_region.destination_address) + be64_to_cpu(fdm.rmr_region.source_len);
	1186	+ addr = fw_dump.fadumphdr_addr;
	1187	+
1200	1188	/* Initialize fadump crash info header. */
1201	1189	addr = init_fadump_header(addr);
1202	1190	vaddr = __va(addr);
..	..	@@ -1205,75 +1193,27 @@
1205	1193	fadump_create_elfcore_headers(vaddr);
1206	1194
1207	1195	/* register the future kernel dump with firmware. */
1208		- return register_fw_dump(&fdm);
1209		-}
1210		-
1211		-static int fadump_unregister_dump(struct fadump_mem_struct *fdm)
1212		-{
1213		- int rc = 0;
1214		- unsigned int wait_time;
1215		-
1216		- pr_debug("Un-register firmware-assisted dump\n");
1217		-
1218		- /* TODO: Add upper time limit for the delay */
1219		- do {
1220		- rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
1221		- FADUMP_UNREGISTER, fdm,
1222		- sizeof(struct fadump_mem_struct));
1223		-
1224		- wait_time = rtas_busy_delay_time(rc);
1225		- if (wait_time)
1226		- mdelay(wait_time);
1227		- } while (wait_time);
1228		-
1229		- if (rc) {
1230		- printk(KERN_ERR "Failed to un-register firmware-assisted dump."
1231		- " unexpected error(%d).\n", rc);
1232		- return rc;
1233		- }
1234		- fw_dump.dump_registered = 0;
1235		- return 0;
1236		-}
1237		-
1238		-static int fadump_invalidate_dump(struct fadump_mem_struct *fdm)
1239		-{
1240		- int rc = 0;
1241		- unsigned int wait_time;
1242		-
1243		- pr_debug("Invalidating firmware-assisted dump registration\n");
1244		-
1245		- /* TODO: Add upper time limit for the delay */
1246		- do {
1247		- rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
1248		- FADUMP_INVALIDATE, fdm,
1249		- sizeof(struct fadump_mem_struct));
1250		-
1251		- wait_time = rtas_busy_delay_time(rc);
1252		- if (wait_time)
1253		- mdelay(wait_time);
1254		- } while (wait_time);
1255		-
1256		- if (rc) {
1257		- pr_err("Failed to invalidate firmware-assisted dump registration. Unexpected error (%d).\n", rc);
1258		- return rc;
1259		- }
1260		- fw_dump.dump_active = 0;
1261		- fdm_active = NULL;
1262		- return 0;
	1196	+ pr_debug("Registering for firmware-assisted kernel dump...\n");
	1197	+ return fw_dump.ops->fadump_register(&fw_dump);
1263	1198	}
1264	1199
1265	1200	void fadump_cleanup(void)
1266	1201	{
	1202	+ if (!fw_dump.fadump_supported)
	1203	+ return;
	1204	+
1267	1205	/* Invalidate the registration only if dump is active. */
1268	1206	if (fw_dump.dump_active) {
1269		- init_fadump_mem_struct(&fdm,
1270		- be64_to_cpu(fdm_active->cpu_state_data.destination_address));
1271		- fadump_invalidate_dump(&fdm);
	1207	+ pr_debug("Invalidating firmware-assisted dump registration\n");
	1208	+ fw_dump.ops->fadump_invalidate(&fw_dump);
1272	1209	} else if (fw_dump.dump_registered) {
1273	1210	/* Un-register Firmware-assisted dump if it was registered. */
1274		- fadump_unregister_dump(&fdm);
1275		- free_crash_memory_ranges();
	1211	+ fw_dump.ops->fadump_unregister(&fw_dump);
	1212	+ fadump_free_mem_ranges(&crash_mrange_info);
1276	1213	}
	1214	+
	1215	+ if (fw_dump.ops->fadump_cleanup)
	1216	+ fw_dump.ops->fadump_cleanup(&fw_dump);
1277	1217	}
1278	1218
1279	1219	static void fadump_free_reserved_memory(unsigned long start_pfn,
..	..	@@ -1298,95 +1238,194 @@
1298	1238	/*
1299	1239	* Skip memory holes and free memory that was actually reserved.
1300	1240	*/
1301		-static void fadump_release_reserved_area(unsigned long start, unsigned long end)
	1241	+static void fadump_release_reserved_area(u64 start, u64 end)
1302	1242	{
1303		- struct memblock_region *reg;
1304		- unsigned long tstart, tend;
1305		- unsigned long start_pfn = PHYS_PFN(start);
1306		- unsigned long end_pfn = PHYS_PFN(end);
	1243	+ unsigned long reg_spfn, reg_epfn;
	1244	+ u64 tstart, tend, spfn, epfn;
	1245	+ int i;
1307	1246
1308		- for_each_memblock(memory, reg) {
1309		- tstart = max(start_pfn, memblock_region_memory_base_pfn(reg));
1310		- tend = min(end_pfn, memblock_region_memory_end_pfn(reg));
	1247	+ spfn = PHYS_PFN(start);
	1248	+ epfn = PHYS_PFN(end);
	1249	+
	1250	+ for_each_mem_pfn_range(i, MAX_NUMNODES, &reg_spfn, &reg_epfn, NULL) {
	1251	+ tstart = max_t(u64, spfn, reg_spfn);
	1252	+ tend = min_t(u64, epfn, reg_epfn);
	1253	+
1311	1254	if (tstart < tend) {
1312	1255	fadump_free_reserved_memory(tstart, tend);
1313	1256
1314		- if (tend == end_pfn)
	1257	+ if (tend == epfn)
1315	1258	break;
1316	1259
1317		- start_pfn = tend + 1;
	1260	+ spfn = tend;
1318	1261	}
1319	1262	}
1320	1263	}
1321	1264
1322	1265	/*
1323		- * Release the memory that was reserved in early boot to preserve the memory
1324		- * contents. The released memory will be available for general use.
	1266	+ * Sort the mem ranges in-place and merge adjacent ranges
	1267	+ * to minimize the memory ranges count.
1325	1268	*/
1326		-static void fadump_release_memory(unsigned long begin, unsigned long end)
	1269	+static void sort_and_merge_mem_ranges(struct fadump_mrange_info *mrange_info)
1327	1270	{
1328		- unsigned long ra_start, ra_end;
	1271	+ struct fadump_memory_range *mem_ranges;
	1272	+ struct fadump_memory_range tmp_range;
	1273	+ u64 base, size;
	1274	+ int i, j, idx;
	1275	+
	1276	+ if (!reserved_mrange_info.mem_range_cnt)
	1277	+ return;
	1278	+
	1279	+ /* Sort the memory ranges */
	1280	+ mem_ranges = mrange_info->mem_ranges;
	1281	+ for (i = 0; i < mrange_info->mem_range_cnt; i++) {
	1282	+ idx = i;
	1283	+ for (j = (i + 1); j < mrange_info->mem_range_cnt; j++) {
	1284	+ if (mem_ranges[idx].base > mem_ranges[j].base)
	1285	+ idx = j;
	1286	+ }
	1287	+ if (idx != i) {
	1288	+ tmp_range = mem_ranges[idx];
	1289	+ mem_ranges[idx] = mem_ranges[i];
	1290	+ mem_ranges[i] = tmp_range;
	1291	+ }
	1292	+ }
	1293	+
	1294	+ /* Merge adjacent reserved ranges */
	1295	+ idx = 0;
	1296	+ for (i = 1; i < mrange_info->mem_range_cnt; i++) {
	1297	+ base = mem_ranges[i-1].base;
	1298	+ size = mem_ranges[i-1].size;
	1299	+ if (mem_ranges[i].base == (base + size))
	1300	+ mem_ranges[idx].size += mem_ranges[i].size;
	1301	+ else {
	1302	+ idx++;
	1303	+ if (i == idx)
	1304	+ continue;
	1305	+
	1306	+ mem_ranges[idx] = mem_ranges[i];
	1307	+ }
	1308	+ }
	1309	+ mrange_info->mem_range_cnt = idx + 1;
	1310	+}
	1311	+
	1312	+/*
	1313	+ * Scan reserved-ranges to consider them while reserving/releasing
	1314	+ * memory for FADump.
	1315	+ */
	1316	+static void __init early_init_dt_scan_reserved_ranges(unsigned long node)
	1317	+{
	1318	+ const __be32 *prop;
	1319	+ int len, ret = -1;
	1320	+ unsigned long i;
	1321	+
	1322	+ /* reserved-ranges already scanned */
	1323	+ if (reserved_mrange_info.mem_range_cnt != 0)
	1324	+ return;
	1325	+
	1326	+ prop = of_get_flat_dt_prop(node, "reserved-ranges", &len);
	1327	+ if (!prop)
	1328	+ return;
	1329	+
	1330	+ /*
	1331	+ * Each reserved range is an (address,size) pair, 2 cells each,
	1332	+ * totalling 4 cells per range.
	1333	+ */
	1334	+ for (i = 0; i < len / (sizeof(prop) 4); i++) {
	1335	+ u64 base, size;
	1336	+
	1337	+ base = of_read_number(prop + (i * 4) + 0, 2);
	1338	+ size = of_read_number(prop + (i * 4) + 2, 2);
	1339	+
	1340	+ if (size) {
	1341	+ ret = fadump_add_mem_range(&reserved_mrange_info,
	1342	+ base, base + size);
	1343	+ if (ret < 0) {
	1344	+ pr_warn("some reserved ranges are ignored!\n");
	1345	+ break;
	1346	+ }
	1347	+ }
	1348	+ }
	1349	+
	1350	+ /* Compact reserved ranges */
	1351	+ sort_and_merge_mem_ranges(&reserved_mrange_info);
	1352	+}
	1353	+
	1354	+/*
	1355	+ * Release the memory that was reserved during early boot to preserve the
	1356	+ * crash'ed kernel's memory contents except reserved dump area (permanent
	1357	+ * reservation) and reserved ranges used by F/W. The released memory will
	1358	+ * be available for general use.
	1359	+ */
	1360	+static void fadump_release_memory(u64 begin, u64 end)
	1361	+{
	1362	+ u64 ra_start, ra_end, tstart;
	1363	+ int i, ret;
1329	1364
1330	1365	ra_start = fw_dump.reserve_dump_area_start;
1331	1366	ra_end = ra_start + fw_dump.reserve_dump_area_size;
1332	1367
1333	1368	/*
1334		- * exclude the dump reserve area. Will reuse it for next
1335		- * fadump registration.
	1369	+ * If reserved ranges array limit is hit, overwrite the last reserved
	1370	+ * memory range with reserved dump area to ensure it is excluded from
	1371	+ * the memory being released (reused for next FADump registration).
1336	1372	*/
1337		- if (begin < ra_end && end > ra_start) {
1338		- if (begin < ra_start)
1339		- fadump_release_reserved_area(begin, ra_start);
1340		- if (end > ra_end)
1341		- fadump_release_reserved_area(ra_end, end);
1342		- } else
1343		- fadump_release_reserved_area(begin, end);
	1373	+ if (reserved_mrange_info.mem_range_cnt ==
	1374	+ reserved_mrange_info.max_mem_ranges)
	1375	+ reserved_mrange_info.mem_range_cnt--;
	1376	+
	1377	+ ret = fadump_add_mem_range(&reserved_mrange_info, ra_start, ra_end);
	1378	+ if (ret != 0)
	1379	+ return;
	1380	+
	1381	+ /* Get the reserved ranges list in order first. */
	1382	+ sort_and_merge_mem_ranges(&reserved_mrange_info);
	1383	+
	1384	+ /* Exclude reserved ranges and release remaining memory */
	1385	+ tstart = begin;
	1386	+ for (i = 0; i < reserved_mrange_info.mem_range_cnt; i++) {
	1387	+ ra_start = reserved_mrange_info.mem_ranges[i].base;
	1388	+ ra_end = ra_start + reserved_mrange_info.mem_ranges[i].size;
	1389	+
	1390	+ if (tstart >= ra_end)
	1391	+ continue;
	1392	+
	1393	+ if (tstart < ra_start)
	1394	+ fadump_release_reserved_area(tstart, ra_start);
	1395	+ tstart = ra_end;
	1396	+ }
	1397	+
	1398	+ if (tstart < end)
	1399	+ fadump_release_reserved_area(tstart, end);
1344	1400	}
1345	1401
1346	1402	static void fadump_invalidate_release_mem(void)
1347	1403	{
1348		- unsigned long reserved_area_start, reserved_area_end;
1349		- unsigned long destination_address;
1350		-
1351	1404	mutex_lock(&fadump_mutex);
1352	1405	if (!fw_dump.dump_active) {
1353	1406	mutex_unlock(&fadump_mutex);
1354	1407	return;
1355	1408	}
1356	1409
1357		- destination_address = be64_to_cpu(fdm_active->cpu_state_data.destination_address);
1358	1410	fadump_cleanup();
1359	1411	mutex_unlock(&fadump_mutex);
1360	1412
1361		- /*
1362		- * Save the current reserved memory bounds we will require them
1363		- * later for releasing the memory for general use.
1364		- */
1365		- reserved_area_start = fw_dump.reserve_dump_area_start;
1366		- reserved_area_end = reserved_area_start +
1367		- fw_dump.reserve_dump_area_size;
1368		- /*
1369		- * Setup reserve_dump_area_start and its size so that we can
1370		- * reuse this reserved memory for Re-registration.
1371		- */
1372		- fw_dump.reserve_dump_area_start = destination_address;
1373		- fw_dump.reserve_dump_area_size = get_fadump_area_size();
	1413	+ fadump_release_memory(fw_dump.boot_mem_top, memblock_end_of_DRAM());
	1414	+ fadump_free_cpu_notes_buf();
1374	1415
1375		- fadump_release_memory(reserved_area_start, reserved_area_end);
1376		- if (fw_dump.cpu_notes_buf) {
1377		- fadump_cpu_notes_buf_free(
1378		- (unsigned long)__va(fw_dump.cpu_notes_buf),
1379		- fw_dump.cpu_notes_buf_size);
1380		- fw_dump.cpu_notes_buf = 0;
1381		- fw_dump.cpu_notes_buf_size = 0;
1382		- }
1383		- /* Initialize the kernel dump memory structure for FAD registration. */
1384		- init_fadump_mem_struct(&fdm, fw_dump.reserve_dump_area_start);
	1416	+ /*
	1417	+ * Setup kernel metadata and initialize the kernel dump
	1418	+ * memory structure for FADump re-registration.
	1419	+ */
	1420	+ if (fw_dump.ops->fadump_setup_metadata &&
	1421	+ (fw_dump.ops->fadump_setup_metadata(&fw_dump) < 0))
	1422	+ pr_warn("Failed to setup kernel metadata!\n");
	1423	+ fw_dump.ops->fadump_init_mem_struct(&fw_dump);
1385	1424	}
1386	1425
1387		-static ssize_t fadump_release_memory_store(struct kobject *kobj,
1388		- struct kobj_attribute *attr,
1389		- const char *buf, size_t count)
	1426	+static ssize_t release_mem_store(struct kobject *kobj,
	1427	+ struct kobj_attribute *attr,
	1428	+ const char *buf, size_t count)
1390	1429	{
1391	1430	int input = -1;
1392	1431
..	..	@@ -1411,28 +1450,45 @@
1411	1450	return count;
1412	1451	}
1413	1452
1414		-static ssize_t fadump_enabled_show(struct kobject *kobj,
1415		- struct kobj_attribute *attr,
1416		- char *buf)
	1453	+/* Release the reserved memory and disable the FADump */
	1454	+static void unregister_fadump(void)
	1455	+{
	1456	+ fadump_cleanup();
	1457	+ fadump_release_memory(fw_dump.reserve_dump_area_start,
	1458	+ fw_dump.reserve_dump_area_size);
	1459	+ fw_dump.fadump_enabled = 0;
	1460	+ kobject_put(fadump_kobj);
	1461	+}
	1462	+
	1463	+static ssize_t enabled_show(struct kobject *kobj,
	1464	+ struct kobj_attribute *attr,
	1465	+ char *buf)
1417	1466	{
1418	1467	return sprintf(buf, "%d\n", fw_dump.fadump_enabled);
1419	1468	}
1420	1469
1421		-static ssize_t fadump_register_show(struct kobject *kobj,
1422		- struct kobj_attribute *attr,
1423		- char *buf)
	1470	+static ssize_t mem_reserved_show(struct kobject *kobj,
	1471	+ struct kobj_attribute *attr,
	1472	+ char *buf)
	1473	+{
	1474	+ return sprintf(buf, "%ld\n", fw_dump.reserve_dump_area_size);
	1475	+}
	1476	+
	1477	+static ssize_t registered_show(struct kobject *kobj,
	1478	+ struct kobj_attribute *attr,
	1479	+ char *buf)
1424	1480	{
1425	1481	return sprintf(buf, "%d\n", fw_dump.dump_registered);
1426	1482	}
1427	1483
1428		-static ssize_t fadump_register_store(struct kobject *kobj,
1429		- struct kobj_attribute *attr,
1430		- const char *buf, size_t count)
	1484	+static ssize_t registered_store(struct kobject *kobj,
	1485	+ struct kobj_attribute *attr,
	1486	+ const char *buf, size_t count)
1431	1487	{
1432	1488	int ret = 0;
1433	1489	int input = -1;
1434	1490
1435		- if (!fw_dump.fadump_enabled \|\| fdm_active)
	1491	+ if (!fw_dump.fadump_enabled \|\| fw_dump.dump_active)
1436	1492	return -EPERM;
1437	1493
1438	1494	if (kstrtoint(buf, 0, &input))
..	..	@@ -1445,13 +1501,15 @@
1445	1501	if (fw_dump.dump_registered == 0) {
1446	1502	goto unlock_out;
1447	1503	}
	1504	+
1448	1505	/* Un-register Firmware-assisted dump */
1449		- fadump_unregister_dump(&fdm);
	1506	+ pr_debug("Un-register firmware-assisted dump\n");
	1507	+ fw_dump.ops->fadump_unregister(&fw_dump);
1450	1508	break;
1451	1509	case 1:
1452	1510	if (fw_dump.dump_registered == 1) {
1453		- ret = -EEXIST;
1454		- goto unlock_out;
	1511	+ /* Un-register Firmware-assisted dump */
	1512	+ fw_dump.ops->fadump_unregister(&fw_dump);
1455	1513	}
1456	1514	/* Register Firmware-assisted dump */
1457	1515	ret = register_fadump();
..	..	@@ -1468,114 +1526,91 @@
1468	1526
1469	1527	static int fadump_region_show(struct seq_file m, void private)
1470	1528	{
1471		- const struct fadump_mem_struct *fdm_ptr;
1472		-
1473	1529	if (!fw_dump.fadump_enabled)
1474	1530	return 0;
1475	1531
1476	1532	mutex_lock(&fadump_mutex);
1477		- if (fdm_active)
1478		- fdm_ptr = fdm_active;
1479		- else {
1480		- mutex_unlock(&fadump_mutex);
1481		- fdm_ptr = &fdm;
1482		- }
1483		-
1484		- seq_printf(m,
1485		- "CPU : [%#016llx-%#016llx] %#llx bytes, "
1486		- "Dumped: %#llx\n",
1487		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address),
1488		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) +
1489		- be64_to_cpu(fdm_ptr->cpu_state_data.source_len) - 1,
1490		- be64_to_cpu(fdm_ptr->cpu_state_data.source_len),
1491		- be64_to_cpu(fdm_ptr->cpu_state_data.bytes_dumped));
1492		- seq_printf(m,
1493		- "HPTE: [%#016llx-%#016llx] %#llx bytes, "
1494		- "Dumped: %#llx\n",
1495		- be64_to_cpu(fdm_ptr->hpte_region.destination_address),
1496		- be64_to_cpu(fdm_ptr->hpte_region.destination_address) +
1497		- be64_to_cpu(fdm_ptr->hpte_region.source_len) - 1,
1498		- be64_to_cpu(fdm_ptr->hpte_region.source_len),
1499		- be64_to_cpu(fdm_ptr->hpte_region.bytes_dumped));
1500		- seq_printf(m,
1501		- "DUMP: [%#016llx-%#016llx] %#llx bytes, "
1502		- "Dumped: %#llx\n",
1503		- be64_to_cpu(fdm_ptr->rmr_region.destination_address),
1504		- be64_to_cpu(fdm_ptr->rmr_region.destination_address) +
1505		- be64_to_cpu(fdm_ptr->rmr_region.source_len) - 1,
1506		- be64_to_cpu(fdm_ptr->rmr_region.source_len),
1507		- be64_to_cpu(fdm_ptr->rmr_region.bytes_dumped));
1508		-
1509		- if (!fdm_active \|\|
1510		- (fw_dump.reserve_dump_area_start ==
1511		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address)))
1512		- goto out;
1513		-
1514		- /* Dump is active. Show reserved memory region. */
1515		- seq_printf(m,
1516		- " : [%#016llx-%#016llx] %#llx bytes, "
1517		- "Dumped: %#llx\n",
1518		- (unsigned long long)fw_dump.reserve_dump_area_start,
1519		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) - 1,
1520		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) -
1521		- fw_dump.reserve_dump_area_start,
1522		- be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) -
1523		- fw_dump.reserve_dump_area_start);
1524		-out:
1525		- if (fdm_active)
1526		- mutex_unlock(&fadump_mutex);
	1533	+ fw_dump.ops->fadump_region_show(&fw_dump, m);
	1534	+ mutex_unlock(&fadump_mutex);
1527	1535	return 0;
1528	1536	}
1529	1537
1530		-static struct kobj_attribute fadump_release_attr = __ATTR(fadump_release_mem,
1531		- 0200, NULL,
1532		- fadump_release_memory_store);
1533		-static struct kobj_attribute fadump_attr = __ATTR(fadump_enabled,
1534		- 0444, fadump_enabled_show,
1535		- NULL);
1536		-static struct kobj_attribute fadump_register_attr = __ATTR(fadump_registered,
1537		- 0644, fadump_register_show,
1538		- fadump_register_store);
	1538	+static struct kobj_attribute release_attr = __ATTR_WO(release_mem);
	1539	+static struct kobj_attribute enable_attr = __ATTR_RO(enabled);
	1540	+static struct kobj_attribute register_attr = __ATTR_RW(registered);
	1541	+static struct kobj_attribute mem_reserved_attr = __ATTR_RO(mem_reserved);
1539	1542
1540		-static int fadump_region_open(struct inode inode, struct file file)
1541		-{
1542		- return single_open(file, fadump_region_show, inode->i_private);
1543		-}
1544		-
1545		-static const struct file_operations fadump_region_fops = {
1546		- .open = fadump_region_open,
1547		- .read = seq_read,
1548		- .llseek = seq_lseek,
1549		- .release = single_release,
	1543	+static struct attribute *fadump_attrs[] = {
	1544	+ &enable_attr.attr,
	1545	+ &register_attr.attr,
	1546	+ &mem_reserved_attr.attr,
	1547	+ NULL,
1550	1548	};
	1549	+
	1550	+ATTRIBUTE_GROUPS(fadump);
	1551	+
	1552	+DEFINE_SHOW_ATTRIBUTE(fadump_region);
1551	1553
1552	1554	static void fadump_init_files(void)
1553	1555	{
1554		- struct dentry *debugfs_file;
1555	1556	int rc = 0;
1556	1557
1557		- rc = sysfs_create_file(kernel_kobj, &fadump_attr.attr);
1558		- if (rc)
1559		- printk(KERN_ERR "fadump: unable to create sysfs file"
1560		- " fadump_enabled (%d)\n", rc);
	1558	+ fadump_kobj = kobject_create_and_add("fadump", kernel_kobj);
	1559	+ if (!fadump_kobj) {
	1560	+ pr_err("failed to create fadump kobject\n");
	1561	+ return;
	1562	+ }
1561	1563
1562		- rc = sysfs_create_file(kernel_kobj, &fadump_register_attr.attr);
1563		- if (rc)
1564		- printk(KERN_ERR "fadump: unable to create sysfs file"
1565		- " fadump_registered (%d)\n", rc);
1566		-
1567		- debugfs_file = debugfs_create_file("fadump_region", 0444,
1568		- powerpc_debugfs_root, NULL,
1569		- &fadump_region_fops);
1570		- if (!debugfs_file)
1571		- printk(KERN_ERR "fadump: unable to create debugfs file"
1572		- " fadump_region\n");
	1564	+ debugfs_create_file("fadump_region", 0444, powerpc_debugfs_root, NULL,
	1565	+ &fadump_region_fops);
1573	1566
1574	1567	if (fw_dump.dump_active) {
1575		- rc = sysfs_create_file(kernel_kobj, &fadump_release_attr.attr);
	1568	+ rc = sysfs_create_file(fadump_kobj, &release_attr.attr);
1576	1569	if (rc)
1577		- printk(KERN_ERR "fadump: unable to create sysfs file"
1578		- " fadump_release_mem (%d)\n", rc);
	1570	+ pr_err("unable to create release_mem sysfs file (%d)\n",
	1571	+ rc);
	1572	+ }
	1573	+
	1574	+ rc = sysfs_create_groups(fadump_kobj, fadump_groups);
	1575	+ if (rc) {
	1576	+ pr_err("sysfs group creation failed (%d), unregistering FADump",
	1577	+ rc);
	1578	+ unregister_fadump();
	1579	+ return;
	1580	+ }
	1581	+
	1582	+ /*
	1583	+ * The FADump sysfs are moved from kernel_kobj to fadump_kobj need to
	1584	+ * create symlink at old location to maintain backward compatibility.
	1585	+ *
	1586	+ * - fadump_enabled -> fadump/enabled
	1587	+ * - fadump_registered -> fadump/registered
	1588	+ * - fadump_release_mem -> fadump/release_mem
	1589	+ */
	1590	+ rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj,
	1591	+ "enabled", "fadump_enabled");
	1592	+ if (rc) {
	1593	+ pr_err("unable to create fadump_enabled symlink (%d)", rc);
	1594	+ return;
	1595	+ }
	1596	+
	1597	+ rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj, fadump_kobj,
	1598	+ "registered",
	1599	+ "fadump_registered");
	1600	+ if (rc) {
	1601	+ pr_err("unable to create fadump_registered symlink (%d)", rc);
	1602	+ sysfs_remove_link(kernel_kobj, "fadump_enabled");
	1603	+ return;
	1604	+ }
	1605	+
	1606	+ if (fw_dump.dump_active) {
	1607	+ rc = compat_only_sysfs_link_entry_to_kobj(kernel_kobj,
	1608	+ fadump_kobj,
	1609	+ "release_mem",
	1610	+ "fadump_release_mem");
	1611	+ if (rc)
	1612	+ pr_err("unable to create fadump_release_mem symlink (%d)",
	1613	+ rc);
1579	1614	}
1580	1615	return;
1581	1616	}
..	..	@@ -1585,16 +1620,15 @@
1585	1620	*/
1586	1621	int __init setup_fadump(void)
1587	1622	{
1588		- if (!fw_dump.fadump_enabled)
	1623	+ if (!fw_dump.fadump_supported)
1589	1624	return 0;
1590	1625
1591		- if (!fw_dump.fadump_supported) {
1592		- printk(KERN_ERR "Firmware-assisted dump is not supported on"
1593		- " this hardware\n");
1594		- return 0;
1595		- }
1596		-
	1626	+ fadump_init_files();
1597	1627	fadump_show_config();
	1628	+
	1629	+ if (!fw_dump.fadump_enabled)
	1630	+ return 1;
	1631	+
1598	1632	/*
1599	1633	* If dump data is available then see if it is valid and prepare for
1600	1634	* saving it to the disk.
..	..	@@ -1604,14 +1638,81 @@
1604	1638	* if dump process fails then invalidate the registration
1605	1639	* and release memory before proceeding for re-registration.
1606	1640	*/
1607		- if (process_fadump(fdm_active) < 0)
	1641	+ if (fw_dump.ops->fadump_process(&fw_dump) < 0)
1608	1642	fadump_invalidate_release_mem();
1609	1643	}
1610	1644	/* Initialize the kernel dump memory structure for FAD registration. */
1611	1645	else if (fw_dump.reserve_dump_area_size)
1612		- init_fadump_mem_struct(&fdm, fw_dump.reserve_dump_area_start);
1613		- fadump_init_files();
	1646	+ fw_dump.ops->fadump_init_mem_struct(&fw_dump);
	1647	+
	1648	+ /*
	1649	+ * In case of panic, fadump is triggered via ppc_panic_event()
	1650	+ * panic notifier. Setting crash_kexec_post_notifiers to 'true'
	1651	+ * lets panic() function take crash friendly path before panic
	1652	+ * notifiers are invoked.
	1653	+ */
	1654	+ crash_kexec_post_notifiers = true;
1614	1655
1615	1656	return 1;
1616	1657	}
1617	1658	subsys_initcall(setup_fadump);
	1659	+#else /* !CONFIG_PRESERVE_FA_DUMP */
	1660	+
	1661	+/* Scan the Firmware Assisted dump configuration details. */
	1662	+int __init early_init_dt_scan_fw_dump(unsigned long node, const char *uname,
	1663	+ int depth, void *data)
	1664	+{
	1665	+ if ((depth != 1) \|\| (strcmp(uname, "ibm,opal") != 0))
	1666	+ return 0;
	1667	+
	1668	+ opal_fadump_dt_scan(&fw_dump, node);
	1669	+ return 1;
	1670	+}
	1671	+
	1672	+/*
	1673	+ * When dump is active but PRESERVE_FA_DUMP is enabled on the kernel,
	1674	+ * preserve crash data. The subsequent memory preserving kernel boot
	1675	+ * is likely to process this crash data.
	1676	+ */
	1677	+int __init fadump_reserve_mem(void)
	1678	+{
	1679	+ if (fw_dump.dump_active) {
	1680	+ /*
	1681	+ * If last boot has crashed then reserve all the memory
	1682	+ * above boot memory to preserve crash data.
	1683	+ */
	1684	+ pr_info("Preserving crash data for processing in next boot.\n");
	1685	+ fadump_reserve_crash_area(fw_dump.boot_mem_top);
	1686	+ } else
	1687	+ pr_debug("FADump-aware kernel..\n");
	1688	+
	1689	+ return 1;
	1690	+}
	1691	+#endif /* CONFIG_PRESERVE_FA_DUMP */
	1692	+
	1693	+/* Preserve everything above the base address */
	1694	+static void __init fadump_reserve_crash_area(u64 base)
	1695	+{
	1696	+ u64 i, mstart, mend, msize;
	1697	+
	1698	+ for_each_mem_range(i, &mstart, &mend) {
	1699	+ msize = mend - mstart;
	1700	+
	1701	+ if ((mstart + msize) < base)
	1702	+ continue;
	1703	+
	1704	+ if (mstart < base) {
	1705	+ msize -= (base - mstart);
	1706	+ mstart = base;
	1707	+ }
	1708	+
	1709	+ pr_info("Reserving %lluMB of memory at %#016llx for preserving crash data",
	1710	+ (msize >> 20), mstart);
	1711	+ memblock_reserve(mstart, msize);
	1712	+ }
	1713	+}
	1714	+
	1715	+unsigned long __init arch_reserved_kernel_pages(void)
	1716	+{
	1717	+ return memblock_reserved_size() / PAGE_SIZE;
	1718	+}