loader/i386/bsd.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2008, 2009  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/loader.h>
  20 #include <grub/cpu/loader.h>
  21 #include <grub/cpu/bsd.h>
  22 #include <grub/machine/init.h>
  23 #include <grub/machine/memory.h>
  24 #include <grub/memory.h>
  25 #include <grub/machine/machine.h>
  26 #include <grub/file.h>
  27 #include <grub/err.h>
  28 #include <grub/dl.h>
  29 #include <grub/mm.h>
  30 #include <grub/elfload.h>
  31 #include <grub/env.h>
  32 #include <grub/misc.h>
  33 #include <grub/gzio.h>
  34 #include <grub/aout.h>
  35 #include <grub/command.h>
  36 #ifdef GRUB_MACHINE_PCBIOS
  37 #include <grub/machine/biosnum.h>
  38 #include <grub/disk.h>
  39 #include <grub/device.h>
  40 #include <grub/partition.h>
  41 #endif
  42
  43 #define ALIGN_DWORD(a)  ALIGN_UP (a, 4)
  44 #define ALIGN_QWORD(a)  ALIGN_UP (a, 8)
  45 #define ALIGN_VAR(a)    ((is_64bit) ? (ALIGN_QWORD(a)) : (ALIGN_DWORD(a)))
  46 #define ALIGN_PAGE(a)   ALIGN_UP (a, 4096)
  47
  48 #define MOD_BUF_ALLOC_UNIT      4096
  49
  50 static int kernel_type;
  51 static grub_dl_t my_mod;
  52 static grub_addr_t entry, entry_hi, kern_start, kern_end;
  53 static grub_uint32_t bootflags;
  54 static char *mod_buf;
  55 static grub_uint32_t mod_buf_len, mod_buf_max, kern_end_mdofs;
  56 static int is_elf_kernel, is_64bit;
  57
  58 static const char freebsd_opts[] = "DhaCcdgmnpqrsv";
  59 static const grub_uint32_t freebsd_flags[] =
  60 {
  61   FREEBSD_RB_DUAL, FREEBSD_RB_SERIAL, FREEBSD_RB_ASKNAME,
  62   FREEBSD_RB_CDROM, FREEBSD_RB_CONFIG, FREEBSD_RB_KDB,
  63   FREEBSD_RB_GDB, FREEBSD_RB_MUTE, FREEBSD_RB_NOINTR,
  64   FREEBSD_RB_PAUSE, FREEBSD_RB_QUIET, FREEBSD_RB_DFLTROOT,
  65   FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE
  66 };
  67
  68 static const char openbsd_opts[] = "abcsd";
  69 static const grub_uint32_t openbsd_flags[] =
  70 {
  71   OPENBSD_RB_ASKNAME, OPENBSD_RB_HALT, OPENBSD_RB_CONFIG,
  72   OPENBSD_RB_SINGLE, OPENBSD_RB_KDB
  73 };
  74
  75 static const char netbsd_opts[] = "abcdmqsvxz";
  76 static const grub_uint32_t netbsd_flags[] =
  77 {
  78   NETBSD_RB_ASKNAME, NETBSD_RB_HALT, NETBSD_RB_USERCONFIG,
  79   NETBSD_RB_KDB, NETBSD_RB_MINIROOT, NETBSD_AB_QUIET,
  80   NETBSD_RB_SINGLE, NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG,
  81   NETBSD_AB_SILENT
  82 };
  83
  84 static void
  85 grub_bsd_get_device (grub_uint32_t * biosdev,
  86                      grub_uint32_t * unit,
  87                      grub_uint32_t * slice, grub_uint32_t * part)
  88 {
  89   char *p;
  90   grub_device_t dev;
  91
  92   *biosdev = grub_get_root_biosnumber () & 0xff;
  93   *unit = (*biosdev & 0x7f);
  94   *slice = 0xff;
  95   *part = 0xff;
  96   dev = grub_device_open (0);
  97   if (dev && dev->disk && dev->disk->partition)
  98     {
  99
 100       p = dev->disk->partition->partmap->get_name (dev->disk->partition);
 101       if (p)
 102         {
 103           if ((p[0] >= '0') && (p[0] <= '9'))
 104             {
 105               *slice = grub_strtoul (p, &p, 0);
 106
 107               if ((p) && (p[0] == ','))
 108                 p++;
 109             }
 110
 111           if ((p[0] >= 'a') && (p[0] <= 'z'))
 112             *part = p[0] - 'a';
 113         }
 114     }
 115   if (dev)
 116     grub_device_close (dev);
 117 }
 118
 119 grub_err_t
 120 grub_freebsd_add_meta (grub_uint32_t type, void *data, grub_uint32_t len)
 121 {
 122   if (mod_buf_max < mod_buf_len + len + 8)
 123     {
 124       char *new_buf;
 125
 126       do
 127         {
 128           mod_buf_max += MOD_BUF_ALLOC_UNIT;
 129         }
 130       while (mod_buf_max < mod_buf_len + len + 8);
 131
 132       new_buf = grub_malloc (mod_buf_max);
 133       if (!new_buf)
 134         return grub_errno;
 135
 136       grub_memcpy (new_buf, mod_buf, mod_buf_len);
 137       grub_free (mod_buf);
 138
 139       mod_buf = new_buf;
 140     }
 141
 142   *((grub_uint32_t *) (mod_buf + mod_buf_len)) = type;
 143   *((grub_uint32_t *) (mod_buf + mod_buf_len + 4)) = len;
 144   mod_buf_len += 8;
 145
 146   if (len)
 147     grub_memcpy (mod_buf + mod_buf_len, data, len);
 148
 149   mod_buf_len = ALIGN_VAR (mod_buf_len + len);
 150
 151   return GRUB_ERR_NONE;
 152 }
 153
 154 struct grub_e820_mmap
 155 {
 156   grub_uint64_t addr;
 157   grub_uint64_t size;
 158   grub_uint32_t type;
 159 } __attribute__((packed));
 160 #define GRUB_E820_RAM        1
 161 #define GRUB_E820_RESERVED   2
 162 #define GRUB_E820_ACPI       3
 163 #define GRUB_E820_NVS        4
 164 #define GRUB_E820_EXEC_CODE  5
 165
 166 static grub_err_t
 167 grub_freebsd_add_mmap (void)
 168 {
 169   grub_size_t len = 0;
 170   struct grub_e820_mmap *mmap_buf = 0;
 171   struct grub_e820_mmap *mmap = 0;
 172   int isfirstrun = 1;
 173
 174   auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
 175   int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size,
 176                              grub_uint32_t type)
 177     {
 178       /* FreeBSD assumes that first 64KiB are available.
 179          Not always true but try to prevent panic somehow. */
 180       if (isfirstrun && addr != 0)
 181         {
 182           if (mmap)
 183             {
 184               mmap->addr = 0;
 185               mmap->size = (addr < 0x10000) ? addr : 0x10000;
 186               mmap->type = GRUB_E820_RAM;
 187               mmap++;
 188             }
 189           else
 190             len += sizeof (struct grub_e820_mmap);
 191         }
 192       isfirstrun = 0;
 193       if (mmap)
 194         {
 195           mmap->addr = addr;
 196           mmap->size = size;
 197           switch (type)
 198             {
 199             case GRUB_MACHINE_MEMORY_AVAILABLE:
 200               mmap->type = GRUB_E820_RAM;
 201               break;
 202
 203 #ifdef GRUB_MACHINE_MEMORY_ACPI
 204             case GRUB_MACHINE_MEMORY_ACPI:
 205               mmap->type = GRUB_E820_ACPI;
 206               break;
 207 #endif
 208
 209 #ifdef GRUB_MACHINE_MEMORY_NVS
 210             case GRUB_MACHINE_MEMORY_NVS:
 211               mmap->type = GRUB_E820_NVS;
 212               break;
 213 #endif
 214
 215             default:
 216 #ifdef GRUB_MACHINE_MEMORY_CODE
 217             case GRUB_MACHINE_MEMORY_CODE:
 218 #endif
 219 #ifdef GRUB_MACHINE_MEMORY_RESERVED
 220             case GRUB_MACHINE_MEMORY_RESERVED:
 221 #endif
 222               mmap->type = GRUB_E820_RESERVED;
 223               break;
 224             }
 225
 226           /* Merge regions if possible. */
 227           if (mmap != mmap_buf && mmap->type == mmap[-1].type &&
 228               mmap->addr == mmap[-1].addr + mmap[-1].size)
 229             mmap[-1].size += mmap->size;
 230           else
 231             mmap++;
 232         }
 233       else
 234         len += sizeof (struct grub_e820_mmap);
 235
 236       return 0;
 237     }
 238
 239   grub_mmap_iterate (hook);
 240   mmap_buf = mmap = grub_malloc (len);
 241   if (! mmap)
 242     return grub_errno;
 243
 244   isfirstrun = 1;
 245   grub_mmap_iterate (hook);
 246
 247   len = (mmap - mmap_buf) * sizeof (struct grub_e820_mmap);
 248   int i;
 249   for (i = 0; i < mmap - mmap_buf; i++)
 250     grub_dprintf ("bsd", "smap %d, %d:%llx - %llx\n", i,
 251                   mmap_buf[i].type,
 252                   (unsigned long long) mmap_buf[i].addr,
 253                   (unsigned long long) mmap_buf[i].size);
 254
 255   grub_dprintf ("bsd", "%d entries in smap\n", mmap - mmap_buf);
 256   grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
 257                          FREEBSD_MODINFOMD_SMAP, mmap_buf, len);
 258
 259   grub_free (mmap_buf);
 260
 261   return grub_errno;
 262 }
 263
 264 grub_err_t
 265 grub_freebsd_add_meta_module (char *filename, char *type, int argc, char **argv,
 266                               grub_addr_t addr, grub_uint32_t size)
 267 {
 268   char *name;
 269   name = grub_strrchr (filename, '/');
 270   if (name)
 271     name++;
 272   else
 273     name = filename;
 274   if (grub_strcmp (type, "/boot/zfs/zpool.cache") == 0)
 275     name = "/boot/zfs/zpool.cache";
 276
 277   if (grub_freebsd_add_meta (FREEBSD_MODINFO_NAME, name,
 278                              grub_strlen (name) + 1))
 279     return grub_errno;
 280
 281   if (is_64bit)
 282     {
 283       grub_uint64_t addr64 = addr, size64 = size;
 284       if ((grub_freebsd_add_meta (FREEBSD_MODINFO_TYPE, type,
 285                               grub_strlen (type) + 1)) ||
 286           (grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr64,
 287                                   sizeof (addr64))) ||
 288           (grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size64,
 289                                   sizeof (size64))))
 290         return grub_errno;
 291     }
 292   else
 293     {
 294       if ((grub_freebsd_add_meta (FREEBSD_MODINFO_TYPE, type,
 295                                   grub_strlen (type) + 1)) ||
 296           (grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr,
 297                                   sizeof (addr))) ||
 298           (grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size,
 299                                   sizeof (size))))
 300         return grub_errno;
 301     }
 302
 303   if (argc)
 304     {
 305       int i, n;
 306
 307       n = 0;
 308       for (i = 0; i < argc; i++)
 309         {
 310           n += grub_strlen (argv[i]) + 1;
 311         }
 312
 313       if (n)
 314         {
 315           char cmdline[n], *p;
 316
 317           p = cmdline;
 318           for (i = 0; i < argc; i++)
 319             {
 320               grub_strcpy (p, argv[i]);
 321               p += grub_strlen (argv[i]);
 322               *(p++) = ' ';
 323             }
 324           *p = 0;
 325
 326           if (grub_freebsd_add_meta (FREEBSD_MODINFO_ARGS, cmdline, n))
 327             return grub_errno;
 328         }
 329     }
 330
 331   return GRUB_ERR_NONE;
 332 }
 333
 334 static void
 335 grub_freebsd_list_modules (void)
 336 {
 337   grub_uint32_t pos = 0;
 338
 339   grub_printf ("  %-18s  %-18s%14s%14s\n", "name", "type", "addr", "size");
 340   while (pos < mod_buf_len)
 341     {
 342       grub_uint32_t type, size;
 343
 344       type = *((grub_uint32_t *) (mod_buf + pos));
 345       size = *((grub_uint32_t *) (mod_buf + pos + 4));
 346       pos += 8;
 347       switch (type)
 348         {
 349         case FREEBSD_MODINFO_NAME:
 350         case FREEBSD_MODINFO_TYPE:
 351           grub_printf ("  %-18s", mod_buf + pos);
 352           break;
 353         case FREEBSD_MODINFO_ADDR:
 354           {
 355             grub_addr_t addr;
 356
 357             addr = *((grub_addr_t *) (mod_buf + pos));
 358             grub_printf ("    0x%08x", addr);
 359             break;
 360           }
 361         case FREEBSD_MODINFO_SIZE:
 362           {
 363             grub_uint32_t len;
 364
 365             len = *((grub_uint32_t *) (mod_buf + pos));
 366             grub_printf ("    0x%08x\n", len);
 367           }
 368         }
 369
 370       pos = ALIGN_VAR (pos + size);
 371     }
 372 }
 373
 374 /* This function would be here but it's under different license. */
 375 #include "bsd_pagetable.c"
 376
 377 struct gdt_descriptor
 378 {
 379   grub_uint16_t limit;
 380   void *base;
 381 } __attribute__ ((packed));
 382
 383 static grub_err_t
 384 grub_freebsd_boot (void)
 385 {
 386   struct grub_freebsd_bootinfo bi;
 387   char *p;
 388   grub_uint32_t bootdev, biosdev, unit, slice, part;
 389
 390   auto int iterate_env (struct grub_env_var *var);
 391   int iterate_env (struct grub_env_var *var)
 392   {
 393     if ((!grub_memcmp (var->name, "FreeBSD.", 8)) && (var->name[8]))
 394       {
 395         grub_strcpy (p, &var->name[8]);
 396         p += grub_strlen (p);
 397         *(p++) = '=';
 398         grub_strcpy (p, var->value);
 399         p += grub_strlen (p) + 1;
 400       }
 401
 402     return 0;
 403   }
 404
 405   grub_memset (&bi, 0, sizeof (bi));
 406   bi.bi_version = FREEBSD_BOOTINFO_VERSION;
 407   bi.bi_size = sizeof (bi);
 408
 409   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 410   bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
 411              (unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
 412
 413   bi.bi_bios_dev = biosdev;
 414
 415   p = (char *) kern_end;
 416
 417   grub_env_iterate (iterate_env);
 418
 419   if (p != (char *) kern_end)
 420     {
 421       *(p++) = 0;
 422
 423       bi.bi_envp = kern_end;
 424       kern_end = ALIGN_PAGE ((grub_uint32_t) p);
 425     }
 426
 427   if (is_elf_kernel)
 428     {
 429       grub_addr_t md_ofs;
 430       int ofs;
 431
 432       if (grub_freebsd_add_meta (FREEBSD_MODINFO_END, 0, 0))
 433         return grub_errno;
 434
 435       grub_memcpy ((char *) kern_end, mod_buf, mod_buf_len);
 436       bi.bi_modulep = kern_end;
 437
 438       kern_end = ALIGN_PAGE (kern_end + mod_buf_len);
 439
 440       if (is_64bit)
 441         kern_end += 4096 * 4;
 442
 443       md_ofs = bi.bi_modulep + kern_end_mdofs;
 444       ofs = (is_64bit) ? 16 : 12;
 445       *((grub_uint32_t *) md_ofs) = kern_end;
 446       md_ofs -= ofs;
 447       *((grub_uint32_t *) md_ofs) = bi.bi_envp;
 448       md_ofs -= ofs;
 449       *((grub_uint32_t *) md_ofs) = bootflags;
 450     }
 451
 452   bi.bi_kernend = kern_end;
 453
 454   if (is_64bit)
 455     {
 456       grub_uint32_t *gdt;
 457       grub_uint8_t *trampoline;
 458       void (*launch_trampoline) (grub_addr_t entry_lo, ...)
 459         __attribute__ ((cdecl, regparm (0)));
 460       grub_uint8_t *pagetable;
 461
 462       struct gdt_descriptor *gdtdesc;
 463
 464       pagetable = (grub_uint8_t *) (kern_end - 16384);
 465       fill_bsd64_pagetable (pagetable);
 466
 467       /* Create GDT. */
 468       gdt = (grub_uint32_t *) (kern_end - 4096);
 469       gdt[0] = 0;
 470       gdt[1] = 0;
 471       gdt[2] = 0;
 472       gdt[3] = 0x00209800;
 473       gdt[4] = 0;
 474       gdt[5] = 0x00008000;
 475
 476       /* Create GDT descriptor. */
 477       gdtdesc = (struct gdt_descriptor *) (kern_end - 4096 + 24);
 478       gdtdesc->limit = 24;
 479       gdtdesc->base = gdt;
 480
 481       /* Prepare trampoline. */
 482       trampoline = (grub_uint8_t *) (kern_end - 4096 + 24
 483                                      + sizeof (struct gdt_descriptor));
 484       launch_trampoline = (void  __attribute__ ((cdecl, regparm (0)))
 485                            (*) (grub_addr_t entry_lo, ...)) trampoline;
 486       grub_bsd64_trampoline_gdt = (grub_uint32_t) gdtdesc;
 487       grub_bsd64_trampoline_selfjump
 488         = (grub_uint32_t) (trampoline + 6
 489                            + ((grub_uint8_t *) &grub_bsd64_trampoline_selfjump
 490                               - &grub_bsd64_trampoline_start));
 491
 492       /* Copy trampoline. */
 493       grub_memcpy (trampoline, &grub_bsd64_trampoline_start,
 494                    &grub_bsd64_trampoline_end - &grub_bsd64_trampoline_start);
 495
 496       /* Launch trampoline. */
 497       launch_trampoline (entry, entry_hi, pagetable, bi.bi_modulep,
 498                          kern_end);
 499     }
 500   else
 501     grub_unix_real_boot (entry, bootflags | FREEBSD_RB_BOOTINFO, bootdev,
 502                          0, 0, 0, &bi, bi.bi_modulep, kern_end);
 503
 504   /* Not reached.  */
 505   return GRUB_ERR_NONE;
 506 }
 507
 508 static grub_err_t
 509 grub_openbsd_boot (void)
 510 {
 511   char *buf = (char *) GRUB_BSD_TEMP_BUFFER;
 512   struct grub_openbsd_bios_mmap *pm;
 513   struct grub_openbsd_bootargs *pa;
 514   grub_uint32_t bootdev, biosdev, unit, slice, part;
 515
 516   auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
 517   int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
 518     {
 519       pm->addr = addr;
 520       pm->len = size;
 521
 522       switch (type)
 523         {
 524         case GRUB_MACHINE_MEMORY_AVAILABLE:
 525           pm->type = OPENBSD_MMAP_AVAILABLE;
 526           break;
 527
 528         default:
 529           pm->type = OPENBSD_MMAP_RESERVED;
 530           break;
 531         }
 532       pm++;
 533
 534       return 0;
 535     }
 536
 537   pa = (struct grub_openbsd_bootargs *) buf;
 538
 539   pa->ba_type = OPENBSD_BOOTARG_MMAP;
 540   pm = (struct grub_openbsd_bios_mmap *) (pa + 1);
 541   grub_mmap_iterate (hook);
 542
 543   pa->ba_size = (char *) pm - (char *) pa;
 544   pa->ba_next = (struct grub_openbsd_bootargs *) pm;
 545   pa = pa->ba_next;
 546   pa->ba_type = OPENBSD_BOOTARG_END;
 547   pa++;
 548
 549   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 550   bootdev = (OPENBSD_B_DEVMAGIC + (unit << OPENBSD_B_UNITSHIFT) +
 551              (part << OPENBSD_B_PARTSHIFT));
 552
 553   grub_unix_real_boot (entry, bootflags, bootdev, OPENBSD_BOOTARG_APIVER,
 554                        0, grub_mmap_get_upper () >> 10,
 555                        grub_mmap_get_lower () >> 10,
 556                        (char *) pa - buf, buf);
 557
 558   /* Not reached.  */
 559   return GRUB_ERR_NONE;
 560 }
 561
 562 static grub_err_t
 563 grub_netbsd_boot (void)
 564 {
 565   struct grub_netbsd_btinfo_rootdevice *rootdev;
 566   struct grub_netbsd_bootinfo *bootinfo;
 567   grub_uint32_t biosdev, unit, slice, part;
 568
 569   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 570
 571   rootdev = (struct grub_netbsd_btinfo_rootdevice *) GRUB_BSD_TEMP_BUFFER;
 572
 573   rootdev->common.len = sizeof (struct grub_netbsd_btinfo_rootdevice);
 574   rootdev->common.type = NETBSD_BTINFO_ROOTDEVICE;
 575   grub_sprintf (rootdev->devname, "%cd%d%c", (biosdev & 0x80) ? 'w' : 'f',
 576                 unit, 'a' + part);
 577
 578   bootinfo = (struct grub_netbsd_bootinfo *) (rootdev + 1);
 579   bootinfo->bi_count = 1;
 580   bootinfo->bi_data[0] = rootdev;
 581
 582   grub_unix_real_boot (entry, bootflags, 0, bootinfo,
 583                        0, grub_mmap_get_upper () >> 10,
 584                        grub_mmap_get_lower () >> 10);
 585
 586   /* Not reached.  */
 587   return GRUB_ERR_NONE;
 588 }
 589
 590 static grub_err_t
 591 grub_bsd_unload (void)
 592 {
 593   if (mod_buf)
 594     {
 595       grub_free (mod_buf);
 596       mod_buf = 0;
 597       mod_buf_max = 0;
 598     }
 599
 600   kernel_type = KERNEL_TYPE_NONE;
 601   grub_dl_unref (my_mod);
 602
 603   return GRUB_ERR_NONE;
 604 }
 605
 606 static grub_err_t
 607 grub_bsd_load_aout (grub_file_t file)
 608 {
 609   grub_addr_t load_addr, bss_end_addr;
 610   int ofs, align_page;
 611   union grub_aout_header ah;
 612
 613   if ((grub_file_seek (file, 0)) == (grub_off_t) - 1)
 614     return grub_errno;
 615
 616   if (grub_file_read (file, &ah, sizeof (ah)) != sizeof (ah))
 617     return grub_error (GRUB_ERR_READ_ERROR, "cannot read the a.out header");
 618
 619   if (grub_aout_get_type (&ah) != AOUT_TYPE_AOUT32)
 620     return grub_error (GRUB_ERR_BAD_OS, "invalid a.out header");
 621
 622   entry = ah.aout32.a_entry & 0xFFFFFF;
 623
 624   if (AOUT_GETMAGIC (ah.aout32) == AOUT32_ZMAGIC)
 625     {
 626       load_addr = entry;
 627       ofs = 0x1000;
 628       align_page = 0;
 629     }
 630   else
 631     {
 632       load_addr = entry & 0xF00000;
 633       ofs = sizeof (struct grub_aout32_header);
 634       align_page = 1;
 635     }
 636
 637   if (load_addr < 0x100000)
 638     return grub_error (GRUB_ERR_BAD_OS, "load address below 1M");
 639
 640   kern_start = load_addr;
 641   kern_end = load_addr + ah.aout32.a_text + ah.aout32.a_data;
 642   if (align_page)
 643     kern_end = ALIGN_PAGE (kern_end);
 644
 645   if (ah.aout32.a_bss)
 646     {
 647       kern_end += ah.aout32.a_bss;
 648       if (align_page)
 649         kern_end = ALIGN_PAGE (kern_end);
 650
 651       bss_end_addr = kern_end;
 652     }
 653   else
 654     bss_end_addr = 0;
 655
 656   return grub_aout_load (file, ofs, load_addr,
 657                          ah.aout32.a_text + ah.aout32.a_data, bss_end_addr);
 658 }
 659
 660 static grub_err_t
 661 grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
 662 {
 663   Elf32_Addr paddr;
 664
 665   if (phdr->p_type != PT_LOAD
 666       && phdr->p_type != PT_DYNAMIC)
 667     {
 668       *do_load = 0;
 669       return 0;
 670     }
 671
 672   *do_load = 1;
 673   phdr->p_paddr &= 0xFFFFFF;
 674   paddr = phdr->p_paddr;
 675
 676   if ((paddr < grub_os_area_addr)
 677       || (paddr + phdr->p_memsz > grub_os_area_addr + grub_os_area_size))
 678     return grub_error (GRUB_ERR_OUT_OF_RANGE, "Address 0x%x is out of range",
 679                        paddr);
 680
 681   if ((!kern_start) || (paddr < kern_start))
 682     kern_start = paddr;
 683
 684   if (paddr + phdr->p_memsz > kern_end)
 685     kern_end = paddr + phdr->p_memsz;
 686
 687   *addr = paddr;
 688
 689   return GRUB_ERR_NONE;
 690 }
 691
 692 static grub_err_t
 693 grub_bsd_elf64_hook (Elf64_Phdr * phdr, grub_addr_t * addr, int *do_load)
 694 {
 695   Elf64_Addr paddr;
 696
 697   if (phdr->p_type != PT_LOAD
 698       && phdr->p_type != PT_DYNAMIC)
 699     {
 700       *do_load = 0;
 701       return 0;
 702     }
 703
 704   *do_load = 1;
 705   paddr = phdr->p_paddr & 0xffffff;
 706
 707   if ((paddr < grub_os_area_addr)
 708       || (paddr + phdr->p_memsz > grub_os_area_addr + grub_os_area_size))
 709     return grub_error (GRUB_ERR_OUT_OF_RANGE, "Address 0x%x is out of range",
 710                        paddr);
 711
 712   if ((!kern_start) || (paddr < kern_start))
 713     kern_start = paddr;
 714
 715   if (paddr + phdr->p_memsz > kern_end)
 716     kern_end = paddr + phdr->p_memsz;
 717
 718   *addr = paddr;
 719
 720   return GRUB_ERR_NONE;
 721 }
 722
 723 static grub_err_t
 724 grub_bsd_load_elf (grub_elf_t elf)
 725 {
 726   kern_start = kern_end = 0;
 727
 728   if (grub_elf_is_elf32 (elf))
 729     {
 730       entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
 731       return grub_elf32_load (elf, grub_bsd_elf32_hook, 0, 0);
 732     }
 733   else if (grub_elf_is_elf64 (elf))
 734     {
 735       is_64bit = 1;
 736       entry = elf->ehdr.ehdr64.e_entry & 0xffffffff;
 737       entry_hi = (elf->ehdr.ehdr64.e_entry >> 32) & 0xffffffff;
 738       return grub_elf64_load (elf, grub_bsd_elf64_hook, 0, 0);
 739     }
 740   else
 741     return grub_error (GRUB_ERR_BAD_OS, "invalid elf");
 742 }
 743
 744 static grub_err_t
 745 grub_bsd_load (int argc, char *argv[])
 746 {
 747   grub_file_t file;
 748   grub_elf_t elf;
 749
 750   grub_dl_ref (my_mod);
 751
 752   grub_loader_unset ();
 753
 754   if (argc == 0)
 755     {
 756       grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
 757       goto fail;
 758     }
 759
 760   file = grub_gzfile_open (argv[0], 1);
 761   if (!file)
 762     goto fail;
 763
 764   elf = grub_elf_file (file);
 765   if (elf)
 766     {
 767       is_elf_kernel = 1;
 768       grub_bsd_load_elf (elf);
 769       grub_elf_close (elf);
 770     }
 771   else
 772     {
 773       is_elf_kernel = 0;
 774       grub_errno = 0;
 775       grub_bsd_load_aout (file);
 776       grub_file_close (file);
 777     }
 778
 779 fail:
 780
 781   if (grub_errno != GRUB_ERR_NONE)
 782     grub_dl_unref (my_mod);
 783
 784   return grub_errno;
 785 }
 786
 787 static grub_uint32_t
 788 grub_bsd_parse_flags (char *str, const char *opts,
 789                       const grub_uint32_t * flags)
 790 {
 791   grub_uint32_t result = 0;
 792
 793   while (*str)
 794     {
 795       const char *po;
 796       const grub_uint32_t *pf;
 797
 798       po = opts;
 799       pf = flags;
 800       while (*po)
 801         {
 802           if (*str == *po)
 803             {
 804               result |= *pf;
 805               break;
 806             }
 807           po++;
 808           pf++;
 809         }
 810       str++;
 811     }
 812
 813   return result;
 814 }
 815
 816 static grub_err_t
 817 grub_cmd_freebsd (grub_command_t cmd __attribute__ ((unused)),
 818                   int argc, char *argv[])
 819 {
 820   kernel_type = KERNEL_TYPE_FREEBSD;
 821   bootflags = ((argc <= 1) ? 0 :
 822                grub_bsd_parse_flags (argv[1], freebsd_opts, freebsd_flags));
 823
 824   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 825     {
 826       kern_end = ALIGN_PAGE (kern_end);
 827       if (is_elf_kernel)
 828         {
 829           grub_err_t err;
 830           grub_uint64_t data = 0;
 831           grub_file_t file;
 832           int len = is_64bit ? 8 : 4;
 833
 834           err = grub_freebsd_add_meta_module (argv[0], is_64bit
 835                                               ? FREEBSD_MODTYPE_KERNEL64
 836                                               : FREEBSD_MODTYPE_KERNEL,
 837                                               argc - 1, argv + 1,
 838                                               kern_start,
 839                                               kern_end - kern_start);
 840           if (err)
 841             return err;
 842
 843           file = grub_gzfile_open (argv[0], 1);
 844           if (! file)
 845             return grub_errno;
 846
 847           if (is_64bit)
 848             err = grub_freebsd_load_elf_meta64 (file, &kern_end);
 849           else
 850             err = grub_freebsd_load_elf_meta32 (file, &kern_end);
 851           if (err)
 852             return err;
 853
 854           err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
 855                                        FREEBSD_MODINFOMD_HOWTO, &data, 4);
 856           if (err)
 857             return err;
 858
 859           err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
 860                                        FREEBSD_MODINFOMD_ENVP, &data, len);
 861           if (err)
 862             return err;
 863
 864           err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
 865                                        FREEBSD_MODINFOMD_KERNEND, &data, len);
 866           if (err)
 867             return err;
 868
 869           kern_end_mdofs = mod_buf_len - len;
 870
 871           err = grub_freebsd_add_mmap ();
 872           if (err)
 873             return err;
 874         }
 875       grub_loader_set (grub_freebsd_boot, grub_bsd_unload, 1);
 876     }
 877
 878   return grub_errno;
 879 }
 880
 881 static grub_err_t
 882 grub_cmd_openbsd (grub_command_t cmd __attribute__ ((unused)),
 883                   int argc, char *argv[])
 884 {
 885   kernel_type = KERNEL_TYPE_OPENBSD;
 886   bootflags = ((argc <= 1) ? 0 :
 887                grub_bsd_parse_flags (argv[1], openbsd_opts, openbsd_flags));
 888
 889   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 890     grub_loader_set (grub_openbsd_boot, grub_bsd_unload, 1);
 891
 892   return grub_errno;
 893 }
 894
 895 static grub_err_t
 896 grub_cmd_netbsd (grub_command_t cmd __attribute__ ((unused)),
 897                  int argc, char *argv[])
 898 {
 899   kernel_type = KERNEL_TYPE_NETBSD;
 900   bootflags = ((argc <= 1) ? 0 :
 901                grub_bsd_parse_flags (argv[1], netbsd_opts, netbsd_flags));
 902
 903   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 904     grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 1);
 905
 906   return grub_errno;
 907 }
 908
 909 static grub_err_t
 910 grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
 911                           int argc, char *argv[])
 912 {
 913   grub_file_t file = 0;
 914   char *buf = 0, *curr, *next;
 915   int len;
 916
 917   if (kernel_type != KERNEL_TYPE_FREEBSD)
 918     return grub_error (GRUB_ERR_BAD_ARGUMENT,
 919                        "only freebsd support environment");
 920
 921   if (argc == 0)
 922     {
 923       grub_error (GRUB_ERR_BAD_ARGUMENT, "no filename");
 924       goto fail;
 925     }
 926
 927   file = grub_gzfile_open (argv[0], 1);
 928   if ((!file) || (!file->size))
 929     goto fail;
 930
 931   len = file->size;
 932   buf = grub_malloc (len + 1);
 933   if (!buf)
 934     goto fail;
 935
 936   if (grub_file_read (file, buf, len) != len)
 937     goto fail;
 938
 939   buf[len] = 0;
 940
 941   next = buf;
 942   while (next)
 943     {
 944       char *p;
 945
 946       curr = next;
 947       next = grub_strchr (curr, '\n');
 948       if (next)
 949         {
 950
 951           p = next - 1;
 952           while (p > curr)
 953             {
 954               if ((*p != '\r') && (*p != ' ') && (*p != '\t'))
 955                 break;
 956               p--;
 957             }
 958
 959           if ((p > curr) && (*p == '"'))
 960             p--;
 961
 962           *(p + 1) = 0;
 963           next++;
 964         }
 965
 966       if (*curr == '#')
 967         continue;
 968
 969       p = grub_strchr (curr, '=');
 970       if (!p)
 971         continue;
 972
 973       *(p++) = 0;
 974
 975       if (*curr)
 976         {
 977           char name[grub_strlen (curr) + 8 + 1];
 978
 979           if (*p == '"')
 980             p++;
 981
 982           grub_sprintf (name, "FreeBSD.%s", curr);
 983           if (grub_env_set (name, p))
 984             goto fail;
 985         }
 986     }
 987
 988 fail:
 989   grub_free (buf);
 990
 991   if (file)
 992     grub_file_close (file);
 993
 994   return grub_errno;
 995 }
 996
 997 static grub_err_t
 998 grub_cmd_freebsd_module (grub_command_t cmd __attribute__ ((unused)),
 999                          int argc, char *argv[])
