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/verification.h>
24 #include <asm/bootparam.h>
25 #include <asm/setup.h>
26 #include <asm/crash.h>
28 #include <asm/e820/api.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_table_firmware
->nr_entries
;
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_table
, &e820_table_firmware
->entries
, nr_e820_entries
*sizeof(struct e820_entry
));
116 static int setup_efi_info_memmap(struct boot_params
*params
,
117 unsigned long params_load_addr
,
118 unsigned int efi_map_offset
,
119 unsigned int efi_map_sz
)
121 void *efi_map
= (void *)params
+ efi_map_offset
;
122 unsigned long efi_map_phys_addr
= params_load_addr
+ efi_map_offset
;
123 struct efi_info
*ei
= ¶ms
->efi_info
;
128 efi_runtime_map_copy(efi_map
, efi_map_sz
);
130 ei
->efi_memmap
= efi_map_phys_addr
& 0xffffffff;
131 ei
->efi_memmap_hi
= efi_map_phys_addr
>> 32;
132 ei
->efi_memmap_size
= efi_map_sz
;
138 prepare_add_efi_setup_data(struct boot_params
*params
,
139 unsigned long params_load_addr
,
140 unsigned int efi_setup_data_offset
)
142 unsigned long setup_data_phys
;
143 struct setup_data
*sd
= (void *)params
+ efi_setup_data_offset
;
144 struct efi_setup_data
*esd
= (void *)sd
+ sizeof(struct setup_data
);
146 esd
->fw_vendor
= efi
.fw_vendor
;
147 esd
->runtime
= efi
.runtime
;
148 esd
->tables
= efi
.config_table
;
149 esd
->smbios
= efi
.smbios
;
151 sd
->type
= SETUP_EFI
;
152 sd
->len
= sizeof(struct efi_setup_data
);
155 setup_data_phys
= params_load_addr
+ efi_setup_data_offset
;
156 sd
->next
= params
->hdr
.setup_data
;
157 params
->hdr
.setup_data
= setup_data_phys
;
163 setup_efi_state(struct boot_params
*params
, unsigned long params_load_addr
,
164 unsigned int efi_map_offset
, unsigned int efi_map_sz
,
165 unsigned int efi_setup_data_offset
)
167 struct efi_info
*current_ei
= &boot_params
.efi_info
;
168 struct efi_info
*ei
= ¶ms
->efi_info
;
170 if (!current_ei
->efi_memmap_size
)
174 * If 1:1 mapping is not enabled, second kernel can not setup EFI
175 * and use EFI run time services. User space will have to pass
176 * acpi_rsdp=<addr> on kernel command line to make second kernel boot
179 if (efi_enabled(EFI_OLD_MEMMAP
))
182 ei
->efi_loader_signature
= current_ei
->efi_loader_signature
;
183 ei
->efi_systab
= current_ei
->efi_systab
;
184 ei
->efi_systab_hi
= current_ei
->efi_systab_hi
;
186 ei
->efi_memdesc_version
= current_ei
->efi_memdesc_version
;
187 ei
->efi_memdesc_size
= efi_get_runtime_map_desc_size();
189 setup_efi_info_memmap(params
, params_load_addr
, efi_map_offset
,
191 prepare_add_efi_setup_data(params
, params_load_addr
,
192 efi_setup_data_offset
);
195 #endif /* CONFIG_EFI */
198 setup_boot_parameters(struct kimage
*image
, struct boot_params
*params
,
199 unsigned long params_load_addr
,
200 unsigned int efi_map_offset
, unsigned int efi_map_sz
,
201 unsigned int efi_setup_data_offset
)
203 unsigned int nr_e820_entries
;
204 unsigned long long mem_k
, start
, end
;
207 /* Get subarch from existing bootparams */
208 params
->hdr
.hardware_subarch
= boot_params
.hdr
.hardware_subarch
;
210 /* Copying screen_info will do? */
211 memcpy(¶ms
->screen_info
, &boot_params
.screen_info
,
212 sizeof(struct screen_info
));
214 /* Fill in memsize later */
215 params
->screen_info
.ext_mem_k
= 0;
216 params
->alt_mem_k
= 0;
218 /* Default APM info */
219 memset(¶ms
->apm_bios_info
, 0, sizeof(params
->apm_bios_info
));
221 /* Default drive info */
222 memset(¶ms
->hd0_info
, 0, sizeof(params
->hd0_info
));
223 memset(¶ms
->hd1_info
, 0, sizeof(params
->hd1_info
));
225 if (image
->type
== KEXEC_TYPE_CRASH
) {
226 ret
= crash_setup_memmap_entries(image
, params
);
230 setup_e820_entries(params
);
232 nr_e820_entries
= params
->e820_entries
;
234 for (i
= 0; i
< nr_e820_entries
; i
++) {
235 if (params
->e820_table
[i
].type
!= E820_RAM
)
237 start
= params
->e820_table
[i
].addr
;
238 end
= params
->e820_table
[i
].addr
+ params
->e820_table
[i
].size
- 1;
240 if ((start
<= 0x100000) && end
> 0x100000) {
241 mem_k
= (end
>> 10) - (0x100000 >> 10);
242 params
->screen_info
.ext_mem_k
= mem_k
;
243 params
->alt_mem_k
= mem_k
;
245 params
->screen_info
.ext_mem_k
= 0xfc00; /* 64M*/
246 if (mem_k
> 0xffffffff)
247 params
->alt_mem_k
= 0xffffffff;
252 /* Setup EFI state */
253 setup_efi_state(params
, params_load_addr
, efi_map_offset
, efi_map_sz
,
254 efi_setup_data_offset
);
258 memcpy(params
->eddbuf
, boot_params
.eddbuf
,
259 EDDMAXNR
* sizeof(struct edd_info
));
260 params
->eddbuf_entries
= boot_params
.eddbuf_entries
;
262 memcpy(params
->edd_mbr_sig_buffer
, boot_params
.edd_mbr_sig_buffer
,
263 EDD_MBR_SIG_MAX
* sizeof(unsigned int));
268 static int bzImage64_probe(const char *buf
, unsigned long len
)
271 struct setup_header
*header
;
273 /* kernel should be at least two sectors long */
275 pr_err("File is too short to be a bzImage\n");
279 header
= (struct setup_header
*)(buf
+ offsetof(struct boot_params
, hdr
));
280 if (memcmp((char *)&header
->header
, "HdrS", 4) != 0) {
281 pr_err("Not a bzImage\n");
285 if (header
->boot_flag
!= 0xAA55) {
286 pr_err("No x86 boot sector present\n");
290 if (header
->version
< 0x020C) {
291 pr_err("Must be at least protocol version 2.12\n");
295 if (!(header
->loadflags
& LOADED_HIGH
)) {
296 pr_err("zImage not a bzImage\n");
300 if (!(header
->xloadflags
& XLF_KERNEL_64
)) {
301 pr_err("Not a bzImage64. XLF_KERNEL_64 is not set.\n");
305 if (!(header
->xloadflags
& XLF_CAN_BE_LOADED_ABOVE_4G
)) {
306 pr_err("XLF_CAN_BE_LOADED_ABOVE_4G is not set.\n");
311 * Can't handle 32bit EFI as it does not allow loading kernel
312 * above 4G. This should be handled by 32bit bzImage loader
314 if (efi_enabled(EFI_RUNTIME_SERVICES
) && !efi_enabled(EFI_64BIT
)) {
315 pr_debug("EFI is 32 bit. Can't load kernel above 4G.\n");
319 /* I've got a bzImage */
320 pr_debug("It's a relocatable bzImage64\n");
326 static void *bzImage64_load(struct kimage
*image
, char *kernel
,
327 unsigned long kernel_len
, char *initrd
,
328 unsigned long initrd_len
, char *cmdline
,
329 unsigned long cmdline_len
)
332 struct setup_header
*header
;
333 int setup_sects
, kern16_size
, ret
= 0;
334 unsigned long setup_header_size
, params_cmdline_sz
;
335 struct boot_params
*params
;
336 unsigned long bootparam_load_addr
, kernel_load_addr
, initrd_load_addr
;
337 unsigned long purgatory_load_addr
;
338 struct bzimage64_data
*ldata
;
339 struct kexec_entry64_regs regs64
;
341 unsigned int setup_hdr_offset
= offsetof(struct boot_params
, hdr
);
342 unsigned int efi_map_offset
, efi_map_sz
, efi_setup_data_offset
;
343 struct kexec_buf kbuf
= { .image
= image
, .buf_max
= ULONG_MAX
,
346 header
= (struct setup_header
*)(kernel
+ setup_hdr_offset
);
347 setup_sects
= header
->setup_sects
;
348 if (setup_sects
== 0)
351 kern16_size
= (setup_sects
+ 1) * 512;
352 if (kernel_len
< kern16_size
) {
353 pr_err("bzImage truncated\n");
354 return ERR_PTR(-ENOEXEC
);
357 if (cmdline_len
> header
->cmdline_size
) {
358 pr_err("Kernel command line too long\n");
359 return ERR_PTR(-EINVAL
);
363 * In case of crash dump, we will append elfcorehdr=<addr> to
364 * command line. Make sure it does not overflow
366 if (cmdline_len
+ MAX_ELFCOREHDR_STR_LEN
> header
->cmdline_size
) {
367 pr_debug("Appending elfcorehdr=<addr> to command line exceeds maximum allowed length\n");
368 return ERR_PTR(-EINVAL
);
371 /* Allocate and load backup region */
372 if (image
->type
== KEXEC_TYPE_CRASH
) {
373 ret
= crash_load_segments(image
);
379 * Load purgatory. For 64bit entry point, purgatory code can be
382 ret
= kexec_load_purgatory(image
, MIN_PURGATORY_ADDR
, ULONG_MAX
, 1,
383 &purgatory_load_addr
);
385 pr_err("Loading purgatory failed\n");
389 pr_debug("Loaded purgatory at 0x%lx\n", purgatory_load_addr
);
393 * Load Bootparams and cmdline and space for efi stuff.
395 * Allocate memory together for multiple data structures so
396 * that they all can go in single area/segment and we don't
397 * have to create separate segment for each. Keeps things
400 efi_map_sz
= efi_get_runtime_map_size();
401 efi_map_sz
= ALIGN(efi_map_sz
, 16);
402 params_cmdline_sz
= sizeof(struct boot_params
) + cmdline_len
+
403 MAX_ELFCOREHDR_STR_LEN
;
404 params_cmdline_sz
= ALIGN(params_cmdline_sz
, 16);
405 kbuf
.bufsz
= params_cmdline_sz
+ efi_map_sz
+
406 sizeof(struct setup_data
) +
407 sizeof(struct efi_setup_data
);
409 params
= kzalloc(kbuf
.bufsz
, GFP_KERNEL
);
411 return ERR_PTR(-ENOMEM
);
412 efi_map_offset
= params_cmdline_sz
;
413 efi_setup_data_offset
= efi_map_offset
+ efi_map_sz
;
415 /* Copy setup header onto bootparams. Documentation/x86/boot.txt */
416 setup_header_size
= 0x0202 + kernel
[0x0201] - setup_hdr_offset
;
418 /* Is there a limit on setup header size? */
419 memcpy(¶ms
->hdr
, (kernel
+ setup_hdr_offset
), setup_header_size
);
421 kbuf
.buffer
= params
;
422 kbuf
.memsz
= kbuf
.bufsz
;
424 kbuf
.buf_min
= MIN_BOOTPARAM_ADDR
;
425 ret
= kexec_add_buffer(&kbuf
);
427 goto out_free_params
;
428 bootparam_load_addr
= kbuf
.mem
;
429 pr_debug("Loaded boot_param, command line and misc at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
430 bootparam_load_addr
, kbuf
.bufsz
, kbuf
.bufsz
);
433 kbuf
.buffer
= kernel
+ kern16_size
;
434 kbuf
.bufsz
= kernel_len
- kern16_size
;
435 kbuf
.memsz
= PAGE_ALIGN(header
->init_size
);
436 kbuf
.buf_align
= header
->kernel_alignment
;
437 kbuf
.buf_min
= MIN_KERNEL_LOAD_ADDR
;
438 ret
= kexec_add_buffer(&kbuf
);
440 goto out_free_params
;
441 kernel_load_addr
= kbuf
.mem
;
443 pr_debug("Loaded 64bit kernel at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
444 kernel_load_addr
, kbuf
.bufsz
, kbuf
.memsz
);
446 /* Load initrd high */
448 kbuf
.buffer
= initrd
;
449 kbuf
.bufsz
= kbuf
.memsz
= initrd_len
;
450 kbuf
.buf_align
= PAGE_SIZE
;
451 kbuf
.buf_min
= MIN_INITRD_LOAD_ADDR
;
452 ret
= kexec_add_buffer(&kbuf
);
454 goto out_free_params
;
455 initrd_load_addr
= kbuf
.mem
;
457 pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
458 initrd_load_addr
, initrd_len
, initrd_len
);
460 setup_initrd(params
, initrd_load_addr
, initrd_len
);
463 setup_cmdline(image
, params
, bootparam_load_addr
,
464 sizeof(struct boot_params
), cmdline
, cmdline_len
);
466 /* bootloader info. Do we need a separate ID for kexec kernel loader? */
467 params
->hdr
.type_of_loader
= 0x0D << 4;
468 params
->hdr
.loadflags
= 0;
470 /* Setup purgatory regs for entry */
471 ret
= kexec_purgatory_get_set_symbol(image
, "entry64_regs", ®s64
,
474 goto out_free_params
;
476 regs64
.rbx
= 0; /* Bootstrap Processor */
477 regs64
.rsi
= bootparam_load_addr
;
478 regs64
.rip
= kernel_load_addr
+ 0x200;
479 stack
= kexec_purgatory_get_symbol_addr(image
, "stack_end");
481 pr_err("Could not find address of symbol stack_end\n");
483 goto out_free_params
;
486 regs64
.rsp
= (unsigned long)stack
;
487 ret
= kexec_purgatory_get_set_symbol(image
, "entry64_regs", ®s64
,
490 goto out_free_params
;
492 ret
= setup_boot_parameters(image
, params
, bootparam_load_addr
,
493 efi_map_offset
, efi_map_sz
,
494 efi_setup_data_offset
);
496 goto out_free_params
;
498 /* Allocate loader specific data */
499 ldata
= kzalloc(sizeof(struct bzimage64_data
), GFP_KERNEL
);
502 goto out_free_params
;
506 * Store pointer to params so that it could be freed after loading
507 * params segment has been loaded and contents have been copied
510 ldata
->bootparams_buf
= params
;
518 /* This cleanup function is called after various segments have been loaded */
519 static int bzImage64_cleanup(void *loader_data
)
521 struct bzimage64_data
*ldata
= loader_data
;
526 kfree(ldata
->bootparams_buf
);
527 ldata
->bootparams_buf
= NULL
;
532 #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
533 static int bzImage64_verify_sig(const char *kernel
, unsigned long kernel_len
)
535 return verify_pefile_signature(kernel
, kernel_len
,
537 VERIFYING_KEXEC_PE_SIGNATURE
);
541 struct kexec_file_ops kexec_bzImage64_ops
= {
542 .probe
= bzImage64_probe
,
543 .load
= bzImage64_load
,
544 .cleanup
= bzImage64_cleanup
,
545 #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
546 .verify_sig
= bzImage64_verify_sig
,