loader/i386/multiboot.c

   1 /* multiboot.c - boot a multiboot OS image. */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2008,2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /*
  21  *  FIXME: The following features from the Multiboot specification still
  22  *         need to be implemented:
  23  *  - VBE support
  24  *  - symbol table
  25  *  - drives table
  26  *  - ROM configuration table
  27  *  - APM table
  28  */
  29
  30 #include <grub/loader.h>
  31 #include <grub/machine/loader.h>
  32 #include <grub/multiboot.h>
  33 #include <grub/machine/init.h>
  34 #include <grub/machine/memory.h>
  35 #include <grub/cpu/multiboot.h>
  36 #include <grub/elf.h>
  37 #include <grub/aout.h>
  38 #include <grub/file.h>
  39 #include <grub/err.h>
  40 #include <grub/dl.h>
  41 #include <grub/mm.h>
  42 #include <grub/misc.h>
  43 #include <grub/gzio.h>
  44 #include <grub/env.h>
  45 #ifdef GRUB_MACHINE_PCBIOS
  46 #include <grub/machine/biosnum.h>
  47 #include <grub/disk.h>
  48 #include <grub/device.h>
  49 #include <grub/partition.h>
  50 #endif
  51
  52 extern grub_dl_t my_mod;
  53 static struct grub_multiboot_info *mbi, *mbi_dest;
  54 static grub_addr_t entry;
  55
  56 static char *playground;
  57 static grub_size_t code_size;
  58
  59 static grub_err_t
  60 grub_multiboot_boot (void)
  61 {
  62   grub_multiboot_real_boot (entry, mbi_dest);
  63
  64   /* Not reached.  */
  65   return GRUB_ERR_NONE;
  66 }
  67
  68 static grub_err_t
  69 grub_multiboot_unload (void)
  70 {
  71   if (mbi)
  72     {
  73       unsigned int i;
  74       for (i = 0; i < mbi->mods_count; i++)
  75         {
  76           grub_free ((void *)
  77                      ((struct grub_mod_list *) mbi->mods_addr)[i].mod_start);
  78           grub_free ((void *)
  79                      ((struct grub_mod_list *) mbi->mods_addr)[i].cmdline);
  80         }
  81       grub_free ((void *) mbi->mods_addr);
  82       grub_free ((void *) mbi->cmdline);
  83       grub_free (mbi);
  84     }
  85
  86   mbi = 0;
  87   grub_dl_unref (my_mod);
  88
  89   return GRUB_ERR_NONE;
  90 }
  91
  92 /* Return the length of the Multiboot mmap that will be needed to allocate
  93    our platform's map.  */
  94 static grub_uint32_t
  95 grub_get_multiboot_mmap_len (void)
  96 {
  97   grub_size_t count = 0;
  98
  99   auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
 100   int NESTED_FUNC_ATTR hook (grub_uint64_t addr __attribute__ ((unused)),
 101                              grub_uint64_t size __attribute__ ((unused)),
 102                              grub_uint32_t type __attribute__ ((unused)))
 103     {
 104       count++;
 105       return 0;
 106     }
 107
 108   grub_mmap_iterate (hook);
 109
 110   return count * sizeof (struct grub_multiboot_mmap_entry);
 111 }
 112
 113 /* Fill previously allocated Multiboot mmap.  */
 114 static void
 115 grub_fill_multiboot_mmap (struct grub_multiboot_mmap_entry *first_entry)
 116 {
 117   struct grub_multiboot_mmap_entry *mmap_entry = (struct grub_multiboot_mmap_entry *) first_entry;
 118
 119   auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
 120   int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
 121     {
 122       mmap_entry->addr = addr;
 123       mmap_entry->len = size;
 124       mmap_entry->type = type;
 125       mmap_entry->size = sizeof (struct grub_multiboot_mmap_entry) - sizeof (mmap_entry->size);
 126       mmap_entry++;
 127
 128       return 0;
 129     }
 130
 131   grub_mmap_iterate (hook);
 132 }
 133
 134 #define MULTIBOOT_LOAD_ELF64
 135 #include "multiboot_elfxx.c"
 136 #undef MULTIBOOT_LOAD_ELF64
 137
 138 #define MULTIBOOT_LOAD_ELF32
 139 #include "multiboot_elfxx.c"
 140 #undef MULTIBOOT_LOAD_ELF32
 141
 142 /* Load ELF32 or ELF64.  */
 143 static grub_err_t
 144 grub_multiboot_load_elf (grub_file_t file, void *buffer)
 145 {
 146   if (grub_multiboot_is_elf32 (buffer))
 147     return grub_multiboot_load_elf32 (file, buffer);
 148   else if (grub_multiboot_is_elf64 (buffer))
 149     return grub_multiboot_load_elf64 (file, buffer);
 150
 151   return grub_error (GRUB_ERR_UNKNOWN_OS, "unknown ELF class");
 152 }
 153
 154 static int
 155 grub_multiboot_get_bootdev (grub_uint32_t *bootdev)
 156 {
 157 #ifdef GRUB_MACHINE_PCBIOS
 158   char *p;
 159   grub_uint32_t biosdev, slice = ~0, part = ~0;
 160   grub_device_t dev;
 161
 162   biosdev = grub_get_root_biosnumber ();
 163
 164   dev = grub_device_open (0);
 165   if (dev && dev->disk && dev->disk->partition)
 166     {
 167
 168       p = dev->disk->partition->partmap->get_name (dev->disk->partition);
 169       if (p)
 170         {
 171           if ((p[0] >= '0') && (p[0] <= '9'))
 172             {
 173               slice = grub_strtoul (p, &p, 0) - 1;
 174
 175               if ((p) && (p[0] == ','))
 176                 p++;
 177             }
 178
 179           if ((p[0] >= 'a') && (p[0] <= 'z'))
 180             part = p[0] - 'a';
 181         }
 182     }
 183   if (dev)
 184     grub_device_close (dev);
 185
 186   *bootdev = ((biosdev & 0xff) << 24) | ((slice & 0xff) << 16)
 187     | ((part & 0xff) << 8) | 0xff;
 188   return (biosdev != ~0UL);
 189 #else
 190   *bootdev = 0xffffffff;
 191   return 0;
 192 #endif
 193 }
 194
 195 void
 196 grub_multiboot (int argc, char *argv[])
 197 {
 198   grub_file_t file = 0;
 199   char buffer[MULTIBOOT_SEARCH], *cmdline = 0, *p;
 200   struct grub_multiboot_header *header;
 201   grub_ssize_t len, cmdline_length, boot_loader_name_length;
 202   grub_uint32_t mmap_length;
 203   int i;
 204
 205   grub_loader_unset ();
 206
 207   if (argc == 0)
 208     {
 209       grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
 210       goto fail;
 211     }
 212
 213   file = grub_gzfile_open (argv[0], 1);
 214   if (! file)
 215     {
 216       grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file");
 217       goto fail;
 218     }
 219
 220   len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
 221   if (len < 32)
 222     {
 223       grub_error (GRUB_ERR_BAD_OS, "File too small");
 224       goto fail;
 225     }
 226
 227   /* Look for the multiboot header in the buffer.  The header should
 228      be at least 12 bytes and aligned on a 4-byte boundary.  */
 229   for (header = (struct grub_multiboot_header *) buffer;
 230        ((char *) header <= buffer + len - 12) || (header = 0);
 231        header = (struct grub_multiboot_header *) ((char *) header + 4))
 232     {
 233       if (header->magic == MULTIBOOT_MAGIC
 234           && !(header->magic + header->flags + header->checksum))
 235         break;
 236     }
 237
 238   if (header == 0)
 239     {
 240       grub_error (GRUB_ERR_BAD_ARGUMENT, "No multiboot header found");
 241       goto fail;
 242     }
 243
 244   if (header->flags & MULTIBOOT_UNSUPPORTED)
 245     {
 246       grub_error (GRUB_ERR_UNKNOWN_OS,
 247                   "Unsupported flag: 0x%x", header->flags);
 248       goto fail;
 249     }
 250
 251   if (playground)
 252     {
 253       grub_free (playground);
 254       playground = NULL;
 255     }
 256
 257   mmap_length = grub_get_multiboot_mmap_len ();
 258
 259   /* Figure out cmdline length.  */
 260   for (i = 0, cmdline_length = 0; i < argc; i++)
 261     cmdline_length += grub_strlen (argv[i]) + 1;
 262
 263   boot_loader_name_length = sizeof(PACKAGE_STRING);
 264
 265 #define cmdline_addr(x)         ((void *) ((x) + code_size))
 266 #define boot_loader_name_addr(x) \
 267                                 ((void *) ((x) + code_size + cmdline_length))
 268 #define mbi_addr(x)             ((void *) ((x) + code_size + cmdline_length + boot_loader_name_length))
 269 #define mmap_addr(x)            ((void *) ((x) + code_size + cmdline_length + boot_loader_name_length + sizeof (struct grub_multiboot_info)))
 270
 271   grub_multiboot_payload_size = cmdline_length
 272     /* boot_loader_name_length might need to grow for mbi,etc to be aligned (see below) */
 273     + boot_loader_name_length + 3
 274     + sizeof (struct grub_multiboot_info) + mmap_length;
 275
 276   if (header->flags & MULTIBOOT_AOUT_KLUDGE)
 277     {
 278       int offset = ((char *) header - buffer -
 279                     (header->header_addr - header->load_addr));
 280       int load_size = ((header->load_end_addr == 0) ? file->size - offset :
 281                        header->load_end_addr - header->load_addr);
 282
 283       if (header->bss_end_addr)
 284         code_size = (header->bss_end_addr - header->load_addr);
 285       else
 286         code_size = load_size;
 287       grub_multiboot_payload_dest = header->load_addr;
 288
 289       grub_multiboot_payload_size += code_size;
 290       playground = grub_malloc (RELOCATOR_SIZEOF(forward) + grub_multiboot_payload_size + RELOCATOR_SIZEOF(backward));
 291       if (! playground)
 292         goto fail;
 293
 294       grub_multiboot_payload_orig = (long) playground + RELOCATOR_SIZEOF(forward);
 295
 296       if ((grub_file_seek (file, offset)) == (grub_off_t) - 1)
 297         goto fail;
 298
 299       grub_file_read (file, (void *) grub_multiboot_payload_orig, load_size);
 300       if (grub_errno)
 301         goto fail;
 302
 303       if (header->bss_end_addr)
 304         grub_memset ((void *) (grub_multiboot_payload_orig + load_size), 0,
 305                      header->bss_end_addr - header->load_addr - load_size);
 306
 307       grub_multiboot_payload_entry_offset = header->entry_addr - header->load_addr;
 308
 309     }
 310   else if (grub_multiboot_load_elf (file, buffer) != GRUB_ERR_NONE)
 311     goto fail;
 312
 313   /* This provides alignment for the MBI, the memory map and the backward relocator.  */
 314   boot_loader_name_length += (0x04 - ((unsigned long) mbi_addr (grub_multiboot_payload_dest) & 0x03));
 315
 316   mbi = mbi_addr (grub_multiboot_payload_orig);
 317   mbi_dest = mbi_addr (grub_multiboot_payload_dest);
 318   grub_memset (mbi, 0, sizeof (struct grub_multiboot_info));
 319   mbi->mmap_length = mmap_length;
 320
 321   grub_fill_multiboot_mmap (mmap_addr (grub_multiboot_payload_orig));
 322
 323   /* FIXME: grub_uint32_t will break for addresses above 4 GiB, but is mandated
 324      by the spec.  Is there something we can do about it?  */
 325   mbi->mmap_addr = (grub_uint32_t) mmap_addr (grub_multiboot_payload_dest);
 326   mbi->flags |= MULTIBOOT_INFO_MEM_MAP;
 327
 328   if (grub_multiboot_payload_dest >= grub_multiboot_payload_orig)
 329     {
 330       grub_memmove (playground, &grub_multiboot_forward_relocator, RELOCATOR_SIZEOF(forward));
 331       entry = (grub_addr_t) playground;
 332     }
 333   else
 334     {
 335       grub_memmove ((char *) (grub_multiboot_payload_orig + grub_multiboot_payload_size),
 336                     &grub_multiboot_backward_relocator, RELOCATOR_SIZEOF(backward));
 337       entry = (grub_addr_t) grub_multiboot_payload_orig + grub_multiboot_payload_size;
 338     }
 339
 340   grub_dprintf ("multiboot_loader", "dest=%p, size=0x%x, entry_offset=0x%x\n",
 341                 (void *) grub_multiboot_payload_dest,
 342                 grub_multiboot_payload_size,
 343                 grub_multiboot_payload_entry_offset);
 344
 345   /* Convert from bytes to kilobytes.  */
 346   mbi->mem_lower = grub_mmap_get_lower () / 1024;
 347   mbi->mem_upper = grub_mmap_get_upper () / 1024;
 348   mbi->flags |= MULTIBOOT_INFO_MEMORY;
 349
 350   cmdline = p = cmdline_addr (grub_multiboot_payload_orig);
 351   if (! cmdline)
 352     goto fail;
 353
 354   for (i = 0; i < argc; i++)
 355     {
 356       p = grub_stpcpy (p, argv[i]);
 357       *(p++) = ' ';
 358     }
 359
 360   /* Remove the space after the last word.  */
 361   *(--p) = '\0';
 362
 363   mbi->flags |= MULTIBOOT_INFO_CMDLINE;
 364   mbi->cmdline = (grub_uint32_t) cmdline_addr (grub_multiboot_payload_dest);
 365
 366
 367   grub_strcpy (boot_loader_name_addr (grub_multiboot_payload_orig), PACKAGE_STRING);
 368   mbi->flags |= MULTIBOOT_INFO_BOOT_LOADER_NAME;
 369   mbi->boot_loader_name = (grub_uint32_t) boot_loader_name_addr (grub_multiboot_payload_dest);
 370
 371   if (grub_multiboot_get_bootdev (&mbi->boot_device))
 372     mbi->flags |= MULTIBOOT_INFO_BOOTDEV;
 373
 374   grub_loader_set (grub_multiboot_boot, grub_multiboot_unload, 1);
 375
 376  fail:
 377   if (file)
 378     grub_file_close (file);
 379
 380   if (grub_errno != GRUB_ERR_NONE)
 381     {
 382       grub_free (cmdline);
 383       grub_free (mbi);
 384       grub_dl_unref (my_mod);
 385     }
 386 }
 387
 388
 389 void
 390 grub_module  (int argc, char *argv[])
 391 {
 392   grub_file_t file = 0;
 393   grub_ssize_t size, len = 0;
 394   char *module = 0, *cmdline = 0, *p;
 395   int i;
 396
 397   if (argc == 0)
 398     {
 399       grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
 400       goto fail;
 401     }
 402
 403   if (!mbi)
 404     {
 405       grub_error (GRUB_ERR_BAD_ARGUMENT,
 406                   "You need to load the multiboot kernel first");
 407       goto fail;
 408     }
 409
 410   file = grub_gzfile_open (argv[0], 1);
 411   if (! file)
 412     goto fail;
 413
 414   size = grub_file_size (file);
 415   module = grub_memalign (MULTIBOOT_MOD_ALIGN, size);
 416   if (! module)
 417     goto fail;
 418
 419   if (grub_file_read (file, module, size) != size)
 420     {
 421       grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
 422       goto fail;
 423     }
 424
 425   for (i = 0; i < argc; i++)
 426     len += grub_strlen (argv[i]) + 1;
 427
 428   cmdline = p = grub_malloc (len);
 429   if (! cmdline)
 430     goto fail;
 431
 432   for (i = 0; i < argc; i++)
 433     {
 434       p = grub_stpcpy (p, argv[i]);
 435       *(p++) = ' ';
 436     }
 437
 438   /* Remove the space after the last word.  */
 439   *(--p) = '\0';
 440
 441   if (mbi->flags & MULTIBOOT_INFO_MODS)
 442     {
 443       struct grub_mod_list *modlist = (struct grub_mod_list *) mbi->mods_addr;
 444
 445       modlist = grub_realloc (modlist, (mbi->mods_count + 1)
 446                                        * sizeof (struct grub_mod_list));
 447       if (! modlist)
 448         goto fail;
 449       mbi->mods_addr = (grub_uint32_t) modlist;
 450       modlist += mbi->mods_count;
 451       modlist->mod_start = (grub_uint32_t) module;
 452       modlist->mod_end = (grub_uint32_t) module + size;
 453       modlist->cmdline = (grub_uint32_t) cmdline;
 454       modlist->pad = 0;
 455       mbi->mods_count++;
 456     }
 457   else
 458     {
 459       struct grub_mod_list *modlist = grub_malloc (sizeof (struct grub_mod_list));
 460       if (! modlist)
 461         goto fail;
 462       modlist->mod_start = (grub_uint32_t) module;
 463       modlist->mod_end = (grub_uint32_t) module + size;
 464       modlist->cmdline = (grub_uint32_t) cmdline;
 465       modlist->pad = 0;
 466       mbi->mods_count = 1;
 467       mbi->mods_addr = (grub_uint32_t) modlist;
 468       mbi->flags |= MULTIBOOT_INFO_MODS;
 469     }
 470
 471  fail:
 472   if (file)
 473     grub_file_close (file);
 474
 475   if (grub_errno != GRUB_ERR_NONE)
 476     {
 477       grub_free (module);
 478       grub_free (cmdline);
 479     }
 480 }