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