← Back to branch summary

~ilya-yanok/ubuntu/precise/grub2/fix-for-948716

« back to all changes in this revision

Viewing changes to loader/i386/bsd.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Millan
  • Date: 2009-07-25 19:00:53 UTC
  • mfrom: (1.6.3 upstream)
  • mto: (17.4.13 sid)
  • mto: This revision was merged to the branch mainline in revision 53.
  • Revision ID: james.westby@ubuntu.com-20090725190053-uv3lm6ya3zxs77ep
Import upstream version 1.96+20090725

Show diffs side-by-side

added added

removed removed

Lines of Context:
loader/i386/bsd.c
19
19
#include <grub/loader.h>
20
20
#include <grub/cpu/loader.h>
21
21
#include <grub/cpu/bsd.h>
22
 
#include <grub/i386/cpuid.h>
23
22
#include <grub/machine/init.h>
24
23
#include <grub/machine/memory.h>
25
24
#include <grub/memory.h>
34
33
#include <grub/gzio.h>
35
34
#include <grub/aout.h>
36
35
#include <grub/command.h>
37
 
#include <grub/extcmd.h>
38
 
 
39
36
#ifdef GRUB_MACHINE_PCBIOS
40
37
#include <grub/machine/biosnum.h>
41
 
#endif
42
38
#include <grub/disk.h>
43
39
#include <grub/device.h>
44
40
#include <grub/partition.h>
 
41
#endif
45
42
 
46
43
#define ALIGN_DWORD(a)  ALIGN_UP (a, 4)
47
44
#define ALIGN_QWORD(a)  ALIGN_UP (a, 8)
50
47
 
51
48
#define MOD_BUF_ALLOC_UNIT      4096
52
49
 
53
 
static int kernel_type = KERNEL_TYPE_NONE;
 
50
static int kernel_type;
54
51
static grub_dl_t my_mod;
55
52
static grub_addr_t entry, entry_hi, kern_start, kern_end;
56
53
static grub_uint32_t bootflags;
57
54
static char *mod_buf;
58
55
static grub_uint32_t mod_buf_len, mod_buf_max, kern_end_mdofs;
59
56
static int is_elf_kernel, is_64bit;
60
 
static char *netbsd_root = NULL;
61
 
static grub_uint32_t openbsd_root;
62
 
 
63
 
static const struct grub_arg_option freebsd_opts[] =
64
 
  {
65
 
    {"dual", 'D', 0, "Display output on all consoles.", 0, 0},
66
 
    {"serial", 'h', 0, "Use serial console.", 0, 0},
67
 
    {"askname", 'a', 0, "Ask for file name to reboot from.", 0, 0},
68
 
    {"cdrom", 'C', 0, "Use cdrom as root.", 0, 0},
69
 
    {"config", 'c', 0, "Invoke user configuration routing.", 0, 0},
70
 
    {"kdb", 'd', 0, "Enter in KDB on boot.", 0, 0},
71
 
    {"gdb", 'g', 0, "Use GDB remote debugger instead of DDB.", 0, 0},
72
 
    {"mute", 'm', 0, "Disable all boot output.", 0, 0},
73
 
    {"nointr", 'n', 0, "", 0, 0},
74
 
    {"pause", 'p', 0, "Wait for keypress after every line of output.", 0, 0},
75
 
    {"quiet", 'q', 0, "", 0, 0},
76
 
    {"dfltroot", 'r', 0, "Use compiled-in rootdev.", 0, 0},
77
 
    {"single", 's', 0, "Boot into single mode.", 0, 0},
78
 
    {"verbose", 'v', 0, "Boot with verbose messages.", 0, 0},
79
 
    {0, 0, 0, 0, 0, 0}
80
 
  };
81
 
 
 
