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