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 <linux/suspend.h>
  17 #include <asm/cio.h>
  18 #include <asm/setup.h>
  19 #include <asm/pgtable.h>
  20 #include <asm/pgalloc.h>
  21 #include <asm/smp.h>
  22 #include <asm/reset.h>
  23 #include <asm/ipl.h>
  24 #include <asm/diag.h>
  25 #include <asm/elf.h>
  26 #include <asm/asm-offsets.h>
  27 #include <asm/os_info.h>
  28 #include <asm/switch_to.h>
  29
  30 typedef void (*relocate_kernel_t)(kimage_entry_t *, unsigned long);
  31
  32 extern const unsigned char relocate_kernel[];
  33 extern const unsigned long long relocate_kernel_len;
  34
  35 #ifdef CONFIG_CRASH_DUMP
  36
  37 /*
  38  * Initialize CPU ELF notes
  39  */
  40 static void setup_regs(void)
  41 {
  42         struct save_area *sa, *sa_0;
  43         unsigned long prefix;
  44         int cpu, this_cpu;
  45
  46         /* setup_regs is called with the prefix register = 0 */
  47         sa_0 = (struct save_area *) __LC_FPREGS_SAVE_AREA;
  48
  49         /* Get status of this CPU out of absolute zero */
  50         prefix = (unsigned long) S390_lowcore.prefixreg_save_area;
  51         sa = (struct save_area *)(prefix + __LC_FPREGS_SAVE_AREA);
  52         memcpy(sa, sa_0, sizeof(struct save_area));
  53         if (MACHINE_HAS_VX) {
  54                 struct _lowcore *lc = (struct _lowcore *) prefix;
  55                 save_vx_regs_safe((void *) lc->vector_save_area_addr);
  56         }
  57
  58         /* Get status of the other CPUs */
  59         this_cpu = smp_find_processor_id(stap());
  60         for_each_online_cpu(cpu) {
  61                 if (cpu == this_cpu)
  62                         continue;
  63                 if (smp_store_status(cpu))
  64                         continue;
  65                 prefix = (unsigned long) S390_lowcore.prefixreg_save_area;
  66                 sa = (struct save_area *)(prefix + __LC_FPREGS_SAVE_AREA);
  67                 memcpy(sa, sa_0, sizeof(struct save_area));
  68         }
  69 }
  70
  71 /*
  72  * PM notifier callback for kdump
  73  */
  74 static int machine_kdump_pm_cb(struct notifier_block *nb, unsigned long action,
  75                                void *ptr)
  76 {
  77         switch (action) {
  78         case PM_SUSPEND_PREPARE:
  79         case PM_HIBERNATION_PREPARE:
  80                 if (crashk_res.start)
  81                         crash_map_reserved_pages();
  82                 break;
  83         case PM_POST_SUSPEND:
  84         case PM_POST_HIBERNATION:
  85                 if (crashk_res.start)
  86                         crash_unmap_reserved_pages();
  87                 break;
  88         default:
  89                 return NOTIFY_DONE;
  90         }
  91         return NOTIFY_OK;
  92 }
  93
  94 static int __init machine_kdump_pm_init(void)
  95 {
  96         pm_notifier(machine_kdump_pm_cb, 0);
  97         return 0;
  98 }
  99 arch_initcall(machine_kdump_pm_init);
 100
 101 /*
 102  * Start kdump: We expect here that a store status has been done on our CPU
 103  */
 104 static void __do_machine_kdump(void *image)
 105 {
 106         int (*start_kdump)(int) = (void *)((struct kimage *) image)->start;
 107
 108         __load_psw_mask(PSW_MASK_BASE | PSW_DEFAULT_KEY | PSW_MASK_EA | PSW_MASK_BA);
 109         start_kdump(1);
 110 }
 111 #endif
 112
 113 /*
 114  * Check if kdump checksums are valid: We call purgatory with parameter "0"
 115  */
 116 static int kdump_csum_valid(struct kimage *image)
 117 {
 118 #ifdef CONFIG_CRASH_DUMP
 119         int (*start_kdump)(int) = (void *)image->start;
 120         int rc;
 121
 122         __arch_local_irq_stnsm(0xfb); /* disable DAT */
 123         rc = start_kdump(0);
 124         __arch_local_irq_stosm(0x04); /* enable DAT */
 125         return rc ? 0 : -EINVAL;
 126 #else
 127         return -EINVAL;
 128 #endif
 129 }
 130
 131 /*
 132  * Map or unmap crashkernel memory
 133  */
 134 static void crash_map_pages(int enable)
 135 {
 136         unsigned long size = resource_size(&crashk_res);
 137
 138         BUG_ON(crashk_res.start % KEXEC_CRASH_MEM_ALIGN ||
 139                size % KEXEC_CRASH_MEM_ALIGN);
 140         if (enable)
 141                 vmem_add_mapping(crashk_res.start, size);
 142         else {
 143                 vmem_remove_mapping(crashk_res.start, size);
 144                 if (size)
 145                         os_info_crashkernel_add(crashk_res.start, size);
 146                 else
 147                         os_info_crashkernel_add(0, 0);
 148         }
 149 }
 150
 151 /*
 152  * Map crashkernel memory
 153  */
 154 void crash_map_reserved_pages(void)
 155 {
 156         crash_map_pages(1);
 157 }
 158
 159 /*
 160  * Unmap crashkernel memory
 161  */
 162 void crash_unmap_reserved_pages(void)
 163 {
 164         crash_map_pages(0);
 165 }
 166
 167 /*
 168  * Give back memory to hypervisor before new kdump is loaded
 169  */
 170 static int machine_kexec_prepare_kdump(void)
 171 {
 172 #ifdef CONFIG_CRASH_DUMP
 173         if (MACHINE_IS_VM)
 174                 diag10_range(PFN_DOWN(crashk_res.start),
 175                              PFN_DOWN(crashk_res.end - crashk_res.start + 1));
 176         return 0;
 177 #else
 178         return -EINVAL;
 179 #endif
 180 }
 181
 182 int machine_kexec_prepare(struct kimage *image)
 183 {
 184         void *reboot_code_buffer;
 185
 186         /* Can't replace kernel image since it is read-only. */
 187         if (ipl_flags & IPL_NSS_VALID)
 188                 return -EOPNOTSUPP;
 189
 190         if (image->type == KEXEC_TYPE_CRASH)
 191                 return machine_kexec_prepare_kdump();
 192
 193         /* We don't support anything but the default image type for now. */
 194         if (image->type != KEXEC_TYPE_DEFAULT)
 195                 return -EINVAL;
 196
 197         /* Get the destination where the assembler code should be copied to.*/
 198         reboot_code_buffer = (void *) page_to_phys(image->control_code_page);
 199
 200         /* Then copy it */
 201         memcpy(reboot_code_buffer, relocate_kernel, relocate_kernel_len);
 202         return 0;
 203 }
 204
 205 void machine_kexec_cleanup(struct kimage *image)
 206 {
 207 }
 208
 209 void arch_crash_save_vmcoreinfo(void)
 210 {
 211         VMCOREINFO_SYMBOL(lowcore_ptr);
 212         VMCOREINFO_SYMBOL(high_memory);
 213         VMCOREINFO_LENGTH(lowcore_ptr, NR_CPUS);
 214 }
 215
 216 void machine_shutdown(void)
 217 {
 218 }
 219
 220 void machine_crash_shutdown(struct pt_regs *regs)
 221 {
 222 }
 223
 224 /*
 225  * Do normal kexec
 226  */
 227 static void __do_machine_kexec(void *data)
 228 {
 229         relocate_kernel_t data_mover;
 230         struct kimage *image = data;
 231
 232         data_mover = (relocate_kernel_t) page_to_phys(image->control_code_page);
 233
 234         /* Call the moving routine */
 235         (*data_mover)(&image->head, image->start);
 236 }
 237
 238 /*
 239  * Reset system and call either kdump or normal kexec
 240  */
 241 static void __machine_kexec(void *data)
 242 {
 243         __arch_local_irq_stosm(0x04); /* enable DAT */
 244         pfault_fini();
 245         tracing_off();
 246         debug_locks_off();
 247 #ifdef CONFIG_CRASH_DUMP
 248         if (((struct kimage *) data)->type == KEXEC_TYPE_CRASH) {
 249
 250                 lgr_info_log();
 251                 s390_reset_system(setup_regs, __do_machine_kdump, data);
 252         } else
 253 #endif
 254                 s390_reset_system(NULL, __do_machine_kexec, data);
 255         disabled_wait((unsigned long) __builtin_return_address(0));
 256 }
 257
 258 /*
 259  * Do either kdump or normal kexec. In case of kdump we first ask
 260  * purgatory, if kdump checksums are valid.
 261  */
 262 void machine_kexec(struct kimage *image)
 263 {
 264         if (image->type == KEXEC_TYPE_CRASH && !kdump_csum_valid(image))
 265                 return;
 266         tracer_disable();
 267         smp_send_stop();
 268         smp_call_ipl_cpu(__machine_kexec, image);
 269 }