]>
Commit | Line | Data |
---|---|---|
dc009d92 | 1 | /* |
2965faa5 | 2 | * kexec.c - kexec_load system call |
dc009d92 EB |
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 | ||
de90a6bc MH |
9 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
10 | ||
c59ede7b | 11 | #include <linux/capability.h> |
dc009d92 EB |
12 | #include <linux/mm.h> |
13 | #include <linux/file.h> | |
dc009d92 | 14 | #include <linux/kexec.h> |
4aaaeb2e | 15 | #include <linux/module.h> |
8c5a1cf0 | 16 | #include <linux/mutex.h> |
dc009d92 | 17 | #include <linux/list.h> |
dc009d92 | 18 | #include <linux/syscalls.h> |
a43cac0d | 19 | #include <linux/vmalloc.h> |
2965faa5 | 20 | #include <linux/slab.h> |
dc009d92 | 21 | |
a43cac0d DY |
22 | #include "kexec_internal.h" |
23 | ||
dabe7862 VG |
24 | static int copy_user_segment_list(struct kimage *image, |
25 | unsigned long nr_segments, | |
26 | struct kexec_segment __user *segments) | |
dc009d92 | 27 | { |
dabe7862 | 28 | int ret; |
dc009d92 | 29 | size_t segment_bytes; |
dc009d92 EB |
30 | |
31 | /* Read in the segments */ | |
32 | image->nr_segments = nr_segments; | |
33 | segment_bytes = nr_segments * sizeof(*segments); | |
dabe7862 VG |
34 | ret = copy_from_user(image->segment, segments, segment_bytes); |
35 | if (ret) | |
36 | ret = -EFAULT; | |
37 | ||
38 | return ret; | |
39 | } | |
40 | ||
255aedd9 VG |
41 | static int kimage_alloc_init(struct kimage **rimage, unsigned long entry, |
42 | unsigned long nr_segments, | |
43 | struct kexec_segment __user *segments, | |
44 | unsigned long flags) | |
dc009d92 | 45 | { |
255aedd9 | 46 | int ret; |
dc009d92 | 47 | struct kimage *image; |
255aedd9 VG |
48 | bool kexec_on_panic = flags & KEXEC_ON_CRASH; |
49 | ||
50 | if (kexec_on_panic) { | |
51 | /* Verify we have a valid entry point */ | |
43546d86 RK |
52 | if ((entry < phys_to_boot_phys(crashk_res.start)) || |
53 | (entry > phys_to_boot_phys(crashk_res.end))) | |
255aedd9 VG |
54 | return -EADDRNOTAVAIL; |
55 | } | |
dc009d92 EB |
56 | |
57 | /* Allocate and initialize a controlling structure */ | |
dabe7862 VG |
58 | image = do_kimage_alloc_init(); |
59 | if (!image) | |
60 | return -ENOMEM; | |
61 | ||
62 | image->start = entry; | |
63 | ||
255aedd9 VG |
64 | ret = copy_user_segment_list(image, nr_segments, segments); |
65 | if (ret) | |
dabe7862 VG |
66 | goto out_free_image; |
67 | ||
255aedd9 | 68 | if (kexec_on_panic) { |
cdf4b3fa | 69 | /* Enable special crash kernel control page alloc policy. */ |
255aedd9 VG |
70 | image->control_page = crashk_res.start; |
71 | image->type = KEXEC_TYPE_CRASH; | |
72 | } | |
73 | ||
cdf4b3fa XP |
74 | ret = sanity_check_segment_list(image); |
75 | if (ret) | |
76 | goto out_free_image; | |
77 | ||
dc009d92 EB |
78 | /* |
79 | * Find a location for the control code buffer, and add it | |
80 | * the vector of segments so that it's pages will also be | |
81 | * counted as destination pages. | |
82 | */ | |
255aedd9 | 83 | ret = -ENOMEM; |
dc009d92 | 84 | image->control_code_page = kimage_alloc_control_pages(image, |
163f6876 | 85 | get_order(KEXEC_CONTROL_PAGE_SIZE)); |
dc009d92 | 86 | if (!image->control_code_page) { |
e1bebcf4 | 87 | pr_err("Could not allocate control_code_buffer\n"); |
dabe7862 | 88 | goto out_free_image; |
dc009d92 EB |
89 | } |
90 | ||
255aedd9 VG |
91 | if (!kexec_on_panic) { |
92 | image->swap_page = kimage_alloc_control_pages(image, 0); | |
93 | if (!image->swap_page) { | |
94 | pr_err("Could not allocate swap buffer\n"); | |
95 | goto out_free_control_pages; | |
96 | } | |
3ab83521 HY |
97 | } |
98 | ||
b92e7e0d ZY |
99 | *rimage = image; |
100 | return 0; | |
dabe7862 | 101 | out_free_control_pages: |
b92e7e0d | 102 | kimage_free_page_list(&image->control_pages); |
dabe7862 | 103 | out_free_image: |
b92e7e0d | 104 | kfree(image); |
255aedd9 | 105 | return ret; |
dc009d92 EB |
106 | } |
107 | ||
0eea0867 MH |
108 | static int do_kexec_load(unsigned long entry, unsigned long nr_segments, |
109 | struct kexec_segment __user *segments, unsigned long flags) | |
110 | { | |
111 | struct kimage **dest_image, *image; | |
112 | unsigned long i; | |
113 | int ret; | |
114 | ||
115 | if (flags & KEXEC_ON_CRASH) { | |
116 | dest_image = &kexec_crash_image; | |
117 | if (kexec_crash_image) | |
118 | arch_kexec_unprotect_crashkres(); | |
119 | } else { | |
120 | dest_image = &kexec_image; | |
121 | } | |
122 | ||
123 | if (nr_segments == 0) { | |
124 | /* Uninstall image */ | |
125 | kimage_free(xchg(dest_image, NULL)); | |
126 | return 0; | |
127 | } | |
128 | if (flags & KEXEC_ON_CRASH) { | |
129 | /* | |
130 | * Loading another kernel to switch to if this one | |
131 | * crashes. Free any current crash dump kernel before | |
132 | * we corrupt it. | |
133 | */ | |
134 | kimage_free(xchg(&kexec_crash_image, NULL)); | |
135 | } | |
136 | ||
137 | ret = kimage_alloc_init(&image, entry, nr_segments, segments, flags); | |
138 | if (ret) | |
139 | return ret; | |
140 | ||
0eea0867 MH |
141 | if (flags & KEXEC_PRESERVE_CONTEXT) |
142 | image->preserve_context = 1; | |
143 | ||
144 | ret = machine_kexec_prepare(image); | |
145 | if (ret) | |
146 | goto out; | |
147 | ||
148 | for (i = 0; i < nr_segments; i++) { | |
149 | ret = kimage_load_segment(image, &image->segment[i]); | |
150 | if (ret) | |
151 | goto out; | |
152 | } | |
153 | ||
154 | kimage_terminate(image); | |
155 | ||
156 | /* Install the new kernel and uninstall the old */ | |
157 | image = xchg(dest_image, image); | |
158 | ||
159 | out: | |
160 | if ((flags & KEXEC_ON_CRASH) && kexec_crash_image) | |
161 | arch_kexec_protect_crashkres(); | |
162 | ||
0eea0867 MH |
163 | kimage_free(image); |
164 | return ret; | |
165 | } | |
166 | ||
dc009d92 EB |
167 | /* |
168 | * Exec Kernel system call: for obvious reasons only root may call it. | |
169 | * | |
170 | * This call breaks up into three pieces. | |
171 | * - A generic part which loads the new kernel from the current | |
172 | * address space, and very carefully places the data in the | |
173 | * allocated pages. | |
174 | * | |
175 | * - A generic part that interacts with the kernel and tells all of | |
176 | * the devices to shut down. Preventing on-going dmas, and placing | |
177 | * the devices in a consistent state so a later kernel can | |
178 | * reinitialize them. | |
179 | * | |
180 | * - A machine specific part that includes the syscall number | |
002ace78 | 181 | * and then copies the image to it's final destination. And |
dc009d92 EB |
182 | * jumps into the image at entry. |
183 | * | |
184 | * kexec does not sync, or unmount filesystems so if you need | |
185 | * that to happen you need to do that yourself. | |
186 | */ | |
8c5a1cf0 | 187 | |
754fe8d2 HC |
188 | SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments, |
189 | struct kexec_segment __user *, segments, unsigned long, flags) | |
dc009d92 | 190 | { |
dc009d92 EB |
191 | int result; |
192 | ||
193 | /* We only trust the superuser with rebooting the system. */ | |
7984754b | 194 | if (!capable(CAP_SYS_BOOT) || kexec_load_disabled) |
dc009d92 EB |
195 | return -EPERM; |
196 | ||
4aaaeb2e MG |
197 | /* |
198 | * kexec can be used to circumvent module loading restrictions, so | |
199 | * prevent loading in that case | |
200 | */ | |
201 | if (secure_modules()) | |
202 | return -EPERM; | |
203 | ||
dc009d92 EB |
204 | /* |
205 | * Verify we have a legal set of flags | |
206 | * This leaves us room for future extensions. | |
207 | */ | |
208 | if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK)) | |
209 | return -EINVAL; | |
210 | ||
211 | /* Verify we are on the appropriate architecture */ | |
212 | if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) && | |
213 | ((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT)) | |
dc009d92 | 214 | return -EINVAL; |
dc009d92 EB |
215 | |
216 | /* Put an artificial cap on the number | |
217 | * of segments passed to kexec_load. | |
218 | */ | |
219 | if (nr_segments > KEXEC_SEGMENT_MAX) | |
220 | return -EINVAL; | |
221 | ||
dc009d92 EB |
222 | /* Because we write directly to the reserved memory |
223 | * region when loading crash kernels we need a mutex here to | |
224 | * prevent multiple crash kernels from attempting to load | |
225 | * simultaneously, and to prevent a crash kernel from loading | |
226 | * over the top of a in use crash kernel. | |
227 | * | |
228 | * KISS: always take the mutex. | |
229 | */ | |
8c5a1cf0 | 230 | if (!mutex_trylock(&kexec_mutex)) |
dc009d92 | 231 | return -EBUSY; |
72414d3f | 232 | |
0eea0867 | 233 | result = do_kexec_load(entry, nr_segments, segments, flags); |
dc009d92 | 234 | |
8c5a1cf0 | 235 | mutex_unlock(&kexec_mutex); |
72414d3f | 236 | |
dc009d92 EB |
237 | return result; |
238 | } | |
239 | ||
240 | #ifdef CONFIG_COMPAT | |
ca2c405a HC |
241 | COMPAT_SYSCALL_DEFINE4(kexec_load, compat_ulong_t, entry, |
242 | compat_ulong_t, nr_segments, | |
243 | struct compat_kexec_segment __user *, segments, | |
244 | compat_ulong_t, flags) | |
dc009d92 EB |
245 | { |
246 | struct compat_kexec_segment in; | |
247 | struct kexec_segment out, __user *ksegments; | |
248 | unsigned long i, result; | |
249 | ||
250 | /* Don't allow clients that don't understand the native | |
251 | * architecture to do anything. | |
252 | */ | |
72414d3f | 253 | if ((flags & KEXEC_ARCH_MASK) == KEXEC_ARCH_DEFAULT) |
dc009d92 | 254 | return -EINVAL; |
dc009d92 | 255 | |
72414d3f | 256 | if (nr_segments > KEXEC_SEGMENT_MAX) |
dc009d92 | 257 | return -EINVAL; |
dc009d92 EB |
258 | |
259 | ksegments = compat_alloc_user_space(nr_segments * sizeof(out)); | |
e1bebcf4 | 260 | for (i = 0; i < nr_segments; i++) { |
dc009d92 | 261 | result = copy_from_user(&in, &segments[i], sizeof(in)); |
72414d3f | 262 | if (result) |
dc009d92 | 263 | return -EFAULT; |
dc009d92 EB |
264 | |
265 | out.buf = compat_ptr(in.buf); | |
266 | out.bufsz = in.bufsz; | |
267 | out.mem = in.mem; | |
268 | out.memsz = in.memsz; | |
269 | ||
270 | result = copy_to_user(&ksegments[i], &out, sizeof(out)); | |
72414d3f | 271 | if (result) |
dc009d92 | 272 | return -EFAULT; |
dc009d92 EB |
273 | } |
274 | ||
275 | return sys_kexec_load(entry, nr_segments, ksegments, flags); | |
276 | } | |
277 | #endif |