1 files changed, 9523 insertions, 0 deletions

diff --git a/sysutils/grub/files/patch-ufs2 b/sysutils/grub/files/patch-ufs2
new file mode 100644
index 000000000000..fcf637cabeef
--- /dev/null
+++ b/sysutils/grub/files/patch-ufs2
@@ -0,0 +1,9523 @@
+diff -ruN grub-0.94.orig/configure.ac configure.ac
+--- grub-0.94.orig/configure.ac	Wed Feb 11 00:22:12 2004
++++ configure.ac	Wed Feb 11 00:22:29 2004
+@@ -227,6 +227,13 @@
+   FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_FFS=1"
+ fi
+ 
++AC_ARG_ENABLE(ufs2,
++  [  --disable-ufs2          disable UFS2 support in Stage 2])
++
++if test x"$enable_ufs2" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_UFS2=1"
++fi
++
+ AC_ARG_ENABLE(minix,
+   [  --disable-minix         disable Minix fs support in Stage 2])
+ 
+diff -ruN grub-0.94.orig/configure.ac.orig configure.ac.orig
+--- grub-0.94.orig/configure.ac.orig	Thu Jan  1 03:00:00 1970
++++ configure.ac.orig	Sun Oct 19 21:25:30 2003
+@@ -0,0 +1,640 @@
++dnl Configure script for GRUB.
++dnl Copyright 1999,2000,2001,2002,2003 Free Software Foundation, Inc.
++
++dnl Permission to use, copy, modify and distribute this software and its
++dnl documentation is hereby granted, provided that both the copyright
++dnl notice and this permission notice appear in all copies of the
++dnl software, derivative works or modified versions, and any portions
++dnl thereof, and that both notices appear in supporting documentation.
++dnl
++dnl THE FREE SOFTWARE FOUNDATION ALLOWS FREE USE OF THIS SOFTWARE IN ITS
++dnl "AS IS" CONDITION.  THE FREE SOFTWARE FOUNDATION DISCLAIMS ANY
++dnl LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE
++dnl USE OF THIS SOFTWARE.
++
++AC_PREREQ(2.57)
++AC_INIT([GRUB], [0.94], [bug-grub@gnu.org])
++AC_CONFIG_SRCDIR([stage2/stage2.c])
++AC_CONFIG_HEADER([config.h])
++AM_INIT_AUTOMAKE
++
++AC_CANONICAL_HOST
++
++case "$host_cpu" in
++i[[3456]]86) host_cpu=i386 ;;
++x86_64) host_cpu=x86_64 ;;
++*) AC_MSG_ERROR([unsupported CPU type]) ;;
++esac
++
++AC_SUBST(host_cpu)
++AC_SUBST(host_vendor)
++
++#
++# Options
++#
++
++AM_MAINTAINER_MODE
++if test "x$enable_maintainer_mode" = xyes; then
++  AC_PATH_PROG(PERL,perl)
++  if test -z "$PERL"; then
++    AC_MSG_ERROR([perl not found])
++  fi
++fi
++
++# This should be checked before AC_PROG_CC
++if test "x$CFLAGS" = x; then
++  default_CFLAGS=yes
++fi
++
++if test "x$host_cpu" = xx86_64; then
++  CFLAGS="-m32 $CFLAGS"
++fi
++
++#
++# Programs
++#
++
++AC_CHECK_TOOL(CC, gcc)
++AC_PROG_CC
++# We need this for older versions of Autoconf.
++_AM_DEPENDENCIES(CC)
++
++dnl Because recent automake complains about AS, set it here.
++CCAS="$CC"
++AC_SUBST(CCAS)
++
++AC_ARG_WITH(binutils,
++  [  --with-binutils=DIR     search the directory DIR to find binutils])
++
++if test "x$with_binutils" != x; then
++dnl AC_PATH_TOOL is not seen in autoconf 2.13, so use AC_PATH_PROG
++dnl instead for now. It is preferable when you cross-compile GRUB.
++dnl  AC_PATH_TOOL(RANLIB, ranlib, :, "$with_binutils:$PATH")
++  AC_PATH_PROG(RANLIB, ranlib, :, "$with_binutils:$PATH")
++else
++  AC_PROG_RANLIB
++fi
++
++# optimization flags
++if test "x$ac_cv_prog_gcc" = xyes; then
++  if test "x$default_CFLAGS" = xyes; then
++    # Autoconf may set CFLAGS to -O2 and/or -g. So eliminate them.
++    CFLAGS="`echo $CFLAGS | sed -e 's/-g//g' -e 's/-O[[0-9]]//g'` -g"
++    # If the user specify the directory for binutils, add the option `-B'.
++    if test "x$with_binutils" != x; then
++      CFLAGS="-B$with_binutils/ $CFLAGS"
++    fi
++    STAGE1_CFLAGS="-O2"
++    GRUB_CFLAGS="-O2"
++    AC_CACHE_CHECK([whether optimization for size works], size_flag, [
++      saved_CFLAGS=$CFLAGS
++      CFLAGS="-Os -g"
++      AC_TRY_COMPILE(, , size_flag=yes, size_flag=no)
++      CFLAGS=$saved_CFLAGS
++    ])
++    if test "x$size_flag" = xyes; then
++      STAGE2_CFLAGS="-Os"
++    else
++      STAGE2_CFLAGS="-O2 -fno-strength-reduce -fno-unroll-loops"
++    fi
++  fi
++fi
++
++AC_SUBST(STAGE1_CFLAGS)
++AC_SUBST(STAGE2_CFLAGS)
++AC_SUBST(GRUB_CFLAGS)
++
++# Enforce coding standards.
++CPPFLAGS="$CPPFLAGS -Wall -Wmissing-prototypes -Wunused -Wshadow"
++CPPFLAGS="$CPPFLAGS -Wpointer-arith"
++
++AC_CACHE_CHECK([whether -Wundef works], undef_flag, [
++  saved_CPPFLAGS="$CPPFLAGS"
++  CPPFLAGS="-Wundef"
++  AC_TRY_COMPILE(, , undef_flag=yes, undef_flag=no)
++  CPPFLAGS="$saved_CPPFLAGS"
++])
++
++# The options `-falign-*' are supported by gcc 3.0 or later.
++# Probably it is sufficient to only check for -falign-loops.
++AC_CACHE_CHECK([whether -falign-loops works], [falign_loop_flag], [
++  saved_CPPFLAGS="$CPPFLAGS"
++  CPPFLAGS="-falign-loops=1"
++  AC_TRY_COMPILE(, , [falign_loop_flag=yes], [falign_loop_flag=no])
++  CPPFLAGS="$saved_CPPFLAGS"
++])
++
++# Force no alignment to save space.
++if test "x$falign_loop_flag" = xyes; then
++  CPPFLAGS="$CPPFLAGS -falign-jumps=1 -falign-loops=1 -falign-functions=1"
++else
++  CPPFLAGS="$CPPFLAGS -malign-jumps=1 -malign-loops=1 -malign-functions=1"
++fi
++
++if test "x$undef_flag" = xyes; then
++  CPPFLAGS="$CPPFLAGS -Wundef"
++fi
++
++if test "x$with_binutils" != x; then
++dnl  AC_PATH_TOOL(OBJCOPY, objcopy, , "$with_binutils:$PATH")
++  AC_PATH_PROG(OBJCOPY, objcopy, , "$with_binutils:$PATH")
++else
++  AC_CHECK_TOOL(OBJCOPY, objcopy)
++fi
++
++# Defined in acinclude.m4.
++grub_ASM_USCORE
++grub_PROG_OBJCOPY_ABSOLUTE
++if test "x$grub_cv_prog_objcopy_absolute" != xyes; then
++  AC_MSG_ERROR([GRUB requires a working absolute objcopy; upgrade your binutils])
++fi
++
++grub_ASM_PREFIX_REQUIREMENT
++
++grub_ASM_ADDR32
++if test "x$grub_cv_asm_addr32" != xyes; then
++  AC_MSG_ERROR([GRUB requires GAS .code16 addr32 support; upgrade your binutils])
++fi
++
++grub_ASM_ABSOLUTE_WITHOUT_ASTERISK
++
++grub_CHECK_START_SYMBOL
++grub_CHECK_USCORE_START_SYMBOL
++if test "x$grub_cv_check_start_symbol" != "xyes" \
++	-a "x$grub_cv_check_uscore_start_symbol" != "xyes"; then
++  AC_MSG_ERROR([Neither start nor _start is defined])
++fi
++
++grub_CHECK_USCORE_USCORE_BSS_START_SYMBOL
++grub_CHECK_USCORE_EDATA_SYMBOL
++grub_CHECK_EDATA_SYMBOL
++if test "x$grub_cv_check_uscore_uscore_bss_start_symbol" != "xyes" \
++	-a "x$grub_cv_check_uscore_edata_symbol" != "xyes" \
++	-a "x$grub_cv_check_edata_symbol" != "xyes"; then
++  AC_MSG_ERROR([None of __bss_start, _edata, edata defined])
++fi
++
++grub_CHECK_END_SYMBOL
++grub_CHECK_USCORE_END_SYMBOL
++if test "x$grub_cv_check_end_symbol" != "xyes" \
++	-a "x$grub_cv_check_uscore_end_symbol" != "xyes"; then
++  AC_MSG_ERROR([Neither end nor _end is defined])
++fi
++
++# Check for curses libraries.
++AC_ARG_WITH(curses,
++  [  --without-curses        do not use curses])
++
++# Get the filename or the whole disk and open it.
++# Known to work on NetBSD.
++AC_CHECK_LIB(util, opendisk, [GRUB_LIBS="$GRUB_LIBS -lutil"
++  AC_DEFINE(HAVE_OPENDISK, 1, [Define if opendisk() in -lutil can be used])])
++
++# Unless the user specify --without-curses, check for curses.
++if test "x$with_curses" != "xno"; then
++  AC_CHECK_LIB(ncurses, wgetch, [GRUB_LIBS="$GRUB_LIBS -lncurses"
++  AC_DEFINE(HAVE_LIBCURSES)],
++    [AC_CHECK_LIB(curses, wgetch, [GRUB_LIBS="$GRUB_LIBS -lcurses"
++       AC_DEFINE(HAVE_LIBCURSES)])])
++fi
++
++AC_SUBST(GRUB_LIBS)
++
++# Check for headers.
++AC_CHECK_HEADERS(string.h strings.h ncurses/curses.h ncurses.h curses.h)
++
++# Check for user options.
++
++# filesystems support.
++AC_ARG_ENABLE(ext2fs,
++  [  --disable-ext2fs        disable ext2fs support in Stage 2])
++
++if test x"$enable_ext2fs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_EXT2FS=1"
++fi
++
++AC_ARG_ENABLE(fat,
++  [  --disable-fat           disable FAT support in Stage 2])
++
++if test x"$enable_fat" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_FAT=1"
++fi
++
++AC_ARG_ENABLE(ffs,
++  [  --disable-ffs           disable FFS support in Stage 2])
++
++if test x"$enable_ffs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_FFS=1"
++fi
++
++AC_ARG_ENABLE(minix,
++  [  --disable-minix         disable Minix fs support in Stage 2])
++
++if test x"$enable_minix" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_MINIX=1"
++fi
++
++AC_ARG_ENABLE(reiserfs,
++  [  --disable-reiserfs      disable ReiserFS support in Stage 2])
++
++if test x"$enable_reiserfs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_REISERFS=1"
++fi
++
++AC_ARG_ENABLE(vstafs,
++  [  --disable-vstafs        disable VSTa FS support in Stage 2])
++
++if test x"$enable_vstafs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_VSTAFS=1"
++fi
++
++AC_ARG_ENABLE(jfs,
++  [  --disable-jfs           disable IBM JFS support in Stage 2])
++
++if test x"$enable_jfs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_JFS=1"
++fi
++
++AC_ARG_ENABLE(xfs,
++  [  --disable-xfs           disable SGI XFS support in Stage 2])
++
++if test x"$enable_xfs" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_XFS=1"
++fi
++
++dnl AC_ARG_ENABLE(tftp,
++dnl [  --enable-tftp           enable TFTP support in Stage 2])
++dnl 
++dnl #if test x"$enable_tftp" = xyes; then
++dnl FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_TFTP=1"
++dnl fi
++
++AC_ARG_ENABLE(gunzip,
++  [  --disable-gunzip        disable decompression in Stage 2])
++
++if test x"$enable_gunzip" = xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DNO_DECOMPRESSION=1"
++fi
++
++AC_ARG_ENABLE(md5-password,
++  [  --disable-md5-password  disable MD5 password support in Stage 2])
++if test "x$enable_md5_password" != xno; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DUSE_MD5_PASSWORDS=1"
++fi
++
++dnl The netboot support.
++dnl General options.
++AC_ARG_ENABLE(packet-retransmission,
++  [  --disable-packet-retransmission
++                          turn off packet retransmission])
++if test "x$enable_packet_retransmission" != xno; then
++  NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DCONGESTED=1"
++fi
++
++AC_ARG_ENABLE(pci-direct,
++  [  --enable-pci-direct     access PCI directly instead of using BIOS])
++if test "x$enable_pci_direct" = xyes; then
++  NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DCONFIG_PCI_DIRECT=1"
++fi
++
++dnl Device drivers.
++AC_ARG_ENABLE(3c509,
++  [  --enable-3c509          enable 3Com509 driver])
++if test "x$enable_3c509" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C509"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c509.o"
++fi
++
++AC_ARG_ENABLE(3c529,
++  [  --enable-3c529          enable 3Com529 driver])
++if test "x$enable_3c529" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C529=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c529.o"
++fi
++
++AC_ARG_ENABLE(3c595,
++  [  --enable-3c595          enable 3Com595 driver])
++if test "x$enable_3c595" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C595=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c595.o"
++fi
++
++AC_ARG_ENABLE(3c90x,
++  [  --enable-3c90x          enable 3Com90x driver])
++if test "x$enable_3c90x" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C90X=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c90x.o"
++fi
++
++AC_ARG_ENABLE(cs89x0,
++  [  --enable-cs89x0         enable CS89x0 driver])
++if test "x$enable_cs89x0" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_CS89X0=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS cs89x0.o"
++fi
++
++AC_ARG_ENABLE(davicom,
++  [  --enable-davicom        enable Davicom driver])
++if test "x$enable_davicom" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_DAVICOM=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS davicom.o"
++fi
++
++AC_ARG_ENABLE(depca,
++  [  --enable-depca          enable DEPCA and EtherWORKS driver])
++if test "x$enable_depca" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_DEPCA=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS depca.o"
++fi
++
++AC_ARG_ENABLE(eepro,
++  [  --enable-eepro          enable Etherexpress Pro/10 driver])
++if test "x$enable_eepro" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_EEPRO=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS eepro.o"
++fi
++
++AC_ARG_ENABLE(eepro100,
++  [  --enable-eepro100       enable Etherexpress Pro/100 driver])
++if test "x$enable_eepro100" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_EEPRO100=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS eepro100.o"
++fi
++
++AC_ARG_ENABLE(epic100,
++  [  --enable-epic100        enable SMC 83c170 EPIC/100 driver])
++if test "x$enable_epic100" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_EPIC100=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS epic100.o"
++fi
++
++AC_ARG_ENABLE(3c507,
++  [  --enable-3c507          enable 3Com507 driver])
++if test "x$enable_3c507" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C507=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c507.o"
++fi
++
++AC_ARG_ENABLE(exos205,
++  [  --enable-exos205        enable EXOS205 driver])
++if test "x$enable_exos205" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_EXOS205=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS exos205.o"
++fi
++
++AC_ARG_ENABLE(ni5210,
++  [  --enable-ni5210         enable Racal-Interlan NI5210 driver])
++if test "x$enable_ni5210" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NI5210=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ni5210.o"
++fi
++
++AC_ARG_ENABLE(lance,
++  [  --enable-lance          enable Lance PCI PCNet/32 driver])
++if test "x$enable_lance" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_LANCE=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS lance.o"
++fi
++
++AC_ARG_ENABLE(ne2100,
++  [  --enable-ne2100         enable Novell NE2100 driver])
++if test "x$enable_ne2100" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NE2100=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ne2100.o"
++fi
++
++AC_ARG_ENABLE(ni6510,
++  [  --enable-ni6510         enable Racal-Interlan NI6510 driver])
++if test "x$enable_ni6510" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NI6510=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ni6510.o"
++fi
++
++AC_ARG_ENABLE(natsemi,
++  [  --enable-natsemi        enable NatSemi DP8381x driver])
++if test "x$enable_natsemi" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NATSEMI=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS natsemi.o"
++fi
++
++AC_ARG_ENABLE(ni5010,
++  [  --enable-ni5010         enable Racal-Interlan NI5010 driver])
++if test "x$enable_ni5010" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NI5010=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ni5010.o"
++fi
++
++AC_ARG_ENABLE(3c503,
++  [  --enable-3c503          enable 3Com503 driver])
++if test "x$enable_3c503" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_3C503=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS 3c503.o"
++fi
++
++AC_ARG_ENABLE(ne,
++  [  --enable-ne             enable NE1000/2000 ISA driver])
++if test "x$enable_ne" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NE=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ne.o"
++fi
++
++AC_ARG_ENABLE(ns8390,
++  [  --enable-ns8390         enable NE2000 PCI driver])
++if test "x$enable_ns8390" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_NS8390=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS ns8390.o"
++fi
++
++AC_ARG_ENABLE(wd,
++  [  --enable-wd             enable WD8003/8013, SMC8216/8416 driver])
++if test "x$enable_wd" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_WD=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS wd.o"
++fi
++
++AC_ARG_ENABLE(otulip,
++  [  --enable-otulip         enable old Tulip driver])
++if test "x$enable_otulip" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_OTULIP=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS otulip.o"
++fi
++
++AC_ARG_ENABLE(rtl8139,
++  [  --enable-rtl8139        enable Realtek 8139 driver])
++if test "x$enable_rtl8139" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_RTL8139=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS rtl8139.o"
++fi
++
++AC_ARG_ENABLE(sis900,
++  [  --enable-sis900         enable SIS 900 and SIS 7016 driver])
++if test "x$enable_sis900" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_SIS900=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS sis900.o"
++fi
++
++AC_ARG_ENABLE(sk-g16,
++  [  --enable-sk-g16         enable Schneider and Koch G16 driver])
++if test "x$enable_sk_g16" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_SK_G16=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS sk_g16.o"
++fi
++
++AC_ARG_ENABLE(smc9000,
++  [  --enable-smc9000        enable SMC9000 driver])
++if test "x$enable_smc9000" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_SMC9000=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS smc9000.o"
++fi
++
++AC_ARG_ENABLE(tiara,
++  [  --enable-tiara          enable Tiara driver])
++if test "x$enable_tiara" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_TIARA=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS tiara.o"
++fi
++
++AC_ARG_ENABLE(tulip,
++  [  --enable-tulip          enable Tulip driver])
++if test "x$enable_tulip" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_TULIP=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS tulip.o"
++fi
++
++AC_ARG_ENABLE(via-rhine,
++  [  --enable-via-rhine      enable Rhine-I/II driver])
++if test "x$enable_via_rhine" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_VIA_RHINE=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS via_rhine.o"
++fi
++
++AC_ARG_ENABLE(w89c840,
++  [  --enable-w89c840        enable Winbond W89c840, Compex RL100-ATX driver])
++if test "x$enable_w89c840" = xyes; then
++  NET_CFLAGS="$NET_CFLAGS -DINCLUDE_W89C840=1"
++  NETBOOT_DRIVERS="$NETBOOT_DRIVERS w89c840.o"
++fi
++
++dnl Check if the netboot support is turned on.
++AM_CONDITIONAL(NETBOOT_SUPPORT, test "x$NET_CFLAGS" != x)
++if test "x$NET_CFLAGS" != x; then
++  FSYS_CFLAGS="$FSYS_CFLAGS -DFSYS_TFTP=1"
++fi
++
++dnl Extra options.
++AC_ARG_ENABLE(3c503-shmem,
++  [  --enable-3c503-shmem    use 3c503 shared memory mode])
++if test "x$enable_3c503_shmem" = xyes; then
++  NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DT503_SHMEM=1"
++fi
++
++AC_ARG_ENABLE(3c503-aui,
++  [  --enable-3c503-aui      use AUI by default on 3c503 cards])
++if test "x$enable_3c503_aui" = xyes; then
++  NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DT503_AUI=1"
++fi
++
++AC_ARG_ENABLE(compex-rl2000-fix,
++  [  --enable-compex-rl2000-fix
++                          specify this if you have a Compex RL2000 PCI])
++if test "x$enable_compex_rl2000_fix" = xyes; then
++  NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DCOMPEX_RL2000_FIX=1"
++fi
++
++AC_ARG_ENABLE(smc9000-scan,
++  [  --enable-smc9000-scan=LIST
++                          probe for SMC9000 I/O addresses using LIST],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DSMC9000_SCAN=$enable_smc9000_scan"])
++
++AC_ARG_ENABLE(ne-scan,
++  [  --enable-ne-scan=LIST   probe for NE base address using LIST],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DNE_SCAN=$enable_ne_scan"],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DNE_SCAN=0x280,0x300,0x320,0x340"])
++
++AC_ARG_ENABLE(wd-default-mem,
++  [  --enable-wd-default-mem=MEM
++                          set the default memory location for WD/SMC],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DWD_DEFAULT_MEM=$enable_wd_default_mem"],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DWD_DEFAULT_MEM=0xCC000"])
++
++AC_ARG_ENABLE(cs-scan,
++  [  --enable-cs-scan=LIST   probe for CS89x0 base address using LIST],
++  [NET_EXTRAFLAGS="$NET_EXTRAFLAGS -DCS_SCAN=$enable_cs_scan"])
++
++dnl Diskless
++AC_ARG_ENABLE(diskless,
++  [  --enable-diskless       enable diskless support])
++AM_CONDITIONAL(DISKLESS_SUPPORT, test "x$enable_diskless" = xyes)
++
++dnl Hercules terminal
++AC_ARG_ENABLE(hercules,
++  [  --disable-hercules      disable hercules terminal support])
++AM_CONDITIONAL(HERCULES_SUPPORT, test "x$enable_hercules" != xno)
++
++dnl Serial terminal
++AC_ARG_ENABLE(serial,
++  [  --disable-serial        disable serial terminal support])
++AM_CONDITIONAL(SERIAL_SUPPORT, test "x$enable_serial" != xno)
++
++dnl Simulation of the slowness of a serial device.
++AC_ARG_ENABLE(serial-speed-simulation,
++  [  --enable-serial-speed-simulation
++                          simulate the slowness of a serial device])
++AM_CONDITIONAL(SERIAL_SPEED_SIMULATION,
++  test "x$enable_serial_speed_simulation" = xyes)
++
++# Sanity check.
++if test "x$enable_diskless" = xyes; then
++  if test "x$NET_CFLAGS" = x; then
++    AC_MSG_ERROR([You must enable at least one network driver])
++  fi
++fi
++
++dnl Embed a menu string in GRUB itself.
++AC_ARG_ENABLE(preset-menu,
++  [  --enable-preset-menu=FILE
++                          preset a menu file FILE in Stage 2])
++if test "x$enable_preset_menu" = x; then
++  :
++else
++  if test -r $enable_preset_menu; then
++    grub_DEFINE_FILE(PRESET_MENU_STRING, [$enable_preset_menu])
++  else
++    AC_MSG_ERROR([Cannot read the preset menu file $enable_preset_menu])
++  fi
++fi
++
++dnl Build the example Multiboot kernel.
++AC_ARG_ENABLE(example-kernel,
++  [  --enable-example-kernel
++                          build the example Multiboot kernel])
++AM_CONDITIONAL(BUILD_EXAMPLE_KERNEL, test "x$enable_example_kernel" = xyes)
++
++dnl Automatic Linux mem= option.
++AC_ARG_ENABLE(auto-linux-mem-opt,
++  [  --disable-auto-linux-mem-opt
++                          don't pass Linux mem= option automatically])
++if test "x$enable_auto_linux_mem_opt" = xno; then
++  :
++else
++  AC_DEFINE(AUTO_LINUX_MEM_OPT)
++fi
++
++dnl Now substitute the variables.
++AC_SUBST(FSYS_CFLAGS)
++AC_SUBST(NET_CFLAGS)
++AC_SUBST(NET_EXTRAFLAGS)
++AC_SUBST(NETBOOT_DRIVERS)
++
++dnl Because recent automake complains about CCASFLAGS, set it here.
++CCASFLAGS='$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)'
++AC_SUBST(CCASFLAGS)
++
++
++dnl Output.
++AC_CONFIG_FILES([Makefile stage1/Makefile stage2/Makefile \
++		 docs/Makefile lib/Makefile util/Makefile \
++		 grub/Makefile netboot/Makefile util/grub-image \
++		 util/grub-install util/grub-md5-crypt \
++		 util/grub-terminfo])
++AC_OUTPUT
+diff -ruN grub-0.94.orig/grub/Makefile.am grub/Makefile.am
+--- grub-0.94.orig/grub/Makefile.am	Wed Feb 11 00:22:12 2004
++++ grub/Makefile.am	Wed Feb 11 00:22:29 2004
+@@ -7,6 +7,7 @@
+ endif
+ 
+ AM_CPPFLAGS = -DGRUB_UTIL=1 -DFSYS_EXT2FS=1 -DFSYS_FAT=1 \
++	-DFSYS_UFS2=1 \
+ 	-DFSYS_FFS=1 -DFSYS_MINIX=1 -DSUPPORT_HERCULES=1 \
+ 	$(SERIAL_FLAGS) -I$(top_srcdir)/stage2 \
+ 	-I$(top_srcdir)/stage1 -I$(top_srcdir)/lib
+diff -ruN grub-0.94.orig/grub/Makefile.am.orig grub/Makefile.am.orig
+--- grub-0.94.orig/grub/Makefile.am.orig	Thu Jan  1 03:00:00 1970
++++ grub/Makefile.am.orig	Sun Jan 18 22:34:24 2004
+@@ -0,0 +1,17 @@
++sbin_PROGRAMS = grub
++
++if SERIAL_SPEED_SIMULATION
++SERIAL_FLAGS = -DSUPPORT_SERIAL=1 -DSIMULATE_SLOWNESS_OF_SERIAL=1
++else
++SERIAL_FLAGS = -DSUPPORT_SERIAL=1 
++endif
++
++AM_CPPFLAGS = -DGRUB_UTIL=1 -DFSYS_EXT2FS=1 -DFSYS_FAT=1 \
++	-DFSYS_FFS=1 -DFSYS_MINIX=1 -DSUPPORT_HERCULES=1 \
++	$(SERIAL_FLAGS) -I$(top_srcdir)/stage2 \
++	-I$(top_srcdir)/stage1 -I$(top_srcdir)/lib
++
++AM_CFLAGS = $(GRUB_CFLAGS) -fwritable-strings
++
++grub_SOURCES = main.c asmstub.c
++grub_LDADD = ../stage2/libgrub.a  ../lib/libcommon.a $(GRUB_LIBS)
+diff -ruN grub-0.94.orig/stage2/Makefile.am stage2/Makefile.am
+--- grub-0.94.orig/stage2/Makefile.am	Wed Feb 11 00:22:12 2004
++++ stage2/Makefile.am	Wed Feb 11 00:22:29 2004
+@@ -17,10 +17,12 @@
+ noinst_LIBRARIES = libgrub.a
+ libgrub_a_SOURCES = boot.c builtins.c char_io.c cmdline.c common.c \
+ 	disk_io.c fsys_ext2fs.c fsys_fat.c fsys_ffs.c fsys_jfs.c \
++	fsys_ufs2.c \
+ 	fsys_minix.c fsys_reiserfs.c fsys_vstafs.c fsys_xfs.c gunzip.c \
+ 	md5.c serial.c stage2.c terminfo.c tparm.c
+ libgrub_a_CFLAGS = $(GRUB_CFLAGS) -I$(top_srcdir)/lib \
+ 	-DGRUB_UTIL=1 -DFSYS_EXT2FS=1 -DFSYS_FAT=1 -DFSYS_FFS=1 \
++	-DFSYS_UFS2=1 \
+ 	-DFSYS_JFS=1 -DFSYS_MINIX=1 -DFSYS_REISERFS=1 -DFSYS_VSTAFS=1 \
+ 	-DFSYS_XFS=1 -DUSE_MD5_PASSWORDS=1 \
+ 	-DSUPPORT_SERIAL=1 -DSUPPORT_HERCULES=1 -fwritable-strings
+@@ -33,21 +35,25 @@
+ if DISKLESS_SUPPORT
+ pkgdata_DATA = stage2 e2fs_stage1_5 fat_stage1_5 ffs_stage1_5 \
+ 	jfs_stage1_5 minix_stage1_5 reiserfs_stage1_5 vstafs_stage1_5 \
++	ufs2_stage1_5 \
+ 	xfs_stage1_5 nbgrub pxegrub
+ noinst_DATA = pre_stage2 start nbloader pxeloader diskless
+ noinst_PROGRAMS = pre_stage2.exec start.exec e2fs_stage1_5.exec \
+ 	fat_stage1_5.exec ffs_stage1_5.exec jfs_stage1_5.exec \
+ 	minix_stage1_5.exec reiserfs_stage1_5.exec \
++	ufs2_stage1_5.exec \
+ 	vstafs_stage1_5.exec xfs_stage1_5.exec nbloader.exec \
+ 	pxeloader.exec diskless.exec
+ else
+ pkgdata_DATA = stage2 e2fs_stage1_5 fat_stage1_5 ffs_stage1_5 \
+ 	jfs_stage1_5 minix_stage1_5 reiserfs_stage1_5 vstafs_stage1_5 \
++	ufs2_stage1_5 \
+ 	xfs_stage1_5
+ noinst_DATA = pre_stage2 start
+ noinst_PROGRAMS = pre_stage2.exec start.exec e2fs_stage1_5.exec \
+ 	fat_stage1_5.exec ffs_stage1_5.exec jfs_stage1_5.exec \
+ 	minix_stage1_5.exec reiserfs_stage1_5.exec \
++	ufs2_stage1_5.exec \
+ 	vstafs_stage1_5.exec xfs_stage1_5.exec
+ endif
+ MOSTLYCLEANFILES = $(noinst_PROGRAMS)
+@@ -84,6 +90,7 @@
+ # For stage2 target.
+ pre_stage2_exec_SOURCES = asm.S bios.c boot.c builtins.c char_io.c \
+ 	cmdline.c common.c console.c disk_io.c fsys_ext2fs.c \
++	fsys_ufs2.c \
+ 	fsys_fat.c fsys_ffs.c fsys_jfs.c fsys_minix.c fsys_reiserfs.c \
+ 	fsys_vstafs.c fsys_xfs.c gunzip.c hercules.c md5.c serial.c \
+ 	smp-imps.c stage2.c terminfo.c tparm.c
+@@ -148,6 +155,15 @@
+ ffs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_FFS=1 \
+ 	-DNO_BLOCK_FILES=1
+ ffs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For ufs2_stage1_5 target.
++ufs2_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
++	stage1_5.c fsys_ufs2.c bios.c
++ufs2_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_UFS2=1 \
++	-DNO_BLOCK_FILES=1
++ufs2_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_UFS2=1 \
++	-DNO_BLOCK_FILES=1
++ufs2_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
+ 
+ # For minix_stage1_5 target.
+ minix_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
+diff -ruN grub-0.94.orig/stage2/Makefile.am.orig stage2/Makefile.am.orig
+--- grub-0.94.orig/stage2/Makefile.am.orig	Thu Jan  1 03:00:00 1970
++++ stage2/Makefile.am.orig	Sun Oct 19 20:45:18 2003
+@@ -0,0 +1,239 @@
++# For test target.
++TESTS = size_test
++noinst_SCRIPTS = $(TESTS)
++
++# For dist target.
++noinst_HEADERS = apic.h defs.h dir.h disk_inode.h disk_inode_ffs.h \
++        fat.h filesys.h freebsd.h fs.h hercules.h i386-elf.h \
++	imgact_aout.h jfs.h mb_header.h mb_info.h md5.h nbi.h \
++	pc_slice.h serial.h shared.h smp-imps.h term.h terminfo.h \
++	tparm.h nbi.h vstafs.h xfs.h
++EXTRA_DIST = setjmp.S apm.S $(noinst_SCRIPTS)
++
++# For <stage1.h>.
++INCLUDES = -I$(top_srcdir)/stage1
++
++# The library for /sbin/grub.
++noinst_LIBRARIES = libgrub.a
++libgrub_a_SOURCES = boot.c builtins.c char_io.c cmdline.c common.c \
++	disk_io.c fsys_ext2fs.c fsys_fat.c fsys_ffs.c fsys_jfs.c \
++	fsys_minix.c fsys_reiserfs.c fsys_vstafs.c fsys_xfs.c gunzip.c \
++	md5.c serial.c stage2.c terminfo.c tparm.c
++libgrub_a_CFLAGS = $(GRUB_CFLAGS) -I$(top_srcdir)/lib \
++	-DGRUB_UTIL=1 -DFSYS_EXT2FS=1 -DFSYS_FAT=1 -DFSYS_FFS=1 \
++	-DFSYS_JFS=1 -DFSYS_MINIX=1 -DFSYS_REISERFS=1 -DFSYS_VSTAFS=1 \
++	-DFSYS_XFS=1 -DUSE_MD5_PASSWORDS=1 \
++	-DSUPPORT_SERIAL=1 -DSUPPORT_HERCULES=1 -fwritable-strings
++
++# Stage 2 and Stage 1.5's.
++pkgdatadir = $(datadir)/$(PACKAGE)/$(host_cpu)-$(host_vendor)
++
++EXTRA_PROGRAMS = nbloader.exec pxeloader.exec diskless.exec
++
++if DISKLESS_SUPPORT
++pkgdata_DATA = stage2 e2fs_stage1_5 fat_stage1_5 ffs_stage1_5 \
++	jfs_stage1_5 minix_stage1_5 reiserfs_stage1_5 vstafs_stage1_5 \
++	xfs_stage1_5 nbgrub pxegrub
++noinst_DATA = pre_stage2 start nbloader pxeloader diskless
++noinst_PROGRAMS = pre_stage2.exec start.exec e2fs_stage1_5.exec \
++	fat_stage1_5.exec ffs_stage1_5.exec jfs_stage1_5.exec \
++	minix_stage1_5.exec reiserfs_stage1_5.exec \
++	vstafs_stage1_5.exec xfs_stage1_5.exec nbloader.exec \
++	pxeloader.exec diskless.exec
++else
++pkgdata_DATA = stage2 e2fs_stage1_5 fat_stage1_5 ffs_stage1_5 \
++	jfs_stage1_5 minix_stage1_5 reiserfs_stage1_5 vstafs_stage1_5 \
++	xfs_stage1_5
++noinst_DATA = pre_stage2 start
++noinst_PROGRAMS = pre_stage2.exec start.exec e2fs_stage1_5.exec \
++	fat_stage1_5.exec ffs_stage1_5.exec jfs_stage1_5.exec \
++	minix_stage1_5.exec reiserfs_stage1_5.exec \
++	vstafs_stage1_5.exec xfs_stage1_5.exec
++endif
++MOSTLYCLEANFILES = $(noinst_PROGRAMS)
++
++PRE_STAGE2_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,8200
++START_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,8000
++NBLOADER_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,0
++PXELOADER_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,7C00
++
++if NETBOOT_SUPPORT
++NETBOOT_FLAGS = -I$(top_srcdir)/netboot -DSUPPORT_NETBOOT=1
++else
++NETBOOT_FLAGS =
++endif
++
++if SERIAL_SUPPORT
++SERIAL_FLAGS = -DSUPPORT_SERIAL=1
++else
++SERIAL_FLAGS =
++endif
++
++if HERCULES_SUPPORT
++HERCULES_FLAGS = -DSUPPORT_HERCULES=1
++else
++HERCULES_FLAGS =
++endif
++
++STAGE2_COMPILE = $(STAGE2_CFLAGS) -fno-builtin -nostdinc \
++	$(NETBOOT_FLAGS) $(SERIAL_FLAGS) $(HERCULES_FLAGS)
++
++STAGE1_5_LINK = -nostdlib -Wl,-N -Wl,-Ttext -Wl,2000
++STAGE1_5_COMPILE = $(STAGE2_COMPILE) -DNO_DECOMPRESSION=1 -DSTAGE1_5=1
++
++# For stage2 target.
++pre_stage2_exec_SOURCES = asm.S bios.c boot.c builtins.c char_io.c \
++	cmdline.c common.c console.c disk_io.c fsys_ext2fs.c \
++	fsys_fat.c fsys_ffs.c fsys_jfs.c fsys_minix.c fsys_reiserfs.c \
++	fsys_vstafs.c fsys_xfs.c gunzip.c hercules.c md5.c serial.c \
++	smp-imps.c stage2.c terminfo.c tparm.c
++pre_stage2_exec_CFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS)
++pre_stage2_exec_CCASFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS)
++pre_stage2_exec_LDFLAGS = $(PRE_STAGE2_LINK)
++
++if NETBOOT_SUPPORT
++pre_stage2_exec_LDADD = ../netboot/libdrivers.a
++endif
++
++if DISKLESS_SUPPORT
++BUILT_SOURCES = stage2_size.h diskless_size.h
++else
++BUILT_SOURCES = stage2_size.h
++endif
++
++CLEANFILES = $(pkgdata_DATA) $(noinst_DATA) $(BUILT_SOURCES)
++
++stage2_size.h: pre_stage2
++	-rm -f stage2_size.h
++	set dummy `ls -l pre_stage2`; \
++	echo "#define STAGE2_SIZE $$6" > stage2_size.h
++
++start_exec_SOURCES = start.S
++start_exec_CCASFLAGS = $(STAGE2_COMPILE)
++start_exec_LDFLAGS = $(START_LINK)
++
++# XXX: automake doesn't provide a way to specify dependencies for object
++# files explicitly, so we must write this by a general Makefile scheme.
++# If automake change the naming scheme for per-executable objects, this
++# will be broken.
++start_exec-start.$(OBJEXT): stage2_size.h
++
++stage2: pre_stage2 start
++	-rm -f stage2
++	cat start pre_stage2 > stage2
++
++# For e2fs_stage1_5 target.
++e2fs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
++	stage1_5.c fsys_ext2fs.c bios.c
++e2fs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_EXT2FS=1 \
++	-DNO_BLOCK_FILES=1
++e2fs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_EXT2FS=1 \
++	-DNO_BLOCK_FILES=1
++e2fs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For fat_stage1_5 target.
++fat_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
++	stage1_5.c fsys_fat.c bios.c
++fat_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_FAT=1 \
++	-DNO_BLOCK_FILES=1
++fat_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_FAT=1 \
++	-DNO_BLOCK_FILES=1
++fat_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For ffs_stage1_5 target.
++ffs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
++	stage1_5.c fsys_ffs.c bios.c
++ffs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_FFS=1 \
++	-DNO_BLOCK_FILES=1
++ffs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_FFS=1 \
++	-DNO_BLOCK_FILES=1
++ffs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For minix_stage1_5 target.
++minix_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c disk_io.c \
++	stage1_5.c fsys_minix.c bios.c
++minix_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_MINIX=1 \
++	-DNO_BLOCK_FILES=1
++minix_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_MINIX=1 \
++	-DNO_BLOCK_FILES=1
++minix_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For reiserfs_stage1_5 target.
++reiserfs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c \
++	disk_io.c stage1_5.c fsys_reiserfs.c bios.c
++reiserfs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_REISERFS=1 \
++	-DNO_BLOCK_FILES=1
++reiserfs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_REISERFS=1 \
++	-DNO_BLOCK_FILES=1
++reiserfs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For vstafs_stage1_5 target.
++vstafs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c \
++	disk_io.c stage1_5.c fsys_vstafs.c bios.c
++vstafs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_VSTAFS=1 \
++	-DNO_BLOCK_FILES=1
++vstafs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_VSTAFS=1 \
++	-DNO_BLOCK_FILES=1
++vstafs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For jfs_stage1_5 target.
++jfs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c \
++	disk_io.c stage1_5.c fsys_jfs.c bios.c
++jfs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_JFS=1 \
++	-DNO_BLOCK_FILES=1
++jfs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_JFS=1 \
++	-DNO_BLOCK_FILES=1
++jfs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For xfs_stage1_5 target.
++xfs_stage1_5_exec_SOURCES = start.S asm.S common.c char_io.c \
++	disk_io.c stage1_5.c fsys_xfs.c bios.c
++xfs_stage1_5_exec_CFLAGS = $(STAGE1_5_COMPILE) -DFSYS_XFS=1 \
++	-DNO_BLOCK_FILES=1
++xfs_stage1_5_exec_CCASFLAGS = $(STAGE1_5_COMPILE) -DFSYS_XFS=1 \
++	-DNO_BLOCK_FILES=1
++xfs_stage1_5_exec_LDFLAGS = $(STAGE1_5_LINK)
++
++# For diskless target.
++diskless_exec_SOURCES = $(pre_stage2_exec_SOURCES)
++diskless_exec_CFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS) \
++	-DSUPPORT_DISKLESS=1
++diskless_exec_CCASFLAGS = $(STAGE2_COMPILE) $(FSYS_CFLAGS) \
++	-DSUPPORT_DISKLESS=1
++diskless_exec_LDFLAGS = $(PRE_STAGE2_LINK)
++diskless_exec_LDADD = ../netboot/libdrivers.a
++
++diskless_size.h: diskless
++	-rm -f $@
++	set dummy `ls -l $^`; \
++	echo "#define DISKLESS_SIZE $$6" > $@
++
++# For nbloader target.
++nbloader_exec_SOURCES = nbloader.S
++nbloader_exec_CCASFLAGS = $(STAGE2_COMPILE)
++nbloader_exec_LDFLAGS = $(NBLOADER_LINK)
++
++# XXX: See the comment for start_exec-start.o.
++nbloader_exec-nbloader.$(OBJEXT): diskless_size.h
++
++# For nbgrub target.
++nbgrub: nbloader diskless
++	-rm -f $@
++	cat $^ > $@
++
++# For pxeloader target.
++pxeloader_exec_SOURCES = pxeloader.S
++pxeloader_exec_CCASFLAGS = $(STAGE2_COMPILE)
++pxeloader_exec_LDFLAGS = $(PXELOADER_LINK)
++
++# XXX: See the comment for start_exec-start.o.
++pxeloader_exec-pxeloader.$(OBJEXT): diskless_size.h
++
++# For pxegrub target.
++pxegrub: pxeloader diskless
++	-rm -f $@
++	cat $^ > $@
++
++# General rule for making a raw binary.
++%: %.exec
++	$(OBJCOPY) -O binary $< $@
+diff -ruN grub-0.94.orig/stage2/builtins.c stage2/builtins.c
+--- grub-0.94.orig/stage2/builtins.c	Wed Feb 11 00:22:12 2004
++++ stage2/builtins.c	Wed Feb 11 00:22:29 2004
+@@ -3747,6 +3747,7 @@
+   {
+     {"ext2fs",   "/e2fs_stage1_5"},
+     {"fat",      "/fat_stage1_5"},
++    {"ufs2",     "/ufs2_stage1_5"},
+     {"ffs",      "/ffs_stage1_5"},
+     {"jfs",      "/jfs_stage1_5"},
+     {"minix",    "/minix_stage1_5"},
+diff -ruN grub-0.94.orig/stage2/builtins.c.orig stage2/builtins.c.orig
+--- grub-0.94.orig/stage2/builtins.c.orig	Thu Jan  1 03:00:00 1970
++++ stage2/builtins.c.orig	Sun Jan 11 12:39:22 2004
+@@ -0,0 +1,4755 @@
++/* builtins.c - the GRUB builtin commands */
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 1999,2000,2001,2002,2003,2004  Free Software Foundation, Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++/* Include stdio.h before shared.h, because we can't define
++   WITHOUT_LIBC_STUBS here.  */
++#ifdef GRUB_UTIL
++# include <stdio.h>
++#endif
++
++#include <shared.h>
++#include <filesys.h>
++#include <term.h>
++
++#ifdef SUPPORT_NETBOOT
++# define GRUB	1
++# include <etherboot.h>
++#endif
++
++#ifdef SUPPORT_SERIAL
++# include <serial.h>
++# include <terminfo.h>
++#endif
++
++#ifdef GRUB_UTIL
++# include <device.h>
++#else /* ! GRUB_UTIL */
++# include <apic.h>
++# include <smp-imps.h>
++#endif /* ! GRUB_UTIL */
++
++#ifdef USE_MD5_PASSWORDS
++# include <md5.h>
++#endif
++
++/* The type of kernel loaded.  */
++kernel_t kernel_type;
++/* The boot device.  */
++static int bootdev;
++/* True when the debug mode is turned on, and false
++   when it is turned off.  */
++int debug = 0;
++/* The default entry.  */
++int default_entry = 0;
++/* The fallback entry.  */
++int fallback_entry = -1;
++/* The number of current entry.  */
++int current_entryno;
++/* The address for Multiboot command-line buffer.  */
++static char *mb_cmdline;
++/* The password.  */
++char *password;
++/* The password type.  */
++password_t password_type;
++/* The flag for indicating that the user is authoritative.  */
++int auth = 0;
++/* The timeout.  */
++int grub_timeout = -1;
++/* Whether to show the menu or not.  */
++int show_menu = 1;
++/* The BIOS drive map.  */
++static unsigned short bios_drive_map[DRIVE_MAP_SIZE + 1];
++
++/* Prototypes for allowing straightfoward calling of builtins functions
++   inside other functions.  */
++static int configfile_func (char *arg, int flags);
++
++/* Initialize the data for builtins.  */
++void
++init_builtins (void)
++{
++  kernel_type = KERNEL_TYPE_NONE;
++  /* BSD and chainloading evil hacks!  */
++  bootdev = set_bootdev (0);
++  mb_cmdline = (char *) MB_CMDLINE_BUF;
++}
++
++/* Initialize the data for the configuration file.  */
++void
++init_config (void)
++{
++  default_entry = 0;
++  password = 0;
++  fallback_entry = -1;
++  grub_timeout = -1;
++}
++
++/* Check a password for correctness.  Returns 0 if password was
++   correct, and a value != 0 for error, similarly to strcmp. */
++int
++check_password (char *entered, char* expected, password_t type)
++{
++  switch (type)
++    {
++    case PASSWORD_PLAIN:
++      return strcmp (entered, expected);
++
++#ifdef USE_MD5_PASSWORDS
++    case PASSWORD_MD5:
++      return check_md5_password (entered, expected);
++#endif
++    default: 
++      /* unsupported password type: be secure */
++      return 1;
++    }
++}
++
++/* Print which sector is read when loading a file.  */
++static void
++disk_read_print_func (int sector, int offset, int length)
++{
++  grub_printf ("[%d,%d,%d]", sector, offset, length);
++}
++
++
++/* blocklist */
++static int
++blocklist_func (char *arg, int flags)
++{
++  char *dummy = (char *) RAW_ADDR (0x100000);
++  int start_sector;
++  int num_sectors = 0;
++  int num_entries = 0;
++  int last_length = 0;
++
++  /* Collect contiguous blocks into one entry as many as possible,
++     and print the blocklist notation on the screen.  */
++  static void disk_read_blocklist_func (int sector, int offset, int length)
++    {
++      if (num_sectors > 0)
++	{
++	  if (start_sector + num_sectors == sector
++	      && offset == 0 && last_length == SECTOR_SIZE)
++	    {
++	      num_sectors++;
++	      last_length = length;
++	      return;
++	    }
++	  else
++	    {
++	      if (last_length == SECTOR_SIZE)
++		grub_printf ("%s%d+%d", num_entries ? "," : "",
++			     start_sector - part_start, num_sectors);
++	      else if (num_sectors > 1)
++		grub_printf ("%s%d+%d,%d[0-%d]", num_entries ? "," : "",
++			     start_sector - part_start, num_sectors-1,
++			     start_sector + num_sectors-1 - part_start, 
++			     last_length);
++	      else
++		grub_printf ("%s%d[0-%d]", num_entries ? "," : "",
++			     start_sector - part_start, last_length);
++	      num_entries++;
++	      num_sectors = 0;
++	    }
++	}
++
++      if (offset > 0)
++	{
++	  grub_printf("%s%d[%d-%d]", num_entries ? "," : "",
++		      sector-part_start, offset, offset+length);
++	  num_entries++;
++	}
++      else
++	{
++	  start_sector = sector;
++	  num_sectors = 1;
++	  last_length = length;
++	}
++    }
++
++  /* Open the file.  */
++  if (! grub_open (arg))
++    return 1;
++
++  /* Print the device name.  */
++  grub_printf ("(%cd%d",
++	       (current_drive & 0x80) ? 'h' : 'f',
++	       current_drive & ~0x80);
++  
++  if ((current_partition & 0xFF0000) != 0xFF0000)
++    grub_printf (",%d", (current_partition >> 16) & 0xFF);
++  
++  if ((current_partition & 0x00FF00) != 0x00FF00)
++    grub_printf (",%c", 'a' + ((current_partition >> 8) & 0xFF));
++  
++  grub_printf (")");
++
++  /* Read in the whole file to DUMMY.  */
++  disk_read_hook = disk_read_blocklist_func;
++  if (! grub_read (dummy, -1))
++    goto fail;
++
++  /* The last entry may not be printed yet.  Don't check if it is a
++   * full sector, since it doesn't matter if we read too much. */
++  if (num_sectors > 0)
++    grub_printf ("%s%d+%d", num_entries ? "," : "",
++		 start_sector - part_start, num_sectors);
++
++  grub_printf ("\n");
++  
++ fail:
++  disk_read_hook = 0;
++  grub_close ();
++  return errnum;
++}
++
++static struct builtin builtin_blocklist =
++{
++  "blocklist",
++  blocklist_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "blocklist FILE",
++  "Print the blocklist notation of the file FILE."
++};
++
++/* boot */
++static int
++boot_func (char *arg, int flags)
++{
++  /* Clear the int15 handler if we can boot the kernel successfully.
++     This assumes that the boot code never fails only if KERNEL_TYPE is
++     not KERNEL_TYPE_NONE. Is this assumption is bad?  */
++  if (kernel_type != KERNEL_TYPE_NONE)
++    unset_int15_handler ();
++
++#ifdef SUPPORT_NETBOOT
++  /* Shut down the networking.  */
++  cleanup_net ();
++#endif
++  
++  switch (kernel_type)
++    {
++    case KERNEL_TYPE_FREEBSD:
++    case KERNEL_TYPE_NETBSD:
++      /* *BSD */
++      bsd_boot (kernel_type, bootdev, (char *) mbi.cmdline);
++      break;
++
++    case KERNEL_TYPE_LINUX:
++      /* Linux */
++      linux_boot ();
++      break;
++
++    case KERNEL_TYPE_BIG_LINUX:
++      /* Big Linux */
++      big_linux_boot ();
++      break;
++
++    case KERNEL_TYPE_CHAINLOADER:
++      /* Chainloader */
++      
++      /* Check if we should set the int13 handler.  */
++      if (bios_drive_map[0] != 0)
++	{
++	  int i;
++	  
++	  /* Search for SAVED_DRIVE.  */
++	  for (i = 0; i < DRIVE_MAP_SIZE; i++)
++	    {
++	      if (! bios_drive_map[i])
++		break;
++	      else if ((bios_drive_map[i] & 0xFF) == saved_drive)
++		{
++		  /* Exchage SAVED_DRIVE with the mapped drive.  */
++		  saved_drive = (bios_drive_map[i] >> 8) & 0xFF;
++		  break;
++		}
++	    }
++	  
++	  /* Set the handler. This is somewhat dangerous.  */
++	  set_int13_handler (bios_drive_map);
++	}
++      
++      gateA20 (0);
++      boot_drive = saved_drive;
++      chain_stage1 (0, BOOTSEC_LOCATION, boot_part_addr);
++      break;
++
++    case KERNEL_TYPE_MULTIBOOT:
++      /* Multiboot */
++      multi_boot ((int) entry_addr, (int) &mbi);
++      break;
++
++    default:
++      errnum = ERR_BOOT_COMMAND;
++      return 1;
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_boot =
++{
++  "boot",
++  boot_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "boot",
++  "Boot the OS/chain-loader which has been loaded."
++};
++
++
++#ifdef SUPPORT_NETBOOT
++/* bootp */
++static int
++bootp_func (char *arg, int flags)
++{
++  int with_configfile = 0;
++
++  if (grub_memcmp (arg, "--with-configfile", sizeof ("--with-configfile") - 1)
++      == 0)
++    {
++      with_configfile = 1;
++      arg = skip_to (0, arg);
++    }
++  
++  if (! bootp ())
++    {
++      if (errnum == ERR_NONE)
++	errnum = ERR_DEV_VALUES;
++
++      return 1;
++    }
++
++  /* Notify the configuration.  */
++  print_network_configuration ();
++
++  /* XXX: this can cause an endless loop, but there is no easy way to
++     detect such a loop unfortunately.  */
++  if (with_configfile)
++    configfile_func (config_file, flags);
++  
++  return 0;
++}
++
++static struct builtin builtin_bootp =
++{
++  "bootp",
++  bootp_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "bootp [--with-configfile]",
++  "Initialize a network device via BOOTP. If the option `--with-configfile'"
++  " is given, try to load a configuration file specified by the 150 vendor"
++  " tag."
++};
++#endif /* SUPPORT_NETBOOT */
++
++
++/* cat */
++static int
++cat_func (char *arg, int flags)
++{
++  char c;
++
++  if (! grub_open (arg))
++    return 1;
++
++  while (grub_read (&c, 1))
++    {
++      /* Because running "cat" with a binary file can confuse the terminal,
++	 print only some characters as they are.  */
++      if (grub_isspace (c) || (c >= ' ' && c <= '~'))
++	grub_putchar (c);
++      else
++	grub_putchar ('?');
++    }
++  
++  grub_close ();
++  return 0;
++}
++
++static struct builtin builtin_cat =
++{
++  "cat",
++  cat_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "cat FILE",
++  "Print the contents of the file FILE."
++};
++
++
++/* chainloader */
++static int
++chainloader_func (char *arg, int flags)
++{
++  int force = 0;
++  char *file = arg;
++
++  /* If the option `--force' is specified?  */
++  if (substring ("--force", arg) <= 0)
++    {
++      force = 1;
++      file = skip_to (0, arg);
++    }
++
++  /* Open the file.  */
++  if (! grub_open (file))
++    {
++      kernel_type = KERNEL_TYPE_NONE;
++      return 1;
++    }
++
++  /* Read the first block.  */
++  if (grub_read ((char *) BOOTSEC_LOCATION, SECTOR_SIZE) != SECTOR_SIZE)
++    {
++      grub_close ();
++      kernel_type = KERNEL_TYPE_NONE;
++
++      /* This below happens, if a file whose size is less than 512 bytes
++	 is loaded.  */
++      if (errnum == ERR_NONE)
++	errnum = ERR_EXEC_FORMAT;
++      
++      return 1;
++    }
++
++  /* If not loading it forcibly, check for the signature.  */
++  if (! force
++      && (*((unsigned short *) (BOOTSEC_LOCATION + BOOTSEC_SIG_OFFSET))
++	  != BOOTSEC_SIGNATURE))
++    {
++      grub_close ();
++      errnum = ERR_EXEC_FORMAT;
++      kernel_type = KERNEL_TYPE_NONE;
++      return 1;
++    }
++
++  grub_close ();
++  kernel_type = KERNEL_TYPE_CHAINLOADER;
++
++  /* XXX: Windows evil hack. For now, only the first five letters are
++     checked.  */
++  if (IS_PC_SLICE_TYPE_FAT (current_slice)
++      && ! grub_memcmp ((char *) BOOTSEC_LOCATION + BOOTSEC_BPB_SYSTEM_ID,
++			"MSWIN", 5))
++    *((unsigned long *) (BOOTSEC_LOCATION + BOOTSEC_BPB_HIDDEN_SECTORS))
++      = part_start;
++
++  errnum = ERR_NONE;
++  
++  return 0;
++}
++
++static struct builtin builtin_chainloader =
++{
++  "chainloader",
++  chainloader_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "chainloader [--force] FILE",
++  "Load the chain-loader FILE. If --force is specified, then load it"
++  " forcibly, whether the boot loader signature is present or not."
++};
++
++
++/* This function could be used to debug new filesystem code. Put a file
++   in the new filesystem and the same file in a well-tested filesystem.
++   Then, run "cmp" with the files. If no output is obtained, probably
++   the code is good, otherwise investigate what's wrong...  */
++/* cmp FILE1 FILE2 */
++static int
++cmp_func (char *arg, int flags)
++{
++  /* The filenames.  */
++  char *file1, *file2;
++  /* The addresses.  */
++  char *addr1, *addr2;
++  int i;
++  /* The size of the file.  */
++  int size;
++
++  /* Get the filenames from ARG.  */
++  file1 = arg;
++  file2 = skip_to (0, arg);
++  if (! *file1 || ! *file2)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  /* Terminate the filenames for convenience.  */
++  nul_terminate (file1);
++  nul_terminate (file2);
++
++  /* Read the whole data from FILE1.  */
++  addr1 = (char *) RAW_ADDR (0x100000);
++  if (! grub_open (file1))
++    return 1;
++  
++  /* Get the size.  */
++  size = filemax;
++  if (grub_read (addr1, -1) != size)
++    {
++      grub_close ();
++      return 1;
++    }
++  
++  grub_close ();
++
++  /* Read the whole data from FILE2.  */
++  addr2 = addr1 + size;
++  if (! grub_open (file2))
++    return 1;
++
++  /* Check if the size of FILE2 is equal to the one of FILE2.  */
++  if (size != filemax)
++    {
++      grub_printf ("Differ in size: 0x%x [%s], 0x%x [%s]\n",
++		   size, file1, filemax, file2);
++      grub_close ();
++      return 0;
++    }
++  
++  if (! grub_read (addr2, -1))
++    {
++      grub_close ();
++      return 1;
++    }
++  
++  grub_close ();
++
++  /* Now compare ADDR1 with ADDR2.  */
++  for (i = 0; i < size; i++)
++    {
++      if (addr1[i] != addr2[i])
++	grub_printf ("Differ at the offset %d: 0x%x [%s], 0x%x [%s]\n",
++		     i, (unsigned) addr1[i], file1,
++		     (unsigned) addr2[i], file2);
++    }
++  
++  return 0;
++}
++
++static struct builtin builtin_cmp =
++{
++  "cmp",
++  cmp_func,
++  BUILTIN_CMDLINE,
++  "cmp FILE1 FILE2",
++  "Compare the file FILE1 with the FILE2 and inform the different values"
++  " if any."
++};
++
++
++/* color */
++/* Set new colors used for the menu interface. Support two methods to
++   specify a color name: a direct integer representation and a symbolic
++   color name. An example of the latter is "blink-light-gray/blue".  */
++static int
++color_func (char *arg, int flags)
++{
++  char *normal;
++  char *highlight;
++  int new_normal_color;
++  int new_highlight_color;
++  static char *color_list[16] =
++  {
++    "black",
++    "blue",
++    "green",
++    "cyan",
++    "red",
++    "magenta",
++    "brown",
++    "light-gray",
++    "dark-gray",
++    "light-blue",
++    "light-green",
++    "light-cyan",
++    "light-red",
++    "light-magenta",
++    "yellow",
++    "white"
++  };
++
++  /* Convert the color name STR into the magical number.  */
++  static int color_number (char *str)
++    {
++      char *ptr;
++      int i;
++      int color = 0;
++      
++      /* Find the separator.  */
++      for (ptr = str; *ptr && *ptr != '/'; ptr++)
++	;
++
++      /* If not found, return -1.  */
++      if (! *ptr)
++	return -1;
++
++      /* Terminate the string STR.  */
++      *ptr++ = 0;
++
++      /* If STR contains the prefix "blink-", then set the `blink' bit
++	 in COLOR.  */
++      if (substring ("blink-", str) <= 0)
++	{
++	  color = 0x80;
++	  str += 6;
++	}
++      
++      /* Search for the color name.  */
++      for (i = 0; i < 16; i++)
++	if (grub_strcmp (color_list[i], str) == 0)
++	  {
++	    color |= i;
++	    break;
++	  }
++
++      if (i == 16)
++	return -1;
++
++      str = ptr;
++      nul_terminate (str);
++
++      /* Search for the color name.  */      
++      for (i = 0; i < 8; i++)
++	if (grub_strcmp (color_list[i], str) == 0)
++	  {
++	    color |= i << 4;
++	    break;
++	  }
++
++      if (i == 8)
++	return -1;
++
++      return color;
++    }
++      
++  normal = arg;
++  highlight = skip_to (0, arg);
++
++  new_normal_color = color_number (normal);
++  if (new_normal_color < 0 && ! safe_parse_maxint (&normal, &new_normal_color))
++    return 1;
++  
++  /* The second argument is optional, so set highlight_color
++     to inverted NORMAL_COLOR.  */
++  if (! *highlight)
++    new_highlight_color = ((new_normal_color >> 4)
++			   | ((new_normal_color & 0xf) << 4));
++  else
++    {
++      new_highlight_color = color_number (highlight);
++      if (new_highlight_color < 0
++	  && ! safe_parse_maxint (&highlight, &new_highlight_color))
++	return 1;
++    }
++
++  if (current_term->setcolor)
++    current_term->setcolor (new_normal_color, new_highlight_color);
++  
++  return 0;
++}
++
++static struct builtin builtin_color =
++{
++  "color",
++  color_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "color NORMAL [HIGHLIGHT]",
++  "Change the menu colors. The color NORMAL is used for most"
++  " lines in the menu, and the color HIGHLIGHT is used to highlight the"
++  " line where the cursor points. If you omit HIGHLIGHT, then the"
++  " inverted color of NORMAL is used for the highlighted line."
++  " The format of a color is \"FG/BG\". FG and BG are symbolic color names."
++  " A symbolic color name must be one of these: black, blue, green,"
++  " cyan, red, magenta, brown, light-gray, dark-gray, light-blue,"
++  " light-green, light-cyan, light-red, light-magenta, yellow and white."
++  " But only the first eight names can be used for BG. You can prefix"
++  " \"blink-\" to FG if you want a blinking foreground color."
++};
++
++
++/* configfile */
++static int
++configfile_func (char *arg, int flags)
++{
++  char *new_config = config_file;
++
++  /* Check if the file ARG is present.  */
++  if (! grub_open (arg))
++    return 1;
++
++  grub_close ();
++  
++  /* Copy ARG to CONFIG_FILE.  */
++  while ((*new_config++ = *arg++) != 0)
++    ;
++
++#ifdef GRUB_UTIL
++  /* Force to load the configuration file.  */
++  use_config_file = 1;
++#endif
++
++  /* Make sure that the user will not be authoritative.  */
++  auth = 0;
++  
++  /* Restart cmain.  */
++  grub_longjmp (restart_env, 0);
++
++  /* Never reach here.  */
++  return 0;
++}
++
++static struct builtin builtin_configfile =
++{
++  "configfile",
++  configfile_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "configfile FILE",
++  "Load FILE as the configuration file."
++};
++
++
++/* debug */
++static int
++debug_func (char *arg, int flags)
++{
++  if (debug)
++    {
++      debug = 0;
++      grub_printf (" Debug mode is turned off\n");
++    }
++  else
++    {
++      debug = 1;
++      grub_printf (" Debug mode is turned on\n");
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_debug =
++{
++  "debug",
++  debug_func,
++  BUILTIN_CMDLINE,
++  "debug",
++  "Turn on/off the debug mode."
++};
++
++
++/* default */
++static int
++default_func (char *arg, int flags)
++{
++#ifndef SUPPORT_DISKLESS
++  if (grub_strcmp (arg, "saved") == 0)
++    {
++      default_entry = saved_entryno;
++      return 0;
++    }
++#endif /* SUPPORT_DISKLESS */
++  
++  if (! safe_parse_maxint (&arg, &default_entry))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_default =
++{
++  "default",
++  default_func,
++  BUILTIN_MENU,
++#if 0
++  "default [NUM | `saved']",
++  "Set the default entry to entry number NUM (if not specified, it is"
++  " 0, the first entry) or the entry number saved by savedefault."
++#endif
++};
++
++
++#ifdef GRUB_UTIL
++/* device */
++static int
++device_func (char *arg, int flags)
++{
++  char *drive = arg;
++  char *device;
++
++  /* Get the drive number from DRIVE.  */
++  if (! set_device (drive))
++    return 1;
++
++  /* Get the device argument.  */
++  device = skip_to (0, drive);
++  
++  /* Terminate DEVICE.  */
++  nul_terminate (device);
++
++  if (! *device || ! check_device (device))
++    {
++      errnum = ERR_FILE_NOT_FOUND;
++      return 1;
++    }
++
++  assign_device_name (current_drive, device);
++  
++  return 0;
++}
++
++static struct builtin builtin_device =
++{
++  "device",
++  device_func,
++  BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "device DRIVE DEVICE",
++  "Specify DEVICE as the actual drive for a BIOS drive DRIVE. This command"
++  " can be used only in the grub shell."
++};
++#endif /* GRUB_UTIL */
++
++
++#ifdef SUPPORT_NETBOOT
++/* dhcp */
++static int
++dhcp_func (char *arg, int flags)
++{
++  /* For now, this is an alias for bootp.  */
++  return bootp_func (arg, flags);
++}
++
++static struct builtin builtin_dhcp =
++{
++  "dhcp",
++  dhcp_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "dhcp",
++  "Initialize a network device via DHCP."
++};
++#endif /* SUPPORT_NETBOOT */
++
++
++/* displayapm */
++static int
++displayapm_func (char *arg, int flags)
++{
++  if (mbi.flags & MB_INFO_APM_TABLE)
++    {
++      grub_printf ("APM BIOS information:\n"
++		   " Version:          0x%x\n"
++		   " 32-bit CS:        0x%x\n"
++		   " Offset:           0x%x\n"
++		   " 16-bit CS:        0x%x\n"
++		   " 16-bit DS:        0x%x\n"
++		   " 32-bit CS length: 0x%x\n"
++		   " 16-bit CS length: 0x%x\n"
++		   " 16-bit DS length: 0x%x\n",
++		   (unsigned) apm_bios_info.version,
++		   (unsigned) apm_bios_info.cseg,
++		   apm_bios_info.offset,
++		   (unsigned) apm_bios_info.cseg_16,
++		   (unsigned) apm_bios_info.dseg_16,
++		   (unsigned) apm_bios_info.cseg_len,
++		   (unsigned) apm_bios_info.cseg_16_len,
++		   (unsigned) apm_bios_info.dseg_16_len);
++    }
++  else
++    {
++      grub_printf ("No APM BIOS found or probe failed\n");
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_displayapm =
++{
++  "displayapm",
++  displayapm_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "displayapm",
++  "Display APM BIOS information."
++};
++
++
++/* displaymem */
++static int
++displaymem_func (char *arg, int flags)
++{
++  if (get_eisamemsize () != -1)
++    grub_printf (" EISA Memory BIOS Interface is present\n");
++  if (get_mmap_entry ((void *) SCRATCHADDR, 0) != 0
++      || *((int *) SCRATCHADDR) != 0)
++    grub_printf (" Address Map BIOS Interface is present\n");
++
++  grub_printf (" Lower memory: %uK, "
++	       "Upper memory (to first chipset hole): %uK\n",
++	       mbi.mem_lower, mbi.mem_upper);
++
++  if (mbi.flags & MB_INFO_MEM_MAP)
++    {
++      struct AddrRangeDesc *map = (struct AddrRangeDesc *) mbi.mmap_addr;
++      int end_addr = mbi.mmap_addr + mbi.mmap_length;
++
++      grub_printf (" [Address Range Descriptor entries "
++		   "immediately follow (values are 64-bit)]\n");
++      while (end_addr > (int) map)
++	{
++	  char *str;
++
++	  if (map->Type == MB_ARD_MEMORY)
++	    str = "Usable RAM";
++	  else
++	    str = "Reserved";
++	  grub_printf ("   %s:  Base Address:  0x%x X 4GB + 0x%x,\n"
++		       "      Length:   0x%x X 4GB + 0x%x bytes\n",
++		       str,
++		       (unsigned long) (map->BaseAddr >> 32),
++		       (unsigned long) (map->BaseAddr & 0xFFFFFFFF),
++		       (unsigned long) (map->Length >> 32),
++		       (unsigned long) (map->Length & 0xFFFFFFFF));
++
++	  map = ((struct AddrRangeDesc *) (((int) map) + 4 + map->size));
++	}
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_displaymem =
++{
++  "displaymem",
++  displaymem_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "displaymem",
++  "Display what GRUB thinks the system address space map of the"
++  " machine is, including all regions of physical RAM installed."
++};
++
++
++/* dump FROM TO */
++#ifdef GRUB_UTIL
++static int
++dump_func (char *arg, int flags)
++{
++  char *from, *to;
++  FILE *fp;
++  char c;
++  
++  from = arg;
++  to = skip_to (0, arg);
++  if (! *from || ! *to)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  nul_terminate (from);
++  nul_terminate (to);
++  
++  if (! grub_open (from))
++    return 1;
++
++  fp = fopen (to, "w");
++  if (! fp)
++    {
++      errnum = ERR_WRITE;
++      return 1;
++    }
++
++  while (grub_read (&c, 1))
++    if (fputc (c, fp) == EOF)
++      {
++	errnum = ERR_WRITE;
++	fclose (fp);
++	return 1;
++      }
++
++  if (fclose (fp) == EOF)
++    {
++      errnum = ERR_WRITE;
++      return 1;
++    }
++
++  grub_close ();
++  return 0;
++}
++
++static struct builtin builtin_dump =
++  {
++    "dump",
++    dump_func,
++    BUILTIN_CMDLINE,
++    "dump FROM TO",
++    "Dump the contents of the file FROM to the file TO. FROM must be"
++    " a GRUB file and TO must be an OS file."
++  };
++#endif /* GRUB_UTIL */
++
++
++static char embed_info[32];
++/* embed */
++/* Embed a Stage 1.5 in the first cylinder after MBR or in the
++   bootloader block in a FFS.  */
++static int
++embed_func (char *arg, int flags)
++{
++  char *stage1_5;
++  char *device;
++  char *stage1_5_buffer = (char *) RAW_ADDR (0x100000);
++  int len, size;
++  int sector;
++  
++  stage1_5 = arg;
++  device = skip_to (0, stage1_5);
++
++  /* Open a Stage 1.5.  */
++  if (! grub_open (stage1_5))
++    return 1;
++
++  /* Read the whole of the Stage 1.5.  */
++  len = grub_read (stage1_5_buffer, -1);
++  grub_close ();
++  
++  if (errnum)
++    return 1;
++  
++  size = (len + SECTOR_SIZE - 1) / SECTOR_SIZE;
++  
++  /* Get the device where the Stage 1.5 will be embedded.  */
++  set_device (device);
++  if (errnum)
++    return 1;
++
++  if (current_partition == 0xFFFFFF)
++    {
++      /* Embed it after the MBR.  */
++      
++      char mbr[SECTOR_SIZE];
++      char ezbios_check[2*SECTOR_SIZE];
++      int i;
++      
++      /* Open the partition.  */
++      if (! open_partition ())
++	return 1;
++
++      /* No floppy has MBR.  */
++      if (! (current_drive & 0x80))
++	{
++	  errnum = ERR_DEV_VALUES;
++	  return 1;
++	}
++      
++      /* Read the MBR of CURRENT_DRIVE.  */
++      if (! rawread (current_drive, PC_MBR_SECTOR, 0, SECTOR_SIZE, mbr))
++	return 1;
++      
++      /* Sanity check.  */
++      if (! PC_MBR_CHECK_SIG (mbr))
++	{
++	  errnum = ERR_BAD_PART_TABLE;
++	  return 1;
++	}
++
++      /* Check if the disk can store the Stage 1.5.  */
++      for (i = 0; i < 4; i++)
++	if (PC_SLICE_TYPE (mbr, i) && PC_SLICE_START (mbr, i) - 1 < size)
++	  {
++	    errnum = ERR_NO_DISK_SPACE;
++	    return 1;
++	  }
++      
++      /* Check for EZ-BIOS signature. It should be in the third
++       * sector, but due to remapping it can appear in the second, so
++       * load and check both.  
++       */
++      if (! rawread (current_drive, 1, 0, 2 * SECTOR_SIZE, ezbios_check))
++	return 1;
++
++      if (! memcmp (ezbios_check + 3, "AERMH", 5)
++	  || ! memcmp (ezbios_check + 512 + 3, "AERMH", 5))
++	{
++	  /* The space after the MBR is used by EZ-BIOS which we must 
++	   * not overwrite.
++	   */
++	  errnum = ERR_NO_DISK_SPACE;
++	  return 1;
++	}
++
++      sector = 1;
++    }
++  else
++    {
++      /* Embed it in the bootloader block in the filesystem.  */
++      int start_sector;
++      
++      /* Open the partition.  */
++      if (! open_device ())
++	return 1;
++
++      /* Check if the current slice supports embedding.  */
++      if (fsys_table[fsys_type].embed_func == 0
++	  || ! fsys_table[fsys_type].embed_func (&start_sector, size))
++	{
++	  errnum = ERR_DEV_VALUES;
++	  return 1;
++	}
++
++      sector = part_start + start_sector;
++    }
++
++  /* Clear the cache.  */
++  buf_track = -1;
++
++  /* Now perform the embedding.  */
++  if (! devwrite (sector - part_start, size, stage1_5_buffer))
++    return 1;
++  
++  grub_printf (" %d sectors are embedded.\n", size);
++  grub_sprintf (embed_info, "%d+%d", sector - part_start, size);
++  return 0;
++}
++
++static struct builtin builtin_embed =
++{
++  "embed",
++  embed_func,
++  BUILTIN_CMDLINE,
++  "embed STAGE1_5 DEVICE",
++  "Embed the Stage 1.5 STAGE1_5 in the sectors after MBR if DEVICE"
++  " is a drive, or in the \"bootloader\" area if DEVICE is a FFS partition."
++  " Print the number of sectors which STAGE1_5 occupies if successful."
++};
++
++
++/* fallback */
++static int
++fallback_func (char *arg, int flags)
++{
++  if (! safe_parse_maxint (&arg, &fallback_entry))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_fallback =
++{
++  "fallback",
++  fallback_func,
++  BUILTIN_MENU,
++#if 0
++  "fallback NUM",
++  "Go into unattended boot mode: if the default boot entry has any"
++  " errors, instead of waiting for the user to do anything, it"
++  " immediately starts over using the NUM entry (same numbering as the"
++  " `default' command). This obviously won't help if the machine"
++  " was rebooted by a kernel that GRUB loaded."
++#endif
++};
++
++
++/* find */
++/* Search for the filename ARG in all of partitions.  */
++static int
++find_func (char *arg, int flags)
++{
++  char *filename = arg;
++  unsigned long drive;
++  unsigned long tmp_drive = saved_drive;
++  unsigned long tmp_partition = saved_partition;
++  int got_file = 0;
++  
++  /* Floppies.  */
++  for (drive = 0; drive < 8; drive++)
++    {
++      current_drive = drive;
++      current_partition = 0xFFFFFF;
++      
++      if (open_device ())
++	{
++	  saved_drive = current_drive;
++	  saved_partition = current_partition;
++	  if (grub_open (filename))
++	    {
++	      grub_close ();
++	      grub_printf (" (fd%d)\n", drive);
++	      got_file = 1;
++	    }
++	}
++
++      errnum = ERR_NONE;
++    }
++
++  /* Hard disks.  */
++  for (drive = 0x80; drive < 0x88; drive++)
++    {
++      unsigned long part = 0xFFFFFF;
++      unsigned long start, len, offset, ext_offset;
++      int type, entry;
++      char buf[SECTOR_SIZE];
++
++      current_drive = drive;
++      while (next_partition (drive, 0xFFFFFF, &part, &type,
++			     &start, &len, &offset, &entry,
++			     &ext_offset, buf))
++	{
++	  if (type != PC_SLICE_TYPE_NONE
++	      && ! IS_PC_SLICE_TYPE_BSD (type)
++	      && ! IS_PC_SLICE_TYPE_EXTENDED (type))
++	    {
++	      current_partition = part;
++	      if (open_device ())
++		{
++		  saved_drive = current_drive;
++		  saved_partition = current_partition;
++		  if (grub_open (filename))
++		    {
++		      int bsd_part = (part >> 8) & 0xFF;
++		      int pc_slice = part >> 16;
++		      
++		      grub_close ();
++		      
++		      if (bsd_part == 0xFF)
++			grub_printf (" (hd%d,%d)\n",
++				     drive - 0x80, pc_slice);
++		      else
++			grub_printf (" (hd%d,%d,%c)\n",
++				     drive - 0x80, pc_slice, bsd_part + 'a');
++
++		      got_file = 1;
++		    }
++		}
++	    }
++
++	  /* We want to ignore any error here.  */
++	  errnum = ERR_NONE;
++	}
++
++      /* next_partition always sets ERRNUM in the last call, so clear
++	 it.  */
++      errnum = ERR_NONE;
++    }
++
++  saved_drive = tmp_drive;
++  saved_partition = tmp_partition;
++
++  if (got_file)
++    {
++      errnum = ERR_NONE;
++      return 0;
++    }
++
++  errnum = ERR_FILE_NOT_FOUND;
++  return 1;
++}
++
++static struct builtin builtin_find =
++{
++  "find",
++  find_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "find FILENAME",
++  "Search for the filename FILENAME in all of partitions and print the list of"
++  " the devices which contain the file."
++};
++
++
++/* fstest */
++static int
++fstest_func (char *arg, int flags)
++{
++  if (disk_read_hook)
++    {
++      disk_read_hook = NULL;
++      printf (" Filesystem tracing is now off\n");
++    }
++  else
++    {
++      disk_read_hook = disk_read_print_func;
++      printf (" Filesystem tracing is now on\n");
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_fstest =
++{
++  "fstest",
++  fstest_func,
++  BUILTIN_CMDLINE,
++  "fstest",
++  "Toggle filesystem test mode."
++};
++
++
++/* geometry */
++static int
++geometry_func (char *arg, int flags)
++{
++  struct geometry geom;
++  char *msg;
++  char *device = arg;
++#ifdef GRUB_UTIL
++  char *ptr;
++#endif
++
++  /* Get the device number.  */
++  set_device (device);
++  if (errnum)
++    return 1;
++
++  /* Check for the geometry.  */
++  if (get_diskinfo (current_drive, &geom))
++    {
++      errnum = ERR_NO_DISK;
++      return 1;
++    }
++
++  /* Attempt to read the first sector, because some BIOSes turns out not
++     to support LBA even though they set the bit 0 in the support
++     bitmap, only after reading something actually.  */
++  if (biosdisk (BIOSDISK_READ, current_drive, &geom, 0, 1, SCRATCHSEG))
++    {
++      errnum = ERR_READ;
++      return 1;
++    }
++
++#ifdef GRUB_UTIL
++  ptr = skip_to (0, device);
++  if (*ptr)
++    {
++      char *cylinder, *head, *sector, *total_sector;
++      int num_cylinder, num_head, num_sector, num_total_sector;
++
++      cylinder = ptr;
++      head = skip_to (0, cylinder);
++      sector = skip_to (0, head);
++      total_sector = skip_to (0, sector);
++      if (! safe_parse_maxint (&cylinder, &num_cylinder)
++	  || ! safe_parse_maxint (&head, &num_head)
++	  || ! safe_parse_maxint (&sector, &num_sector))
++	return 1;
++
++      disks[current_drive].cylinders = num_cylinder;
++      disks[current_drive].heads = num_head;
++      disks[current_drive].sectors = num_sector;
++
++      if (safe_parse_maxint (&total_sector, &num_total_sector))
++	disks[current_drive].total_sectors = num_total_sector;
++      else
++	disks[current_drive].total_sectors
++	  = num_cylinder * num_head * num_sector;
++      errnum = 0;
++
++      geom = disks[current_drive];
++      buf_drive = -1;
++    }
++#endif /* GRUB_UTIL */
++
++#ifdef GRUB_UTIL
++  msg = device_map[current_drive];
++#else
++  if (geom.flags & BIOSDISK_FLAG_LBA_EXTENSION)
++    msg = "LBA";
++  else
++    msg = "CHS";
++#endif
++
++  grub_printf ("drive 0x%x: C/H/S = %d/%d/%d, "
++	       "The number of sectors = %d, %s\n",
++	       current_drive,
++	       geom.cylinders, geom.heads, geom.sectors,
++	       geom.total_sectors, msg);
++  real_open_partition (1);
++
++  return 0;
++}
++
++static struct builtin builtin_geometry =
++{
++  "geometry",
++  geometry_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "geometry DRIVE [CYLINDER HEAD SECTOR [TOTAL_SECTOR]]",
++  "Print the information for a drive DRIVE. In the grub shell, you can"
++  " set the geometry of the drive arbitrarily. The number of the cylinders,"
++  " the one of the heads, the one of the sectors and the one of the total"
++  " sectors are set to CYLINDER, HEAD, SECTOR and TOTAL_SECTOR,"
++  " respectively. If you omit TOTAL_SECTOR, then it will be calculated based"
++  " on the C/H/S values automatically."
++};
++
++
++/* halt */
++static int
++halt_func (char *arg, int flags)
++{
++  int no_apm;
++
++  no_apm = (grub_memcmp (arg, "--no-apm", 8) == 0);
++  grub_halt (no_apm);
++  
++  /* Never reach here.  */
++  return 1;
++}
++
++static struct builtin builtin_halt =
++{
++  "halt",
++  halt_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "halt [--no-apm]",
++  "Halt your system. If APM is avaiable on it, turn off the power using"
++  " the APM BIOS, unless you specify the option `--no-apm'."
++};
++
++
++/* help */
++#define MAX_SHORT_DOC_LEN	39
++#define MAX_LONG_DOC_LEN	66
++
++static int
++help_func (char *arg, int flags)
++{
++  int all = 0;
++  
++  if (grub_memcmp (arg, "--all", sizeof ("--all") - 1) == 0)
++    {
++      all = 1;
++      arg = skip_to (0, arg);
++    }
++  
++  if (! *arg)
++    {
++      /* Invoked with no argument. Print the list of the short docs.  */
++      struct builtin **builtin;
++      int left = 1;
++
++      for (builtin = builtin_table; *builtin != 0; builtin++)
++	{
++	  int len;
++	  int i;
++
++	  /* If this cannot be used in the command-line interface,
++	     skip this.  */
++	  if (! ((*builtin)->flags & BUILTIN_CMDLINE))
++	    continue;
++	  
++	  /* If this doesn't need to be listed automatically and "--all"
++	     is not specified, skip this.  */
++	  if (! all && ! ((*builtin)->flags & BUILTIN_HELP_LIST))
++	    continue;
++
++	  len = grub_strlen ((*builtin)->short_doc);
++	  /* If the length of SHORT_DOC is too long, truncate it.  */
++	  if (len > MAX_SHORT_DOC_LEN - 1)
++	    len = MAX_SHORT_DOC_LEN - 1;
++
++	  for (i = 0; i < len; i++)
++	    grub_putchar ((*builtin)->short_doc[i]);
++
++	  for (; i < MAX_SHORT_DOC_LEN; i++)
++	    grub_putchar (' ');
++
++	  if (! left)
++	    grub_putchar ('\n');
++
++	  left = ! left;
++	}
++
++      /* If the last entry was at the left column, no newline was printed
++	 at the end.  */
++      if (! left)
++	grub_putchar ('\n');
++    }
++  else
++    {
++      /* Invoked with one or more patterns.  */
++      do
++	{
++	  struct builtin **builtin;
++	  char *next_arg;
++
++	  /* Get the next argument.  */
++	  next_arg = skip_to (0, arg);
++
++	  /* Terminate ARG.  */
++	  nul_terminate (arg);
++
++	  for (builtin = builtin_table; *builtin; builtin++)
++	    {
++	      /* Skip this if this is only for the configuration file.  */
++	      if (! ((*builtin)->flags & BUILTIN_CMDLINE))
++		continue;
++
++	      if (substring (arg, (*builtin)->name) < 1)
++		{
++		  char *doc = (*builtin)->long_doc;
++
++		  /* At first, print the name and the short doc.  */
++		  grub_printf ("%s: %s\n",
++			       (*builtin)->name, (*builtin)->short_doc);
++
++		  /* Print the long doc.  */
++		  while (*doc)
++		    {
++		      int len = grub_strlen (doc);
++		      int i;
++
++		      /* If LEN is too long, fold DOC.  */
++		      if (len > MAX_LONG_DOC_LEN)
++			{
++			  /* Fold this line at the position of a space.  */
++			  for (len = MAX_LONG_DOC_LEN; len > 0; len--)
++			    if (doc[len - 1] == ' ')
++			      break;
++			}
++
++		      grub_printf ("    ");
++		      for (i = 0; i < len; i++)
++			grub_putchar (*doc++);
++		      grub_putchar ('\n');
++		    }
++		}
++	    }
++
++	  arg = next_arg;
++	}
++      while (*arg);
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_help =
++{
++  "help",
++  help_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "help [--all] [PATTERN ...]",
++  "Display helpful information about builtin commands. Not all commands"
++  " aren't shown without the option `--all'."
++};
++
++
++/* hiddenmenu */
++static int
++hiddenmenu_func (char *arg, int flags)
++{
++  show_menu = 0;
++  return 0;
++}
++
++static struct builtin builtin_hiddenmenu =
++{
++  "hiddenmenu",
++  hiddenmenu_func,
++  BUILTIN_MENU,
++#if 0
++  "hiddenmenu",
++  "Hide the menu."
++#endif
++};
++
++
++/* hide */
++static int
++hide_func (char *arg, int flags)
++{
++  if (! set_device (arg))
++    return 1;
++
++  if (! set_partition_hidden_flag (1))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_hide =
++{
++  "hide",
++  hide_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "hide PARTITION",
++  "Hide PARTITION by setting the \"hidden\" bit in"
++  " its partition type code."
++};
++
++
++#ifdef SUPPORT_NETBOOT
++/* ifconfig */
++static int
++ifconfig_func (char *arg, int flags)
++{
++  char *svr = 0, *ip = 0, *gw = 0, *sm = 0;
++  
++  if (! eth_probe ())
++    {
++      grub_printf ("No ethernet card found.\n");
++      errnum = ERR_DEV_VALUES;
++      return 1;
++    }
++  
++  while (*arg) 
++    {
++      if (! grub_memcmp ("--server=", arg, sizeof ("--server=") - 1))
++	svr = arg + sizeof("--server=") - 1;
++      else if (! grub_memcmp ("--address=", arg, sizeof ("--address=") - 1))
++	ip = arg + sizeof ("--address=") - 1;
++      else if (! grub_memcmp ("--gateway=", arg, sizeof ("--gateway=") - 1))
++	gw = arg + sizeof ("--gateway=") - 1;
++      else if (! grub_memcmp ("--mask=", arg, sizeof("--mask=") - 1))
++	sm = arg + sizeof ("--mask=") - 1;
++      else
++	{
++	  errnum = ERR_BAD_ARGUMENT;
++	  return 1;
++	}
++      
++      arg = skip_to (0, arg);
++    }
++  
++  if (! ifconfig (ip, sm, gw, svr))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  print_network_configuration ();
++  return 0;
++}
++
++static struct builtin builtin_ifconfig =
++{
++  "ifconfig",
++  ifconfig_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "ifconfig [--address=IP] [--gateway=IP] [--mask=MASK] [--server=IP]",
++  "Configure the IP address, the netmask, the gateway and the server"
++  " address or print current network configuration."
++};
++#endif /* SUPPORT_NETBOOT */
++
++
++/* impsprobe */
++static int
++impsprobe_func (char *arg, int flags)
++{
++#ifdef GRUB_UTIL
++  /* In the grub shell, we cannot probe IMPS.  */
++  errnum = ERR_UNRECOGNIZED;
++  return 1;
++#else /* ! GRUB_UTIL */
++  if (!imps_probe ())
++    printf (" No MPS information found or probe failed\n");
++
++  return 0;
++#endif /* ! GRUB_UTIL */
++}
++
++static struct builtin builtin_impsprobe =
++{
++  "impsprobe",
++  impsprobe_func,
++  BUILTIN_CMDLINE,
++  "impsprobe",
++  "Probe the Intel Multiprocessor Specification 1.1 or 1.4"
++  " configuration table and boot the various CPUs which are found into"
++  " a tight loop."
++};
++
++
++/* initrd */
++static int
++initrd_func (char *arg, int flags)
++{
++  switch (kernel_type)
++    {
++    case KERNEL_TYPE_LINUX:
++    case KERNEL_TYPE_BIG_LINUX:
++      if (! load_initrd (arg))
++	return 1;
++      break;
++
++    default:
++      errnum = ERR_NEED_LX_KERNEL;
++      return 1;
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_initrd =
++{
++  "initrd",
++  initrd_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "initrd FILE [ARG ...]",
++  "Load an initial ramdisk FILE for a Linux format boot image and set the"
++  " appropriate parameters in the Linux setup area in memory."
++};
++
++
++/* install */
++static int
++install_func (char *arg, int flags)
++{
++  char *stage1_file, *dest_dev, *file, *addr;
++  char *stage1_buffer = (char *) RAW_ADDR (0x100000);
++  char *stage2_buffer = stage1_buffer + SECTOR_SIZE;
++  char *old_sect = stage2_buffer + SECTOR_SIZE;
++  char *stage2_first_buffer = old_sect + SECTOR_SIZE;
++  char *stage2_second_buffer = stage2_first_buffer + SECTOR_SIZE;
++  /* XXX: Probably SECTOR_SIZE is reasonable.  */
++  char *config_filename = stage2_second_buffer + SECTOR_SIZE;
++  char *dummy = config_filename + SECTOR_SIZE;
++  int new_drive = 0xFF;
++  int dest_drive, dest_partition, dest_sector;
++  int src_drive, src_partition, src_part_start;
++  int i;
++  struct geometry dest_geom, src_geom;
++  int saved_sector;
++  int stage2_first_sector, stage2_second_sector;
++  char *ptr;
++  int installaddr, installlist;
++  /* Point to the location of the name of a configuration file in Stage 2.  */
++  char *config_file_location;
++  /* If FILE is a Stage 1.5?  */
++  int is_stage1_5 = 0;
++  /* Must call grub_close?  */
++  int is_open = 0;
++  /* If LBA is forced?  */
++  int is_force_lba = 0;
++  /* Was the last sector full? */
++  int last_length = SECTOR_SIZE;
++  
++#ifdef GRUB_UTIL
++  /* If the Stage 2 is in a partition mounted by an OS, this will store
++     the filename under the OS.  */
++  char *stage2_os_file = 0;
++#endif /* GRUB_UTIL */
++  
++  /* Save the first sector of Stage2 in STAGE2_SECT.  */
++  static void disk_read_savesect_func (int sector, int offset, int length)
++    {
++      if (debug)
++	printf ("[%d]", sector);
++
++      /* ReiserFS has files which sometimes contain data not aligned
++         on sector boundaries.  Returning an error is better than
++         silently failing. */
++      if (offset != 0 || length != SECTOR_SIZE)
++	errnum = ERR_UNALIGNED;
++
++      saved_sector = sector;
++    }
++
++  /* Write SECTOR to INSTALLLIST, and update INSTALLADDR and
++     INSTALLSECT.  */
++  static void disk_read_blocklist_func (int sector, int offset, int length)
++    {
++      if (debug)
++	printf("[%d]", sector);
++
++      if (offset != 0 || last_length != SECTOR_SIZE)
++	{
++	  /* We found a non-sector-aligned data block. */
++	  errnum = ERR_UNALIGNED;
++	  return;
++	}
++
++      last_length = length;
++
++      if (*((unsigned long *) (installlist - 4))
++	  + *((unsigned short *) installlist) != sector
++	  || installlist == (int) stage2_first_buffer + SECTOR_SIZE + 4)
++	{
++	  installlist -= 8;
++
++	  if (*((unsigned long *) (installlist - 8)))
++	    errnum = ERR_WONT_FIT;
++	  else
++	    {
++	      *((unsigned short *) (installlist + 2)) = (installaddr >> 4);
++	      *((unsigned long *) (installlist - 4)) = sector;
++	    }
++	}
++
++      *((unsigned short *) installlist) += 1;
++      installaddr += 512;
++    }
++
++  /* First, check the GNU-style long option.  */
++  while (1)
++    {
++      if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0)
++	{
++	  is_force_lba = 1;
++	  arg = skip_to (0, arg);
++	}
++#ifdef GRUB_UTIL
++      else if (grub_memcmp ("--stage2=", arg, sizeof ("--stage2=") - 1) == 0)
++	{
++	  stage2_os_file = arg + sizeof ("--stage2=") - 1;
++	  arg = skip_to (0, arg);
++	  nul_terminate (stage2_os_file);
++	}
++#endif /* GRUB_UTIL */
++      else
++	break;
++    }
++  
++  stage1_file = arg;
++  dest_dev = skip_to (0, stage1_file);
++  if (*dest_dev == 'd')
++    {
++      new_drive = 0;
++      dest_dev = skip_to (0, dest_dev);
++    }
++  file = skip_to (0, dest_dev);
++  addr = skip_to (0, file);
++
++  /* Get the installation address.  */
++  if (! safe_parse_maxint (&addr, &installaddr))
++    {
++      /* ADDR is not specified.  */
++      installaddr = 0;
++      ptr = addr;
++      errnum = 0;
++    }
++  else
++    ptr = skip_to (0, addr);
++
++#ifndef NO_DECOMPRESSION
++  /* Do not decompress Stage 1 or Stage 2.  */
++  no_decompression = 1;
++#endif
++
++  /* Read Stage 1.  */
++  is_open = grub_open (stage1_file);
++  if (! is_open
++      || ! grub_read (stage1_buffer, SECTOR_SIZE) == SECTOR_SIZE)
++    goto fail;
++
++  /* Read the old sector from DEST_DEV.  */
++  if (! set_device (dest_dev)
++      || ! open_partition ()
++      || ! devread (0, 0, SECTOR_SIZE, old_sect))
++    goto fail;
++
++  /* Store the information for the destination device.  */
++  dest_drive = current_drive;
++  dest_partition = current_partition;
++  dest_geom = buf_geom;
++  dest_sector = part_start;
++
++  /* Copy the possible DOS BPB, 59 bytes at byte offset 3.  */
++  grub_memmove (stage1_buffer + BOOTSEC_BPB_OFFSET,
++		old_sect + BOOTSEC_BPB_OFFSET,
++		BOOTSEC_BPB_LENGTH);
++
++  /* If for a hard disk, copy the possible MBR/extended part table.  */
++  if (dest_drive & 0x80)
++    grub_memmove (stage1_buffer + STAGE1_WINDOWS_NT_MAGIC,
++		  old_sect + STAGE1_WINDOWS_NT_MAGIC,
++		  STAGE1_PARTEND - STAGE1_WINDOWS_NT_MAGIC);
++
++  /* Check for the version and the signature of Stage 1.  */
++  if (*((short *)(stage1_buffer + STAGE1_VER_MAJ_OFFS)) != COMPAT_VERSION
++      || (*((unsigned short *) (stage1_buffer + BOOTSEC_SIG_OFFSET))
++	  != BOOTSEC_SIGNATURE))
++    {
++      errnum = ERR_BAD_VERSION;
++      goto fail;
++    }
++
++  /* This below is not true any longer. But should we leave this alone?  */
++  
++  /* If DEST_DRIVE is a floppy, Stage 2 must have the iteration probe
++     routine.  */
++  if (! (dest_drive & 0x80)
++      && (*((unsigned char *) (stage1_buffer + BOOTSEC_PART_OFFSET)) == 0x80
++	  || stage1_buffer[BOOTSEC_PART_OFFSET] == 0))
++    {
++      errnum = ERR_BAD_VERSION;
++      goto fail;
++    }
++
++  grub_close ();
++  
++  /* Open Stage 2.  */
++  is_open = grub_open (file);
++  if (! is_open)
++    goto fail;
++
++  src_drive = current_drive;
++  src_partition = current_partition;
++  src_part_start = part_start;
++  src_geom = buf_geom;
++  
++  if (! new_drive)
++    new_drive = src_drive;
++  else if (src_drive != dest_drive)
++    grub_printf ("Warning: the option `d' was not used, but the Stage 1 will"
++		 " be installed on a\ndifferent drive than the drive where"
++		 " the Stage 2 resides.\n");
++
++  /* Set the boot drive.  */
++  *((unsigned char *) (stage1_buffer + STAGE1_BOOT_DRIVE)) = new_drive;
++
++  /* Set the "force LBA" flag.  */
++  *((unsigned char *) (stage1_buffer + STAGE1_FORCE_LBA)) = is_force_lba;
++
++  /* Set the boot drive mask. This is a workaround for buggy BIOSes which
++     don't pass boot drive correctly. Instead, they pass 0x00 even when
++     booted from 0x80.  */
++  *((unsigned char *) (stage1_buffer + STAGE1_BOOT_DRIVE_MASK))
++    = (dest_drive & BIOS_FLAG_FIXED_DISK);
++  
++  /* Read the first sector of Stage 2.  */
++  disk_read_hook = disk_read_savesect_func;
++  if (grub_read (stage2_first_buffer, SECTOR_SIZE) != SECTOR_SIZE)
++    goto fail;
++
++  stage2_first_sector = saved_sector;
++  
++  /* Read the second sector of Stage 2.  */
++  if (grub_read (stage2_second_buffer, SECTOR_SIZE) != SECTOR_SIZE)
++    goto fail;
++
++  stage2_second_sector = saved_sector;
++  
++  /* Check for the version of Stage 2.  */
++  if (*((short *) (stage2_second_buffer + STAGE2_VER_MAJ_OFFS))
++      != COMPAT_VERSION)
++    {
++      errnum = ERR_BAD_VERSION;
++      goto fail;
++    }
++
++  /* Check for the Stage 2 id.  */
++  if (stage2_second_buffer[STAGE2_STAGE2_ID] != STAGE2_ID_STAGE2)
++    is_stage1_5 = 1;
++
++  /* If INSTALLADDR is not specified explicitly in the command-line,
++     determine it by the Stage 2 id.  */
++  if (! installaddr)
++    {
++      if (! is_stage1_5)
++	/* Stage 2.  */
++	installaddr = 0x8000;
++      else
++	/* Stage 1.5.  */
++	installaddr = 0x2000;
++    }
++
++  *((unsigned long *) (stage1_buffer + STAGE1_STAGE2_SECTOR))
++    = stage2_first_sector;
++  *((unsigned short *) (stage1_buffer + STAGE1_STAGE2_ADDRESS))
++    = installaddr;
++  *((unsigned short *) (stage1_buffer + STAGE1_STAGE2_SEGMENT))
++    = installaddr >> 4;
++
++  i = (int) stage2_first_buffer + SECTOR_SIZE - 4;
++  while (*((unsigned long *) i))
++    {
++      if (i < (int) stage2_first_buffer
++	  || (*((int *) (i - 4)) & 0x80000000)
++	  || *((unsigned short *) i) >= 0xA00
++	  || *((short *) (i + 2)) == 0)
++	{
++	  errnum = ERR_BAD_VERSION;
++	  goto fail;
++	}
++
++      *((int *) i) = 0;
++      *((int *) (i - 4)) = 0;
++      i -= 8;
++    }
++
++  installlist = (int) stage2_first_buffer + SECTOR_SIZE + 4;
++  installaddr += SECTOR_SIZE;
++  
++  /* Read the whole of Stage2 except for the first sector.  */
++  grub_seek (SECTOR_SIZE);
++
++  disk_read_hook = disk_read_blocklist_func;
++  if (! grub_read (dummy, -1))
++    goto fail;
++  
++  disk_read_hook = 0;
++  
++  /* Find a string for the configuration filename.  */
++  config_file_location = stage2_second_buffer + STAGE2_VER_STR_OFFS;
++  while (*(config_file_location++))
++    ;
++
++  /* Set the "force LBA" flag for Stage2.  */
++  *((unsigned char *) (stage2_second_buffer + STAGE2_FORCE_LBA))
++    = is_force_lba;
++  
++  if (*ptr == 'p')
++    {
++      *((long *) (stage2_second_buffer + STAGE2_INSTALLPART))
++	= src_partition;
++      if (is_stage1_5)
++	{
++	  /* Reset the device information in FILE if it is a Stage 1.5.  */
++	  unsigned long device = 0xFFFFFFFF;
++
++	  grub_memmove (config_file_location, (char *) &device,
++			sizeof (device));
++	}
++
++      ptr = skip_to (0, ptr);
++    }
++
++  if (*ptr)
++    {
++      grub_strcpy (config_filename, ptr);
++      nul_terminate (config_filename);
++	
++      if (! is_stage1_5)
++	/* If it is a Stage 2, just copy PTR to CONFIG_FILE_LOCATION.  */
++	grub_strcpy (config_file_location, ptr);
++      else
++	{
++	  char *real_config;
++	  unsigned long device;
++
++	  /* Translate the external device syntax to the internal device
++	     syntax.  */
++	  if (! (real_config = set_device (ptr)))
++	    {
++	      /* The Stage 2 PTR does not contain the device name, so
++		 use the root device instead.  */
++	      errnum = ERR_NONE;
++	      current_drive = saved_drive;
++	      current_partition = saved_partition;
++	      real_config = ptr;
++	    }
++	  
++	  if (current_drive == src_drive)
++	    {
++	      /* If the drive where the Stage 2 resides is the same as
++		 the one where the Stage 1.5 resides, do not embed the
++		 drive number.  */
++	      current_drive = 0xFF;
++	    }
++
++	  device = (current_drive << 24) | current_partition;
++	  grub_memmove (config_file_location, (char *) &device,
++			sizeof (device));
++	  grub_strcpy (config_file_location + sizeof (device),
++		       real_config);
++	}
++
++      /* If a Stage 1.5 is used, then we need to modify the Stage2.  */
++      if (is_stage1_5)
++	{
++	  char *real_config_filename = skip_to (0, ptr);
++	  
++	  is_open = grub_open (config_filename);
++	  if (! is_open)
++	    goto fail;
++
++	  /* Skip the first sector.  */
++	  grub_seek (SECTOR_SIZE);
++	  
++	  disk_read_hook = disk_read_savesect_func;
++	  if (grub_read (stage2_buffer, SECTOR_SIZE) != SECTOR_SIZE)
++	    goto fail;
++	  
++	  disk_read_hook = 0;
++	  grub_close ();
++	  is_open = 0;
++	  
++	  /* Sanity check.  */
++	  if (*(stage2_buffer + STAGE2_STAGE2_ID) != STAGE2_ID_STAGE2)
++	    {
++	      errnum = ERR_BAD_VERSION;
++	      goto fail;
++	    }
++
++	  /* Set the "force LBA" flag for Stage2.  */
++	  *(stage2_buffer + STAGE2_FORCE_LBA) = is_force_lba;
++
++	  /* If REAL_CONFIG_FILENAME is specified, copy it to the Stage2.  */
++	  if (*real_config_filename)
++	    {
++	      /* Specified */
++	      char *location;
++	      
++	      /* Find a string for the configuration filename.  */
++	      location = stage2_buffer + STAGE2_VER_STR_OFFS;
++	      while (*(location++))
++		;
++	      
++	      /* Copy the name.  */
++	      grub_strcpy (location, real_config_filename);
++	    }
++	  
++	  /* Write it to the disk.  */
++	  buf_track = -1;
++
++#ifdef GRUB_UTIL
++	  /* In the grub shell, access the Stage 2 via the OS filesystem
++	     service, if possible.  */
++	  if (stage2_os_file)
++	    {
++	      FILE *fp;
++
++	      fp = fopen (stage2_os_file, "r+");
++	      if (! fp)
++		{
++		  errnum = ERR_FILE_NOT_FOUND;
++		  goto fail;
++		}
++
++	      if (fseek (fp, SECTOR_SIZE, SEEK_SET) != 0)
++		{
++		  fclose (fp);
++		  errnum = ERR_BAD_VERSION;
++		  goto fail;
++		}
++
++	      if (fwrite (stage2_buffer, 1, SECTOR_SIZE, fp)
++		  != SECTOR_SIZE)
++		{
++		  fclose (fp);
++		  errnum = ERR_WRITE;
++		  goto fail;
++		}
++
++	      fclose (fp);
++	    }
++	  else
++#endif /* GRUB_UTIL */
++	    {
++	      if (! devwrite (saved_sector - part_start, 1, stage2_buffer))
++		goto fail;
++	    }
++	}
++    }
++
++  /* Clear the cache.  */
++  buf_track = -1;
++
++  /* Write the modified sectors of Stage2 to the disk.  */
++#ifdef GRUB_UTIL
++  if (! is_stage1_5 && stage2_os_file)
++    {
++      FILE *fp;
++
++      fp = fopen (stage2_os_file, "r+");
++      if (! fp)
++	{
++	  errnum = ERR_FILE_NOT_FOUND;
++	  goto fail;
++	}
++
++      if (fwrite (stage2_first_buffer, 1, SECTOR_SIZE, fp) != SECTOR_SIZE)
++	{
++	  fclose (fp);
++	  errnum = ERR_WRITE;
++	  goto fail;
++	}
++
++      if (fwrite (stage2_second_buffer, 1, SECTOR_SIZE, fp) != SECTOR_SIZE)
++	{
++	  fclose (fp);
++	  errnum = ERR_WRITE;
++	  goto fail;
++	}
++
++      fclose (fp);
++    }
++  else
++#endif /* GRUB_UTIL */
++    {
++      /* The first.  */
++      current_drive = src_drive;
++      current_partition = src_partition;
++
++      if (! open_partition ())
++	goto fail;
++
++      if (! devwrite (stage2_first_sector - src_part_start, 1,
++		      stage2_first_buffer))
++	goto fail;
++
++      if (! devwrite (stage2_second_sector - src_part_start, 1,
++		      stage2_second_buffer))
++	goto fail;
++    }
++  
++  /* Write the modified sector of Stage 1 to the disk.  */
++  current_drive = dest_drive;
++  current_partition = dest_partition;
++  if (! open_partition ())
++    goto fail;
++
++  devwrite (0, 1, stage1_buffer);
++
++ fail:
++  if (is_open)
++    grub_close ();
++  
++  disk_read_hook = 0;
++  
++#ifndef NO_DECOMPRESSION
++  no_decompression = 0;
++#endif
++
++  return errnum;
++}
++
++static struct builtin builtin_install =
++{
++  "install",
++  install_func,
++  BUILTIN_CMDLINE,
++  "install [--stage2=STAGE2_FILE] [--force-lba] STAGE1 [d] DEVICE STAGE2 [ADDR] [p] [CONFIG_FILE] [REAL_CONFIG_FILE]",
++  "Install STAGE1 on DEVICE, and install a blocklist for loading STAGE2"
++  " as a Stage 2. If the option `d' is present, the Stage 1 will always"
++  " look for the disk where STAGE2 was installed, rather than using"
++  " the booting drive. The Stage 2 will be loaded at address ADDR, which"
++  " will be determined automatically if you don't specify it. If"
++  " the option `p' or CONFIG_FILE is present, then the first block"
++  " of Stage 2 is patched with new values of the partition and name"
++  " of the configuration file used by the true Stage 2 (for a Stage 1.5,"
++  " this is the name of the true Stage 2) at boot time. If STAGE2 is a Stage"
++  " 1.5 and REAL_CONFIG_FILE is present, then the Stage 2 CONFIG_FILE is"
++  " patched with the configuration filename REAL_CONFIG_FILE."
++  " If the option `--force-lba' is specified, disable some sanity checks"
++  " for LBA mode. If the option `--stage2' is specified, rewrite the Stage"
++  " 2 via your OS's filesystem instead of the raw device."
++};
++
++
++/* ioprobe */
++static int
++ioprobe_func (char *arg, int flags)
++{
++#ifdef GRUB_UTIL
++  
++  errnum = ERR_UNRECOGNIZED;
++  return 1;
++  
++#else /* ! GRUB_UTIL */
++  
++  unsigned short *port;
++  
++  /* Get the drive number.  */
++  set_device (arg);
++  if (errnum)
++    return 1;
++
++  /* Clean out IO_MAP.  */
++  grub_memset ((char *) io_map, 0, IO_MAP_SIZE * sizeof (unsigned short));
++
++  /* Track the int13 handler.  */
++  track_int13 (current_drive);
++  
++  /* Print out the result.  */
++  for (port = io_map; *port != 0; port++)
++    grub_printf (" 0x%x", (unsigned int) *port);
++
++  return 0;
++  
++#endif /* ! GRUB_UTIL */
++}
++
++static struct builtin builtin_ioprobe =
++{
++  "ioprobe",
++  ioprobe_func,
++  BUILTIN_CMDLINE,
++  "ioprobe DRIVE",
++  "Probe I/O ports used for the drive DRIVE."
++};
++
++
++/* kernel */
++static int
++kernel_func (char *arg, int flags)
++{
++  int len;
++  kernel_t suggested_type = KERNEL_TYPE_NONE;
++  unsigned long load_flags = 0;
++
++#ifndef AUTO_LINUX_MEM_OPT
++  load_flags |= KERNEL_LOAD_NO_MEM_OPTION;
++#endif
++
++  /* Deal with GNU-style long options.  */
++  while (1)
++    {
++      /* If the option `--type=TYPE' is specified, convert the string to
++	 a kernel type.  */
++      if (grub_memcmp (arg, "--type=", 7) == 0)
++	{
++	  arg += 7;
++	  
++	  if (grub_memcmp (arg, "netbsd", 6) == 0)
++	    suggested_type = KERNEL_TYPE_NETBSD;
++	  else if (grub_memcmp (arg, "freebsd", 7) == 0)
++	    suggested_type = KERNEL_TYPE_FREEBSD;
++	  else if (grub_memcmp (arg, "openbsd", 7) == 0)
++	    /* XXX: For now, OpenBSD is identical to NetBSD, from GRUB's
++	       point of view.  */
++	    suggested_type = KERNEL_TYPE_NETBSD;
++	  else if (grub_memcmp (arg, "linux", 5) == 0)
++	    suggested_type = KERNEL_TYPE_LINUX;
++	  else if (grub_memcmp (arg, "biglinux", 8) == 0)
++	    suggested_type = KERNEL_TYPE_BIG_LINUX;
++	  else if (grub_memcmp (arg, "multiboot", 9) == 0)
++	    suggested_type = KERNEL_TYPE_MULTIBOOT;
++	  else
++	    {
++	      errnum = ERR_BAD_ARGUMENT;
++	      return 1;
++	    }
++	}
++      /* If the `--no-mem-option' is specified, don't pass a Linux's mem
++	 option automatically. If the kernel is another type, this flag
++	 has no effect.  */
++      else if (grub_memcmp (arg, "--no-mem-option", 15) == 0)
++	load_flags |= KERNEL_LOAD_NO_MEM_OPTION;
++      else
++	break;
++
++      /* Try the next.  */
++      arg = skip_to (0, arg);
++    }
++      
++  len = grub_strlen (arg);
++
++  /* Reset MB_CMDLINE.  */
++  mb_cmdline = (char *) MB_CMDLINE_BUF;
++  if (len + 1 > MB_CMDLINE_BUFLEN)
++    {
++      errnum = ERR_WONT_FIT;
++      return 1;
++    }
++
++  /* Copy the command-line to MB_CMDLINE.  */
++  grub_memmove (mb_cmdline, arg, len + 1);
++  kernel_type = load_image (arg, mb_cmdline, suggested_type, load_flags);
++  if (kernel_type == KERNEL_TYPE_NONE)
++    return 1;
++
++  mb_cmdline += len + 1;
++  return 0;
++}
++
++static struct builtin builtin_kernel =
++{
++  "kernel",
++  kernel_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "kernel [--no-mem-option] [--type=TYPE] FILE [ARG ...]",
++  "Attempt to load the primary boot image from FILE. The rest of the"
++  " line is passed verbatim as the \"kernel command line\".  Any modules"
++  " must be reloaded after using this command. The option --type is used"
++  " to suggest what type of kernel to be loaded. TYPE must be either of"
++  " \"netbsd\", \"freebsd\", \"openbsd\", \"linux\", \"biglinux\" and"
++  " \"multiboot\". The option --no-mem-option tells GRUB not to pass a"
++  " Linux's mem option automatically."
++};
++
++
++/* lock */
++static int
++lock_func (char *arg, int flags)
++{
++  if (! auth && password)
++    {
++      errnum = ERR_PRIVILEGED;
++      return 1;
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_lock =
++{
++  "lock",
++  lock_func,
++  BUILTIN_CMDLINE,
++  "lock",
++  "Break a command execution unless the user is authenticated."
++};
++  
++
++/* makeactive */
++static int
++makeactive_func (char *arg, int flags)
++{
++  if (! make_saved_active ())
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_makeactive =
++{
++  "makeactive",
++  makeactive_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "makeactive",
++  "Set the active partition on the root disk to GRUB's root device."
++  " This command is limited to _primary_ PC partitions on a hard disk."
++};
++
++
++/* map */
++/* Map FROM_DRIVE to TO_DRIVE.  */
++static int
++map_func (char *arg, int flags)
++{
++  char *to_drive;
++  char *from_drive;
++  unsigned long to, from;
++  int i;
++  
++  to_drive = arg;
++  from_drive = skip_to (0, arg);
++
++  /* Get the drive number for TO_DRIVE.  */
++  set_device (to_drive);
++  if (errnum)
++    return 1;
++  to = current_drive;
++
++  /* Get the drive number for FROM_DRIVE.  */
++  set_device (from_drive);
++  if (errnum)
++    return 1;
++  from = current_drive;
++
++  /* Search for an empty slot in BIOS_DRIVE_MAP.  */
++  for (i = 0; i < DRIVE_MAP_SIZE; i++)
++    {
++      /* Perhaps the user wants to override the map.  */
++      if ((bios_drive_map[i] & 0xff) == from)
++	break;
++      
++      if (! bios_drive_map[i])
++	break;
++    }
++
++  if (i == DRIVE_MAP_SIZE)
++    {
++      errnum = ERR_WONT_FIT;
++      return 1;
++    }
++
++  if (to == from)
++    /* If TO is equal to FROM, delete the entry.  */
++    grub_memmove ((char *) &bios_drive_map[i], (char *) &bios_drive_map[i + 1],
++		  sizeof (unsigned short) * (DRIVE_MAP_SIZE - i));
++  else
++    bios_drive_map[i] = from | (to << 8);
++  
++  return 0;
++}
++
++static struct builtin builtin_map =
++{
++  "map",
++  map_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "map TO_DRIVE FROM_DRIVE",
++  "Map the drive FROM_DRIVE to the drive TO_DRIVE. This is necessary"
++  " when you chain-load some operating systems, such as DOS, if such an"
++  " OS resides at a non-first drive."
++};
++
++
++#ifdef USE_MD5_PASSWORDS
++/* md5crypt */
++static int
++md5crypt_func (char *arg, int flags)
++{
++  char crypted[36];
++  char key[32];
++  unsigned int seed;
++  int i;
++  const char *const seedchars =
++    "./0123456789ABCDEFGHIJKLMNOPQRST"
++    "UVWXYZabcdefghijklmnopqrstuvwxyz";
++  
++  /* First create a salt.  */
++
++  /* The magical prefix.  */
++  grub_memset (crypted, 0, sizeof (crypted));
++  grub_memmove (crypted, "$1$", 3);
++
++  /* Create the length of a salt.  */
++  seed = currticks ();
++
++  /* Generate a salt.  */
++  for (i = 0; i < 8 && seed; i++)
++    {
++      /* FIXME: This should be more random.  */
++      crypted[3 + i] = seedchars[seed & 0x3f];
++      seed >>= 6;
++    }
++
++  /* A salt must be terminated with `$', if it is less than 8 chars.  */
++  crypted[3 + i] = '$';
++
++#ifdef DEBUG_MD5CRYPT
++  grub_printf ("salt = %s\n", crypted);
++#endif
++  
++  /* Get a password.  */
++  grub_memset (key, 0, sizeof (key));
++  get_cmdline ("Password: ", key, sizeof (key) - 1, '*', 0);
++
++  /* Crypt the key.  */
++  make_md5_password (key, crypted);
++
++  grub_printf ("Encrypted: %s\n", crypted);
++  return 0;
++}
++
++static struct builtin builtin_md5crypt =
++{
++  "md5crypt",
++  md5crypt_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "md5crypt",
++  "Generate a password in MD5 format."
++};
++#endif /* USE_MD5_PASSWORDS */
++
++
++/* module */
++static int
++module_func (char *arg, int flags)
++{
++  int len = grub_strlen (arg);
++
++  switch (kernel_type)
++    {
++    case KERNEL_TYPE_MULTIBOOT:
++      if (mb_cmdline + len + 1 > (char *) MB_CMDLINE_BUF + MB_CMDLINE_BUFLEN)
++	{
++	  errnum = ERR_WONT_FIT;
++	  return 1;
++	}
++      grub_memmove (mb_cmdline, arg, len + 1);
++      if (! load_module (arg, mb_cmdline))
++	return 1;
++      mb_cmdline += len + 1;
++      break;
++
++    case KERNEL_TYPE_LINUX:
++    case KERNEL_TYPE_BIG_LINUX:
++      if (! load_initrd (arg))
++	return 1;
++      break;
++
++    default:
++      errnum = ERR_NEED_MB_KERNEL;
++      return 1;
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_module =
++{
++  "module",
++  module_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "module FILE [ARG ...]",
++  "Load a boot module FILE for a Multiboot format boot image (no"
++  " interpretation of the file contents is made, so users of this"
++  " command must know what the kernel in question expects). The"
++  " rest of the line is passed as the \"module command line\", like"
++  " the `kernel' command."
++};
++
++
++/* modulenounzip */
++static int
++modulenounzip_func (char *arg, int flags)
++{
++  int ret;
++
++#ifndef NO_DECOMPRESSION
++  no_decompression = 1;
++#endif
++
++  ret = module_func (arg, flags);
++
++#ifndef NO_DECOMPRESSION
++  no_decompression = 0;
++#endif
++
++  return ret;
++}
++
++static struct builtin builtin_modulenounzip =
++{
++  "modulenounzip",
++  modulenounzip_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "modulenounzip FILE [ARG ...]",
++  "The same as `module', except that automatic decompression is"
++  " disabled."
++};
++
++
++/* pager [on|off] */
++static int
++pager_func (char *arg, int flags)
++{
++  /* If ARG is empty, toggle the flag.  */
++  if (! *arg)
++    use_pager = ! use_pager;
++  else if (grub_memcmp (arg, "on", 2) == 0)
++    use_pager = 1;
++  else if (grub_memcmp (arg, "off", 3) == 0)
++    use_pager = 0;
++  else
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  grub_printf (" Internal pager is now %s\n", use_pager ? "on" : "off");
++  return 0;
++}
++
++static struct builtin builtin_pager =
++{
++  "pager",
++  pager_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "pager [FLAG]",
++  "Toggle pager mode with no argument. If FLAG is given and its value"
++  " is `on', turn on the mode. If FLAG is `off', turn off the mode."
++};
++
++
++/* partnew PART TYPE START LEN */
++static int
++partnew_func (char *arg, int flags)
++{
++  int new_type, new_start, new_len;
++  int start_cl, start_ch, start_dh;
++  int end_cl, end_ch, end_dh;
++  int entry;
++  char mbr[512];
++
++  /* Convert a LBA address to a CHS address in the INT 13 format.  */
++  auto void lba_to_chs (int lba, int *cl, int *ch, int *dh);
++  void lba_to_chs (int lba, int *cl, int *ch, int *dh)
++    {
++      int cylinder, head, sector;
++
++      sector = lba % buf_geom.sectors + 1;
++      head = (lba / buf_geom.sectors) % buf_geom.heads;
++      cylinder = lba / (buf_geom.sectors * buf_geom.heads);
++
++      if (cylinder >= buf_geom.cylinders)
++	cylinder = buf_geom.cylinders - 1;
++      
++      *cl = sector | ((cylinder & 0x300) >> 2);
++      *ch = cylinder & 0xFF;
++      *dh = head;
++    }
++      
++  /* Get the drive and the partition.  */
++  if (! set_device (arg))
++    return 1;
++
++  /* The drive must be a hard disk.  */
++  if (! (current_drive & 0x80))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  /* The partition must a primary partition.  */
++  if ((current_partition >> 16) > 3
++      || (current_partition & 0xFFFF) != 0xFFFF)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  entry = current_partition >> 16;
++  
++  /* Get the new partition type.  */
++  arg = skip_to (0, arg);
++  if (! safe_parse_maxint (&arg, &new_type))
++    return 1;
++
++  /* The partition type is unsigned char.  */
++  if (new_type > 0xFF)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  /* Get the new partition start.  */
++  arg = skip_to (0, arg);
++  if (! safe_parse_maxint (&arg, &new_start))
++    return 1;
++  
++  /* Get the new partition length.  */
++  arg = skip_to (0, arg);
++  if (! safe_parse_maxint (&arg, &new_len))
++    return 1;
++
++  /* Read the MBR.  */
++  if (! rawread (current_drive, 0, 0, SECTOR_SIZE, mbr))
++    return 1;
++
++  /* Check if the new partition will fit in the disk.  */
++  if (new_start + new_len > buf_geom.total_sectors)
++    {
++      errnum = ERR_GEOM;
++      return 1;
++    }
++
++  /* Store the partition information in the MBR.  */
++  lba_to_chs (new_start, &start_cl, &start_ch, &start_dh);
++  lba_to_chs (new_start + new_len - 1, &end_cl, &end_ch, &end_dh);
++
++  PC_SLICE_FLAG (mbr, entry) = 0;
++  PC_SLICE_HEAD (mbr, entry) = start_dh;
++  PC_SLICE_SEC (mbr, entry) = start_cl;
++  PC_SLICE_CYL (mbr, entry) = start_ch;
++  PC_SLICE_TYPE (mbr, entry) = new_type;
++  PC_SLICE_EHEAD (mbr, entry) = end_dh;
++  PC_SLICE_ESEC (mbr, entry) = end_cl;
++  PC_SLICE_ECYL (mbr, entry) = end_ch;
++  PC_SLICE_START (mbr, entry) = new_start;
++  PC_SLICE_LENGTH (mbr, entry) = new_len;
++
++  /* Make sure that the MBR has a valid signature.  */
++  PC_MBR_SIG (mbr) = PC_MBR_SIGNATURE;
++  
++  /* Write back the MBR to the disk.  */
++  buf_track = -1;
++  if (! rawwrite (current_drive, 0, mbr))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_partnew =
++{
++  "partnew",
++  partnew_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "partnew PART TYPE START LEN",
++  "Create a primary partition at the starting address START with the"
++  " length LEN, with the type TYPE. START and LEN are in sector units."
++};
++
++
++/* parttype PART TYPE */
++static int
++parttype_func (char *arg, int flags)
++{
++  int new_type;
++  unsigned long part = 0xFFFFFF;
++  unsigned long start, len, offset, ext_offset;
++  int entry, type;
++  char mbr[512];
++
++  /* Get the drive and the partition.  */
++  if (! set_device (arg))
++    return 1;
++
++  /* The drive must be a hard disk.  */
++  if (! (current_drive & 0x80))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  /* The partition must be a PC slice.  */
++  if ((current_partition >> 16) == 0xFF
++      || (current_partition & 0xFFFF) != 0xFFFF)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  /* Get the new partition type.  */
++  arg = skip_to (0, arg);
++  if (! safe_parse_maxint (&arg, &new_type))
++    return 1;
++
++  /* The partition type is unsigned char.  */
++  if (new_type > 0xFF)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  /* Look for the partition.  */
++  while (next_partition (current_drive, 0xFFFFFF, &part, &type,
++			 &start, &len, &offset, &entry,
++			 &ext_offset, mbr))
++    {
++      if (part == current_partition)
++	{
++	  /* Found.  */
++
++	  /* Set the type to NEW_TYPE.  */
++	  PC_SLICE_TYPE (mbr, entry) = new_type;
++	  
++	  /* Write back the MBR to the disk.  */
++	  buf_track = -1;
++	  if (! rawwrite (current_drive, offset, mbr))
++	    return 1;
++
++	  /* Succeed.  */
++	  return 0;
++	}
++    }
++
++  /* The partition was not found.  ERRNUM was set by next_partition.  */
++  return 1;
++}
++
++static struct builtin builtin_parttype =
++{
++  "parttype",
++  parttype_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "parttype PART TYPE",
++  "Change the type of the partition PART to TYPE."
++};
++
++
++/* password */
++static int
++password_func (char *arg, int flags)
++{
++  int len;
++  password_t type = PASSWORD_PLAIN;
++
++#ifdef USE_MD5_PASSWORDS
++  if (grub_memcmp (arg, "--md5", 5) == 0)
++    {
++      type = PASSWORD_MD5;
++      arg = skip_to (0, arg);
++    }
++#endif
++  if (grub_memcmp (arg, "--", 2) == 0)
++    {
++      type = PASSWORD_UNSUPPORTED;
++      arg = skip_to (0, arg);
++    }
++
++  if ((flags & (BUILTIN_CMDLINE | BUILTIN_SCRIPT)) != 0)
++    {
++      /* Do password check! */
++      char entered[32];
++      
++      /* Wipe out any previously entered password */
++      entered[0] = 0;
++      get_cmdline ("Password: ", entered, 31, '*', 0);
++
++      nul_terminate (arg);
++      if (check_password (entered, arg, type) != 0)
++	{
++	  errnum = ERR_PRIVILEGED;
++	  return 1;
++	}
++    }
++  else
++    {
++      len = grub_strlen (arg);
++      
++      /* PASSWORD NUL NUL ... */
++      if (len + 2 > PASSWORD_BUFLEN)
++	{
++	  errnum = ERR_WONT_FIT;
++	  return 1;
++	}
++      
++      /* Copy the password and clear the rest of the buffer.  */
++      password = (char *) PASSWORD_BUF;
++      grub_memmove (password, arg, len);
++      grub_memset (password + len, 0, PASSWORD_BUFLEN - len);
++      password_type = type;
++    }
++  return 0;
++}
++
++static struct builtin builtin_password =
++{
++  "password",
++  password_func,
++  BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_NO_ECHO,
++  "password [--md5] PASSWD [FILE]",
++  "If used in the first section of a menu file, disable all"
++  " interactive editing control (menu entry editor and"
++  " command line). If the password PASSWD is entered, it loads the"
++  " FILE as a new config file and restarts the GRUB Stage 2. If you"
++  " omit the argument FILE, then GRUB just unlocks privileged"
++  " instructions.  You can also use it in the script section, in"
++  " which case it will ask for the password, before continueing."
++  " The option --md5 tells GRUB that PASSWD is encrypted with"
++  " md5crypt."
++};
++
++
++/* pause */
++static int
++pause_func (char *arg, int flags)
++{
++  printf("%s\n", arg);
++
++  /* If ESC is returned, then abort this entry.  */
++  if (ASCII_CHAR (getkey ()) == 27)
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_pause =
++{
++  "pause",
++  pause_func,
++  BUILTIN_CMDLINE | BUILTIN_NO_ECHO,
++  "pause [MESSAGE ...]",
++  "Print MESSAGE, then wait until a key is pressed."
++};
++
++
++#ifdef GRUB_UTIL
++/* quit */
++static int
++quit_func (char *arg, int flags)
++{
++  stop ();
++  
++  /* Never reach here.  */
++  return 0;
++}
++
++static struct builtin builtin_quit =
++{
++  "quit",
++  quit_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "quit",
++  "Exit from the GRUB shell."
++};
++#endif /* GRUB_UTIL */
++
++
++#ifdef SUPPORT_NETBOOT
++/* rarp */
++static int
++rarp_func (char *arg, int flags)
++{
++  if (! rarp ())
++    {
++      if (errnum == ERR_NONE)
++	errnum = ERR_DEV_VALUES;
++
++      return 1;
++    }
++
++  /* Notify the configuration.  */
++  print_network_configuration ();
++  return 0;
++}
++
++static struct builtin builtin_rarp =
++{
++  "rarp",
++  rarp_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "rarp",
++  "Initialize a network device via RARP."
++};
++#endif /* SUPPORT_NETBOOT */
++
++
++static int
++read_func (char *arg, int flags)
++{
++  int addr;
++
++  if (! safe_parse_maxint (&arg, &addr))
++    return 1;
++
++  grub_printf ("Address 0x%x: Value 0x%x\n",
++	       addr, *((unsigned *) RAW_ADDR (addr)));
++  return 0;
++}
++
++static struct builtin builtin_read =
++{
++  "read",
++  read_func,
++  BUILTIN_CMDLINE,
++  "read ADDR",
++  "Read a 32-bit value from memory at address ADDR and"
++  " display it in hex format."
++};
++
++
++/* reboot */
++static int
++reboot_func (char *arg, int flags)
++{
++  grub_reboot ();
++
++  /* Never reach here.  */
++  return 1;
++}
++
++static struct builtin builtin_reboot =
++{
++  "reboot",
++  reboot_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "reboot",
++  "Reboot your system."
++};
++
++
++/* Print the root device information.  */
++static void
++print_root_device (void)
++{
++  if (saved_drive == NETWORK_DRIVE)
++    {
++      /* Network drive.  */
++      grub_printf (" (nd):");
++    }
++  else if (saved_drive & 0x80)
++    {
++      /* Hard disk drive.  */
++      grub_printf (" (hd%d", saved_drive - 0x80);
++      
++      if ((saved_partition & 0xFF0000) != 0xFF0000)
++	grub_printf (",%d", saved_partition >> 16);
++
++      if ((saved_partition & 0x00FF00) != 0x00FF00)
++	grub_printf (",%c", ((saved_partition >> 8) & 0xFF) + 'a');
++
++      grub_printf ("):");
++    }
++  else
++    {
++      /* Floppy disk drive.  */
++      grub_printf (" (fd%d):", saved_drive);
++    }
++
++  /* Print the filesystem information.  */
++  current_partition = saved_partition;
++  current_drive = saved_drive;
++  print_fsys_type ();
++}
++
++static int
++real_root_func (char *arg, int attempt_mount)
++{
++  int hdbias = 0;
++  char *biasptr;
++  char *next;
++
++  /* If ARG is empty, just print the current root device.  */
++  if (! *arg)
++    {
++      print_root_device ();
++      return 0;
++    }
++  
++  /* Call set_device to get the drive and the partition in ARG.  */
++  next = set_device (arg);
++  if (! next)
++    return 1;
++
++  /* Ignore ERR_FSYS_MOUNT.  */
++  if (attempt_mount)
++    {
++      if (! open_device () && errnum != ERR_FSYS_MOUNT)
++	return 1;
++    }
++  else
++    {
++      /* This is necessary, because the location of a partition table
++	 must be set appropriately.  */
++      if (open_partition ())
++	{
++	  set_bootdev (0);
++	  if (errnum)
++	    return 1;
++	}
++    }
++  
++  /* Clear ERRNUM.  */
++  errnum = 0;
++  saved_partition = current_partition;
++  saved_drive = current_drive;
++
++  if (attempt_mount)
++    {
++      /* BSD and chainloading evil hacks !!  */
++      biasptr = skip_to (0, next);
++      safe_parse_maxint (&biasptr, &hdbias);
++      errnum = 0;
++      bootdev = set_bootdev (hdbias);
++      if (errnum)
++	return 1;
++      
++      /* Print the type of the filesystem.  */
++      print_fsys_type ();
++    }
++  
++  return 0;
++}
++
++static int
++root_func (char *arg, int flags)
++{
++  return real_root_func (arg, 1);
++}
++
++static struct builtin builtin_root =
++{
++  "root",
++  root_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "root [DEVICE [HDBIAS]]",
++  "Set the current \"root device\" to the device DEVICE, then"
++  " attempt to mount it to get the partition size (for passing the"
++  " partition descriptor in `ES:ESI', used by some chain-loaded"
++  " bootloaders), the BSD drive-type (for booting BSD kernels using"
++  " their native boot format), and correctly determine "
++  " the PC partition where a BSD sub-partition is located. The"
++  " optional HDBIAS parameter is a number to tell a BSD kernel"
++  " how many BIOS drive numbers are on controllers before the current"
++  " one. For example, if there is an IDE disk and a SCSI disk, and your"
++  " FreeBSD root partition is on the SCSI disk, then use a `1' for HDBIAS."
++};
++
++
++/* rootnoverify */
++static int
++rootnoverify_func (char *arg, int flags)
++{
++  return real_root_func (arg, 0);
++}
++
++static struct builtin builtin_rootnoverify =
++{
++  "rootnoverify",
++  rootnoverify_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "rootnoverify [DEVICE [HDBIAS]]",
++  "Similar to `root', but don't attempt to mount the partition. This"
++  " is useful for when an OS is outside of the area of the disk that"
++  " GRUB can read, but setting the correct root device is still"
++  " desired. Note that the items mentioned in `root' which"
++  " derived from attempting the mount will NOT work correctly."
++};
++
++
++/* savedefault */
++static int
++savedefault_func (char *arg, int flags)
++{
++#if !defined(SUPPORT_DISKLESS) && !defined(GRUB_UTIL)
++  char buffer[512];
++  int *entryno_ptr;
++  
++  /* This command is only useful when you boot an entry from the menu
++     interface.  */
++  if (! (flags & BUILTIN_SCRIPT))
++    {
++      errnum = ERR_UNRECOGNIZED;
++      return 1;
++    }
++  
++  /* Get the geometry of the boot drive (i.e. the disk which contains
++     this stage2).  */
++  if (get_diskinfo (boot_drive, &buf_geom))
++    {
++      errnum = ERR_NO_DISK;
++      return 1;
++    }
++
++  /* Load the second sector of this stage2.  */
++  if (! rawread (boot_drive, install_second_sector, 0, SECTOR_SIZE, buffer))
++    {
++      return 1;
++    }
++
++  /* Sanity check.  */
++  if (buffer[STAGE2_STAGE2_ID] != STAGE2_ID_STAGE2
++      || *((short *) (buffer + STAGE2_VER_MAJ_OFFS)) != COMPAT_VERSION)
++    {
++      errnum = ERR_BAD_VERSION;
++      return 1;
++    }
++  
++  entryno_ptr = (int *) (buffer + STAGE2_SAVED_ENTRYNO);
++
++  /* Check if the saved entry number differs from current entry number.  */
++  if (*entryno_ptr != current_entryno)
++    {
++      /* Overwrite the saved entry number.  */
++      *entryno_ptr = current_entryno;
++      
++      /* Save the image in the disk.  */
++      if (! rawwrite (boot_drive, install_second_sector, buffer))
++	return 1;
++      
++      /* Clear the cache.  */
++      buf_track = -1;
++    }
++
++  return 0;
++#else /* ! SUPPORT_DISKLESS && ! GRUB_UTIL */
++  errnum = ERR_UNRECOGNIZED;
++  return 1;
++#endif /* ! SUPPORT_DISKLESS && ! GRUB_UTIL */
++}
++
++static struct builtin builtin_savedefault =
++{
++  "savedefault",
++  savedefault_func,
++  BUILTIN_CMDLINE,
++  "savedefault",
++  "Save the current entry as the default boot entry."
++};
++
++
++#ifdef SUPPORT_SERIAL
++/* serial */
++static int
++serial_func (char *arg, int flags)
++{
++  unsigned short port = serial_hw_get_port (0);
++  unsigned int speed = 9600;
++  int word_len = UART_8BITS_WORD;
++  int parity = UART_NO_PARITY;
++  int stop_bit_len = UART_1_STOP_BIT;
++
++  /* Process GNU-style long options.
++     FIXME: We should implement a getopt-like function, to avoid
++     duplications.  */
++  while (1)
++    {
++      if (grub_memcmp (arg, "--unit=", sizeof ("--unit=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--unit=") - 1;
++	  int unit;
++	  
++	  if (! safe_parse_maxint (&p, &unit))
++	    return 1;
++	  
++	  if (unit < 0 || unit > 3)
++	    {
++	      errnum = ERR_DEV_VALUES;
++	      return 1;
++	    }
++
++	  port = serial_hw_get_port (unit);
++	}
++      else if (grub_memcmp (arg, "--speed=", sizeof ("--speed=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--speed=") - 1;
++	  int num;
++	  
++	  if (! safe_parse_maxint (&p, &num))
++	    return 1;
++
++	  speed = (unsigned int) num;
++	}
++      else if (grub_memcmp (arg, "--port=", sizeof ("--port=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--port=") - 1;
++	  int num;
++	  
++	  if (! safe_parse_maxint (&p, &num))
++	    return 1;
++
++	  port = (unsigned short) num;
++	}
++      else if (grub_memcmp (arg, "--word=", sizeof ("--word=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--word=") - 1;
++	  int len;
++	  
++	  if (! safe_parse_maxint (&p, &len))
++	    return 1;
++
++	  switch (len)
++	    {
++	    case 5: word_len = UART_5BITS_WORD; break;
++	    case 6: word_len = UART_6BITS_WORD; break;
++	    case 7: word_len = UART_7BITS_WORD; break;
++	    case 8: word_len = UART_8BITS_WORD; break;
++	    default:
++	      errnum = ERR_BAD_ARGUMENT;
++	      return 1;
++	    }
++	}
++      else if (grub_memcmp (arg, "--stop=", sizeof ("--stop=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--stop=") - 1;
++	  int len;
++	  
++	  if (! safe_parse_maxint (&p, &len))
++	    return 1;
++
++	  switch (len)
++	    {
++	    case 1: stop_bit_len = UART_1_STOP_BIT; break;
++	    case 2: stop_bit_len = UART_2_STOP_BITS; break;
++	    default:
++	      errnum = ERR_BAD_ARGUMENT;
++	      return 1;
++	    }
++	}
++      else if (grub_memcmp (arg, "--parity=", sizeof ("--parity=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--parity=") - 1;
++
++	  if (grub_memcmp (p, "no", sizeof ("no") - 1) == 0)
++	    parity = UART_NO_PARITY;
++	  else if (grub_memcmp (p, "odd", sizeof ("odd") - 1) == 0)
++	    parity = UART_ODD_PARITY;
++	  else if (grub_memcmp (p, "even", sizeof ("even") - 1) == 0)
++	    parity = UART_EVEN_PARITY;
++	  else
++	    {
++	      errnum = ERR_BAD_ARGUMENT;
++	      return 1;
++	    }
++	}
++# ifdef GRUB_UTIL
++      /* In the grub shell, don't use any port number but open a tty
++	 device instead.  */
++      else if (grub_memcmp (arg, "--device=", sizeof ("--device=") - 1) == 0)
++	{
++	  char *p = arg + sizeof ("--device=") - 1;
++	  char dev[256];	/* XXX */
++	  char *q = dev;
++	  
++	  while (*p && ! grub_isspace (*p))
++	    *q++ = *p++;
++	  
++	  *q = 0;
++	  serial_set_device (dev);
++	}
++# endif /* GRUB_UTIL */
++      else
++	break;
++
++      arg = skip_to (0, arg);
++    }
++
++  /* Initialize the serial unit.  */
++  if (! serial_hw_init (port, speed, word_len, parity, stop_bit_len))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  return 0;
++}
++
++static struct builtin builtin_serial =
++{
++  "serial",
++  serial_func,
++  BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "serial [--unit=UNIT] [--port=PORT] [--speed=SPEED] [--word=WORD] [--parity=PARITY] [--stop=STOP] [--device=DEV]",
++  "Initialize a serial device. UNIT is a digit that specifies which serial"
++  " device is used (e.g. 0 == COM1). If you need to specify the port number,"
++  " set it by --port. SPEED is the DTE-DTE speed. WORD is the word length,"
++  " PARITY is the type of parity, which is one of `no', `odd' and `even'."
++  " STOP is the length of stop bit(s). The option --device can be used only"
++  " in the grub shell, which specifies the file name of a tty device. The"
++  " default values are COM1, 9600, 8N1."
++};
++#endif /* SUPPORT_SERIAL */
++
++
++/* setkey */
++struct keysym
++{
++  char *unshifted_name;			/* the name in unshifted state */
++  char *shifted_name;			/* the name in shifted state */
++  unsigned char unshifted_ascii;	/* the ascii code in unshifted state */
++  unsigned char shifted_ascii;		/* the ascii code in shifted state */
++  unsigned char keycode;		/* keyboard scancode */
++};
++
++/* The table for key symbols. If the "shifted" member of an entry is
++   NULL, the entry does not have shifted state.  */
++static struct keysym keysym_table[] =
++{
++  {"escape",		0,		0x1b,	0,	0x01},
++  {"1",			"exclam",	'1',	'!',	0x02},
++  {"2",			"at",		'2',	'@',	0x03},
++  {"3",			"numbersign",	'3',	'#',	0x04},
++  {"4",			"dollar",	'4',	'$',	0x05},
++  {"5",			"percent",	'5',	'%',	0x06},
++  {"6",			"caret",	'6',	'^',	0x07},
++  {"7",			"ampersand",	'7',	'&',	0x08},
++  {"8",			"asterisk",	'8',	'*',	0x09},
++  {"9",			"parenleft",	'9',	'(',	0x0a},
++  {"0",			"parenright",	'0',	')',	0x0b},
++  {"minus",		"underscore",	'-',	'_',	0x0c},
++  {"equal",		"plus",		'=',	'+',	0x0d},
++  {"backspace",		0,		'\b',	0,	0x0e},
++  {"tab",		0,		'\t',	0,	0x0f},
++  {"q",			"Q",		'q',	'Q',	0x10},
++  {"w",			"W",		'w',	'W',	0x11},
++  {"e",			"E",		'e',	'E',	0x12},
++  {"r",			"R",		'r',	'R',	0x13},
++  {"t",			"T",		't',	'T',	0x14},
++  {"y",			"Y",		'y',	'Y',	0x15},
++  {"u",			"U",		'u',	'U',	0x16},
++  {"i",			"I",		'i',	'I',	0x17},
++  {"o",			"O",		'o',	'O',	0x18},
++  {"p",			"P",		'p',	'P',	0x19},
++  {"bracketleft",	"braceleft",	'[',	'{',	0x1a},
++  {"bracketright",	"braceright",	']',	'}',	0x1b},
++  {"enter",		0,		'\n',	0,	0x1c},
++  {"control",		0,		0,	0,	0x1d},
++  {"a",			"A",		'a',	'A',	0x1e},
++  {"s",			"S",		's',	'S',	0x1f},
++  {"d",			"D",		'd',	'D',	0x20},
++  {"f",			"F",		'f',	'F',	0x21},
++  {"g",			"G",		'g',	'G',	0x22},
++  {"h",			"H",		'h',	'H',	0x23},
++  {"j",			"J",		'j',	'J',	0x24},
++  {"k",			"K",		'k',	'K',	0x25},
++  {"l",			"L",		'l',	'L',	0x26},
++  {"semicolon",		"colon",	';',	':',	0x27},
++  {"quote",		"doublequote",	'\'',	'"',	0x28},
++  {"backquote",		"tilde",	'`',	'~',	0x29},
++  {"shift",		0,		0,	0,	0x2a},
++  {"backslash",		"bar",		'\\',	'|',	0x2b},
++  {"z",			"Z",		'z',	'Z',	0x2c},
++  {"x",			"X",		'x',	'X',	0x2d},
++  {"c",			"C",		'c',	'C',	0x2e},
++  {"v",			"V",		'v',	'V',	0x2f},
++  {"b",			"B",		'b',	'B',	0x30},
++  {"n",			"N",		'n',	'N',	0x31},
++  {"m",			"M",		'm',	'M',	0x32},
++  {"comma",		"less",		',',	'<',	0x33},
++  {"period",		"greater",	'.',	'>',	0x34},
++  {"slash",		"question",	'/',	'?',	0x35},
++  {"alt",		0,		0,	0,	0x38},
++  {"space",		0,		' ',	0,	0x39},
++  {"capslock",		0,		0,	0,	0x3a},
++  {"F1",		0,		0,	0,	0x3b},
++  {"F2",		0,		0,	0,	0x3c},
++  {"F3",		0,		0,	0,	0x3d},
++  {"F4",		0,		0,	0,	0x3e},
++  {"F5",		0,		0,	0,	0x3f},
++  {"F6",		0,		0,	0,	0x40},
++  {"F7",		0,		0,	0,	0x41},
++  {"F8",		0,		0,	0,	0x42},
++  {"F9",		0,		0,	0,	0x43},
++  {"F10",		0,		0,	0,	0x44},
++  /* Caution: do not add NumLock here! we cannot deal with it properly.  */
++  {"delete",		0,		0x7f,	0,	0x53}
++};
++
++static int
++setkey_func (char *arg, int flags)
++{
++  char *to_key, *from_key;
++  int to_code, from_code;
++  int map_in_interrupt = 0;
++  
++  static int find_key_code (char *key)
++    {
++      int i;
++
++      for (i = 0; i < sizeof (keysym_table) / sizeof (keysym_table[0]); i++)
++	{
++	  if (keysym_table[i].unshifted_name &&
++	      grub_strcmp (key, keysym_table[i].unshifted_name) == 0)
++	    return keysym_table[i].keycode;
++	  else if (keysym_table[i].shifted_name &&
++		   grub_strcmp (key, keysym_table[i].shifted_name) == 0)
++	    return keysym_table[i].keycode;
++	}
++      
++      return 0;
++    }
++  
++  static int find_ascii_code (char *key)
++    {
++      int i;
++      
++      for (i = 0; i < sizeof (keysym_table) / sizeof (keysym_table[0]); i++)
++	{
++	  if (keysym_table[i].unshifted_name &&
++	      grub_strcmp (key, keysym_table[i].unshifted_name) == 0)
++	    return keysym_table[i].unshifted_ascii;
++	  else if (keysym_table[i].shifted_name &&
++		   grub_strcmp (key, keysym_table[i].shifted_name) == 0)
++	    return keysym_table[i].shifted_ascii;
++	}
++      
++      return 0;
++    }
++  
++  to_key = arg;
++  from_key = skip_to (0, to_key);
++
++  if (! *to_key)
++    {
++      /* If the user specifies no argument, reset the key mappings.  */
++      grub_memset (bios_key_map, 0, KEY_MAP_SIZE * sizeof (unsigned short));
++      grub_memset (ascii_key_map, 0, KEY_MAP_SIZE * sizeof (unsigned short));
++
++      return 0;
++    }
++  else if (! *from_key)
++    {
++      /* The user must specify two arguments or zero argument.  */
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  nul_terminate (to_key);
++  nul_terminate (from_key);
++  
++  to_code = find_ascii_code (to_key);
++  from_code = find_ascii_code (from_key);
++  if (! to_code || ! from_code)
++    {
++      map_in_interrupt = 1;
++      to_code = find_key_code (to_key);
++      from_code = find_key_code (from_key);
++      if (! to_code || ! from_code)
++	{
++	  errnum = ERR_BAD_ARGUMENT;
++	  return 1;
++	}
++    }
++  
++  if (map_in_interrupt)
++    {
++      int i;
++      
++      /* Find an empty slot.  */
++      for (i = 0; i < KEY_MAP_SIZE; i++)
++	{
++	  if ((bios_key_map[i] & 0xff) == from_code)
++	    /* Perhaps the user wants to overwrite the map.  */
++	    break;
++	  
++	  if (! bios_key_map[i])
++	    break;
++	}
++      
++      if (i == KEY_MAP_SIZE)
++	{
++	  errnum = ERR_WONT_FIT;
++	  return 1;
++	}
++      
++      if (to_code == from_code)
++	/* If TO is equal to FROM, delete the entry.  */
++	grub_memmove ((char *) &bios_key_map[i],
++		      (char *) &bios_key_map[i + 1],
++		      sizeof (unsigned short) * (KEY_MAP_SIZE - i));
++      else
++	bios_key_map[i] = (to_code << 8) | from_code;
++      
++      /* Ugly but should work.  */
++      unset_int15_handler ();
++      set_int15_handler ();
++    }
++  else
++    {
++      int i;
++      
++      /* Find an empty slot.  */
++      for (i = 0; i < KEY_MAP_SIZE; i++)
++	{
++	  if ((ascii_key_map[i] & 0xff) == from_code)
++	    /* Perhaps the user wants to overwrite the map.  */
++	    break;
++	  
++	  if (! ascii_key_map[i])
++	    break;
++	}
++      
++      if (i == KEY_MAP_SIZE)
++	{
++	  errnum = ERR_WONT_FIT;
++	  return 1;
++	}
++      
++      if (to_code == from_code)
++	/* If TO is equal to FROM, delete the entry.  */
++	grub_memmove ((char *) &ascii_key_map[i],
++		      (char *) &ascii_key_map[i + 1],
++		      sizeof (unsigned short) * (KEY_MAP_SIZE - i));
++      else
++	ascii_key_map[i] = (to_code << 8) | from_code;
++    }
++      
++  return 0;
++}
++
++static struct builtin builtin_setkey =
++{
++  "setkey",
++  setkey_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "setkey [TO_KEY FROM_KEY]",
++  "Change the keyboard map. The key FROM_KEY is mapped to the key TO_KEY."
++  " A key must be an alphabet, a digit, or one of these: escape, exclam,"
++  " at, numbersign, dollar, percent, caret, ampersand, asterisk, parenleft,"
++  " parenright, minus, underscore, equal, plus, backspace, tab, bracketleft,"
++  " braceleft, bracketright, braceright, enter, control, semicolon, colon,"
++  " quote, doublequote, backquote, tilde, shift, backslash, bar, comma,"
++  " less, period, greater, slash, question, alt, space, capslock, FX (X"
++  " is a digit), and delete. If no argument is specified, reset key"
++  " mappings."
++};
++
++
++/* setup */
++static int
++setup_func (char *arg, int flags)
++{
++  /* Point to the string of the installed drive/partition.  */
++  char *install_ptr;
++  /* Point to the string of the drive/parition where the GRUB images
++     reside.  */
++  char *image_ptr;
++  unsigned long installed_drive, installed_partition;
++  unsigned long image_drive, image_partition;
++  unsigned long tmp_drive, tmp_partition;
++  char stage1[64];
++  char stage2[64];
++  char config_filename[64];
++  char real_config_filename[64];
++  char cmd_arg[256];
++  char device[16];
++  char *buffer = (char *) RAW_ADDR (0x100000);
++  int is_force_lba = 0;
++  char *stage2_arg = 0;
++  char *prefix = 0;
++
++  auto int check_file (char *file);
++  auto void sprint_device (int drive, int partition);
++  auto int embed_stage1_5 (char * stage1_5, int drive, int partition);
++  
++  /* Check if the file FILE exists like Autoconf.  */
++  int check_file (char *file)
++    {
++      int ret;
++      
++      grub_printf (" Checking if \"%s\" exists... ", file);
++      ret = grub_open (file);
++      if (ret)
++	{
++	  grub_close ();
++	  grub_printf ("yes\n");
++	}
++      else
++	grub_printf ("no\n");
++
++      return ret;
++    }
++  
++  /* Construct a device name in DEVICE.  */
++  void sprint_device (int drive, int partition)
++    {
++      grub_sprintf (device, "(%cd%d",
++		    (drive & 0x80) ? 'h' : 'f',
++		    drive & ~0x80);
++      if ((partition & 0xFF0000) != 0xFF0000)
++	{
++	  char tmp[16];
++	  grub_sprintf (tmp, ",%d", (partition >> 16) & 0xFF);
++	  grub_strncat (device, tmp, 256);
++	}
++      if ((partition & 0x00FF00) != 0x00FF00)
++	{
++	  char tmp[16];
++	  grub_sprintf (tmp, ",%c", 'a' + ((partition >> 8) & 0xFF));
++	  grub_strncat (device, tmp, 256);
++	}
++      grub_strncat (device, ")", 256);
++    }
++  
++  int embed_stage1_5 (char *stage1_5, int drive, int partition)
++    {
++      /* We install GRUB into the MBR, so try to embed the
++	 Stage 1.5 in the sectors right after the MBR.  */
++      sprint_device (drive, partition);
++      grub_sprintf (cmd_arg, "%s %s", stage1_5, device);
++	      
++      /* Notify what will be run.  */
++      grub_printf (" Running \"embed %s\"... ", cmd_arg);
++      
++      embed_func (cmd_arg, flags);
++      if (! errnum)
++	{
++	  /* Construct the blocklist representation.  */
++	  grub_sprintf (buffer, "%s%s", device, embed_info);
++	  grub_printf ("succeeded\n");
++	  return 1;
++	}
++      else
++	{
++	  grub_printf ("failed (this is not fatal)\n");
++	  return 0;
++	}
++    }
++	  
++  struct stage1_5_map {
++    char *fsys;
++    char *name;
++  };
++  struct stage1_5_map stage1_5_map[] =
++  {
++    {"ext2fs",   "/e2fs_stage1_5"},
++    {"fat",      "/fat_stage1_5"},
++    {"ffs",      "/ffs_stage1_5"},
++    {"jfs",      "/jfs_stage1_5"},
++    {"minix",    "/minix_stage1_5"},
++    {"reiserfs", "/reiserfs_stage1_5"},
++    {"vstafs",   "/vstafs_stage1_5"},
++    {"xfs",      "/xfs_stage1_5"}
++  };
++
++  tmp_drive = saved_drive;
++  tmp_partition = saved_partition;
++
++  /* Check if the user specifies --force-lba.  */
++  while (1)
++    {
++      if (grub_memcmp ("--force-lba", arg, sizeof ("--force-lba") - 1) == 0)
++	{
++	  is_force_lba = 1;
++	  arg = skip_to (0, arg);
++	}
++      else if (grub_memcmp ("--prefix=", arg, sizeof ("--prefix=") - 1) == 0)
++	{
++	  prefix = arg + sizeof ("--prefix=") - 1;
++	  arg = skip_to (0, arg);
++	  nul_terminate (prefix);
++	}
++#ifdef GRUB_UTIL
++      else if (grub_memcmp ("--stage2=", arg, sizeof ("--stage2=") - 1) == 0)
++	{
++	  stage2_arg = arg;
++	  arg = skip_to (0, arg);
++	  nul_terminate (stage2_arg);
++	}
++#endif /* GRUB_UTIL */
++      else
++	break;
++    }
++  
++  install_ptr = arg;
++  image_ptr = skip_to (0, install_ptr);
++
++  /* Make sure that INSTALL_PTR is valid.  */
++  set_device (install_ptr);
++  if (errnum)
++    return 1;
++
++  installed_drive = current_drive;
++  installed_partition = current_partition;
++  
++  /* Mount the drive pointed by IMAGE_PTR.  */
++  if (*image_ptr)
++    {
++      /* If the drive/partition where the images reside is specified,
++	 get the drive and the partition.  */
++      set_device (image_ptr);
++      if (errnum)
++	return 1;
++    }
++  else
++    {
++      /* If omitted, use SAVED_PARTITION and SAVED_DRIVE.  */
++      current_drive = saved_drive;
++      current_partition = saved_partition;
++    }
++
++  image_drive = saved_drive = current_drive;
++  image_partition = saved_partition = current_partition;
++
++  /* Open it.  */
++  if (! open_device ())
++    goto fail;
++
++  /* Check if stage1 exists. If the user doesn't specify the option
++     `--prefix', attempt /boot/grub and /grub.  */
++  /* NOTE: It is dangerous to run this command without `--prefix' in the
++     grub shell, since that affects `--stage2'.  */
++  if (! prefix)
++    {
++      prefix = "/boot/grub";
++      grub_sprintf (stage1, "%s%s", prefix, "/stage1");
++      if (! check_file (stage1))
++	{
++	  errnum = ERR_NONE;
++	  prefix = "/grub";
++	  grub_sprintf (stage1, "%s%s", prefix, "/stage1");
++	  if (! check_file (stage1))
++	    goto fail;
++	}
++    }
++  else
++    {
++      grub_sprintf (stage1, "%s%s", prefix, "/stage1");
++      if (! check_file (stage1))
++	goto fail;
++    }
++
++  /* The prefix was determined.  */
++  grub_sprintf (stage2, "%s%s", prefix, "/stage2");
++  grub_sprintf (config_filename, "%s%s", prefix, "/menu.lst");
++  *real_config_filename = 0;
++
++  /* Check if stage2 exists.  */
++  if (! check_file (stage2))
++    goto fail;
++
++  {
++    char *fsys = fsys_table[fsys_type].name;
++    int i;
++    int size = sizeof (stage1_5_map) / sizeof (stage1_5_map[0]);
++    
++    /* Iterate finding the same filesystem name as FSYS.  */
++    for (i = 0; i < size; i++)
++      if (grub_strcmp (fsys, stage1_5_map[i].fsys) == 0)
++	{
++	  /* OK, check if the Stage 1.5 exists.  */
++	  char stage1_5[64];
++	  
++	  grub_sprintf (stage1_5, "%s%s", prefix, stage1_5_map[i].name);
++	  if (check_file (stage1_5))
++	    {
++	      if (embed_stage1_5 (stage1_5, 
++				    installed_drive, installed_partition)
++		  || embed_stage1_5 (stage1_5, 
++				     image_drive, image_partition))
++		{
++		  grub_strcpy (real_config_filename, config_filename);
++		  sprint_device (image_drive, image_partition);
++		  grub_sprintf (config_filename, "%s%s", device, stage2);
++		  grub_strcpy (stage2, buffer);
++		}
++	    }
++	  errnum = 0;
++	  break;
++	}
++  }
++
++  /* Construct a string that is used by the command "install" as its
++     arguments.  */
++  sprint_device (installed_drive, installed_partition);
++  
++#if 1
++  /* Don't embed a drive number unnecessarily.  */
++  grub_sprintf (cmd_arg, "%s%s%s%s %s%s %s p %s %s",
++		is_force_lba? "--force-lba " : "",
++		stage2_arg? stage2_arg : "",
++		stage2_arg? " " : "",
++		stage1,
++		(installed_drive != image_drive) ? "d " : "",
++		device,
++		stage2,
++		config_filename,
++		real_config_filename);
++#else /* NOT USED */
++  /* This code was used, because we belived some BIOSes had a problem
++     that they didn't pass a booting drive correctly. It turned out,
++     however, stage1 could trash a booting drive when checking LBA support,
++     because some BIOSes modified the register %dx in INT 13H, AH=48H.
++     So it becamed unclear whether GRUB should use a pre-defined booting
++     drive or not. If the problem still exists, it would be necessary to
++     switch back to this code.  */
++  grub_sprintf (cmd_arg, "%s%s%s%s d %s %s p %s %s",
++		is_force_lba? "--force-lba " : "",
++		stage2_arg? stage2_arg : "",
++		stage2_arg? " " : "",
++		stage1,
++		device,
++		stage2,
++		config_filename,
++		real_config_filename);
++#endif /* NOT USED */
++  
++  /* Notify what will be run.  */
++  grub_printf (" Running \"install %s\"... ", cmd_arg);
++
++  /* Make sure that SAVED_DRIVE and SAVED_PARTITION are identical
++     with IMAGE_DRIVE and IMAGE_PARTITION, respectively.  */
++  saved_drive = image_drive;
++  saved_partition = image_partition;
++  
++  /* Run the command.  */
++  if (! install_func (cmd_arg, flags))
++    grub_printf ("succeeded\nDone.\n");
++  else
++    grub_printf ("failed\n");
++
++ fail:
++  saved_drive = tmp_drive;
++  saved_partition = tmp_partition;
++  return errnum;
++}
++
++static struct builtin builtin_setup =
++{
++  "setup",
++  setup_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "setup [--prefix=DIR] [--stage2=STAGE2_FILE] [--force-lba] INSTALL_DEVICE [IMAGE_DEVICE]",
++  "Set up the installation of GRUB automatically. This command uses"
++  " the more flexible command \"install\" in the backend and installs"
++  " GRUB into the device INSTALL_DEVICE. If IMAGE_DEVICE is specified,"
++  " then find the GRUB images in the device IMAGE_DEVICE, otherwise"
++  " use the current \"root device\", which can be set by the command"
++  " \"root\". If you know that your BIOS should support LBA but GRUB"
++  " doesn't work in LBA mode, specify the option `--force-lba'."
++  " If you install GRUB under the grub shell and you cannot unmount the"
++  " partition where GRUB images reside, specify the option `--stage2'"
++  " to tell GRUB the file name under your OS."
++};
++
++
++#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES)
++/* terminal */
++static int
++terminal_func (char *arg, int flags)
++{
++  /* The index of the default terminal in TERM_TABLE.  */
++  int default_term = -1;
++  struct term_entry *prev_term = current_term;
++  int to = -1;
++  int lines = 0;
++  int no_message = 0;
++  unsigned long term_flags = 0;
++  /* XXX: Assume less than 32 terminals.  */
++  unsigned long term_bitmap = 0;
++
++  /* Get GNU-style long options.  */
++  while (1)
++    {
++      if (grub_memcmp (arg, "--dumb", sizeof ("--dumb") - 1) == 0)
++	term_flags |= TERM_DUMB;
++      else if (grub_memcmp (arg, "--no-echo", sizeof ("--no-echo") - 1) == 0)
++	/* ``--no-echo'' implies ``--no-edit''.  */
++	term_flags |= (TERM_NO_ECHO | TERM_NO_EDIT);
++      else if (grub_memcmp (arg, "--no-edit", sizeof ("--no-edit") - 1) == 0)
++	term_flags |= TERM_NO_EDIT;
++      else if (grub_memcmp (arg, "--timeout=", sizeof ("--timeout=") - 1) == 0)
++	{
++	  char *val = arg + sizeof ("--timeout=") - 1;
++	  
++	  if (! safe_parse_maxint (&val, &to))
++	    return 1;
++	}
++      else if (grub_memcmp (arg, "--lines=", sizeof ("--lines=") - 1) == 0)
++	{
++	  char *val = arg + sizeof ("--lines=") - 1;
++
++	  if (! safe_parse_maxint (&val, &lines))
++	    return 1;
++
++	  /* Probably less than four is meaningless....  */
++	  if (lines < 4)
++	    {
++	      errnum = ERR_BAD_ARGUMENT;
++	      return 1;
++	    }
++	}
++      else if (grub_memcmp (arg, "--silent", sizeof ("--silent") - 1) == 0)
++	no_message = 1;
++      else
++	break;
++
++      arg = skip_to (0, arg);
++    }
++  
++  /* If no argument is specified, show current setting.  */
++  if (! *arg)
++    {
++      grub_printf ("%s%s%s%s\n",
++		   current_term->name,
++		   current_term->flags & TERM_DUMB ? " (dumb)" : "",
++		   current_term->flags & TERM_NO_EDIT ? " (no edit)" : "",
++		   current_term->flags & TERM_NO_ECHO ? " (no echo)" : "");
++      return 0;
++    }
++
++  while (*arg)
++    {
++      int i;
++      char *next = skip_to (0, arg);
++      
++      nul_terminate (arg);
++
++      for (i = 0; term_table[i].name; i++)
++	{
++	  if (grub_strcmp (arg, term_table[i].name) == 0)
++	    {
++	      if (term_table[i].flags & TERM_NEED_INIT)
++		{
++		  errnum = ERR_DEV_NEED_INIT;
++		  return 1;
++		}
++	      
++	      if (default_term < 0)
++		default_term = i;
++
++	      term_bitmap |= (1 << i);
++	      break;
++	    }
++	}
++
++      if (! term_table[i].name)
++	{
++	  errnum = ERR_BAD_ARGUMENT;
++	  return 1;
++	}
++
++      arg = next;
++    }
++
++  /* If multiple terminals are specified, wait until the user pushes any
++     key on one of the terminals.  */
++  if (term_bitmap & ~(1 << default_term))
++    {
++      int time1, time2 = -1;
++
++      /* XXX: Disable the pager.  */
++      count_lines = -1;
++      
++      /* Get current time.  */
++      while ((time1 = getrtsecs ()) == 0xFF)
++	;
++
++      /* Wait for a key input.  */
++      while (to)
++	{
++	  int i;
++
++	  for (i = 0; term_table[i].name; i++)
++	    {
++	      if (term_bitmap & (1 << i))
++		{
++		  if (term_table[i].checkkey () >= 0)
++		    {
++		      (void) term_table[i].getkey ();
++		      default_term = i;
++		      
++		      goto end;
++		    }
++		}
++	    }
++	  
++	  /* Prompt the user, once per sec.  */
++	  if ((time1 = getrtsecs ()) != time2 && time1 != 0xFF)
++	    {
++	      if (! no_message)
++		{
++		  /* Need to set CURRENT_TERM to each of selected
++		     terminals.  */
++		  for (i = 0; term_table[i].name; i++)
++		    if (term_bitmap & (1 << i))
++		      {
++			current_term = term_table + i;
++			grub_printf ("\rPress any key to continue.\n");
++		      }
++		  
++		  /* Restore CURRENT_TERM.  */
++		  current_term = prev_term;
++		}
++	      
++	      time2 = time1;
++	      if (to > 0)
++		to--;
++	    }
++	}
++    }
++
++ end:
++  current_term = term_table + default_term;
++  current_term->flags = term_flags;
++  
++  if (lines)
++    max_lines = lines;
++  else
++    /* 24 would be a good default value.  */
++    max_lines = 24;
++  
++  /* If the interface is currently the command-line,
++     restart it to repaint the screen.  */
++  if (current_term != prev_term && (flags & BUILTIN_CMDLINE))
++    grub_longjmp (restart_cmdline_env, 0);
++  
++  return 0;
++}
++
++static struct builtin builtin_terminal =
++{
++  "terminal",
++  terminal_func,
++  BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "terminal [--dumb] [--no-echo] [--no-edit] [--timeout=SECS] [--lines=LINES] [--silent] [console] [serial] [hercules]",
++  "Select a terminal. When multiple terminals are specified, wait until"
++  " you push any key to continue. If both console and serial are specified,"
++  " the terminal to which you input a key first will be selected. If no"
++  " argument is specified, print current setting. The option --dumb"
++  " specifies that your terminal is dumb, otherwise, vt100-compatibility"
++  " is assumed. If you specify --no-echo, input characters won't be echoed."
++  " If you specify --no-edit, the BASH-like editing feature will be disabled."
++  " If --timeout is present, this command will wait at most for SECS"
++  " seconds. The option --lines specifies the maximum number of lines."
++  " The option --silent is used to suppress messages."
++};
++#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES */
++
++
++#ifdef SUPPORT_SERIAL
++static int
++terminfo_func (char *arg, int flags)
++{
++  struct terminfo term;
++
++  if (*arg)
++    {
++      struct
++      {
++	const char *name;
++	char *var;
++      }
++      options[] =
++	{
++	  {"--name=", term.name},
++	  {"--cursor-address=", term.cursor_address},
++	  {"--clear-screen=", term.clear_screen},
++	  {"--enter-standout-mode=", term.enter_standout_mode},
++	  {"--exit-standout-mode=", term.exit_standout_mode}
++	};
++
++      grub_memset (&term, 0, sizeof (term));
++      
++      while (*arg)
++	{
++	  int i;
++	  char *next = skip_to (0, arg);
++	      
++	  nul_terminate (arg);
++	  
++	  for (i = 0; i < sizeof (options) / sizeof (options[0]); i++)
++	    {
++	      const char *name = options[i].name;
++	      int len = grub_strlen (name);
++	      
++	      if (! grub_memcmp (arg, name, len))
++		{
++		  grub_strcpy (options[i].var, ti_unescape_string (arg + len));
++		  break;
++		}
++	    }
++
++	  if (i == sizeof (options) / sizeof (options[0]))
++	    {
++	      errnum = ERR_BAD_ARGUMENT;
++	      return errnum;
++	    }
++
++	  arg = next;
++	}
++
++      if (term.name[0] == 0 || term.cursor_address[0] == 0)
++	{
++	  errnum = ERR_BAD_ARGUMENT;
++	  return errnum;
++	}
++
++      ti_set_term (&term);
++    }
++  else
++    {
++      /* No option specifies printing out current settings.  */
++      ti_get_term (&term);
++
++      grub_printf ("name=%s\n",
++		   ti_escape_string (term.name));
++      grub_printf ("cursor_address=%s\n",
++		   ti_escape_string (term.cursor_address));
++      grub_printf ("clear_screen=%s\n",
++		   ti_escape_string (term.clear_screen));
++      grub_printf ("enter_standout_mode=%s\n",
++		   ti_escape_string (term.enter_standout_mode));
++      grub_printf ("exit_standout_mode=%s\n",
++		   ti_escape_string (term.exit_standout_mode));
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_terminfo =
++{
++  "terminfo",
++  terminfo_func,
++  BUILTIN_MENU | BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "terminfo [--name=NAME --cursor-address=SEQ [--clear-screen=SEQ]"
++  " [--enter-standout-mode=SEQ] [--exit-standout-mode=SEQ]]",
++  
++  "Define the capabilities of your terminal. Use this command to"
++  " define escape sequences, if it is not vt100-compatible."
++  " You may use \\e for ESC and ^X for a control character."
++  " If no option is specified, the current settings are printed."
++};
++#endif /* SUPPORT_SERIAL */
++	  
++
++/* testload */
++static int
++testload_func (char *arg, int flags)
++{
++  int i;
++
++  kernel_type = KERNEL_TYPE_NONE;
++
++  if (! grub_open (arg))
++    return 1;
++
++  disk_read_hook = disk_read_print_func;
++
++  /* Perform filesystem test on the specified file.  */
++  /* Read whole file first. */
++  grub_printf ("Whole file: ");
++
++  grub_read ((char *) RAW_ADDR (0x100000), -1);
++
++  /* Now compare two sections of the file read differently.  */
++
++  for (i = 0; i < 0x10ac0; i++)
++    {
++      *((unsigned char *) RAW_ADDR (0x200000 + i)) = 0;
++      *((unsigned char *) RAW_ADDR (0x300000 + i)) = 1;
++    }
++
++  /* First partial read.  */
++  grub_printf ("\nPartial read 1: ");
++
++  grub_seek (0);
++  grub_read ((char *) RAW_ADDR (0x200000), 0x7);
++  grub_read ((char *) RAW_ADDR (0x200007), 0x100);
++  grub_read ((char *) RAW_ADDR (0x200107), 0x10);
++  grub_read ((char *) RAW_ADDR (0x200117), 0x999);
++  grub_read ((char *) RAW_ADDR (0x200ab0), 0x10);
++  grub_read ((char *) RAW_ADDR (0x200ac0), 0x10000);
++
++  /* Second partial read.  */
++  grub_printf ("\nPartial read 2: ");
++
++  grub_seek (0);
++  grub_read ((char *) RAW_ADDR (0x300000), 0x10000);
++  grub_read ((char *) RAW_ADDR (0x310000), 0x10);
++  grub_read ((char *) RAW_ADDR (0x310010), 0x7);
++  grub_read ((char *) RAW_ADDR (0x310017), 0x10);
++  grub_read ((char *) RAW_ADDR (0x310027), 0x999);
++  grub_read ((char *) RAW_ADDR (0x3109c0), 0x100);
++
++  grub_printf ("\nHeader1 = 0x%x, next = 0x%x, next = 0x%x, next = 0x%x\n",
++	       *((int *) RAW_ADDR (0x200000)),
++	       *((int *) RAW_ADDR (0x200004)),
++	       *((int *) RAW_ADDR (0x200008)),
++	       *((int *) RAW_ADDR (0x20000c)));
++
++  grub_printf ("Header2 = 0x%x, next = 0x%x, next = 0x%x, next = 0x%x\n",
++	       *((int *) RAW_ADDR (0x300000)),
++	       *((int *) RAW_ADDR (0x300004)),
++	       *((int *) RAW_ADDR (0x300008)),
++	       *((int *) RAW_ADDR (0x30000c)));
++
++  for (i = 0; i < 0x10ac0; i++)
++    if (*((unsigned char *) RAW_ADDR (0x200000 + i))
++	!= *((unsigned char *) RAW_ADDR (0x300000 + i)))
++      break;
++
++  grub_printf ("Max is 0x10ac0: i=0x%x, filepos=0x%x\n", i, filepos);
++  disk_read_hook = 0;
++  grub_close ();
++  return 0;
++}
++
++static struct builtin builtin_testload =
++{
++  "testload",
++  testload_func,
++  BUILTIN_CMDLINE,
++  "testload FILE",
++  "Read the entire contents of FILE in several different ways and"
++  " compares them, to test the filesystem code. The output is somewhat"
++  " cryptic, but if no errors are reported and the final `i=X,"
++  " filepos=Y' reading has X and Y equal, then it is definitely"
++  " consistent, and very likely works correctly subject to a"
++  " consistent offset error. If this test succeeds, then a good next"
++  " step is to try loading a kernel."
++};
++
++
++/* testvbe MODE */
++static int
++testvbe_func (char *arg, int flags)
++{
++  int mode_number;
++  struct vbe_controller controller;
++  struct vbe_mode mode;
++  
++  if (! *arg)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  if (! safe_parse_maxint (&arg, &mode_number))
++    return 1;
++
++  /* Preset `VBE2'.  */
++  grub_memmove (controller.signature, "VBE2", 4);
++
++  /* Detect VBE BIOS.  */
++  if (get_vbe_controller_info (&controller) != 0x004F)
++    {
++      grub_printf (" VBE BIOS is not present.\n");
++      return 0;
++    }
++  
++  if (controller.version < 0x0200)
++    {
++      grub_printf (" VBE version %d.%d is not supported.\n",
++		   (int) (controller.version >> 8),
++		   (int) (controller.version & 0xFF));
++      return 0;
++    }
++
++  if (get_vbe_mode_info (mode_number, &mode) != 0x004F
++      || (mode.mode_attributes & 0x0091) != 0x0091)
++    {
++      grub_printf (" Mode 0x%x is not supported.\n", mode_number);
++      return 0;
++    }
++
++  /* Now trip to the graphics mode.  */
++  if (set_vbe_mode (mode_number | (1 << 14)) != 0x004F)
++    {
++      grub_printf (" Switching to Mode 0x%x failed.\n", mode_number);
++      return 0;
++    }
++
++  /* Draw something on the screen...  */
++  {
++    unsigned char *base_buf = (unsigned char *) mode.phys_base;
++    int scanline = controller.version >= 0x0300
++      ? mode.linear_bytes_per_scanline : mode.bytes_per_scanline;
++    /* FIXME: this assumes that any depth is a modulo of 8.  */
++    int bpp = mode.bits_per_pixel / 8;
++    int width = mode.x_resolution;
++    int height = mode.y_resolution;
++    int x, y;
++    unsigned color = 0;
++
++    /* Iterate drawing on the screen, until the user hits any key.  */
++    while (checkkey () == -1)
++      {
++	for (y = 0; y < height; y++)
++	  {
++	    unsigned char *line_buf = base_buf + scanline * y;
++	    
++	    for (x = 0; x < width; x++)
++	      {
++		unsigned char *buf = line_buf + bpp * x;
++		int i;
++
++		for (i = 0; i < bpp; i++, buf++)
++		  *buf = (color >> (i * 8)) & 0xff;
++	      }
++
++	    color++;
++	  }
++      }
++
++    /* Discard the input.  */
++    getkey ();
++  }
++  
++  /* Back to the default text mode.  */
++  if (set_vbe_mode (0x03) != 0x004F)
++    {
++      /* Why?!  */
++      grub_reboot ();
++    }
++
++  return 0;
++}
++
++static struct builtin builtin_testvbe =
++{
++  "testvbe",
++  testvbe_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "testvbe MODE",
++  "Test the VBE mode MODE. Hit any key to return."
++};
++
++
++#ifdef SUPPORT_NETBOOT
++/* tftpserver */
++static int
++tftpserver_func (char *arg, int flags)
++{
++  if (! *arg || ! ifconfig (0, 0, 0, arg))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++
++  print_network_configuration ();
++  return 0;
++}
++
++static struct builtin builtin_tftpserver =
++{
++  "tftpserver",
++  tftpserver_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "tftpserver IPADDR",
++  "Override the TFTP server address."
++};
++#endif /* SUPPORT_NETBOOT */
++
++
++/* timeout */
++static int
++timeout_func (char *arg, int flags)
++{
++  if (! safe_parse_maxint (&arg, &grub_timeout))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_timeout =
++{
++  "timeout",
++  timeout_func,
++  BUILTIN_MENU,
++#if 0
++  "timeout SEC",
++  "Set a timeout, in SEC seconds, before automatically booting the"
++  " default entry (normally the first entry defined)."
++#endif
++};
++
++
++/* title */
++static int
++title_func (char *arg, int flags)
++{
++  /* This function is not actually used at least currently.  */
++  return 0;
++}
++
++static struct builtin builtin_title =
++{
++  "title",
++  title_func,
++  BUILTIN_TITLE,
++#if 0
++  "title [NAME ...]",
++  "Start a new boot entry, and set its name to the contents of the"
++  " rest of the line, starting with the first non-space character."
++#endif
++};
++
++
++/* unhide */
++static int
++unhide_func (char *arg, int flags)
++{
++  if (! set_device (arg))
++    return 1;
++
++  if (! set_partition_hidden_flag (0))
++    return 1;
++
++  return 0;
++}
++
++static struct builtin builtin_unhide =
++{
++  "unhide",
++  unhide_func,
++  BUILTIN_CMDLINE | BUILTIN_MENU | BUILTIN_HELP_LIST,
++  "unhide PARTITION",
++  "Unhide PARTITION by clearing the \"hidden\" bit in its"
++  " partition type code."
++};
++
++
++/* uppermem */
++static int
++uppermem_func (char *arg, int flags)
++{
++  if (! safe_parse_maxint (&arg, (int *) &mbi.mem_upper))
++    return 1;
++
++  mbi.flags &= ~MB_INFO_MEM_MAP;
++  return 0;
++}
++
++static struct builtin builtin_uppermem =
++{
++  "uppermem",
++  uppermem_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "uppermem KBYTES",
++  "Force GRUB to assume that only KBYTES kilobytes of upper memory are"
++  " installed.  Any system address range maps are discarded."
++};
++
++
++/* vbeprobe */
++static int
++vbeprobe_func (char *arg, int flags)
++{
++  struct vbe_controller controller;
++  unsigned short *mode_list;
++  int mode_number = -1;
++  
++  auto unsigned long vbe_far_ptr_to_linear (unsigned long);
++  
++  unsigned long vbe_far_ptr_to_linear (unsigned long ptr)
++    {
++      unsigned short seg = (ptr >> 16);
++      unsigned short off = (ptr & 0xFFFF);
++
++      return (seg << 4) + off;
++    }
++  
++  if (*arg)
++    {
++      if (! safe_parse_maxint (&arg, &mode_number))
++	return 1;
++    }
++  
++  /* Set the signature to `VBE2', to obtain VBE 3.0 information.  */
++  grub_memmove (controller.signature, "VBE2", 4);
++  
++  if (get_vbe_controller_info (&controller) != 0x004F)
++    {
++      grub_printf (" VBE BIOS is not present.\n");
++      return 0;
++    }
++
++  /* Check the version.  */
++  if (controller.version < 0x0200)
++    {
++      grub_printf (" VBE version %d.%d is not supported.\n",
++		   (int) (controller.version >> 8),
++		   (int) (controller.version & 0xFF));
++      return 0;
++    }
++
++  /* Print some information.  */
++  grub_printf (" VBE version %d.%d\n",
++	       (int) (controller.version >> 8),
++	       (int) (controller.version & 0xFF));
++
++  /* Iterate probing modes.  */
++  for (mode_list
++	 = (unsigned short *) vbe_far_ptr_to_linear (controller.video_mode);
++       *mode_list != 0xFFFF;
++       mode_list++)
++    {
++      struct vbe_mode mode;
++      
++      if (get_vbe_mode_info (*mode_list, &mode) != 0x004F)
++	continue;
++
++      /* Skip this, if this is not supported or linear frame buffer
++	 mode is not support.  */
++      if ((mode.mode_attributes & 0x0081) != 0x0081)
++	continue;
++
++      if (mode_number == -1 || mode_number == *mode_list)
++	{
++	  char *model;
++	  switch (mode.memory_model)
++	    {
++	    case 0x00: model = "Text"; break;
++	    case 0x01: model = "CGA graphics"; break;
++	    case 0x02: model = "Hercules graphics"; break;
++	    case 0x03: model = "Planar"; break;
++	    case 0x04: model = "Packed pixel"; break;
++	    case 0x05: model = "Non-chain 4, 256 color"; break;
++	    case 0x06: model = "Direct Color"; break;
++	    case 0x07: model = "YUV"; break;
++	    default: model = "Unknown"; break;
++	    }
++	  
++	  grub_printf ("  0x%x: %s, %ux%ux%u\n",
++		       (unsigned) *mode_list,
++		       model,
++		       (unsigned) mode.x_resolution,
++		       (unsigned) mode.y_resolution,
++		       (unsigned) mode.bits_per_pixel);
++	  
++	  if (mode_number != -1)
++	    break;
++	}
++    }
++
++  if (mode_number != -1 && mode_number != *mode_list)
++    grub_printf ("  Mode 0x%x is not found or supported.\n", mode_number);
++  
++  return 0;
++}
++
++static struct builtin builtin_vbeprobe =
++{
++  "vbeprobe",
++  vbeprobe_func,
++  BUILTIN_CMDLINE | BUILTIN_HELP_LIST,
++  "vbeprobe [MODE]",
++  "Probe VBE information. If the mode number MODE is specified, show only"
++  " the information about only the mode."
++};
++  
++
++/* The table of builtin commands. Sorted in dictionary order.  */
++struct builtin *builtin_table[] =
++{
++  &builtin_blocklist,
++  &builtin_boot,
++#ifdef SUPPORT_NETBOOT
++  &builtin_bootp,
++#endif /* SUPPORT_NETBOOT */
++  &builtin_cat,
++  &builtin_chainloader,
++  &builtin_cmp,
++  &builtin_color,
++  &builtin_configfile,
++  &builtin_debug,
++  &builtin_default,
++#ifdef GRUB_UTIL
++  &builtin_device,
++#endif /* GRUB_UTIL */
++#ifdef SUPPORT_NETBOOT
++  &builtin_dhcp,
++#endif /* SUPPORT_NETBOOT */
++  &builtin_displayapm,
++  &builtin_displaymem,
++#ifdef GRUB_UTIL
++  &builtin_dump,
++#endif /* GRUB_UTIL */
++  &builtin_embed,
++  &builtin_fallback,
++  &builtin_find,
++  &builtin_fstest,
++  &builtin_geometry,
++  &builtin_halt,
++  &builtin_help,
++  &builtin_hiddenmenu,
++  &builtin_hide,
++#ifdef SUPPORT_NETBOOT
++  &builtin_ifconfig,
++#endif /* SUPPORT_NETBOOT */
++  &builtin_impsprobe,
++  &builtin_initrd,
++  &builtin_install,
++  &builtin_ioprobe,
++  &builtin_kernel,
++  &builtin_lock,
++  &builtin_makeactive,
++  &builtin_map,
++#ifdef USE_MD5_PASSWORDS
++  &builtin_md5crypt,
++#endif /* USE_MD5_PASSWORDS */
++  &builtin_module,
++  &builtin_modulenounzip,
++  &builtin_pager,
++  &builtin_partnew,
++  &builtin_parttype,
++  &builtin_password,
++  &builtin_pause,
++#ifdef GRUB_UTIL
++  &builtin_quit,
++#endif /* GRUB_UTIL */
++#ifdef SUPPORT_NETBOOT
++  &builtin_rarp,
++#endif /* SUPPORT_NETBOOT */
++  &builtin_read,
++  &builtin_reboot,
++  &builtin_root,
++  &builtin_rootnoverify,
++  &builtin_savedefault,
++#ifdef SUPPORT_SERIAL
++  &builtin_serial,
++#endif /* SUPPORT_SERIAL */
++  &builtin_setkey,
++  &builtin_setup,
++#if defined(SUPPORT_SERIAL) || defined(SUPPORT_HERCULES)
++  &builtin_terminal,
++#endif /* SUPPORT_SERIAL || SUPPORT_HERCULES */
++#ifdef SUPPORT_SERIAL
++  &builtin_terminfo,
++#endif /* SUPPORT_SERIAL */
++  &builtin_testload,
++  &builtin_testvbe,
++#ifdef SUPPORT_NETBOOT
++  &builtin_tftpserver,
++#endif /* SUPPORT_NETBOOT */
++  &builtin_timeout,
++  &builtin_title,
++  &builtin_unhide,
++  &builtin_uppermem,
++  &builtin_vbeprobe,
++  0
++};
+diff -ruN grub-0.94.orig/stage2/disk_io.c stage2/disk_io.c
+--- grub-0.94.orig/stage2/disk_io.c	Wed Feb 11 00:22:12 2004
++++ stage2/disk_io.c	Wed Feb 11 00:22:29 2004
+@@ -72,6 +72,9 @@
+ # ifdef FSYS_XFS
+   {"xfs", xfs_mount, xfs_read, xfs_dir, 0, 0},
+ # endif
++# ifdef FSYS_UFS2
++  {"ufs2", ufs2_mount, ufs2_read, ufs2_dir, 0, ufs2_embed},
++# endif
+   /* XX FFS should come last as it's superblock is commonly crossing tracks
+      on floppies from track 1 to 2, while others only use 1.  */
+ # ifdef FSYS_FFS
+diff -ruN grub-0.94.orig/stage2/disk_io.c.orig stage2/disk_io.c.orig
+--- grub-0.94.orig/stage2/disk_io.c.orig	Thu Jan  1 03:00:00 1970
++++ stage2/disk_io.c.orig	Sun Oct 19 19:58:03 2003
+@@ -0,0 +1,1741 @@
++/* disk_io.c - implement abstract BIOS disk input and output */
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 1999,2000,2001,2002,2003  Free Software Foundation, Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++
++#include <shared.h>
++#include <filesys.h>
++
++#ifdef SUPPORT_NETBOOT
++# define GRUB	1
++# include <etherboot.h>
++#endif
++
++#ifdef GRUB_UTIL
++# include <device.h>
++#endif
++
++/* instrumentation variables */
++void (*disk_read_hook) (int, int, int) = NULL;
++void (*disk_read_func) (int, int, int) = NULL;
++
++#ifndef STAGE1_5
++int print_possibilities;
++
++static int do_completion;
++static int unique;
++static char *unique_string;
++
++#endif
++
++int fsmax;
++struct fsys_entry fsys_table[NUM_FSYS + 1] =
++{
++  /* TFTP should come first because others don't handle net device.  */
++# ifdef FSYS_TFTP
++  {"tftp", tftp_mount, tftp_read, tftp_dir, tftp_close, 0},
++# endif
++# ifdef FSYS_FAT
++  {"fat", fat_mount, fat_read, fat_dir, 0, 0},
++# endif
++# ifdef FSYS_EXT2FS
++  {"ext2fs", ext2fs_mount, ext2fs_read, ext2fs_dir, 0, 0},
++# endif
++# ifdef FSYS_MINIX
++  {"minix", minix_mount, minix_read, minix_dir, 0, 0},
++# endif
++# ifdef FSYS_REISERFS
++  {"reiserfs", reiserfs_mount, reiserfs_read, reiserfs_dir, 0, reiserfs_embed},
++# endif
++# ifdef FSYS_VSTAFS
++  {"vstafs", vstafs_mount, vstafs_read, vstafs_dir, 0, 0},
++# endif
++# ifdef FSYS_JFS
++  {"jfs", jfs_mount, jfs_read, jfs_dir, 0, jfs_embed},
++# endif
++# ifdef FSYS_XFS
++  {"xfs", xfs_mount, xfs_read, xfs_dir, 0, 0},
++# endif
++  /* XX FFS should come last as it's superblock is commonly crossing tracks
++     on floppies from track 1 to 2, while others only use 1.  */
++# ifdef FSYS_FFS
++  {"ffs", ffs_mount, ffs_read, ffs_dir, 0, ffs_embed},
++# endif
++  {0, 0, 0, 0, 0, 0}
++};
++
++
++/* These have the same format as "boot_drive" and "install_partition", but
++   are meant to be working values. */
++unsigned long current_drive = 0xFF;
++unsigned long current_partition;
++
++#ifndef STAGE1_5
++/* The register ESI should contain the address of the partition to be
++   used for loading a chain-loader when chain-loading the loader.  */
++unsigned long boot_part_addr = 0;
++#endif
++
++/*
++ *  Global variables describing details of the filesystem
++ */
++
++/* FIXME: BSD evil hack */
++#include "freebsd.h"
++int bsd_evil_hack;
++
++/* filesystem type */
++int fsys_type = NUM_FSYS;
++#ifndef NO_BLOCK_FILES
++static int block_file = 0;
++#endif /* NO_BLOCK_FILES */
++
++/* these are the translated numbers for the open partition */
++unsigned long part_start;
++unsigned long part_length;
++
++int current_slice;
++
++/* disk buffer parameters */
++int buf_drive = -1;
++int buf_track;
++struct geometry buf_geom;
++
++/* filesystem common variables */
++int filepos;
++int filemax;
++
++int
++rawread (int drive, int sector, int byte_offset, int byte_len, char *buf)
++{
++  int slen = (byte_offset + byte_len + SECTOR_SIZE - 1) >> SECTOR_BITS;
++
++  if (byte_len <= 0)
++    return 1;
++
++  while (byte_len > 0 && !errnum)
++    {
++      int soff, num_sect, bufaddr, track, size = byte_len;
++
++      /*
++       *  Check track buffer.  If it isn't valid or it is from the
++       *  wrong disk, then reset the disk geometry.
++       */
++      if (buf_drive != drive)
++	{
++	  if (get_diskinfo (drive, &buf_geom))
++	    {
++	      errnum = ERR_NO_DISK;
++	      return 0;
++	    }
++	  buf_drive = drive;
++	  buf_track = -1;
++	}
++
++      /* Make sure that SECTOR is valid.  */
++      if (sector < 0 || sector >= buf_geom.total_sectors)
++	{
++	  errnum = ERR_GEOM;
++	  return 0;
++	}
++      
++      /*  Get first sector of track  */
++      soff = sector % buf_geom.sectors;
++      track = sector - soff;
++      num_sect = buf_geom.sectors - soff;
++      bufaddr = BUFFERADDR + (soff * SECTOR_SIZE) + byte_offset;
++
++      if (track != buf_track)
++	{
++	  int bios_err, read_start = track, read_len = buf_geom.sectors;
++
++	  /*
++	   *  If there's more than one read in this entire loop, then
++	   *  only make the earlier reads for the portion needed.  This
++	   *  saves filling the buffer with data that won't be used!
++	   */
++	  if (slen > num_sect)
++	    {
++	      read_start = sector;
++	      read_len = num_sect;
++	      bufaddr = BUFFERADDR + byte_offset;
++	    }
++
++	  bios_err = biosdisk (BIOSDISK_READ, drive, &buf_geom,
++			       read_start, read_len, BUFFERSEG);
++	  if (bios_err)
++	    {
++	      buf_track = -1;
++
++	      if (bios_err == BIOSDISK_ERROR_GEOMETRY)
++		errnum = ERR_GEOM;
++	      else
++		{
++		  /*
++		   *  If there was an error, try to load only the
++		   *  required sector(s) rather than failing completely.
++		   */
++		  if (slen > num_sect
++		      || biosdisk (BIOSDISK_READ, drive, &buf_geom,
++				   sector, slen, BUFFERSEG))
++		    errnum = ERR_READ;
++
++		  bufaddr = BUFFERADDR + byte_offset;
++		}
++	    }
++	  else
++	    buf_track = track;
++
++	  if ((buf_track == 0 || sector == 0)
++	      && (PC_SLICE_TYPE (BUFFERADDR, 0) == PC_SLICE_TYPE_EZD
++		  || PC_SLICE_TYPE (BUFFERADDR, 1) == PC_SLICE_TYPE_EZD
++		  || PC_SLICE_TYPE (BUFFERADDR, 2) == PC_SLICE_TYPE_EZD
++		  || PC_SLICE_TYPE (BUFFERADDR, 3) == PC_SLICE_TYPE_EZD))
++	    {
++	      /* This is a EZD disk map sector 0 to sector 1 */
++	      if (buf_track == 0 || slen >= 2)
++		{
++		  /* We already read the sector 1, copy it to sector 0 */
++		  memmove ((char *) BUFFERADDR, 
++			   (char *) BUFFERADDR + SECTOR_SIZE, SECTOR_SIZE);
++		}
++	      else
++		{
++		  if (biosdisk (BIOSDISK_READ, drive, &buf_geom,
++				1, 1, BUFFERSEG))
++		    errnum = ERR_READ;
++		}
++	    }
++	}
++	  
++      if (size > ((num_sect * SECTOR_SIZE) - byte_offset))
++	size = (num_sect * SECTOR_SIZE) - byte_offset;
++
++      /*
++       *  Instrumentation to tell which sectors were read and used.
++       */
++      if (disk_read_func)
++	{
++	  int sector_num = sector;
++	  int length = SECTOR_SIZE - byte_offset;
++	  if (length > size)
++	    length = size;
++	  (*disk_read_func) (sector_num++, byte_offset, length);
++	  length = size - length;
++	  if (length > 0)
++	    {
++	      while (length > SECTOR_SIZE)
++		{
++		  (*disk_read_func) (sector_num++, 0, SECTOR_SIZE);
++		  length -= SECTOR_SIZE;
++		}
++	      (*disk_read_func) (sector_num, 0, length);
++	    }
++	}
++
++      memmove (buf, (char *) bufaddr, size);
++
++      buf += size;
++      byte_len -= size;
++      sector += num_sect;
++      slen -= num_sect;
++      byte_offset = 0;
++    }
++
++  return (!errnum);
++}
++
++
++int
++devread (int sector, int byte_offset, int byte_len, char *buf)
++{
++  /*
++   *  Check partition boundaries
++   */
++  if (sector < 0
++      || ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS))
++	  >= part_length))
++    {
++      errnum = ERR_OUTSIDE_PART;
++      return 0;
++    }
++
++  /*
++   *  Get the read to the beginning of a partition.
++   */
++  sector += byte_offset >> SECTOR_BITS;
++  byte_offset &= SECTOR_SIZE - 1;
++
++#if !defined(STAGE1_5)
++  if (disk_read_hook && debug)
++    printf ("<%d, %d, %d>", sector, byte_offset, byte_len);
++#endif /* !STAGE1_5 */
++
++  /*
++   *  Call RAWREAD, which is very similar, but:
++   *
++   *    --  It takes an extra parameter, the drive number.
++   *    --  It requires that "sector" is relative to the beginning
++   *            of the disk.
++   *    --  It doesn't handle offsets of more than 511 bytes into the
++   *            sector.
++   */
++  return rawread (current_drive, part_start + sector, byte_offset,
++		  byte_len, buf);
++}
++
++#ifndef STAGE1_5
++int
++rawwrite (int drive, int sector, char *buf)
++{
++  if (sector == 0)
++    {
++      if (biosdisk (BIOSDISK_READ, drive, &buf_geom, 0, 1, SCRATCHSEG))
++	{
++	  errnum = ERR_WRITE;
++	  return 0;
++	}
++
++      if (PC_SLICE_TYPE (SCRATCHADDR, 0) == PC_SLICE_TYPE_EZD
++	  || PC_SLICE_TYPE (SCRATCHADDR, 1) == PC_SLICE_TYPE_EZD
++	  || PC_SLICE_TYPE (SCRATCHADDR, 2) == PC_SLICE_TYPE_EZD
++	  || PC_SLICE_TYPE (SCRATCHADDR, 3) == PC_SLICE_TYPE_EZD)
++	sector = 1;
++    }
++  
++  memmove ((char *) SCRATCHADDR, buf, SECTOR_SIZE);
++  if (biosdisk (BIOSDISK_WRITE, drive, &buf_geom,
++		sector, 1, SCRATCHSEG))
++    {
++      errnum = ERR_WRITE;
++      return 0;
++    }
++
++  if (sector - sector % buf_geom.sectors == buf_track)
++    /* Clear the cache.  */
++    buf_track = -1;
++
++  return 1;
++}
++
++int
++devwrite (int sector, int sector_count, char *buf)
++{
++#if defined(GRUB_UTIL) && defined(__linux__)
++  if (current_partition != 0xFFFFFF)
++    {
++      /* If the grub shell is running under Linux and the user wants to
++	 embed a Stage 1.5 into a partition instead of a MBR, use system
++	 calls directly instead of biosdisk, because of the bug in
++	 Linux. *sigh*  */
++      return write_to_partition (device_map, current_drive, current_partition,
++				 sector, sector_count, buf);
++    }
++  else
++#endif /* GRUB_UTIL && __linux__ */
++    {
++      int i;
++      
++      for (i = 0; i < sector_count; i++)
++	{
++	  if (! rawwrite (current_drive, part_start + sector + i, 
++			  buf + (i << SECTOR_BITS)))
++	      return 0;
++
++	}
++      return 1;
++    }
++}
++
++static int
++sane_partition (void)
++{
++  /* network drive */
++  if (current_drive == NETWORK_DRIVE)
++    return 1;
++  
++  if (!(current_partition & 0xFF000000uL)
++      && (current_drive & 0xFFFFFF7F) < 8
++      && (current_partition & 0xFF) == 0xFF
++      && ((current_partition & 0xFF00) == 0xFF00
++	  || (current_partition & 0xFF00) < 0x800)
++      && ((current_partition >> 16) == 0xFF
++	  || (current_drive & 0x80)))
++    return 1;
++
++  errnum = ERR_DEV_VALUES;
++  return 0;
++}
++#endif /* ! STAGE1_5 */
++
++static void
++attempt_mount (void)
++{
++#ifndef STAGE1_5
++  for (fsys_type = 0; fsys_type < NUM_FSYS; fsys_type++)
++    if ((fsys_table[fsys_type].mount_func) ())
++      break;
++
++  if (fsys_type == NUM_FSYS && errnum == ERR_NONE)
++    errnum = ERR_FSYS_MOUNT;
++#else
++  fsys_type = 0;
++  if ((*(fsys_table[fsys_type].mount_func)) () != 1)
++    {
++      fsys_type = NUM_FSYS;
++      errnum = ERR_FSYS_MOUNT;
++    }
++#endif
++}
++
++
++#ifndef STAGE1_5
++/* Turn on the active flag for the partition SAVED_PARTITION in the
++   drive SAVED_DRIVE. If an error occurs, return zero, otherwise return
++   non-zero.  */
++int
++make_saved_active (void)
++{
++  char mbr[512];
++
++  if (saved_drive & 0x80)
++    {
++      /* Hard disk */
++      int part = saved_partition >> 16;
++
++      /* If the partition is not a primary partition, the active flag is
++	 meaningless. (XXX: Really?)  */
++      if (part > 3)
++	{
++	  errnum = ERR_DEV_VALUES;
++	  return 0;
++	}
++
++      /* Read the MBR in the scratch space.  */
++      if (! rawread (saved_drive, 0, 0, SECTOR_SIZE, mbr))
++	return 0;
++
++      /* If the partition is an extended partition, setting the active
++	 flag violates the specification by IBM.  */
++      if (IS_PC_SLICE_TYPE_EXTENDED (PC_SLICE_TYPE (mbr, part)))
++	{
++	  errnum = ERR_DEV_VALUES;
++	  return 0;
++	}
++
++      /* Check if the active flag is disabled.  */
++      if (PC_SLICE_FLAG (mbr, part) != PC_SLICE_FLAG_BOOTABLE)
++	{
++	  int i;
++
++	  /* Clear all the active flags in this table.  */
++	  for (i = 0; i < 4; i++)
++	    PC_SLICE_FLAG (mbr, i) = 0;
++
++	  /* Set the flag.  */
++	  PC_SLICE_FLAG (mbr, part) = PC_SLICE_FLAG_BOOTABLE;
++
++	  /* Write back the MBR.  */
++	  if (! rawwrite (saved_drive, 0, mbr))
++	    return 0;
++	}
++    }
++  else
++    {
++      /* If the drive is not a hard disk drive, you shouldn't call this
++	 function. (XXX: Should I just ignore this error?)  */
++      errnum = ERR_DEV_VALUES;
++      return 0;
++    }
++
++  return 1;
++}
++
++/* Hide/Unhide CURRENT_PARTITION.  */
++int
++set_partition_hidden_flag (int hidden)
++{
++  unsigned long part = 0xFFFFFF;
++  unsigned long start, len, offset, ext_offset;
++  int entry, type;
++  char mbr[512];
++  
++  /* The drive must be a hard disk.  */
++  if (! (current_drive & 0x80))
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  /* The partition must be a PC slice.  */
++  if ((current_partition >> 16) == 0xFF
++      || (current_partition & 0xFFFF) != 0xFFFF)
++    {
++      errnum = ERR_BAD_ARGUMENT;
++      return 1;
++    }
++  
++  /* Look for the partition.  */
++  while (next_partition (current_drive, 0xFFFFFF, &part, &type,           
++			 &start, &len, &offset, &entry,
++			 &ext_offset, mbr))
++    {                                                                       
++      if (part == current_partition)
++	{
++	  /* Found.  */
++	  if (hidden)
++	    PC_SLICE_TYPE (mbr, entry) |= PC_SLICE_TYPE_HIDDEN_FLAG;
++	  else
++	    PC_SLICE_TYPE (mbr, entry) &= ~PC_SLICE_TYPE_HIDDEN_FLAG;       
++	  
++	  /* Write back the MBR to the disk.  */
++	  buf_track = -1;
++	  if (! rawwrite (current_drive, offset, mbr))
++	    return 1;
++	  
++	  /* Succeed.  */
++	  return 0;
++	}
++    }
++  
++  return 1;
++}
++
++
++static void
++check_and_print_mount (void)
++{
++  attempt_mount ();
++  if (errnum == ERR_FSYS_MOUNT)
++    errnum = ERR_NONE;
++  if (!errnum)
++    print_fsys_type ();
++  print_error ();
++}
++#endif /* STAGE1_5 */
++
++
++/* Get the information on next partition on the drive DRIVE.
++   The caller must not modify the contents of the arguments when
++   iterating this function. The partition representation in GRUB will
++   be stored in *PARTITION. Likewise, the partition type in *TYPE, the
++   start sector in *START, the length in *LEN, the offset of the
++   partition table in *OFFSET, the entry number in the table in *ENTRY,
++   the offset of the extended partition in *EXT_OFFSET.
++   BUF is used to store a MBR, the boot sector of a partition, or
++   a BSD label sector, and it must be at least 512 bytes length.
++   When calling this function first, *PARTITION must be initialized to
++   0xFFFFFF. The return value is zero if fails, otherwise non-zero.  */
++int
++next_partition (unsigned long drive, unsigned long dest,
++		unsigned long *partition, int *type,
++		unsigned long *start, unsigned long *len,
++		unsigned long *offset, int *entry,
++		unsigned long *ext_offset, char *buf)
++{
++  /* Forward declarations.  */
++  auto int next_bsd_partition (void);
++  auto int next_pc_slice (void);
++
++  /* Get next BSD partition in current PC slice.  */
++  int next_bsd_partition (void)
++    {
++      int i;
++      int bsd_part_no = (*partition & 0xFF00) >> 8;
++
++      /* If this is the first time...  */
++      if (bsd_part_no == 0xFF)
++	{
++	  /* Check if the BSD label is within current PC slice.  */
++	  if (*len < BSD_LABEL_SECTOR + 1)
++	    {
++	      errnum = ERR_BAD_PART_TABLE;
++	      return 0;
++	    }
++
++	  /* Read the BSD label.  */
++	  if (! rawread (drive, *start + BSD_LABEL_SECTOR,
++			 0, SECTOR_SIZE, buf))
++	    return 0;
++
++	  /* Check if it is valid.  */
++	  if (! BSD_LABEL_CHECK_MAG (buf))
++	    {
++	      errnum = ERR_BAD_PART_TABLE;
++	      return 0;
++	    }
++	  
++	  bsd_part_no = -1;
++	}
++
++      /* Search next valid BSD partition.  */
++      for (i = bsd_part_no + 1; i < BSD_LABEL_NPARTS (buf); i++)
++	{
++	  if (BSD_PART_TYPE (buf, i))
++	    {
++	      /* Note that *TYPE and *PARTITION were set
++		 for current PC slice.  */
++	      *type = (BSD_PART_TYPE (buf, i) << 8) | (*type & 0xFF);
++	      *start = BSD_PART_START (buf, i);
++	      *len = BSD_PART_LENGTH (buf, i);
++	      *partition = (*partition & 0xFF00FF) | (i << 8);
++
++#ifndef STAGE1_5
++	      /* XXX */
++	      if ((drive & 0x80) && BSD_LABEL_DTYPE (buf) == DTYPE_SCSI)
++		bsd_evil_hack = 4;
++#endif /* ! STAGE1_5 */
++	      
++	      return 1;
++	    }
++	}
++
++      errnum = ERR_NO_PART;
++      return 0;
++    }
++
++  /* Get next PC slice. Be careful of that this function may return
++     an empty PC slice (i.e. a partition whose type is zero) as well.  */
++  int next_pc_slice (void)
++    {
++      int pc_slice_no = (*partition & 0xFF0000) >> 16;
++
++      /* If this is the first time...  */
++      if (pc_slice_no == 0xFF)
++	{
++	  *offset = 0;
++	  *ext_offset = 0;
++	  *entry = -1;
++	  pc_slice_no = -1;
++	}
++
++      /* Read the MBR or the boot sector of the extended partition.  */
++      if (! rawread (drive, *offset, 0, SECTOR_SIZE, buf))
++	return 0;
++
++      /* Check if it is valid.  */
++      if (! PC_MBR_CHECK_SIG (buf))
++	{
++	  errnum = ERR_BAD_PART_TABLE;
++	  return 0;
++	}
++
++      /* Increase the entry number.  */
++      (*entry)++;
++
++      /* If this is out of current partition table...  */
++      if (*entry == PC_SLICE_MAX)
++	{
++	  int i;
++
++	  /* Search the first extended partition in current table.  */
++	  for (i = 0; i < PC_SLICE_MAX; i++)
++	    {
++	      if (IS_PC_SLICE_TYPE_EXTENDED (PC_SLICE_TYPE (buf, i)))
++		{
++		  /* Found. Set the new offset and the entry number,
++		     and restart this function.  */
++		  *offset = *ext_offset + PC_SLICE_START (buf, i);
++		  if (! *ext_offset)
++		    *ext_offset = *offset;
++		  *entry = -1;
++		  return next_pc_slice ();
++		}
++	    }
++
++	  errnum = ERR_NO_PART;
++	  return 0;
++	}
++      
++      *type = PC_SLICE_TYPE (buf, *entry);
++      *start = *offset + PC_SLICE_START (buf, *entry);
++      *len = PC_SLICE_LENGTH (buf, *entry);
++
++      /* The calculation of a PC slice number is complicated, because of
++	 the rather odd definition of extended partitions. Even worse,
++	 there is no guarantee that this is consistent with every
++	 operating systems. Uggh.  */
++      if (pc_slice_no < PC_SLICE_MAX
++	  || (! IS_PC_SLICE_TYPE_EXTENDED (*type)
++	      && *type != PC_SLICE_TYPE_NONE))
++	pc_slice_no++;
++      
++      *partition = (pc_slice_no << 16) | 0xFFFF;
++      return 1;
++    }
++
++  /* Start the body of this function.  */
++  
++#ifndef STAGE1_5
++  if (current_drive == NETWORK_DRIVE)
++    return 0;
++#endif
++
++  /* If previous partition is a BSD partition or a PC slice which
++     contains BSD partitions...  */
++  if ((*partition != 0xFFFFFF && IS_PC_SLICE_TYPE_BSD (*type & 0xff))
++      || ! (drive & 0x80))
++    {
++      if (*type == PC_SLICE_TYPE_NONE)
++	*type = PC_SLICE_TYPE_FREEBSD;
++      
++      /* Get next BSD partition, if any.  */
++      if (next_bsd_partition ())
++	return 1;
++
++      /* If the destination partition is a BSD partition and current
++	 BSD partition has any error, abort the operation.  */
++      if ((dest & 0xFF00) != 0xFF00
++	  && ((dest & 0xFF0000) == 0xFF0000
++	      || (dest & 0xFF0000) == (*partition & 0xFF0000)))
++	return 0;
++
++      /* Ignore the error.  */
++      errnum = ERR_NONE;
++    }
++	  
++  return next_pc_slice ();
++}
++
++#ifndef STAGE1_5
++static unsigned long cur_part_offset;
++static unsigned long cur_part_addr;
++#endif
++
++/* Open a partition.  */
++int
++real_open_partition (int flags)
++{
++  unsigned long dest_partition = current_partition;
++  unsigned long part_offset;
++  unsigned long ext_offset;
++  int entry;
++  char buf[SECTOR_SIZE];
++  int bsd_part, pc_slice;
++
++  /* For simplicity.  */
++  auto int next (void);
++  int next (void)
++    {
++      int ret = next_partition (current_drive, dest_partition,
++				&current_partition, &current_slice,
++				&part_start, &part_length,
++				&part_offset, &entry, &ext_offset, buf);
++      bsd_part = (current_partition >> 8) & 0xFF;
++      pc_slice = current_partition >> 16;
++      return ret;
++    }
++  
++#ifndef STAGE1_5
++  /* network drive */
++  if (current_drive == NETWORK_DRIVE)
++    return 1;
++  
++  if (! sane_partition ())
++    return 0;
++#endif
++
++  bsd_evil_hack = 0;
++  current_slice = 0;
++  part_start = 0;
++
++  /* Make sure that buf_geom is valid. */
++  if (buf_drive != current_drive)
++    {
++      if (get_diskinfo (current_drive, &buf_geom))
++	{
++	  errnum = ERR_NO_DISK;
++	  return 0;
++	}
++      buf_drive = current_drive;
++      buf_track = -1;
++    }
++  part_length = buf_geom.total_sectors;
++
++  /* If this is the whole disk, return here.  */
++  if (! flags && current_partition == 0xFFFFFF)
++    return 1;
++
++  if (flags)
++    dest_partition = 0xFFFFFF;
++
++  /* Initialize CURRENT_PARTITION for next_partition.  */
++  current_partition = 0xFFFFFF;
++  
++  while (next ())
++    {
++#ifndef STAGE1_5
++    loop_start:
++      
++      cur_part_offset = part_offset;
++      cur_part_addr = BOOT_PART_TABLE + (entry << 4);
++#endif /* ! STAGE1_5 */
++
++      /* If this is a valid partition...  */
++      if (current_slice)
++	{
++#ifndef STAGE1_5
++	  /* Display partition information.  */
++	  if (flags && ! IS_PC_SLICE_TYPE_EXTENDED (current_slice))
++	    {
++	      if (! do_completion)
++		{
++		  if (current_drive & 0x80)
++		    grub_printf ("   Partition num: %d, ",
++				 current_partition >> 16);
++
++		  if (! IS_PC_SLICE_TYPE_BSD (current_slice))
++		    check_and_print_mount ();
++		  else
++		    {
++		      int got_part = 0;
++		      int saved_slice = current_slice;
++		      
++		      while (next ())
++			{
++			  if (bsd_part == 0xFF)
++			    break;
++			  
++			  if (! got_part)
++			    {
++			      grub_printf ("[BSD sub-partitions immediately follow]\n");
++			      got_part = 1;
++			    }
++			  
++			  grub_printf ("     BSD Partition num: \'%c\', ",
++				       bsd_part + 'a');
++			  check_and_print_mount ();
++			}
++
++		      if (! got_part)
++			grub_printf (" No BSD sub-partition found, partition type 0x%x\n",
++				     saved_slice);
++		      
++		      if (errnum)
++			{
++			  errnum = ERR_NONE;
++			  break;
++			}
++		      
++		      goto loop_start;
++		    }
++		}
++	      else
++		{
++		  if (bsd_part != 0xFF)
++		    {
++		      char str[16];
++		      
++		      if (! (current_drive & 0x80)
++			  || (dest_partition >> 16) == pc_slice)
++			grub_sprintf (str, "%c)", bsd_part + 'a');
++		      else
++			grub_sprintf (str, "%d,%c)",
++				      pc_slice, bsd_part + 'a');
++		      print_a_completion (str);
++		    }
++		  else if (! IS_PC_SLICE_TYPE_BSD (current_slice))
++		    {
++		      char str[8];
++		      
++		      grub_sprintf (str, "%d)", pc_slice);
++		      print_a_completion (str);
++		    }
++		}
++	    }
++	  
++	  errnum = ERR_NONE;
++#endif /* ! STAGE1_5 */
++	  
++	  /* Check if this is the destination partition.  */
++	  if (! flags
++	      && (dest_partition == current_partition
++		  || ((dest_partition >> 16) == 0xFF
++		      && ((dest_partition >> 8) & 0xFF) == bsd_part)))
++	    return 1;
++	}
++    }
++
++#ifndef STAGE1_5
++  if (flags)
++    {
++      if (! (current_drive & 0x80))
++	{
++	  current_partition = 0xFFFFFF;
++	  check_and_print_mount ();
++	}
++      
++      errnum = ERR_NONE;
++      return 1;
++    }
++#endif /* ! STAGE1_5 */
++  
++  return 0;
++}
++
++
++int
++open_partition (void)
++{
++  return real_open_partition (0);
++}
++
++
++#ifndef STAGE1_5
++/* XX used for device completion in 'set_device' and 'print_completions' */
++static int incomplete, disk_choice;
++static enum
++{
++  PART_UNSPECIFIED = 0,
++  PART_DISK,
++  PART_CHOSEN,
++}
++part_choice;
++#endif /* ! STAGE1_5 */
++
++char *
++set_device (char *device)
++{
++#ifdef STAGE1_5
++    /* In Stage 1.5, the first 4 bytes of FILENAME has a device number.  */
++  unsigned long dev = *((unsigned long *) device);
++  int drive = (dev >> 24) & 0xFF;
++  int partition = dev & 0xFFFFFF;
++
++  /* If DRIVE is disabled (0xFF), use SAVED_DRIVE instead.  */
++  if (drive == 0xFF)
++    current_drive = saved_drive;
++  else
++    current_drive = drive;
++
++  /* The `partition' part must always have a valid number.  */
++  current_partition = partition;
++  
++  return device + sizeof (unsigned long);
++  
++#else /* ! STAGE1_5 */
++  
++  int result = 0;
++
++  incomplete = 0;
++  disk_choice = 1;
++  part_choice = PART_UNSPECIFIED;
++  current_drive = saved_drive;
++  current_partition = 0xFFFFFF;
++
++  if (*device == '(' && !*(device + 1))
++    /* user has given '(' only, let disk_choice handle what disks we have */
++    return device + 1;
++
++  if (*device == '(' && *(++device))
++    {
++      if (*device != ',' && *device != ')')
++	{
++	  char ch = *device;
++#ifdef SUPPORT_NETBOOT
++	  if (*device == 'f' || *device == 'h' ||
++	      (*device == 'n' && network_ready))
++#else
++	  if (*device == 'f' || *device == 'h')
++#endif /* SUPPORT_NETBOOT */
++	    {
++	      /* user has given '([fhn]', check for resp. add 'd' and
++		 let disk_choice handle what disks we have */
++	      if (!*(device + 1))
++		{
++		  device++;
++		  *device++ = 'd';
++		  *device = '\0';
++		  return device;
++		}
++	      else if (*(device + 1) == 'd' && !*(device + 2))
++		return device + 2;
++	    }
++
++#ifdef SUPPORT_NETBOOT
++	  if ((*device == 'f' || *device == 'h' ||
++	       (*device == 'n' && network_ready))
++#else
++	  if ((*device == 'f' || *device == 'h')
++#endif /* SUPPORT_NETBOOT */
++	      && (device += 2, (*(device - 1) != 'd')))
++	    errnum = ERR_NUMBER_PARSING;
++
++#ifdef SUPPORT_NETBOOT
++	  if (ch == 'n' && network_ready)
++	    current_drive = NETWORK_DRIVE;
++	  else
++#endif /* SUPPORT_NETBOOT */
++	    {
++	      safe_parse_maxint (&device, (int *) &current_drive);
++	      
++	      disk_choice = 0;
++	      if (ch == 'h')
++		current_drive += 0x80;
++	    }
++	}
++
++      if (errnum)
++	return 0;
++
++      if (*device == ')')
++	{
++	  part_choice = PART_CHOSEN;
++	  result = 1;
++	}
++      else if (*device == ',')
++	{
++	  /* Either an absolute PC or BSD partition. */
++	  disk_choice = 0;
++	  part_choice ++;
++	  device++;
++
++	  if (*device >= '0' && *device <= '9')
++	    {
++	      part_choice ++;
++	      current_partition = 0;
++
++	      if (!(current_drive & 0x80)
++		  || !safe_parse_maxint (&device, (int *) &current_partition)
++		  || current_partition > 254)
++		{
++		  errnum = ERR_DEV_FORMAT;
++		  return 0;
++		}
++
++	      current_partition = (current_partition << 16) + 0xFFFF;
++
++	      if (*device == ',')
++		device++;
++	      
++	      if (*device >= 'a' && *device <= 'h')
++		{
++		  current_partition = (((*(device++) - 'a') << 8)
++				       | (current_partition & 0xFF00FF));
++		}
++	    }
++	  else if (*device >= 'a' && *device <= 'h')
++	    {
++	      part_choice ++;
++	      current_partition = ((*(device++) - 'a') << 8) | 0xFF00FF;
++	    }
++
++	  if (*device == ')')
++	    {
++	      if (part_choice == PART_DISK)
++		{
++		  current_partition = saved_partition;
++		  part_choice ++;
++		}
++
++	      result = 1;
++	    }
++	}
++    }
++
++  if (! sane_partition ())
++    return 0;
++  
++  if (result)
++    return device + 1;
++  else
++    {
++      if (!*device)
++	incomplete = 1;
++      errnum = ERR_DEV_FORMAT;
++    }
++
++  return 0;
++  
++#endif /* ! STAGE1_5 */
++}
++
++/*
++ *  This performs a "mount" on the current device, both drive and partition
++ *  number.
++ */
++
++int
++open_device (void)
++{
++  if (open_partition ())
++    attempt_mount ();
++
++  if (errnum != ERR_NONE)
++    return 0;
++
++  return 1;
++}
++
++
++#ifndef STAGE1_5
++int
++set_bootdev (int hdbias)
++{
++  int i, j;
++
++  /* Copy the boot partition information to 0x7be-0x7fd for chain-loading.  */
++  if ((saved_drive & 0x80) && cur_part_addr)
++    {
++      if (rawread (saved_drive, cur_part_offset,
++		   0, SECTOR_SIZE, (char *) SCRATCHADDR))
++	{
++	  char *dst, *src;
++      
++	  /* Need only the partition table.
++	     XXX: We cannot use grub_memmove because BOOT_PART_TABLE
++	     (0x07be) is less than 0x1000.  */
++	  dst = (char *) BOOT_PART_TABLE;
++	  src = (char *) SCRATCHADDR + BOOTSEC_PART_OFFSET;
++	  while (dst < (char *) BOOT_PART_TABLE + BOOTSEC_PART_LENGTH)
++	    *dst++ = *src++;
++	  
++	  /* Set the active flag of the booted partition.  */
++	  for (i = 0; i < 4; i++)
++	    PC_SLICE_FLAG (BOOT_PART_TABLE, i) = 0;
++	  
++	  *((unsigned char *) cur_part_addr) = PC_SLICE_FLAG_BOOTABLE;
++	  boot_part_addr = cur_part_addr;
++	}
++      else
++	return 0;
++    }
++  
++  /*
++   *  Set BSD boot device.
++   */
++  i = (saved_partition >> 16) + 2;
++  if (saved_partition == 0xFFFFFF)
++    i = 1;
++  else if ((saved_partition >> 16) == 0xFF)
++    i = 0;
++
++  /* FIXME: extremely evil hack!!! */
++  j = 2;
++  if (saved_drive & 0x80)
++    j = bsd_evil_hack;
++
++  return MAKEBOOTDEV (j, (i >> 4), (i & 0xF),
++		      ((saved_drive - hdbias) & 0x7F),
++		      ((saved_partition >> 8) & 0xFF));
++}
++#endif /* STAGE1_5 */
++
++
++static char *
++setup_part (char *filename)
++{
++#ifdef STAGE1_5
++
++  if (! (filename = set_device (filename)))
++    {
++      current_drive = 0xFF;
++      return 0;
++    }
++  
++# ifndef NO_BLOCK_FILES
++  if (*filename != '/')
++    open_partition ();
++  else
++# endif /* ! NO_BLOCK_FILES */
++    open_device ();
++  
++#else /* ! STAGE1_5 */
++  
++  if (*filename == '(')
++    {
++      if ((filename = set_device (filename)) == 0)
++	{
++	  current_drive = 0xFF;
++	  return 0;
++	}
++# ifndef NO_BLOCK_FILES
++      if (*filename != '/')
++	open_partition ();
++      else
++# endif /* ! NO_BLOCK_FILES */
++	open_device ();
++    }
++  else if (saved_drive != current_drive
++	   || saved_partition != current_partition
++	   || (*filename == '/' && fsys_type == NUM_FSYS)
++	   || buf_drive == -1)
++    {
++      current_drive = saved_drive;
++      current_partition = saved_partition;
++      /* allow for the error case of "no filesystem" after the partition
++         is found.  This makes block files work fine on no filesystem */
++# ifndef NO_BLOCK_FILES
++      if (*filename != '/')
++	open_partition ();
++      else
++# endif /* ! NO_BLOCK_FILES */
++	open_device ();
++    }
++  
++#endif /* ! STAGE1_5 */
++  
++  if (errnum && (*filename == '/' || errnum != ERR_FSYS_MOUNT))
++    return 0;
++  else
++    errnum = 0;
++
++#ifndef STAGE1_5
++  if (!sane_partition ())
++    return 0;
++#endif
++
++  return filename;
++}
++
++
++#ifndef STAGE1_5
++/*
++ *  This prints the filesystem type or gives relevant information.
++ */
++
++void
++print_fsys_type (void)
++{
++  if (! do_completion)
++    {
++      printf (" Filesystem type ");
++      
++      if (fsys_type != NUM_FSYS)
++	printf ("is %s, ", fsys_table[fsys_type].name);
++      else
++	printf ("unknown, ");
++      
++      if (current_partition == 0xFFFFFF)
++	printf ("using whole disk\n");
++      else
++	printf ("partition type 0x%x\n", current_slice & 0xFF);
++    }
++}
++#endif /* STAGE1_5 */
++
++#ifndef STAGE1_5
++/* If DO_COMPLETION is true, just print NAME. Otherwise save the unique
++   part into UNIQUE_STRING.  */
++void
++print_a_completion (char *name)
++{
++  /* If NAME is "." or "..", do not count it.  */
++  if (grub_strcmp (name, ".") == 0 || grub_strcmp (name, "..") == 0)
++    return;
++  
++  if (do_completion)
++    {
++      char *buf = unique_string;
++      
++      if (! unique)
++	while ((*buf++ = *name++))
++	  ;
++      else
++	{
++	  while (*buf && (*buf == *name))
++	    {
++	      buf++;
++	      name++;
++	    }
++	  /* mismatch, strip it.  */
++	  *buf = '\0';
++	}
++    }
++  else
++    grub_printf (" %s", name);
++  
++  unique++;
++}
++
++/*
++ *  This lists the possible completions of a device string, filename, or
++ *  any sane combination of the two.
++ */
++
++int
++print_completions (int is_filename, int is_completion)
++{
++  char *buf = (char *) COMPLETION_BUF;
++  char *ptr = buf;
++
++  unique_string = (char *) UNIQUE_BUF;
++  *unique_string = 0;
++  unique = 0;
++  do_completion = is_completion;
++
++  if (! is_filename)
++    {
++      /* Print the completions of builtin commands.  */
++      struct builtin **builtin;
++
++      if (! is_completion)
++	grub_printf (" Possible commands are:");
++      
++      for (builtin = builtin_table; (*builtin); builtin++)
++	{
++	  /* If *BUILTIN cannot be run in the command-line, skip it.  */
++	  if (! ((*builtin)->flags & BUILTIN_CMDLINE))
++	    continue;
++
++	  if (substring (buf, (*builtin)->name) <= 0)
++	    print_a_completion ((*builtin)->name);
++	}
++
++      if (is_completion && *unique_string)
++	{
++	  if (unique == 1)
++	    {
++	      char *u = unique_string + grub_strlen (unique_string);
++
++	      *u++ = ' ';
++	      *u = 0;
++	    }
++	  
++	  grub_strcpy (buf, unique_string);
++	}
++
++      if (! is_completion)
++	grub_putchar ('\n');
++      
++      print_error ();
++      do_completion = 0;
++      if (errnum)
++	return -1;
++      else
++	return unique - 1;
++    }
++
++  if (*buf == '/' || (ptr = set_device (buf)) || incomplete)
++    {
++      errnum = 0;
++
++      if (*buf == '(' && (incomplete || ! *ptr))
++	{
++	  if (! part_choice)
++	    {
++	      /* disk completions */
++	      int disk_no, i, j;
++	      struct geometry geom;
++
++	      if (! is_completion)
++		grub_printf (" Possible disks are: ");
++
++#ifdef SUPPORT_NETBOOT
++	      if (!ptr || *(ptr-1) != 'd' || *(ptr-2) != 'n')
++#endif /* SUPPORT_NETBOOT */
++		{
++		  for (i = (ptr && (*(ptr-1) == 'd' && *(ptr-2) == 'h') ? 1:0);
++		       i < (ptr && (*(ptr-1) == 'd' && *(ptr-2) == 'f') ? 1:2);
++		       i++)
++		    {
++		      for (j = 0; j < 8; j++)
++			{
++			  disk_no = (i * 0x80) + j;
++			  if ((disk_choice || disk_no == current_drive)
++			      && ! get_diskinfo (disk_no, &geom))
++			    {
++			      char dev_name[8];
++
++			      grub_sprintf (dev_name, "%cd%d", i ? 'h':'f', j);
++			      print_a_completion (dev_name);
++			    }
++			}
++		    }
++		}
++# ifdef SUPPORT_NETBOOT
++	      if (network_ready &&
++		  (disk_choice || NETWORK_DRIVE == current_drive) &&
++		  (!ptr || *(ptr-1) == '(' ||
++		   (*(ptr-1) == 'd' && *(ptr-2) == 'n')))
++		print_a_completion ("nd");
++# endif /* SUPPORT_NETBOOT */
++
++	      if (is_completion && *unique_string)
++		{
++		  ptr = buf;
++		  while (*ptr != '(')
++		    ptr--;
++		  ptr++;
++		  grub_strcpy (ptr, unique_string);
++		  if (unique == 1)
++		    {
++		      ptr += grub_strlen (ptr);
++		      if (*unique_string == 'h')
++			{
++			  *ptr++ = ',';
++			  *ptr = 0;
++			}
++		      else
++			{
++			  *ptr++ = ')';
++			  *ptr = 0;
++			}
++		    }
++		}
++
++	      if (! is_completion)
++		grub_putchar ('\n');
++	    }
++	  else
++	    {
++	      /* partition completions */
++	      if (part_choice == PART_CHOSEN
++		  && open_partition ()
++		  && ! IS_PC_SLICE_TYPE_BSD (current_slice))
++		{
++		  unique = 1;
++		  ptr = buf + grub_strlen (buf);
++		  if (*(ptr - 1) != ')')
++		    {
++		      *ptr++ = ')';
++		      *ptr = 0;
++		    }
++		}
++	      else
++		{
++		  if (! is_completion)
++		    grub_printf (" Possible partitions are:\n");
++		  real_open_partition (1);
++		  
++		  if (is_completion && *unique_string)
++		    {
++		      ptr = buf;
++		      while (*ptr++ != ',')
++			;
++		      grub_strcpy (ptr, unique_string);
++		    }
++		}
++	    }
++	}
++      else if (ptr && *ptr == '/')
++	{
++	  /* filename completions */
++	  if (! is_completion)
++	    grub_printf (" Possible files are:");
++	  
++	  dir (buf);
++	  
++	  if (is_completion && *unique_string)
++	    {
++	      ptr += grub_strlen (ptr);
++	      while (*ptr != '/')
++		ptr--;
++	      ptr++;
++	      
++	      grub_strcpy (ptr, unique_string);
++	      
++	      if (unique == 1)
++		{
++		  ptr += grub_strlen (unique_string);
++
++		  /* Check if the file UNIQUE_STRING is a directory.  */
++		  *ptr = '/';
++		  *(ptr + 1) = 0;
++		  
++		  dir (buf);
++		  
++		  /* Restore the original unique value.  */
++		  unique = 1;
++		  
++		  if (errnum)
++		    {
++		      /* Regular file */
++		      errnum = 0;
++		      *ptr = ' ';
++		      *(ptr + 1) = 0;
++		    }
++		}
++	    }
++	  
++	  if (! is_completion)
++	    grub_putchar ('\n');
++	}
++      else
++	errnum = ERR_BAD_FILENAME;
++    }
++
++  print_error ();
++  do_completion = 0;
++  if (errnum)
++    return -1;
++  else
++    return unique - 1;
++}
++#endif /* STAGE1_5 */
++
++
++/*
++ *  This is the generic file open function.
++ */
++
++int
++grub_open (char *filename)
++{
++#ifndef NO_DECOMPRESSION
++  compressed_file = 0;
++#endif /* NO_DECOMPRESSION */
++
++  /* if any "dir" function uses/sets filepos, it must
++     set it to zero before returning if opening a file! */
++  filepos = 0;
++
++  if (!(filename = setup_part (filename)))
++    return 0;
++
++#ifndef NO_BLOCK_FILES
++  block_file = 0;
++#endif /* NO_BLOCK_FILES */
++
++  /* This accounts for partial filesystem implementations. */
++  fsmax = MAXINT;
++
++  if (*filename != '/')
++    {
++#ifndef NO_BLOCK_FILES
++      char *ptr = filename;
++      int tmp, list_addr = BLK_BLKLIST_START;
++      filemax = 0;
++
++      while (list_addr < BLK_MAX_ADDR)
++	{
++	  tmp = 0;
++	  safe_parse_maxint (&ptr, &tmp);
++	  errnum = 0;
++
++	  if (*ptr != '+')
++	    {
++	      if ((*ptr && *ptr != '/' && !isspace (*ptr))
++		  || tmp == 0 || tmp > filemax)
++		errnum = ERR_BAD_FILENAME;
++	      else
++		filemax = tmp;
++
++	      break;
++	    }
++
++	  /* since we use the same filesystem buffer, mark it to
++	     be remounted */
++	  fsys_type = NUM_FSYS;
++
++	  BLK_BLKSTART (list_addr) = tmp;
++	  ptr++;
++
++	  if (!safe_parse_maxint (&ptr, &tmp)
++	      || tmp == 0
++	      || (*ptr && *ptr != ',' && *ptr != '/' && !isspace (*ptr)))
++	    {
++	      errnum = ERR_BAD_FILENAME;
++	      break;
++	    }
++
++	  BLK_BLKLENGTH (list_addr) = tmp;
++
++	  filemax += (tmp * SECTOR_SIZE);
++	  list_addr += BLK_BLKLIST_INC_VAL;
++
++	  if (*ptr != ',')
++	    break;
++
++	  ptr++;
++	}
++
++      if (list_addr < BLK_MAX_ADDR && ptr != filename && !errnum)
++	{
++	  block_file = 1;
++	  BLK_CUR_FILEPOS = 0;
++	  BLK_CUR_BLKLIST = BLK_BLKLIST_START;
++	  BLK_CUR_BLKNUM = 0;
++
++#ifndef NO_DECOMPRESSION
++	  return gunzip_test_header ();
++#else /* NO_DECOMPRESSION */
++	  return 1;
++#endif /* NO_DECOMPRESSION */
++	}
++#else /* NO_BLOCK_FILES */
++      errnum = ERR_BAD_FILENAME;
++#endif /* NO_BLOCK_FILES */
++    }
++
++  if (!errnum && fsys_type == NUM_FSYS)
++    errnum = ERR_FSYS_MOUNT;
++
++# ifndef STAGE1_5
++  /* set "dir" function to open a file */
++  print_possibilities = 0;
++# endif
++
++  if (!errnum && (*(fsys_table[fsys_type].dir_func)) (filename))
++    {
++#ifndef NO_DECOMPRESSION
++      return gunzip_test_header ();
++#else /* NO_DECOMPRESSION */
++      return 1;
++#endif /* NO_DECOMPRESSION */
++    }
++
++  return 0;
++}
++
++
++int
++grub_read (char *buf, int len)
++{
++  /* Make sure "filepos" is a sane value */
++  if ((filepos < 0) || (filepos > filemax))
++    filepos = filemax;
++
++  /* Make sure "len" is a sane value */
++  if ((len < 0) || (len > (filemax - filepos)))
++    len = filemax - filepos;
++
++  /* if target file position is past the end of
++     the supported/configured filesize, then
++     there is an error */
++  if (filepos + len > fsmax)
++    {
++      errnum = ERR_FILELENGTH;
++      return 0;
++    }
++
++#ifndef NO_DECOMPRESSION
++  if (compressed_file)
++    return gunzip_read (buf, len);
++#endif /* NO_DECOMPRESSION */
++
++#ifndef NO_BLOCK_FILES
++  if (block_file)
++    {
++      int size, off, ret = 0;
++
++      while (len && !errnum)
++	{
++	  /* we may need to look for the right block in the list(s) */
++	  if (filepos < BLK_CUR_FILEPOS)
++	    {
++	      BLK_CUR_FILEPOS = 0;
++	      BLK_CUR_BLKLIST = BLK_BLKLIST_START;
++	      BLK_CUR_BLKNUM = 0;
++	    }
++
++	  /* run BLK_CUR_FILEPOS up to filepos */
++	  while (filepos > BLK_CUR_FILEPOS)
++	    {
++	      if ((filepos - (BLK_CUR_FILEPOS & ~(SECTOR_SIZE - 1)))
++		  >= SECTOR_SIZE)
++		{
++		  BLK_CUR_FILEPOS += SECTOR_SIZE;
++		  BLK_CUR_BLKNUM++;
++
++		  if (BLK_CUR_BLKNUM >= BLK_BLKLENGTH (BLK_CUR_BLKLIST))
++		    {
++		      BLK_CUR_BLKLIST += BLK_BLKLIST_INC_VAL;
++		      BLK_CUR_BLKNUM = 0;
++		    }
++		}
++	      else
++		BLK_CUR_FILEPOS = filepos;
++	    }
++
++	  off = filepos & (SECTOR_SIZE - 1);
++	  size = ((BLK_BLKLENGTH (BLK_CUR_BLKLIST) - BLK_CUR_BLKNUM)
++		  * SECTOR_SIZE) - off;
++	  if (size > len)
++	    size = len;
++
++	  disk_read_func = disk_read_hook;
++
++	  /* read current block and put it in the right place in memory */
++	  devread (BLK_BLKSTART (BLK_CUR_BLKLIST) + BLK_CUR_BLKNUM,
++		   off, size, buf);
++
++	  disk_read_func = NULL;
++
++	  len -= size;
++	  filepos += size;
++	  ret += size;
++	  buf += size;
++	}
++
++      if (errnum)
++	ret = 0;
++
++      return ret;
++    }
++#endif /* NO_BLOCK_FILES */
++
++  if (fsys_type == NUM_FSYS)
++    {
++      errnum = ERR_FSYS_MOUNT;
++      return 0;
++    }
++
++  return (*(fsys_table[fsys_type].read_func)) (buf, len);
++}
++
++#ifndef STAGE1_5
++/* Reposition a file offset.  */
++int
++grub_seek (int offset)
++{
++  if (offset > filemax || offset < 0)
++    return -1;
++
++  filepos = offset;
++  return offset;
++}
++
++int
++dir (char *dirname)
++{
++#ifndef NO_DECOMPRESSION
++  compressed_file = 0;
++#endif /* NO_DECOMPRESSION */
++
++  if (!(dirname = setup_part (dirname)))
++    return 0;
++
++  if (*dirname != '/')
++    errnum = ERR_BAD_FILENAME;
++
++  if (fsys_type == NUM_FSYS)
++    errnum = ERR_FSYS_MOUNT;
++
++  if (errnum)
++    return 0;
++
++  /* set "dir" function to list completions */
++  print_possibilities = 1;
++
++  return (*(fsys_table[fsys_type].dir_func)) (dirname);
++}
++#endif /* STAGE1_5 */
++
++void 
++grub_close (void)
++{
++#ifndef NO_BLOCK_FILES
++  if (block_file)
++    return;
++#endif /* NO_BLOCK_FILES */
++  
++  if (fsys_table[fsys_type].close_func != 0)
++    (*(fsys_table[fsys_type].close_func)) ();
++}
+diff -ruN grub-0.94.orig/stage2/filesys.h stage2/filesys.h
+--- grub-0.94.orig/stage2/filesys.h	Wed Feb 11 00:22:12 2004
++++ stage2/filesys.h	Wed Feb 11 00:22:29 2004
+@@ -30,6 +30,16 @@
+ #define FSYS_FFS_NUM 0
+ #endif
+ 
++#ifdef FSYS_UFS2
++#define FSYS_UFS2_NUM 1
++int ufs2_mount (void);
++int ufs2_read (char *buf, int len);
++int ufs2_dir (char *dirname);
++int ufs2_embed (int *start_sector, int needed_sectors);
++#else
++#define FSYS_UFS2_NUM 0
++#endif
++
+ #ifdef FSYS_FAT
+ #define FSYS_FAT_NUM 1
+ int fat_mount (void);
+@@ -109,6 +119,7 @@
+ #define NUM_FSYS	\
+   (FSYS_FFS_NUM + FSYS_FAT_NUM + FSYS_EXT2FS_NUM + FSYS_MINIX_NUM	\
+    + FSYS_REISERFS_NUM + FSYS_VSTAFS_NUM + FSYS_JFS_NUM + FSYS_XFS_NUM	\
++   + FSYS_UFS2_NUM \
+    + FSYS_TFTP_NUM)
+ #endif
+ 
+diff -ruN grub-0.94.orig/stage2/filesys.h.orig stage2/filesys.h.orig
+--- grub-0.94.orig/stage2/filesys.h.orig	Thu Jan  1 03:00:00 1970
++++ stage2/filesys.h.orig	Wed Jul  9 15:45:52 2003
+@@ -0,0 +1,146 @@
++/* filesys.h - abstract filesystem interface */
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 1999, 2000, 2001  Free Software Foundation, Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#include "pc_slice.h"
++
++#ifdef FSYS_FFS
++#define FSYS_FFS_NUM 1
++int ffs_mount (void);
++int ffs_read (char *buf, int len);
++int ffs_dir (char *dirname);
++int ffs_embed (int *start_sector, int needed_sectors);
++#else
++#define FSYS_FFS_NUM 0
++#endif
++
++#ifdef FSYS_FAT
++#define FSYS_FAT_NUM 1
++int fat_mount (void);
++int fat_read (char *buf, int len);
++int fat_dir (char *dirname);
++#else
++#define FSYS_FAT_NUM 0
++#endif
++
++#ifdef FSYS_EXT2FS
++#define FSYS_EXT2FS_NUM 1
++int ext2fs_mount (void);
++int ext2fs_read (char *buf, int len);
++int ext2fs_dir (char *dirname);
++#else
++#define FSYS_EXT2FS_NUM 0
++#endif
++
++#ifdef FSYS_MINIX
++#define FSYS_MINIX_NUM 1
++int minix_mount (void);
++int minix_read (char *buf, int len);
++int minix_dir (char *dirname);
++#else
++#define FSYS_MINIX_NUM 0
++#endif
++
++#ifdef FSYS_REISERFS
++#define FSYS_REISERFS_NUM 1
++int reiserfs_mount (void);
++int reiserfs_read (char *buf, int len);
++int reiserfs_dir (char *dirname);
++int reiserfs_embed (int *start_sector, int needed_sectors);
++#else
++#define FSYS_REISERFS_NUM 0
++#endif
++
++#ifdef FSYS_VSTAFS
++#define FSYS_VSTAFS_NUM 1
++int vstafs_mount (void);
++int vstafs_read (char *buf, int len);
++int vstafs_dir (char *dirname);
++#else
++#define FSYS_VSTAFS_NUM 0
++#endif
++
++#ifdef FSYS_JFS
++#define FSYS_JFS_NUM 1
++int jfs_mount (void);
++int jfs_read (char *buf, int len);
++int jfs_dir (char *dirname);
++int jfs_embed (int *start_sector, int needed_sectors);
++#else
++#define FSYS_JFS_NUM 0
++#endif
++
++#ifdef FSYS_XFS
++#define FSYS_XFS_NUM 1
++int xfs_mount (void);
++int xfs_read (char *buf, int len);
++int xfs_dir (char *dirname);
++#else
++#define FSYS_XFS_NUM 0
++#endif
++
++#ifdef FSYS_TFTP
++#define FSYS_TFTP_NUM 1
++int tftp_mount (void);
++int tftp_read (char *buf, int len);
++int tftp_dir (char *dirname);
++void tftp_close (void);
++#else
++#define FSYS_TFTP_NUM 0
++#endif
++
++#ifndef NUM_FSYS
++#define NUM_FSYS	\
++  (FSYS_FFS_NUM + FSYS_FAT_NUM + FSYS_EXT2FS_NUM + FSYS_MINIX_NUM	\
++   + FSYS_REISERFS_NUM + FSYS_VSTAFS_NUM + FSYS_JFS_NUM + FSYS_XFS_NUM	\
++   + FSYS_TFTP_NUM)
++#endif
++
++/* defines for the block filesystem info area */
++#ifndef NO_BLOCK_FILES
++#define BLK_CUR_FILEPOS      (*((int*)FSYS_BUF))
++#define BLK_CUR_BLKLIST      (*((int*)(FSYS_BUF+4)))
++#define BLK_CUR_BLKNUM       (*((int*)(FSYS_BUF+8)))
++#define BLK_MAX_ADDR         (FSYS_BUF+0x7FF9)
++#define BLK_BLKSTART(l)      (*((int*)l))
++#define BLK_BLKLENGTH(l)     (*((int*)(l+4)))
++#define BLK_BLKLIST_START    (FSYS_BUF+12)
++#define BLK_BLKLIST_INC_VAL  8
++#endif /* NO_BLOCK_FILES */
++
++/* this next part is pretty ugly, but it keeps it in one place! */
++
++struct fsys_entry
++{
++  char *name;
++  int (*mount_func) (void);
++  int (*read_func) (char *buf, int len);
++  int (*dir_func) (char *dirname);
++  void (*close_func) (void);
++  int (*embed_func) (int *start_sector, int needed_sectors);
++};
++
++#ifdef STAGE1_5
++# define print_possibilities 0
++#else
++extern int print_possibilities;
++#endif
++
++extern int fsmax;
++extern struct fsys_entry fsys_table[NUM_FSYS + 1];
+diff -ruN grub-0.94.orig/stage2/fsys_ufs2.c stage2/fsys_ufs2.c
+--- grub-0.94.orig/stage2/fsys_ufs2.c	Thu Jan  1 03:00:00 1970
++++ stage2/fsys_ufs2.c	Wed Feb 11 00:22:29 2004
+@@ -0,0 +1,305 @@
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++/*
++ * Elements of this file were originally from the FreeBSD "biosboot"
++ * bootloader file "disk.c" dated 4/12/95.
++ *
++ * The license and header comments from that file are included here.
++ */
++
++/*
++ * Mach Operating System
++ * Copyright (c) 1992, 1991 Carnegie Mellon University
++ * All Rights Reserved.
++ *
++ * Permission to use, copy, modify and distribute this software and its
++ * documentation is hereby granted, provided that both the copyright
++ * notice and this permission notice appear in all copies of the
++ * software, derivative works or modified versions, and any portions
++ * thereof, and that both notices appear in supporting documentation.
++ *
++ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
++ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
++ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
++ *
++ * Carnegie Mellon requests users of this software to return to
++ *
++ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
++ *  School of Computer Science
++ *  Carnegie Mellon University
++ *  Pittsburgh PA 15213-3890
++ *
++ * any improvements or extensions that they make and grant Carnegie Mellon
++ * the rights to redistribute these changes.
++ *
++ *	from: Mach, Revision 2.2  92/04/04  11:35:49  rpd
++ *
++ */
++
++#ifdef FSYS_UFS2
++
++#include "shared.h"
++#include "filesys.h"
++
++#include "ufs2.h"
++
++/* used for filesystem map blocks */
++static int mapblock;
++static int mapblock_offset;
++static int mapblock_bsize;
++
++/* pointer to superblock */
++#define SUPERBLOCK ((struct fs *) ( FSYS_BUF + 8192 ))
++#define INODE ((struct ufs2_dinode *) ( FSYS_BUF + 16384 ))
++#define MAPBUF ( FSYS_BUF + 24576 )
++#define MAPBUF_LEN 8192
++
++  
++int
++ufs2_mount (void)
++{
++  int retval = 1;
++
++  if ((((current_drive & 0x80) || (current_slice != 0))
++       && ! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_BSDFFS))
++      || part_length < (SBLOCK_UFS2 + (SBLOCKSIZE / DEV_BSIZE))
++      || !devread (0, SBLOCK_UFS2, SBLOCKSIZE, (char *) SUPERBLOCK)
++      || SUPERBLOCK->fs_magic != FS_UFS2_MAGIC)
++    retval = 0;
++
++  mapblock = -1;
++  mapblock_offset = -1;
++  
++  return retval;
++}
++
++static int64_t
++block_map (int file_block)
++{
++  int bnum, offset, bsize;
++  
++  if (file_block < NDADDR)
++    return (INODE->di_db[file_block]);
++  
++  /* If the blockmap loaded does not include FILE_BLOCK,
++     load a new blockmap.  */
++  if ((bnum = fsbtodb (SUPERBLOCK, INODE->di_ib[0])) != mapblock
++      || (mapblock_offset <= bnum && bnum <= mapblock_offset + mapblock_bsize))
++    {
++      if (MAPBUF_LEN < SUPERBLOCK->fs_bsize)
++	{
++	  offset = ((file_block - NDADDR) % NINDIR (SUPERBLOCK));
++	  bsize = MAPBUF_LEN;
++	  
++	  if (offset + MAPBUF_LEN > SUPERBLOCK->fs_bsize)
++	    offset = (SUPERBLOCK->fs_bsize - MAPBUF_LEN) / sizeof (int);
++	}
++      else
++	{
++	  bsize = SUPERBLOCK->fs_bsize;
++	  offset = 0;
++	}
++      
++      if (! devread (bnum, offset * sizeof (int), bsize, (char *) MAPBUF))
++	{
++	  mapblock = -1;
++	  mapblock_bsize = -1;
++	  mapblock_offset = -1;
++	  errnum = ERR_FSYS_CORRUPT;
++	  return -1;
++	}
++      
++      mapblock = bnum;
++      mapblock_bsize = bsize;
++      mapblock_offset = offset;
++    }
++  
++  return (((int64_t *) MAPBUF)[((file_block - NDADDR) % NINDIR (SUPERBLOCK))
++			  - mapblock_offset]);
++}
++
++int
++ufs2_read (char *buf, int len)
++{
++  int logno, off, size, ret = 0;
++  int64_t map;
++
++  while (len && !errnum)
++    {
++      off = blkoff (SUPERBLOCK, filepos);
++      logno = lblkno (SUPERBLOCK, filepos);
++      size = blksize (SUPERBLOCK, INODE, logno);
++
++      if ((map = block_map (logno)) < 0)
++	break; 
++
++      size -= off;
++
++      if (size > len)
++	size = len;
++
++      disk_read_func = disk_read_hook;
++
++      devread (fsbtodb (SUPERBLOCK, map), off, size, buf);
++
++      disk_read_func = NULL;
++
++      buf += size;
++      len -= size;
++      filepos += size;
++      ret += size;
++    }
++
++  if (errnum)
++    ret = 0;
++
++  return ret;
++}
++
++int
++ufs2_dir (char *dirname)
++{
++  char *rest, ch;
++  int block, off, loc, ino = ROOTINO;
++  int64_t map;
++  struct direct *dp;
++
++/* main loop to find destination inode */
++loop:
++
++  /* load current inode (defaults to the root inode) */
++
++	if (!devread (fsbtodb (SUPERBLOCK, ino_to_fsba (SUPERBLOCK, ino)),
++								ino % (SUPERBLOCK->fs_inopb) * sizeof (struct ufs2_dinode),
++								sizeof (struct ufs2_dinode), (char *) INODE))
++			return 0;			/* XXX what return value? */
++
++  /* if we have a real file (and we're not just printing possibilities),
++     then this is where we want to exit */
++
++  if (!*dirname || isspace (*dirname))
++    {
++      if ((INODE->di_mode & IFMT) != IFREG)
++	{
++	  errnum = ERR_BAD_FILETYPE;
++	  return 0;
++	}
++
++      filemax = INODE->di_size;
++
++      /* incomplete implementation requires this! */
++      fsmax = (NDADDR + NINDIR (SUPERBLOCK)) * SUPERBLOCK->fs_bsize;
++      return 1;
++    }
++
++  /* continue with file/directory name interpretation */
++
++  while (*dirname == '/')
++    dirname++;
++
++  if (!(INODE->di_size) || ((INODE->di_mode & IFMT) != IFDIR))
++    {
++      errnum = ERR_BAD_FILETYPE;
++      return 0;
++    }
++
++  for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
++
++  *rest = 0;
++  loc = 0;
++
++  /* loop for reading a the entries in a directory */
++
++  do
++    {
++      if (loc >= INODE->di_size)
++	{
++#if 0
++	  putchar ('\n');
++#endif
++
++	  if (print_possibilities < 0)
++	    return 1;
++
++	  errnum = ERR_FILE_NOT_FOUND;
++	  *rest = ch;
++	  return 0;
++	}
++
++      if (!(off = blkoff (SUPERBLOCK, loc)))
++	{
++	  block = lblkno (SUPERBLOCK, loc);
++
++	  if ((map = block_map (block)) < 0
++	      || !devread (fsbtodb (SUPERBLOCK, map), 0,
++			   blksize (SUPERBLOCK, INODE, block),
++			   (char *) FSYS_BUF))
++	    {
++	      errnum = ERR_FSYS_CORRUPT;
++	      *rest = ch;
++	      return 0;
++	    }
++	}
++
++      dp = (struct direct *) (FSYS_BUF + off);
++      loc += dp->d_reclen;
++
++#ifndef STAGE1_5
++      if (dp->d_ino && print_possibilities && ch != '/'
++	  && (!*dirname || substring (dirname, dp->d_name) <= 0))
++	{
++	  if (print_possibilities > 0)
++	    print_possibilities = -print_possibilities;
++
++	  print_a_completion (dp->d_name);
++	}
++#endif /* STAGE1_5 */
++    }
++  while (!dp->d_ino || (substring (dirname, dp->d_name) != 0
++			|| (print_possibilities && ch != '/')));
++
++  /* only get here if we have a matching directory entry */
++
++  ino = dp->d_ino;
++  *(dirname = rest) = ch;
++
++  /* go back to main loop at top of function */
++  goto loop;
++}
++
++int
++ufs2_embed (int *start_sector, int needed_sectors)
++{
++  /* XXX: I don't know if this is really correct. Someone who is
++     familiar with BSD should check for this.  */
++  if (needed_sectors > 14)
++    return 0;
++  
++  *start_sector = 1;
++#if 1
++  /* FIXME: Disable the embedding in FFS until someone checks if
++     the code above is correct.  */
++  return 0;
++#else
++  return 1;
++#endif
++}
++
++#endif /* FSYS_UFS2 */
+diff -ruN grub-0.94.orig/stage2/shared.h stage2/shared.h
+--- grub-0.94.orig/stage2/shared.h	Wed Feb 11 00:22:12 2004
++++ stage2/shared.h	Wed Feb 11 00:22:29 2004
+@@ -205,6 +205,7 @@
+ #define STAGE2_ID_VSTAFS_STAGE1_5	6
+ #define STAGE2_ID_JFS_STAGE1_5		7
+ #define STAGE2_ID_XFS_STAGE1_5		8
++#define STAGE2_ID_UFS2_STAGE1_5         9
+ 
+ #ifndef STAGE1_5
+ # define STAGE2_ID	STAGE2_ID_STAGE2
+@@ -225,6 +226,8 @@
+ #  define STAGE2_ID	STAGE2_ID_JFS_STAGE1_5
+ # elif defined(FSYS_XFS)
+ #  define STAGE2_ID	STAGE2_ID_XFS_STAGE1_5
++# elif defined(FSYS_UFS2)
++#  define STAGE2_ID	STAGE2_ID_UFS2_STAGE1_5
+ # else
+ #  error "unknown Stage 2"
+ # endif
+diff -ruN grub-0.94.orig/stage2/shared.h.orig stage2/shared.h.orig
+--- grub-0.94.orig/stage2/shared.h.orig	Thu Jan  1 03:00:00 1970
++++ stage2/shared.h.orig	Sun Jan 11 12:39:22 2004
+@@ -0,0 +1,980 @@
++/* shared.h - definitions used in all GRUB-specific code */
++/*
++ *  GRUB  --  GRand Unified Bootloader
++ *  Copyright (C) 1999,2000,2001,2002,2003,2004  Free Software Foundation, Inc.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License as published by
++ *  the Free Software Foundation; either version 2 of the License, or
++ *  (at your option) any later version.
++ *
++ *  This program is distributed in the hope that it will be useful,
++ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
++ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ *  GNU General Public License for more details.
++ *
++ *  You should have received a copy of the GNU General Public License
++ *  along with this program; if not, write to the Free Software
++ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++/*
++ *  Generic defines to use anywhere
++ */
++
++#ifndef GRUB_SHARED_HEADER
++#define GRUB_SHARED_HEADER	1
++
++#include <config.h>
++
++/* Add an underscore to a C symbol in assembler code if needed. */
++#ifdef HAVE_ASM_USCORE
++# define EXT_C(sym) _ ## sym
++#else
++# define EXT_C(sym) sym
++#endif
++
++/* Maybe redirect memory requests through grub_scratch_mem. */
++#ifdef GRUB_UTIL
++extern char *grub_scratch_mem;
++# define RAW_ADDR(x) ((x) + (int) grub_scratch_mem)
++# define RAW_SEG(x) (RAW_ADDR ((x) << 4) >> 4)
++#else
++# define RAW_ADDR(x) (x)
++# define RAW_SEG(x) (x)
++#endif
++
++/*
++ *  Integer sizes
++ */
++
++#define MAXINT     0x7FFFFFFF
++
++/* Maximum command line size. Before you blindly increase this value,
++   see the comment in char_io.c (get_cmdline).  */
++#define MAX_CMDLINE 1600
++#define NEW_HEAPSIZE 1500
++
++/* 512-byte scratch area */
++#define SCRATCHADDR  RAW_ADDR (0x77e00)
++#define SCRATCHSEG   RAW_SEG (0x77e0)
++
++/*
++ *  This is the location of the raw device buffer.  It is 31.5K
++ *  in size.
++ */
++
++#define BUFFERLEN   0x7e00
++#define BUFFERADDR  RAW_ADDR (0x70000)
++#define BUFFERSEG   RAW_SEG (0x7000)
++
++#define BOOT_PART_TABLE	RAW_ADDR (0x07be)
++
++/*
++ *  BIOS disk defines
++ */
++#define BIOSDISK_READ		    0x0
++#define BIOSDISK_WRITE		    0x1
++#define BIOSDISK_ERROR_GEOMETRY     0x100
++#define BIOSDISK_FLAG_LBA_EXTENSION 0x1
++
++/*
++ *  This is the filesystem (not raw device) buffer.
++ *  It is 32K in size, do not overrun!
++ */
++
++#define FSYS_BUFLEN  0x8000
++#define FSYS_BUF RAW_ADDR (0x68000)
++
++/* Command-line buffer for Multiboot kernels and modules. This area
++   includes the area into which Stage 1.5 and Stage 1 are loaded, but
++   that's no problem.  */
++#define MB_CMDLINE_BUF		RAW_ADDR (0x2000)
++#define MB_CMDLINE_BUFLEN	0x6000
++
++/* The buffer for the password.  */
++#define PASSWORD_BUF		RAW_ADDR (0x78000)
++#define PASSWORD_BUFLEN		0x200
++
++/* The buffer for the command-line.  */
++#define CMDLINE_BUF		(PASSWORD_BUF + PASSWORD_BUFLEN)
++#define CMDLINE_BUFLEN		MAX_CMDLINE
++
++/* The kill buffer for the command-line.  */
++#define KILL_BUF		(CMDLINE_BUF + CMDLINE_BUFLEN)
++#define KILL_BUFLEN		MAX_CMDLINE
++
++/* The history buffer for the command-line.  */
++#define HISTORY_BUF		(KILL_BUF + KILL_BUFLEN)
++#define HISTORY_SIZE		5
++#define HISTORY_BUFLEN		(MAX_CMDLINE * HISTORY_SIZE)
++
++/* The buffer for the completion.  */
++#define COMPLETION_BUF		(HISTORY_BUF + HISTORY_BUFLEN)
++#define COMPLETION_BUFLEN	MAX_CMDLINE
++
++/* The buffer for the unique string.  */
++#define UNIQUE_BUF		(COMPLETION_BUF + COMPLETION_BUFLEN)
++#define UNIQUE_BUFLEN		MAX_CMDLINE
++
++/* The buffer for the menu entries.  */
++#define MENU_BUF		(UNIQUE_BUF + UNIQUE_BUFLEN)
++#define MENU_BUFLEN		(0x8000 + PASSWORD_BUF - UNIQUE_BUF)
++
++/* The size of the drive map.  */
++#define DRIVE_MAP_SIZE		8
++
++/* The size of the key map.  */
++#define KEY_MAP_SIZE		128
++
++/* The size of the io map.  */
++#define IO_MAP_SIZE		128
++
++/*
++ *  Linux setup parameters
++ */
++
++#define LINUX_MAGIC_SIGNATURE		0x53726448	/* "HdrS" */
++#define LINUX_DEFAULT_SETUP_SECTS	4
++#define LINUX_FLAG_CAN_USE_HEAP		0x80
++#define LINUX_INITRD_MAX_ADDRESS	0x38000000
++#define LINUX_MAX_SETUP_SECTS		64
++#define LINUX_BOOT_LOADER_TYPE		0x71
++#define LINUX_HEAP_END_OFFSET		(0x9000 - 0x200)
++
++#define LINUX_BZIMAGE_ADDR		RAW_ADDR (0x100000)
++#define LINUX_ZIMAGE_ADDR		RAW_ADDR (0x10000)
++#define LINUX_OLD_REAL_MODE_ADDR	RAW_ADDR (0x90000)
++#define LINUX_SETUP_STACK		0x9000
++
++#define LINUX_FLAG_BIG_KERNEL		0x1
++
++/* Linux's video mode selection support. Actually I hate it!  */
++#define LINUX_VID_MODE_NORMAL		0xFFFF
++#define LINUX_VID_MODE_EXTENDED		0xFFFE
++#define LINUX_VID_MODE_ASK		0xFFFD
++
++#define LINUX_CL_OFFSET			0x9000
++#define LINUX_CL_END_OFFSET		0x90FF
++#define LINUX_SETUP_MOVE_SIZE		0x9100
++#define LINUX_CL_MAGIC			0xA33F
++
++/*
++ *  General disk stuff
++ */
++
++#define SECTOR_SIZE		0x200
++#define SECTOR_BITS		9
++#define BIOS_FLAG_FIXED_DISK	0x80
++
++#define BOOTSEC_LOCATION		RAW_ADDR (0x7C00)
++#define BOOTSEC_SIGNATURE		0xAA55
++#define BOOTSEC_BPB_OFFSET		0x3
++#define BOOTSEC_BPB_LENGTH		0x3B
++#define BOOTSEC_BPB_SYSTEM_ID		0x3
++#define BOOTSEC_BPB_HIDDEN_SECTORS	0x1C
++#define BOOTSEC_PART_OFFSET		0x1BE
++#define BOOTSEC_PART_LENGTH		0x40
++#define BOOTSEC_SIG_OFFSET		0x1FE
++#define BOOTSEC_LISTSIZE		8
++
++/* Not bad, perhaps.  */
++#define NETWORK_DRIVE	0x20
++
++/*
++ *  GRUB specific information
++ *    (in LSB order)
++ */
++
++#include <stage1.h>
++
++#define STAGE2_VER_MAJ_OFFS	0x6
++#define STAGE2_INSTALLPART	0x8
++#define STAGE2_SAVED_ENTRYNO	0xc
++#define STAGE2_STAGE2_ID	0x10
++#define STAGE2_FORCE_LBA	0x11
++#define STAGE2_VER_STR_OFFS	0x12
++
++/* Stage 2 identifiers */
++#define STAGE2_ID_STAGE2		0
++#define STAGE2_ID_FFS_STAGE1_5		1
++#define STAGE2_ID_E2FS_STAGE1_5		2
++#define STAGE2_ID_FAT_STAGE1_5		3
++#define STAGE2_ID_MINIX_STAGE1_5	4
++#define STAGE2_ID_REISERFS_STAGE1_5	5
++#define STAGE2_ID_VSTAFS_STAGE1_5	6
++#define STAGE2_ID_JFS_STAGE1_5		7
++#define STAGE2_ID_XFS_STAGE1_5		8
++
++#ifndef STAGE1_5
++# define STAGE2_ID	STAGE2_ID_STAGE2
++#else
++# if defined(FSYS_FFS)
++#  define STAGE2_ID	STAGE2_ID_FFS_STAGE1_5
++# elif defined(FSYS_EXT2FS)
++#  define STAGE2_ID	STAGE2_ID_E2FS_STAGE1_5
++# elif defined(FSYS_FAT)
++#  define STAGE2_ID	STAGE2_ID_FAT_STAGE1_5
++# elif defined(FSYS_MINIX)
++#  define STAGE2_ID	STAGE2_ID_MINIX_STAGE1_5
++# elif defined(FSYS_REISERFS)
++#  define STAGE2_ID	STAGE2_ID_REISERFS_STAGE1_5
++# elif defined(FSYS_VSTAFS)
++#  define STAGE2_ID	STAGE2_ID_VSTAFS_STAGE1_5
++# elif defined(FSYS_JFS)
++#  define STAGE2_ID	STAGE2_ID_JFS_STAGE1_5
++# elif defined(FSYS_XFS)
++#  define STAGE2_ID	STAGE2_ID_XFS_STAGE1_5
++# else
++#  error "unknown Stage 2"
++# endif
++#endif
++
++/*
++ *  defines for use when switching between real and protected mode
++ */
++
++#define CR0_PE_ON	0x1
++#define CR0_PE_OFF	0xfffffffe
++#define PROT_MODE_CSEG	0x8
++#define PROT_MODE_DSEG  0x10
++#define PSEUDO_RM_CSEG	0x18
++#define PSEUDO_RM_DSEG	0x20
++#define STACKOFF	(0x2000 - 0x10)
++#define PROTSTACKINIT   (FSYS_BUF - 0x10)
++
++
++/*
++ * Assembly code defines
++ *
++ * "EXT_C" is assumed to be defined in the Makefile by the configure
++ *   command.
++ */
++
++#define ENTRY(x) .globl EXT_C(x) ; EXT_C(x):
++#define VARIABLE(x) ENTRY(x)
++
++
++#define K_RDWR  	0x60	/* keyboard data & cmds (read/write) */
++#define K_STATUS	0x64	/* keyboard status */
++#define K_CMD		0x64	/* keybd ctlr command (write-only) */
++
++#define K_OBUF_FUL 	0x01	/* output buffer full */
++#define K_IBUF_FUL 	0x02	/* input buffer full */
++
++#define KC_CMD_WIN	0xd0	/* read  output port */
++#define KC_CMD_WOUT	0xd1	/* write output port */
++#define KB_OUTPUT_MASK  0xdd	/* enable output buffer full interrupt
++				   enable data line
++				   enable clock line */
++#define KB_A20_ENABLE   0x02
++
++/* Codes for getchar. */
++#define ASCII_CHAR(x)   ((x) & 0xFF)
++#if !defined(GRUB_UTIL) || !defined(HAVE_LIBCURSES)
++# define KEY_LEFT        0x4B00
++# define KEY_RIGHT       0x4D00
++# define KEY_UP          0x4800
++# define KEY_DOWN        0x5000
++# define KEY_IC          0x5200	/* insert char */
++# define KEY_DC          0x5300	/* delete char */
++# define KEY_BACKSPACE   0x0008
++# define KEY_HOME        0x4700
++# define KEY_END         0x4F00
++# define KEY_NPAGE       0x5100
++# define KEY_PPAGE       0x4900
++# define A_NORMAL        0x7
++# define A_REVERSE       0x70
++#elif defined(HAVE_NCURSES_CURSES_H)
++# include <ncurses/curses.h>
++#elif defined(HAVE_NCURSES_H)
++# include <ncurses.h>
++#elif defined(HAVE_CURSES_H)
++# include <curses.h>
++#endif
++
++/* In old BSD curses, A_NORMAL and A_REVERSE are not defined, so we
++   define them here if they are undefined.  */
++#ifndef A_NORMAL
++# define A_NORMAL	0
++#endif /* ! A_NORMAL */
++#ifndef A_REVERSE
++# ifdef A_STANDOUT
++#  define A_REVERSE	A_STANDOUT
++# else /* ! A_STANDOUT */
++#  define A_REVERSE	0
++# endif /* ! A_STANDOUT */
++#endif /* ! A_REVERSE */
++
++/* Define ACS_* ourselves, since the definitions are not consistent among
++   various curses implementations.  */
++#undef ACS_ULCORNER
++#undef ACS_URCORNER
++#undef ACS_LLCORNER
++#undef ACS_LRCORNER
++#undef ACS_HLINE
++#undef ACS_VLINE
++#undef ACS_LARROW
++#undef ACS_RARROW
++#undef ACS_UARROW
++#undef ACS_DARROW
++
++#define ACS_ULCORNER	'+'
++#define ACS_URCORNER	'+'
++#define ACS_LLCORNER	'+'
++#define ACS_LRCORNER	'+'
++#define ACS_HLINE	'-'
++#define ACS_VLINE	'|'
++#define ACS_LARROW	'<'
++#define ACS_RARROW	'>'
++#define ACS_UARROW	'^'
++#define ACS_DARROW	'v'
++
++/* Special graphics characters for IBM displays. */
++#define DISP_UL		218
++#define DISP_UR		191
++#define DISP_LL		192
++#define DISP_LR		217
++#define DISP_HORIZ	196
++#define DISP_VERT	179
++#define DISP_LEFT	0x1b
++#define DISP_RIGHT	0x1a
++#define DISP_UP		0x18
++#define DISP_DOWN	0x19
++
++/* Remap some libc-API-compatible function names so that we prevent
++   circularararity. */
++#ifndef WITHOUT_LIBC_STUBS
++#define memmove grub_memmove
++#define memcpy grub_memmove	/* we don't need a separate memcpy */
++#define memset grub_memset
++#define isspace grub_isspace
++#define printf grub_printf
++#define sprintf grub_sprintf
++#undef putchar
++#define putchar grub_putchar
++#define strncat grub_strncat
++#define strstr grub_strstr
++#define memcmp grub_memcmp
++#define strcmp grub_strcmp
++#define tolower grub_tolower
++#define strlen grub_strlen
++#define strcpy grub_strcpy
++#endif /* WITHOUT_LIBC_STUBS */
++
++
++#ifndef ASM_FILE
++/*
++ *  Below this should be ONLY defines and other constructs for C code.
++ */
++
++/* multiboot stuff */
++
++#include "mb_header.h"
++#include "mb_info.h"
++
++/* For the Linux/i386 boot protocol version 2.03.  */
++struct linux_kernel_header
++{
++  char code1[0x0020];
++  unsigned short cl_magic;		/* Magic number 0xA33F */
++  unsigned short cl_offset;		/* The offset of command line */
++  char code2[0x01F1 - 0x0020 - 2 - 2];
++  unsigned char setup_sects;		/* The size of the setup in sectors */
++  unsigned short root_flags;		/* If the root is mounted readonly */
++  unsigned short syssize;		/* obsolete */
++  unsigned short swap_dev;		/* obsolete */
++  unsigned short ram_size;		/* obsolete */
++  unsigned short vid_mode;		/* Video mode control */
++  unsigned short root_dev;		/* Default root device number */
++  unsigned short boot_flag;		/* 0xAA55 magic number */
++  unsigned short jump;			/* Jump instruction */
++  unsigned long header;			/* Magic signature "HdrS" */
++  unsigned short version;		/* Boot protocol version supported */
++  unsigned long realmode_swtch;		/* Boot loader hook */
++  unsigned long start_sys;		/* Points to kernel version string */
++  unsigned char type_of_loader;		/* Boot loader identifier */
++  unsigned char loadflags;		/* Boot protocol option flags */
++  unsigned short setup_move_size;	/* Move to high memory size */
++  unsigned long code32_start;		/* Boot loader hook */
++  unsigned long ramdisk_image;		/* initrd load address */
++  unsigned long ramdisk_size;		/* initrd size */
++  unsigned long bootsect_kludge;	/* obsolete */
++  unsigned short heap_end_ptr;		/* Free memory after setup end */
++  unsigned short pad1;			/* Unused */
++  char *cmd_line_ptr;			/* Points to the kernel command line */
++  unsigned long initrd_addr_max;	/* The highest address of initrd */
++} __attribute__ ((packed));
++
++/* Memory map address range descriptor used by GET_MMAP_ENTRY. */
++struct mmar_desc
++{
++  unsigned long desc_len;	/* Size of this descriptor. */
++  unsigned long long addr;	/* Base address. */
++  unsigned long long length;	/* Length in bytes. */
++  unsigned long type;		/* Type of address range. */
++} __attribute__ ((packed));
++
++/* VBE controller information.  */
++struct vbe_controller
++{
++  unsigned char signature[4];
++  unsigned short version;
++  unsigned long oem_string;
++  unsigned long capabilities;
++  unsigned long video_mode;
++  unsigned short total_memory;
++  unsigned short oem_software_rev;
++  unsigned long oem_vendor_name;
++  unsigned long oem_product_name;
++  unsigned long oem_product_rev;
++  unsigned char reserved[222];
++  unsigned char oem_data[256];
++} __attribute__ ((packed));
++
++/* VBE mode information.  */
++struct vbe_mode
++{
++  unsigned short mode_attributes;
++  unsigned char win_a_attributes;
++  unsigned char win_b_attributes;
++  unsigned short win_granularity;
++  unsigned short win_size;
++  unsigned short win_a_segment;
++  unsigned short win_b_segment;
++  unsigned long win_func;
++  unsigned short bytes_per_scanline;
++
++  /* >=1.2 */
++  unsigned short x_resolution;
++  unsigned short y_resolution;
++  unsigned char x_char_size;
++  unsigned char y_char_size;
++  unsigned char number_of_planes;
++  unsigned char bits_per_pixel;
++  unsigned char number_of_banks;
++  unsigned char memory_model;
++  unsigned char bank_size;
++  unsigned char number_of_image_pages;
++  unsigned char reserved0;
++
++  /* direct color */
++  unsigned char red_mask_size;
++  unsigned char red_field_position;
++  unsigned char green_mask_size;
++  unsigned char green_field_position;
++  unsigned char blue_mask_size;
++  unsigned char blue_field_position;
++  unsigned char reserved_mask_size;
++  unsigned char reserved_field_position;
++  unsigned char direct_color_mode_info;
++
++  /* >=2.0 */
++  unsigned long phys_base;
++  unsigned long reserved1;
++  unsigned short reversed2;
++
++  /* >=3.0 */
++  unsigned short linear_bytes_per_scanline;
++  unsigned char banked_number_of_image_pages;
++  unsigned char linear_number_of_image_pages;
++  unsigned char linear_red_mask_size;
++  unsigned char linear_red_field_position;
++  unsigned char linear_green_mask_size;
++  unsigned char linear_green_field_position;
++  unsigned char linear_blue_mask_size;
++  unsigned char linear_blue_field_position;
++  unsigned char linear_reserved_mask_size;
++  unsigned char linear_reserved_field_position;
++  unsigned long max_pixel_clock;
++
++  unsigned char reserved3[189];
++} __attribute__ ((packed));
++
++
++#undef NULL
++#define NULL         ((void *) 0)
++
++/* Error codes (descriptions are in common.c) */
++typedef enum
++{
++  ERR_NONE = 0,
++  ERR_BAD_FILENAME,
++  ERR_BAD_FILETYPE,
++  ERR_BAD_GZIP_DATA,
++  ERR_BAD_GZIP_HEADER,
++  ERR_BAD_PART_TABLE,
++  ERR_BAD_VERSION,
++  ERR_BELOW_1MB,
++  ERR_BOOT_COMMAND,
++  ERR_BOOT_FAILURE,
++  ERR_BOOT_FEATURES,
++  ERR_DEV_FORMAT,
++  ERR_DEV_VALUES,
++  ERR_EXEC_FORMAT,
++  ERR_FILELENGTH,
++  ERR_FILE_NOT_FOUND,
++  ERR_FSYS_CORRUPT,
++  ERR_FSYS_MOUNT,
++  ERR_GEOM,
++  ERR_NEED_LX_KERNEL,
++  ERR_NEED_MB_KERNEL,
++  ERR_NO_DISK,
++  ERR_NO_PART,
++  ERR_NUMBER_PARSING,
++  ERR_OUTSIDE_PART,
++  ERR_READ,
++  ERR_SYMLINK_LOOP,
++  ERR_UNRECOGNIZED,
++  ERR_WONT_FIT,
++  ERR_WRITE,
++  ERR_BAD_ARGUMENT,
++  ERR_UNALIGNED,
++  ERR_PRIVILEGED,
++  ERR_DEV_NEED_INIT,
++  ERR_NO_DISK_SPACE,
++  ERR_NUMBER_OVERFLOW,
++
++  MAX_ERR_NUM
++} grub_error_t;
++
++extern unsigned long install_partition;
++extern unsigned long boot_drive;
++extern unsigned long install_second_sector;
++extern struct apm_info apm_bios_info;
++extern unsigned long boot_part_addr;
++extern int saved_entryno;
++extern unsigned char force_lba;
++extern char version_string[];
++extern char config_file[];
++extern unsigned long linux_text_len;
++extern char *linux_data_tmp_addr;
++extern char *linux_data_real_addr;
++
++#ifdef GRUB_UTIL
++/* If not using config file, this variable is set to zero,
++   otherwise non-zero.  */
++extern int use_config_file;
++/* If using the preset menu, this variable is set to non-zero,
++   otherwise zero.  */
++extern int use_preset_menu;
++/* If not using curses, this variable is set to zero, otherwise non-zero.  */
++extern int use_curses;
++/* The flag for verbose messages.  */
++extern int verbose;
++/* The flag for read-only.  */
++extern int read_only;
++/* The number of floppies to be probed.  */
++extern int floppy_disks;
++/* The map between BIOS drives and UNIX device file names.  */
++extern char **device_map;
++/* The filename which stores the information about a device map.  */
++extern char *device_map_file;
++/* The array of geometries.  */
++extern struct geometry *disks;
++/* Assign DRIVE to a device name DEVICE.  */
++extern void assign_device_name (int drive, const char *device);
++#endif
++
++#ifndef STAGE1_5
++/* GUI interface variables. */
++extern int fallback_entry;
++extern int default_entry;
++extern int current_entryno;
++
++/* The constants for password types.  */
++typedef enum
++{
++  PASSWORD_PLAIN,
++  PASSWORD_MD5,
++  PASSWORD_UNSUPPORTED
++}
++password_t;
++
++extern char *password;
++extern password_t password_type;
++extern int auth;
++extern char commands[];
++
++/* For `more'-like feature.  */
++extern int max_lines;
++extern int count_lines;
++extern int use_pager;
++#endif
++
++#ifndef NO_DECOMPRESSION
++extern int no_decompression;
++extern int compressed_file;
++#endif
++
++/* instrumentation variables */
++extern void (*disk_read_hook) (int, int, int);
++extern void (*disk_read_func) (int, int, int);
++
++#ifndef STAGE1_5
++/* The flag for debug mode.  */
++extern int debug;
++#endif /* STAGE1_5 */
++
++extern unsigned long current_drive;
++extern unsigned long current_partition;
++
++extern int fsys_type;
++
++/* The information for a disk geometry. The CHS information is only for
++   DOS/Partition table compatibility, and the real number of sectors is
++   stored in TOTAL_SECTORS.  */
++struct geometry
++{
++  /* The number of cylinders */
++  unsigned long cylinders;
++  /* The number of heads */
++  unsigned long heads;
++  /* The number of sectors */
++  unsigned long sectors;
++  /* The total number of sectors */
++  unsigned long total_sectors;
++  /* Flags */
++  unsigned long flags;
++};
++
++extern unsigned long part_start;
++extern unsigned long part_length;
++
++extern int current_slice;
++
++extern int buf_drive;
++extern int buf_track;
++extern struct geometry buf_geom;
++
++/* these are the current file position and maximum file position */
++extern int filepos;
++extern int filemax;
++
++/*
++ *  Common BIOS/boot data.
++ */
++
++extern struct multiboot_info mbi;
++extern unsigned long saved_drive;
++extern unsigned long saved_partition;
++#ifndef STAGE1_5
++extern unsigned long saved_mem_upper;
++extern unsigned long extended_memory;
++#endif
++
++/*
++ *  Error variables.
++ */
++
++extern grub_error_t errnum;
++extern char *err_list[];
++
++/* Simplify declaration of entry_addr. */
++typedef void (*entry_func) (int, int, int, int, int, int)
++     __attribute__ ((noreturn));
++
++extern entry_func entry_addr;
++
++/* Enter the stage1.5/stage2 C code after the stack is set up. */
++void cmain (void);
++
++/* Halt the processor (called after an unrecoverable error). */
++void stop (void) __attribute__ ((noreturn));
++
++/* Reboot the system.  */
++void grub_reboot (void) __attribute__ ((noreturn));
++
++/* Halt the system, using APM if possible. If NO_APM is true, don't use
++   APM even if it is available.  */
++void grub_halt (int no_apm) __attribute__ ((noreturn));
++
++/* Copy MAP to the drive map and set up int13_handler.  */
++void set_int13_handler (unsigned short *map);
++
++/* Set up int15_handler.  */
++void set_int15_handler (void);
++
++/* Restore the original int15 handler.  */
++void unset_int15_handler (void);
++
++/* Track the int13 handler to probe I/O address space.  */
++void track_int13 (int drive);
++
++/* The key map.  */
++extern unsigned short bios_key_map[];
++extern unsigned short ascii_key_map[];
++extern unsigned short io_map[];
++
++/* calls for direct boot-loader chaining */
++void chain_stage1 (unsigned long segment, unsigned long offset,
++		   unsigned long part_table_addr)
++     __attribute__ ((noreturn));
++void chain_stage2 (unsigned long segment, unsigned long offset,
++		   int second_sector)
++     __attribute__ ((noreturn));
++
++/* do some funky stuff, then boot linux */
++void linux_boot (void) __attribute__ ((noreturn));
++
++/* do some funky stuff, then boot bzImage linux */
++void big_linux_boot (void) __attribute__ ((noreturn));
++
++/* booting a multiboot executable */
++void multi_boot (int start, int mb_info) __attribute__ ((noreturn));
++
++/* If LINEAR is nonzero, then set the Intel processor to linear mode.
++   Otherwise, bit 20 of all memory accesses is always forced to zero,
++   causing a wraparound effect for bugwards compatibility with the
++   8086 CPU. */
++void gateA20 (int linear);
++
++/* memory probe routines */
++int get_memsize (int type);
++int get_eisamemsize (void);
++
++/* Fetch the next entry in the memory map and return the continuation
++   value.  DESC is a pointer to the descriptor buffer, and CONT is the
++   previous continuation value (0 to get the first entry in the
++   map). */
++int get_mmap_entry (struct mmar_desc *desc, int cont);
++
++/* Get the linear address of a ROM configuration table. Return zero,
++   if fails.  */
++unsigned long get_rom_config_table (void);
++
++/* Get APM BIOS information.  */
++void get_apm_info (void);
++
++/* Get VBE controller information.  */
++int get_vbe_controller_info (struct vbe_controller *controller);
++
++/* Get VBE mode information.  */
++int get_vbe_mode_info (int mode_number, struct vbe_mode *mode);
++
++/* Set VBE mode.  */
++int set_vbe_mode (int mode_number);
++
++/* Return the data area immediately following our code. */
++int get_code_end (void);
++
++/* low-level timing info */
++int getrtsecs (void);
++int currticks (void);
++
++/* Clear the screen. */
++void cls (void);
++
++/* Turn on/off cursor. */
++int setcursor (int on);
++
++/* Get the current cursor position (where 0,0 is the top left hand
++   corner of the screen).  Returns packed values, (RET >> 8) is x,
++   (RET & 0xff) is y. */
++int getxy (void);
++
++/* Set the cursor position. */
++void gotoxy (int x, int y);
++
++/* Displays an ASCII character.  IBM displays will translate some
++   characters to special graphical ones (see the DISP_* constants). */
++void grub_putchar (int c);
++
++/* Wait for a keypress, and return its packed BIOS/ASCII key code.
++   Use ASCII_CHAR(ret) to extract the ASCII code. */
++int getkey (void);
++
++/* Like GETKEY, but doesn't block, and returns -1 if no keystroke is
++   available. */
++int checkkey (void);
++
++/* Low-level disk I/O */
++int get_diskinfo (int drive, struct geometry *geometry);
++int biosdisk (int subfunc, int drive, struct geometry *geometry,
++	      int sector, int nsec, int segment);
++void stop_floppy (void);
++
++/* Command-line interface functions. */
++#ifndef STAGE1_5
++
++/* The flags for the builtins.  */
++#define BUILTIN_CMDLINE		0x1	/* Run in the command-line.  */
++#define BUILTIN_MENU		0x2	/* Run in the menu.  */
++#define BUILTIN_TITLE		0x4	/* Only for the command title.  */
++#define BUILTIN_SCRIPT		0x8	/* Run in the script.  */
++#define BUILTIN_NO_ECHO		0x10	/* Don't print command on booting. */
++#define BUILTIN_HELP_LIST	0x20	/* Show help in listing.  */
++
++/* The table for a builtin.  */
++struct builtin
++{
++  /* The command name.  */
++  char *name;
++  /* The callback function.  */
++  int (*func) (char *, int);
++  /* The combination of the flags defined above.  */
++  int flags;
++  /* The short version of the documentation.  */
++  char *short_doc;
++  /* The long version of the documentation.  */
++  char *long_doc;
++};
++
++/* All the builtins are registered in this.  */
++extern struct builtin *builtin_table[];
++
++/* The constants for kernel types.  */
++typedef enum
++{
++  KERNEL_TYPE_NONE,		/* None is loaded.  */
++  KERNEL_TYPE_MULTIBOOT,	/* Multiboot.  */
++  KERNEL_TYPE_LINUX,		/* Linux.  */
++  KERNEL_TYPE_BIG_LINUX,	/* Big Linux.  */
++  KERNEL_TYPE_FREEBSD,		/* FreeBSD.  */
++  KERNEL_TYPE_NETBSD,		/* NetBSD.  */
++  KERNEL_TYPE_CHAINLOADER	/* Chainloader.  */
++}
++kernel_t;
++
++extern kernel_t kernel_type;
++extern int show_menu;
++extern int grub_timeout;
++
++void init_builtins (void);
++void init_config (void);
++char *skip_to (int after_equal, char *cmdline);
++struct builtin *find_command (char *command);
++void print_cmdline_message (int forever);
++void enter_cmdline (char *heap, int forever);
++int run_script (char *script, char *heap);
++#endif
++
++/* C library replacement functions with identical semantics. */
++void grub_printf (const char *format,...);
++int grub_sprintf (char *buffer, const char *format, ...);
++int grub_tolower (int c);
++int grub_isspace (int c);
++int grub_strncat (char *s1, const char *s2, int n);
++void *grub_memmove (void *to, const void *from, int len);
++void *grub_memset (void *start, int c, int len);
++int grub_strncat (char *s1, const char *s2, int n);
++char *grub_strstr (const char *s1, const char *s2);
++int grub_memcmp (const char *s1, const char *s2, int n);
++int grub_strcmp (const char *s1, const char *s2);
++int grub_strlen (const char *str);
++char *grub_strcpy (char *dest, const char *src);
++
++#ifndef GRUB_UTIL
++typedef unsigned long grub_jmp_buf[6];
++#else
++/* In the grub shell, use the libc jmp_buf instead.  */
++# include <setjmp.h>
++# define grub_jmp_buf jmp_buf
++#endif
++
++#ifdef GRUB_UTIL
++# define grub_setjmp	setjmp
++# define grub_longjmp	longjmp
++#else /* ! GRUB_UTIL */
++int grub_setjmp (grub_jmp_buf env);
++void grub_longjmp (grub_jmp_buf env, int val);
++#endif /* ! GRUB_UTIL */
++
++/* The environment for restarting Stage 2.  */
++extern grub_jmp_buf restart_env;
++/* The environment for restarting the command-line interface.  */
++extern grub_jmp_buf restart_cmdline_env;
++
++/* misc */
++void init_page (void);
++void print_error (void);
++char *convert_to_ascii (char *buf, int c, ...);
++int get_cmdline (char *prompt, char *cmdline, int maxlen,
++		 int echo_char, int history);
++int substring (const char *s1, const char *s2);
++int nul_terminate (char *str);
++int get_based_digit (int c, int base);
++int safe_parse_maxint (char **str_ptr, int *myint_ptr);
++int memcheck (int start, int len);
++void grub_putstr (const char *str);
++
++#ifndef NO_DECOMPRESSION
++/* Compression support. */
++int gunzip_test_header (void);
++int gunzip_read (char *buf, int len);
++#endif /* NO_DECOMPRESSION */
++
++int rawread (int drive, int sector, int byte_offset, int byte_len, char *buf);
++int devread (int sector, int byte_offset, int byte_len, char *buf);
++int rawwrite (int drive, int sector, char *buf);
++int devwrite (int sector, int sector_len, char *buf);
++
++/* Parse a device string and initialize the global parameters. */
++char *set_device (char *device);
++int open_device (void);
++int real_open_partition (int flags);
++int open_partition (void);
++int next_partition (unsigned long drive, unsigned long dest,
++		    unsigned long *partition, int *type,
++		    unsigned long *start, unsigned long *len,
++		    unsigned long *offset, int *entry,
++		    unsigned long *ext_offset, char *buf);
++
++/* Sets device to the one represented by the SAVED_* parameters. */
++int make_saved_active (void);
++
++/* Set or clear the current root partition's hidden flag.  */
++int set_partition_hidden_flag (int hidden);
++
++/* Open a file or directory on the active device, using GRUB's
++   internal filesystem support. */
++int grub_open (char *filename);
++
++/* Read LEN bytes into BUF from the file that was opened with
++   GRUB_OPEN.  If LEN is -1, read all the remaining data in the file.  */
++int grub_read (char *buf, int len);
++
++/* Reposition a file offset.  */
++int grub_seek (int offset);
++
++/* Close a file.  */
++void grub_close (void);
++
++/* List the contents of the directory that was opened with GRUB_OPEN,
++   printing all completions. */
++int dir (char *dirname);
++
++int set_bootdev (int hdbias);
++
++/* Display statistics on the current active device. */
++void print_fsys_type (void);
++
++/* Display device and filename completions. */
++void print_a_completion (char *filename);
++int print_completions (int is_filename, int is_completion);
++
++/* Copies the current partition data to the desired address. */
++void copy_current_part_entry (char *buf);
++
++#ifndef STAGE1_5
++void bsd_boot (kernel_t type, int bootdev, char *arg)
++     __attribute__ ((noreturn));
++
++/* Define flags for load_image here.  */
++/* Don't pass a Linux's mem option automatically.  */
++#define KERNEL_LOAD_NO_MEM_OPTION	(1 << 0)
++
++kernel_t load_image (char *kernel, char *arg, kernel_t suggested_type,
++		     unsigned long load_flags);
++
++int load_module (char *module, char *arg);
++int load_initrd (char *initrd);
++
++int check_password(char *entered, char* expected, password_t type);
++#endif
++
++void init_bios_info (void);
++
++#endif /* ASM_FILE */
++
++#endif /* ! GRUB_SHARED_HEADER */
+diff -ruN grub-0.94.orig/stage2/size_test stage2/size_test
+--- grub-0.94.orig/stage2/size_test	Wed Feb 11 00:22:12 2004
++++ stage2/size_test	Wed Feb 11 00:22:29 2004
+@@ -40,6 +40,8 @@
+ # The bootloader area of a FFS partition is 14 sectors.
+ check ffs_stage1_5 7168
+ 
++check ufs2_stage1_5 7168
++
+ # Stage 1.5 can be installed in the sectors immediately after MBR in the
+ # first cylinder, so the size is (63 - 1) sectors.
+ check fat_stage1_5 31744
+diff -ruN grub-0.94.orig/stage2/size_test.orig stage2/size_test.orig
+--- grub-0.94.orig/stage2/size_test.orig	Thu Jan  1 03:00:00 1970
++++ stage2/size_test.orig	Wed Jul  9 15:45:53 2003
+@@ -0,0 +1,54 @@
++#!/bin/sh
++
++# Check the sizes of Stage 2 and Stage 1.5's.
++# Copyright (C) 1999  Free Software Foundation, Inc.
++
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2, or (at your option)
++# any later version.
++
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software Foundation,
++# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++
++# Written by OKUJI Yoshinori <okuji@kuicr.kyoto-u.ac.jp>
++
++
++# This function checks if the size of the first argument (filename) is
++# greater than the second argument (limit). If so, then exit with the
++# status 1, otherwise do nothing.
++check ()
++{
++    local file size limit
++
++    file=$1
++    limit=$2
++    set dummy `ls -l $file`
++    size=$6
++    if test $size -gt $limit; then
++	echo "$file is too big ($size > $limit)."
++	exit 1
++    fi
++}
++
++# The bootloader area of a FFS partition is 14 sectors.
++check ffs_stage1_5 7168
++
++# Stage 1.5 can be installed in the sectors immediately after MBR in the
++# first cylinder, so the size is (63 - 1) sectors.
++check fat_stage1_5 31744
++
++# Likewise.
++check e2fs_stage1_5 31744
++
++# Likewise.
++check minix_stage1_5 31744
++
++# Success.
++exit 0
+diff -ruN grub-0.94.orig/stage2/ufs2.h stage2/ufs2.h
+--- grub-0.94.orig/stage2/ufs2.h	Thu Jan  1 03:00:00 1970
++++ stage2/ufs2.h	Wed Feb 11 00:23:16 2004
+@@ -0,0 +1,410 @@
++/*
++ * Copyright (c) 2002 Networks Associates Technology, Inc.
++ * All rights reserved.
++ *
++ * This software was developed for the FreeBSD Project by Marshall
++ * Kirk McKusick and Network Associates Laboratories, the Security
++ * Research Division of Network Associates, Inc. under DARPA/SPAWAR
++ * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
++ * research program
++ *
++ * Copyright (c) 1982, 1989, 1993
++ *	The Regents of the University of California.  All rights reserved.
++ * (c) UNIX System Laboratories, Inc.
++ * All or some portions of this file are derived from material licensed
++ * to the University of California by American Telephone and Telegraph
++ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
++ * the permission of UNIX System Laboratories, Inc.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ * 3. The names of the authors may not be used to endorse or promote
++ *    products derived from this software without specific prior written
++ *    permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ *
++ *	@(#)dinode.h	8.3 (Berkeley) 1/21/94
++ * $FreeBSD: /tmp/pcvs/ports/sysutils/grub/files/Attic/patch-ufs2,v 1.1 2004-02-10 22:00:02 krion Exp $
++ */
++
++#ifndef _GRUB_UFS2_H_
++#define _GRUB_UFS2_H_
++
++typedef signed char            int8_t;
++typedef signed short           int16_t;
++typedef signed int             int32_t;
++typedef signed long long int   int64_t;
++typedef unsigned char          uint8_t;
++typedef unsigned short         uint16_t;
++typedef unsigned int           uint32_t;
++typedef unsigned long long int uint64_t;
++
++typedef uint8_t                u_char;
++typedef uint32_t               u_int;
++
++typedef uint8_t                u_int8_t;
++typedef uint16_t               u_int16_t;
++typedef uint32_t               u_int32_t;
++typedef uint64_t               u_int64_t;
++
++/*
++ * __uint* constants already defined in
++ * FreeBSD 5.x /usr/include/machine/_types.h
++ * or
++ * FreeBSD 4.x /usr/include/machine/ansi.h
++ */
++#if !defined(_MACHINE__TYPES_H_) && !defined(_MACHINE_ANSI_H_)
++typedef uint8_t                __uint8_t;
++typedef uint16_t               __uint16_t;
++typedef uint32_t               __uint32_t;
++typedef uint64_t               __uint64_t;
++#endif /* _MACHINE__TYPES_H_ */
++
++#define i_size di_size
++
++
++#define DEV_BSIZE 512
++
++/*
++ * The root inode is the root of the filesystem.  Inode 0 can't be used for
++ * normal purposes and historically bad blocks were linked to inode 1, thus
++ * the root inode is 2.  (Inode 1 is no longer used for this purpose, however
++ * numerous dump tapes make this assumption, so we are stuck with it).
++ */
++#define	ROOTINO	((ino_t)2)
++
++/*
++ * The size of physical and logical block numbers and time fields in UFS.
++ */
++typedef	int64_t	ufs2_daddr_t;
++typedef int64_t ufs_lbn_t;
++typedef int64_t ufs_time_t;
++
++/* inode number */
++typedef __uint32_t      ino_t;
++
++/* File permissions. */
++#define	IEXEC		0000100		/* Executable. */
++#define	IWRITE		0000200		/* Writeable. */
++#define	IREAD		0000400		/* Readable. */
++#define	ISVTX		0001000		/* Sticky bit. */
++#define	ISGID		0002000		/* Set-gid. */
++#define	ISUID		0004000		/* Set-uid. */
++
++/* File types. */
++#define	IFMT		0170000		/* Mask of file type. */
++#define	IFIFO		0010000		/* Named pipe (fifo). */
++#define	IFCHR		0020000		/* Character device. */
++#define	IFDIR		0040000		/* Directory file. */
++#define	IFBLK		0060000		/* Block device. */
++#define	IFREG		0100000		/* Regular file. */
++#define	IFLNK		0120000		/* Symbolic link. */
++#define	IFSOCK		0140000		/* UNIX domain socket. */
++#define	IFWHT		0160000		/* Whiteout. */
++
++/*
++ * A dinode contains all the meta-data associated with a UFS2 file.
++ * This structure defines the on-disk format of a dinode. Since
++ * this structure describes an on-disk structure, all its fields
++ * are defined by types with precise widths.
++ */
++
++#define	NXADDR	2			/* External addresses in inode. */
++#define	NDADDR	12			/* Direct addresses in inode. */
++#define	NIADDR	3			/* Indirect addresses in inode. */
++
++struct ufs2_dinode {
++	u_int16_t	di_mode;	/*   0: IFMT, permissions; see below. */
++	int16_t		di_nlink;	/*   2: File link count. */
++	u_int32_t	di_uid;		/*   4: File owner. */
++	u_int32_t	di_gid;		/*   8: File group. */
++	u_int32_t	di_blksize;	/*  12: Inode blocksize. */
++	u_int64_t	di_size;	/*  16: File byte count. */
++	u_int64_t	di_blocks;	/*  24: Bytes actually held. */
++	ufs_time_t	di_atime;	/*  32: Last access time. */
++	ufs_time_t	di_mtime;	/*  40: Last modified time. */
++	ufs_time_t	di_ctime;	/*  48: Last inode change time. */
++	ufs_time_t	di_birthtime;	/*  56: Inode creation time. */
++	int32_t		di_mtimensec;	/*  64: Last modified time. */
++	int32_t		di_atimensec;	/*  68: Last access time. */
++	int32_t		di_ctimensec;	/*  72: Last inode change time. */
++	int32_t		di_birthnsec;	/*  76: Inode creation time. */
++	int32_t		di_gen;		/*  80: Generation number. */
++	u_int32_t	di_kernflags;	/*  84: Kernel flags. */
++	u_int32_t	di_flags;	/*  88: Status flags (chflags). */
++	int32_t		di_extsize;	/*  92: External attributes block. */
++	ufs2_daddr_t	di_extb[NXADDR];/*  96: External attributes block. */
++	ufs2_daddr_t	di_db[NDADDR];	/* 112: Direct disk blocks. */
++	ufs2_daddr_t	di_ib[NIADDR];	/* 208: Indirect disk blocks. */
++	int64_t		di_spare[3];	/* 232: Reserved; currently unused */
++};
++
++#define	MAXNAMLEN	255
++
++struct	direct {
++	u_int32_t d_ino;		/* inode number of entry */
++	u_int16_t d_reclen;		/* length of this record */
++	u_int8_t  d_type; 		/* file type, see below */
++	u_int8_t  d_namlen;		/* length of string in d_name */
++	char	  d_name[MAXNAMLEN + 1];/* name with length <= MAXNAMLEN */
++};
++
++/*
++ * File types
++ */
++#define DT_UNKNOWN       0
++#define DT_FIFO          1
++#define DT_CHR           2
++#define DT_DIR           4
++#define DT_BLK           6
++#define DT_REG           8
++#define DT_LNK          10
++#define DT_SOCK         12
++#define DT_WHT          14
++
++#define SBLOCK_UFS2	 65536
++#define SBLOCKSIZE	  8192
++
++#define MAXMNTLEN	512
++
++#define	NOCSPTRS	((128 / sizeof(void *)) - 4)
++
++/*
++ * The maximum number of snapshot nodes that can be associated
++ * with each filesystem. This limit affects only the number of
++ * snapshot files that can be recorded within the superblock so
++ * that they can be found when the filesystem is mounted. However,
++ * maintaining too many will slow the filesystem performance, so
++ * having this limit is a good idea.
++ */
++#define FSMAXSNAP 20
++	
++/*
++ * Per cylinder group information; summarized in blocks allocated
++ * from first cylinder group data blocks.  These blocks have to be
++ * read in from fs_csaddr (size fs_cssize) in addition to the
++ * super block.
++ */
++struct csum {
++	int32_t	cs_ndir;		/* number of directories */
++	int32_t	cs_nbfree;		/* number of free blocks */
++	int32_t	cs_nifree;		/* number of free inodes */
++	int32_t	cs_nffree;		/* number of free frags */
++};
++
++struct csum_total {
++	int64_t	cs_ndir;		/* number of directories */
++	int64_t	cs_nbfree;		/* number of free blocks */
++	int64_t	cs_nifree;		/* number of free inodes */
++	int64_t	cs_nffree;		/* number of free frags */
++	int64_t	cs_numclusters;		/* number of free clusters */
++	int64_t	cs_spare[3];		/* future expansion */
++};
++
++/*
++ * Super block for an FFS filesystem.
++ */
++struct fs {
++	int32_t	 fs_firstfield;		/* historic filesystem linked list, */
++	int32_t	 fs_unused_1;		/*     used for incore super blocks */
++	int32_t	 fs_sblkno;		/* offset of super-block in filesys */
++	int32_t	 fs_cblkno;		/* offset of cyl-block in filesys */
++	int32_t	 fs_iblkno;		/* offset of inode-blocks in filesys */
++	int32_t	 fs_dblkno;		/* offset of first data after cg */
++	int32_t	 fs_old_cgoffset;	/* cylinder group offset in cylinder */
++	int32_t	 fs_old_cgmask;		/* used to calc mod fs_ntrak */
++	int32_t  fs_old_time;		/* last time written */
++	int32_t	 fs_old_size;		/* number of blocks in fs */
++	int32_t	 fs_old_dsize;		/* number of data blocks in fs */
++	int32_t	 fs_ncg;		/* number of cylinder groups */
++	int32_t	 fs_bsize;		/* size of basic blocks in fs */
++	int32_t	 fs_fsize;		/* size of frag blocks in fs */
++	int32_t	 fs_frag;		/* number of frags in a block in fs */
++/* these are configuration parameters */
++	int32_t	 fs_minfree;		/* minimum percentage of free blocks */
++	int32_t	 fs_old_rotdelay;	/* num of ms for optimal next block */
++	int32_t	 fs_old_rps;		/* disk revolutions per second */
++/* these fields can be computed from the others */
++	int32_t	 fs_bmask;		/* ``blkoff'' calc of blk offsets */
++	int32_t	 fs_fmask;		/* ``fragoff'' calc of frag offsets */
++	int32_t	 fs_bshift;		/* ``lblkno'' calc of logical blkno */
++	int32_t	 fs_fshift;		/* ``numfrags'' calc number of frags */
++/* these are configuration parameters */
++	int32_t	 fs_maxcontig;		/* max number of contiguous blks */
++	int32_t	 fs_maxbpg;		/* max number of blks per cyl group */
++/* these fields can be computed from the others */
++	int32_t	 fs_fragshift;		/* block to frag shift */
++	int32_t	 fs_fsbtodb;		/* fsbtodb and dbtofsb shift constant */
++	int32_t	 fs_sbsize;		/* actual size of super block */
++	int32_t	 fs_spare1[2];		/* old fs_csmask */
++					/* old fs_csshift */
++	int32_t	 fs_nindir;		/* value of NINDIR */
++	int32_t	 fs_inopb;		/* value of INOPB */
++	int32_t	 fs_old_nspf;		/* value of NSPF */
++/* yet another configuration parameter */
++	int32_t	 fs_optim;		/* optimization preference, see below */
++	int32_t	 fs_old_npsect;		/* # sectors/track including spares */
++	int32_t	 fs_old_interleave;	/* hardware sector interleave */
++	int32_t	 fs_old_trackskew;	/* sector 0 skew, per track */
++	int32_t	 fs_id[2];		/* unique filesystem id */
++/* sizes determined by number of cylinder groups and their sizes */
++	int32_t	 fs_old_csaddr;		/* blk addr of cyl grp summary area */
++	int32_t	 fs_cssize;		/* size of cyl grp summary area */
++	int32_t	 fs_cgsize;		/* cylinder group size */
++	int32_t	 fs_spare2;		/* old fs_ntrak */
++	int32_t	 fs_old_nsect;		/* sectors per track */
++	int32_t  fs_old_spc;		/* sectors per cylinder */
++	int32_t	 fs_old_ncyl;		/* cylinders in filesystem */
++	int32_t	 fs_old_cpg;		/* cylinders per group */
++	int32_t	 fs_ipg;		/* inodes per group */
++	int32_t	 fs_fpg;		/* blocks per group * fs_frag */
++/* this data must be re-computed after crashes */
++	struct	csum fs_old_cstotal;	/* cylinder summary information */
++/* these fields are cleared at mount time */
++	int8_t   fs_fmod;		/* super block modified flag */
++	int8_t   fs_clean;		/* filesystem is clean flag */
++	int8_t 	 fs_ronly;		/* mounted read-only flag */
++	int8_t   fs_old_flags;		/* old FS_ flags */
++	u_char	 fs_fsmnt[MAXMNTLEN];	/* name mounted on */
++/* these fields retain the current block allocation info */
++	int32_t	 fs_cgrotor;		/* last cg searched */
++	void 	*fs_ocsp[NOCSPTRS];	/* padding; was list of fs_cs buffers */
++	u_int8_t *fs_contigdirs;	/* # of contiguously allocated dirs */
++	struct	csum *fs_csp;		/* cg summary info buffer for fs_cs */
++	int32_t	*fs_maxcluster;		/* max cluster in each cyl group */
++	u_int	*fs_active;		/* used by snapshots to track fs */
++	int32_t	 fs_old_cpc;		/* cyl per cycle in postbl */
++	int32_t	 fs_maxbsize;		/* maximum blocking factor permitted */
++	int64_t	 fs_sparecon64[17];	/* old rotation block list head */
++	int64_t	 fs_sblockloc;		/* byte offset of standard superblock */
++	struct	csum_total fs_cstotal;	/* cylinder summary information */
++	ufs_time_t fs_time;		/* last time written */
++	int64_t	 fs_size;		/* number of blocks in fs */
++	int64_t	 fs_dsize;		/* number of data blocks in fs */
++	ufs2_daddr_t fs_csaddr;		/* blk addr of cyl grp summary area */
++	int64_t	 fs_pendingblocks;	/* blocks in process of being freed */
++	int32_t	 fs_pendinginodes;	/* inodes in process of being freed */
++	int32_t	 fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
++	int32_t	 fs_avgfilesize;	/* expected average file size */
++	int32_t	 fs_avgfpdir;		/* expected # of files per directory */
++	int32_t	 fs_save_cgsize;	/* save real cg size to use fs_bsize */
++	int32_t	 fs_sparecon32[26];	/* reserved for future constants */
++	int32_t  fs_flags;		/* see FS_ flags below */
++	int32_t	 fs_contigsumsize;	/* size of cluster summary array */ 
++	int32_t	 fs_maxsymlinklen;	/* max length of an internal symlink */
++	int32_t	 fs_old_inodefmt;	/* format of on-disk inodes */
++	u_int64_t fs_maxfilesize;	/* maximum representable file size */
++	int64_t	 fs_qbmask;		/* ~fs_bmask for use with 64-bit size */
++	int64_t	 fs_qfmask;		/* ~fs_fmask for use with 64-bit size */
++	int32_t	 fs_state;		/* validate fs_clean field */
++	int32_t	 fs_old_postblformat;	/* format of positional layout tables */
++	int32_t	 fs_old_nrpos;		/* number of rotational positions */
++	int32_t	 fs_spare5[2];		/* old fs_postbloff */
++					/* old fs_rotbloff */
++	int32_t	 fs_magic;		/* magic number */
++};
++
++/*
++ * Filesystem identification
++ */
++#define	FS_UFS2_MAGIC	0x19540119	/* UFS2 fast filesystem magic number */
++
++/*
++ * Turn filesystem block numbers into disk block addresses.
++ * This maps filesystem blocks to device size blocks.
++ */
++#define fsbtodb(fs, b)	((b) << (fs)->fs_fsbtodb)
++#define	dbtofsb(fs, b)	((b) >> (fs)->fs_fsbtodb)
++
++/*
++ * Cylinder group macros to locate things in cylinder groups.
++ * They calc filesystem addresses of cylinder group data structures.
++ */
++#define	cgbase(fs, c)	((ufs2_daddr_t)((fs)->fs_fpg * (c)))
++#define	cgimin(fs, c)	(cgstart(fs, c) + (fs)->fs_iblkno)	/* inode blk */
++#define cgstart(fs, c)							\
++       ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) :		\
++       (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask))))
++
++/*
++ * Macros for handling inode numbers:
++ *     inode number to filesystem block offset.
++ *     inode number to cylinder group number.
++ *     inode number to filesystem block address.
++ */
++#define	ino_to_cg(fs, x)	((x) / (fs)->fs_ipg)
++#define	ino_to_fsba(fs, x)						\
++	((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) +			\
++	    (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
++#define	ino_to_fsbo(fs, x)	((x) % INOPB(fs))
++
++/*
++ * The following macros optimize certain frequently calculated
++ * quantities by using shifts and masks in place of divisions
++ * modulos and multiplications.
++ */
++#define blkoff(fs, loc)		/* calculates (loc % fs->fs_bsize) */ \
++	((loc) & (fs)->fs_qbmask)
++
++/* Use this only when `blk' is known to be small, e.g., < NDADDR. */
++#define smalllblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
++	((blk) << (fs)->fs_bshift)
++
++
++#define lblkno(fs, loc)		/* calculates (loc / fs->fs_bsize) */ \
++	((loc) >> (fs)->fs_bshift)
++
++#define fragroundup(fs, size)	/* calculates roundup(size, fs->fs_fsize) */ \
++	(((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
++
++#define fragstoblks(fs, frags)	/* calculates (frags / fs->fs_frag) */ \
++	((frags) >> (fs)->fs_fragshift)
++#define blkstofrags(fs, blks)	/* calculates (blks * fs->fs_frag) */ \
++	((blks) << (fs)->fs_fragshift)
++#define fragnum(fs, fsb)	/* calculates (fsb % fs->fs_frag) */ \
++	((fsb) & ((fs)->fs_frag - 1))
++#define blknum(fs, fsb)		/* calculates rounddown(fsb, fs->fs_frag) */ \
++	((fsb) &~ ((fs)->fs_frag - 1))
++
++/*
++ * Determining the size of a file block in the filesystem.
++ */
++#define blksize(fs, ip, lbn) \
++	(((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \
++	    ? (fs)->fs_bsize \
++	    : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
++#define sblksize(fs, size, lbn) \
++	(((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
++	  ? (fs)->fs_bsize \
++	  : (fragroundup(fs, blkoff(fs, (size)))))
++
++
++/*
++ * Number of inodes in a secondary storage block/fragment.
++ */
++#define	INOPB(fs)	((fs)->fs_inopb)
++#define	INOPF(fs)	((fs)->fs_inopb >> (fs)->fs_fragshift)
++
++/*
++ * Number of indirects in a filesystem block.
++ */
++#define	NINDIR(fs)	((fs)->fs_nindir)
++
++#endif /* _GRUB_UFS2_H_ */
+--- util/grub-install.in.orig	Wed Feb 11 00:31:26 2004
++++ util/grub-install.in	Wed Feb 11 00:31:58 2004
+@@ -105,11 +105,11 @@
+ 	tmp_disk=`echo "$1" | sed 's%\([sh]d[0-9]*\).*%\1%'`
+ 	tmp_part=`echo "$1" | sed "s%$tmp_disk%%"` ;;
+     freebsd*)
+-	tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([saw]d[0-9]*\).*$%r\1%' \
+-			    | sed 's%r\{0,1\}\(da[0-9]*\).*$%r\1%'`
++	tmp_disk=`echo "$1" | sed 's%\([saw]d[0-9]*\).*$%\1%' \
++			    | sed 's%\(da[0-9]*\).*$%\1%'`
+ 	tmp_part=`echo "$1" \
+-	    | sed "s%.*/r\{0,1\}[saw]d[0-9]\(s[0-9]*[a-h]\)%\1%" \
+-       	    | sed "s%.*/r\{0,1\}da[0-9]\(s[0-9]*[a-h]\)%\1%"`
++	    | sed "s%.*/[saw]d[0-9]\(s[0-9]*[a-h]\)%\1%" \
++       	    | sed "s%.*/da[0-9]\(s[0-9]*[a-h]\)%\1%"`
+ 	;;
+     netbsd*)
+ 	tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([sw]d[0-9]*\).*$%r\1d%' \