loader/multiboot2.c

   1 /* multiboot2.c - boot a multiboot 2 OS image. */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2007  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 #include <multiboot2.h>
  21 #include <grub/loader.h>
  22 #include <grub/machine/loader.h>
  23 #include <grub/multiboot2.h>
  24 #include <grub/elfload.h>
  25 #include <grub/file.h>
  26 #include <grub/err.h>
  27 #include <grub/rescue.h>
  28 #include <grub/dl.h>
  29 #include <grub/mm.h>
  30 #include <grub/misc.h>
  31 #include <grub/gzio.h>
  32
  33 static grub_addr_t entry;
  34 extern grub_dl_t my_mod;
  35
  36 static char *grub_mb2_tags;
  37 static char *grub_mb2_tags_pos;
  38 static grub_size_t grub_mb2_tags_len;
  39 static int grub_mb2_tags_count;
  40
  41 static void
  42 grub_mb2_tags_free (void)
  43 {
  44   grub_dprintf ("loader", "Freeing all tags...\n");
  45   grub_free (grub_mb2_tags);
  46   grub_mb2_tags = 0;
  47   grub_mb2_tags_pos = 0;
  48   grub_mb2_tags_len = 0;
  49   grub_mb2_tags_count = 0;
  50 }
  51
  52 grub_err_t
  53 grub_mb2_tag_alloc (grub_addr_t *addr, int key, grub_size_t len)
  54 {
  55   struct multiboot_tag_header *tag;
  56   grub_size_t used;
  57   grub_size_t needed;
  58
  59   grub_dprintf ("loader", "Allocating tag: key 0x%x, size 0x%lx.\n",
  60                 key, (unsigned long) len);
  61
  62   used = grub_mb2_tags_pos - grub_mb2_tags;
  63   len = ALIGN_UP (len, sizeof (multiboot_word));
  64
  65   needed = used + len;
  66
  67   if (needed > grub_mb2_tags_len)
  68     {
  69       /* Allocate new buffer.  */
  70       grub_size_t newsize = needed * 2;
  71       char *newarea;
  72
  73       grub_dprintf ("loader", "Reallocating tag buffer (new size 0x%lx).\n",
  74                     (unsigned long) newsize);
  75
  76       newarea = grub_malloc (newsize);
  77       if (! newarea)
  78         return grub_errno;
  79       grub_memcpy (newarea, grub_mb2_tags, grub_mb2_tags_len);
  80       grub_free (grub_mb2_tags);
  81
  82       grub_mb2_tags_len = newsize;
  83       grub_mb2_tags = newarea;
  84       grub_mb2_tags_pos = newarea + used;
  85     }
  86
  87   tag = (struct multiboot_tag_header *) grub_mb2_tags_pos;
  88   grub_mb2_tags_pos += len;
  89
  90   tag->key = key;
  91   tag->len = len;
  92
  93   if (addr)
  94     *addr = (grub_addr_t) tag;
  95
  96   grub_mb2_tags_count++;
  97
  98   grub_dprintf ("loader", "Allocated tag %u at %p.\n", grub_mb2_tags_count, tag);
  99
 100   return 0;
 101 }
 102
 103 static grub_err_t
 104 grub_mb2_tag_start_create (void)
 105 {
 106   return grub_mb2_tag_alloc (0, MULTIBOOT2_TAG_START,
 107                             sizeof (struct multiboot_tag_start));
 108 }
 109
 110 static grub_err_t
 111 grub_mb2_tag_name_create (void)
 112 {
 113   struct multiboot_tag_name *name;
 114   grub_addr_t name_addr;
 115   grub_err_t err;
 116   const char *grub_version = PACKAGE_STRING;
 117
 118   err = grub_mb2_tag_alloc (&name_addr, MULTIBOOT2_TAG_NAME,
 119                            sizeof (struct multiboot_tag_name) +
 120                            sizeof (grub_version) + 1);
 121   if (err)
 122     return err;
 123
 124   name = (struct multiboot_tag_name *) name_addr;
 125   grub_strcpy (name->name, grub_version);
 126
 127   return GRUB_ERR_NONE;
 128 }
 129
 130 typedef grub_err_t (*tag_create_t) (void);
 131 static tag_create_t grub_mb2_tag_creators[] = {
 132   grub_mb2_tag_start_create,
 133   grub_mb2_tag_name_create,
 134   grub_mb2_tags_arch_create,
 135   0,
 136 };
 137
 138 static grub_err_t
 139 grub_mb2_tags_create (void)
 140 {
 141   tag_create_t *creator;
 142   grub_err_t err;
 143
 144   for (creator = grub_mb2_tag_creators; *creator != 0; creator++)
 145     {
 146       err = (*creator) ();
 147       if (err)
 148         goto error;
 149     }
 150
 151   return GRUB_ERR_NONE;
 152
 153 error:
 154   grub_error_push ();
 155   grub_mb2_tags_free ();
 156   grub_error_pop ();
 157   return err;
 158 }
 159
 160 static grub_err_t
 161 grub_mb2_tags_finish (void)
 162 {
 163   struct multiboot_tag_start *start;
 164   grub_err_t err;
 165
 166   /* Create the `end' tag.  */
 167   err = grub_mb2_tag_alloc (0, MULTIBOOT2_TAG_END,
 168                            sizeof (struct multiboot_tag_end));
 169   if (err)
 170     goto error;
 171
 172   /* We created the `start' tag first.  Update it now.  */
 173   start = (struct multiboot_tag_start *) grub_mb2_tags;
 174   start->size = grub_mb2_tags_pos - grub_mb2_tags;
 175   return GRUB_ERR_NONE;
 176
 177 error:
 178   grub_error_push ();
 179   grub_mb2_tags_free ();
 180   grub_error_pop ();
 181   return err;
 182 }
 183
 184 static grub_err_t
 185 grub_mb2_boot (void)
 186 {
 187   grub_mb2_tags_finish ();
 188
 189   grub_dprintf ("loader", "Tags at %p\n", grub_mb2_tags);
 190   grub_mb2_arch_boot (entry, grub_mb2_tags);
 191
 192   /* Not reached.  */
 193   return GRUB_ERR_NONE;
 194 }
 195
 196 static grub_err_t
 197 grub_mb2_unload (void)
 198 {
 199   struct multiboot_tag_header *tag;
 200   struct multiboot_tag_header *tags =
 201     (struct multiboot_tag_header *) grub_mb2_tags;
 202
 203   /* Free all module memory in the tag list.  */
 204   for_each_tag (tag, tags)
 205     {
 206       if (tag->key == MULTIBOOT2_TAG_MODULE)
 207         {
 208           struct multiboot_tag_module *module =
 209               (struct multiboot_tag_module *) tag;
 210           grub_free ((void *) module->addr);
 211         }
 212     }
 213
 214   /* Allow architecture to un-reserve memory.  */
 215   grub_mb2_arch_unload (tags);
 216
 217   /* Free the tags themselves.  */
 218   grub_mb2_tags_free ();
 219
 220   grub_dl_unref (my_mod);
 221
 222   return GRUB_ERR_NONE;
 223 }
 224
 225 static grub_err_t
 226 grub_mb2_load_other (UNUSED grub_file_t file, UNUSED void *buffer)
 227 {
 228   /* XXX Create module tag here.  */
 229   return grub_error (GRUB_ERR_UNKNOWN_OS, "currently only ELF is supported");
 230 }
 231
 232 /* Create the tag containing the cmdline and the address of the module data.  */
 233 static grub_err_t
 234 grub_mb2_tag_module_create (grub_addr_t modaddr, grub_size_t modsize,
 235                             char *type, int key, int argc, char *argv[])
 236 {
 237   struct multiboot_tag_module *module;
 238   grub_ssize_t argslen = 0;
 239   grub_err_t err;
 240   char *p;
 241   grub_addr_t module_addr;
 242   int i;
 243
 244   /* Allocate enough space for the arguments and spaces between them.  */
 245   for (i = 0; i < argc; i++)
 246     argslen += grub_strlen (argv[i]) + 1;
 247
 248   /* Note: includes implicit 1-byte cmdline.  */
 249   err = grub_mb2_tag_alloc (&module_addr, key,
 250                            sizeof (struct multiboot_tag_module) + argslen);
 251   if (err)
 252     return grub_errno;
 253
 254   module = (struct multiboot_tag_module *) module_addr;
 255   module->addr = modaddr;
 256   module->size = modsize;
 257   grub_strcpy(module->type, type);
 258
 259   /* Fill in the command line.  */
 260   p = module->cmdline;
 261   for (i = 0; i < argc; i++)
 262     {
 263       p = grub_stpcpy (p, argv[i]);
 264       *p++ = ' ';
 265     }
 266   module->cmdline[argslen] = '\0';
 267
 268   return GRUB_ERR_NONE;
 269 }
 270
 271 /* Load ELF32 or ELF64.  */
 272 static grub_err_t
 273 grub_mb2_load_elf (grub_elf_t elf, int argc, char *argv[])
 274 {
 275   grub_addr_t kern_base;
 276   grub_size_t kern_size;
 277   grub_err_t err;
 278
 279   if (grub_elf_is_elf32 (elf))
 280     {
 281       entry = elf->ehdr.ehdr32.e_entry;
 282       err = grub_elf32_load (elf, grub_mb2_arch_elf32_hook, &kern_base,
 283                              &kern_size);
 284     }
 285   else if (grub_elf_is_elf64 (elf))
 286     {
 287       entry = elf->ehdr.ehdr64.e_entry;
 288       err = grub_elf64_load (elf, grub_mb2_arch_elf64_hook, &kern_base,
 289                              &kern_size);
 290     }
 291   else
 292     err = grub_error (GRUB_ERR_UNKNOWN_OS, "unknown ELF class");
 293
 294   if (err)
 295     goto fail;
 296
 297   grub_dprintf ("loader", "Entry point is 0x%lx.\n", (unsigned long) entry);
 298
 299   grub_mb2_tag_module_create (kern_base, kern_size, "kernel",
 300                              MULTIBOOT2_TAG_MODULE, argc, argv);
 301
 302 fail:
 303   return err;
 304 }
 305
 306 void
 307 grub_multiboot2 (int argc, char *argv[])
 308 {
 309   char *buffer;
 310   grub_file_t file = 0;
 311   grub_elf_t elf = 0;
 312   struct multiboot_header *header = 0;
 313   char *p;
 314   grub_ssize_t len;
 315   grub_err_t err;
 316   int header_found = 0;
 317
 318   grub_loader_unset ();
 319
 320   if (argc == 0)
 321     {
 322       grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
 323       goto fail;
 324     }
 325
 326   file = grub_gzfile_open (argv[0], 1);
 327   if (! file)
 328     {
 329       grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file");
 330       goto fail;
 331     }
 332
 333   buffer = grub_malloc (MULTIBOOT2_HEADER_SEARCH);
 334   if (! buffer)
 335     return;
 336
 337   len = grub_file_read (file, buffer, MULTIBOOT2_HEADER_SEARCH);
 338   if (len < 32)
 339     {
 340       grub_error (GRUB_ERR_BAD_OS, "File too small");
 341       goto fail;
 342     }
 343
 344   /* Look for the multiboot header in the buffer.  The header should
 345      be at least 12 bytes and aligned on a 4-byte boundary.  */
 346   for (p = buffer; p <= buffer + len - 12; p += 4)
 347     {
 348       header = (struct multiboot_header *) p;
 349       if (header->magic == MULTIBOOT2_HEADER_MAGIC)
 350         {
 351           header_found = 1;
 352           break;
 353         }
 354     }
 355
 356   if (! header_found)
 357     grub_dprintf ("loader", "No multiboot 2 header found.\n");
 358
 359
 360   /* Create the basic tags.  */
 361   grub_dprintf ("loader", "Creating multiboot 2 tags\n");
 362   grub_mb2_tags_create ();
 363
 364   /* Load the kernel and create its tag.  */
 365   elf = grub_elf_file (file);
 366   if (elf)
 367     {
 368       grub_dprintf ("loader", "Loading ELF multiboot 2 file.\n");
 369       err = grub_mb2_load_elf (elf, argc-1, &argv[1]);
 370       grub_elf_close (elf);
 371     }
 372   else
 373     {
 374       grub_errno = 0;
 375       grub_dprintf ("loader", "Loading non-ELF multiboot 2 file.\n");
 376
 377       if (header)
 378         err = grub_mb2_load_other (file, header);
 379       else
 380         err = grub_error (GRUB_ERR_BAD_OS,
 381                           "Need multiboot 2 header to load non-ELF files.");
 382       grub_file_close (file);
 383     }
 384
 385   grub_free (buffer);
 386
 387   if (err)
 388     goto fail;
 389
 390   /* Good to go.  */
 391   grub_loader_set (grub_mb2_boot, grub_mb2_unload, 1);
 392   return;
 393
 394 fail:
 395   grub_mb2_tags_free ();
 396   grub_dl_unref (my_mod);
 397 }
 398
 399 void
 400 grub_module2 (int argc, char *argv[])
 401 {
 402   grub_file_t file;
 403   grub_addr_t modaddr = 0;
 404   grub_ssize_t modsize = 0;
 405   grub_err_t err;
 406
 407   if (argc == 0)
 408     {
 409       grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
 410       return;
 411     }
 412
 413   if (argc == 1)
 414     {
 415       grub_error (GRUB_ERR_BAD_ARGUMENT, "No module type specified");
 416       return;
 417     }
 418
 419   if (entry == 0)
 420     {
 421       grub_error (GRUB_ERR_BAD_ARGUMENT,
 422                   "You need to load the multiboot kernel first");
 423       return;
 424     }
 425
 426   /* Load module data.  */
 427   file = grub_gzfile_open (argv[0], 1);
 428   if (! file)
 429     goto out;
 430
 431   modsize = grub_file_size (file);
 432   err = grub_mb2_arch_module_alloc (modsize, &modaddr);
 433   if (err)
 434     goto out;
 435
 436   grub_dprintf ("loader", "Loading module at 0x%x - 0x%x\n", modaddr,
 437                 modaddr + modsize);
 438   if (grub_file_read (file, (char *) modaddr, modsize) != modsize)
 439     {
 440       grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
 441       goto out;
 442     }
 443
 444   /* Create the module tag.  */
 445   err = grub_mb2_tag_module_create (modaddr, modsize,
 446                                    argv[1], MULTIBOOT2_TAG_MODULE,
 447                                    argc-2, &argv[2]);
 448   if (err)
 449     goto out;
 450
 451 out:
 452   grub_error_push ();
 453
 454   if (file)
 455     grub_file_close (file);
 456
 457   if (modaddr)
 458     grub_mb2_arch_module_free (modaddr, modsize);
 459
 460   grub_error_pop ();
 461 }