57
 
 
58
static const char freebsd_opts[] = "DhaCcdgmnpqrsv";
82
59
static const grub_uint32_t freebsd_flags[] =
83
60
{
84
61
  FREEBSD_RB_DUAL, FREEBSD_RB_SERIAL, FREEBSD_RB_ASKNAME,
85
62
  FREEBSD_RB_CDROM, FREEBSD_RB_CONFIG, FREEBSD_RB_KDB,
86
63
  FREEBSD_RB_GDB, FREEBSD_RB_MUTE, FREEBSD_RB_NOINTR,
87
64
  FREEBSD_RB_PAUSE, FREEBSD_RB_QUIET, FREEBSD_RB_DFLTROOT,
88
 
  FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE, 0
 
65
  FREEBSD_RB_SINGLE, FREEBSD_RB_VERBOSE
89
66
};
90
67
 
91
 
static const struct grub_arg_option openbsd_opts[] =
92
 
  {
93
 
    {"askname", 'a', 0, "Ask for file name to reboot from.", 0, 0},
94
 
    {"halt", 'b', 0, "Don't reboot, just halt.", 0, 0},
95
 
    {"config", 'c', 0, "Change configured devices.", 0, 0},
96
 
    {"single", 's', 0, "Boot into single mode.", 0, 0},
97
 
    {"kdb", 'd', 0, "Enter in KDB on boot.", 0, 0},
98
 
    {"root", 'r', 0, "Set root device.", "wdXY", ARG_TYPE_STRING},
99
 
    {0, 0, 0, 0, 0, 0}
100
 
  };
101
 
 
 
68
static const char openbsd_opts[] = "abcsd";
102
69
static const grub_uint32_t openbsd_flags[] =
103
70
{
104
71
  OPENBSD_RB_ASKNAME, OPENBSD_RB_HALT, OPENBSD_RB_CONFIG,
105
 
  OPENBSD_RB_SINGLE, OPENBSD_RB_KDB, 0
 
72
  OPENBSD_RB_SINGLE, OPENBSD_RB_KDB
106
73
};
107
74
 
108
 
#define OPENBSD_ROOT_ARG (ARRAY_SIZE (openbsd_flags) - 1)
109
 
 
110
 
static const struct grub_arg_option netbsd_opts[] =
111
 
  {
112
 
    {"no-smp", '1', 0, "Disable SMP.", 0, 0},
113
 
    {"no-acpi", '2', 0, "Disable ACPI.", 0, 0},
114
 
    {"askname", 'a', 0, "Ask for file name to reboot from.", 0, 0},
115
 
    {"halt", 'b', 0, "Don't reboot, just halt.", 0, 0},
116
 
    {"config", 'c', 0, "Change configured devices.", 0, 0},
117
 
    {"kdb", 'd', 0, "Enter in KDB on boot.", 0, 0},
118
 
    {"miniroot", 'm', 0, "", 0, 0},
119
 
    {"quiet", 'q', 0, "Don't display boot diagnostic messages.", 0, 0},
120
 
    {"single", 's', 0, "Boot into single mode.", 0, 0},
121
 
    {"verbose", 'v', 0, "Boot with verbose messages.", 0, 0},
122
 
    {"debug", 'x', 0, "Boot with debug messages.", 0, 0},
123
 
    {"silent", 'z', 0, "Supress normal output (warnings remain).", 0, 0},
124
 
    {"root", 'r', 0, "Set root device.", "DEVICE", ARG_TYPE_STRING},
125
 
    {0, 0, 0, 0, 0, 0}
126
 
  };
127
 
 
 
75
static const char netbsd_opts[] = "abcdmqsvxz";
128
76
static const grub_uint32_t netbsd_flags[] =
129
77
{
130
 
  NETBSD_AB_NOSMP, NETBSD_AB_NOACPI, NETBSD_RB_ASKNAME,
131
 
  NETBSD_RB_HALT, NETBSD_RB_USERCONFIG, NETBSD_RB_KDB,
132
 
  NETBSD_RB_MINIROOT, NETBSD_AB_QUIET, NETBSD_RB_SINGLE,
133
 
  NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG, NETBSD_AB_SILENT, 0
 
78
  NETBSD_RB_ASKNAME, NETBSD_RB_HALT, NETBSD_RB_USERCONFIG,
 
79
  NETBSD_RB_KDB, NETBSD_RB_MINIROOT, NETBSD_AB_QUIET,
 
80
  NETBSD_RB_SINGLE, NETBSD_AB_VERBOSE, NETBSD_AB_DEBUG,
 
81
  NETBSD_AB_SILENT
134
82
};
135
83
 
