arch/powerpc/kernel/crash_dump.c

   1 /*
   2  * Routines for doing kexec-based kdump.
   3  *
   4  * Copyright (C) 2005, IBM Corp.
   5  *
   6  * Created by: Michael Ellerman
   7  *
   8  * This source code is licensed under the GNU General Public License,
   9  * Version 2.  See the file COPYING for more details.
  10  */
  11
  12 #undef DEBUG
  13
  14 #include <linux/crash_dump.h>
  15 #include <linux/bootmem.h>
  16 #include <linux/memblock.h>
  17 #include <asm/code-patching.h>
  18 #include <asm/kdump.h>
  19 #include <asm/prom.h>
  20 #include <asm/firmware.h>
  21 #include <asm/uaccess.h>
  22
  23 #ifdef DEBUG
  24 #include <asm/udbg.h>
  25 #define DBG(fmt...) udbg_printf(fmt)
  26 #else
  27 #define DBG(fmt...)
  28 #endif
  29
  30 /* Stores the physical address of elf header of crash image. */
  31 unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
  32
  33 #ifndef CONFIG_RELOCATABLE
  34 void __init reserve_kdump_trampoline(void)
  35 {
  36         memblock_reserve(0, KDUMP_RESERVE_LIMIT);
  37 }
  38
  39 static void __init create_trampoline(unsigned long addr)
  40 {
  41         unsigned int *p = (unsigned int *)addr;
  42
  43         /* The maximum range of a single instruction branch, is the current
  44          * instruction's address + (32 MB - 4) bytes. For the trampoline we
  45          * need to branch to current address + 32 MB. So we insert a nop at
  46          * the trampoline address, then the next instruction (+ 4 bytes)
  47          * does a branch to (32 MB - 4). The net effect is that when we
  48          * branch to "addr" we jump to ("addr" + 32 MB). Although it requires
  49          * two instructions it doesn't require any registers.
  50          */
  51         patch_instruction(p, PPC_INST_NOP);
  52         patch_branch(++p, addr + PHYSICAL_START, 0);
  53 }
  54
  55 void __init setup_kdump_trampoline(void)
  56 {
  57         unsigned long i;
  58
  59         DBG(" -> setup_kdump_trampoline()\n");
  60
  61         for (i = KDUMP_TRAMPOLINE_START; i < KDUMP_TRAMPOLINE_END; i += 8) {
  62                 create_trampoline(i);
  63         }
  64
  65 #ifdef CONFIG_PPC_PSERIES
  66         create_trampoline(__pa(system_reset_fwnmi) - PHYSICAL_START);
  67         create_trampoline(__pa(machine_check_fwnmi) - PHYSICAL_START);
  68 #endif /* CONFIG_PPC_PSERIES */
  69
  70         DBG(" <- setup_kdump_trampoline()\n");
  71 }
  72 #endif /* CONFIG_RELOCATABLE */
  73
  74 /*
  75  * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
  76  * is_kdump_kernel() to determine if we are booting after a panic. Hence
  77  * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
  78  */
  79 static int __init parse_elfcorehdr(char *p)
  80 {
  81         if (p)
  82                 elfcorehdr_addr = memparse(p, &p);
  83
  84         return 1;
  85 }
  86 __setup("elfcorehdr=", parse_elfcorehdr);
  87
  88 static int __init parse_savemaxmem(char *p)
  89 {
  90         if (p)
  91                 saved_max_pfn = (memparse(p, &p) >> PAGE_SHIFT) - 1;
  92
  93         return 1;
  94 }
  95 __setup("savemaxmem=", parse_savemaxmem);
  96
  97
  98 static size_t copy_oldmem_vaddr(void *vaddr, char *buf, size_t csize,
  99                                unsigned long offset, int userbuf)
 100 {
 101         if (userbuf) {
 102                 if (copy_to_user((char __user *)buf, (vaddr + offset), csize))
 103                         return -EFAULT;
 104         } else
 105                 memcpy(buf, (vaddr + offset), csize);
 106
 107         return csize;
 108 }
 109
 110 /**
 111  * copy_oldmem_page - copy one page from "oldmem"
 112  * @pfn: page frame number to be copied
 113  * @buf: target memory address for the copy; this can be in kernel address
 114  *      space or user address space (see @userbuf)
 115  * @csize: number of bytes to copy
 116  * @offset: offset in bytes into the page (based on pfn) to begin the copy
 117  * @userbuf: if set, @buf is in user address space, use copy_to_user(),
 118  *      otherwise @buf is in kernel address space, use memcpy().
 119  *
 120  * Copy a page from "oldmem". For this page, there is no pte mapped
 121  * in the current kernel. We stitch up a pte, similar to kmap_atomic.
 122  */
 123 ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
 124                         size_t csize, unsigned long offset, int userbuf)
 125 {
 126         void  *vaddr;
 127
 128         if (!csize)
 129                 return 0;
 130
 131         csize = min_t(size_t, csize, PAGE_SIZE);
 132
 133         if ((min_low_pfn < pfn) && (pfn < max_pfn)) {
 134                 vaddr = __va(pfn << PAGE_SHIFT);
 135                 csize = copy_oldmem_vaddr(vaddr, buf, csize, offset, userbuf);
 136         } else {
 137                 vaddr = __ioremap(pfn << PAGE_SHIFT, PAGE_SIZE, 0);
 138                 csize = copy_oldmem_vaddr(vaddr, buf, csize, offset, userbuf);
 139                 iounmap(vaddr);
 140         }
 141
 142         return csize;
 143 }