src/arch/i386/image/multiboot.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  * Multiboot image format
  23  *
  24  */
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <assert.h>
  29 #include <realmode.h>
  30 #include <multiboot.h>
  31 #include <gpxe/uaccess.h>
  32 #include <gpxe/image.h>
  33 #include <gpxe/segment.h>
  34 #include <gpxe/memmap.h>
  35 #include <gpxe/elf.h>
  36 #include <gpxe/init.h>
  37 #include <gpxe/features.h>
  38
  39 FEATURE ( FEATURE_IMAGE, "Multiboot", DHCP_EB_FEATURE_MULTIBOOT, 1 );
  40
  41 struct image_type multiboot_image_type __image_type ( PROBE_MULTIBOOT );
  42
  43 /**
  44  * Maximum number of modules we will allow for
  45  *
  46  * If this has bitten you: sorry.  I did have a perfect scheme with a
  47  * dynamically allocated list of modules on the protected-mode stack,
  48  * but it was incompatible with some broken OSes that can only access
  49  * low memory at boot time (even though we kindly set up 4GB flat
  50  * physical addressing as per the multiboot specification.
  51  *
  52  */
  53 #define MAX_MODULES 8
  54
  55 /**
  56  * Maximum combined length of command lines
  57  *
  58  * Again; sorry.  Some broken OSes zero out any non-base memory that
  59  * isn't part of the loaded module set, so we can't just use
  60  * virt_to_phys(cmdline) to point to the command lines, even though
  61  * this would comply with the Multiboot spec.
  62  */
  63 #define MB_MAX_CMDLINE 512
  64
  65 /** Multiboot flags that we support */
  66 #define MB_SUPPORTED_FLAGS ( MB_FLAG_PGALIGN | MB_FLAG_MEMMAP | \
  67                              MB_FLAG_VIDMODE | MB_FLAG_RAW )
  68
  69 /** Compulsory feature multiboot flags */
  70 #define MB_COMPULSORY_FLAGS 0x0000ffff
  71
  72 /** Optional feature multiboot flags */
  73 #define MB_OPTIONAL_FLAGS 0xffff0000
  74
  75 /**
  76  * Multiboot flags that we don't support
  77  *
  78  * We only care about the compulsory feature flags (bits 0-15); we are
  79  * allowed to ignore the optional feature flags.
  80  */
  81 #define MB_UNSUPPORTED_FLAGS ( MB_COMPULSORY_FLAGS & ~MB_SUPPORTED_FLAGS )
  82
  83 /** A multiboot header descriptor */
  84 struct multiboot_header_info {
  85         /** The actual multiboot header */
  86         struct multiboot_header mb;
  87         /** Offset of header within the multiboot image */
  88         size_t offset;
  89 };
  90
  91 /** Multiboot module command lines */
  92 static char __bss16_array ( mb_cmdlines, [MB_MAX_CMDLINE] );
  93 #define mb_cmdlines __use_data16 ( mb_cmdlines )
  94
  95 /** Offset within module command lines */
  96 static unsigned int mb_cmdline_offset;
  97
  98 /**
  99  * Build multiboot memory map
 100  *
 101  * @v image             Multiboot image
 102  * @v mbinfo            Multiboot information structure
 103  * @v mbmemmap          Multiboot memory map
 104  * @v limit             Maxmimum number of memory map entries
 105  */
 106 static void multiboot_build_memmap ( struct image *image,
 107                                      struct multiboot_info *mbinfo,
 108                                      struct multiboot_memory_map *mbmemmap,
 109                                      unsigned int limit ) {
 110         struct memory_map memmap;
 111         unsigned int i;
 112
 113         /* Get memory map */
 114         get_memmap ( &memmap );
 115
 116         /* Translate into multiboot format */
 117         memset ( mbmemmap, 0, sizeof ( *mbmemmap ) );
 118         for ( i = 0 ; i < memmap.count ; i++ ) {
 119                 if ( i >= limit ) {
 120                         DBGC ( image, "MULTIBOOT %p limit of %d memmap "
 121                                "entries reached\n", image, limit );
 122                         break;
 123                 }
 124                 mbmemmap[i].size = ( sizeof ( mbmemmap[i] ) -
 125                                      sizeof ( mbmemmap[i].size ) );
 126                 mbmemmap[i].base_addr = memmap.regions[i].start;
 127                 mbmemmap[i].length = ( memmap.regions[i].end -
 128                                        memmap.regions[i].start );
 129                 mbmemmap[i].type = MBMEM_RAM;
 130                 mbinfo->mmap_length += sizeof ( mbmemmap[i] );
 131                 if ( memmap.regions[i].start == 0 )
 132                         mbinfo->mem_lower = ( memmap.regions[i].end / 1024 );
 133                 if ( memmap.regions[i].start == 0x100000 )
 134                         mbinfo->mem_upper = ( ( memmap.regions[i].end -
 135                                                 0x100000 ) / 1024 );
 136         }
 137 }
 138
 139 /**
 140  * Add command line in base memory
 141  *
 142  * @v cmdline           Command line
 143  * @ret physaddr        Physical address of command line
 144  */
 145 physaddr_t multiboot_add_cmdline ( const char *cmdline ) {
 146         char *mb_cmdline;
 147
 148         if ( ! cmdline )
 149                 cmdline = "";
 150
 151         /* Copy command line to base memory buffer */
 152         mb_cmdline = ( mb_cmdlines + mb_cmdline_offset );
 153         mb_cmdline_offset +=
 154                 ( snprintf ( mb_cmdline,
 155                              ( sizeof ( mb_cmdlines ) - mb_cmdline_offset ),
 156                              "%s", cmdline ) + 1 );
 157
 158         /* Truncate to terminating NUL in buffer if necessary */
 159         if ( mb_cmdline_offset > sizeof ( mb_cmdlines ) )
 160                 mb_cmdline_offset = ( sizeof ( mb_cmdlines ) - 1 );
 161
 162         return virt_to_phys ( mb_cmdline );
 163 }
 164
 165 /**
 166  * Build multiboot module list
 167  *
 168  * @v image             Multiboot image
 169  * @v modules           Module list to fill, or NULL
 170  * @ret count           Number of modules
 171  */
 172 static unsigned int
 173 multiboot_build_module_list ( struct image *image,
 174                               struct multiboot_module *modules,
 175                               unsigned int limit ) {
 176         struct image *module_image;
 177         struct multiboot_module *module;
 178         unsigned int count = 0;
 179         unsigned int insert;
 180         physaddr_t start;
 181         physaddr_t end;
 182         unsigned int i;
 183
 184         /* Add each image as a multiboot module */
 185         for_each_image ( module_image ) {
 186
 187                 if ( count >= limit ) {
 188                         DBGC ( image, "MULTIBOOT %p limit of %d modules "
 189                                "reached\n", image, limit );
 190                         break;
 191                 }
 192
 193                 /* Do not include kernel image itself as a module */
 194                 if ( module_image == image )
 195                         continue;
 196
 197                 /* At least some OSes expect the multiboot modules to
 198                  * be in ascending order, so we have to support it.
 199                  */
 200                 start = user_to_phys ( module_image->data, 0 );
 201                 end = user_to_phys ( module_image->data, module_image->len );
 202                 for ( insert = 0 ; insert < count ; insert++ ) {
 203                         if ( start < modules[insert].mod_start )
 204                                 break;
 205                 }
 206                 module = &modules[insert];
 207                 memmove ( ( module + 1 ), module,
 208                           ( ( count - insert ) * sizeof ( *module ) ) );
 209                 module->mod_start = start;
 210                 module->mod_end = end;
 211                 module->string =
 212                         multiboot_add_cmdline ( module_image->cmdline );
 213                 module->reserved = 0;
 214
 215                 /* We promise to page-align modules */
 216                 assert ( ( module->mod_start & 0xfff ) == 0 );
 217
 218                 count++;
 219         }
 220
 221         /* Dump module configuration */
 222         for ( i = 0 ; i < count ; i++ ) {
 223                 DBGC ( image, "MULTIBOOT %p module %d is [%lx,%lx)\n",
 224                        image, i, modules[i].mod_start,
 225                        modules[i].mod_end );
 226         }
 227
 228         return count;
 229 }
 230
 231 /**
 232  * The multiboot information structure
 233  *
 234  * Kept in base memory because some OSes won't find it elsewhere,
 235  * along with the other structures belonging to the Multiboot
 236  * information table.
 237  */
 238 static struct multiboot_info __bss16 ( mbinfo );
 239 #define mbinfo __use_data16 ( mbinfo )
 240
 241 /** The multiboot bootloader name */
 242 static char __data16_array ( mb_bootloader_name, [] ) = "gPXE " VERSION;
 243 #define mb_bootloader_name __use_data16 ( mb_bootloader_name )
 244
 245 /** The multiboot memory map */
 246 static struct multiboot_memory_map
 247         __bss16_array ( mbmemmap, [MAX_MEMORY_REGIONS] );
 248 #define mbmemmap __use_data16 ( mbmemmap )
 249
 250 /** The multiboot module list */
 251 static struct multiboot_module __bss16_array ( mbmodules, [MAX_MODULES] );
 252 #define mbmodules __use_data16 ( mbmodules )
 253
 254 /**
 255  * Execute multiboot image
 256  *
 257  * @v image             Multiboot image
 258  * @ret rc              Return status code
 259  */
 260 static int multiboot_exec ( struct image *image ) {
 261         physaddr_t entry = image->priv.phys;
 262
 263         /* Populate multiboot information structure */
 264         memset ( &mbinfo, 0, sizeof ( mbinfo ) );
 265         mbinfo.flags = ( MBI_FLAG_LOADER | MBI_FLAG_MEM | MBI_FLAG_MMAP |
 266                          MBI_FLAG_CMDLINE | MBI_FLAG_MODS );
 267         multiboot_build_memmap ( image, &mbinfo, mbmemmap,
 268                                  ( sizeof(mbmemmap) / sizeof(mbmemmap[0]) ) );
 269         mb_cmdline_offset = 0;
 270         mbinfo.cmdline = multiboot_add_cmdline ( image->cmdline );
 271         mbinfo.mods_count = multiboot_build_module_list ( image, mbmodules,
 272                                 ( sizeof(mbmodules) / sizeof(mbmodules[0]) ) );
 273         mbinfo.mods_addr = virt_to_phys ( mbmodules );
 274         mbinfo.mmap_addr = virt_to_phys ( mbmemmap );
 275         mbinfo.boot_loader_name = virt_to_phys ( mb_bootloader_name );
 276
 277         /* Multiboot images may not return and have no callback
 278          * interface, so shut everything down prior to booting the OS.
 279          */
 280         shutdown();
 281
 282         /* Jump to OS with flat physical addressing */
 283         __asm__ __volatile__ ( PHYS_CODE ( "call *%%edi\n\t" )
 284                                : : "a" ( MULTIBOOT_BOOTLOADER_MAGIC ),
 285                                    "b" ( virt_to_phys ( &mbinfo ) ),
 286                                    "D" ( entry )
 287                                : "ecx", "edx", "esi", "ebp", "memory" );
 288
 289         DBGC ( image, "MULTIBOOT %p returned\n", image );
 290
 291         /* It isn't safe to continue after calling shutdown() */
 292         while ( 1 ) {}
 293
 294         return -ECANCELED;  /* -EIMPOSSIBLE, anyone? */
 295 }
 296
 297 /**
 298  * Find multiboot header
 299  *
 300  * @v image             Multiboot file
 301  * @v hdr               Multiboot header descriptor to fill in
 302  * @ret rc              Return status code
 303  */
 304 static int multiboot_find_header ( struct image *image,
 305                                    struct multiboot_header_info *hdr ) {
 306         uint32_t buf[64];
 307         size_t offset;
 308         unsigned int buf_idx;
 309         uint32_t checksum;
 310
 311         /* Scan through first 8kB of image file 256 bytes at a time.
 312          * (Use the buffering to avoid the overhead of a
 313          * copy_from_user() for every dword.)
 314          */
 315         for ( offset = 0 ; offset < 8192 ; offset += sizeof ( buf[0] ) ) {
 316                 /* Check for end of image */
 317                 if ( offset > image->len )
 318                         break;
 319                 /* Refill buffer if applicable */
 320                 buf_idx = ( ( offset % sizeof ( buf ) ) / sizeof ( buf[0] ) );
 321                 if ( buf_idx == 0 ) {
 322                         copy_from_user ( buf, image->data, offset,
 323                                          sizeof ( buf ) );
 324                 }
 325                 /* Check signature */
 326                 if ( buf[buf_idx] != MULTIBOOT_HEADER_MAGIC )
 327                         continue;
 328                 /* Copy header and verify checksum */
 329                 copy_from_user ( &hdr->mb, image->data, offset,
 330                                  sizeof ( hdr->mb ) );
 331                 checksum = ( hdr->mb.magic + hdr->mb.flags +
 332                              hdr->mb.checksum );
 333                 if ( checksum != 0 )
 334                         continue;
 335                 /* Record offset of multiboot header and return */
 336                 hdr->offset = offset;
 337                 return 0;
 338         }
 339
 340         /* No multiboot header found */
 341         return -ENOEXEC;
 342 }
 343
 344 /**
 345  * Load raw multiboot image into memory
 346  *
 347  * @v image             Multiboot file
 348  * @v hdr               Multiboot header descriptor
 349  * @ret rc              Return status code
 350  */
 351 static int multiboot_load_raw ( struct image *image,
 352                                 struct multiboot_header_info *hdr ) {
 353         size_t offset;
 354         size_t filesz;
 355         size_t memsz;
 356         userptr_t buffer;
 357         int rc;
 358
 359         /* Verify and prepare segment */
 360         offset = ( hdr->offset - hdr->mb.header_addr + hdr->mb.load_addr );
 361         filesz = ( hdr->mb.load_end_addr - hdr->mb.load_addr );
 362         memsz = ( hdr->mb.bss_end_addr - hdr->mb.load_addr );
 363         buffer = phys_to_user ( hdr->mb.load_addr );
 364         if ( ( rc = prep_segment ( buffer, filesz, memsz ) ) != 0 ) {
 365                 DBGC ( image, "MULTIBOOT %p could not prepare segment: %s\n",
 366                        image, strerror ( rc ) );
 367                 return rc;
 368         }
 369
 370         /* Copy image to segment */
 371         memcpy_user ( buffer, 0, image->data, offset, filesz );
 372
 373         /* Record execution entry point in image private data field */
 374         image->priv.phys = hdr->mb.entry_addr;
 375
 376         return 0;
 377 }
 378
 379 /**
 380  * Load ELF multiboot image into memory
 381  *
 382  * @v image             Multiboot file
 383  * @ret rc              Return status code
 384  */
 385 static int multiboot_load_elf ( struct image *image ) {
 386         int rc;
 387
 388         /* Load ELF image*/
 389         if ( ( rc = elf_load ( image ) ) != 0 ) {
 390                 DBGC ( image, "MULTIBOOT %p ELF image failed to load: %s\n",
 391                        image, strerror ( rc ) );
 392                 return rc;
 393         }
 394
 395         return 0;
 396 }
 397
 398 /**
 399  * Load multiboot image into memory
 400  *
 401  * @v image             Multiboot file
 402  * @ret rc              Return status code
 403  */
 404 static int multiboot_load ( struct image *image ) {
 405         struct multiboot_header_info hdr;
 406         int rc;
 407
 408         /* Locate multiboot header, if present */
 409         if ( ( rc = multiboot_find_header ( image, &hdr ) ) != 0 ) {
 410                 DBGC ( image, "MULTIBOOT %p has no multiboot header\n",
 411                        image );
 412                 return rc;
 413         }
 414         DBGC ( image, "MULTIBOOT %p found header with flags %08lx\n",
 415                image, hdr.mb.flags );
 416
 417         /* This is a multiboot image, valid or otherwise */
 418         if ( ! image->type )
 419                 image->type = &multiboot_image_type;
 420
 421         /* Abort if we detect flags that we cannot support */
 422         if ( hdr.mb.flags & MB_UNSUPPORTED_FLAGS ) {
 423                 DBGC ( image, "MULTIBOOT %p flags %08lx not supported\n",
 424                        image, ( hdr.mb.flags & MB_UNSUPPORTED_FLAGS ) );
 425                 return -ENOTSUP;
 426         }
 427
 428         /* Load the actual image */
 429         if ( hdr.mb.flags & MB_FLAG_RAW ) {
 430                 if ( ( rc = multiboot_load_raw ( image, &hdr ) ) != 0 )
 431                         return rc;
 432         } else {
 433                 if ( ( rc = multiboot_load_elf ( image ) ) != 0 )
 434                         return rc;
 435         }
 436
 437         return 0;
 438 }
 439
 440 /** Multiboot image type */
 441 struct image_type multiboot_image_type __image_type ( PROBE_MULTIBOOT ) = {
 442         .name = "Multiboot",
 443         .load = multiboot_load,
 444         .exec = multiboot_exec,
 445 };