136
 
#define NETBSD_ROOT_ARG (ARRAY_SIZE (netbsd_flags) - 1)
137
 
 
138
84
static void
139
85
grub_bsd_get_device (grub_uint32_t * biosdev,
140
86
                     grub_uint32_t * unit,
143
89
  char *p;
144
90
  grub_device_t dev; 
145
91
 
146
 
#ifdef GRUB_MACHINE_PCBIOS
147
92
  *biosdev = grub_get_root_biosnumber () & 0xff;
148
 
#else
149
 
  *biosdev = 0xff;
150
 
#endif
151
93
  *unit = (*biosdev & 0x7f);
152
94
  *slice = 0xff;
153
95
  *part = 0xff;
448
390
  auto int iterate_env (struct grub_env_var *var);
449
391
  int iterate_env (struct grub_env_var *var)
450
392
  {
451
 
    if ((!grub_memcmp (var->name, "kFreeBSD.", sizeof("kFreeBSD.") - 1)) && (var->name[sizeof("kFreeBSD.") - 1]))
 
393
    if ((!grub_memcmp (var->name, "FreeBSD.", 8)) && (var->name[8]))
452
394
      {
453
 
        grub_strcpy (p, &var->name[sizeof("kFreeBSD.") - 1]);
 
395
        grub_strcpy (p, &var->name[8]);
454
396
        p += grub_strlen (p);
455
397
        *(p++) = '=';
456
398
        grub_strcpy (p, var->value);
569
511
  char *buf = (char *) GRUB_BSD_TEMP_BUFFER;
570
512
  struct grub_openbsd_bios_mmap *pm;
571
513
  struct grub_openbsd_bootargs *pa;
 
514
  grub_uint32_t bootdev, biosdev, unit, slice, part;
572
515
 
573
516
  auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
574
517
  int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
582
525
          pm->type = OPENBSD_MMAP_AVAILABLE;
583
526
          break;
584
527
 
585
 
        case GRUB_MACHINE_MEMORY_ACPI:
586
 
          pm->type = OPENBSD_MMAP_ACPI;
587
 
          break;
588
 
 
589
 
        case GRUB_MACHINE_MEMORY_NVS:
590
 
          pm->type = OPENBSD_MMAP_NVS;
591
 
          break;
592
 
 
593
528
        default:
594
529
          pm->type = OPENBSD_MMAP_RESERVED;
595
530
          break;
605
540
  pm = (struct grub_openbsd_bios_mmap *) (pa + 1);
606
541
  grub_mmap_iterate (hook);
607
542
 
608
 
  /* Memory map terminator.  */
609
 
  pm->addr = 0;
610
 
  pm->len = 0;
611
 
  pm->type = 0;
612
 
  pm++;
613
 
 
614
543
  pa->ba_size = (char *) pm - (char *) pa;
615
544
  pa->ba_next = (struct grub_openbsd_bootargs *) pm;
616
545
  pa = pa->ba_next;
617
546
  pa->ba_type = OPENBSD_BOOTARG_END;
618
547
  pa++;
619
548
 
620
 
  grub_unix_real_boot (entry, bootflags, openbsd_root, OPENBSD_BOOTARG_APIVER,
621
 
                       0, (grub_uint32_t) (grub_mmap_get_upper () >> 10),
622
 
                       (grub_uint32_t) (grub_mmap_get_lower () >> 10),
 
549
  grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 
550
  bootdev = (OPENBSD_B_DEVMAGIC + (unit << OPENBSD_B_UNITSHIFT) +
 
551
             (part << OPENBSD_B_PARTSHIFT));
 
552
 
 
553
  grub_unix_real_boot (entry, bootflags, bootdev, OPENBSD_BOOTARG_APIVER,
 
554
                       0, grub_mmap_get_upper () >> 10,
 
555
                       grub_mmap_get_lower () >> 10,
623
556
                       (char *) pa - buf, buf);
624
557
 
625
558
  /* Not reached.  */
629
562
static grub_err_t
630
563
grub_netbsd_boot (void)
631
564
{
 
565
  struct grub_netbsd_btinfo_rootdevice *rootdev;
632
566
  struct grub_netbsd_bootinfo *bootinfo;
633
 
  int count = 0;
634
 
  struct grub_netbsd_btinfo_mmap_header *mmap;
635
 
  struct grub_netbsd_btinfo_mmap_entry *pm;
636
 
  void *curarg;
637
 
 
638
 
  auto int NESTED_FUNC_ATTR count_hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
639
 
  int NESTED_FUNC_ATTR count_hook (grub_uint64_t addr __attribute__ ((unused)),
640
 
                                   grub_uint64_t size __attribute__ ((unused)),
641
 
                                   grub_uint32_t type __attribute__ ((unused)))
642
 
  {
643
 
    count++;
644
 
    return 0;
645
 
  }
646
 
 
647
 
  auto int NESTED_FUNC_ATTR fill_hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
648
 
  int NESTED_FUNC_ATTR fill_hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
649
 
  {
650
 
    pm->addr = addr;
651
 
    pm->len = size;
652
 
 
653
 
    switch (type)
654
 
      {
655
 
      case GRUB_MACHINE_MEMORY_AVAILABLE:
656
 
        pm->type = NETBSD_MMAP_AVAILABLE;
657
 
        break;
658
 
 
659
 
      case GRUB_MACHINE_MEMORY_ACPI:
660
 
        pm->type = NETBSD_MMAP_ACPI;
661
 
        break;
662
 
 
663
 
      case GRUB_MACHINE_MEMORY_NVS:
664
 
        pm->type = NETBSD_MMAP_NVS;
665
 
        break;
666
 
 
667
 
      default:
668
 
        pm->type = NETBSD_MMAP_RESERVED;
669
 
        break;
670
 
      }
671
 
    pm++;
672
 
 
673
 
    return 0;
674
 
  }
675
 
 
676
 
  grub_mmap_iterate (count_hook);
677
 
 
678
 
  if (kern_end + sizeof (struct grub_netbsd_btinfo_rootdevice)
679
 
      + sizeof (struct grub_netbsd_bootinfo)
680
 
      + sizeof (struct grub_netbsd_btinfo_mmap_header)
681
 
      + count * sizeof (struct grub_netbsd_btinfo_mmap_entry)
682
 
      > grub_os_area_addr + grub_os_area_size)
683
 
    return grub_error (GRUB_ERR_OUT_OF_MEMORY, "No memory for boot info.");
684
 
 
685
 
  curarg = mmap = (struct grub_netbsd_btinfo_mmap_header *) kern_end;
686
 
  pm = (struct grub_netbsd_btinfo_mmap_entry *) (mmap + 1);
687
 
 
688
 
  grub_mmap_iterate (fill_hook);
689
 
  mmap->common.type = NETBSD_BTINFO_MEMMAP;
690
 
  mmap->common.len = (char *) pm - (char *) mmap;
691
 
  mmap->count = count;
692
 
  curarg = pm;
693
 
 
694
 
  if (netbsd_root)
695
 
    {
696
 
      struct grub_netbsd_btinfo_rootdevice *rootdev;
697
 
 
698
 
      rootdev = (struct grub_netbsd_btinfo_rootdevice *) curarg;
699
 
 
700
 
      rootdev->common.len = sizeof (struct grub_netbsd_btinfo_rootdevice);
701
 
      rootdev->common.type = NETBSD_BTINFO_ROOTDEVICE;
702
 
      grub_strncpy (rootdev->devname, netbsd_root, sizeof (rootdev->devname));
703
 
 
704
 
      bootinfo = (struct grub_netbsd_bootinfo *) (rootdev + 1);
705
 
      bootinfo->bi_count = 2;
706
 
      bootinfo->bi_data[0] = mmap;
707
 
      bootinfo->bi_data[1] = rootdev;
708
 
    }
709
 
  else
710
 
    {
711
 
      bootinfo = (struct grub_netbsd_bootinfo *) curarg;
712
 
      bootinfo->bi_count = 1;
713
 
      bootinfo->bi_data[0] = mmap;
714
 
    }
 
567
  grub_uint32_t biosdev, unit, slice, part;
 
568
 
 
569
  grub_bsd_get_device (&biosdev, &unit, &slice, &part);
 
570
 
 
571
  rootdev = (struct grub_netbsd_btinfo_rootdevice *) GRUB_BSD_TEMP_BUFFER;
 
572
 
 
573
  rootdev->common.len = sizeof (struct grub_netbsd_btinfo_rootdevice);
 
574
  rootdev->common.type = NETBSD_BTINFO_ROOTDEVICE;
 
575
  grub_sprintf (rootdev->devname, "%cd%d%c", (biosdev & 0x80) ? 'w' : 'f',
 
576
                unit, 'a' + part);
 
577
 
 
578
  bootinfo = (struct grub_netbsd_bootinfo *) (rootdev + 1);
 
579
  bootinfo->bi_count = 1;
 
580
  bootinfo->bi_data[0] = rootdev;
715
581
 
716
582
  grub_unix_real_boot (entry, bootflags, 0, bootinfo,
717
 
                       0, (grub_uint32_t) (grub_mmap_get_upper () >> 10),
718
 
                       (grub_uint32_t) (grub_mmap_get_lower () >> 10));
 
583
                       0, grub_mmap_get_upper () >> 10,
 
584
                       grub_mmap_get_lower () >> 10);
719
585
 
720
586
  /* Not reached.  */
721
587
  return GRUB_ERR_NONE;
734
600
  kernel_type = KERNEL_TYPE_NONE;
735
601
  grub_dl_unref (my_mod);
736
602
 
737
 
  grub_free (netbsd_root);
738
 
  netbsd_root = NULL;
739
 
 
740
603
  return GRUB_ERR_NONE;
741
604
}
742
605
 
751
614
    return grub_errno;
752
615
 
753
616
  if (grub_file_read (file, &ah, sizeof (ah)) != sizeof (ah))
754
 
    return grub_error (GRUB_ERR_READ_ERROR, "Cannot read the a.out header");
 
617
    return grub_error (GRUB_ERR_READ_ERROR, "cannot read the a.out header");
755
618
 
756
619
  if (grub_aout_get_type (&ah) != AOUT_TYPE_AOUT32)
757
 
    return grub_error (GRUB_ERR_BAD_OS, "Invalid a.out header");
 
620
    return grub_error (GRUB_ERR_BAD_OS, "invalid a.out header");
758
621
 
759
622
  entry = ah.aout32.a_entry & 0xFFFFFF;
760
623
 
772
635
    }
773
636
 
774
637
  if (load_addr < 0x100000)
775
 
    return grub_error (GRUB_ERR_BAD_OS, "Load address below 1M");
 
638
    return grub_error (GRUB_ERR_BAD_OS, "load address below 1M");
776
639
 
777
640
  kern_start = load_addr;
778
641
  kern_end = load_addr + ah.aout32.a_text + ah.aout32.a_data;
870
733
  else if (grub_elf_is_elf64 (elf))
871
734
    {
872
735
      is_64bit = 1;
873
 
 
874
 
      if (! grub_cpuid_has_longmode)
875
 
        return grub_error (GRUB_ERR_BAD_OS, "Your CPU does not implement AMD64 architecture.");
876
 
 
877
 
      /* FreeBSD has 64-bit entry point.  */
878
 
      if (kernel_type == KERNEL_TYPE_FREEBSD)
879
 
        {
880
 
          entry = elf->ehdr.ehdr64.e_entry & 0xffffffff;
881
 
          entry_hi = (elf->ehdr.ehdr64.e_entry >> 32) & 0xffffffff;
882
 
        }
883
 
      else
884
 
        {
885
 
          entry = elf->ehdr.ehdr64.e_entry & 0x0fffffff;
886
 
          entry_hi = 0;
887
 
        }
 
736
      entry = elf->ehdr.ehdr64.e_entry & 0xffffffff;
 
737
      entry_hi = (elf->ehdr.ehdr64.e_entry >> 32) & 0xffffffff;
888
738
      return grub_elf64_load (elf, grub_bsd_elf64_hook, 0, 0);
889
739
    }
890
740
  else
891
 
    return grub_error (GRUB_ERR_BAD_OS, "Invalid elf");
 
741
    return grub_error (GRUB_ERR_BAD_OS, "invalid elf");
892
742
}
893
743
 
894
744
static grub_err_t
903
753
 
904
754
  if (argc == 0)
905
755
    {
906
 
      grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
 
756
      grub_error (GRUB_ERR_BAD_ARGUMENT, "no kernel specified");
907
757
      goto fail;
908
758
    }
909
759
 
935
785
}
936
786
 
