arch/s390/kernel/machine_kexec.c

   1 /*
   2  * Copyright IBM Corp. 2005, 2011
   3  *
   4  * Author(s): Rolf Adelsberger,
   5  *            Heiko Carstens <heiko.carstens@de.ibm.com>
   6  *            Michael Holzheu <holzheu@linux.vnet.ibm.com>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/mm.h>
  11 #include <linux/kexec.h>
  12 #include <linux/delay.h>
  13 #include <linux/reboot.h>
  14 #include <linux/ftrace.h>
  15 #include <linux/debug_locks.h>
  16 #include <asm/cio.h>
  17 #include <asm/setup.h>
  18 #include <asm/pgtable.h>
  19 #include <asm/pgalloc.h>
  20 #include <asm/smp.h>
  21 #include <asm/reset.h>
  22 #include <asm/ipl.h>
  23 #include <asm/diag.h>
  24 #include <asm/elf.h>
  25 #include <asm/asm-offsets.h>
  26 #include <asm/os_info.h>
  27
  28 typedef void (*relocate_kernel_t)(kimage_entry_t *, unsigned long);
  29
  30 extern const unsigned char relocate_kernel[];
  31 extern const unsigned long long relocate_kernel_len;
  32
  33 #ifdef CONFIG_CRASH_DUMP
  34
  35 /*
  36  * Create ELF notes for one CPU
  37  */
  38 static void add_elf_notes(int cpu)
  39 {
  40         struct save_area *sa = (void *) 4608 + store_prefix();
  41         void *ptr;
  42
  43         memcpy((void *) (4608UL + sa->pref_reg), sa, sizeof(*sa));
  44         ptr = (u64 *) per_cpu_ptr(crash_notes, cpu);
  45         ptr = fill_cpu_elf_notes(ptr, sa);
  46         memset(ptr, 0, sizeof(struct elf_note));
  47 }
  48
  49 /*
  50  * Initialize CPU ELF notes
  51  */
  52 void setup_regs(void)
  53 {
  54         unsigned long sa = S390_lowcore.prefixreg_save_area + SAVE_AREA_BASE;
  55         int cpu, this_cpu;
  56
  57         this_cpu = smp_find_processor_id(stap());
  58         add_elf_notes(this_cpu);
  59         for_each_online_cpu(cpu) {
  60                 if (cpu == this_cpu)
  61                         continue;
  62                 if (smp_store_status(cpu))
  63                         continue;
  64                 add_elf_notes(cpu);
  65         }
  66         /* Copy dump CPU store status info to absolute zero */
  67         memcpy((void *) SAVE_AREA_BASE, (void *) sa, sizeof(struct save_area));
  68 }
  69
  70 #endif
  71
  72 /*
  73  * Start kdump: We expect here that a store status has been done on our CPU
  74  */
  75 static void __do_machine_kdump(void *image)
  76 {
  77 #ifdef CONFIG_CRASH_DUMP
  78         int (*start_kdump)(int) = (void *)((struct kimage *) image)->start;
  79
  80         setup_regs();
  81         __load_psw_mask(PSW_MASK_BASE | PSW_DEFAULT_KEY | PSW_MASK_EA | PSW_MASK_BA);
  82         start_kdump(1);
  83 #endif
  84 }
  85
  86 /*
  87  * Check if kdump checksums are valid: We call purgatory with parameter "0"
  88  */
  89 static int kdump_csum_valid(struct kimage *image)
  90 {
  91 #ifdef CONFIG_CRASH_DUMP
  92         int (*start_kdump)(int) = (void *)image->start;
  93         int rc;
  94
  95         __arch_local_irq_stnsm(0xfb); /* disable DAT */
  96         rc = start_kdump(0);
  97         __arch_local_irq_stosm(0x04); /* enable DAT */
  98         return rc ? 0 : -EINVAL;
  99 #else
 100         return -EINVAL;
 101 #endif
 102 }
 103
 104 /*
 105  * Map or unmap crashkernel memory
 106  */
 107 static void crash_map_pages(int enable)
 108 {
 109         unsigned long size = resource_size(&crashk_res);
 110
 111         BUG_ON(crashk_res.start % KEXEC_CRASH_MEM_ALIGN ||
 112                size % KEXEC_CRASH_MEM_ALIGN);
 113         if (enable)
 114                 vmem_add_mapping(crashk_res.start, size);
 115         else {
 116                 vmem_remove_mapping(crashk_res.start, size);
 117                 if (size)
 118                         os_info_crashkernel_add(crashk_res.start, size);
 119                 else
 120                         os_info_crashkernel_add(0, 0);
 121         }
 122 }
 123
 124 /*
 125  * Map crashkernel memory
 126  */
 127 void crash_map_reserved_pages(void)
 128 {
 129         crash_map_pages(1);
 130 }
 131
 132 /*
 133  * Unmap crashkernel memory
 134  */
 135 void crash_unmap_reserved_pages(void)
 136 {
 137         crash_map_pages(0);
 138 }
 139
 140 /*
 141  * Give back memory to hypervisor before new kdump is loaded
 142  */
 143 static int machine_kexec_prepare_kdump(void)
 144 {
 145 #ifdef CONFIG_CRASH_DUMP
 146         if (MACHINE_IS_VM)
 147                 diag10_range(PFN_DOWN(crashk_res.start),
 148                              PFN_DOWN(crashk_res.end - crashk_res.start + 1));
 149         return 0;
 150 #else
 151         return -EINVAL;
 152 #endif
 153 }
 154
 155 int machine_kexec_prepare(struct kimage *image)
 156 {
 157         void *reboot_code_buffer;
 158
 159         /* Can't replace kernel image since it is read-only. */
 160         if (ipl_flags & IPL_NSS_VALID)
 161                 return -EOPNOTSUPP;
 162
 163         if (image->type == KEXEC_TYPE_CRASH)
 164                 return machine_kexec_prepare_kdump();
 165
 166         /* We don't support anything but the default image type for now. */
 167         if (image->type != KEXEC_TYPE_DEFAULT)
 168                 return -EINVAL;
 169
 170         /* Get the destination where the assembler code should be copied to.*/
 171         reboot_code_buffer = (void *) page_to_phys(image->control_code_page);
 172
 173         /* Then copy it */
 174         memcpy(reboot_code_buffer, relocate_kernel, relocate_kernel_len);
 175         return 0;
 176 }
 177
 178 void machine_kexec_cleanup(struct kimage *image)
 179 {
 180 }
 181
 182 void arch_crash_save_vmcoreinfo(void)
 183 {
 184         VMCOREINFO_SYMBOL(lowcore_ptr);
 185         VMCOREINFO_SYMBOL(high_memory);
 186         VMCOREINFO_LENGTH(lowcore_ptr, NR_CPUS);
 187 }
 188
 189 void machine_shutdown(void)
 190 {
 191 }
 192
 193 void machine_crash_shutdown(struct pt_regs *regs)
 194 {
 195 }
 196
 197 /*
 198  * Do normal kexec
 199  */
 200 static void __do_machine_kexec(void *data)
 201 {
 202         relocate_kernel_t data_mover;
 203         struct kimage *image = data;
 204
 205         data_mover = (relocate_kernel_t) page_to_phys(image->control_code_page);
 206
 207         /* Call the moving routine */
 208         (*data_mover)(&image->head, image->start);
 209 }
 210
 211 /*
 212  * Reset system and call either kdump or normal kexec
 213  */
 214 static void __machine_kexec(void *data)
 215 {
 216         struct kimage *image = data;
 217
 218         __arch_local_irq_stosm(0x04); /* enable DAT */
 219         pfault_fini();
 220         tracing_off();
 221         debug_locks_off();
 222         if (image->type == KEXEC_TYPE_CRASH) {
 223                 lgr_info_log();
 224                 s390_reset_system(__do_machine_kdump, data);
 225         } else {
 226                 s390_reset_system(__do_machine_kexec, data);
 227         }
 228         disabled_wait((unsigned long) __builtin_return_address(0));
 229 }
 230
 231 /*
 232  * Do either kdump or normal kexec. In case of kdump we first ask
 233  * purgatory, if kdump checksums are valid.
 234  */
 235 void machine_kexec(struct kimage *image)
 236 {
 237         if (image->type == KEXEC_TYPE_CRASH && !kdump_csum_valid(image))
 238                 return;
 239         tracer_disable();
 240         smp_send_stop();
 241         smp_call_ipl_cpu(__machine_kexec, image);
 242 }