~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kernel/fadump.c

Version: ~ [ linux-5.12 ] ~ [ linux-5.11.16 ] ~ [ linux-5.10.32 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.114 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.188 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.231 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.267 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.267 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Firmware Assisted dump: A robust mechanism to get reliable kernel crash
  3  * dump with assistance from firmware. This approach does not use kexec,
  4  * instead firmware assists in booting the kdump kernel while preserving
  5  * memory contents. The most of the code implementation has been adapted
  6  * from phyp assisted dump implementation written by Linas Vepstas and
  7  * Manish Ahuja
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2 of the License, or
 12  * (at your option) any later version.
 13  *
 14  * This program is distributed in the hope that it will be useful,
 15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17  * GNU General Public License for more details.
 18  *
 19  * You should have received a copy of the GNU General Public License
 20  * along with this program; if not, write to the Free Software
 21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 22  *
 23  * Copyright 2011 IBM Corporation
 24  * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
 25  */
 26 
 27 #undef DEBUG
 28 #define pr_fmt(fmt) "fadump: " fmt
 29 
 30 #include <linux/string.h>
 31 #include <linux/memblock.h>
 32 #include <linux/delay.h>
 33 #include <linux/seq_file.h>
 34 #include <linux/crash_dump.h>
 35 #include <linux/kobject.h>
 36 #include <linux/sysfs.h>
 37 
 38 #include <asm/debugfs.h>
 39 #include <asm/page.h>
 40 #include <asm/prom.h>
 41 #include <asm/rtas.h>
 42 #include <asm/fadump.h>
 43 #include <asm/setup.h>
 44 
 45 static struct fw_dump fw_dump;
 46 static struct fadump_mem_struct fdm;
 47 static const struct fadump_mem_struct *fdm_active;
 48 
 49 static DEFINE_MUTEX(fadump_mutex);
 50 struct fad_crash_memory_ranges crash_memory_ranges[INIT_CRASHMEM_RANGES];
 51 int crash_mem_ranges;
 52 
 53 /* Scan the Firmware Assisted dump configuration details. */
 54 int __init early_init_dt_scan_fw_dump(unsigned long node,
 55                         const char *uname, int depth, void *data)
 56 {
 57         const __be32 *sections;
 58         int i, num_sections;
 59         int size;
 60         const __be32 *token;
 61 
 62         if (depth != 1 || strcmp(uname, "rtas") != 0)
 63                 return 0;
 64 
 65         /*
 66          * Check if Firmware Assisted dump is supported. if yes, check
 67          * if dump has been initiated on last reboot.
 68          */
 69         token = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump", NULL);
 70         if (!token)
 71                 return 1;
 72 
 73         fw_dump.fadump_supported = 1;
 74         fw_dump.ibm_configure_kernel_dump = be32_to_cpu(*token);
 75 
 76         /*
 77          * The 'ibm,kernel-dump' rtas node is present only if there is
 78          * dump data waiting for us.
 79          */
 80         fdm_active = of_get_flat_dt_prop(node, "ibm,kernel-dump", NULL);
 81         if (fdm_active)
 82                 fw_dump.dump_active = 1;
 83 
 84         /* Get the sizes required to store dump data for the firmware provided
 85          * dump sections.
 86          * For each dump section type supported, a 32bit cell which defines
 87          * the ID of a supported section followed by two 32 bit cells which
 88          * gives teh size of the section in bytes.
 89          */
 90         sections = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump-sizes",
 91                                         &size);
 92 
 93         if (!sections)
 94                 return 1;
 95 
 96         num_sections = size / (3 * sizeof(u32));
 97 
 98         for (i = 0; i < num_sections; i++, sections += 3) {
 99                 u32 type = (u32)of_read_number(sections, 1);
100 
101                 switch (type) {
102                 case FADUMP_CPU_STATE_DATA:
103                         fw_dump.cpu_state_data_size =
104                                         of_read_ulong(&sections[1], 2);
105                         break;
106                 case FADUMP_HPTE_REGION:
107                         fw_dump.hpte_region_size =
108                                         of_read_ulong(&sections[1], 2);
109                         break;
110                 }
111         }
112 
113         return 1;
114 }
115 
116 /*
117  * If fadump is registered, check if the memory provided
118  * falls within boot memory area.
119  */
120 int is_fadump_boot_memory_area(u64 addr, ulong size)
121 {
122         if (!fw_dump.dump_registered)
123                 return 0;
124 
125         return (addr + size) > RMA_START && addr <= fw_dump.boot_memory_size;
126 }
127 
128 int should_fadump_crash(void)
129 {
130         if (!fw_dump.dump_registered || !fw_dump.fadumphdr_addr)
131                 return 0;
132         return 1;
133 }
134 
135 int is_fadump_active(void)
136 {
137         return fw_dump.dump_active;
138 }
139 
140 /*
141  * Returns 1, if there are no holes in boot memory area,
142  * 0 otherwise.
143  */
144 static int is_boot_memory_area_contiguous(void)
145 {
146         struct memblock_region *reg;
147         unsigned long tstart, tend;
148         unsigned long start_pfn = PHYS_PFN(RMA_START);
149         unsigned long end_pfn = PHYS_PFN(RMA_START + fw_dump.boot_memory_size);
150         unsigned int ret = 0;
151 
152         for_each_memblock(memory, reg) {
153                 tstart = max(start_pfn, memblock_region_memory_base_pfn(reg));
154                 tend = min(end_pfn, memblock_region_memory_end_pfn(reg));
155                 if (tstart < tend) {
156                         /* Memory hole from start_pfn to tstart */
157                         if (tstart > start_pfn)
158                                 break;
159 
160                         if (tend == end_pfn) {
161                                 ret = 1;
162                                 break;
163                         }
164 
165                         start_pfn = tend + 1;
166                 }
167         }
168 
169         return ret;
170 }
171 
172 /* Print firmware assisted dump configurations for debugging purpose. */
173 static void fadump_show_config(void)
174 {
175         pr_debug("Support for firmware-assisted dump (fadump): %s\n",
176                         (fw_dump.fadump_supported ? "present" : "no support"));
177 
178         if (!fw_dump.fadump_supported)
179                 return;
180 
181         pr_debug("Fadump enabled    : %s\n",
182                                 (fw_dump.fadump_enabled ? "yes" : "no"));
183         pr_debug("Dump Active       : %s\n",
184                                 (fw_dump.dump_active ? "yes" : "no"));
185         pr_debug("Dump section sizes:\n");
186         pr_debug("    CPU state data size: %lx\n", fw_dump.cpu_state_data_size);
187         pr_debug("    HPTE region size   : %lx\n", fw_dump.hpte_region_size);
188         pr_debug("Boot memory size  : %lx\n", fw_dump.boot_memory_size);
189 }
190 
191 static unsigned long init_fadump_mem_struct(struct fadump_mem_struct *fdm,
192                                 unsigned long addr)
193 {
194         if (!fdm)
195                 return 0;
196 
197         memset(fdm, 0, sizeof(struct fadump_mem_struct));
198         addr = addr & PAGE_MASK;
199 
200         fdm->header.dump_format_version = cpu_to_be32(0x00000001);
201         fdm->header.dump_num_sections = cpu_to_be16(3);
202         fdm->header.dump_status_flag = 0;
203         fdm->header.offset_first_dump_section =
204                 cpu_to_be32((u32)offsetof(struct fadump_mem_struct, cpu_state_data));
205 
206         /*
207          * Fields for disk dump option.
208          * We are not using disk dump option, hence set these fields to 0.
209          */
210         fdm->header.dd_block_size = 0;
211         fdm->header.dd_block_offset = 0;
212         fdm->header.dd_num_blocks = 0;
213         fdm->header.dd_offset_disk_path = 0;
214 
215         /* set 0 to disable an automatic dump-reboot. */
216         fdm->header.max_time_auto = 0;
217 
218         /* Kernel dump sections */
219         /* cpu state data section. */
220         fdm->cpu_state_data.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
221         fdm->cpu_state_data.source_data_type = cpu_to_be16(FADUMP_CPU_STATE_DATA);
222         fdm->cpu_state_data.source_address = 0;
223         fdm->cpu_state_data.source_len = cpu_to_be64(fw_dump.cpu_state_data_size);
224         fdm->cpu_state_data.destination_address = cpu_to_be64(addr);
225         addr += fw_dump.cpu_state_data_size;
226 
227         /* hpte region section */
228         fdm->hpte_region.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
229         fdm->hpte_region.source_data_type = cpu_to_be16(FADUMP_HPTE_REGION);
230         fdm->hpte_region.source_address = 0;
231         fdm->hpte_region.source_len = cpu_to_be64(fw_dump.hpte_region_size);
232         fdm->hpte_region.destination_address = cpu_to_be64(addr);
233         addr += fw_dump.hpte_region_size;
234 
235         /* RMA region section */
236         fdm->rmr_region.request_flag = cpu_to_be32(FADUMP_REQUEST_FLAG);
237         fdm->rmr_region.source_data_type = cpu_to_be16(FADUMP_REAL_MODE_REGION);
238         fdm->rmr_region.source_address = cpu_to_be64(RMA_START);
239         fdm->rmr_region.source_len = cpu_to_be64(fw_dump.boot_memory_size);
240         fdm->rmr_region.destination_address = cpu_to_be64(addr);
241         addr += fw_dump.boot_memory_size;
242 
243         return addr;
244 }
245 
246 /**
247  * fadump_calculate_reserve_size(): reserve variable boot area 5% of System RAM
248  *
249  * Function to find the largest memory size we need to reserve during early
250  * boot process. This will be the size of the memory that is required for a
251  * kernel to boot successfully.
252  *
253  * This function has been taken from phyp-assisted dump feature implementation.
254  *
255  * returns larger of 256MB or 5% rounded down to multiples of 256MB.
256  *
257  * TODO: Come up with better approach to find out more accurate memory size
258  * that is required for a kernel to boot successfully.
259  *
260  */
261 static inline unsigned long fadump_calculate_reserve_size(void)
262 {
263         int ret;
264         unsigned long long base, size;
265 
266         if (fw_dump.reserve_bootvar)
267                 pr_warn("'fadump_reserve_mem=' parameter is deprecated in favor of 'crashkernel=' parameter.\n");
268 
269         /*
270          * Check if the size is specified through crashkernel= cmdline
271          * option. If yes, then use that but ignore base as fadump reserves
272          * memory at a predefined offset.
273          */
274         ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(),
275                                 &size, &base);
276         if (ret == 0 && size > 0) {
277                 unsigned long max_size;
278 
279                 if (fw_dump.reserve_bootvar)
280                         pr_info("Using 'crashkernel=' parameter for memory reservation.\n");
281 
282                 fw_dump.reserve_bootvar = (unsigned long)size;
283 
284                 /*
285                  * Adjust if the boot memory size specified is above
286                  * the upper limit.
287                  */
288                 max_size = memblock_phys_mem_size() / MAX_BOOT_MEM_RATIO;
289                 if (fw_dump.reserve_bootvar > max_size) {
290                         fw_dump.reserve_bootvar = max_size;
291                         pr_info("Adjusted boot memory size to %luMB\n",
292                                 (fw_dump.reserve_bootvar >> 20));
293                 }
294 
295                 return fw_dump.reserve_bootvar;
296         } else if (fw_dump.reserve_bootvar) {
297                 /*
298                  * 'fadump_reserve_mem=' is being used to reserve memory
299                  * for firmware-assisted dump.
300                  */
301                 return fw_dump.reserve_bootvar;
302         }
303 
304         /* divide by 20 to get 5% of value */
305         size = memblock_phys_mem_size() / 20;
306 
307         /* round it down in multiples of 256 */
308         size = size & ~0x0FFFFFFFUL;
309 
310         /* Truncate to memory_limit. We don't want to over reserve the memory.*/
311         if (memory_limit && size > memory_limit)
312                 size = memory_limit;
313 
314         return (size > MIN_BOOT_MEM ? size : MIN_BOOT_MEM);
315 }
316 
317 /*
318  * Calculate the total memory size required to be reserved for
319  * firmware-assisted dump registration.
320  */
321 static unsigned long get_fadump_area_size(void)
322 {
323         unsigned long size = 0;
324 
325         size += fw_dump.cpu_state_data_size;
326         size += fw_dump.hpte_region_size;
327         size += fw_dump.boot_memory_size;
328         size += sizeof(struct fadump_crash_info_header);
329         size += sizeof(struct elfhdr); /* ELF core header.*/
330         size += sizeof(struct elf_phdr); /* place holder for cpu notes */
331         /* Program headers for crash memory regions. */
332         size += sizeof(struct elf_phdr) * (memblock_num_regions(memory) + 2);
333 
334         size = PAGE_ALIGN(size);
335         return size;
336 }
337 
338 int __init fadump_reserve_mem(void)
339 {
340         unsigned long base, size, memory_boundary;
341 
342         if (!fw_dump.fadump_enabled)
343                 return 0;
344 
345         if (!fw_dump.fadump_supported) {
346                 printk(KERN_INFO "Firmware-assisted dump is not supported on"
347                                 " this hardware\n");
348                 fw_dump.fadump_enabled = 0;
349                 return 0;
350         }
351         /*
352          * Initialize boot memory size
353          * If dump is active then we have already calculated the size during
354          * first kernel.
355          */
356         if (fdm_active)
357                 fw_dump.boot_memory_size = be64_to_cpu(fdm_active->rmr_region.source_len);
358         else
359                 fw_dump.boot_memory_size = fadump_calculate_reserve_size();
360 
361         /*
362          * Calculate the memory boundary.
363          * If memory_limit is less than actual memory boundary then reserve
364          * the memory for fadump beyond the memory_limit and adjust the
365          * memory_limit accordingly, so that the running kernel can run with
366          * specified memory_limit.
367          */
368         if (memory_limit && memory_limit < memblock_end_of_DRAM()) {
369                 size = get_fadump_area_size();
370                 if ((memory_limit + size) < memblock_end_of_DRAM())
371                         memory_limit += size;
372                 else
373                         memory_limit = memblock_end_of_DRAM();
374                 printk(KERN_INFO "Adjusted memory_limit for firmware-assisted"
375                                 " dump, now %#016llx\n", memory_limit);
376         }
377         if (memory_limit)
378                 memory_boundary = memory_limit;
379         else
380                 memory_boundary = memblock_end_of_DRAM();
381 
382         if (fw_dump.dump_active) {
383                 printk(KERN_INFO "Firmware-assisted dump is active.\n");
384                 /*
385                  * If last boot has crashed then reserve all the memory
386                  * above boot_memory_size so that we don't touch it until
387                  * dump is written to disk by userspace tool. This memory
388                  * will be released for general use once the dump is saved.
389                  */
390                 base = fw_dump.boot_memory_size;
391                 size = memory_boundary - base;
392                 memblock_reserve(base, size);
393                 printk(KERN_INFO "Reserved %ldMB of memory at %ldMB "
394                                 "for saving crash dump\n",
395                                 (unsigned long)(size >> 20),
396                                 (unsigned long)(base >> 20));
397 
398                 fw_dump.fadumphdr_addr =
399                                 be64_to_cpu(fdm_active->rmr_region.destination_address) +
400                                 be64_to_cpu(fdm_active->rmr_region.source_len);
401                 pr_debug("fadumphdr_addr = %p\n",
402                                 (void *) fw_dump.fadumphdr_addr);
403         } else {
404                 size = get_fadump_area_size();
405 
406                 /*
407                  * Reserve memory at an offset closer to bottom of the RAM to
408                  * minimize the impact of memory hot-remove operation. We can't
409                  * use memblock_find_in_range() here since it doesn't allocate
410                  * from bottom to top.
411                  */
412                 for (base = fw_dump.boot_memory_size;
413                      base <= (memory_boundary - size);
414                      base += size) {
415                         if (memblock_is_region_memory(base, size) &&
416                             !memblock_is_region_reserved(base, size))
417                                 break;
418                 }
419                 if ((base > (memory_boundary - size)) ||
420                     memblock_reserve(base, size)) {
421                         pr_err("Failed to reserve memory\n");
422                         return 0;
423                 }
424 
425                 pr_info("Reserved %ldMB of memory at %ldMB for firmware-"
426                         "assisted dump (System RAM: %ldMB)\n",
427                         (unsigned long)(size >> 20),
428                         (unsigned long)(base >> 20),
429                         (unsigned long)(memblock_phys_mem_size() >> 20));
430         }
431 
432         fw_dump.reserve_dump_area_start = base;
433         fw_dump.reserve_dump_area_size = size;
434         return 1;
435 }
436 
437 unsigned long __init arch_reserved_kernel_pages(void)
438 {
439         return memblock_reserved_size() / PAGE_SIZE;
440 }
441 
442 /* Look for fadump= cmdline option. */
443 static int __init early_fadump_param(char *p)
444 {
445         if (!p)
446                 return 1;
447 
448         if (strncmp(p, "on", 2) == 0)
449                 fw_dump.fadump_enabled = 1;
450         else if (strncmp(p, "off", 3) == 0)
451                 fw_dump.fadump_enabled = 0;
452 
453         return 0;
454 }
455 early_param("fadump", early_fadump_param);
456 
457 /*
458  * Look for fadump_reserve_mem= cmdline option
459  * TODO: Remove references to 'fadump_reserve_mem=' parameter,
460  *       the sooner 'crashkernel=' parameter is accustomed to.
461  */
462 static int __init early_fadump_reserve_mem(char *p)
463 {
464         if (p)
465                 fw_dump.reserve_bootvar = memparse(p, &p);
466         return 0;
467 }
468 early_param("fadump_reserve_mem", early_fadump_reserve_mem);
469 
470 static int register_fw_dump(struct fadump_mem_struct *fdm)
471 {
472         int rc, err;
473         unsigned int wait_time;
474 
475         pr_debug("Registering for firmware-assisted kernel dump...\n");
476 
477         /* TODO: Add upper time limit for the delay */
478         do {
479                 rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
480                         FADUMP_REGISTER, fdm,
481                         sizeof(struct fadump_mem_struct));
482 
483                 wait_time = rtas_busy_delay_time(rc);
484                 if (wait_time)
485                         mdelay(wait_time);
486 
487         } while (wait_time);
488 
489         err = -EIO;
490         switch (rc) {
491         default:
492                 pr_err("Failed to register. Unknown Error(%d).\n", rc);
493                 break;
494         case -1:
495                 printk(KERN_ERR "Failed to register firmware-assisted kernel"
496                         " dump. Hardware Error(%d).\n", rc);
497                 break;
498         case -3:
499                 if (!is_boot_memory_area_contiguous())
500                         pr_err("Can't have holes in boot memory area while "
501                                "registering fadump\n");
502 
503                 printk(KERN_ERR "Failed to register firmware-assisted kernel"
504                         " dump. Parameter Error(%d).\n", rc);
505                 err = -EINVAL;
506                 break;
507         case -9:
508                 printk(KERN_ERR "firmware-assisted kernel dump is already "
509                         " registered.");
510                 fw_dump.dump_registered = 1;
511                 err = -EEXIST;
512                 break;
513         case 0:
514                 printk(KERN_INFO "firmware-assisted kernel dump registration"
515                         " is successful\n");
516                 fw_dump.dump_registered = 1;
517                 err = 0;
518                 break;
519         }
520         return err;
521 }
522 
523 void crash_fadump(struct pt_regs *regs, const char *str)
524 {
525         struct fadump_crash_info_header *fdh = NULL;
526         int old_cpu, this_cpu;
527 
528         if (!should_fadump_crash())
529                 return;
530 
531         /*
532          * old_cpu == -1 means this is the first CPU which has come here,
533          * go ahead and trigger fadump.
534          *
535          * old_cpu != -1 means some other CPU has already on it's way
536          * to trigger fadump, just keep looping here.
537          */
538         this_cpu = smp_processor_id();
539         old_cpu = cmpxchg(&crashing_cpu, -1, this_cpu);
540 
541         if (old_cpu != -1) {
542                 /*
543                  * We can't loop here indefinitely. Wait as long as fadump
544                  * is in force. If we race with fadump un-registration this
545                  * loop will break and then we go down to normal panic path
546                  * and reboot. If fadump is in force the first crashing
547                  * cpu will definitely trigger fadump.
548                  */
549                 while (fw_dump.dump_registered)
550                         cpu_relax();
551                 return;
552         }
553 
554         fdh = __va(fw_dump.fadumphdr_addr);
555         fdh->crashing_cpu = crashing_cpu;
556         crash_save_vmcoreinfo();
557 
558         if (regs)
559                 fdh->regs = *regs;
560         else
561                 ppc_save_regs(&fdh->regs);
562 
563         fdh->online_mask = *cpu_online_mask;
564 
565         /* Call ibm,os-term rtas call to trigger firmware assisted dump */
566         rtas_os_term((char *)str);
567 }
568 
569 #define GPR_MASK        0xffffff0000000000
570 static inline int fadump_gpr_index(u64 id)
571 {
572         int i = -1;
573         char str[3];
574 
575         if ((id & GPR_MASK) == REG_ID("GPR")) {
576                 /* get the digits at the end */
577                 id &= ~GPR_MASK;
578                 id >>= 24;
579                 str[2] = '\0';
580                 str[1] = id & 0xff;
581                 str[0] = (id >> 8) & 0xff;
582                 sscanf(str, "%d", &i);
583                 if (i > 31)
584                         i = -1;
585         }
586         return i;
587 }
588 
589 static inline void fadump_set_regval(struct pt_regs *regs, u64 reg_id,
590                                                                 u64 reg_val)
591 {
592         int i;
593 
594         i = fadump_gpr_index(reg_id);
595         if (i >= 0)
596                 regs->gpr[i] = (unsigned long)reg_val;
597         else if (reg_id == REG_ID("NIA"))
598                 regs->nip = (unsigned long)reg_val;
599         else if (reg_id == REG_ID("MSR"))
600                 regs->msr = (unsigned long)reg_val;
601         else if (reg_id == REG_ID("CTR"))
602                 regs->ctr = (unsigned long)reg_val;
603         else if (reg_id == REG_ID("LR"))
604                 regs->link = (unsigned long)reg_val;
605         else if (reg_id == REG_ID("XER"))
606                 regs->xer = (unsigned long)reg_val;
607         else if (reg_id == REG_ID("CR"))
608                 regs->ccr = (unsigned long)reg_val;
609         else if (reg_id == REG_ID("DAR"))
610                 regs->dar = (unsigned long)reg_val;
611         else if (reg_id == REG_ID("DSISR"))
612                 regs->dsisr = (unsigned long)reg_val;
613 }
614 
615 static struct fadump_reg_entry*
616 fadump_read_registers(struct fadump_reg_entry *reg_entry, struct pt_regs *regs)
617 {
618         memset(regs, 0, sizeof(struct pt_regs));
619 
620         while (be64_to_cpu(reg_entry->reg_id) != REG_ID("CPUEND")) {
621                 fadump_set_regval(regs, be64_to_cpu(reg_entry->reg_id),
622                                         be64_to_cpu(reg_entry->reg_value));
623                 reg_entry++;
624         }
625         reg_entry++;
626         return reg_entry;
627 }
628 
629 static u32 *fadump_regs_to_elf_notes(u32 *buf, struct pt_regs *regs)
630 {
631         struct elf_prstatus prstatus;
632 
633         memset(&prstatus, 0, sizeof(prstatus));
634         /*
635          * FIXME: How do i get PID? Do I really need it?
636          * prstatus.pr_pid = ????
637          */
638         elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
639         buf = append_elf_note(buf, CRASH_CORE_NOTE_NAME, NT_PRSTATUS,
640                               &prstatus, sizeof(prstatus));
641         return buf;
642 }
643 
644 static void fadump_update_elfcore_header(char *bufp)
645 {
646         struct elfhdr *elf;
647         struct elf_phdr *phdr;
648 
649         elf = (struct elfhdr *)bufp;
650         bufp += sizeof(struct elfhdr);
651 
652         /* First note is a place holder for cpu notes info. */
653         phdr = (struct elf_phdr *)bufp;
654 
655         if (phdr->p_type == PT_NOTE) {
656                 phdr->p_paddr = fw_dump.cpu_notes_buf;
657                 phdr->p_offset  = phdr->p_paddr;
658                 phdr->p_filesz  = fw_dump.cpu_notes_buf_size;
659                 phdr->p_memsz = fw_dump.cpu_notes_buf_size;
660         }
661         return;
662 }
663 
664 static void *fadump_cpu_notes_buf_alloc(unsigned long size)
665 {
666         void *vaddr;
667         struct page *page;
668         unsigned long order, count, i;
669 
670         order = get_order(size);
671         vaddr = (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, order);
672         if (!vaddr)
673                 return NULL;
674 
675         count = 1 << order;
676         page = virt_to_page(vaddr);
677         for (i = 0; i < count; i++)
678                 SetPageReserved(page + i);
679         return vaddr;
680 }
681 
682 static void fadump_cpu_notes_buf_free(unsigned long vaddr, unsigned long size)
683 {
684         struct page *page;
685         unsigned long order, count, i;
686 
687         order = get_order(size);
688         count = 1 << order;
689         page = virt_to_page(vaddr);
690         for (i = 0; i < count; i++)
691                 ClearPageReserved(page + i);
692         __free_pages(page, order);
693 }
694 
695 /*
696  * Read CPU state dump data and convert it into ELF notes.
697  * The CPU dump starts with magic number "REGSAVE". NumCpusOffset should be
698  * used to access the data to allow for additional fields to be added without
699  * affecting compatibility. Each list of registers for a CPU starts with
700  * "CPUSTRT" and ends with "CPUEND". Each register entry is of 16 bytes,
701  * 8 Byte ASCII identifier and 8 Byte register value. The register entry
702  * with identifier "CPUSTRT" and "CPUEND" contains 4 byte cpu id as part
703  * of register value. For more details refer to PAPR document.
704  *
705  * Only for the crashing cpu we ignore the CPU dump data and get exact
706  * state from fadump crash info structure populated by first kernel at the
707  * time of crash.
708  */
709 static int __init fadump_build_cpu_notes(const struct fadump_mem_struct *fdm)
710 {
711         struct fadump_reg_save_area_header *reg_header;
712         struct fadump_reg_entry *reg_entry;
713         struct fadump_crash_info_header *fdh = NULL;
714         void *vaddr;
715         unsigned long addr;
716         u32 num_cpus, *note_buf;
717         struct pt_regs regs;
718         int i, rc = 0, cpu = 0;
719 
720         if (!fdm->cpu_state_data.bytes_dumped)
721                 return -EINVAL;
722 
723         addr = be64_to_cpu(fdm->cpu_state_data.destination_address);
724         vaddr = __va(addr);
725 
726         reg_header = vaddr;
727         if (be64_to_cpu(reg_header->magic_number) != REGSAVE_AREA_MAGIC) {
728                 printk(KERN_ERR "Unable to read register save area.\n");
729                 return -ENOENT;
730         }
731         pr_debug("--------CPU State Data------------\n");
732         pr_debug("Magic Number: %llx\n", be64_to_cpu(reg_header->magic_number));
733         pr_debug("NumCpuOffset: %x\n", be32_to_cpu(reg_header->num_cpu_offset));
734 
735         vaddr += be32_to_cpu(reg_header->num_cpu_offset);
736         num_cpus = be32_to_cpu(*((__be32 *)(vaddr)));
737         pr_debug("NumCpus     : %u\n", num_cpus);
738         vaddr += sizeof(u32);
739         reg_entry = (struct fadump_reg_entry *)vaddr;
740 
741         /* Allocate buffer to hold cpu crash notes. */
742         fw_dump.cpu_notes_buf_size = num_cpus * sizeof(note_buf_t);
743         fw_dump.cpu_notes_buf_size = PAGE_ALIGN(fw_dump.cpu_notes_buf_size);
744         note_buf = fadump_cpu_notes_buf_alloc(fw_dump.cpu_notes_buf_size);
745         if (!note_buf) {
746                 printk(KERN_ERR "Failed to allocate 0x%lx bytes for "
747                         "cpu notes buffer\n", fw_dump.cpu_notes_buf_size);
748                 return -ENOMEM;
749         }
750         fw_dump.cpu_notes_buf = __pa(note_buf);
751 
752         pr_debug("Allocated buffer for cpu notes of size %ld at %p\n",
753                         (num_cpus * sizeof(note_buf_t)), note_buf);
754 
755         if (fw_dump.fadumphdr_addr)
756                 fdh = __va(fw_dump.fadumphdr_addr);
757 
758         for (i = 0; i < num_cpus; i++) {
759                 if (be64_to_cpu(reg_entry->reg_id) != REG_ID("CPUSTRT")) {
760                         printk(KERN_ERR "Unable to read CPU state data\n");
761                         rc = -ENOENT;
762                         goto error_out;
763                 }
764                 /* Lower 4 bytes of reg_value contains logical cpu id */
765                 cpu = be64_to_cpu(reg_entry->reg_value) & FADUMP_CPU_ID_MASK;
766                 if (fdh && !cpumask_test_cpu(cpu, &fdh->online_mask)) {
767                         SKIP_TO_NEXT_CPU(reg_entry);
768                         continue;
769                 }
770                 pr_debug("Reading register data for cpu %d...\n", cpu);
771                 if (fdh && fdh->crashing_cpu == cpu) {
772                         regs = fdh->regs;
773                         note_buf = fadump_regs_to_elf_notes(note_buf, &regs);
774                         SKIP_TO_NEXT_CPU(reg_entry);
775                 } else {
776                         reg_entry++;
777                         reg_entry = fadump_read_registers(reg_entry, &regs);
778                         note_buf = fadump_regs_to_elf_notes(note_buf, &regs);
779                 }
780         }
781         final_note(note_buf);
782 
783         if (fdh) {
784                 pr_debug("Updating elfcore header (%llx) with cpu notes\n",
785                                                         fdh->elfcorehdr_addr);
786                 fadump_update_elfcore_header((char *)__va(fdh->elfcorehdr_addr));
787         }
788         return 0;
789 
790 error_out:
791         fadump_cpu_notes_buf_free((unsigned long)__va(fw_dump.cpu_notes_buf),
792                                         fw_dump.cpu_notes_buf_size);
793         fw_dump.cpu_notes_buf = 0;
794         fw_dump.cpu_notes_buf_size = 0;
795         return rc;
796 
797 }
798 
799 /*
800  * Validate and process the dump data stored by firmware before exporting
801  * it through '/proc/vmcore'.
802  */
803 static int __init process_fadump(const struct fadump_mem_struct *fdm_active)
804 {
805         struct fadump_crash_info_header *fdh;
806         int rc = 0;
807 
808         if (!fdm_active || !fw_dump.fadumphdr_addr)
809                 return -EINVAL;
810 
811         /* Check if the dump data is valid. */
812         if ((be16_to_cpu(fdm_active->header.dump_status_flag) == FADUMP_ERROR_FLAG) ||
813                         (fdm_active->cpu_state_data.error_flags != 0) ||
814                         (fdm_active->rmr_region.error_flags != 0)) {
815                 printk(KERN_ERR "Dump taken by platform is not valid\n");
816                 return -EINVAL;
817         }
818         if ((fdm_active->rmr_region.bytes_dumped !=
819                         fdm_active->rmr_region.source_len) ||
820                         !fdm_active->cpu_state_data.bytes_dumped) {
821                 printk(KERN_ERR "Dump taken by platform is incomplete\n");
822                 return -EINVAL;
823         }
824 
825         /* Validate the fadump crash info header */
826         fdh = __va(fw_dump.fadumphdr_addr);
827         if (fdh->magic_number != FADUMP_CRASH_INFO_MAGIC) {
828                 printk(KERN_ERR "Crash info header is not valid.\n");
829                 return -EINVAL;
830         }
831 
832         rc = fadump_build_cpu_notes(fdm_active);
833         if (rc)
834                 return rc;
835 
836         /*
837          * We are done validating dump info and elfcore header is now ready
838          * to be exported. set elfcorehdr_addr so that vmcore module will
839          * export the elfcore header through '/proc/vmcore'.
840          */
841         elfcorehdr_addr = fdh->elfcorehdr_addr;
842 
843         return 0;
844 }
845 
846 static inline void fadump_add_crash_memory(unsigned long long base,
847                                         unsigned long long end)
848 {
849         if (base == end)
850                 return;
851 
852         pr_debug("crash_memory_range[%d] [%#016llx-%#016llx], %#llx bytes\n",
853                 crash_mem_ranges, base, end - 1, (end - base));
854         crash_memory_ranges[crash_mem_ranges].base = base;
855         crash_memory_ranges[crash_mem_ranges].size = end - base;
856         crash_mem_ranges++;
857 }
858 
859 static void fadump_exclude_reserved_area(unsigned long long start,
860                                         unsigned long long end)
861 {
862         unsigned long long ra_start, ra_end;
863 
864         ra_start = fw_dump.reserve_dump_area_start;
865         ra_end = ra_start + fw_dump.reserve_dump_area_size;
866 
867         if ((ra_start < end) && (ra_end > start)) {
868                 if ((start < ra_start) && (end > ra_end)) {
869                         fadump_add_crash_memory(start, ra_start);
870                         fadump_add_crash_memory(ra_end, end);
871                 } else if (start < ra_start) {
872                         fadump_add_crash_memory(start, ra_start);
873                 } else if (ra_end < end) {
874                         fadump_add_crash_memory(ra_end, end);
875                 }
876         } else
877                 fadump_add_crash_memory(start, end);
878 }
879 
880 static int fadump_init_elfcore_header(char *bufp)
881 {
882         struct elfhdr *elf;
883 
884         elf = (struct elfhdr *) bufp;
885         bufp += sizeof(struct elfhdr);
886         memcpy(elf->e_ident, ELFMAG, SELFMAG);
887         elf->e_ident[EI_CLASS] = ELF_CLASS;
888         elf->e_ident[EI_DATA] = ELF_DATA;
889         elf->e_ident[EI_VERSION] = EV_CURRENT;
890         elf->e_ident[EI_OSABI] = ELF_OSABI;
891         memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
892         elf->e_type = ET_CORE;
893         elf->e_machine = ELF_ARCH;
894         elf->e_version = EV_CURRENT;
895         elf->e_entry = 0;
896         elf->e_phoff = sizeof(struct elfhdr);
897         elf->e_shoff = 0;
898 #if defined(_CALL_ELF)
899         elf->e_flags = _CALL_ELF;
900 #else
901         elf->e_flags = 0;
902 #endif
903         elf->e_ehsize = sizeof(struct elfhdr);
904         elf->e_phentsize = sizeof(struct elf_phdr);
905         elf->e_phnum = 0;
906         elf->e_shentsize = 0;
907         elf->e_shnum = 0;
908         elf->e_shstrndx = 0;
909 
910         return 0;
911 }
912 
913 /*
914  * Traverse through memblock structure and setup crash memory ranges. These
915  * ranges will be used create PT_LOAD program headers in elfcore header.
916  */
917 static void fadump_setup_crash_memory_ranges(void)
918 {
919         struct memblock_region *reg;
920         unsigned long long start, end;
921 
922         pr_debug("Setup crash memory ranges.\n");
923         crash_mem_ranges = 0;
924         /*
925          * add the first memory chunk (RMA_START through boot_memory_size) as
926          * a separate memory chunk. The reason is, at the time crash firmware
927          * will move the content of this memory chunk to different location
928          * specified during fadump registration. We need to create a separate
929          * program header for this chunk with the correct offset.
930          */
931         fadump_add_crash_memory(RMA_START, fw_dump.boot_memory_size);
932 
933         for_each_memblock(memory, reg) {
934                 start = (unsigned long long)reg->base;
935                 end = start + (unsigned long long)reg->size;
936 
937                 /*
938                  * skip the first memory chunk that is already added (RMA_START
939                  * through boot_memory_size). This logic needs a relook if and
940                  * when RMA_START changes to a non-zero value.
941                  */
942                 BUILD_BUG_ON(RMA_START != 0);
943                 if (start < fw_dump.boot_memory_size) {
944                         if (end > fw_dump.boot_memory_size)
945                                 start = fw_dump.boot_memory_size;
946                         else
947                                 continue;
948                 }
949 
950                 /* add this range excluding the reserved dump area. */
951                 fadump_exclude_reserved_area(start, end);
952         }
953 }
954 
955 /*
956  * If the given physical address falls within the boot memory region then
957  * return the relocated address that points to the dump region reserved
958  * for saving initial boot memory contents.
959  */
960 static inline unsigned long fadump_relocate(unsigned long paddr)
961 {
962         if (paddr > RMA_START && paddr < fw_dump.boot_memory_size)
963                 return be64_to_cpu(fdm.rmr_region.destination_address) + paddr;
964         else
965                 return paddr;
966 }
967 
968 static int fadump_create_elfcore_headers(char *bufp)
969 {
970         struct elfhdr *elf;
971         struct elf_phdr *phdr;
972         int i;
973 
974         fadump_init_elfcore_header(bufp);
975         elf = (struct elfhdr *)bufp;
976         bufp += sizeof(struct elfhdr);
977 
978         /*
979          * setup ELF PT_NOTE, place holder for cpu notes info. The notes info
980          * will be populated during second kernel boot after crash. Hence
981          * this PT_NOTE will always be the first elf note.
982          *
983          * NOTE: Any new ELF note addition should be placed after this note.
984          */
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_offset = 0;
993         phdr->p_paddr = 0;
994         phdr->p_filesz = 0;
995         phdr->p_memsz = 0;
996 
997         (elf->e_phnum)++;
998 
999         /* setup ELF PT_NOTE for vmcoreinfo */
1000         phdr = (struct elf_phdr *)bufp;
1001         bufp += sizeof(struct elf_phdr);
1002         phdr->p_type    = PT_NOTE;
1003         phdr->p_flags   = 0;
1004         phdr->p_vaddr   = 0;
1005         phdr->p_align   = 0;
1006 
1007         phdr->p_paddr   = fadump_relocate(paddr_vmcoreinfo_note());
1008         phdr->p_offset  = phdr->p_paddr;
1009         phdr->p_memsz   = phdr->p_filesz = VMCOREINFO_NOTE_SIZE;
1010 
1011         /* Increment number of program headers. */
1012         (elf->e_phnum)++;
1013 
1014         /* setup PT_LOAD sections. */
1015 
1016         for (i = 0; i < crash_mem_ranges; i++) {
1017                 unsigned long long mbase, msize;
1018                 mbase = crash_memory_ranges[i].base;
1019                 msize = crash_memory_ranges[i].size;
1020 
1021                 if (!msize)
1022                         continue;
1023 
1024                 phdr = (struct elf_phdr *)bufp;
1025                 bufp += sizeof(struct elf_phdr);
1026                 phdr->p_type    = PT_LOAD;
1027                 phdr->p_flags   = PF_R|PF_W|PF_X;
1028                 phdr->p_offset  = mbase;
1029 
1030                 if (mbase == RMA_START) {
1031                         /*
1032                          * The entire RMA region will be moved by firmware
1033                          * to the specified destination_address. Hence set
1034                          * the correct offset.
1035                          */
1036                         phdr->p_offset = be64_to_cpu(fdm.rmr_region.destination_address);
1037                 }
1038 
1039                 phdr->p_paddr = mbase;
1040                 phdr->p_vaddr = (unsigned long)__va(mbase);
1041                 phdr->p_filesz = msize;
1042                 phdr->p_memsz = msize;
1043                 phdr->p_align = 0;
1044 
1045                 /* Increment number of program headers. */
1046                 (elf->e_phnum)++;
1047         }
1048         return 0;
1049 }
1050 
1051 static unsigned long init_fadump_header(unsigned long addr)
1052 {
1053         struct fadump_crash_info_header *fdh;
1054 
1055         if (!addr)
1056                 return 0;
1057 
1058         fw_dump.fadumphdr_addr = addr;
1059         fdh = __va(addr);
1060         addr += sizeof(struct fadump_crash_info_header);
1061 
1062         memset(fdh, 0, sizeof(struct fadump_crash_info_header));
1063         fdh->magic_number = FADUMP_CRASH_INFO_MAGIC;
1064         fdh->elfcorehdr_addr = addr;
1065         /* We will set the crashing cpu id in crash_fadump() during crash. */
1066         fdh->crashing_cpu = CPU_UNKNOWN;
1067 
1068         return addr;
1069 }
1070 
1071 static int register_fadump(void)
1072 {
1073         unsigned long addr;
1074         void *vaddr;
1075 
1076         /*
1077          * If no memory is reserved then we can not register for firmware-
1078          * assisted dump.
1079          */
1080         if (!fw_dump.reserve_dump_area_size)
1081                 return -ENODEV;
1082 
1083         fadump_setup_crash_memory_ranges();
1084 
1085         addr = be64_to_cpu(fdm.rmr_region.destination_address) + be64_to_cpu(fdm.rmr_region.source_len);
1086         /* Initialize fadump crash info header. */
1087         addr = init_fadump_header(addr);
1088         vaddr = __va(addr);
1089 
1090         pr_debug("Creating ELF core headers at %#016lx\n", addr);
1091         fadump_create_elfcore_headers(vaddr);
1092 
1093         /* register the future kernel dump with firmware. */
1094         return register_fw_dump(&fdm);
1095 }
1096 
1097 static int fadump_unregister_dump(struct fadump_mem_struct *fdm)
1098 {
1099         int rc = 0;
1100         unsigned int wait_time;
1101 
1102         pr_debug("Un-register firmware-assisted dump\n");
1103 
1104         /* TODO: Add upper time limit for the delay */
1105         do {
1106                 rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
1107                         FADUMP_UNREGISTER, fdm,
1108                         sizeof(struct fadump_mem_struct));
1109 
1110                 wait_time = rtas_busy_delay_time(rc);
1111                 if (wait_time)
1112                         mdelay(wait_time);
1113         } while (wait_time);
1114 
1115         if (rc) {
1116                 printk(KERN_ERR "Failed to un-register firmware-assisted dump."
1117                         " unexpected error(%d).\n", rc);
1118                 return rc;
1119         }
1120         fw_dump.dump_registered = 0;
1121         return 0;
1122 }
1123 
1124 static int fadump_invalidate_dump(struct fadump_mem_struct *fdm)
1125 {
1126         int rc = 0;
1127         unsigned int wait_time;
1128 
1129         pr_debug("Invalidating firmware-assisted dump registration\n");
1130 
1131         /* TODO: Add upper time limit for the delay */
1132         do {
1133                 rc = rtas_call(fw_dump.ibm_configure_kernel_dump, 3, 1, NULL,
1134                         FADUMP_INVALIDATE, fdm,
1135                         sizeof(struct fadump_mem_struct));
1136 
1137                 wait_time = rtas_busy_delay_time(rc);
1138                 if (wait_time)
1139                         mdelay(wait_time);
1140         } while (wait_time);
1141 
1142         if (rc) {
1143                 pr_err("Failed to invalidate firmware-assisted dump registration. Unexpected error (%d).\n", rc);
1144                 return rc;
1145         }
1146         fw_dump.dump_active = 0;
1147         fdm_active = NULL;
1148         return 0;
1149 }
1150 
1151 void fadump_cleanup(void)
1152 {
1153         /* Invalidate the registration only if dump is active. */
1154         if (fw_dump.dump_active) {
1155                 init_fadump_mem_struct(&fdm,
1156                         be64_to_cpu(fdm_active->cpu_state_data.destination_address));
1157                 fadump_invalidate_dump(&fdm);
1158         }
1159 }
1160 
1161 static void fadump_free_reserved_memory(unsigned long start_pfn,
1162                                         unsigned long end_pfn)
1163 {
1164         unsigned long pfn;
1165         unsigned long time_limit = jiffies + HZ;
1166 
1167         pr_info("freeing reserved memory (0x%llx - 0x%llx)\n",
1168                 PFN_PHYS(start_pfn), PFN_PHYS(end_pfn));
1169 
1170         for (pfn = start_pfn; pfn < end_pfn; pfn++) {
1171                 free_reserved_page(pfn_to_page(pfn));
1172 
1173                 if (time_after(jiffies, time_limit)) {
1174                         cond_resched();
1175                         time_limit = jiffies + HZ;
1176                 }
1177         }
1178 }
1179 
1180 /*
1181  * Skip memory holes and free memory that was actually reserved.
1182  */
1183 static void fadump_release_reserved_area(unsigned long start, unsigned long end)
1184 {
1185         struct memblock_region *reg;
1186         unsigned long tstart, tend;
1187         unsigned long start_pfn = PHYS_PFN(start);
1188         unsigned long end_pfn = PHYS_PFN(end);
1189 
1190         for_each_memblock(memory, reg) {
1191                 tstart = max(start_pfn, memblock_region_memory_base_pfn(reg));
1192                 tend = min(end_pfn, memblock_region_memory_end_pfn(reg));
1193                 if (tstart < tend) {
1194                         fadump_free_reserved_memory(tstart, tend);
1195 
1196                         if (tend == end_pfn)
1197                                 break;
1198 
1199                         start_pfn = tend + 1;
1200                 }
1201         }
1202 }
1203 
1204 /*
1205  * Release the memory that was reserved in early boot to preserve the memory
1206  * contents. The released memory will be available for general use.
1207  */
1208 static void fadump_release_memory(unsigned long begin, unsigned long end)
1209 {
1210         unsigned long ra_start, ra_end;
1211 
1212         ra_start = fw_dump.reserve_dump_area_start;
1213         ra_end = ra_start + fw_dump.reserve_dump_area_size;
1214 
1215         /*
1216          * exclude the dump reserve area. Will reuse it for next
1217          * fadump registration.
1218          */
1219         if (begin < ra_end && end > ra_start) {
1220                 if (begin < ra_start)
1221                         fadump_release_reserved_area(begin, ra_start);
1222                 if (end > ra_end)
1223                         fadump_release_reserved_area(ra_end, end);
1224         } else
1225                 fadump_release_reserved_area(begin, end);
1226 }
1227 
1228 static void fadump_invalidate_release_mem(void)
1229 {
1230         unsigned long reserved_area_start, reserved_area_end;
1231         unsigned long destination_address;
1232 
1233         mutex_lock(&fadump_mutex);
1234         if (!fw_dump.dump_active) {
1235                 mutex_unlock(&fadump_mutex);
1236                 return;
1237         }
1238 
1239         destination_address = be64_to_cpu(fdm_active->cpu_state_data.destination_address);
1240         fadump_cleanup();
1241         mutex_unlock(&fadump_mutex);
1242 
1243         /*
1244          * Save the current reserved memory bounds we will require them
1245          * later for releasing the memory for general use.
1246          */
1247         reserved_area_start = fw_dump.reserve_dump_area_start;
1248         reserved_area_end = reserved_area_start +
1249                         fw_dump.reserve_dump_area_size;
1250         /*
1251          * Setup reserve_dump_area_start and its size so that we can
1252          * reuse this reserved memory for Re-registration.
1253          */
1254         fw_dump.reserve_dump_area_start = destination_address;
1255         fw_dump.reserve_dump_area_size = get_fadump_area_size();
1256 
1257         fadump_release_memory(reserved_area_start, reserved_area_end);
1258         if (fw_dump.cpu_notes_buf) {
1259                 fadump_cpu_notes_buf_free(
1260                                 (unsigned long)__va(fw_dump.cpu_notes_buf),
1261                                 fw_dump.cpu_notes_buf_size);
1262                 fw_dump.cpu_notes_buf = 0;
1263                 fw_dump.cpu_notes_buf_size = 0;
1264         }
1265         /* Initialize the kernel dump memory structure for FAD registration. */
1266         init_fadump_mem_struct(&fdm, fw_dump.reserve_dump_area_start);
1267 }
1268 
1269 static ssize_t fadump_release_memory_store(struct kobject *kobj,
1270                                         struct kobj_attribute *attr,
1271                                         const char *buf, size_t count)
1272 {
1273         int input = -1;
1274 
1275         if (!fw_dump.dump_active)
1276                 return -EPERM;
1277 
1278         if (kstrtoint(buf, 0, &input))
1279                 return -EINVAL;
1280 
1281         if (input == 1) {
1282                 /*
1283                  * Take away the '/proc/vmcore'. We are releasing the dump
1284                  * memory, hence it will not be valid anymore.
1285                  */
1286 #ifdef CONFIG_PROC_VMCORE
1287                 vmcore_cleanup();
1288 #endif
1289                 fadump_invalidate_release_mem();
1290 
1291         } else
1292                 return -EINVAL;
1293         return count;
1294 }
1295 
1296 static ssize_t fadump_enabled_show(struct kobject *kobj,
1297                                         struct kobj_attribute *attr,
1298                                         char *buf)
1299 {
1300         return sprintf(buf, "%d\n", fw_dump.fadump_enabled);
1301 }
1302 
1303 static ssize_t fadump_register_show(struct kobject *kobj,
1304                                         struct kobj_attribute *attr,
1305                                         char *buf)
1306 {
1307         return sprintf(buf, "%d\n", fw_dump.dump_registered);
1308 }
1309 
1310 static ssize_t fadump_register_store(struct kobject *kobj,
1311                                         struct kobj_attribute *attr,
1312                                         const char *buf, size_t count)
1313 {
1314         int ret = 0;
1315         int input = -1;
1316 
1317         if (!fw_dump.fadump_enabled || fdm_active)
1318                 return -EPERM;
1319 
1320         if (kstrtoint(buf, 0, &input))
1321                 return -EINVAL;
1322 
1323         mutex_lock(&fadump_mutex);
1324 
1325         switch (input) {
1326         case 0:
1327                 if (fw_dump.dump_registered == 0) {
1328                         goto unlock_out;
1329                 }
1330                 /* Un-register Firmware-assisted dump */
1331                 fadump_unregister_dump(&fdm);
1332                 break;
1333         case 1:
1334                 if (fw_dump.dump_registered == 1) {
1335                         ret = -EEXIST;
1336                         goto unlock_out;
1337                 }
1338                 /* Register Firmware-assisted dump */
1339                 ret = register_fadump();
1340                 break;
1341         default:
1342                 ret = -EINVAL;
1343                 break;
1344         }
1345 
1346 unlock_out:
1347         mutex_unlock(&fadump_mutex);
1348         return ret < 0 ? ret : count;
1349 }
1350 
1351 static int fadump_region_show(struct seq_file *m, void *private)
1352 {
1353         const struct fadump_mem_struct *fdm_ptr;
1354 
1355         if (!fw_dump.fadump_enabled)
1356                 return 0;
1357 
1358         mutex_lock(&fadump_mutex);
1359         if (fdm_active)
1360                 fdm_ptr = fdm_active;
1361         else {
1362                 mutex_unlock(&fadump_mutex);
1363                 fdm_ptr = &fdm;
1364         }
1365 
1366         seq_printf(m,
1367                         "CPU : [%#016llx-%#016llx] %#llx bytes, "
1368                         "Dumped: %#llx\n",
1369                         be64_to_cpu(fdm_ptr->cpu_state_data.destination_address),
1370                         be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) +
1371                         be64_to_cpu(fdm_ptr->cpu_state_data.source_len) - 1,
1372                         be64_to_cpu(fdm_ptr->cpu_state_data.source_len),
1373                         be64_to_cpu(fdm_ptr->cpu_state_data.bytes_dumped));
1374         seq_printf(m,
1375                         "HPTE: [%#016llx-%#016llx] %#llx bytes, "
1376                         "Dumped: %#llx\n",
1377                         be64_to_cpu(fdm_ptr->hpte_region.destination_address),
1378                         be64_to_cpu(fdm_ptr->hpte_region.destination_address) +
1379                         be64_to_cpu(fdm_ptr->hpte_region.source_len) - 1,
1380                         be64_to_cpu(fdm_ptr->hpte_region.source_len),
1381                         be64_to_cpu(fdm_ptr->hpte_region.bytes_dumped));
1382         seq_printf(m,
1383                         "DUMP: [%#016llx-%#016llx] %#llx bytes, "
1384                         "Dumped: %#llx\n",
1385                         be64_to_cpu(fdm_ptr->rmr_region.destination_address),
1386                         be64_to_cpu(fdm_ptr->rmr_region.destination_address) +
1387                         be64_to_cpu(fdm_ptr->rmr_region.source_len) - 1,
1388                         be64_to_cpu(fdm_ptr->rmr_region.source_len),
1389                         be64_to_cpu(fdm_ptr->rmr_region.bytes_dumped));
1390 
1391         if (!fdm_active ||
1392                 (fw_dump.reserve_dump_area_start ==
1393                 be64_to_cpu(fdm_ptr->cpu_state_data.destination_address)))
1394                 goto out;
1395 
1396         /* Dump is active. Show reserved memory region. */
1397         seq_printf(m,
1398                         "    : [%#016llx-%#016llx] %#llx bytes, "
1399                         "Dumped: %#llx\n",
1400                         (unsigned long long)fw_dump.reserve_dump_area_start,
1401                         be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) - 1,
1402                         be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) -
1403                         fw_dump.reserve_dump_area_start,
1404                         be64_to_cpu(fdm_ptr->cpu_state_data.destination_address) -
1405                         fw_dump.reserve_dump_area_start);
1406 out:
1407         if (fdm_active)
1408                 mutex_unlock(&fadump_mutex);
1409         return 0;
1410 }
1411 
1412 static struct kobj_attribute fadump_release_attr = __ATTR(fadump_release_mem,
1413                                                 0200, NULL,
1414                                                 fadump_release_memory_store);
1415 static struct kobj_attribute fadump_attr = __ATTR(fadump_enabled,
1416                                                 0444, fadump_enabled_show,
1417                                                 NULL);
1418 static struct kobj_attribute fadump_register_attr = __ATTR(fadump_registered,
1419                                                 0644, fadump_register_show,
1420                                                 fadump_register_store);
1421 
1422 static int fadump_region_open(struct inode *inode, struct file *file)
1423 {
1424         return single_open(file, fadump_region_show, inode->i_private);
1425 }
1426 
1427 static const struct file_operations fadump_region_fops = {
1428         .open    = fadump_region_open,
1429         .read    = seq_read,
1430         .llseek  = seq_lseek,
1431         .release = single_release,
1432 };
1433 
1434 static void fadump_init_files(void)
1435 {
1436         struct dentry *debugfs_file;
1437         int rc = 0;
1438 
1439         rc = sysfs_create_file(kernel_kobj, &fadump_attr.attr);
1440         if (rc)
1441                 printk(KERN_ERR "fadump: unable to create sysfs file"
1442                         " fadump_enabled (%d)\n", rc);
1443 
1444         rc = sysfs_create_file(kernel_kobj, &fadump_register_attr.attr);
1445         if (rc)
1446                 printk(KERN_ERR "fadump: unable to create sysfs file"
1447                         " fadump_registered (%d)\n", rc);
1448 
1449         debugfs_file = debugfs_create_file("fadump_region", 0444,
1450                                         powerpc_debugfs_root, NULL,
1451                                         &fadump_region_fops);
1452         if (!debugfs_file)
1453                 printk(KERN_ERR "fadump: unable to create debugfs file"
1454                                 " fadump_region\n");
1455 
1456         if (fw_dump.dump_active) {
1457                 rc = sysfs_create_file(kernel_kobj, &fadump_release_attr.attr);
1458                 if (rc)
1459                         printk(KERN_ERR "fadump: unable to create sysfs file"
1460                                 " fadump_release_mem (%d)\n", rc);
1461         }
1462         return;
1463 }
1464 
1465 /*
1466  * Prepare for firmware-assisted dump.
1467  */
1468 int __init setup_fadump(void)
1469 {
1470         if (!fw_dump.fadump_enabled)
1471                 return 0;
1472 
1473         if (!fw_dump.fadump_supported) {
1474                 printk(KERN_ERR "Firmware-assisted dump is not supported on"
1475                         " this hardware\n");
1476                 return 0;
1477         }
1478 
1479         fadump_show_config();
1480         /*
1481          * If dump data is available then see if it is valid and prepare for
1482          * saving it to the disk.
1483          */
1484         if (fw_dump.dump_active) {
1485                 /*
1486                  * if dump process fails then invalidate the registration
1487                  * and release memory before proceeding for re-registration.
1488                  */
1489                 if (process_fadump(fdm_active) < 0)
1490                         fadump_invalidate_release_mem();
1491         }
1492         /* Initialize the kernel dump memory structure for FAD registration. */
1493         else if (fw_dump.reserve_dump_area_size)
1494                 init_fadump_mem_struct(&fdm, fw_dump.reserve_dump_area_start);
1495         fadump_init_files();
1496 
1497         return 1;
1498 }
1499 subsys_initcall(setup_fadump);
1500 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp