4 * Copyright (C) 2014 Red Hat Inc.
6 * Vivek Goyal <vgoyal@redhat.com>
8 * This source code is licensed under the GNU General Public License,
9 * Version 2. See the file COPYING for more details.
12 #define pr_fmt(fmt) "kexec-bzImage64: " fmt
14 #include <linux/string.h>
15 #include <linux/printk.h>
16 #include <linux/errno.h>
17 #include <linux/slab.h>
18 #include <linux/kexec.h>
19 #include <linux/kernel.h>
21 #include <linux/efi.h>
22 #include <linux/verify_pefile.h>
23 #include <keys/system_keyring.h>
25 #include <asm/bootparam.h>
26 #include <asm/setup.h>
27 #include <asm/crash.h>
29 #include <asm/kexec-bzimage64.h>
31 #define MAX_ELFCOREHDR_STR_LEN 30 /* elfcorehdr=0x<64bit-value> */
34 * Defines lowest physical address for various segments. Not sure where
35 * exactly these limits came from. Current bzimage64 loader in kexec-tools
36 * uses these so I am retaining it. It can be changed over time as we gain
39 #define MIN_PURGATORY_ADDR 0x3000
40 #define MIN_BOOTPARAM_ADDR 0x3000
41 #define MIN_KERNEL_LOAD_ADDR 0x100000
42 #define MIN_INITRD_LOAD_ADDR 0x1000000
45 * This is a place holder for all boot loader specific data structure which
46 * gets allocated in one call but gets freed much later during cleanup
47 * time. Right now there is only one field but it can grow as need be.
49 struct bzimage64_data
{
51 * Temporary buffer to hold bootparams buffer. This should be
52 * freed once the bootparam segment has been loaded.
57 static int setup_initrd(struct boot_params
*params
,
58 unsigned long initrd_load_addr
, unsigned long initrd_len
)
60 params
->hdr
.ramdisk_image
= initrd_load_addr
& 0xffffffffUL
;
61 params
->hdr
.ramdisk_size
= initrd_len
& 0xffffffffUL
;
63 params
->ext_ramdisk_image
= initrd_load_addr
>> 32;
64 params
->ext_ramdisk_size
= initrd_len
>> 32;
69 static int setup_cmdline(struct kimage
*image
, struct boot_params
*params
,
70 unsigned long bootparams_load_addr
,
71 unsigned long cmdline_offset
, char *cmdline
,
72 unsigned long cmdline_len
)
74 char *cmdline_ptr
= ((char *)params
) + cmdline_offset
;
75 unsigned long cmdline_ptr_phys
, len
= 0;
76 uint32_t cmdline_low_32
, cmdline_ext_32
;
78 if (image
->type
== KEXEC_TYPE_CRASH
) {
79 len
= sprintf(cmdline_ptr
,
80 "elfcorehdr=0x%lx ", image
->arch
.elf_load_addr
);
82 memcpy(cmdline_ptr
+ len
, cmdline
, cmdline_len
);
85 cmdline_ptr
[cmdline_len
- 1] = '\0';
87 pr_debug("Final command line is: %s\n", cmdline_ptr
);
88 cmdline_ptr_phys
= bootparams_load_addr
+ cmdline_offset
;
89 cmdline_low_32
= cmdline_ptr_phys
& 0xffffffffUL
;
90 cmdline_ext_32
= cmdline_ptr_phys
>> 32;
92 params
->hdr
.cmd_line_ptr
= cmdline_low_32
;
94 params
->ext_cmd_line_ptr
= cmdline_ext_32
;
99 static int setup_e820_entries(struct boot_params
*params
)
101 unsigned int nr_e820_entries
;
103 nr_e820_entries
= e820_saved
.nr_map
;
105 /* TODO: Pass entries more than E820MAX in bootparams setup data */
106 if (nr_e820_entries
> E820MAX
)
107 nr_e820_entries
= E820MAX
;
109 params
->e820_entries
= nr_e820_entries
;
110 memcpy(¶ms
->e820_map
, &e820_saved
.map
,
111 nr_e820_entries
* sizeof(struct e820entry
));
117 static int setup_efi_info_memmap(struct boot_params
*params
,
118 unsigned long params_load_addr
,
119 unsigned int efi_map_offset
,
120 unsigned int efi_map_sz
)
122 void *efi_map
= (void *)params
+ efi_map_offset
;
123 unsigned long efi_map_phys_addr
= params_load_addr
+ efi_map_offset
;
124 struct efi_info
*ei
= ¶ms
->efi_info
;
129 efi_runtime_map_copy(efi_map
, efi_map_sz
);
131 ei
->efi_memmap
= efi_map_phys_addr
& 0xffffffff;
132 ei
->efi_memmap_hi
= efi_map_phys_addr
>> 32;
133 ei
->efi_memmap_size
= efi_map_sz
;
139 prepare_add_efi_setup_data(struct boot_params
*params
,
140 unsigned long params_load_addr
,
141 unsigned int efi_setup_data_offset
)
143 unsigned long setup_data_phys
;
144 struct setup_data
*sd
= (void *)params
+ efi_setup_data_offset
;
145 struct efi_setup_data
*esd
= (void *)sd
+ sizeof(struct setup_data
);
147 esd
->fw_vendor
= efi
.fw_vendor
;
148 esd
->runtime
= efi
.runtime
;
149 esd
->tables
= efi
.config_table
;
150 esd
->smbios
= efi
.smbios
;
152 sd
->type
= SETUP_EFI
;
153 sd
->len
= sizeof(struct efi_setup_data
);
156 setup_data_phys
= params_load_addr
+ efi_setup_data_offset
;
157 sd
->next
= params
->hdr
.setup_data
;
158 params
->hdr
.setup_data
= setup_data_phys
;
164 setup_efi_state(struct boot_params
*params
, unsigned long params_load_addr
,
165 unsigned int efi_map_offset
, unsigned int efi_map_sz
,
166 unsigned int efi_setup_data_offset
)
168 struct efi_info
*current_ei
= &boot_params
.efi_info
;
169 struct efi_info
*ei
= ¶ms
->efi_info
;
171 if (!current_ei
->efi_memmap_size
)
175 * If 1:1 mapping is not enabled, second kernel can not setup EFI
176 * and use EFI run time services. User space will have to pass
177 * acpi_rsdp=<addr> on kernel command line to make second kernel boot
180 if (efi_enabled(EFI_OLD_MEMMAP
))
183 ei
->efi_loader_signature
= current_ei
->efi_loader_signature
;
184 ei
->efi_systab
= current_ei
->efi_systab
;
185 ei
->efi_systab_hi
= current_ei
->efi_systab_hi
;
187 ei
->efi_memdesc_version
= current_ei
->efi_memdesc_version
;
188 ei
->efi_memdesc_size
= efi_get_runtime_map_desc_size();
190 setup_efi_info_memmap(params
, params_load_addr
, efi_map_offset
,
192 prepare_add_efi_setup_data(params
, params_load_addr
,
193 efi_setup_data_offset
);
196 #endif /* CONFIG_EFI */
199 setup_boot_parameters(struct kimage
*image
, struct boot_params
*params
,
200 unsigned long params_load_addr
,
201 unsigned int efi_map_offset
, unsigned int efi_map_sz
,
202 unsigned int efi_setup_data_offset
)
204 unsigned int nr_e820_entries
;
205 unsigned long long mem_k
, start
, end
;
208 /* Get subarch from existing bootparams */
209 params
->hdr
.hardware_subarch
= boot_params
.hdr
.hardware_subarch
;
211 /* Copying screen_info will do? */
212 memcpy(¶ms
->screen_info
, &boot_params
.screen_info
,
213 sizeof(struct screen_info
));
215 /* Fill in memsize later */
216 params
->screen_info
.ext_mem_k
= 0;
217 params
->alt_mem_k
= 0;
219 /* Default APM info */
220 memset(¶ms
->apm_bios_info
, 0, sizeof(params
->apm_bios_info
));
222 /* Default drive info */
223 memset(¶ms
->hd0_info
, 0, sizeof(params
->hd0_info
));
224 memset(¶ms
->hd1_info
, 0, sizeof(params
->hd1_info
));
226 if (image
->type
== KEXEC_TYPE_CRASH
) {
227 ret
= crash_setup_memmap_entries(image
, params
);
231 setup_e820_entries(params
);
233 nr_e820_entries
= params
->e820_entries
;
235 for (i
= 0; i
< nr_e820_entries
; i
++) {
236 if (params
->e820_map
[i
].type
!= E820_RAM
)
238 start
= params
->e820_map
[i
].addr
;
239 end
= params
->e820_map
[i
].addr
+ params
->e820_map
[i
].size
- 1;
241 if ((start
<= 0x100000) && end
> 0x100000) {
242 mem_k
= (end
>> 10) - (0x100000 >> 10);
243 params
->screen_info
.ext_mem_k
= mem_k
;
244 params
->alt_mem_k
= mem_k
;
246 params
->screen_info
.ext_mem_k
= 0xfc00; /* 64M*/
247 if (mem_k
> 0xffffffff)
248 params
->alt_mem_k
= 0xffffffff;
253 /* Setup EFI state */
254 setup_efi_state(params
, params_load_addr
, efi_map_offset
, efi_map_sz
,
255 efi_setup_data_offset
);
259 memcpy(params
->eddbuf
, boot_params
.eddbuf
,
260 EDDMAXNR
* sizeof(struct edd_info
));
261 params
->eddbuf_entries
= boot_params
.eddbuf_entries
;
263 memcpy(params
->edd_mbr_sig_buffer
, boot_params
.edd_mbr_sig_buffer
,
264 EDD_MBR_SIG_MAX
* sizeof(unsigned int));
269 static int bzImage64_probe(const char *buf
, unsigned long len
)
272 struct setup_header
*header
;
274 /* kernel should be at least two sectors long */
276 pr_err("File is too short to be a bzImage\n");
280 header
= (struct setup_header
*)(buf
+ offsetof(struct boot_params
, hdr
));
281 if (memcmp((char *)&header
->header
, "HdrS", 4) != 0) {
282 pr_err("Not a bzImage\n");
286 if (header
->boot_flag
!= 0xAA55) {
287 pr_err("No x86 boot sector present\n");
291 if (header
->version
< 0x020C) {
292 pr_err("Must be at least protocol version 2.12\n");
296 if (!(header
->loadflags
& LOADED_HIGH
)) {
297 pr_err("zImage not a bzImage\n");
301 if (!(header
->xloadflags
& XLF_KERNEL_64
)) {
302 pr_err("Not a bzImage64. XLF_KERNEL_64 is not set.\n");
306 if (!(header
->xloadflags
& XLF_CAN_BE_LOADED_ABOVE_4G
)) {
307 pr_err("XLF_CAN_BE_LOADED_ABOVE_4G is not set.\n");
312 * Can't handle 32bit EFI as it does not allow loading kernel
313 * above 4G. This should be handled by 32bit bzImage loader
315 if (efi_enabled(EFI_RUNTIME_SERVICES
) && !efi_enabled(EFI_64BIT
)) {
316 pr_debug("EFI is 32 bit. Can't load kernel above 4G.\n");
320 /* I've got a bzImage */
321 pr_debug("It's a relocatable bzImage64\n");
327 static void *bzImage64_load(struct kimage
*image
, char *kernel
,
328 unsigned long kernel_len
, char *initrd
,
329 unsigned long initrd_len
, char *cmdline
,
330 unsigned long cmdline_len
)
333 struct setup_header
*header
;
334 int setup_sects
, kern16_size
, ret
= 0;
335 unsigned long setup_header_size
, params_cmdline_sz
, params_misc_sz
;
336 struct boot_params
*params
;
337 unsigned long bootparam_load_addr
, kernel_load_addr
, initrd_load_addr
;
338 unsigned long purgatory_load_addr
;
339 unsigned long kernel_bufsz
, kernel_memsz
, kernel_align
;
341 struct bzimage64_data
*ldata
;
342 struct kexec_entry64_regs regs64
;
344 unsigned int setup_hdr_offset
= offsetof(struct boot_params
, hdr
);
345 unsigned int efi_map_offset
, efi_map_sz
, efi_setup_data_offset
;
347 header
= (struct setup_header
*)(kernel
+ setup_hdr_offset
);
348 setup_sects
= header
->setup_sects
;
349 if (setup_sects
== 0)
352 kern16_size
= (setup_sects
+ 1) * 512;
353 if (kernel_len
< kern16_size
) {
354 pr_err("bzImage truncated\n");
355 return ERR_PTR(-ENOEXEC
);
358 if (cmdline_len
> header
->cmdline_size
) {
359 pr_err("Kernel command line too long\n");
360 return ERR_PTR(-EINVAL
);
364 * In case of crash dump, we will append elfcorehdr=<addr> to
365 * command line. Make sure it does not overflow
367 if (cmdline_len
+ MAX_ELFCOREHDR_STR_LEN
> header
->cmdline_size
) {
368 pr_debug("Appending elfcorehdr=<addr> to command line exceeds maximum allowed length\n");
369 return ERR_PTR(-EINVAL
);
372 /* Allocate and load backup region */
373 if (image
->type
== KEXEC_TYPE_CRASH
) {
374 ret
= crash_load_segments(image
);
380 * Load purgatory. For 64bit entry point, purgatory code can be
383 ret
= kexec_load_purgatory(image
, MIN_PURGATORY_ADDR
, ULONG_MAX
, 1,
384 &purgatory_load_addr
);
386 pr_err("Loading purgatory failed\n");
390 pr_debug("Loaded purgatory at 0x%lx\n", purgatory_load_addr
);
394 * Load Bootparams and cmdline and space for efi stuff.
396 * Allocate memory together for multiple data structures so
397 * that they all can go in single area/segment and we don't
398 * have to create separate segment for each. Keeps things
401 efi_map_sz
= efi_get_runtime_map_size();
402 efi_map_sz
= ALIGN(efi_map_sz
, 16);
403 params_cmdline_sz
= sizeof(struct boot_params
) + cmdline_len
+
404 MAX_ELFCOREHDR_STR_LEN
;
405 params_cmdline_sz
= ALIGN(params_cmdline_sz
, 16);
406 params_misc_sz
= params_cmdline_sz
+ efi_map_sz
+
407 sizeof(struct setup_data
) +
408 sizeof(struct efi_setup_data
);
410 params
= kzalloc(params_misc_sz
, GFP_KERNEL
);
412 return ERR_PTR(-ENOMEM
);
413 efi_map_offset
= params_cmdline_sz
;
414 efi_setup_data_offset
= efi_map_offset
+ efi_map_sz
;
416 /* Copy setup header onto bootparams. Documentation/x86/boot.txt */
417 setup_header_size
= 0x0202 + kernel
[0x0201] - setup_hdr_offset
;
419 /* Is there a limit on setup header size? */
420 memcpy(¶ms
->hdr
, (kernel
+ setup_hdr_offset
), setup_header_size
);
422 ret
= kexec_add_buffer(image
, (char *)params
, params_misc_sz
,
423 params_misc_sz
, 16, MIN_BOOTPARAM_ADDR
,
424 ULONG_MAX
, 1, &bootparam_load_addr
);
426 goto out_free_params
;
427 pr_debug("Loaded boot_param, command line and misc at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
428 bootparam_load_addr
, params_misc_sz
, params_misc_sz
);
431 kernel_buf
= kernel
+ kern16_size
;
432 kernel_bufsz
= kernel_len
- kern16_size
;
433 kernel_memsz
= PAGE_ALIGN(header
->init_size
);
434 kernel_align
= header
->kernel_alignment
;
436 ret
= kexec_add_buffer(image
, kernel_buf
,
437 kernel_bufsz
, kernel_memsz
, kernel_align
,
438 MIN_KERNEL_LOAD_ADDR
, ULONG_MAX
, 1,
441 goto out_free_params
;
443 pr_debug("Loaded 64bit kernel at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
444 kernel_load_addr
, kernel_memsz
, kernel_memsz
);
446 /* Load initrd high */
448 ret
= kexec_add_buffer(image
, initrd
, initrd_len
, initrd_len
,
449 PAGE_SIZE
, MIN_INITRD_LOAD_ADDR
,
450 ULONG_MAX
, 1, &initrd_load_addr
);
452 goto out_free_params
;
454 pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
455 initrd_load_addr
, initrd_len
, initrd_len
);
457 setup_initrd(params
, initrd_load_addr
, initrd_len
);
460 setup_cmdline(image
, params
, bootparam_load_addr
,
461 sizeof(struct boot_params
), cmdline
, cmdline_len
);
463 /* bootloader info. Do we need a separate ID for kexec kernel loader? */
464 params
->hdr
.type_of_loader
= 0x0D << 4;
465 params
->hdr
.loadflags
= 0;
467 /* Setup purgatory regs for entry */
468 ret
= kexec_purgatory_get_set_symbol(image
, "entry64_regs", ®s64
,
471 goto out_free_params
;
473 regs64
.rbx
= 0; /* Bootstrap Processor */
474 regs64
.rsi
= bootparam_load_addr
;
475 regs64
.rip
= kernel_load_addr
+ 0x200;
476 stack
= kexec_purgatory_get_symbol_addr(image
, "stack_end");
478 pr_err("Could not find address of symbol stack_end\n");
480 goto out_free_params
;
483 regs64
.rsp
= (unsigned long)stack
;
484 ret
= kexec_purgatory_get_set_symbol(image
, "entry64_regs", ®s64
,
487 goto out_free_params
;
489 ret
= setup_boot_parameters(image
, params
, bootparam_load_addr
,
490 efi_map_offset
, efi_map_sz
,
491 efi_setup_data_offset
);
493 goto out_free_params
;
495 /* Allocate loader specific data */
496 ldata
= kzalloc(sizeof(struct bzimage64_data
), GFP_KERNEL
);
499 goto out_free_params
;
503 * Store pointer to params so that it could be freed after loading
504 * params segment has been loaded and contents have been copied
507 ldata
->bootparams_buf
= params
;
515 /* This cleanup function is called after various segments have been loaded */
516 static int bzImage64_cleanup(void *loader_data
)
518 struct bzimage64_data
*ldata
= loader_data
;
523 kfree(ldata
->bootparams_buf
);
524 ldata
->bootparams_buf
= NULL
;
529 #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
530 static int bzImage64_verify_sig(const char *kernel
, unsigned long kernel_len
)
535 ret
= verify_pefile_signature(kernel
, kernel_len
,
536 system_trusted_keyring
,
537 VERIFYING_KEXEC_PE_SIGNATURE
,
542 return -EKEYREJECTED
;
547 struct kexec_file_ops kexec_bzImage64_ops
= {
548 .probe
= bzImage64_probe
,
549 .load
= bzImage64_load
,
550 .cleanup
= bzImage64_cleanup
,
551 #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
552 .verify_sig
= bzImage64_verify_sig
,