937
787
static grub_uint32_t
938
 
grub_bsd_parse_flags (const struct grub_arg_list *state,
 
788
grub_bsd_parse_flags (char *str, const char *opts,
939
789
                      const grub_uint32_t * flags)
940
790
{
941
791
  grub_uint32_t result = 0;
942
 
  unsigned i;
943
 
 
944
 
  for (i = 0; flags[i]; i++)
945
 
    if (state[i].set)
946
 
      result |= flags[i];
 
792
 
 
793
  while (*str)
 
794
    {
 
795
      const char *po;
 
796
      const grub_uint32_t *pf;
 
797
 
 
798
      po = opts;
 
799
      pf = flags;
 
800
      while (*po)
 
801
        {
 
802
          if (*str == *po)
 
803
            {
 
804
              result |= *pf;
 
805
              break;
 
806
            }
 
807
          po++;
 
808
          pf++;
 
809
        }
 
810
      str++;
 
811
    }
947
812
 
948
813
  return result;
949
814
}
950
815
 
951
816
static grub_err_t
952
 
grub_cmd_freebsd (grub_extcmd_t cmd, int argc, char *argv[])
 
817
grub_cmd_freebsd (grub_command_t cmd __attribute__ ((unused)),
 
818
                  int argc, char *argv[])
953
819
{
954
820
  kernel_type = KERNEL_TYPE_FREEBSD;
955
 
  bootflags = grub_bsd_parse_flags (cmd->state, freebsd_flags);
 
821
  bootflags = ((argc <= 1) ? 0 :
 
822
               grub_bsd_parse_flags (argv[1], freebsd_opts, freebsd_flags));
956
823
 
957
824
  if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
958
825
    {
1012
879
}
1013
880
 
1014
881
static grub_err_t
1015
 
grub_cmd_openbsd (grub_extcmd_t cmd, int argc, char *argv[])
 
882
grub_cmd_openbsd (grub_command_t cmd __attribute__ ((unused)),
 
883
                  int argc, char *argv[])
1016
884
{
1017
 
  grub_uint32_t bootdev;
1018
 
 
1019
885
  kernel_type = KERNEL_TYPE_OPENBSD;
1020
 
  bootflags = grub_bsd_parse_flags (cmd->state, openbsd_flags);
1021
 
 
1022
 
  if (cmd->state[OPENBSD_ROOT_ARG].set)
1023
 
    {
1024
 
      const char *arg = cmd->state[OPENBSD_ROOT_ARG].arg;
1025
 
      int unit, part;
1026
 
      if (*(arg++) != 'w' || *(arg++) != 'd')
1027
 
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
1028
 
                           "Only device specifications of form "
1029
 
                           "wd<number><lowercase letter> are supported.");
1030
 
 
1031
 
      unit = grub_strtoul (arg, (char **) &arg, 10);
1032
 
      if (! (arg && *arg >= 'a' && *arg <= 'z'))
1033
 
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
1034
 
                           "Only device specifications of form "
1035
 
                           "wd<number><lowercase letter> are supported.");
1036
 
 
1037
 
      part = *arg - 'a';
1038
 
 
1039
 
      bootdev = (OPENBSD_B_DEVMAGIC + (unit << OPENBSD_B_UNITSHIFT) +
1040
 
                 (part << OPENBSD_B_PARTSHIFT));
1041
 
    }
1042
 
  else
1043
 
    bootdev = 0;
 
886
  bootflags = ((argc <= 1) ? 0 :
 
887
               grub_bsd_parse_flags (argv[1], openbsd_opts, openbsd_flags));
1044
888
 
1045
889
  if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
1046
 
    {
1047
 
      grub_loader_set (grub_openbsd_boot, grub_bsd_unload, 1);
1048
 
      openbsd_root = bootdev;
1049
 
    }
 
890
    grub_loader_set (grub_openbsd_boot, grub_bsd_unload, 1);
1050
891
 
1051
892
  return grub_errno;
1052
893
}
1053
894
 
