arch/x86/kernel/kexec-bzimage64.c

   1 /*
   2  * Kexec bzImage loader
   3  *
   4  * Copyright (C) 2014 Red Hat Inc.
   5  * Authors:
   6  *      Vivek Goyal <vgoyal@redhat.com>
   7  *
   8  * This source code is licensed under the GNU General Public License,
   9  * Version 2.  See the file COPYING for more details.
  10  */
  11
  12 #define pr_fmt(fmt)     "kexec-bzImage64: " fmt
  13
  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>
  20 #include <linux/mm.h>
  21
  22 #include <asm/bootparam.h>
  23 #include <asm/setup.h>
  24
  25 /*
  26  * Defines lowest physical address for various segments. Not sure where
  27  * exactly these limits came from. Current bzimage64 loader in kexec-tools
  28  * uses these so I am retaining it. It can be changed over time as we gain
  29  * more insight.
  30  */
  31 #define MIN_PURGATORY_ADDR      0x3000
  32 #define MIN_BOOTPARAM_ADDR      0x3000
  33 #define MIN_KERNEL_LOAD_ADDR    0x100000
  34 #define MIN_INITRD_LOAD_ADDR    0x1000000
  35
  36 /*
  37  * This is a place holder for all boot loader specific data structure which
  38  * gets allocated in one call but gets freed much later during cleanup
  39  * time. Right now there is only one field but it can grow as need be.
  40  */
  41 struct bzimage64_data {
  42         /*
  43          * Temporary buffer to hold bootparams buffer. This should be
  44          * freed once the bootparam segment has been loaded.
  45          */
  46         void *bootparams_buf;
  47 };
  48
  49 static int setup_initrd(struct boot_params *params,
  50                 unsigned long initrd_load_addr, unsigned long initrd_len)
  51 {
  52         params->hdr.ramdisk_image = initrd_load_addr & 0xffffffffUL;
  53         params->hdr.ramdisk_size = initrd_len & 0xffffffffUL;
  54
  55         params->ext_ramdisk_image = initrd_load_addr >> 32;
  56         params->ext_ramdisk_size = initrd_len >> 32;
  57
  58         return 0;
  59 }
  60
  61 static int setup_cmdline(struct boot_params *params,
  62                          unsigned long bootparams_load_addr,
  63                          unsigned long cmdline_offset, char *cmdline,
  64                          unsigned long cmdline_len)
  65 {
  66         char *cmdline_ptr = ((char *)params) + cmdline_offset;
  67         unsigned long cmdline_ptr_phys;
  68         uint32_t cmdline_low_32, cmdline_ext_32;
  69
  70         memcpy(cmdline_ptr, cmdline, cmdline_len);
  71         cmdline_ptr[cmdline_len - 1] = '\0';
  72
  73         cmdline_ptr_phys = bootparams_load_addr + cmdline_offset;
  74         cmdline_low_32 = cmdline_ptr_phys & 0xffffffffUL;
  75         cmdline_ext_32 = cmdline_ptr_phys >> 32;
  76
  77         params->hdr.cmd_line_ptr = cmdline_low_32;
  78         if (cmdline_ext_32)
  79                 params->ext_cmd_line_ptr = cmdline_ext_32;
  80
  81         return 0;
  82 }
  83
  84 static int setup_memory_map_entries(struct boot_params *params)
  85 {
  86         unsigned int nr_e820_entries;
  87
  88         nr_e820_entries = e820_saved.nr_map;
  89
  90         /* TODO: Pass entries more than E820MAX in bootparams setup data */
  91         if (nr_e820_entries > E820MAX)
  92                 nr_e820_entries = E820MAX;
  93
  94         params->e820_entries = nr_e820_entries;
  95         memcpy(&params->e820_map, &e820_saved.map,
  96                nr_e820_entries * sizeof(struct e820entry));
  97
  98         return 0;
  99 }
 100
 101 static int setup_boot_parameters(struct boot_params *params)
 102 {
 103         unsigned int nr_e820_entries;
 104         unsigned long long mem_k, start, end;
 105         int i;
 106
 107         /* Get subarch from existing bootparams */
 108         params->hdr.hardware_subarch = boot_params.hdr.hardware_subarch;
 109
 110         /* Copying screen_info will do? */
 111         memcpy(&params->screen_info, &boot_params.screen_info,
 112                                 sizeof(struct screen_info));
 113
 114         /* Fill in memsize later */
 115         params->screen_info.ext_mem_k = 0;
 116         params->alt_mem_k = 0;
 117
 118         /* Default APM info */
 119         memset(&params->apm_bios_info, 0, sizeof(params->apm_bios_info));
 120
 121         /* Default drive info */
 122         memset(&params->hd0_info, 0, sizeof(params->hd0_info));
 123         memset(&params->hd1_info, 0, sizeof(params->hd1_info));
 124
 125         /* Default sysdesc table */
 126         params->sys_desc_table.length = 0;
 127
 128         setup_memory_map_entries(params);
 129         nr_e820_entries = params->e820_entries;
 130
 131         for (i = 0; i < nr_e820_entries; i++) {
 132                 if (params->e820_map[i].type != E820_RAM)
 133                         continue;
 134                 start = params->e820_map[i].addr;
 135                 end = params->e820_map[i].addr + params->e820_map[i].size - 1;
 136
 137                 if ((start <= 0x100000) && end > 0x100000) {
 138                         mem_k = (end >> 10) - (0x100000 >> 10);
 139                         params->screen_info.ext_mem_k = mem_k;
 140                         params->alt_mem_k = mem_k;
 141                         if (mem_k > 0xfc00)
 142                                 params->screen_info.ext_mem_k = 0xfc00; /* 64M*/
 143                         if (mem_k > 0xffffffff)
 144                                 params->alt_mem_k = 0xffffffff;
 145                 }
 146         }
 147
 148         /* Setup EDD info */
 149         memcpy(params->eddbuf, boot_params.eddbuf,
 150                                 EDDMAXNR * sizeof(struct edd_info));
 151         params->eddbuf_entries = boot_params.eddbuf_entries;
 152
 153         memcpy(params->edd_mbr_sig_buffer, boot_params.edd_mbr_sig_buffer,
 154                EDD_MBR_SIG_MAX * sizeof(unsigned int));
 155
 156         return 0;
 157 }
 158
 159 int bzImage64_probe(const char *buf, unsigned long len)
 160 {
 161         int ret = -ENOEXEC;
 162         struct setup_header *header;
 163
 164         /* kernel should be atleast two sectors long */
 165         if (len < 2 * 512) {
 166                 pr_err("File is too short to be a bzImage\n");
 167                 return ret;
 168         }
 169
 170         header = (struct setup_header *)(buf + offsetof(struct boot_params, hdr));
 171         if (memcmp((char *)&header->header, "HdrS", 4) != 0) {
 172                 pr_err("Not a bzImage\n");
 173                 return ret;
 174         }
 175
 176         if (header->boot_flag != 0xAA55) {
 177                 pr_err("No x86 boot sector present\n");
 178                 return ret;
 179         }
 180
 181         if (header->version < 0x020C) {
 182                 pr_err("Must be at least protocol version 2.12\n");
 183                 return ret;
 184         }
 185
 186         if (!(header->loadflags & LOADED_HIGH)) {
 187                 pr_err("zImage not a bzImage\n");
 188                 return ret;
 189         }
 190
 191         if (!(header->xloadflags & XLF_KERNEL_64)) {
 192                 pr_err("Not a bzImage64. XLF_KERNEL_64 is not set.\n");
 193                 return ret;
 194         }
 195
 196         if (!(header->xloadflags & XLF_CAN_BE_LOADED_ABOVE_4G)) {
 197                 pr_err("XLF_CAN_BE_LOADED_ABOVE_4G is not set.\n");
 198                 return ret;
 199         }
 200
 201         /* I've got a bzImage */
 202         pr_debug("It's a relocatable bzImage64\n");
 203         ret = 0;
 204
 205         return ret;
 206 }
 207
 208 void *bzImage64_load(struct kimage *image, char *kernel,
 209                      unsigned long kernel_len, char *initrd,
 210                      unsigned long initrd_len, char *cmdline,
 211                      unsigned long cmdline_len)
 212 {
 213
 214         struct setup_header *header;
 215         int setup_sects, kern16_size, ret = 0;
 216         unsigned long setup_header_size, params_cmdline_sz;
 217         struct boot_params *params;
 218         unsigned long bootparam_load_addr, kernel_load_addr, initrd_load_addr;
 219         unsigned long purgatory_load_addr;
 220         unsigned long kernel_bufsz, kernel_memsz, kernel_align;
 221         char *kernel_buf;
 222         struct bzimage64_data *ldata;
 223         struct kexec_entry64_regs regs64;
 224         void *stack;
 225         unsigned int setup_hdr_offset = offsetof(struct boot_params, hdr);
 226
 227         header = (struct setup_header *)(kernel + setup_hdr_offset);
 228         setup_sects = header->setup_sects;
 229         if (setup_sects == 0)
 230                 setup_sects = 4;
 231
 232         kern16_size = (setup_sects + 1) * 512;
 233         if (kernel_len < kern16_size) {
 234                 pr_err("bzImage truncated\n");
 235                 return ERR_PTR(-ENOEXEC);
 236         }
 237
 238         if (cmdline_len > header->cmdline_size) {
 239                 pr_err("Kernel command line too long\n");
 240                 return ERR_PTR(-EINVAL);
 241         }
 242
 243         /*
 244          * Load purgatory. For 64bit entry point, purgatory  code can be
 245          * anywhere.
 246          */
 247         ret = kexec_load_purgatory(image, MIN_PURGATORY_ADDR, ULONG_MAX, 1,
 248                                    &purgatory_load_addr);
 249         if (ret) {
 250                 pr_err("Loading purgatory failed\n");
 251                 return ERR_PTR(ret);
 252         }
 253
 254         pr_debug("Loaded purgatory at 0x%lx\n", purgatory_load_addr);
 255
 256         /* Load Bootparams and cmdline */
 257         params_cmdline_sz = sizeof(struct boot_params) + cmdline_len;
 258         params = kzalloc(params_cmdline_sz, GFP_KERNEL);
 259         if (!params)
 260                 return ERR_PTR(-ENOMEM);
 261
 262         /* Copy setup header onto bootparams. Documentation/x86/boot.txt */
 263         setup_header_size = 0x0202 + kernel[0x0201] - setup_hdr_offset;
 264
 265         /* Is there a limit on setup header size? */
 266         memcpy(&params->hdr, (kernel + setup_hdr_offset), setup_header_size);
 267
 268         ret = kexec_add_buffer(image, (char *)params, params_cmdline_sz,
 269                                params_cmdline_sz, 16, MIN_BOOTPARAM_ADDR,
 270                                ULONG_MAX, 1, &bootparam_load_addr);
 271         if (ret)
 272                 goto out_free_params;
 273         pr_debug("Loaded boot_param and command line at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
 274                  bootparam_load_addr, params_cmdline_sz, params_cmdline_sz);
 275
 276         /* Load kernel */
 277         kernel_buf = kernel + kern16_size;
 278         kernel_bufsz =  kernel_len - kern16_size;
 279         kernel_memsz = PAGE_ALIGN(header->init_size);
 280         kernel_align = header->kernel_alignment;
 281
 282         ret = kexec_add_buffer(image, kernel_buf,
 283                                kernel_bufsz, kernel_memsz, kernel_align,
 284                                MIN_KERNEL_LOAD_ADDR, ULONG_MAX, 1,
 285                                &kernel_load_addr);
 286         if (ret)
 287                 goto out_free_params;
 288
 289         pr_debug("Loaded 64bit kernel at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
 290                  kernel_load_addr, kernel_memsz, kernel_memsz);
 291
 292         /* Load initrd high */
 293         if (initrd) {
 294                 ret = kexec_add_buffer(image, initrd, initrd_len, initrd_len,
 295                                        PAGE_SIZE, MIN_INITRD_LOAD_ADDR,
 296                                        ULONG_MAX, 1, &initrd_load_addr);
 297                 if (ret)
 298                         goto out_free_params;
 299
 300                 pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
 301                                 initrd_load_addr, initrd_len, initrd_len);
 302
 303                 setup_initrd(params, initrd_load_addr, initrd_len);
 304         }
 305
 306         setup_cmdline(params, bootparam_load_addr, sizeof(struct boot_params),
 307                       cmdline, cmdline_len);
 308
 309         /* bootloader info. Do we need a separate ID for kexec kernel loader? */
 310         params->hdr.type_of_loader = 0x0D << 4;
 311         params->hdr.loadflags = 0;
 312
 313         /* Setup purgatory regs for entry */
 314         ret = kexec_purgatory_get_set_symbol(image, "entry64_regs", &regs64,
 315                                              sizeof(regs64), 1);
 316         if (ret)
 317                 goto out_free_params;
 318
 319         regs64.rbx = 0; /* Bootstrap Processor */
 320         regs64.rsi = bootparam_load_addr;
 321         regs64.rip = kernel_load_addr + 0x200;
 322         stack = kexec_purgatory_get_symbol_addr(image, "stack_end");
 323         if (IS_ERR(stack)) {
 324                 pr_err("Could not find address of symbol stack_end\n");
 325                 ret = -EINVAL;
 326                 goto out_free_params;
 327         }
 328
 329         regs64.rsp = (unsigned long)stack;
 330         ret = kexec_purgatory_get_set_symbol(image, "entry64_regs", &regs64,
 331                                              sizeof(regs64), 0);
 332         if (ret)
 333                 goto out_free_params;
 334
 335         setup_boot_parameters(params);
 336
 337         /* Allocate loader specific data */
 338         ldata = kzalloc(sizeof(struct bzimage64_data), GFP_KERNEL);
 339         if (!ldata) {
 340                 ret = -ENOMEM;
 341                 goto out_free_params;
 342         }
 343
 344         /*
 345          * Store pointer to params so that it could be freed after loading
 346          * params segment has been loaded and contents have been copied
 347          * somewhere else.
 348          */
 349         ldata->bootparams_buf = params;
 350         return ldata;
 351
 352 out_free_params:
 353         kfree(params);
 354         return ERR_PTR(ret);
 355 }
 356
 357 /* This cleanup function is called after various segments have been loaded */
 358 int bzImage64_cleanup(void *loader_data)
 359 {
 360         struct bzimage64_data *ldata = loader_data;
 361
 362         if (!ldata)
 363                 return 0;
 364
 365         kfree(ldata->bootparams_buf);
 366         ldata->bootparams_buf = NULL;
 367
 368         return 0;
 369 }
 370
 371 struct kexec_file_ops kexec_bzImage64_ops = {
 372         .probe = bzImage64_probe,
 373         .load = bzImage64_load,
 374         .cleanup = bzImage64_cleanup,
 375 };