2 * kexec.c - kexec_load system call
3 * Copyright (C) 2002-2004 Eric Biederman <ebiederm@xmission.com>
5 * This source code is licensed under the GNU General Public License,
6 * Version 2. See the file COPYING for more details.
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/capability.h>
13 #include <linux/file.h>
14 #include <linux/kexec.h>
15 #include <linux/mutex.h>
16 #include <linux/list.h>
17 #include <linux/syscalls.h>
18 #include <linux/vmalloc.h>
19 #include <linux/slab.h>
21 #include "kexec_internal.h"
23 static int copy_user_segment_list(struct kimage
*image
,
24 unsigned long nr_segments
,
25 struct kexec_segment __user
*segments
)
30 /* Read in the segments */
31 image
->nr_segments
= nr_segments
;
32 segment_bytes
= nr_segments
* sizeof(*segments
);
33 ret
= copy_from_user(image
->segment
, segments
, segment_bytes
);
40 static int kimage_alloc_init(struct kimage
**rimage
, unsigned long entry
,
41 unsigned long nr_segments
,
42 struct kexec_segment __user
*segments
,
47 bool kexec_on_panic
= flags
& KEXEC_ON_CRASH
;
50 /* Verify we have a valid entry point */
51 if ((entry
< crashk_res
.start
) || (entry
> crashk_res
.end
))
52 return -EADDRNOTAVAIL
;
55 /* Allocate and initialize a controlling structure */
56 image
= do_kimage_alloc_init();
62 ret
= copy_user_segment_list(image
, nr_segments
, segments
);
67 /* Enable special crash kernel control page alloc policy. */
68 image
->control_page
= crashk_res
.start
;
69 image
->type
= KEXEC_TYPE_CRASH
;
72 ret
= sanity_check_segment_list(image
);
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.
82 image
->control_code_page
= kimage_alloc_control_pages(image
,
83 get_order(KEXEC_CONTROL_PAGE_SIZE
));
84 if (!image
->control_code_page
) {
85 pr_err("Could not allocate control_code_buffer\n");
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
;
99 out_free_control_pages
:
100 kimage_free_page_list(&image
->control_pages
);
106 static int do_kexec_load(unsigned long entry
, unsigned long nr_segments
,
107 struct kexec_segment __user
*segments
, unsigned long flags
)
109 struct kimage
**dest_image
, *image
;
113 if (flags
& KEXEC_ON_CRASH
) {
114 dest_image
= &kexec_crash_image
;
115 if (kexec_crash_image
)
116 arch_kexec_unprotect_crashkres();
118 dest_image
= &kexec_image
;
121 if (nr_segments
== 0) {
122 /* Uninstall image */
123 kimage_free(xchg(dest_image
, NULL
));
126 if (flags
& KEXEC_ON_CRASH
) {
128 * Loading another kernel to switch to if this one
129 * crashes. Free any current crash dump kernel before
132 kimage_free(xchg(&kexec_crash_image
, NULL
));
135 ret
= kimage_alloc_init(&image
, entry
, nr_segments
, segments
, flags
);
139 if (flags
& KEXEC_ON_CRASH
)
140 crash_map_reserved_pages();
142 if (flags
& KEXEC_PRESERVE_CONTEXT
)
143 image
->preserve_context
= 1;
145 ret
= machine_kexec_prepare(image
);
149 for (i
= 0; i
< nr_segments
; i
++) {
150 ret
= kimage_load_segment(image
, &image
->segment
[i
]);
155 kimage_terminate(image
);
157 /* Install the new kernel and uninstall the old */
158 image
= xchg(dest_image
, image
);
161 if ((flags
& KEXEC_ON_CRASH
) && kexec_crash_image
)
162 arch_kexec_protect_crashkres();
165 * Once the reserved memory is mapped, we should unmap this memory
168 if (flags
& KEXEC_ON_CRASH
)
169 crash_unmap_reserved_pages();
175 * Exec Kernel system call: for obvious reasons only root may call it.
177 * This call breaks up into three pieces.
178 * - A generic part which loads the new kernel from the current
179 * address space, and very carefully places the data in the
182 * - A generic part that interacts with the kernel and tells all of
183 * the devices to shut down. Preventing on-going dmas, and placing
184 * the devices in a consistent state so a later kernel can
187 * - A machine specific part that includes the syscall number
188 * and then copies the image to it's final destination. And
189 * jumps into the image at entry.
191 * kexec does not sync, or unmount filesystems so if you need
192 * that to happen you need to do that yourself.
195 SYSCALL_DEFINE4(kexec_load
, unsigned long, entry
, unsigned long, nr_segments
,
196 struct kexec_segment __user
*, segments
, unsigned long, flags
)
200 /* We only trust the superuser with rebooting the system. */
201 if (!capable(CAP_SYS_BOOT
) || kexec_load_disabled
)
205 * Verify we have a legal set of flags
206 * This leaves us room for future extensions.
208 if ((flags
& KEXEC_FLAGS
) != (flags
& ~KEXEC_ARCH_MASK
))
211 /* Verify we are on the appropriate architecture */
212 if (((flags
& KEXEC_ARCH_MASK
) != KEXEC_ARCH
) &&
213 ((flags
& KEXEC_ARCH_MASK
) != KEXEC_ARCH_DEFAULT
))
216 /* Put an artificial cap on the number
217 * of segments passed to kexec_load.
219 if (nr_segments
> KEXEC_SEGMENT_MAX
)
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.
228 * KISS: always take the mutex.
230 if (!mutex_trylock(&kexec_mutex
))
233 result
= do_kexec_load(entry
, nr_segments
, segments
, flags
);
235 if ((flags
& KEXEC_ON_CRASH
) && kexec_crash_image
)
236 arch_kexec_protect_crashkres();
238 mutex_unlock(&kexec_mutex
);
244 COMPAT_SYSCALL_DEFINE4(kexec_load
, compat_ulong_t
, entry
,
245 compat_ulong_t
, nr_segments
,
246 struct compat_kexec_segment __user
*, segments
,
247 compat_ulong_t
, flags
)
249 struct compat_kexec_segment in
;
250 struct kexec_segment out
, __user
*ksegments
;
251 unsigned long i
, result
;
253 /* Don't allow clients that don't understand the native
254 * architecture to do anything.
256 if ((flags
& KEXEC_ARCH_MASK
) == KEXEC_ARCH_DEFAULT
)
259 if (nr_segments
> KEXEC_SEGMENT_MAX
)
262 ksegments
= compat_alloc_user_space(nr_segments
* sizeof(out
));
263 for (i
= 0; i
< nr_segments
; i
++) {
264 result
= copy_from_user(&in
, &segments
[i
], sizeof(in
));
268 out
.buf
= compat_ptr(in
.buf
);
269 out
.bufsz
= in
.bufsz
;
271 out
.memsz
= in
.memsz
;
273 result
= copy_to_user(&ksegments
[i
], &out
, sizeof(out
));
278 return sys_kexec_load(entry
, nr_segments
, ksegments
, flags
);