src/arch/i386/image/bzimage.c

   1 /*
   2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 /**
  20  * @file
  21  *
  22  * Linux bzImage image format
  23  *
  24  */
  25
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <realmode.h>
  32 #include <bzimage.h>
  33 #include <gpxe/uaccess.h>
  34 #include <gpxe/image.h>
  35 #include <gpxe/segment.h>
  36 #include <gpxe/init.h>
  37 #include <gpxe/initrd.h>
  38 #include <gpxe/cpio.h>
  39 #include <gpxe/features.h>
  40
  41 FEATURE ( FEATURE_IMAGE, "bzImage", DHCP_EB_FEATURE_BZIMAGE, 1 );
  42
  43 struct image_type bzimage_image_type __image_type ( PROBE_NORMAL );
  44
  45 /**
  46  * bzImage load context
  47  */
  48 struct bzimage_load_context {
  49         /** Real-mode kernel portion load segment address */
  50         unsigned int rm_kernel_seg;
  51         /** Real-mode kernel portion load address */
  52         userptr_t rm_kernel;
  53         /** Real-mode kernel portion file size */
  54         size_t rm_filesz;
  55         /** Real-mode heap top (offset from rm_kernel) */
  56         size_t rm_heap;
  57         /** Command line (offset from rm_kernel) */
  58         size_t rm_cmdline;
  59         /** Real-mode kernel portion total memory size */
  60         size_t rm_memsz;
  61         /** Non-real-mode kernel portion load address */
  62         userptr_t pm_kernel;
  63         /** Non-real-mode kernel portion file and memory size */
  64         size_t pm_sz;
  65 };
  66
  67 /**
  68  * bzImage execution context
  69  */
  70 struct bzimage_exec_context {
  71         /** Real-mode kernel portion load segment address */
  72         unsigned int rm_kernel_seg;
  73         /** Real-mode kernel portion load address */
  74         userptr_t rm_kernel;
  75         /** Real-mode heap top (offset from rm_kernel) */
  76         size_t rm_heap;
  77         /** Command line (offset from rm_kernel) */
  78         size_t rm_cmdline;
  79         /** Video mode */
  80         unsigned int vid_mode;
  81         /** Memory limit */
  82         uint64_t mem_limit;
  83         /** Initrd address */
  84         physaddr_t ramdisk_image;
  85         /** Initrd size */
  86         physaddr_t ramdisk_size;
  87 };
  88
  89 /**
  90  * Parse kernel command line for bootloader parameters
  91  *
  92  * @v image             bzImage file
  93  * @v exec_ctx          Execution context
  94  * @v cmdline           Kernel command line
  95  * @ret rc              Return status code
  96  */
  97 static int bzimage_parse_cmdline ( struct image *image,
  98                                    struct bzimage_exec_context *exec_ctx,
  99                                    const char *cmdline ) {
 100         char *vga;
 101         char *mem;
 102
 103         /* Look for "vga=" */
 104         if ( ( vga = strstr ( cmdline, "vga=" ) ) ) {
 105                 vga += 4;
 106                 if ( strcmp ( vga, "normal" ) == 0 ) {
 107                         exec_ctx->vid_mode = BZI_VID_MODE_NORMAL;
 108                 } else if ( strcmp ( vga, "ext" ) == 0 ) {
 109                         exec_ctx->vid_mode = BZI_VID_MODE_EXT;
 110                 } else if ( strcmp ( vga, "ask" ) == 0 ) {
 111                         exec_ctx->vid_mode = BZI_VID_MODE_ASK;
 112                 } else {
 113                         exec_ctx->vid_mode = strtoul ( vga, &vga, 0 );
 114                         if ( *vga && ( *vga != ' ' ) ) {
 115                                 DBGC ( image, "bzImage %p strange \"vga=\""
 116                                        "terminator '%c'\n", image, *vga );
 117                         }
 118                 }
 119         }
 120
 121         /* Look for "mem=" */
 122         if ( ( mem = strstr ( cmdline, "mem=" ) ) ) {
 123                 mem += 4;
 124                 exec_ctx->mem_limit = strtoul ( mem, &mem, 0 );
 125                 switch ( *mem ) {
 126                 case 'G':
 127                 case 'g':
 128                         exec_ctx->mem_limit <<= 10;
 129                 case 'M':
 130                 case 'm':
 131                         exec_ctx->mem_limit <<= 10;
 132                 case 'K':
 133                 case 'k':
 134                         exec_ctx->mem_limit <<= 10;
 135                         break;
 136                 case '\0':
 137                 case ' ':
 138                         break;
 139                 default:
 140                         DBGC ( image, "bzImage %p strange \"mem=\" "
 141                                "terminator '%c'\n", image, *mem );
 142                         break;
 143                 }
 144                 exec_ctx->mem_limit -= 1;
 145         }
 146
 147         return 0;
 148 }
 149
 150 /**
 151  * Set command line
 152  *
 153  * @v image             bzImage image
 154  * @v exec_ctx          Execution context
 155  * @v cmdline           Kernel command line
 156  * @ret rc              Return status code
 157  */
 158 static int bzimage_set_cmdline ( struct image *image,
 159                                  struct bzimage_exec_context *exec_ctx,
 160                                  const char *cmdline ) {
 161         size_t cmdline_len;
 162
 163         /* Copy command line down to real-mode portion */
 164         cmdline_len = ( strlen ( cmdline ) + 1 );
 165         if ( cmdline_len > BZI_CMDLINE_SIZE )
 166                 cmdline_len = BZI_CMDLINE_SIZE;
 167         copy_to_user ( exec_ctx->rm_kernel, exec_ctx->rm_cmdline,
 168                        cmdline, cmdline_len );
 169         DBGC ( image, "bzImage %p command line \"%s\"\n", image, cmdline );
 170
 171         return 0;
 172 }
 173
 174 /**
 175  * Load initrd
 176  *
 177  * @v image             bzImage image
 178  * @v initrd            initrd image
 179  * @v address           Address at which to load, or UNULL
 180  * @ret len             Length of loaded image, rounded up to 4 bytes
 181  */
 182 static size_t bzimage_load_initrd ( struct image *image,
 183                                     struct image *initrd,
 184                                     userptr_t address ) {
 185         char *filename = initrd->cmdline;
 186         struct cpio_header cpio;
 187         size_t offset = 0;
 188
 189         /* Ignore images which aren't initrds */
 190         if ( initrd->type != &initrd_image_type )
 191                 return 0;
 192
 193         /* Create cpio header before non-prebuilt images */
 194         if ( filename && filename[0] ) {
 195                 size_t name_len = ( strlen ( filename ) + 1 );
 196
 197                 DBGC ( image, "bzImage %p inserting initrd %p as %s\n",
 198                        image, initrd, filename );
 199                 memset ( &cpio, '0', sizeof ( cpio ) );
 200                 memcpy ( cpio.c_magic, CPIO_MAGIC, sizeof ( cpio.c_magic ) );
 201                 cpio_set_field ( cpio.c_mode, 0100644 );
 202                 cpio_set_field ( cpio.c_nlink, 1 );
 203                 cpio_set_field ( cpio.c_filesize, initrd->len );
 204                 cpio_set_field ( cpio.c_namesize, name_len );
 205                 if ( address ) {
 206                         copy_to_user ( address, offset, &cpio,
 207                                        sizeof ( cpio ) );
 208                 }
 209                 offset += sizeof ( cpio );
 210                 if ( address ) {
 211                         copy_to_user ( address, offset, filename,
 212                                        name_len );
 213                 }
 214                 offset += name_len;
 215                 offset = ( ( offset + 0x03 ) & ~0x03 );
 216         }
 217
 218         /* Copy in initrd image body */
 219         if ( address ) {
 220                 DBGC ( image, "bzImage %p has initrd %p at [%lx,%lx)\n",
 221                        image, initrd, address, ( address + offset ) );
 222                 memcpy_user ( address, offset, initrd->data, 0,
 223                               initrd->len );
 224         }
 225         offset += initrd->len;
 226
 227         offset = ( ( offset + 0x03 ) & ~0x03 );
 228         return offset;
 229 }
 230
 231 /**
 232  * Load initrds, if any
 233  *
 234  * @v image             bzImage image
 235  * @v exec_ctx          Execution context
 236  * @ret rc              Return status code
 237  */
 238 static int bzimage_load_initrds ( struct image *image,
 239                                   struct bzimage_exec_context *exec_ctx ) {
 240         struct image *initrd;
 241         size_t total_len = 0;
 242         physaddr_t address;
 243         int rc;
 244
 245         /* Add up length of all initrd images */
 246         for_each_image ( initrd ) {
 247                 total_len += bzimage_load_initrd ( image, initrd, UNULL );
 248         }
 249
 250         /* Give up if no initrd images found */
 251         if ( ! total_len )
 252                 return 0;
 253
 254         /* Find a suitable start address.  Try 1MB boundaries,
 255          * starting from the downloaded kernel image itself and
 256          * working downwards until we hit an available region.
 257          */
 258         for ( address = ( user_to_phys ( image->data, 0 ) & ~0xfffff ) ; ;
 259               address -= 0x100000 ) {
 260                 /* Check that we're not going to overwrite the
 261                  * kernel itself.  This check isn't totally
 262                  * accurate, but errs on the side of caution.
 263                  */
 264                 if ( address <= ( BZI_LOAD_HIGH_ADDR + image->len ) ) {
 265                         DBGC ( image, "bzImage %p could not find a location "
 266                                "for initrd\n", image );
 267                         return -ENOBUFS;
 268                 }
 269                 /* Check that we are within the kernel's range */
 270                 if ( ( address + total_len - 1 ) > exec_ctx->mem_limit )
 271                         continue;
 272                 /* Prepare and verify segment */
 273                 if ( ( rc = prep_segment ( phys_to_user ( address ), 0,
 274                                            total_len ) ) != 0 )
 275                         continue;
 276                 /* Use this address */
 277                 break;
 278         }
 279
 280         /* Record initrd location */
 281         exec_ctx->ramdisk_image = address;
 282         exec_ctx->ramdisk_size = total_len;
 283
 284         /* Construct initrd */
 285         DBGC ( image, "bzImage %p constructing initrd at [%lx,%lx)\n",
 286                image, address, ( address + total_len ) );
 287         for_each_image ( initrd ) {
 288                 address += bzimage_load_initrd ( image, initrd,
 289                                                  phys_to_user ( address ) );
 290         }
 291
 292         return 0;
 293 }
 294
 295 /**
 296  * Execute bzImage image
 297  *
 298  * @v image             bzImage image
 299  * @ret rc              Return status code
 300  */
 301 static int bzimage_exec ( struct image *image ) {
 302         struct bzimage_exec_context exec_ctx;
 303         struct bzimage_header bzhdr;
 304         const char *cmdline = ( image->cmdline ? image->cmdline : "" );
 305         int rc;
 306
 307         /* Initialise context */
 308         memset ( &exec_ctx, 0, sizeof ( exec_ctx ) );
 309
 310         /* Retrieve kernel header */
 311         exec_ctx.rm_kernel_seg = image->priv.ul;
 312         exec_ctx.rm_kernel = real_to_user ( exec_ctx.rm_kernel_seg, 0 );
 313         copy_from_user ( &bzhdr, exec_ctx.rm_kernel, BZI_HDR_OFFSET,
 314                          sizeof ( bzhdr ) );
 315         exec_ctx.rm_cmdline = exec_ctx.rm_heap =
 316                 ( bzhdr.heap_end_ptr + 0x200 );
 317         exec_ctx.vid_mode = bzhdr.vid_mode;
 318         if ( bzhdr.version >= 0x0203 ) {
 319                 exec_ctx.mem_limit = bzhdr.initrd_addr_max;
 320         } else {
 321                 exec_ctx.mem_limit = BZI_INITRD_MAX;
 322         }
 323
 324         /* Parse command line for bootloader parameters */
 325         if ( ( rc = bzimage_parse_cmdline ( image, &exec_ctx, cmdline ) ) != 0)
 326                 return rc;
 327
 328         /* Store command line */
 329         if ( ( rc = bzimage_set_cmdline ( image, &exec_ctx, cmdline ) ) != 0 )
 330                 return rc;
 331
 332         /* Load any initrds */
 333         if ( ( rc = bzimage_load_initrds ( image, &exec_ctx ) ) != 0 )
 334                 return rc;
 335
 336         /* Update and store kernel header */
 337         bzhdr.vid_mode = exec_ctx.vid_mode;
 338         bzhdr.ramdisk_image = exec_ctx.ramdisk_image;
 339         bzhdr.ramdisk_size = exec_ctx.ramdisk_size;
 340         copy_to_user ( exec_ctx.rm_kernel, BZI_HDR_OFFSET, &bzhdr,
 341                        sizeof ( bzhdr ) );
 342
 343         /* Prepare for exiting */
 344         shutdown();
 345
 346         /* Jump to the kernel */
 347         __asm__ __volatile__ ( REAL_CODE ( "movw %w0, %%ds\n\t"
 348                                            "movw %w0, %%es\n\t"
 349                                            "movw %w0, %%fs\n\t"
 350                                            "movw %w0, %%gs\n\t"
 351                                            "movw %w0, %%ss\n\t"
 352                                            "movw %w1, %%sp\n\t"
 353                                            "pushw %w2\n\t"
 354                                            "pushw $0\n\t"
 355                                            "lret\n\t" )
 356                                : : "r" ( exec_ctx.rm_kernel_seg ),
 357                                    "r" ( exec_ctx.rm_heap ),
 358                                    "r" ( exec_ctx.rm_kernel_seg + 0x20 ) );
 359
 360         /* There is no way for the image to return, since we provide
 361          * no return address.
 362          */
 363         assert ( 0 );
 364
 365         return -ECANCELED; /* -EIMPOSSIBLE */
 366 }
 367
 368 /**
 369  * Load and parse bzImage header
 370  *
 371  * @v image             bzImage file
 372  * @v load_ctx          Load context
 373  * @v bzhdr             Buffer for bzImage header
 374  * @ret rc              Return status code
 375  */
 376 static int bzimage_load_header ( struct image *image,
 377                                  struct bzimage_load_context *load_ctx,
 378                                  struct bzimage_header *bzhdr ) {
 379
 380         /* Sanity check */
 381         if ( image->len < ( BZI_HDR_OFFSET + sizeof ( *bzhdr ) ) ) {
 382                 DBGC ( image, "bzImage %p too short for kernel header\n",
 383                        image );
 384                 return -ENOEXEC;
 385         }
 386
 387         /* Read and verify header */
 388         copy_from_user ( bzhdr, image->data, BZI_HDR_OFFSET,
 389                          sizeof ( *bzhdr ) );
 390         if ( bzhdr->header != BZI_SIGNATURE ) {
 391                 DBGC ( image, "bzImage %p bad signature %08lx\n",
 392                        image, bzhdr->header );
 393                 return -ENOEXEC;
 394         }
 395
 396         /* We don't support ancient kernels */
 397         if ( bzhdr->version < 0x0200 ) {
 398                 DBGC ( image, "bzImage %p version %04x not supported\n",
 399                        image, bzhdr->version );
 400                 return -ENOTSUP;
 401         }
 402
 403         /* Calculate load address and size of real-mode portion */
 404         load_ctx->rm_kernel_seg = 0x1000; /* place RM kernel at 1000:0000 */
 405         load_ctx->rm_kernel = real_to_user ( load_ctx->rm_kernel_seg, 0 );
 406         load_ctx->rm_filesz = load_ctx->rm_memsz =
 407                 ( ( bzhdr->setup_sects ? bzhdr->setup_sects : 4 ) + 1 ) << 9;
 408         if ( load_ctx->rm_filesz > image->len ) {
 409                 DBGC ( image, "bzImage %p too short for %zd byte of setup\n",
 410                        image, load_ctx->rm_filesz );
 411                 return -ENOEXEC;
 412         }
 413
 414         /* Calculate load address and size of non-real-mode portion */
 415         load_ctx->pm_kernel = ( ( bzhdr->loadflags & BZI_LOAD_HIGH ) ?
 416                                 phys_to_user ( BZI_LOAD_HIGH_ADDR ) :
 417                                 phys_to_user ( BZI_LOAD_LOW_ADDR ) );
 418         load_ctx->pm_sz = ( image->len - load_ctx->rm_filesz );
 419
 420         DBGC ( image, "bzImage %p version %04x RM %#zx bytes PM %#zx bytes\n",
 421                image, bzhdr->version, load_ctx->rm_filesz, load_ctx->pm_sz );
 422         return 0;
 423 }
 424
 425 /**
 426  * Load real-mode portion of bzImage
 427  *
 428  * @v image             bzImage file
 429  * @v load_ctx          Load context
 430  * @ret rc              Return status code
 431  */
 432 static int bzimage_load_real ( struct image *image,
 433                                struct bzimage_load_context *load_ctx ) {
 434         int rc;
 435
 436         /* Allow space for the stack and heap */
 437         load_ctx->rm_memsz += BZI_STACK_SIZE;
 438         load_ctx->rm_heap = load_ctx->rm_memsz;
 439
 440         /* Allow space for the command line */
 441         load_ctx->rm_cmdline = load_ctx->rm_memsz;
 442         load_ctx->rm_memsz += BZI_CMDLINE_SIZE;
 443
 444         /* Prepare, verify, and load the real-mode segment */
 445         if ( ( rc = prep_segment ( load_ctx->rm_kernel, load_ctx->rm_filesz,
 446                                    load_ctx->rm_memsz ) ) != 0 ) {
 447                 DBGC ( image, "bzImage %p could not prepare RM segment: %s\n",
 448                        image, strerror ( rc ) );
 449                 return rc;
 450         }
 451         memcpy_user ( load_ctx->rm_kernel, 0, image->data, 0,
 452                       load_ctx->rm_filesz );
 453
 454         return 0;
 455 }
 456
 457 /**
 458  * Load non-real-mode portion of bzImage
 459  *
 460  * @v image             bzImage file
 461  * @v load_ctx          Load context
 462  * @ret rc              Return status code
 463  */
 464 static int bzimage_load_non_real ( struct image *image,
 465                                    struct bzimage_load_context *load_ctx ) {
 466         int rc;
 467
 468         /* Prepare, verify and load the non-real-mode segment */
 469         if ( ( rc = prep_segment ( load_ctx->pm_kernel, load_ctx->pm_sz,
 470                                    load_ctx->pm_sz ) ) != 0 ) {
 471                 DBGC ( image, "bzImage %p could not prepare PM segment: %s\n",
 472                        image, strerror ( rc ) );
 473                 return rc;
 474         }
 475         memcpy_user ( load_ctx->pm_kernel, 0, image->data, load_ctx->rm_filesz,
 476                       load_ctx->pm_sz );
 477
 478         return 0;
 479 }
 480
 481 /**
 482  * Update and store bzImage header
 483  *
 484  * @v image             bzImage file
 485  * @v load_ctx          Load context
 486  * @v bzhdr             Original bzImage header
 487  * @ret rc              Return status code
 488  */
 489 static int bzimage_write_header ( struct image *image __unused,
 490                                   struct bzimage_load_context *load_ctx,
 491                                   struct bzimage_header *bzhdr ) {
 492         struct bzimage_cmdline cmdline;
 493
 494         /* Update the header and copy it into the loaded kernel */
 495         bzhdr->type_of_loader = BZI_LOADER_TYPE_GPXE;
 496         if ( bzhdr->version >= 0x0201 ) {
 497                 bzhdr->heap_end_ptr = ( load_ctx->rm_heap - 0x200 );
 498                 bzhdr->loadflags |= BZI_CAN_USE_HEAP;
 499         }
 500         if ( bzhdr->version >= 0x0202 ) {
 501                 bzhdr->cmd_line_ptr = user_to_phys ( load_ctx->rm_kernel,
 502                                                      load_ctx->rm_cmdline );
 503         } else {
 504                 cmdline.magic = BZI_CMDLINE_MAGIC;
 505                 cmdline.offset = load_ctx->rm_cmdline;
 506                 copy_to_user ( load_ctx->rm_kernel, BZI_CMDLINE_OFFSET,
 507                                &cmdline, sizeof ( cmdline ) );
 508                 bzhdr->setup_move_size = load_ctx->rm_memsz;
 509         }
 510         copy_to_user ( load_ctx->rm_kernel, BZI_HDR_OFFSET,
 511                        bzhdr, sizeof ( *bzhdr ) );
 512
 513         return 0;
 514 }
 515
 516 /**
 517  * Load bzImage image into memory
 518  *
 519  * @v image             bzImage file
 520  * @ret rc              Return status code
 521  */
 522 int bzimage_load ( struct image *image ) {
 523         struct bzimage_load_context load_ctx;
 524         struct bzimage_header bzhdr;
 525         int rc;
 526
 527         /* Initialise context */
 528         memset ( &load_ctx, 0, sizeof ( load_ctx ) );
 529
 530         /* Load and verify header */
 531         if ( ( rc = bzimage_load_header ( image, &load_ctx, &bzhdr ) ) != 0 )
 532                 return rc;
 533
 534         /* This is a bzImage image, valid or otherwise */
 535         if ( ! image->type )
 536                 image->type = &bzimage_image_type;
 537
 538         /* Load real-mode portion */
 539         if ( ( rc = bzimage_load_real ( image, &load_ctx ) ) != 0 )
 540                 return rc;
 541
 542         /* Load non-real-mode portion */
 543         if ( ( rc = bzimage_load_non_real ( image, &load_ctx ) ) != 0 )
 544                 return rc;
 545
 546         /* Update and write out header */
 547         if ( ( rc = bzimage_write_header ( image, &load_ctx, &bzhdr ) ) != 0 )
 548                 return rc;
 549
 550         /* Record real-mode segment in image private data field */
 551         image->priv.ul = load_ctx.rm_kernel_seg;
 552
 553         return 0;
 554 }
 555
 556 /** Linux bzImage image type */
 557 struct image_type bzimage_image_type __image_type ( PROBE_NORMAL ) = {
 558         .name = "bzImage",
 559         .load = bzimage_load,
 560         .exec = bzimage_exec,
 561 };