1054
895
static grub_err_t
1055
 
grub_cmd_netbsd (grub_extcmd_t cmd, int argc, char *argv[])
 
896
grub_cmd_netbsd (grub_command_t cmd __attribute__ ((unused)),
 
897
                 int argc, char *argv[])
1056
898
{
1057
899
  kernel_type = KERNEL_TYPE_NETBSD;
1058
 
  bootflags = grub_bsd_parse_flags (cmd->state, netbsd_flags);
 
900
  bootflags = ((argc <= 1) ? 0 :
 
901
               grub_bsd_parse_flags (argv[1], netbsd_opts, netbsd_flags));
1059
902
 
1060
903
  if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
1061
 
    {
1062
 
      grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 1);
1063
 
      if (cmd->state[NETBSD_ROOT_ARG].set)
1064
 
        netbsd_root = grub_strdup (cmd->state[NETBSD_ROOT_ARG].arg);
1065
 
    }
 
904
    grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 1);
1066
905
 
1067
906
  return grub_errno;
1068
907
}
1075
914
  char *buf = 0, *curr, *next;
1076
915
  int len;
1077
916
 
1078
 
  if (kernel_type == KERNEL_TYPE_NONE)
1079
 
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1080
 
                       "You need to load the kernel first.");
1081
 
 
1082
917
  if (kernel_type != KERNEL_TYPE_FREEBSD)
