Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 1 | /* |
Heiko Carstens | a53c8fa | 2012-07-20 11:15:04 +0200 | [diff] [blame] | 2 | * Copyright IBM Corp. 2005, 2011 |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 3 | * |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 4 | * Author(s): Rolf Adelsberger, |
| 5 | * Heiko Carstens <heiko.carstens@de.ibm.com> |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 6 | * Michael Holzheu <holzheu@linux.vnet.ibm.com> |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 9 | #include <linux/device.h> |
| 10 | #include <linux/mm.h> |
| 11 | #include <linux/kexec.h> |
| 12 | #include <linux/delay.h> |
Heiko Carstens | 2b67fc4 | 2007-02-05 21:16:47 +0100 | [diff] [blame] | 13 | #include <linux/reboot.h> |
Heiko Carstens | 6966727 | 2011-03-15 17:08:33 +0100 | [diff] [blame] | 14 | #include <linux/ftrace.h> |
Michael Holzheu | 3ab121a | 2012-03-11 11:59:32 -0400 | [diff] [blame] | 15 | #include <linux/debug_locks.h> |
Michael Holzheu | b66ac63 | 2013-04-04 19:49:53 +0200 | [diff] [blame] | 16 | #include <linux/suspend.h> |
Heiko Carstens | a386fba | 2006-02-11 17:56:01 -0800 | [diff] [blame] | 17 | #include <asm/cio.h> |
| 18 | #include <asm/setup.h> |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 19 | #include <asm/pgtable.h> |
| 20 | #include <asm/pgalloc.h> |
Heiko Carstens | a386fba | 2006-02-11 17:56:01 -0800 | [diff] [blame] | 21 | #include <asm/smp.h> |
Heiko Carstens | 15e9b58 | 2006-12-04 15:40:26 +0100 | [diff] [blame] | 22 | #include <asm/reset.h> |
Heiko Carstens | 9c9c176 | 2007-03-05 23:35:45 +0100 | [diff] [blame] | 23 | #include <asm/ipl.h> |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 24 | #include <asm/diag.h> |
Heiko Carstens | 6b563d8 | 2012-09-14 14:11:32 +0200 | [diff] [blame] | 25 | #include <asm/elf.h> |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 26 | #include <asm/asm-offsets.h> |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 27 | #include <asm/cacheflush.h> |
Michael Holzheu | a9fbf1a | 2012-05-18 15:10:05 +0200 | [diff] [blame] | 28 | #include <asm/os_info.h> |
Michael Holzheu | a62bc07 | 2014-10-06 17:57:43 +0200 | [diff] [blame] | 29 | #include <asm/switch_to.h> |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 30 | |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 31 | typedef void (*relocate_kernel_t)(kimage_entry_t *, unsigned long); |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 32 | |
Tobias Klauser | 2efe55a | 2006-06-26 18:57:34 +0200 | [diff] [blame] | 33 | extern const unsigned char relocate_kernel[]; |
| 34 | extern const unsigned long long relocate_kernel_len; |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 35 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 36 | #ifdef CONFIG_CRASH_DUMP |
| 37 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 38 | /* |
Michael Holzheu | b66ac63 | 2013-04-04 19:49:53 +0200 | [diff] [blame] | 39 | * PM notifier callback for kdump |
| 40 | */ |
| 41 | static int machine_kdump_pm_cb(struct notifier_block *nb, unsigned long action, |
| 42 | void *ptr) |
| 43 | { |
| 44 | switch (action) { |
| 45 | case PM_SUSPEND_PREPARE: |
| 46 | case PM_HIBERNATION_PREPARE: |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 47 | if (kexec_crash_image) |
| 48 | arch_kexec_unprotect_crashkres(); |
Michael Holzheu | b66ac63 | 2013-04-04 19:49:53 +0200 | [diff] [blame] | 49 | break; |
| 50 | case PM_POST_SUSPEND: |
| 51 | case PM_POST_HIBERNATION: |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 52 | if (kexec_crash_image) |
| 53 | arch_kexec_protect_crashkres(); |
Michael Holzheu | b66ac63 | 2013-04-04 19:49:53 +0200 | [diff] [blame] | 54 | break; |
| 55 | default: |
| 56 | return NOTIFY_DONE; |
| 57 | } |
| 58 | return NOTIFY_OK; |
| 59 | } |
| 60 | |
| 61 | static int __init machine_kdump_pm_init(void) |
| 62 | { |
| 63 | pm_notifier(machine_kdump_pm_cb, 0); |
| 64 | return 0; |
| 65 | } |
| 66 | arch_initcall(machine_kdump_pm_init); |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 67 | |
| 68 | /* |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 69 | * Reset the system, copy boot CPU registers to absolute zero, |
| 70 | * and jump to the kdump image |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 71 | */ |
| 72 | static void __do_machine_kdump(void *image) |
| 73 | { |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 74 | int (*start_kdump)(int); |
| 75 | unsigned long prefix; |
| 76 | |
| 77 | /* store_status() saved the prefix register to lowcore */ |
| 78 | prefix = (unsigned long) S390_lowcore.prefixreg_save_area; |
| 79 | |
| 80 | /* Now do the reset */ |
| 81 | s390_reset_system(); |
| 82 | |
| 83 | /* |
| 84 | * Copy dump CPU store status info to absolute zero. |
| 85 | * This need to be done *after* s390_reset_system set the |
| 86 | * prefix register of this CPU to zero |
| 87 | */ |
| 88 | memcpy((void *) __LC_FPREGS_SAVE_AREA, |
| 89 | (void *)(prefix + __LC_FPREGS_SAVE_AREA), 512); |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 90 | |
Michael Holzheu | fa7c004 | 2012-05-21 11:30:30 +0200 | [diff] [blame] | 91 | __load_psw_mask(PSW_MASK_BASE | PSW_DEFAULT_KEY | PSW_MASK_EA | PSW_MASK_BA); |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 92 | start_kdump = (void *)((struct kimage *) image)->start; |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 93 | start_kdump(1); |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 94 | |
| 95 | /* Die if start_kdump returns */ |
| 96 | disabled_wait((unsigned long) __builtin_return_address(0)); |
| 97 | } |
| 98 | |
| 99 | /* |
| 100 | * Start kdump: create a LGR log entry, store status of all CPUs and |
| 101 | * branch to __do_machine_kdump. |
| 102 | */ |
| 103 | static noinline void __machine_kdump(void *image) |
| 104 | { |
| 105 | int this_cpu, cpu; |
| 106 | |
| 107 | lgr_info_log(); |
| 108 | /* Get status of the other CPUs */ |
| 109 | this_cpu = smp_find_processor_id(stap()); |
| 110 | for_each_online_cpu(cpu) { |
| 111 | if (cpu == this_cpu) |
| 112 | continue; |
| 113 | if (smp_store_status(cpu)) |
| 114 | continue; |
| 115 | } |
| 116 | /* Store status of the boot CPU */ |
| 117 | if (MACHINE_HAS_VX) |
| 118 | save_vx_regs((void *) &S390_lowcore.vector_save_area); |
| 119 | /* |
| 120 | * To create a good backchain for this CPU in the dump store_status |
| 121 | * is passed the address of a function. The address is saved into |
| 122 | * the PSW save area of the boot CPU and the function is invoked as |
| 123 | * a tail call of store_status. The backchain in the dump will look |
| 124 | * like this: |
| 125 | * restart_int_handler -> __machine_kexec -> __do_machine_kdump |
| 126 | * The call to store_status() will not return. |
| 127 | */ |
| 128 | store_status(__do_machine_kdump, image); |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 129 | } |
Martin Schwidefsky | 10ad34b | 2015-01-14 17:52:10 +0100 | [diff] [blame] | 130 | #endif |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 131 | |
| 132 | /* |
| 133 | * Check if kdump checksums are valid: We call purgatory with parameter "0" |
| 134 | */ |
| 135 | static int kdump_csum_valid(struct kimage *image) |
| 136 | { |
| 137 | #ifdef CONFIG_CRASH_DUMP |
| 138 | int (*start_kdump)(int) = (void *)image->start; |
| 139 | int rc; |
| 140 | |
| 141 | __arch_local_irq_stnsm(0xfb); /* disable DAT */ |
| 142 | rc = start_kdump(0); |
| 143 | __arch_local_irq_stosm(0x04); /* enable DAT */ |
| 144 | return rc ? 0 : -EINVAL; |
| 145 | #else |
| 146 | return -EINVAL; |
| 147 | #endif |
| 148 | } |
| 149 | |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 150 | #ifdef CONFIG_CRASH_DUMP |
| 151 | |
Heiko Carstens | 2d0af22 | 2016-05-31 09:13:59 +0200 | [diff] [blame] | 152 | void crash_free_reserved_phys_range(unsigned long begin, unsigned long end) |
| 153 | { |
| 154 | unsigned long addr, size; |
| 155 | |
| 156 | for (addr = begin; addr < end; addr += PAGE_SIZE) |
| 157 | free_reserved_page(pfn_to_page(addr >> PAGE_SHIFT)); |
| 158 | size = begin - crashk_res.start; |
| 159 | if (size) |
| 160 | os_info_crashkernel_add(crashk_res.start, size); |
| 161 | else |
| 162 | os_info_crashkernel_add(0, 0); |
| 163 | } |
| 164 | |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 165 | static void crash_protect_pages(int protect) |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 166 | { |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 167 | unsigned long size; |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 168 | |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 169 | if (!crashk_res.end) |
| 170 | return; |
| 171 | size = resource_size(&crashk_res); |
| 172 | if (protect) |
| 173 | set_memory_ro(crashk_res.start, size >> PAGE_SHIFT); |
Heiko Carstens | 2d0af22 | 2016-05-31 09:13:59 +0200 | [diff] [blame] | 174 | else |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 175 | set_memory_rw(crashk_res.start, size >> PAGE_SHIFT); |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 176 | } |
| 177 | |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 178 | void arch_kexec_protect_crashkres(void) |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 179 | { |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 180 | crash_protect_pages(1); |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 181 | } |
| 182 | |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 183 | void arch_kexec_unprotect_crashkres(void) |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 184 | { |
Heiko Carstens | 4e042af | 2016-05-31 09:14:00 +0200 | [diff] [blame] | 185 | crash_protect_pages(0); |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 186 | } |
| 187 | |
Xunlei Pang | 7a0058e | 2016-05-23 16:24:22 -0700 | [diff] [blame] | 188 | #endif |
| 189 | |
Michael Holzheu | dab7a7b | 2011-10-30 15:16:44 +0100 | [diff] [blame] | 190 | /* |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 191 | * Give back memory to hypervisor before new kdump is loaded |
| 192 | */ |
| 193 | static int machine_kexec_prepare_kdump(void) |
| 194 | { |
| 195 | #ifdef CONFIG_CRASH_DUMP |
| 196 | if (MACHINE_IS_VM) |
| 197 | diag10_range(PFN_DOWN(crashk_res.start), |
| 198 | PFN_DOWN(crashk_res.end - crashk_res.start + 1)); |
| 199 | return 0; |
| 200 | #else |
| 201 | return -EINVAL; |
| 202 | #endif |
| 203 | } |
| 204 | |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 205 | int machine_kexec_prepare(struct kimage *image) |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 206 | { |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 207 | void *reboot_code_buffer; |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 208 | |
Heiko Carstens | 9c9c176 | 2007-03-05 23:35:45 +0100 | [diff] [blame] | 209 | /* Can't replace kernel image since it is read-only. */ |
| 210 | if (ipl_flags & IPL_NSS_VALID) |
Heiko Carstens | d978386 | 2012-09-06 15:19:08 +0200 | [diff] [blame] | 211 | return -EOPNOTSUPP; |
Heiko Carstens | 9c9c176 | 2007-03-05 23:35:45 +0100 | [diff] [blame] | 212 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 213 | if (image->type == KEXEC_TYPE_CRASH) |
| 214 | return machine_kexec_prepare_kdump(); |
| 215 | |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 216 | /* We don't support anything but the default image type for now. */ |
| 217 | if (image->type != KEXEC_TYPE_DEFAULT) |
| 218 | return -EINVAL; |
| 219 | |
| 220 | /* Get the destination where the assembler code should be copied to.*/ |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 221 | reboot_code_buffer = (void *) page_to_phys(image->control_code_page); |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 222 | |
| 223 | /* Then copy it */ |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 224 | memcpy(reboot_code_buffer, relocate_kernel, relocate_kernel_len); |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 225 | return 0; |
| 226 | } |
| 227 | |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 228 | void machine_kexec_cleanup(struct kimage *image) |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 229 | { |
| 230 | } |
| 231 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 232 | void arch_crash_save_vmcoreinfo(void) |
| 233 | { |
| 234 | VMCOREINFO_SYMBOL(lowcore_ptr); |
Michael Holzheu | 7fe7a18 | 2011-12-27 11:27:24 +0100 | [diff] [blame] | 235 | VMCOREINFO_SYMBOL(high_memory); |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 236 | VMCOREINFO_LENGTH(lowcore_ptr, NR_CPUS); |
| 237 | } |
| 238 | |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 239 | void machine_shutdown(void) |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 240 | { |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 241 | } |
| 242 | |
Heiko Carstens | 48a8ca0 | 2012-08-27 15:50:29 +0200 | [diff] [blame] | 243 | void machine_crash_shutdown(struct pt_regs *regs) |
| 244 | { |
| 245 | } |
| 246 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 247 | /* |
| 248 | * Do normal kexec |
| 249 | */ |
| 250 | static void __do_machine_kexec(void *data) |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 251 | { |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 252 | relocate_kernel_t data_mover; |
Heiko Carstens | 2c2df11 | 2010-02-26 22:37:34 +0100 | [diff] [blame] | 253 | struct kimage *image = data; |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 254 | |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 255 | s390_reset_system(); |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 256 | data_mover = (relocate_kernel_t) page_to_phys(image->control_code_page); |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 257 | |
| 258 | /* Call the moving routine */ |
Heiko Carstens | c6b5b84 | 2006-12-04 15:40:33 +0100 | [diff] [blame] | 259 | (*data_mover)(&image->head, image->start); |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 260 | |
| 261 | /* Die if kexec returns */ |
| 262 | disabled_wait((unsigned long) __builtin_return_address(0)); |
Heiko Carstens | cf13f0e | 2005-06-25 14:58:11 -0700 | [diff] [blame] | 263 | } |
Heiko Carstens | 2c2df11 | 2010-02-26 22:37:34 +0100 | [diff] [blame] | 264 | |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 265 | /* |
| 266 | * Reset system and call either kdump or normal kexec |
| 267 | */ |
| 268 | static void __machine_kexec(void *data) |
| 269 | { |
Michael Holzheu | fa7c004 | 2012-05-21 11:30:30 +0200 | [diff] [blame] | 270 | __arch_local_irq_stosm(0x04); /* enable DAT */ |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 271 | pfault_fini(); |
Michael Holzheu | 3ab121a | 2012-03-11 11:59:32 -0400 | [diff] [blame] | 272 | tracing_off(); |
| 273 | debug_locks_off(); |
Martin Schwidefsky | 10ad34b | 2015-01-14 17:52:10 +0100 | [diff] [blame] | 274 | #ifdef CONFIG_CRASH_DUMP |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 275 | if (((struct kimage *) data)->type == KEXEC_TYPE_CRASH) |
| 276 | __machine_kdump(data); |
Martin Schwidefsky | 10ad34b | 2015-01-14 17:52:10 +0100 | [diff] [blame] | 277 | #endif |
Martin Schwidefsky | 1a36a39 | 2015-10-29 10:28:26 +0100 | [diff] [blame] | 278 | __do_machine_kexec(data); |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | /* |
| 282 | * Do either kdump or normal kexec. In case of kdump we first ask |
| 283 | * purgatory, if kdump checksums are valid. |
| 284 | */ |
Heiko Carstens | 2c2df11 | 2010-02-26 22:37:34 +0100 | [diff] [blame] | 285 | void machine_kexec(struct kimage *image) |
| 286 | { |
Michael Holzheu | 60a0c68 | 2011-10-30 15:16:40 +0100 | [diff] [blame] | 287 | if (image->type == KEXEC_TYPE_CRASH && !kdump_csum_valid(image)) |
| 288 | return; |
Heiko Carstens | 6966727 | 2011-03-15 17:08:33 +0100 | [diff] [blame] | 289 | tracer_disable(); |
Heiko Carstens | 2c2df11 | 2010-02-26 22:37:34 +0100 | [diff] [blame] | 290 | smp_send_stop(); |
Martin Schwidefsky | 8b646bd | 2012-03-11 11:59:26 -0400 | [diff] [blame] | 291 | smp_call_ipl_cpu(__machine_kexec, image); |
Heiko Carstens | 2c2df11 | 2010-02-26 22:37:34 +0100 | [diff] [blame] | 292 | } |