grub-core/loader/i386/bsd.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2008,2009,2010  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/i386/bsd.h>
  21 #include <grub/i386/cpuid.h>
  22 #include <grub/memory.h>
  23 #include <grub/i386/memory.h>
  24 #include <grub/file.h>
  25 #include <grub/err.h>
  26 #include <grub/dl.h>
  27 #include <grub/mm.h>
  28 #include <grub/elfload.h>
  29 #include <grub/env.h>
  30 #include <grub/misc.h>
  31 #include <grub/aout.h>
  32 #include <grub/command.h>
  33 #include <grub/extcmd.h>
  34 #include <grub/i18n.h>
  35 #include <grub/ns8250.h>
  36 #include <grub/bsdlabel.h>
  37 #include <grub/crypto.h>
  38 #ifdef GRUB_MACHINE_PCBIOS
  39 #include <grub/machine/int.h>
  40 #endif
  41
  42 GRUB_MOD_LICENSE ("GPLv3+");
  43
  44 #include <grub/video.h>
  45 #ifdef GRUB_MACHINE_PCBIOS
  46 #include <grub/machine/biosnum.h>
  47 #endif
  48 #ifdef GRUB_MACHINE_EFI
  49 #include <grub/efi/efi.h>
  50 #define NETBSD_DEFAULT_VIDEO_MODE "800x600"
  51 #else
  52 #define NETBSD_DEFAULT_VIDEO_MODE "text"
  53 #include <grub/i386/pc/vbe.h>
  54 #endif
  55 #include <grub/video.h>
  56
  57 #include <grub/disk.h>
  58 #include <grub/device.h>
  59 #include <grub/partition.h>
  60 #include <grub/relocator.h>
  61 #include <grub/i386/relocator.h>
  62
  63 #define ALIGN_DWORD(a)  ALIGN_UP (a, 4)
  64 #define ALIGN_QWORD(a)  ALIGN_UP (a, 8)
  65 #define ALIGN_VAR(a)    ((is_64bit) ? (ALIGN_QWORD(a)) : (ALIGN_DWORD(a)))
  66 #define ALIGN_PAGE(a)   ALIGN_UP (a, 4096)
  67
  68 static int kernel_type = KERNEL_TYPE_NONE;
  69 static grub_dl_t my_mod;
  70 static grub_addr_t entry, entry_hi, kern_start, kern_end;
  71 static void *kern_chunk_src;
  72 static grub_uint32_t bootflags;
  73 static int is_elf_kernel, is_64bit;
  74 static grub_uint32_t openbsd_root;
  75 static struct grub_relocator *relocator = NULL;
  76 static struct grub_openbsd_ramdisk_descriptor openbsd_ramdisk;
  77
  78 struct bsd_tag
  79 {
  80   struct bsd_tag *next;
  81   grub_size_t len;
  82   grub_uint32_t type;
  83   union {
  84     grub_uint8_t a;
  85     grub_uint16_t b;
  86     grub_uint32_t c;
  87   } data[0];
  88 };
  89
  90 static struct bsd_tag *tags, *tags_last;
  91
  92 struct netbsd_module
  93 {
  94   struct netbsd_module *next;
  95   struct grub_netbsd_btinfo_module mod;
  96 };
  97
  98 static struct netbsd_module *netbsd_mods, *netbsd_mods_last;
  99
 100 static const struct grub_arg_option freebsd_opts[] =
 101   {
 102     {"dual", 'D', 0, N_("Display output on all consoles."), 0, 0},
 103     {"serial", 'h', 0, N_("Use serial console."), 0, 0},
 104     {"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
 105     {"cdrom", 'C', 0, N_("Use CD-ROM as root."), 0, 0},
 106     {"config", 'c', 0, N_("Invoke user configuration routing."), 0, 0},
 107     {"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
 108     {"gdb", 'g', 0, N_("Use GDB remote debugger instead of DDB."), 0, 0},
 109     {"mute", 'm', 0, N_("Disable all boot output."), 0, 0},
 110     {"nointr", 'n', 0, "", 0, 0},
 111     {"pause", 'p', 0, N_("Wait for keypress after every line of output."), 0, 0},
 112     {"quiet", 'q', 0, "", 0, 0},
 113     {"dfltroot", 'r', 0, N_("Use compiled-in root device."), 0, 0},
 114     {"single", 's', 0, N_("Boot into single mode."), 0, 0},
 115     {"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
 116     {0, 0, 0, 0, 0, 0}
 117   };
 118
 119 static const grub_uint32_t freebsd_flags[] =
 120 {
 121   FREEBSD_RB_DUAL, FREEBSD_RB_SERIAL, FREEBSD_RB_ASKNAME,
 122   FREEBSD_RB_CDROM, FREEBSD_RB_CONFIG, FREEBSD_RB_KDB,
 123   FREEBSD_RB_GDB, FREEBSD_RB_MUTE, FREEBSD_RB_NOINTR,
 124   FREEBSD_RB_PAUSE, FREEBSD_RB_QUIET, FREEBSD_RB_DFLTROOT,
 125   FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE, 0
 126 };
 127
 128 static const struct grub_arg_option openbsd_opts[] =
 129   {
 130     {"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
 131     {"halt", 'b', 0, N_("Don't reboot, just halt."), 0, 0},
 132     {"config", 'c', 0, N_("Change configured devices."), 0, 0},
 133     {"single", 's', 0, N_("Boot into single mode."), 0, 0},
 134     {"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
 135     {"root", 'r', 0, N_("Set root device."), "wdXY", ARG_TYPE_STRING},
 136     {"serial", 'h', GRUB_ARG_OPTION_OPTIONAL,
 137      N_("Use serial console."),
 138      /* TRANSLATORS: "com" is static and not to be translated. It refers to
 139         serial ports e.g. com1.
 140       */
 141      N_("comUNIT[,SPEED]"), ARG_TYPE_STRING},
 142     {0, 0, 0, 0, 0, 0}
 143   };
 144
 145 static const grub_uint32_t openbsd_flags[] =
 146 {
 147   OPENBSD_RB_ASKNAME, OPENBSD_RB_HALT, OPENBSD_RB_CONFIG,
 148   OPENBSD_RB_SINGLE, OPENBSD_RB_KDB, 0
 149 };
 150
 151 #define OPENBSD_ROOT_ARG (ARRAY_SIZE (openbsd_flags) - 1)
 152 #define OPENBSD_SERIAL_ARG (ARRAY_SIZE (openbsd_flags))
 153
 154 static const struct grub_arg_option netbsd_opts[] =
 155   {
 156     {"no-smp", '1', 0, N_("Disable SMP."), 0, 0},
 157     {"no-acpi", '2', 0, N_("Disable ACPI."), 0, 0},
 158     {"askname", 'a', 0, N_("Ask for file name to reboot from."), 0, 0},
 159     {"halt", 'b', 0, N_("Don't reboot, just halt."), 0, 0},
 160     {"config", 'c', 0, N_("Change configured devices."), 0, 0},
 161     {"kdb", 'd', 0, N_("Enter in KDB on boot."), 0, 0},
 162     {"miniroot", 'm', 0, "", 0, 0},
 163     {"quiet", 'q', 0, N_("Don't display boot diagnostic messages."), 0, 0},
 164     {"single", 's', 0, N_("Boot into single mode."), 0, 0},
 165     {"verbose", 'v', 0, N_("Boot with verbose messages."), 0, 0},
 166     {"debug", 'x', 0, N_("Boot with debug messages."), 0, 0},
 167     {"silent", 'z', 0, N_("Suppress normal output (warnings remain)."), 0, 0},
 168     {"root", 'r', 0, N_("Set root device."), N_("DEVICE"), ARG_TYPE_STRING},
 169     {"serial", 'h', GRUB_ARG_OPTION_OPTIONAL,
 170      N_("Use serial console."),
 171      /* TRANSLATORS: "com" is static and not to be translated. It refers to
 172         serial ports e.g. com1.
 173       */
 174      N_("[ADDR|comUNIT][,SPEED]"), ARG_TYPE_STRING},
 175     {0, 0, 0, 0, 0, 0}
 176   };
 177
 178 static const grub_uint32_t netbsd_flags[] =
 179 {
 180   NETBSD_AB_NOSMP, NETBSD_AB_NOACPI, NETBSD_RB_ASKNAME,
 181   NETBSD_RB_HALT, NETBSD_RB_USERCONFIG, NETBSD_RB_KDB,
 182   NETBSD_RB_MINIROOT, NETBSD_AB_QUIET, NETBSD_RB_SINGLE,
 183   NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG, NETBSD_AB_SILENT, 0
 184 };
 185
 186 #define NETBSD_ROOT_ARG (ARRAY_SIZE (netbsd_flags) - 1)
 187 #define NETBSD_SERIAL_ARG (ARRAY_SIZE (netbsd_flags))
 188
 189 static void
 190 grub_bsd_get_device (grub_uint32_t * biosdev,
 191                      grub_uint32_t * unit,
 192                      grub_uint32_t * slice, grub_uint32_t * part)
 193 {
 194   grub_device_t dev;
 195
 196 #ifdef GRUB_MACHINE_PCBIOS
 197   *biosdev = grub_get_root_biosnumber () & 0xff;
 198 #else
 199   *biosdev = 0xff;
 200 #endif
 201   *unit = (*biosdev & 0x7f);
 202   *slice = 0xff;
 203   *part = 0xff;
 204   dev = grub_device_open (0);
 205   if (dev && dev->disk && dev->disk->partition)
 206     {
 207       if (dev->disk->partition->parent)
 208         {
 209           *part = dev->disk->partition->number;
 210           *slice = dev->disk->partition->parent->number + 1;
 211         }
 212       else
 213         *slice = dev->disk->partition->number + 1;
 214     }
 215   if (dev)
 216     grub_device_close (dev);
 217 }
 218
 219 static grub_err_t
 220 grub_bsd_add_meta_ptr (grub_uint32_t type, void **ptr, grub_uint32_t len)
 221 {
 222   struct bsd_tag *newtag;
 223
 224   newtag = grub_malloc (len + sizeof (struct bsd_tag));
 225   if (!newtag)
 226     return grub_errno;
 227   newtag->len = len;
 228   newtag->type = type;
 229   newtag->next = NULL;
 230   *ptr = newtag->data;
 231
 232   if (kernel_type == KERNEL_TYPE_FREEBSD
 233       && type == (FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_SMAP))
 234     {
 235       struct bsd_tag *p;
 236       for (p = tags;
 237            p && p->type != (FREEBSD_MODINFO_METADATA
 238                             | FREEBSD_MODINFOMD_KERNEND);
 239            p = p->next);
 240
 241       if (p)
 242         {
 243           newtag->next = p->next;
 244           p->next = newtag;
 245           if (newtag->next == NULL)
 246             tags_last = newtag;
 247           return GRUB_ERR_NONE;
 248         }
 249     }
 250
 251   if (tags_last)
 252     tags_last->next = newtag;
 253   else
 254     tags = newtag;
 255   tags_last = newtag;
 256
 257   return GRUB_ERR_NONE;
 258 }
 259
 260 grub_err_t
 261 grub_bsd_add_meta (grub_uint32_t type, const void *data, grub_uint32_t len)
 262 {
 263   grub_err_t err;
 264   void *ptr;
 265
 266   err = grub_bsd_add_meta_ptr (type, &ptr, len);
 267   if (err)
 268     return err;
 269   if (len)
 270     grub_memcpy (ptr, data, len);
 271   return GRUB_ERR_NONE;
 272 }
 273
 274
 275 struct grub_e820_mmap
 276 {
 277   grub_uint64_t addr;
 278   grub_uint64_t size;
 279   grub_uint32_t type;
 280 } GRUB_PACKED;
 281 #define GRUB_E820_RAM        1
 282 #define GRUB_E820_RESERVED   2
 283 #define GRUB_E820_ACPI       3
 284 #define GRUB_E820_NVS        4
 285 #define GRUB_E820_BADRAM     5
 286 #define GRUB_E820_COREBOOT_TABLES 0x10
 287
 288 /* Context for generate_e820_mmap.  */
 289 struct generate_e820_mmap_ctx
 290 {
 291   int count;
 292   struct grub_e820_mmap *mmap;
 293   struct grub_e820_mmap prev, cur;
 294 };
 295
 296 /* Helper for generate_e820_mmap.  */
 297 static int
 298 generate_e820_mmap_iter (grub_uint64_t addr, grub_uint64_t size,
 299                          grub_memory_type_t type, void *data)
 300 {
 301   struct generate_e820_mmap_ctx *ctx = data;
 302
 303   ctx->cur.addr = addr;
 304   ctx->cur.size = size;
 305
 306   if (type == GRUB_MEMORY_COREBOOT_TABLES
 307       && addr == 0)
 308       /* Nowadays the tables at 0 don't contain anything important but
 309        *BSD needs the memory at 0 for own needs.
 310        */
 311     type = GRUB_E820_RAM;
 312
 313   ctx->cur.type = type;
 314
 315   /* Merge regions if possible. */
 316   if (ctx->count && ctx->cur.type == ctx->prev.type
 317       && ctx->cur.addr == ctx->prev.addr + ctx->prev.size)
 318     {
 319       ctx->prev.size += ctx->cur.size;
 320       if (ctx->mmap)
 321         ctx->mmap[-1] = ctx->prev;
 322     }
 323   else
 324     {
 325       if (ctx->mmap)
 326         *ctx->mmap++ = ctx->cur;
 327       ctx->prev = ctx->cur;
 328       ctx->count++;
 329     }
 330
 331   if (kernel_type == KERNEL_TYPE_OPENBSD && ctx->prev.addr < 0x100000
 332       && ctx->prev.addr + ctx->prev.size > 0x100000)
 333     {
 334       ctx->cur.addr = 0x100000;
 335       ctx->cur.size = ctx->prev.addr + ctx->prev.size - 0x100000;
 336       ctx->cur.type = ctx->prev.type;
 337       ctx->prev.size = 0x100000 - ctx->prev.addr;
 338       if (ctx->mmap)
 339         {
 340           ctx->mmap[-1] = ctx->prev;
 341           ctx->mmap[0] = ctx->cur;
 342           ctx->mmap++;
 343         }
 344       ctx->prev = ctx->cur;
 345       ctx->count++;
 346     }
 347
 348   return 0;
 349 }
 350
 351 static void
 352 generate_e820_mmap (grub_size_t *len, grub_size_t *cnt, void *buf)
 353 {
 354   struct generate_e820_mmap_ctx ctx = {
 355     .count = 0,
 356     .mmap = buf
 357   };
 358
 359   grub_mmap_iterate (generate_e820_mmap_iter, &ctx);
 360
 361   if (len)
 362     *len = ctx.count * sizeof (struct grub_e820_mmap);
 363   *cnt = ctx.count;
 364
 365   return;
 366 }
 367
 368 static grub_err_t
 369 grub_bsd_add_mmap (void)
 370 {
 371   grub_size_t len, cnt;
 372   void *buf = NULL, *buf0;
 373
 374   generate_e820_mmap (&len, &cnt, buf);
 375
 376   if (kernel_type == KERNEL_TYPE_NETBSD)
 377     len += sizeof (grub_uint32_t);
 378
 379   if (kernel_type == KERNEL_TYPE_OPENBSD)
 380     len += sizeof (struct grub_e820_mmap);
 381
 382   buf = grub_malloc (len);
 383   if (!buf)
 384     return grub_errno;
 385
 386   buf0 = buf;
 387   if (kernel_type == KERNEL_TYPE_NETBSD)
 388     {
 389       *(grub_uint32_t *) buf = cnt;
 390       buf = ((grub_uint32_t *) buf + 1);
 391     }
 392
 393   generate_e820_mmap (NULL, &cnt, buf);
 394
 395   if (kernel_type == KERNEL_TYPE_OPENBSD)
 396     grub_memset ((grub_uint8_t *) buf + len - sizeof (struct grub_e820_mmap), 0,
 397                  sizeof (struct grub_e820_mmap));
 398
 399   grub_dprintf ("bsd", "%u entries in smap\n", (unsigned) cnt);
 400   if (kernel_type == KERNEL_TYPE_NETBSD)
 401     grub_bsd_add_meta (NETBSD_BTINFO_MEMMAP, buf0, len);
 402   else if (kernel_type == KERNEL_TYPE_OPENBSD)
 403     grub_bsd_add_meta (OPENBSD_BOOTARG_MMAP, buf0, len);
 404   else
 405     grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
 406                        FREEBSD_MODINFOMD_SMAP, buf0, len);
 407
 408   grub_free (buf0);
 409
 410   return grub_errno;
 411 }
 412
 413 grub_err_t
 414 grub_freebsd_add_meta_module (const char *filename, const char *type,
 415                               int argc, char **argv,
 416                               grub_addr_t addr, grub_uint32_t size)
 417 {
 418   const char *name;
 419   name = grub_strrchr (filename, '/');
 420   if (name)
 421     name++;
 422   else
 423     name = filename;
 424   if (grub_strcmp (type, "/boot/zfs/zpool.cache") == 0)
 425     name = "/boot/zfs/zpool.cache";
 426
 427   if (grub_bsd_add_meta (FREEBSD_MODINFO_NAME, name, grub_strlen (name) + 1))
 428     return grub_errno;
 429
 430   if (is_64bit)
 431     {
 432       grub_uint64_t addr64 = addr, size64 = size;
 433       if (grub_bsd_add_meta (FREEBSD_MODINFO_TYPE, type, grub_strlen (type) + 1)
 434           || grub_bsd_add_meta (FREEBSD_MODINFO_ADDR, &addr64, sizeof (addr64))
 435           || grub_bsd_add_meta (FREEBSD_MODINFO_SIZE, &size64, sizeof (size64)))
 436         return grub_errno;
 437     }
 438   else
 439     {
 440       if (grub_bsd_add_meta (FREEBSD_MODINFO_TYPE, type, grub_strlen (type) + 1)
 441           || grub_bsd_add_meta (FREEBSD_MODINFO_ADDR, &addr, sizeof (addr))
 442           || grub_bsd_add_meta (FREEBSD_MODINFO_SIZE, &size, sizeof (size)))
 443         return grub_errno;
 444     }
 445
 446   if (argc)
 447     {
 448       int i, n;
 449
 450       n = 0;
 451       for (i = 0; i < argc; i++)
 452         {
 453           n += grub_strlen (argv[i]) + 1;
 454         }
 455
 456       if (n)
 457         {
 458           void *cmdline;
 459           char *p;
 460
 461           if (grub_bsd_add_meta_ptr (FREEBSD_MODINFO_ARGS, &cmdline, n))
 462             return grub_errno;
 463
 464           p = cmdline;
 465           for (i = 0; i < argc; i++)
 466             {
 467               grub_strcpy (p, argv[i]);
 468               p += grub_strlen (argv[i]);
 469               *(p++) = ' ';
 470             }
 471           *p = 0;
 472         }
 473     }
 474
 475   return GRUB_ERR_NONE;
 476 }
 477
 478 static void
 479 grub_freebsd_list_modules (void)
 480 {
 481   struct bsd_tag *tag;
 482
 483   grub_printf ("  %-18s  %-18s%14s%14s\n", _("name"), _("type"), _("addr"),
 484                _("size"));
 485
 486   for (tag = tags; tag; tag = tag->next)
 487     {
 488       switch (tag->type)
 489         {
 490         case FREEBSD_MODINFO_NAME:
 491         case FREEBSD_MODINFO_TYPE:
 492           grub_printf ("  %-18s", (char *) tag->data);
 493           break;
 494         case FREEBSD_MODINFO_ADDR:
 495           {
 496             grub_uint32_t addr;
 497
 498             addr = *((grub_uint32_t *) tag->data);
 499             grub_printf ("    0x%08x", addr);
 500             break;
 501           }
 502         case FREEBSD_MODINFO_SIZE:
 503           {
 504             grub_uint32_t len;
 505
 506             len = *((grub_uint32_t *) tag->data);
 507             grub_printf ("    0x%08x\n", len);
 508           }
 509         }
 510     }
 511 }
 512
 513 static grub_err_t
 514 grub_netbsd_add_meta_module (char *filename, grub_uint32_t type,
 515                              grub_addr_t addr, grub_uint32_t size)
 516 {
 517   char *name;
 518   struct netbsd_module *mod;
 519   name = grub_strrchr (filename, '/');
 520
 521   if (name)
 522     name++;
 523   else
 524     name = filename;
 525
 526   mod = grub_zalloc (sizeof (*mod));
 527   if (!mod)
 528     return grub_errno;
 529
 530   grub_strncpy (mod->mod.name, name, sizeof (mod->mod.name) - 1);
 531   mod->mod.addr = addr;
 532   mod->mod.type = type;
 533   mod->mod.size = size;
 534
 535   if (netbsd_mods_last)
 536     netbsd_mods_last->next = mod;
 537   else
 538     netbsd_mods = mod;
 539   netbsd_mods_last = mod;
 540
 541   return GRUB_ERR_NONE;
 542 }
 543
 544 static void
 545 grub_netbsd_list_modules (void)
 546 {
 547   struct netbsd_module *mod;
 548
 549   grub_printf ("  %-18s%14s%14s%14s\n", _("name"), _("type"), _("addr"),
 550                _("size"));
 551
 552   for (mod = netbsd_mods; mod; mod = mod->next)
 553     grub_printf ("  %-18s  0x%08x  0x%08x  0x%08x", mod->mod.name,
 554                  mod->mod.type, mod->mod.addr, mod->mod.size);
 555 }
 556
 557 /* This function would be here but it's under different license. */
 558 #include "bsd_pagetable.c"
 559
 560 static grub_uint32_t freebsd_bootdev, freebsd_biosdev;
 561 static grub_uint64_t freebsd_zfsguid;
 562
 563 static void
 564 freebsd_get_zfs (void)
 565 {
 566   grub_device_t dev;
 567   grub_fs_t fs;
 568   char *uuid;
 569   grub_err_t err;
 570
 571   dev = grub_device_open (0);
 572   if (!dev)
 573     return;
 574   fs = grub_fs_probe (dev);
 575   if (!fs)
 576     return;
 577   if (!fs->uuid || grub_strcmp (fs->name, "zfs") != 0)
 578     return;
 579   err = fs->uuid (dev, &uuid);
 580   if (err)
 581     return;
 582   if (!uuid)
 583     return;
 584   freebsd_zfsguid = grub_strtoull (uuid, 0, 16);
 585   grub_free (uuid);
 586 }
 587
 588 static grub_err_t
 589 grub_freebsd_boot (void)
 590 {
 591   struct grub_freebsd_bootinfo bi;
 592   grub_uint8_t *p, *p0;
 593   grub_addr_t p_target;
 594   grub_size_t p_size = 0;
 595   grub_err_t err;
 596   grub_size_t tag_buf_len = 0;
 597
 598   struct grub_env_var *var;
 599
 600   grub_memset (&bi, 0, sizeof (bi));
 601   bi.version = FREEBSD_BOOTINFO_VERSION;
 602   bi.length = sizeof (bi);
 603
 604   bi.boot_device = freebsd_biosdev;
 605
 606   p_size = 0;
 607   FOR_SORTED_ENV (var)
 608     if ((grub_memcmp (var->name, "kFreeBSD.", sizeof("kFreeBSD.") - 1) == 0) && (var->name[sizeof("kFreeBSD.") - 1]))
 609       {
 610         p_size += grub_strlen (&var->name[sizeof("kFreeBSD.") - 1]);
 611         p_size++;
 612         p_size += grub_strlen (var->value) + 1;
 613       }
 614
 615   if (p_size)
 616     p_size = ALIGN_PAGE (kern_end + p_size + 1) - kern_end;
 617
 618   if (is_elf_kernel)
 619     {
 620       struct bsd_tag *tag;
 621
 622       err = grub_bsd_add_mmap ();
 623       if (err)
 624         return err;
 625
 626       err = grub_bsd_add_meta (FREEBSD_MODINFO_END, 0, 0);
 627       if (err)
 628         return err;
 629
 630       tag_buf_len = 0;
 631       for (tag = tags; tag; tag = tag->next)
 632         tag_buf_len = ALIGN_VAR (tag_buf_len
 633                                  + sizeof (struct freebsd_tag_header)
 634                                  + tag->len);
 635       p_size = ALIGN_PAGE (kern_end + p_size + tag_buf_len) - kern_end;
 636     }
 637
 638   if (is_64bit)
 639     p_size += 4096 * 3;
 640
 641   {
 642     grub_relocator_chunk_t ch;
 643     err = grub_relocator_alloc_chunk_addr (relocator, &ch,
 644                                            kern_end, p_size);
 645     if (err)
 646       return err;
 647     p = get_virtual_current_address (ch);
 648   }
 649   p_target = kern_end;
 650   p0 = p;
 651   kern_end += p_size;
 652
 653   FOR_SORTED_ENV (var)
 654     if ((grub_memcmp (var->name, "kFreeBSD.", sizeof("kFreeBSD.") - 1) == 0) && (var->name[sizeof("kFreeBSD.") - 1]))
 655       {
 656         grub_strcpy ((char *) p, &var->name[sizeof("kFreeBSD.") - 1]);
 657         p += grub_strlen ((char *) p);
 658         *(p++) = '=';
 659         grub_strcpy ((char *) p, var->value);
 660         p += grub_strlen ((char *) p) + 1;
 661       }
 662
 663   if (p != p0)
 664     {
 665       *(p++) = 0;
 666
 667       bi.environment = p_target;
 668     }
 669
 670   if (is_elf_kernel)
 671     {
 672       grub_uint8_t *p_tag = p;
 673       struct bsd_tag *tag;
 674
 675       for (tag = tags; tag; tag = tag->next)
 676         {
 677           struct freebsd_tag_header *head
 678             = (struct freebsd_tag_header *) p_tag;
 679           head->type = tag->type;
 680           head->len = tag->len;
 681           p_tag += sizeof (struct freebsd_tag_header);
 682           switch (tag->type)
 683             {
 684             case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_HOWTO:
 685               if (is_64bit)
 686                 *(grub_uint64_t *) p_tag = bootflags;
 687               else
 688                 *(grub_uint32_t *) p_tag = bootflags;
 689               break;
 690
 691             case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_ENVP:
 692               if (is_64bit)
 693                 *(grub_uint64_t *) p_tag = bi.environment;
 694               else
 695                 *(grub_uint32_t *) p_tag = bi.environment;
 696               break;
 697
 698             case FREEBSD_MODINFO_METADATA | FREEBSD_MODINFOMD_KERNEND:
 699               if (is_64bit)
 700                 *(grub_uint64_t *) p_tag = kern_end;
 701               else
 702                 *(grub_uint32_t *) p_tag = kern_end;
 703               break;
 704
 705             default:
 706               grub_memcpy (p_tag, tag->data, tag->len);
 707               break;
 708             }
 709           p_tag += tag->len;
 710           p_tag = ALIGN_VAR (p_tag - p) + p;
 711         }
 712
 713       bi.tags = (p - p0) + p_target;
 714
 715       p = (ALIGN_PAGE ((p_tag - p0) + p_target) - p_target) + p0;
 716     }
 717
 718   bi.kern_end = kern_end;
 719
 720   grub_video_set_mode ("text", 0, 0);
 721
 722   if (is_64bit)
 723     {
 724       struct grub_relocator64_state state;
 725       grub_uint8_t *pagetable;
 726       grub_uint32_t *stack;
 727       grub_addr_t stack_target;
 728
 729       {
 730         grub_relocator_chunk_t ch;
 731         err = grub_relocator_alloc_chunk_align (relocator, &ch,
 732                                                 0x10000, 0x90000,
 733                                                 3 * sizeof (grub_uint32_t)
 734                                                 + sizeof (bi), 4,
 735                                                 GRUB_RELOCATOR_PREFERENCE_NONE,
 736                                                 0);
 737         if (err)
 738           return err;
 739         stack = get_virtual_current_address (ch);
 740         stack_target = get_physical_target_address (ch);
 741       }
 742
 743 #ifdef GRUB_MACHINE_EFI
 744       err = grub_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
 745       if (err)
 746         return err;
 747 #endif
 748
 749       pagetable = p;
 750       fill_bsd64_pagetable (pagetable, (pagetable - p0) + p_target);
 751
 752       state.cr3 = (pagetable - p0) + p_target;
 753       state.rsp = stack_target;
 754       state.rip = (((grub_uint64_t) entry_hi) << 32) | entry;
 755
 756       stack[0] = entry;
 757       stack[1] = bi.tags;
 758       stack[2] = kern_end;
 759       return grub_relocator64_boot (relocator, state, 0, 0x40000000);
 760     }
 761   else
 762     {
 763       struct grub_relocator32_state state;
 764       grub_uint32_t *stack;
 765       grub_addr_t stack_target;
 766
 767       {
 768         grub_relocator_chunk_t ch;
 769         err = grub_relocator_alloc_chunk_align (relocator, &ch,
 770                                                 0x10000, 0x90000,
 771                                                 9 * sizeof (grub_uint32_t)
 772                                                 + sizeof (bi), 4,
 773                                                 GRUB_RELOCATOR_PREFERENCE_NONE,
 774                                                 0);
 775         if (err)
 776           return err;
 777         stack = get_virtual_current_address (ch);
 778         stack_target = get_physical_target_address (ch);
 779       }
 780
 781 #ifdef GRUB_MACHINE_EFI
 782       err = grub_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
 783       if (err)
 784         return err;
 785 #endif
 786
 787       grub_memcpy (&stack[9], &bi, sizeof (bi));
 788       state.eip = entry;
 789       state.esp = stack_target;
 790       state.ebp = stack_target;
 791       stack[0] = entry; /* "Return" address.  */
 792       stack[1] = bootflags | FREEBSD_RB_BOOTINFO;
 793       stack[2] = freebsd_bootdev;
 794       stack[3] = freebsd_zfsguid ? 4 : 0;
 795       stack[4] = freebsd_zfsguid;
 796       stack[5] = freebsd_zfsguid >> 32;
 797       stack[6] = stack_target + 9 * sizeof (grub_uint32_t);
 798       stack[7] = bi.tags;
 799       stack[8] = kern_end;
 800       return grub_relocator32_boot (relocator, state, 0);
 801     }
 802
 803   /* Not reached.  */
 804   return GRUB_ERR_NONE;
 805 }
 806
 807 static grub_err_t
 808 grub_openbsd_boot (void)
 809 {
 810   grub_uint32_t *stack;
 811   struct grub_relocator32_state state;
 812   void *curarg, *buf0, *arg0;
 813   grub_addr_t buf_target;
 814   grub_err_t err;
 815   grub_size_t tag_buf_len;
 816
 817   err = grub_bsd_add_mmap ();
 818   if (err)
 819     return err;
 820
 821 #ifdef GRUB_MACHINE_PCBIOS
 822   {
 823     struct grub_bios_int_registers regs;
 824
 825     regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
 826
 827     regs.ebx = 0;
 828     regs.ecx = 0;
 829     regs.eax = 0xb101;
 830     regs.es = 0;
 831     regs.edi = 0;
 832     regs.edx = 0;
 833
 834     grub_bios_interrupt (0x1a, &regs);
 835     if (regs.edx == 0x20494350)
 836       {
 837         struct grub_openbsd_bootarg_pcibios pcibios;
 838
 839         pcibios.characteristics = regs.eax & 0xff;
 840         pcibios.revision = regs.ebx & 0xffff;
 841         pcibios.pm_entry = regs.edi;
 842         pcibios.last_bus = regs.ecx & 0xff;
 843
 844         grub_bsd_add_meta (OPENBSD_BOOTARG_PCIBIOS, &pcibios,
 845                            sizeof (pcibios));
 846       }
 847   }
 848 #endif
 849
 850   {
 851     struct bsd_tag *tag;
 852     tag_buf_len = 0;
 853     for (tag = tags; tag; tag = tag->next)
 854       tag_buf_len = ALIGN_VAR (tag_buf_len
 855                                + sizeof (struct grub_openbsd_bootargs)
 856                                + tag->len);
 857   }
 858
 859   buf_target = GRUB_BSD_TEMP_BUFFER - 9 * sizeof (grub_uint32_t);
 860   {
 861     grub_relocator_chunk_t ch;
 862     err = grub_relocator_alloc_chunk_addr (relocator, &ch, buf_target,
 863                                            tag_buf_len
 864                                            + sizeof (struct grub_openbsd_bootargs)
 865                                            + 9 * sizeof (grub_uint32_t));
 866     if (err)
 867       return err;
 868     buf0 = get_virtual_current_address (ch);
 869   }
 870
 871   stack = (grub_uint32_t *) buf0;
 872   arg0 = curarg = stack + 9;
 873
 874   {
 875     struct bsd_tag *tag;
 876     struct grub_openbsd_bootargs *head;
 877
 878     for (tag = tags; tag; tag = tag->next)
 879       {
 880         head = curarg;
 881         head->ba_type = tag->type;
 882         head->ba_size = tag->len + sizeof (*head);
 883         curarg = head + 1;
 884         grub_memcpy (curarg, tag->data, tag->len);
 885         curarg = (grub_uint8_t *) curarg + tag->len;
 886         head->ba_next = (grub_uint8_t *) curarg - (grub_uint8_t *) buf0
 887           + buf_target;
 888       }
 889     head = curarg;
 890     head->ba_type = OPENBSD_BOOTARG_END;
 891     head->ba_size = 0;
 892     head->ba_next = 0;
 893   }
 894
 895   grub_video_set_mode ("text", 0, 0);
 896
 897 #ifdef GRUB_MACHINE_EFI
 898   err = grub_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
 899   if (err)
 900     return err;
 901 #endif
 902
 903   state.eip = entry;
 904   state.ebp = state.esp
 905     = ((grub_uint8_t *) stack - (grub_uint8_t *) buf0) + buf_target;
 906   stack[0] = entry;
 907   stack[1] = bootflags;
 908   stack[2] = openbsd_root;
 909   stack[3] = OPENBSD_BOOTARG_APIVER;
 910   stack[4] = 0;
 911   stack[5] = grub_mmap_get_upper () >> 10;
 912   stack[6] = grub_mmap_get_lower () >> 10;
 913   stack[7] = (grub_uint8_t *) curarg - (grub_uint8_t *) arg0;
 914   stack[8] = ((grub_uint8_t *) arg0 - (grub_uint8_t *) buf0) + buf_target;
 915
 916   return grub_relocator32_boot (relocator, state, 0);
 917 }
 918
 919 static grub_err_t
 920 grub_netbsd_setup_video (void)
 921 {
 922   struct grub_video_mode_info mode_info;
 923   void *framebuffer;
 924   const char *modevar;
 925   struct grub_netbsd_btinfo_framebuf params;
 926   grub_err_t err;
 927   grub_video_driver_id_t driv_id;
 928
 929   modevar = grub_env_get ("gfxpayload");
 930
 931   /* Now all graphical modes are acceptable.
 932      May change in future if we have modes without framebuffer.  */
 933   if (modevar && *modevar != 0)
 934     {
 935       char *tmp;
 936       tmp = grub_xasprintf ("%s;" NETBSD_DEFAULT_VIDEO_MODE, modevar);
 937       if (! tmp)
 938         return grub_errno;
 939       err = grub_video_set_mode (tmp, 0, 0);
 940       grub_free (tmp);
 941     }
 942   else
 943     err = grub_video_set_mode (NETBSD_DEFAULT_VIDEO_MODE, 0, 0);
 944
 945   if (err)
 946     return err;
 947
 948   driv_id = grub_video_get_driver_id ();
 949   if (driv_id == GRUB_VIDEO_DRIVER_NONE)
 950     return GRUB_ERR_NONE;
 951
 952   err = grub_video_get_info_and_fini (&mode_info, &framebuffer);
 953
 954   if (err)
 955     return err;
 956
 957   params.width = mode_info.width;
 958   params.height = mode_info.height;
 959   params.bpp = mode_info.bpp;
 960   params.pitch = mode_info.pitch;
 961   params.flags = 0;
 962
 963   params.fbaddr = (grub_addr_t) framebuffer;
 964
 965   params.red_mask_size = mode_info.red_mask_size;
 966   params.red_field_pos = mode_info.red_field_pos;
 967   params.green_mask_size = mode_info.green_mask_size;
 968   params.green_field_pos = mode_info.green_field_pos;
 969   params.blue_mask_size = mode_info.blue_mask_size;
 970   params.blue_field_pos = mode_info.blue_field_pos;
 971
 972 #ifdef GRUB_MACHINE_PCBIOS
 973   /* VESA packed modes may come with zeroed mask sizes, which need
 974      to be set here according to DAC Palette width.  If we don't,
 975      this results in Linux displaying a black screen.  */
 976   if (mode_info.bpp <= 8 && driv_id == GRUB_VIDEO_DRIVER_VBE)
 977     {
 978       struct grub_vbe_info_block controller_info;
 979       int status;
 980       int width = 8;
 981
 982       status = grub_vbe_bios_get_controller_info (&controller_info);
 983
 984       if (status == GRUB_VBE_STATUS_OK &&
 985           (controller_info.capabilities & GRUB_VBE_CAPABILITY_DACWIDTH))
 986         status = grub_vbe_bios_set_dac_palette_width (&width);
 987
 988       if (status != GRUB_VBE_STATUS_OK)
 989         /* 6 is default after mode reset.  */
 990         width = 6;
 991
 992       params.red_mask_size = params.green_mask_size
 993         = params.blue_mask_size = width;
 994     }
 995 #endif
 996
 997   err = grub_bsd_add_meta (NETBSD_BTINFO_FRAMEBUF, &params, sizeof (params));
 998   return err;
 999 }
1000
1001 static grub_err_t
1002 grub_netbsd_add_modules (void)
1003 {
1004   struct netbsd_module *mod;
1005   unsigned modcnt = 0;
1006   struct grub_netbsd_btinfo_modules *mods;
1007   unsigned i;
1008   grub_err_t err;
1009
1010   for (mod = netbsd_mods; mod; mod = mod->next)
1011     modcnt++;
1012
1013   mods = grub_malloc (sizeof (*mods) + sizeof (mods->mods[0]) * modcnt);
1014   if (!mods)
1015     return grub_errno;
1016
1017   mods->num = modcnt;
1018   mods->last_addr = kern_end;
1019   for (mod = netbsd_mods, i = 0; mod; i++, mod = mod->next)
1020     mods->mods[i] = mod->mod;
1021
1022   err = grub_bsd_add_meta (NETBSD_BTINFO_MODULES, mods,
1023                            sizeof (*mods) + sizeof (mods->mods[0]) * modcnt);
1024   grub_free (mods);
1025   return err;
1026 }
1027
1028 /*
1029  * Adds NetBSD bootinfo bootdisk and bootwedge.  The partition identified
1030  * in these bootinfo fields is the root device.
1031  */
1032 static void
1033 grub_netbsd_add_boot_disk_and_wedge (void)
1034 {
1035   grub_device_t dev;
1036   grub_disk_t disk;
1037   grub_partition_t part;
1038   grub_uint32_t biosdev;
1039   grub_uint32_t partmapsector;
1040   union {
1041     grub_uint64_t raw[GRUB_DISK_SECTOR_SIZE / 8];
1042     struct grub_partition_bsd_disk_label label;
1043   } buf;
1044
1045   if (GRUB_MD_MD5->mdlen > GRUB_CRYPTO_MAX_MDLEN)
1046     {
1047       grub_error (GRUB_ERR_BUG, "mdlen too long");
1048       return;
1049     }
1050
1051   dev = grub_device_open (0);
1052   if (! (dev && dev->disk && dev->disk->partition))
1053     goto fail;
1054
1055   disk = dev->disk;
1056   part = disk->partition;
1057
1058   if (disk->dev && disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID)
1059     biosdev = (grub_uint32_t) disk->id & 0xff;
1060   else
1061     biosdev = 0xff;
1062
1063   /* Absolute sector of the partition map describing this partition.  */
1064   partmapsector = grub_partition_get_start (part->parent) + part->offset;
1065
1066   disk->partition = part->parent;
1067   if (grub_disk_read (disk, part->offset, 0, GRUB_DISK_SECTOR_SIZE, buf.raw)
1068       != GRUB_ERR_NONE)
1069     goto fail;
1070   disk->partition = part;
1071
1072   /* Fill bootwedge.  */
1073   {
1074     struct grub_netbsd_btinfo_bootwedge biw;
1075     grub_uint8_t hash[GRUB_CRYPTO_MAX_MDLEN];
1076
1077     grub_memset (&biw, 0, sizeof (biw));
1078     biw.biosdev = biosdev;
1079     biw.startblk = grub_partition_get_start (part);
1080     biw.nblks = part->len;
1081     biw.matchblk = partmapsector;
1082     biw.matchnblks = 1;
1083
1084     grub_crypto_hash (GRUB_MD_MD5, hash,
1085                       buf.raw, GRUB_DISK_SECTOR_SIZE);
1086     grub_memcpy (biw.matchhash, hash, 16);
1087
1088     grub_bsd_add_meta (NETBSD_BTINFO_BOOTWEDGE, &biw, sizeof (biw));
1089   }
1090
1091   /* Fill bootdisk.  */
1092   {
1093     struct grub_netbsd_btinfo_bootdisk bid;
1094
1095     grub_memset (&bid, 0, sizeof (bid));
1096     /* Check for a NetBSD disk label.  */
1097     if (part->partmap != NULL &&
1098         (grub_strcmp (part->partmap->name, "netbsd") == 0 ||
1099          (part->parent == NULL && grub_strcmp (part->partmap->name, "bsd") == 0)))
1100       {
1101         bid.labelsector = partmapsector;
1102         bid.label.type = buf.label.type;
1103         bid.label.checksum = buf.label.checksum;
1104         grub_memcpy (bid.label.packname, buf.label.packname, 16);
1105       }
1106     else
1107       {
1108         bid.labelsector = -1;
1109       }
1110     bid.biosdev = biosdev;
1111     bid.partition = part->number;
1112
1113     grub_bsd_add_meta (NETBSD_BTINFO_BOOTDISK, &bid, sizeof (bid));
1114   }
1115
1116 fail:
1117   if (dev)
1118     grub_device_close (dev);
1119 }
1120
1121 static grub_err_t
1122 grub_netbsd_boot (void)
1123 {
1124   struct grub_netbsd_bootinfo *bootinfo;
1125   void *curarg, *arg0;
1126   grub_addr_t arg_target, stack_target;
1127   grub_uint32_t *stack;
1128   grub_err_t err;
1129   struct grub_relocator32_state state;
1130   grub_size_t tag_buf_len = 0;
1131   int tag_count = 0;
1132
1133   err = grub_bsd_add_mmap ();
1134   if (err)
1135     return err;
1136
1137   err = grub_netbsd_setup_video ();
1138   if (err)
1139     {
1140       grub_print_error ();
1141       grub_puts_ (N_("Booting in blind mode"));
1142       grub_errno = GRUB_ERR_NONE;
1143     }
1144
1145   err = grub_netbsd_add_modules ();
1146   if (err)
1147     return err;
1148
1149 #ifdef GRUB_MACHINE_EFI
1150   err = grub_bsd_add_meta (NETBSD_BTINFO_EFI,
1151                            &grub_efi_system_table,
1152                            sizeof (grub_efi_system_table));
1153   if (err)
1154     return err;
1155 #endif
1156
1157   {
1158     struct bsd_tag *tag;
1159     tag_buf_len = 0;
1160     for (tag = tags; tag; tag = tag->next)
1161       {
1162         tag_buf_len = ALIGN_VAR (tag_buf_len
1163                                  + sizeof (struct grub_netbsd_btinfo_common)
1164                                  + tag->len);
1165         tag_count++;
1166       }
1167   }
1168
1169   arg_target = kern_end;
1170   {
1171     grub_relocator_chunk_t ch;
1172     err = grub_relocator_alloc_chunk_addr (relocator, &ch,
1173                                            arg_target, tag_buf_len
1174                                            + sizeof (struct grub_netbsd_bootinfo)
1175                                            + tag_count * sizeof (grub_uint32_t));
1176     if (err)
1177       return err;
1178     curarg = get_virtual_current_address (ch);
1179   }
1180
1181   arg0 = curarg;
1182   bootinfo = (void *) ((grub_uint8_t *) arg0 + tag_buf_len);
1183
1184   {
1185     struct bsd_tag *tag;
1186     unsigned i;
1187
1188     bootinfo->bi_count = tag_count;
1189     for (tag = tags, i = 0; tag; i++, tag = tag->next)
1190       {
1191         struct grub_netbsd_btinfo_common *head = curarg;
1192         bootinfo->bi_data[i] = ((grub_uint8_t *) curarg - (grub_uint8_t *) arg0)
1193           + arg_target;
1194         head->type = tag->type;
1195         head->len = tag->len + sizeof (*head);
1196         curarg = head + 1;
1197         grub_memcpy (curarg, tag->data, tag->len);
1198         curarg = (grub_uint8_t *) curarg + tag->len;
1199       }
1200   }
1201
1202   {
1203     grub_relocator_chunk_t ch;
1204     err = grub_relocator_alloc_chunk_align (relocator, &ch, 0x10000, 0x90000,
1205                                             7 * sizeof (grub_uint32_t), 4,
1206                                             GRUB_RELOCATOR_PREFERENCE_NONE,
1207                                             0);
1208     if (err)
1209       return err;
1210     stack = get_virtual_current_address (ch);
1211     stack_target = get_physical_target_address (ch);
1212   }
1213
1214 #ifdef GRUB_MACHINE_EFI
1215   err = grub_efi_finish_boot_services (NULL, NULL, NULL, NULL, NULL);
1216   if (err)
1217     return err;
1218 #endif
1219
1220   state.eip = entry;
1221   state.esp = stack_target;
1222   state.ebp = stack_target;
1223   stack[0] = entry;
1224   stack[1] = bootflags;
1225   stack[2] = 0;
1226   stack[3] = ((grub_uint8_t *) bootinfo - (grub_uint8_t *) arg0) + arg_target;
1227   stack[4] = 0;
1228   stack[5] = grub_mmap_get_upper () >> 10;
1229   stack[6] = grub_mmap_get_lower () >> 10;
1230
1231   return grub_relocator32_boot (relocator, state, 0);
1232 }
1233
1234 static grub_err_t
1235 grub_bsd_unload (void)
1236 {
1237   struct bsd_tag *tag, *next;
1238   for (tag = tags; tag; tag = next)
1239     {
1240       next = tag->next;
1241       grub_free (tag);
1242     }
1243   tags = NULL;
1244   tags_last = NULL;
1245
1246   kernel_type = KERNEL_TYPE_NONE;
1247   grub_dl_unref (my_mod);
1248
1249   grub_relocator_unload (relocator);
1250   relocator = NULL;
1251
1252   return GRUB_ERR_NONE;
1253 }
1254
1255 static grub_err_t
1256 grub_bsd_load_aout (grub_file_t file, const char *filename)
1257 {
1258   grub_addr_t load_addr, load_end;
1259   int ofs, align_page;
1260   union grub_aout_header ah;
1261   grub_err_t err;
1262   grub_size_t bss_size;
1263
1264   if ((grub_file_seek (file, 0)) == (grub_off_t) - 1)
1265     return grub_errno;
1266
1267   if (grub_file_read (file, &ah, sizeof (ah)) != sizeof (ah))
1268     {
1269       if (!grub_errno)
1270         grub_error (GRUB_ERR_READ_ERROR, N_("premature end of file %s"),
1271                     filename);
1272       return grub_errno;
1273     }
1274
1275   if (grub_aout_get_type (&ah) != AOUT_TYPE_AOUT32)
1276     return grub_error (GRUB_ERR_BAD_OS, "invalid a.out header");
1277
1278   entry = ah.aout32.a_entry & 0xFFFFFF;
1279
1280   if (AOUT_GETMAGIC (ah.aout32) == AOUT32_ZMAGIC)
1281     {
1282       load_addr = entry;
1283       ofs = 0x1000;
1284       align_page = 0;
1285     }
1286   else
1287     {
1288       load_addr = entry & 0xF00000;
1289       ofs = sizeof (struct grub_aout32_header);
1290       align_page = 1;
1291     }
1292
1293   if (load_addr < 0x100000)
1294     return grub_error (GRUB_ERR_BAD_OS, "load address below 1M");
1295
1296   kern_start = load_addr;
1297   load_end = kern_end = load_addr + ah.aout32.a_text + ah.aout32.a_data;
1298   if (align_page)
1299     kern_end = ALIGN_PAGE (kern_end);
1300
1301   if (ah.aout32.a_bss)
1302     {
1303       kern_end += ah.aout32.a_bss;
1304       if (align_page)
1305         kern_end = ALIGN_PAGE (kern_end);
1306
1307       bss_size = kern_end - load_end;
1308     }
1309   else
1310     bss_size = 0;
1311
1312   {
1313     grub_relocator_chunk_t ch;
1314
1315     err = grub_relocator_alloc_chunk_addr (relocator, &ch,
1316                                            kern_start, kern_end - kern_start);
1317     if (err)
1318       return err;
1319     kern_chunk_src = get_virtual_current_address (ch);
1320   }
1321
1322   return grub_aout_load (file, ofs, kern_chunk_src,
1323                          ah.aout32.a_text + ah.aout32.a_data,
1324                          bss_size);
1325 }
1326
1327 static grub_err_t
1328 grub_bsd_load_elf (grub_elf_t elf, const char *filename)
1329 {
1330   grub_err_t err;
1331
1332   kern_end = 0;
1333   kern_start = ~0;
1334
1335   if (grub_elf_is_elf32 (elf))
1336     {
1337       grub_relocator_chunk_t ch;
1338       Elf32_Phdr *phdr;
1339
1340       entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFFF;
1341
1342       FOR_ELF32_PHDRS (elf, phdr)
1343         {
1344           Elf32_Addr paddr;
1345
1346           if (phdr->p_type != PT_LOAD
1347               && phdr->p_type != PT_DYNAMIC)
1348             continue;
1349
1350           paddr = phdr->p_paddr & 0xFFFFFFF;
1351
1352           if (paddr < kern_start)
1353             kern_start = paddr;
1354
1355           if (paddr + phdr->p_memsz > kern_end)
1356             kern_end = paddr + phdr->p_memsz;
1357         }
1358
1359       if (grub_errno)
1360         return grub_errno;
1361       err = grub_relocator_alloc_chunk_addr (relocator, &ch,
1362                                              kern_start, kern_end - kern_start);
1363       if (err)
1364         return err;
1365
1366       kern_chunk_src = get_virtual_current_address (ch);
1367
1368       err = grub_elf32_load (elf, filename, (grub_uint8_t *) kern_chunk_src - kern_start, GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | GRUB_ELF_LOAD_FLAGS_28BITS, 0, 0);
1369       if (err)
1370         return err;
1371       if (kernel_type != KERNEL_TYPE_OPENBSD)
1372         return GRUB_ERR_NONE;
1373       return grub_openbsd_find_ramdisk32 (elf->file, filename, kern_start,
1374                                           kern_chunk_src, &openbsd_ramdisk);
1375     }
1376   else if (grub_elf_is_elf64 (elf))
1377     {
1378       Elf64_Phdr *phdr;
1379
1380       is_64bit = 1;
1381
1382       if (! grub_cpuid_has_longmode)
1383         return grub_error (GRUB_ERR_BAD_OS, "your CPU does not implement AMD64 architecture");
1384
1385       /* FreeBSD has 64-bit entry point.  */
1386       if (kernel_type == KERNEL_TYPE_FREEBSD)
1387         {
1388           entry = elf->ehdr.ehdr64.e_entry & 0xffffffff;
1389           entry_hi = (elf->ehdr.ehdr64.e_entry >> 32) & 0xffffffff;
1390         }
1391       else
1392         {
1393           entry = elf->ehdr.ehdr64.e_entry & 0x0fffffff;
1394           entry_hi = 0;
1395         }
1396
1397       FOR_ELF64_PHDRS (elf, phdr)
1398         {
1399           Elf64_Addr paddr;
1400
1401           if (phdr->p_type != PT_LOAD
1402               && phdr->p_type != PT_DYNAMIC)
1403             continue;
1404
1405           paddr = phdr->p_paddr & 0xFFFFFFF;
1406
1407           if (paddr < kern_start)
1408             kern_start = paddr;
1409
1410           if (paddr + phdr->p_memsz > kern_end)
1411             kern_end = paddr + phdr->p_memsz;
1412         }
1413
1414       if (grub_errno)
1415         return grub_errno;
1416
1417       grub_dprintf ("bsd", "kern_start = %lx, kern_end = %lx\n",
1418                     (unsigned long) kern_start, (unsigned long) kern_end);
1419       {
1420         grub_relocator_chunk_t ch;
1421
1422         err = grub_relocator_alloc_chunk_addr (relocator, &ch, kern_start,
1423                                                kern_end - kern_start);
1424         if (err)
1425           return err;
1426         kern_chunk_src = get_virtual_current_address (ch);
1427       }
1428
1429       err = grub_elf64_load (elf, filename,
1430                              (grub_uint8_t *) kern_chunk_src - kern_start, GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC | GRUB_ELF_LOAD_FLAGS_28BITS, 0, 0);
1431       if (err)
1432         return err;
1433       if (kernel_type != KERNEL_TYPE_OPENBSD)
1434         return GRUB_ERR_NONE;
1435       return grub_openbsd_find_ramdisk64 (elf->file, filename, kern_start,
1436                                           kern_chunk_src, &openbsd_ramdisk);
1437     }
1438   else
1439     return grub_error (GRUB_ERR_BAD_OS, N_("invalid arch-dependent ELF magic"));
1440 }
1441
1442 static grub_err_t
1443 grub_bsd_load (int argc, char *argv[])
1444 {
1445   grub_file_t file;
1446   grub_elf_t elf;
1447
1448   grub_dl_ref (my_mod);
1449
1450   grub_loader_unset ();
1451
1452   grub_memset (&openbsd_ramdisk, 0, sizeof (openbsd_ramdisk));
1453
1454   if (argc == 0)
1455     {
1456       grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
1457       goto fail;
1458     }
1459
1460   file = grub_file_open (argv[0]);
1461   if (!file)
1462     goto fail;
1463
1464   relocator = grub_relocator_new ();
1465   if (!relocator)
1466     {
1467       grub_file_close (file);
1468       goto fail;
1469     }
1470
1471   elf = grub_elf_file (file, argv[0]);
1472   if (elf)
1473     {
1474       is_elf_kernel = 1;
1475       grub_bsd_load_elf (elf, argv[0]);
1476       grub_elf_close (elf);
1477     }
1478   else
1479     {
1480       is_elf_kernel = 0;
1481       grub_errno = 0;
1482       grub_bsd_load_aout (file, argv[0]);
1483       grub_file_close (file);
1484     }
1485
1486   kern_end = ALIGN_PAGE (kern_end);
1487
1488 fail:
1489
1490   if (grub_errno != GRUB_ERR_NONE)
1491     grub_dl_unref (my_mod);
1492
1493   return grub_errno;
1494 }
1495
1496 static grub_uint32_t
1497 grub_bsd_parse_flags (const struct grub_arg_list *state,
1498                       const grub_uint32_t * flags)
1499 {
1500   grub_uint32_t result = 0;
1501   unsigned i;
1502
1503   for (i = 0; flags[i]; i++)
1504     if (state[i].set)
1505       result |= flags[i];
1506
1507   return result;
1508 }
1509
1510 static grub_err_t
1511 grub_cmd_freebsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
1512 {
1513   kernel_type = KERNEL_TYPE_FREEBSD;
1514   bootflags = grub_bsd_parse_flags (ctxt->state, freebsd_flags);
1515
1516   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
1517     {
1518       grub_uint32_t unit, slice, part;
1519
1520       kern_end = ALIGN_PAGE (kern_end);
1521       if (is_elf_kernel)
1522         {
1523           grub_err_t err;
1524           grub_uint64_t data = 0;
1525           grub_file_t file;
1526           int len = is_64bit ? 8 : 4;
1527
1528           err = grub_freebsd_add_meta_module (argv[0], is_64bit
1529                                               ? FREEBSD_MODTYPE_KERNEL64
1530                                               : FREEBSD_MODTYPE_KERNEL,
1531                                               argc - 1, argv + 1,
1532                                               kern_start,
1533                                               kern_end - kern_start);
1534           if (err)
1535             return err;
1536
1537           file = grub_file_open (argv[0]);
1538           if (! file)
1539             return grub_errno;
1540
1541           if (is_64bit)
1542             err = grub_freebsd_load_elf_meta64 (relocator, file, argv[0],
1543                                                 &kern_end);
1544           else
1545             err = grub_freebsd_load_elf_meta32 (relocator, file, argv[0],
1546                                                 &kern_end);
1547           if (err)
1548             return err;
1549
1550           err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
1551                                    FREEBSD_MODINFOMD_HOWTO, &data, 4);
1552           if (err)
1553             return err;
1554
1555           err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
1556                                        FREEBSD_MODINFOMD_ENVP, &data, len);
1557           if (err)
1558             return err;
1559
1560           err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
1561                                    FREEBSD_MODINFOMD_KERNEND, &data, len);
1562           if (err)
1563             return err;
1564         }
1565       grub_bsd_get_device (&freebsd_biosdev, &unit, &slice, &part);
1566       freebsd_zfsguid = 0;
1567       if (!is_64bit)
1568         freebsd_get_zfs ();
1569       grub_print_error ();
1570       freebsd_bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
1571                          (unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
1572
1573       grub_loader_set (grub_freebsd_boot, grub_bsd_unload, 0);
1574     }
1575
1576   return grub_errno;
1577 }
1578
1579 static const char *types[] = {
1580   [0] = "wd",
1581   [2] = "fd",
1582   [4] = "sd",
1583   [6] = "cd",
1584   [14] = "vnd",
1585   [17] = "rd"
1586 };
1587
1588 static grub_err_t
1589 grub_cmd_openbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
1590 {
1591   grub_uint32_t bootdev;
1592
1593   kernel_type = KERNEL_TYPE_OPENBSD;
1594   bootflags = grub_bsd_parse_flags (ctxt->state, openbsd_flags);
1595
1596   if (ctxt->state[OPENBSD_ROOT_ARG].set)
1597     {
1598       const char *arg = ctxt->state[OPENBSD_ROOT_ARG].arg;
1599       unsigned type, unit, part;
1600       for (type = 0; type < ARRAY_SIZE (types); type++)
1601         if (types[type]
1602             && grub_strncmp (arg, types[type],
1603                              grub_strlen (types[type])) == 0)
1604           {
1605             arg += grub_strlen (types[type]);
1606             break;
1607           }
1608       if (type == ARRAY_SIZE (types))
1609         return grub_error (GRUB_ERR_BAD_ARGUMENT,
1610                            "unknown disk type name");
1611
1612       unit = grub_strtoul (arg, (char **) &arg, 10);
1613       if (! (arg && *arg >= 'a' && *arg <= 'z'))
1614         return grub_error (GRUB_ERR_BAD_ARGUMENT,
1615                            "only device specifications of form "
1616                            "<type><number><lowercase letter> are supported");
1617
1618       part = *arg - 'a';
1619
1620       bootdev = (OPENBSD_B_DEVMAGIC | (type << OPENBSD_B_TYPESHIFT)
1621                  | (unit << OPENBSD_B_UNITSHIFT)
1622                  | (part << OPENBSD_B_PARTSHIFT));
1623     }
1624   else
1625     bootdev = 0;
1626
1627   if (ctxt->state[OPENBSD_SERIAL_ARG].set)
1628     {
1629       struct grub_openbsd_bootarg_console serial;
1630       char *ptr;
1631       unsigned port = 0;
1632       unsigned speed = 9600;
1633
1634       grub_memset (&serial, 0, sizeof (serial));
1635
1636       if (ctxt->state[OPENBSD_SERIAL_ARG].arg)
1637         {
1638           ptr = ctxt->state[OPENBSD_SERIAL_ARG].arg;
1639           if (grub_memcmp (ptr, "com", sizeof ("com") - 1) != 0)
1640             return grub_error (GRUB_ERR_BAD_ARGUMENT,
1641                                "only com0-com3 are supported");
1642           ptr += sizeof ("com") - 1;
1643           port = grub_strtoul (ptr, &ptr, 0);
1644           if (port >= 4)
1645             return grub_error (GRUB_ERR_BAD_ARGUMENT,
1646                                "only com0-com3 are supported");
1647           if (*ptr == ',')
1648             {
1649               ptr++;
1650               speed = grub_strtoul (ptr, &ptr, 0);
1651               if (grub_errno)
1652                 return grub_errno;
1653             }
1654         }
1655
1656       serial.device = (GRUB_OPENBSD_COM_MAJOR << 8) | port;
1657       serial.speed = speed;
1658       serial.addr = grub_ns8250_hw_get_port (port);
1659
1660       grub_bsd_add_meta (OPENBSD_BOOTARG_CONSOLE, &serial, sizeof (serial));
1661       bootflags |= OPENBSD_RB_SERCONS;
1662     }
1663   else
1664     {
1665       struct grub_openbsd_bootarg_console serial;
1666
1667       grub_memset (&serial, 0, sizeof (serial));
1668       serial.device = (GRUB_OPENBSD_VGA_MAJOR << 8);
1669       serial.addr = 0xffffffff;
1670       grub_bsd_add_meta (OPENBSD_BOOTARG_CONSOLE, &serial, sizeof (serial));
1671       bootflags &= ~OPENBSD_RB_SERCONS;
1672     }
1673
1674   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
1675     {
1676       grub_loader_set (grub_openbsd_boot, grub_bsd_unload, 0);
1677       openbsd_root = bootdev;
1678     }
1679
1680   return grub_errno;
1681 }
1682
1683 static grub_err_t
1684 grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
1685 {
1686   grub_err_t err;
1687   kernel_type = KERNEL_TYPE_NETBSD;
1688   bootflags = grub_bsd_parse_flags (ctxt->state, netbsd_flags);
1689
1690   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
1691     {
1692       if (is_elf_kernel)
1693         {
1694           grub_file_t file;
1695
1696           file = grub_file_open (argv[0]);
1697           if (! file)
1698             return grub_errno;
1699
1700           if (is_64bit)
1701             err = grub_netbsd_load_elf_meta64 (relocator, file, argv[0], &kern_end);
1702           else
1703             err = grub_netbsd_load_elf_meta32 (relocator, file, argv[0], &kern_end);
1704           if (err)
1705             return err;
1706         }
1707
1708       {
1709         char bootpath[GRUB_NETBSD_MAX_BOOTPATH_LEN];
1710         char *name;
1711         name = grub_strrchr (argv[0], '/');
1712         if (name)
1713           name++;
1714         else
1715           name = argv[0];
1716         grub_memset (bootpath, 0, sizeof (bootpath));
1717         grub_strncpy (bootpath, name, sizeof (bootpath) - 1);
1718         grub_bsd_add_meta (NETBSD_BTINFO_BOOTPATH, bootpath, sizeof (bootpath));
1719       }
1720
1721       if (ctxt->state[NETBSD_ROOT_ARG].set)
1722         {
1723           char root[GRUB_NETBSD_MAX_ROOTDEVICE_LEN];
1724           grub_memset (root, 0, sizeof (root));
1725           grub_strncpy (root, ctxt->state[NETBSD_ROOT_ARG].arg,
1726                         sizeof (root) - 1);
1727           grub_bsd_add_meta (NETBSD_BTINFO_ROOTDEVICE, root, sizeof (root));
1728         }
1729       if (ctxt->state[NETBSD_SERIAL_ARG].set)
1730         {
1731           struct grub_netbsd_btinfo_serial serial;
1732           char *ptr;
1733
1734           grub_memset (&serial, 0, sizeof (serial));
1735           grub_strcpy (serial.devname, "com");
1736
1737           serial.addr = grub_ns8250_hw_get_port (0);
1738           serial.speed = 9600;
1739
1740           if (ctxt->state[NETBSD_SERIAL_ARG].arg)
1741             {
1742               ptr = ctxt->state[NETBSD_SERIAL_ARG].arg;
1743               if (grub_memcmp (ptr, "com", sizeof ("com") - 1) == 0)
1744                 {
1745                   ptr += sizeof ("com") - 1;
1746                   serial.addr
1747                     = grub_ns8250_hw_get_port (grub_strtoul (ptr, &ptr, 0));
1748                 }
1749               else
1750                 serial.addr = grub_strtoul (ptr, &ptr, 0);
1751               if (grub_errno)
1752                 return grub_errno;
1753
1754               if (*ptr == ',')
1755                 {
1756                   ptr++;
1757                   serial.speed = grub_strtoul (ptr, &ptr, 0);
1758                   if (grub_errno)
1759                     return grub_errno;
1760                 }
1761             }
1762
1763           grub_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &serial, sizeof (serial));
1764         }
1765       else
1766         {
1767           struct grub_netbsd_btinfo_serial cons;
1768
1769           grub_memset (&cons, 0, sizeof (cons));
1770           grub_strcpy (cons.devname, "pc");
1771
1772           grub_bsd_add_meta (NETBSD_BTINFO_CONSOLE, &cons, sizeof (cons));
1773         }
1774
1775       grub_netbsd_add_boot_disk_and_wedge ();
1776
1777       grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 0);
1778     }
1779
1780   return grub_errno;
1781 }
1782
1783 static grub_err_t
1784 grub_cmd_freebsd_loadenv (grub_command_t cmd __attribute__ ((unused)),
1785                           int argc, char *argv[])
1786 {
1787   grub_file_t file = 0;
1788   char *buf = 0, *curr, *next;
1789   int len;
1790
1791   if (! grub_loader_is_loaded ())
1792     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1793                        N_("you need to load the kernel first"));
1794
1795   if (kernel_type != KERNEL_TYPE_FREEBSD)
1796     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1797                        "only FreeBSD supports environment");
1798
1799   if (argc == 0)
1800     {
1801       grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
1802       goto fail;
1803     }
1804
1805   file = grub_file_open (argv[0]);
1806   if ((!file) || (!file->size))
1807     goto fail;
1808
1809   len = file->size;
1810   buf = grub_malloc (len + 1);
1811   if (!buf)
1812     goto fail;
1813
1814   if (grub_file_read (file, buf, len) != len)
1815     goto fail;
1816
1817   buf[len] = 0;
1818
1819   next = buf;
1820   while (next)
1821     {
1822       char *p;
1823
1824       curr = next;
1825       next = grub_strchr (curr, '\n');
1826       if (next)
1827         {
1828
1829           p = next - 1;
1830           while (p > curr)
1831             {
1832               if ((*p != '\r') && (*p != ' ') && (*p != '\t'))
1833                 break;
1834               p--;
1835             }
1836
1837           if ((p > curr) && (*p == '"'))
1838             p--;
1839
1840           *(p + 1) = 0;
1841           next++;
1842         }
1843
1844       if (*curr == '#')
1845         continue;
1846
1847       p = grub_strchr (curr, '=');
1848       if (!p)
1849         continue;
1850
1851       *(p++) = 0;
1852
1853       if (*curr)
1854         {
1855           char *name;
1856
1857           if (*p == '"')
1858             p++;
1859
1860           name = grub_xasprintf ("kFreeBSD.%s", curr);
1861           if (!name)
1862             goto fail;
1863           if (grub_env_set (name, p))
1864             {
1865               grub_free (name);
1866               goto fail;
1867             }
1868           grub_free (name);
1869         }
1870     }
1871
1872 fail:
1873   grub_free (buf);
1874
1875   if (file)
1876     grub_file_close (file);
1877
1878   return grub_errno;
1879 }
1880
1881 static grub_err_t
1882 grub_cmd_freebsd_module (grub_command_t cmd __attribute__ ((unused)),
1883                          int argc, char *argv[])
1884 {
1885   grub_file_t file = 0;
1886   int modargc;
1887   char **modargv;
1888   const char *type;
1889   grub_err_t err;
1890   void *src;
1891
1892   if (! grub_loader_is_loaded ())
1893     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1894                        N_("you need to load the kernel first"));
1895
1896   if (kernel_type != KERNEL_TYPE_FREEBSD)
1897     return grub_error (GRUB_ERR_BAD_ARGUMENT, "no FreeBSD loaded");
1898
1899   if (!is_elf_kernel)
1900     return grub_error (GRUB_ERR_BAD_ARGUMENT,
1901                        "only ELF kernel supports module");
1902
1903   /* List the current modules if no parameter.  */
1904   if (!argc)
1905     {
1906       grub_freebsd_list_modules ();
1907       return 0;
1908     }
1909
1910   file = grub_file_open (argv[0]);
1911   if ((!file) || (!file->size))
1912     goto fail;
1913
1914   {
1915     grub_relocator_chunk_t ch;
1916     err = grub_relocator_alloc_chunk_addr (relocator, &ch, kern_end,
1917                                            file->size);
1918     if (err)
1919       goto fail;
1920     src = get_virtual_current_address (ch);
1921   }
1922
1923
1924   grub_file_read (file, src, file->size);
1925   if (grub_errno)
1926     goto fail;
1927
1928   modargc = argc - 1;
1929   modargv = argv + 1;
1930
1931   if (modargc && (! grub_memcmp (modargv[0], "type=", 5)))
1932     {
1933       type = &modargv[0][5];
1934       modargc--;
1935       modargv++;
1936     }
1937   else
1938     type = FREEBSD_MODTYPE_RAW;
1939
1940   err = grub_freebsd_add_meta_module (argv[0], type, modargc, modargv,
1941                                       kern_end, file->size);
1942   if (err)
1943     goto fail;
1944
1945   kern_end = ALIGN_PAGE (kern_end + file->size);
1946
1947 fail:
1948   if (file)
1949     grub_file_close (file);
1950
1951   return grub_errno;
1952 }
1953
1954 static grub_err_t
1955 grub_netbsd_module_load (char *filename, grub_uint32_t type)
1956 {
1957   grub_file_t file = 0;
1958   void *src;
1959   grub_err_t err;
1960
1961   file = grub_file_open (filename);
1962   if ((!file) || (!file->size))
1963     goto fail;
1964
1965   {
1966     grub_relocator_chunk_t ch;
1967     err = grub_relocator_alloc_chunk_addr (relocator, &ch, kern_end,
1968                                            file->size);
1969     if (err)
1970       goto fail;
1971
1972     src = get_virtual_current_address (ch);
1973   }
1974
1975   grub_file_read (file, src, file->size);
1976   if (grub_errno)
1977     goto fail;
1978
1979   err = grub_netbsd_add_meta_module (filename, type, kern_end, file->size);
1980
1981   if (err)
1982     goto fail;
1983
1984   kern_end = ALIGN_PAGE (kern_end + file->size);
1985
1986 fail:
1987   if (file)
1988     grub_file_close (file);
1989
1990   return grub_errno;
1991 }
1992
1993 static grub_err_t
1994 grub_cmd_netbsd_module (grub_command_t cmd,
1995                         int argc, char *argv[])
1996 {
1997   grub_uint32_t type;
1998
1999   if (! grub_loader_is_loaded ())
2000     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2001                        N_("you need to load the kernel first"));
2002
2003   if (kernel_type != KERNEL_TYPE_NETBSD)
2004     return grub_error (GRUB_ERR_BAD_ARGUMENT, "no NetBSD loaded");
2005
2006   if (!is_elf_kernel)
2007     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2008                        "only ELF kernel supports module");
2009
2010   /* List the current modules if no parameter.  */
2011   if (!argc)
2012     {
2013       grub_netbsd_list_modules ();
2014       return 0;
2015     }
2016
2017   if (grub_strcmp (cmd->name, "knetbsd_module_elf") == 0)
2018     type = GRUB_NETBSD_MODULE_ELF;
2019   else
2020     type = GRUB_NETBSD_MODULE_RAW;
2021
2022   return grub_netbsd_module_load (argv[0], type);
2023 }
2024
2025 static grub_err_t
2026 grub_cmd_freebsd_module_elf (grub_command_t cmd __attribute__ ((unused)),
2027                              int argc, char *argv[])
2028 {
2029   grub_file_t file = 0;
2030   grub_err_t err;
2031
2032   if (! grub_loader_is_loaded ())
2033     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2034                        N_("you need to load the kernel first"));
2035
2036   if (kernel_type != KERNEL_TYPE_FREEBSD)
2037     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2038                        "only FreeBSD supports module");
2039
2040   if (! is_elf_kernel)
2041     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2042                        "only ELF kernel supports module");
2043
2044   /* List the current modules if no parameter.  */
2045   if (! argc)
2046     {
2047       grub_freebsd_list_modules ();
2048       return 0;
2049     }
2050
2051   file = grub_file_open (argv[0]);
2052   if (!file)
2053     return grub_errno;
2054   if (!file->size)
2055     {
2056       grub_file_close (file);
2057       return grub_errno;
2058     }
2059
2060   if (is_64bit)
2061     err = grub_freebsd_load_elfmodule_obj64 (relocator, file,
2062                                              argc, argv, &kern_end);
2063   else
2064     err = grub_freebsd_load_elfmodule32 (relocator, file,
2065                                          argc, argv, &kern_end);
2066   grub_file_close (file);
2067
2068   return err;
2069 }
2070
2071 static grub_err_t
2072 grub_cmd_openbsd_ramdisk (grub_command_t cmd __attribute__ ((unused)),
2073                       int argc, char *args[])
2074 {
2075   grub_file_t file;
2076   grub_size_t size;
2077
2078   if (argc != 1)
2079     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("filename expected"));
2080
2081   if (! grub_loader_is_loaded ())
2082     return grub_error (GRUB_ERR_BAD_ARGUMENT,
2083                        N_("you need to load the kernel first"));
2084
2085   if (kernel_type != KERNEL_TYPE_OPENBSD)
2086     return grub_error (GRUB_ERR_BAD_OS, "no kOpenBSD loaded");
2087
2088   if (!openbsd_ramdisk.max_size)
2089     return grub_error (GRUB_ERR_BAD_OS, "your kOpenBSD doesn't support ramdisk");
2090
2091   file = grub_file_open (args[0]);
2092   if (! file)
2093     return grub_errno;
2094
2095   size = grub_file_size (file);
2096
2097   if (size > openbsd_ramdisk.max_size)
2098     {
2099       grub_file_close (file);
2100       return grub_error (GRUB_ERR_BAD_OS, "your kOpenBSD supports ramdisk only"
2101                          " up to %u bytes, however you supplied a %u bytes one",
2102                          openbsd_ramdisk.max_size, size);
2103     }
2104
2105   if (grub_file_read (file, openbsd_ramdisk.target, size)
2106       != (grub_ssize_t) (size))
2107     {
2108       grub_file_close (file);
2109       if (!grub_errno)
2110         grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), args[0]);
2111       return grub_errno;
2112     }
2113   grub_memset (openbsd_ramdisk.target + size, 0,
2114                openbsd_ramdisk.max_size - size);
2115   *openbsd_ramdisk.size = ALIGN_UP (size, 512);
2116
2117   return GRUB_ERR_NONE;
2118 }
2119
2120 static grub_extcmd_t cmd_freebsd, cmd_openbsd, cmd_netbsd;
2121 static grub_command_t cmd_freebsd_loadenv, cmd_freebsd_module;
2122 static grub_command_t cmd_netbsd_module, cmd_freebsd_module_elf;
2123 static grub_command_t cmd_netbsd_module_elf, cmd_openbsd_ramdisk;
2124
2125 GRUB_MOD_INIT (bsd)
2126 {
2127   /* Net and OpenBSD kernels are often compressed.  */
2128   grub_dl_load ("gzio");
2129
2130   cmd_freebsd = grub_register_extcmd ("kfreebsd", grub_cmd_freebsd, 0,
2131                                       N_("FILE"), N_("Load kernel of FreeBSD."),
2132                                       freebsd_opts);
2133   cmd_openbsd = grub_register_extcmd ("kopenbsd", grub_cmd_openbsd, 0,
2134                                       N_("FILE"), N_("Load kernel of OpenBSD."),
2135                                       openbsd_opts);
2136   cmd_netbsd = grub_register_extcmd ("knetbsd", grub_cmd_netbsd,  0,
2137                                      N_("FILE"), N_("Load kernel of NetBSD."),
2138                                      netbsd_opts);
2139   cmd_freebsd_loadenv =
2140     grub_register_command ("kfreebsd_loadenv", grub_cmd_freebsd_loadenv,
2141                            0, N_("Load FreeBSD env."));
2142   cmd_freebsd_module =
2143     grub_register_command ("kfreebsd_module", grub_cmd_freebsd_module,
2144                            0, N_("Load FreeBSD kernel module."));
2145   cmd_netbsd_module =
2146     grub_register_command ("knetbsd_module", grub_cmd_netbsd_module,
2147                            0, N_("Load NetBSD kernel module."));
2148   cmd_netbsd_module_elf =
2149     grub_register_command ("knetbsd_module_elf", grub_cmd_netbsd_module,
2150                            0, N_("Load NetBSD kernel module (ELF)."));
2151   cmd_freebsd_module_elf =
2152     grub_register_command ("kfreebsd_module_elf", grub_cmd_freebsd_module_elf,
2153                            0, N_("Load FreeBSD kernel module (ELF)."));
2154
2155   cmd_openbsd_ramdisk = grub_register_command ("kopenbsd_ramdisk",
2156                                                grub_cmd_openbsd_ramdisk, 0,
2157                                                /* TRANSLATORS: ramdisk isn't identifier,
2158                                                 it can be translated.  */
2159                                                N_("Load kOpenBSD ramdisk."));
2160
2161   my_mod = mod;
2162 }
2163
2164 GRUB_MOD_FINI (bsd)
2165 {
2166   grub_unregister_extcmd (cmd_freebsd);
2167   grub_unregister_extcmd (cmd_openbsd);
2168   grub_unregister_extcmd (cmd_netbsd);
2169
2170   grub_unregister_command (cmd_freebsd_loadenv);
2171   grub_unregister_command (cmd_freebsd_module);
2172   grub_unregister_command (cmd_netbsd_module);
2173   grub_unregister_command (cmd_freebsd_module_elf);
2174   grub_unregister_command (cmd_netbsd_module_elf);
2175   grub_unregister_command (cmd_openbsd_ramdisk);
2176
2177   grub_bsd_unload ();
2178 }