1083
918
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1084
 
                       "Only FreeBSD support environment");
 
919
                       "only freebsd support environment");
1085
920
 
1086
921
  if (argc == 0)
1087
922
    {
1088
 
      grub_error (GRUB_ERR_BAD_ARGUMENT, "No filename");
 
923
      grub_error (GRUB_ERR_BAD_ARGUMENT, "no filename");
1089
924
      goto fail;
1090
925
    }
1091
926
 
1139
974
 
1140
975
      if (*curr)
1141
976
        {
1142
 
          char name[grub_strlen (curr) + sizeof("kFreeBSD.")];
 
977
          char name[grub_strlen (curr) + 8 + 1];
1143
978
 
1144
979
          if (*p == '"')
1145
980
            p++;
1146
981
 
1147
 
          grub_sprintf (name, "kFreeBSD.%s", curr);
 
982
          grub_sprintf (name, "FreeBSD.%s", curr);
1148
983
          if (grub_env_set (name, p))
1149
984
            goto fail;
1150
985
        }
1169
1004
  char **modargv;
1170
1005
  char *type;
1171
1006
 
1172
 
  if (kernel_type == KERNEL_TYPE_NONE)
1173
 
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1174
 
                       "You need to load the kernel first.");
1175
 
 
1176
1007
  if (kernel_type != KERNEL_TYPE_FREEBSD)
