Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 1 | /* |
Dave Young | 2965faa | 2015-09-09 15:38:55 -0700 | [diff] [blame] | 2 | * kexec.c - kexec_load system call |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 3 | * Copyright (C) 2002-2004 Eric Biederman <ebiederm@xmission.com> |
| 4 | * |
| 5 | * This source code is licensed under the GNU General Public License, |
| 6 | * Version 2. See the file COPYING for more details. |
| 7 | */ |
| 8 | |
Minfei Huang | de90a6b | 2015-11-06 16:32:45 -0800 | [diff] [blame] | 9 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 10 | |
Randy.Dunlap | c59ede7 | 2006-01-11 12:17:46 -0800 | [diff] [blame] | 11 | #include <linux/capability.h> |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 12 | #include <linux/mm.h> |
| 13 | #include <linux/file.h> |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 14 | #include <linux/kexec.h> |
Andrew Morton | 8c5a1cf | 2008-08-15 00:40:27 -0700 | [diff] [blame] | 15 | #include <linux/mutex.h> |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 16 | #include <linux/list.h> |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 17 | #include <linux/syscalls.h> |
Dave Young | a43cac0 | 2015-09-09 15:38:51 -0700 | [diff] [blame] | 18 | #include <linux/vmalloc.h> |
Dave Young | 2965faa | 2015-09-09 15:38:55 -0700 | [diff] [blame] | 19 | #include <linux/slab.h> |
Alexander Nyberg | 6e274d1 | 2005-06-25 14:58:26 -0700 | [diff] [blame] | 20 | |
Dave Young | a43cac0 | 2015-09-09 15:38:51 -0700 | [diff] [blame] | 21 | #include "kexec_internal.h" |
| 22 | |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 23 | static int copy_user_segment_list(struct kimage *image, |
| 24 | unsigned long nr_segments, |
| 25 | struct kexec_segment __user *segments) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 26 | { |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 27 | int ret; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 28 | size_t segment_bytes; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 29 | |
| 30 | /* Read in the segments */ |
| 31 | image->nr_segments = nr_segments; |
| 32 | segment_bytes = nr_segments * sizeof(*segments); |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 33 | ret = copy_from_user(image->segment, segments, segment_bytes); |
| 34 | if (ret) |
| 35 | ret = -EFAULT; |
| 36 | |
| 37 | return ret; |
| 38 | } |
| 39 | |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 40 | static int kimage_alloc_init(struct kimage **rimage, unsigned long entry, |
| 41 | unsigned long nr_segments, |
| 42 | struct kexec_segment __user *segments, |
| 43 | unsigned long flags) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 44 | { |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 45 | int ret; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 46 | struct kimage *image; |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 47 | bool kexec_on_panic = flags & KEXEC_ON_CRASH; |
| 48 | |
| 49 | if (kexec_on_panic) { |
| 50 | /* Verify we have a valid entry point */ |
| 51 | if ((entry < crashk_res.start) || (entry > crashk_res.end)) |
| 52 | return -EADDRNOTAVAIL; |
| 53 | } |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 54 | |
| 55 | /* Allocate and initialize a controlling structure */ |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 56 | image = do_kimage_alloc_init(); |
| 57 | if (!image) |
| 58 | return -ENOMEM; |
| 59 | |
| 60 | image->start = entry; |
| 61 | |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 62 | ret = copy_user_segment_list(image, nr_segments, segments); |
| 63 | if (ret) |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 64 | goto out_free_image; |
| 65 | |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 66 | if (kexec_on_panic) { |
Xunlei Pang | cdf4b3f | 2016-01-20 15:00:31 -0800 | [diff] [blame] | 67 | /* Enable special crash kernel control page alloc policy. */ |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 68 | image->control_page = crashk_res.start; |
| 69 | image->type = KEXEC_TYPE_CRASH; |
| 70 | } |
| 71 | |
Xunlei Pang | cdf4b3f | 2016-01-20 15:00:31 -0800 | [diff] [blame] | 72 | ret = sanity_check_segment_list(image); |
| 73 | if (ret) |
| 74 | goto out_free_image; |
| 75 | |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 76 | /* |
| 77 | * Find a location for the control code buffer, and add it |
| 78 | * the vector of segments so that it's pages will also be |
| 79 | * counted as destination pages. |
| 80 | */ |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 81 | ret = -ENOMEM; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 82 | image->control_code_page = kimage_alloc_control_pages(image, |
Huang Ying | 163f687 | 2008-08-15 00:40:22 -0700 | [diff] [blame] | 83 | get_order(KEXEC_CONTROL_PAGE_SIZE)); |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 84 | if (!image->control_code_page) { |
Fabian Frederick | e1bebcf | 2014-06-06 14:37:09 -0700 | [diff] [blame] | 85 | pr_err("Could not allocate control_code_buffer\n"); |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 86 | goto out_free_image; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 89 | if (!kexec_on_panic) { |
| 90 | image->swap_page = kimage_alloc_control_pages(image, 0); |
| 91 | if (!image->swap_page) { |
| 92 | pr_err("Could not allocate swap buffer\n"); |
| 93 | goto out_free_control_pages; |
| 94 | } |
Huang Ying | 3ab8352 | 2008-07-25 19:45:07 -0700 | [diff] [blame] | 95 | } |
| 96 | |
Zhang Yanfei | b92e7e0 | 2013-02-27 17:03:29 -0800 | [diff] [blame] | 97 | *rimage = image; |
| 98 | return 0; |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 99 | out_free_control_pages: |
Zhang Yanfei | b92e7e0 | 2013-02-27 17:03:29 -0800 | [diff] [blame] | 100 | kimage_free_page_list(&image->control_pages); |
Vivek Goyal | dabe786 | 2014-08-08 14:25:45 -0700 | [diff] [blame] | 101 | out_free_image: |
Zhang Yanfei | b92e7e0 | 2013-02-27 17:03:29 -0800 | [diff] [blame] | 102 | kfree(image); |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 103 | return ret; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 106 | /* |
| 107 | * Exec Kernel system call: for obvious reasons only root may call it. |
| 108 | * |
| 109 | * This call breaks up into three pieces. |
| 110 | * - A generic part which loads the new kernel from the current |
| 111 | * address space, and very carefully places the data in the |
| 112 | * allocated pages. |
| 113 | * |
| 114 | * - A generic part that interacts with the kernel and tells all of |
| 115 | * the devices to shut down. Preventing on-going dmas, and placing |
| 116 | * the devices in a consistent state so a later kernel can |
| 117 | * reinitialize them. |
| 118 | * |
| 119 | * - A machine specific part that includes the syscall number |
Geert Uytterhoeven | 002ace7 | 2013-09-15 11:35:37 +0200 | [diff] [blame] | 120 | * and then copies the image to it's final destination. And |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 121 | * jumps into the image at entry. |
| 122 | * |
| 123 | * kexec does not sync, or unmount filesystems so if you need |
| 124 | * that to happen you need to do that yourself. |
| 125 | */ |
Andrew Morton | 8c5a1cf | 2008-08-15 00:40:27 -0700 | [diff] [blame] | 126 | |
Heiko Carstens | 754fe8d | 2009-01-14 14:14:09 +0100 | [diff] [blame] | 127 | SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments, |
| 128 | struct kexec_segment __user *, segments, unsigned long, flags) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 129 | { |
| 130 | struct kimage **dest_image, *image; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 131 | int result; |
| 132 | |
| 133 | /* We only trust the superuser with rebooting the system. */ |
Kees Cook | 7984754 | 2014-01-23 15:55:59 -0800 | [diff] [blame] | 134 | if (!capable(CAP_SYS_BOOT) || kexec_load_disabled) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 135 | return -EPERM; |
| 136 | |
| 137 | /* |
| 138 | * Verify we have a legal set of flags |
| 139 | * This leaves us room for future extensions. |
| 140 | */ |
| 141 | if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK)) |
| 142 | return -EINVAL; |
| 143 | |
| 144 | /* Verify we are on the appropriate architecture */ |
| 145 | if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) && |
| 146 | ((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT)) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 147 | return -EINVAL; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 148 | |
| 149 | /* Put an artificial cap on the number |
| 150 | * of segments passed to kexec_load. |
| 151 | */ |
| 152 | if (nr_segments > KEXEC_SEGMENT_MAX) |
| 153 | return -EINVAL; |
| 154 | |
| 155 | image = NULL; |
| 156 | result = 0; |
| 157 | |
| 158 | /* Because we write directly to the reserved memory |
| 159 | * region when loading crash kernels we need a mutex here to |
| 160 | * prevent multiple crash kernels from attempting to load |
| 161 | * simultaneously, and to prevent a crash kernel from loading |
| 162 | * over the top of a in use crash kernel. |
| 163 | * |
| 164 | * KISS: always take the mutex. |
| 165 | */ |
Andrew Morton | 8c5a1cf | 2008-08-15 00:40:27 -0700 | [diff] [blame] | 166 | if (!mutex_trylock(&kexec_mutex)) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 167 | return -EBUSY; |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 168 | |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 169 | dest_image = &kexec_image; |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 170 | if (flags & KEXEC_ON_CRASH) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 171 | dest_image = &kexec_crash_image; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 172 | if (nr_segments > 0) { |
| 173 | unsigned long i; |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 174 | |
Geoff Levand | 518a0c7 | 2015-02-17 13:45:53 -0800 | [diff] [blame] | 175 | if (flags & KEXEC_ON_CRASH) { |
| 176 | /* |
| 177 | * Loading another kernel to switch to if this one |
| 178 | * crashes. Free any current crash dump kernel before |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 179 | * we corrupt it. |
| 180 | */ |
Geoff Levand | 518a0c7 | 2015-02-17 13:45:53 -0800 | [diff] [blame] | 181 | |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 182 | kimage_free(xchg(&kexec_crash_image, NULL)); |
Vivek Goyal | 255aedd | 2014-08-08 14:25:48 -0700 | [diff] [blame] | 183 | result = kimage_alloc_init(&image, entry, nr_segments, |
| 184 | segments, flags); |
Michael Holzheu | 558df72 | 2011-10-30 15:16:43 +0100 | [diff] [blame] | 185 | crash_map_reserved_pages(); |
Geoff Levand | 518a0c7 | 2015-02-17 13:45:53 -0800 | [diff] [blame] | 186 | } else { |
| 187 | /* Loading another kernel to reboot into. */ |
| 188 | |
| 189 | result = kimage_alloc_init(&image, entry, nr_segments, |
| 190 | segments, flags); |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 191 | } |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 192 | if (result) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 193 | goto out; |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 194 | |
Huang Ying | 3ab8352 | 2008-07-25 19:45:07 -0700 | [diff] [blame] | 195 | if (flags & KEXEC_PRESERVE_CONTEXT) |
| 196 | image->preserve_context = 1; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 197 | result = machine_kexec_prepare(image); |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 198 | if (result) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 199 | goto out; |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 200 | |
| 201 | for (i = 0; i < nr_segments; i++) { |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 202 | result = kimage_load_segment(image, &image->segment[i]); |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 203 | if (result) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 204 | goto out; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 205 | } |
WANG Cong | 7fccf03 | 2008-07-25 19:45:02 -0700 | [diff] [blame] | 206 | kimage_terminate(image); |
Michael Holzheu | 558df72 | 2011-10-30 15:16:43 +0100 | [diff] [blame] | 207 | if (flags & KEXEC_ON_CRASH) |
| 208 | crash_unmap_reserved_pages(); |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 209 | } |
| 210 | /* Install the new kernel, and Uninstall the old */ |
| 211 | image = xchg(dest_image, image); |
| 212 | |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 213 | out: |
Andrew Morton | 8c5a1cf | 2008-08-15 00:40:27 -0700 | [diff] [blame] | 214 | mutex_unlock(&kexec_mutex); |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 215 | kimage_free(image); |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 216 | |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 217 | return result; |
| 218 | } |
| 219 | |
| 220 | #ifdef CONFIG_COMPAT |
Heiko Carstens | ca2c405 | 2014-03-04 17:13:42 +0100 | [diff] [blame] | 221 | COMPAT_SYSCALL_DEFINE4(kexec_load, compat_ulong_t, entry, |
| 222 | compat_ulong_t, nr_segments, |
| 223 | struct compat_kexec_segment __user *, segments, |
| 224 | compat_ulong_t, flags) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 225 | { |
| 226 | struct compat_kexec_segment in; |
| 227 | struct kexec_segment out, __user *ksegments; |
| 228 | unsigned long i, result; |
| 229 | |
| 230 | /* Don't allow clients that don't understand the native |
| 231 | * architecture to do anything. |
| 232 | */ |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 233 | if ((flags & KEXEC_ARCH_MASK) == KEXEC_ARCH_DEFAULT) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 234 | return -EINVAL; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 235 | |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 236 | if (nr_segments > KEXEC_SEGMENT_MAX) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 237 | return -EINVAL; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 238 | |
| 239 | ksegments = compat_alloc_user_space(nr_segments * sizeof(out)); |
Fabian Frederick | e1bebcf | 2014-06-06 14:37:09 -0700 | [diff] [blame] | 240 | for (i = 0; i < nr_segments; i++) { |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 241 | result = copy_from_user(&in, &segments[i], sizeof(in)); |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 242 | if (result) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 243 | return -EFAULT; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 244 | |
| 245 | out.buf = compat_ptr(in.buf); |
| 246 | out.bufsz = in.bufsz; |
| 247 | out.mem = in.mem; |
| 248 | out.memsz = in.memsz; |
| 249 | |
| 250 | result = copy_to_user(&ksegments[i], &out, sizeof(out)); |
Maneesh Soni | 72414d3 | 2005-06-25 14:58:28 -0700 | [diff] [blame] | 251 | if (result) |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 252 | return -EFAULT; |
Eric W. Biederman | dc009d9 | 2005-06-25 14:57:52 -0700 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | return sys_kexec_load(entry, nr_segments, ksegments, flags); |
| 256 | } |
| 257 | #endif |