1000 {
1001   grub_file_t file = 0;
1002   grub_err_t err;
1003   int modargc;
1004   char **modargv;
1005   char *type;
1006
1007   if (kernel_type != KERNEL_TYPE_FREEBSD)
1008     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1009                        "only freebsd support module");
1010
1011   if (!is_elf_kernel)
1012     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1013                        "only elf kernel support module");
1014
1015   /* List the current modules if no parameter.  */
1016   if (!argc)
1017     {
1018       grub_freebsd_list_modules ();
1019       return 0;
1020     }
1021
1022   file = grub_gzfile_open (argv[0], 1);
1023   if ((!file) || (!file->size))
1024     goto fail;
1025
1026   if (kern_end + file->size > grub_os_area_addr + grub_os_area_size)
1027     {
1028       grub_error (GRUB_ERR_OUT_OF_RANGE, "Not enough memory for the module");
1029       goto fail;
1030     }
1031
1032   grub_file_read (file, (void *) kern_end, file->size);
1033   if (grub_errno)
1034     goto fail;
1035
1036   modargc = argc - 1;
1037   modargv = argv + 1;
1038
1039   if (modargc && (! grub_memcmp (modargv[0], "type=", 5)))
1040     {
1041       type = &modargv[0][5];
1042       modargc--;
1043       modargv++;
1044     }
1045   else
1046     type = FREEBSD_MODTYPE_RAW;
1047
1048   err = grub_freebsd_add_meta_module (argv[0], type, modargc, modargv,
1049                                       kern_end, file->size);
1050   if (err)
1051     goto fail;
1052
1053   kern_end = ALIGN_PAGE (kern_end + file->size);
1054
1055 fail:
1056   if (file)
1057     grub_file_close (file);
1058
1059   return grub_errno;
1060 }
1061
1062 static grub_err_t
1063 grub_cmd_freebsd_module_elf (grub_command_t cmd __attribute__ ((unused)),
1064                              int argc, char *argv[])
1065 {
1066   grub_file_t file = 0;
1067   grub_err_t err;
1068
1069   if (kernel_type != KERNEL_TYPE_FREEBSD)
1070     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1071                        "only freebsd support module");
1072
1073   if (! is_elf_kernel)
1074     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1075                        "only elf kernel support module");
1076
1077   /* List the current modules if no parameter.  */
1078   if (! argc)
1079     {
1080       grub_freebsd_list_modules ();
1081       return 0;
1082     }
1083
1084   file = grub_gzfile_open (argv[0], 1);
1085   if (!file)
1086     return grub_errno;
1087   if (!file->size)
1088     {
1089       grub_file_close (file);
1090       return grub_errno;
1091     }
1092
1093   if (is_64bit)
1094     err = grub_freebsd_load_elfmodule_obj64 (file, argc, argv, &kern_end);
1095   else
1096     err = grub_freebsd_load_elfmodule32 (file, argc, argv, &kern_end);
1097   grub_file_close (file);
1098
1099   return err;
1100 }
1101
1102
1103 static grub_command_t cmd_freebsd, cmd_openbsd, cmd_netbsd;
1104 static grub_command_t cmd_freebsd_loadenv, cmd_freebsd_module;
1105 static grub_command_t cmd_freebsd_module_elf;
1106
1107 GRUB_MOD_INIT (bsd)
1108 {
1109   cmd_freebsd =
1110     grub_register_command ("freebsd", grub_cmd_freebsd,
1111                            0, "load freebsd kernel");
1112   cmd_openbsd =
1113     grub_register_command ("openbsd", grub_cmd_openbsd,
1114                            0, "load openbsd kernel");
1115   cmd_netbsd =
1116     grub_register_command ("netbsd", grub_cmd_netbsd,
1117                            0, "load netbsd kernel");
1118   cmd_freebsd_loadenv =
1119     grub_register_command ("freebsd_loadenv", grub_cmd_freebsd_loadenv,
1120                            0, "load freebsd env");
1121   cmd_freebsd_module =
1122     grub_register_command ("freebsd_module", grub_cmd_freebsd_module,
1123                            0, "load freebsd module");
1124   cmd_freebsd_module_elf =
1125     grub_register_command ("freebsd_module_elf", grub_cmd_freebsd_module_elf,
1126                            0, "load freebsd ELF module");
1127
1128   my_mod = mod;
1129 }
1130
1131 GRUB_MOD_FINI (bsd)
1132 {
1133   grub_unregister_command (cmd_freebsd);
1134   grub_unregister_command (cmd_openbsd);
1135   grub_unregister_command (cmd_netbsd);
1136
1137   grub_unregister_command (cmd_freebsd_loadenv);
1138   grub_unregister_command (cmd_freebsd_module);
1139   grub_unregister_command (cmd_freebsd_module_elf);
1140
1141   if (mod_buf)
1142     {
1143       grub_free (mod_buf);
1144       mod_buf = 0;
1145       mod_buf_max = 0;
1146     }
1147 }