1177
1008
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1178
 
                       "Only FreeBSD support module");
 
1009
                       "only freebsd support module");
1179
1010
 
1180
1011
  if (!is_elf_kernel)
1181
1012
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1182
 
                       "Only ELF kernel support module");
 
1013
                       "only elf kernel support module");
1183
1014
 
1184
1015
  /* List the current modules if no parameter.  */
1185
1016
  if (!argc)
1235
1066
  grub_file_t file = 0;
1236
1067
  grub_err_t err;
1237
1068
 
1238
 
  if (kernel_type == KERNEL_TYPE_NONE)
1239
 
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1240
 
                       "You need to load the kernel first.");
1241
 
 
1242
1069
  if (kernel_type != KERNEL_TYPE_FREEBSD)
1243
1070
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1244
 
                       "Only FreeBSD support module");
 
1071
                       "only freebsd support module");
1245
1072
 
1246
1073
  if (! is_elf_kernel)
1247
1074
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
1248
 
                       "Only ELF kernel support module");
 
1075
                       "only elf kernel support module");
1249
1076
 
1250
1077
  /* List the current modules if no parameter.  */
1251
1078
  if (! argc)
1273
1100
}
1274
1101
 
1275
1102
 
1276
 
static grub_extcmd_t cmd_freebsd, cmd_openbsd, cmd_netbsd;
 
