arch/common/boot/grub2/loader/i386/bsd.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2008  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/file.h>
  25 #include <grub/err.h>
  26 #include <grub/rescue.h>
  27 #include <grub/dl.h>
  28 #include <grub/mm.h>
  29 #include <grub/elfload.h>
  30 #include <grub/env.h>
  31 #include <grub/misc.h>
  32 #include <grub/gzio.h>
  33 #include <grub/aout.h>
  34
  35 #define ALIGN_DWORD(a)  ALIGN_UP (a, 4)
  36 #define ALIGN_PAGE(a)   ALIGN_UP (a, 4096)
  37
  38 #define MOD_BUF_ALLOC_UNIT      4096
  39
  40 static int kernel_type;
  41 static grub_dl_t my_mod;
  42 static grub_addr_t entry, kern_start, kern_end;
  43 static grub_uint32_t bootflags;
  44 static char *mod_buf;
  45 static grub_uint32_t mod_buf_len, mod_buf_max;
  46 static int is_elf_kernel;
  47
  48 static const char freebsd_opts[] = "DhaCcdgmnpqrsv";
  49 static const grub_uint32_t freebsd_flags[] =
  50 {
  51   FREEBSD_RB_DUAL, FREEBSD_RB_SERIAL, FREEBSD_RB_ASKNAME,
  52   FREEBSD_RB_CDROM, FREEBSD_RB_CONFIG, FREEBSD_RB_KDB,
  53   FREEBSD_RB_GDB, FREEBSD_RB_MUTE, FREEBSD_RB_NOINTR,
  54   FREEBSD_RB_PAUSE, FREEBSD_RB_QUIET, FREEBSD_RB_DFLTROOT,
  55   FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE
  56 };
  57
  58 static const char openbsd_opts[] = "abcsd";
  59 static const grub_uint32_t openbsd_flags[] =
  60 {
  61   OPENBSD_RB_ASKNAME, OPENBSD_RB_HALT, OPENBSD_RB_CONFIG,
  62   OPENBSD_RB_SINGLE, OPENBSD_RB_KDB
  63 };
  64
  65 static const char netbsd_opts[] = "abcdmqsvxz";
  66 static const grub_uint32_t netbsd_flags[] =
  67 {
  68   NETBSD_RB_ASKNAME, NETBSD_RB_HALT, NETBSD_RB_USERCONFIG,
  69   NETBSD_RB_KDB, NETBSD_RB_MINIROOT, NETBSD_AB_QUIET,
  70   NETBSD_RB_SINGLE, NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG,
  71   NETBSD_AB_SILENT
  72 };
  73
  74 static void
  75 grub_bsd_get_device (grub_uint32_t * biosdev,
  76                      grub_uint32_t * unit,
  77                      grub_uint32_t * slice, grub_uint32_t * part)
  78 {
  79   char *p;
  80
  81   *biosdev = *unit = *slice = *part = 0;
  82   p = grub_env_get ("root");
  83   if ((p) && ((p[0] == 'h') || (p[0] == 'f')) && (p[1] == 'd') &&
  84       (p[2] >= '0') && (p[2] <= '9'))
  85     {
  86       if (p[0] == 'h')
  87         *biosdev = 0x80;
  88
  89       *unit = grub_strtoul (p + 2, &p, 0);
  90       *biosdev += *unit;
  91
  92       if ((p) && (p[0] == ','))
  93         {
  94           if ((p[1] >= '0') && (p[1] <= '9'))
  95             {
  96               *slice = grub_strtoul (p + 1, &p, 0);
  97
  98               if ((p) && (p[0] == ','))
  99                 p++;
 100             }
 101
 102           if ((p[0] >= 'a') && (p[0] <= 'z'))
 103             *part = p[0] - 'a';
 104         }
 105     }
 106 }
 107
 108 static grub_err_t
 109 grub_freebsd_add_meta (grub_uint32_t type, void *data, grub_uint32_t len)
 110 {
 111   if (mod_buf_max < mod_buf_len + len + 8)
 112     {
 113       char *new_buf;
 114
 115       do
 116         {
 117           mod_buf_max += MOD_BUF_ALLOC_UNIT;
 118         }
 119       while (mod_buf_max < mod_buf_len + len + 8);
 120
 121       new_buf = grub_malloc (mod_buf_max);
 122       if (!new_buf)
 123         return grub_errno;
 124
 125       grub_memcpy (new_buf, mod_buf, mod_buf_len);
 126       grub_free (mod_buf);
 127
 128       mod_buf = new_buf;
 129     }
 130
 131   *((grub_uint32_t *) (mod_buf + mod_buf_len)) = type;
 132   *((grub_uint32_t *) (mod_buf + mod_buf_len + 4)) = len;
 133   mod_buf_len += 8;
 134
 135   if (len)
 136     grub_memcpy (mod_buf + mod_buf_len, data, len);
 137
 138   mod_buf_len = ALIGN_DWORD (mod_buf_len + len);
 139
 140   return GRUB_ERR_NONE;
 141 }
 142
 143 static grub_err_t
 144 grub_freebsd_add_meta_module (int is_kern, int argc, char **argv,
 145                               grub_addr_t addr, grub_uint32_t size)
 146 {
 147   char *name, *type;
 148
 149   name = grub_strrchr (argv[0], '/');
 150   if (name)
 151     name++;
 152   else
 153     name = argv[0];
 154
 155   if (grub_freebsd_add_meta (FREEBSD_MODINFO_NAME, name,
 156                              grub_strlen (name) + 1))
 157     return grub_errno;
 158
 159   argc--;
 160   argv++;
 161
 162   if ((argc) && (!grub_memcmp (argv[0], "type=", 5)))
 163     {
 164       type = &argv[0][5];
 165       argc--;
 166       argv++;
 167     }
 168   else
 169     type = (is_kern) ? FREEBSD_MODTYPE_KERNEL : FREEBSD_MODTYPE_RAW;
 170
 171   if ((grub_freebsd_add_meta (FREEBSD_MODINFO_TYPE, type,
 172                               grub_strlen (type) + 1)) ||
 173       (grub_freebsd_add_meta (FREEBSD_MODINFO_ADDR, &addr, sizeof (addr))) ||
 174       (grub_freebsd_add_meta (FREEBSD_MODINFO_SIZE, &size, sizeof (size))))
 175     return grub_errno;
 176
 177   if (argc)
 178     {
 179       int i, n;
 180
 181       n = 0;
 182       for (i = 0; i < argc; i++)
 183         {
 184           n += grub_strlen (argv[i]) + 1;
 185         }
 186
 187       if (n)
 188         {
 189           char cmdline[n], *p;
 190
 191           p = cmdline;
 192           for (i = 0; i < argc; i++)
 193             {
 194               grub_strcpy (p, argv[i]);
 195               p += grub_strlen (argv[i]);
 196               *(p++) = ' ';
 197             }
 198           *p = 0;
 199
 200           if (grub_freebsd_add_meta (FREEBSD_MODINFO_ARGS, cmdline, n))
 201             return grub_errno;
 202         }
 203     }
 204
 205   return GRUB_ERR_NONE;
 206 }
 207
 208 static void
 209 grub_freebsd_list_modules (void)
 210 {
 211   grub_uint32_t pos = 0;
 212
 213   grub_printf ("  %-18s  %-18s%14s%14s\n", "name", "type", "addr", "size");
 214   while (pos < mod_buf_len)
 215     {
 216       grub_uint32_t type, size;
 217
 218       type = *((grub_uint32_t *) (mod_buf + pos));
 219       size = *((grub_uint32_t *) (mod_buf + pos + 4));
 220       pos += 8;
 221       switch (type)
 222         {
 223         case FREEBSD_MODINFO_NAME:
 224         case FREEBSD_MODINFO_TYPE:
 225           grub_printf ("  %-18s", mod_buf + pos);
 226           break;
 227         case FREEBSD_MODINFO_ADDR:
 228           {
 229             grub_addr_t addr;
 230
 231             addr = *((grub_addr_t *) (mod_buf + pos));
 232             grub_printf ("    0x%08x", addr);
 233             break;
 234           }
 235         case FREEBSD_MODINFO_SIZE:
 236           {
 237             grub_uint32_t len;
 238
 239             len = *((grub_uint32_t *) (mod_buf + pos));
 240             grub_printf ("    0x%08x\n", len);
 241           }
 242         }
 243
 244       pos = ALIGN_DWORD (pos + size);
 245     }
 246 }
 247
 248 static grub_err_t
 249 grub_freebsd_boot (void)
 250 {
 251   struct grub_freebsd_bootinfo bi;
 252   char *p;
 253   grub_uint32_t bootdev, biosdev, unit, slice, part;
 254
 255   auto int iterate_env (struct grub_env_var *var);
 256   int iterate_env (struct grub_env_var *var)
 257   {
 258     if ((!grub_memcmp (var->name, "FreeBSD.", 8)) && (var->name[8]))
 259       {
 260         grub_strcpy (p, &var->name[8]);
 261         p += grub_strlen (p);
 262         *(p++) = '=';
 263         grub_strcpy (p, var->value);
 264         p += grub_strlen (p) + 1;
 265       }
 266
 267     return 0;
 268   }
 269
 270   grub_memset (&bi, 0, sizeof (bi));
 271   bi.bi_version = FREEBSD_BOOTINFO_VERSION;
 272   bi.bi_size = sizeof (bi);
 273
 274   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 275   bootdev = (FREEBSD_B_DEVMAGIC + ((slice + 1) << FREEBSD_B_SLICESHIFT) +
 276              (unit << FREEBSD_B_UNITSHIFT) + (part << FREEBSD_B_PARTSHIFT));
 277
 278   bi.bi_bios_dev = biosdev;
 279
 280   p = (char *) kern_end;
 281
 282   grub_env_iterate (iterate_env);
 283
 284   if (p != (char *) kern_end)
 285     {
 286       *(p++) = 0;
 287
 288       bi.bi_envp = kern_end;
 289       kern_end = ALIGN_PAGE ((grub_uint32_t) p);
 290     }
 291
 292   if (is_elf_kernel)
 293     {
 294       if (grub_freebsd_add_meta (FREEBSD_MODINFO_END, 0, 0))
 295         return grub_errno;
 296
 297       grub_memcpy ((char *) kern_end, mod_buf, mod_buf_len);
 298       bi.bi_modulep = kern_end;
 299
 300       kern_end = ALIGN_PAGE (kern_end + mod_buf_len);
 301     }
 302
 303   bi.bi_kernend = kern_end;
 304
 305   grub_unix_real_boot (entry, bootflags | FREEBSD_RB_BOOTINFO, bootdev,
 306                        0, 0, 0, &bi, bi.bi_modulep, kern_end);
 307
 308   /* Not reached.  */
 309   return GRUB_ERR_NONE;
 310 }
 311
 312 static grub_err_t
 313 grub_openbsd_boot (void)
 314 {
 315   char *buf = (char *) GRUB_BSD_TEMP_BUFFER;
 316   struct grub_machine_mmap_entry mmap;
 317   struct grub_openbsd_bios_mmap *pm;
 318   struct grub_openbsd_bootargs *pa;
 319   grub_uint32_t bootdev, biosdev, unit, slice, part, cont;
 320
 321   pa = (struct grub_openbsd_bootargs *) buf;
 322
 323   pa->ba_type = OPENBSD_BOOTARG_MMAP;
 324   pm = (struct grub_openbsd_bios_mmap *) (pa + 1);
 325   cont = grub_get_mmap_entry (&mmap, 0);
 326   if (mmap.size)
 327     do
 328       {
 329         pm->addr = mmap.addr;
 330         pm->len = mmap.len;
 331         pm->type = mmap.type;
 332         pm++;
 333
 334         if (!cont)
 335           break;
 336
 337         cont = grub_get_mmap_entry (&mmap, cont);
 338       }
 339     while (mmap.size);
 340
 341   pa->ba_size = (char *) pm - (char *) pa;
 342   pa->ba_next = (struct grub_openbsd_bootargs *) pm;
 343   pa = pa->ba_next;
 344   pa->ba_type = OPENBSD_BOOTARG_END;
 345   pa++;
 346
 347   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 348   bootdev = (OPENBSD_B_DEVMAGIC + (unit << OPENBSD_B_UNITSHIFT) +
 349              (part << OPENBSD_B_PARTSHIFT));
 350
 351   grub_unix_real_boot (entry, bootflags, bootdev, OPENBSD_BOOTARG_APIVER,
 352                        0, grub_upper_mem >> 10, grub_lower_mem >> 10,
 353                        (char *) pa - buf, buf);
 354
 355   /* Not reached.  */
 356   return GRUB_ERR_NONE;
 357 }
 358
 359 static grub_err_t
 360 grub_netbsd_boot (void)
 361 {
 362   struct grub_netbsd_btinfo_rootdevice *rootdev;
 363   struct grub_netbsd_bootinfo *bootinfo;
 364   grub_uint32_t biosdev, unit, slice, part;
 365
 366   grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 367
 368   rootdev = (struct grub_netbsd_btinfo_rootdevice *) GRUB_BSD_TEMP_BUFFER;
 369
 370   rootdev->common.len = sizeof (struct grub_netbsd_btinfo_rootdevice);
 371   rootdev->common.type = NETBSD_BTINFO_ROOTDEVICE;
 372   grub_sprintf (rootdev->devname, "%cd%d%c", (biosdev & 0x80) ? 'w' : 'f',
 373                 unit, 'a' + part);
 374
 375   bootinfo = (struct grub_netbsd_bootinfo *) (rootdev + 1);
 376   bootinfo->bi_count = 1;
 377   bootinfo->bi_data[0] = rootdev;
 378
 379   grub_unix_real_boot (entry, bootflags, 0, bootinfo,
 380                        0, grub_upper_mem >> 10, grub_lower_mem >> 10);
 381
 382   /* Not reached.  */
 383   return GRUB_ERR_NONE;
 384 }
 385
 386 static grub_err_t
 387 grub_bsd_unload (void)
 388 {
 389   if (mod_buf)
 390     {
 391       grub_free (mod_buf);
 392       mod_buf = 0;
 393       mod_buf_max = 0;
 394     }
 395
 396   kernel_type = KERNEL_TYPE_NONE;
 397   grub_dl_unref (my_mod);
 398
 399   return GRUB_ERR_NONE;
 400 }
 401
 402 static grub_err_t
 403 grub_bsd_load_aout (grub_file_t file)
 404 {
 405   grub_addr_t load_addr, bss_end_addr;
 406   int ofs, align_page;
 407   union grub_aout_header ah;
 408
 409   if ((grub_file_seek (file, 0)) == (grub_off_t) - 1)
 410     return grub_errno;
 411
 412   if (grub_file_read (file, (char *) &ah, sizeof (ah)) != sizeof (ah))
 413     return grub_error (GRUB_ERR_READ_ERROR, "cannot read the a.out header");
 414
 415   if (grub_aout_get_type (&ah) != AOUT_TYPE_AOUT32)
 416     return grub_error (GRUB_ERR_BAD_OS, "invalid a.out header");
 417
 418   entry = ah.aout32.a_entry & 0xFFFFFF;
 419
 420   if (AOUT_GETMAGIC (ah.aout32) == AOUT32_ZMAGIC)
 421     {
 422       load_addr = entry;
 423       ofs = 0x1000;
 424       align_page = 0;
 425     }
 426   else
 427     {
 428       load_addr = entry & 0xF00000;
 429       ofs = sizeof (struct grub_aout32_header);
 430       align_page = 1;
 431     }
 432
 433   if (load_addr < 0x100000)
 434     return grub_error (GRUB_ERR_BAD_OS, "load address below 1M");
 435
 436   kern_start = load_addr;
 437   kern_end = load_addr + ah.aout32.a_text + ah.aout32.a_data;
 438   if (align_page)
 439     kern_end = ALIGN_PAGE (kern_end);
 440
 441   if (ah.aout32.a_bss)
 442     {
 443       kern_end += ah.aout32.a_bss;
 444       if (align_page)
 445         kern_end = ALIGN_PAGE (kern_end);
 446
 447       bss_end_addr = kern_end;
 448     }
 449   else
 450     bss_end_addr = 0;
 451
 452   return grub_aout_load (file, ofs, load_addr,
 453                          ah.aout32.a_text + ah.aout32.a_data, bss_end_addr);
 454 }
 455
 456 static grub_err_t
 457 grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr)
 458 {
 459   Elf32_Addr paddr;
 460
 461   phdr->p_paddr &= 0xFFFFFF;
 462   paddr = phdr->p_paddr;
 463
 464   if ((paddr < grub_os_area_addr)
 465       || (paddr + phdr->p_memsz > grub_os_area_addr + grub_os_area_size))
 466     return grub_error (GRUB_ERR_OUT_OF_RANGE, "Address 0x%x is out of range",
 467                        paddr);
 468
 469   if ((!kern_start) || (paddr < kern_start))
 470     kern_start = paddr;
 471
 472   if (paddr + phdr->p_memsz > kern_end)
 473     kern_end = paddr + phdr->p_memsz;
 474
 475   *addr = paddr;
 476
 477   return GRUB_ERR_NONE;
 478 }
 479
 480 static grub_err_t
 481 grub_bsd_load_elf (grub_elf_t elf)
 482 {
 483   kern_start = kern_end = 0;
 484
 485   if (grub_elf_is_elf32 (elf))
 486     {
 487       entry = elf->ehdr.ehdr32.e_entry & 0xFFFFFF;
 488       return grub_elf32_load (elf, grub_bsd_elf32_hook, 0, 0);
 489     }
 490   else
 491     return grub_error (GRUB_ERR_BAD_OS, "invalid elf");
 492 }
 493
 494 static grub_err_t
 495 grub_bsd_load (int argc, char *argv[])
 496 {
 497   grub_file_t file;
 498   grub_elf_t elf;
 499
 500   grub_dl_ref (my_mod);
 501
 502   grub_loader_unset ();
 503
 504   if (argc == 0)
 505     {
 506       grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
 507       goto fail;
 508     }
 509
 510   file = grub_gzfile_open (argv[0], 1);
 511   if (!file)
 512     goto fail;
 513
 514   elf = grub_elf_file (file);
 515   if (elf)
 516     {
 517       is_elf_kernel = 1;
 518       grub_bsd_load_elf (elf);
 519       grub_elf_close (elf);
 520     }
 521   else
 522     {
 523       is_elf_kernel = 0;
 524       grub_errno = 0;
 525       grub_bsd_load_aout (file);
 526       grub_file_close (file);
 527     }
 528
 529 fail:
 530
 531   if (grub_errno != GRUB_ERR_NONE)
 532     grub_dl_unref (my_mod);
 533
 534   return grub_errno;
 535 }
 536
 537 static grub_uint32_t
 538 grub_bsd_parse_flags (char *str, const char *opts,
 539                       const grub_uint32_t * flags)
 540 {
 541   grub_uint32_t result = 0;
 542
 543   while (*str)
 544     {
 545       const char *po;
 546       const grub_uint32_t *pf;
 547
 548       po = opts;
 549       pf = flags;
 550       while (*po)
 551         {
 552           if (*str == *po)
 553             {
 554               result |= *pf;
 555               break;
 556             }
 557           po++;
 558           pf++;
 559         }
 560       str++;
 561     }
 562
 563   return result;
 564 }
 565
 566 void
 567 grub_rescue_cmd_freebsd (int argc, char *argv[])
 568 {
 569   kernel_type = KERNEL_TYPE_FREEBSD;
 570   bootflags = ((argc <= 1) ? 0 :
 571                grub_bsd_parse_flags (argv[1], freebsd_opts, freebsd_flags));
 572
 573   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 574     {
 575       kern_end = ALIGN_PAGE (kern_end);
 576       if ((is_elf_kernel) &&
 577           (grub_freebsd_add_meta_module (1, argc, argv, kern_start,
 578                                          kern_end - kern_start)))
 579         return;
 580       grub_loader_set (grub_freebsd_boot, grub_bsd_unload, 1);
 581     }
 582 }
 583
 584 void
 585 grub_rescue_cmd_openbsd (int argc, char *argv[])
 586 {
 587   kernel_type = KERNEL_TYPE_OPENBSD;
 588   bootflags = ((argc <= 1) ? 0 :
 589                grub_bsd_parse_flags (argv[1], openbsd_opts, openbsd_flags));
 590
 591   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 592     grub_loader_set (grub_openbsd_boot, grub_bsd_unload, 1);
 593 }
 594
 595 void
 596 grub_rescue_cmd_netbsd (int argc, char *argv[])
 597 {
 598   kernel_type = KERNEL_TYPE_NETBSD;
 599   bootflags = ((argc <= 1) ? 0 :
 600                grub_bsd_parse_flags (argv[1], netbsd_opts, netbsd_flags));
 601
 602   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
 603     grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 1);
 604 }
 605
 606 void
 607 grub_rescue_cmd_freebsd_loadenv (int argc, char *argv[])
 608 {
 609   grub_file_t file = 0;
 610   char *buf = 0, *curr, *next;
 611   int len;
 612
 613   if (kernel_type != KERNEL_TYPE_FREEBSD)
 614     {
 615       grub_error (GRUB_ERR_BAD_ARGUMENT, "only freebsd support environment");
 616       return;
 617     }
 618
 619   if (argc == 0)
 620     {
 621       grub_error (GRUB_ERR_BAD_ARGUMENT, "no filename");
 622       goto fail;
 623     }
 624
 625   file = grub_gzfile_open (argv[0], 1);
 626   if ((!file) || (!file->size))
 627     goto fail;
 628
 629   len = file->size;
 630   buf = grub_malloc (len + 1);
 631   if (!buf)
 632     goto fail;
 633
 634   if (grub_file_read (file, buf, len) != len)
 635     goto fail;
 636
 637   buf[len] = 0;
 638
 639   next = buf;
 640   while (next)
 641     {
 642       char *p;
 643
 644       curr = next;
 645       next = grub_strchr (curr, '\n');
 646       if (next)
 647         {
 648
 649           p = next - 1;
 650           while (p > curr)
 651             {
 652               if ((*p != '\r') && (*p != ' ') && (*p != '\t'))
 653                 break;
 654               p--;
 655             }
 656
 657           if ((p > curr) && (*p == '"'))
 658             p--;
 659
 660           *(p + 1) = 0;
 661           next++;
 662         }
 663
 664       if (*curr == '#')
 665         continue;
 666
 667       p = grub_strchr (curr, '=');
 668       if (!p)
 669         continue;
 670
 671       *(p++) = 0;
 672
 673       if (*curr)
 674         {
 675           char name[grub_strlen (curr) + 8 + 1];
 676
 677           if (*p == '"')
 678             p++;
 679
 680           grub_sprintf (name, "FreeBSD.%s", curr);
 681           if (grub_env_set (name, p))
 682             goto fail;
 683         }
 684     }
 685
 686 fail:
 687   grub_free (buf);
 688
 689   if (file)
 690     grub_file_close (file);
 691 }
 692
 693 void
 694 grub_rescue_cmd_freebsd_module (int argc, char *argv[])
 695 {
 696   grub_file_t file = 0;
 697
 698   if (kernel_type != KERNEL_TYPE_FREEBSD)
 699     {
 700       grub_error (GRUB_ERR_BAD_ARGUMENT, "only freebsd support module");
 701       return;
 702     }
 703
 704   if (!is_elf_kernel)
 705     {
 706       grub_error (GRUB_ERR_BAD_ARGUMENT, "only elf kernel support module");
 707       return;
 708     }
 709
 710   /* List the current modules if no parameter.  */
 711   if (!argc)
 712     {
 713       grub_freebsd_list_modules ();
 714       return;
 715     }
 716
 717   file = grub_gzfile_open (argv[0], 1);
 718   if ((!file) || (!file->size))
 719     goto fail;
 720
 721   if (kern_end + file->size > grub_os_area_addr + grub_os_area_size)
 722     {
 723       grub_error (GRUB_ERR_OUT_OF_RANGE, "Not enough memory for the module");
 724       goto fail;
 725     }
 726
 727   grub_file_read (file, (char *) kern_end, file->size);
 728   if ((!grub_errno) &&
 729       (!grub_freebsd_add_meta_module (0, argc, argv, kern_end, file->size)))
 730     kern_end = ALIGN_PAGE (kern_end + file->size);
 731
 732 fail:
 733   if (file)
 734     grub_file_close (file);
 735 }
 736
 737 GRUB_MOD_INIT (bsd)
 738 {
 739   grub_rescue_register_command ("freebsd",
 740                                 grub_rescue_cmd_freebsd,
 741                                 "load freebsd kernel");
 742   grub_rescue_register_command ("openbsd",
 743                                 grub_rescue_cmd_openbsd,
 744                                 "load openbsd kernel");
 745   grub_rescue_register_command ("netbsd",
 746                                 grub_rescue_cmd_netbsd, "load netbsd kernel");
 747
 748   grub_rescue_register_command ("freebsd_loadenv",
 749                                 grub_rescue_cmd_freebsd_loadenv,
 750                                 "load freebsd env");
 751   grub_rescue_register_command ("freebsd_module",
 752                                 grub_rescue_cmd_freebsd_module,
 753                                 "load freebsd module");
 754
 755   my_mod = mod;
 756 }
 757
 758 GRUB_MOD_FINI (bsd)
 759 {
 760   grub_rescue_unregister_command ("freebsd");
 761   grub_rescue_unregister_command ("openbsd");
 762   grub_rescue_unregister_command ("netbsd");
 763
 764   grub_rescue_unregister_command ("freebsd_loadenv");
 765   grub_rescue_unregister_command ("freebsd_module");
 766
 767   if (mod_buf)
 768     {
 769       grub_free (mod_buf);
 770       mod_buf = 0;
 771       mod_buf_max = 0;
 772     }
 773 }