1103
static grub_command_t cmd_freebsd, cmd_openbsd, cmd_netbsd;
1277
1104
static grub_command_t cmd_freebsd_loadenv, cmd_freebsd_module;
1278
1105
static grub_command_t cmd_freebsd_module_elf;
1279
1106
 
1280
1107
GRUB_MOD_INIT (bsd)
1281
1108
{
1282
 
  cmd_freebsd = grub_register_extcmd ("kfreebsd", grub_cmd_freebsd,
1283
 
                                      GRUB_COMMAND_FLAG_BOTH,
1284
 
                                      "kfreebsd FILE", "Load kernel of FreeBSD.",
1285
 
                                      freebsd_opts);
1286
 
  cmd_openbsd = grub_register_extcmd ("kopenbsd", grub_cmd_openbsd,
1287
 
                                      GRUB_COMMAND_FLAG_BOTH,
1288
 
                                      "kopenbsd FILE", "Load kernel of OpenBSD.",
1289
 
                                      openbsd_opts);
1290
 
  cmd_netbsd = grub_register_extcmd ("knetbsd", grub_cmd_netbsd,
1291
 
                                     GRUB_COMMAND_FLAG_BOTH,
1292
 
                                     "knetbsd FILE", "Load kernel of NetBSD.",
1293
 
                                     netbsd_opts);
 
1109
  cmd_freebsd =
 
1110
    grub_register_command ("freebsd", grub_cmd_freebsd,
 
1111
                           0, "load freebsd kernel");
 
1112
  cmd_openbsd =
 
1113
    grub_register_command ("openbsd", grub_cmd_openbsd,
 
1114
                           0, "load openbsd kernel");
 
1115
  cmd_netbsd =
 
1116
    grub_register_command ("netbsd", grub_cmd_netbsd,
 
1117
                           0, "load netbsd kernel");
1294
1118
  cmd_freebsd_loadenv =
1295
 
    grub_register_command ("kfreebsd_loadenv", grub_cmd_freebsd_loadenv,
1296
 
                           0, "load FreeBSD env");
 
1119
    grub_register_command ("freebsd_loadenv", grub_cmd_freebsd_loadenv,
 
1120
                           0, "load freebsd env");
1297
1121
  cmd_freebsd_module =
1298
 
    grub_register_command ("kfreebsd_module", grub_cmd_freebsd_module,
1299
 
                           0, "load FreeBSD kernel module");
 
1122
    grub_register_command ("freebsd_module", grub_cmd_freebsd_module,
 
1123
                           0, "load freebsd module");
1300
1124
  cmd_freebsd_module_elf =
1301
 
    grub_register_command ("kfreebsd_module_elf", grub_cmd_freebsd_module_elf,
1302
 
                           0, "load FreeBSD kernel module (ELF)");
 
1125
    grub_register_command ("freebsd_module_elf", grub_cmd_freebsd_module_elf,
 
1126
                           0, "load freebsd ELF module");
1303
1127
 
1304
1128
  my_mod = mod;
1305
1129
}
1306
1130
 
1307
1131
GRUB_MOD_FINI (bsd)
1308
1132
{
1309
 
  grub_unregister_extcmd (cmd_freebsd);
1310
 
  grub_unregister_extcmd (cmd_openbsd);
1311
 
  grub_unregister_extcmd (cmd_netbsd);
 
1133
  grub_unregister_command (cmd_freebsd);
 
1134
  grub_unregister_command (cmd_openbsd);
 
1135
  grub_unregister_command (cmd_netbsd);
1312
1136
 
1313
1137
  grub_unregister_command (cmd_freebsd_loadenv);
1314
1138
  grub_unregister_command (cmd_freebsd_module);