aboutsummaryrefslogtreecommitdiffstats
path: root/sysutils
diff options
context:
space:
mode:
authorkrion <krion@FreeBSD.org>2004-02-11 06:00:02 +0800
committerkrion <krion@FreeBSD.org>2004-02-11 06:00:02 +0800
commit1257b1a2b566ac08e6ced755bdafe3a0d9b55354 (patch)
treee283089a34e89c8da809230512443a986096eaba /sysutils
parent37dc9f17081aff01c6b620cd44f44f8a4e7feca2 (diff)
downloadfreebsd-ports-gnome-1257b1a2b566ac08e6ced755bdafe3a0d9b55354.tar.gz
freebsd-ports-gnome-1257b1a2b566ac08e6ced755bdafe3a0d9b55354.tar.zst
freebsd-ports-gnome-1257b1a2b566ac08e6ced755bdafe3a0d9b55354.zip
- a patch for UFS2 support (contributed by Valery Hromov)
- get rid of pkg-plist - cleanup old code PR: ports/62299 Submitted by: maintainer
Diffstat (limited to 'sysutils')
-rw-r--r--sysutils/grub/Makefile34
-rw-r--r--sysutils/grub/distinfo1
-rw-r--r--sysutils/grub/files/patch-ufs29523
-rw-r--r--sysutils/grub/pkg-message2
-rw-r--r--sysutils/grub/pkg-plist17
5 files changed, 9541 insertions, 36 deletions
diff --git a/sysutils/grub/Makefile b/sysutils/grub/Makefile
index b61bf4dec1a4..facc3cd1ec6e 100644
--- a/sysutils/grub/Makefile
+++ b/sysutils/grub/Makefile
@@ -7,35 +7,35 @@
PORTNAME= grub
PORTVERSION= 0.94
-PORTREVISION= 2
+PORTREVISION= 3
CATEGORIES= sysutils
MASTER_SITES= ftp://alpha.gnu.org/gnu/grub/
MAINTAINER= sem@ciam.ru
COMMENT= GRand Unified Bootloader
-GNU_CONFIGURE= yes
-USE_GMAKE= yes
+USE_AUTOMAKE_VER= 17
+AUTOMAKE_ENV= AUTOCONF=${AUTOCONF}
+USE_AUTOCONF_VER= 257
+GNU_CONFIGURE= yes
+USE_GMAKE= yes
CONFIGURE_TARGET= --build=${MACHINE_ARCH}-freebsd-freebsd${OSREL}
-ONLY_FOR_ARCHS= i386
+ONLY_FOR_ARCHS= i386
+
+GRUB_DIR= ${DATADIR:C|^${PREFIX}/||}/i386-freebsd
MAN1= mbchk.1
MAN8= grub.8 grub-install.8 grub-md5-crypt.8 grub-terminfo.8
INFO= grub multiboot
+PLIST_DIRS= ${GRUB_DIR} ${DATADIR:C|^${PREFIX}/||}
+PLIST_FILES= bin/mbchk sbin/grub sbin/grub-install sbin/grub-md5-crypt \
+ sbin/grub-terminfo ${GRUB_DIR}/stage1 ${GRUB_DIR}/stage2
+.for f in e2fs fat ffs jfs minix reiserfs ufs2 vstafs xfs
+PLIST_FILES+= ${GRUB_DIR}/${f}_stage1_5
+.endfor
-#.if defined(WITH_SPLASHIMAGE)
-#PATCH_SITES= http://people.redhat.com/~katzj/grub/patches/
-#PATCHFILES= ${DISTNAME}-vga16.patch ${DISTNAME}-splashimagehelp.patch
-#PATCH_DIST_STRIP= -p1
-#USE_AUTOCONF= yes
-#.else
-#pre-fetch:
-# @${ECHO_MSG}
-# @${ECHO_MSG} "You may build grub with splash image support by"
-# @${ECHO_MSG} "defining WITH_SPLASHIMAGE."
-# @${ECHO_MSG}
-# @sleep 2
-#.endif
+pre-configure:
+ @cd ${WRKSRC}; ${ACLOCAL}
post-install:
@${CAT} ${PKGMESSAGE}
diff --git a/sysutils/grub/distinfo b/sysutils/grub/distinfo
index 446046f2ebac..1dbcdcb2acd9 100644
--- a/sysutils/grub/distinfo
+++ b/sysutils/grub/distinfo
@@ -1 +1,2 @@
MD5 (grub-0.94.tar.gz) = 299672a99cf59656e653d8ffd7851b56
+SIZE (grub-0.94.tar.gz) = 923518
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%' \
diff --git a/sysutils/grub/pkg-message b/sysutils/grub/pkg-message
index 7821a1621f8f..65c7bd33bb12 100644
--- a/sysutils/grub/pkg-message
+++ b/sysutils/grub/pkg-message
@@ -4,6 +4,4 @@ of your hard drive.
To do this, or to use it with a floppy disk, you will need
to read the info page using 'info grub'.
-
-Warning! GRUB does not (yet) support UFS2.
###########################################################
diff --git a/sysutils/grub/pkg-plist b/sysutils/grub/pkg-plist
deleted file mode 100644
index 62fb4471fad0..000000000000
--- a/sysutils/grub/pkg-plist
+++ /dev/null
@@ -1,17 +0,0 @@
-bin/mbchk
-sbin/grub
-sbin/grub-install
-sbin/grub-md5-crypt
-sbin/grub-terminfo
-share/grub/i386-freebsd/e2fs_stage1_5
-share/grub/i386-freebsd/fat_stage1_5
-share/grub/i386-freebsd/ffs_stage1_5
-share/grub/i386-freebsd/jfs_stage1_5
-share/grub/i386-freebsd/minix_stage1_5
-share/grub/i386-freebsd/reiserfs_stage1_5
-share/grub/i386-freebsd/stage1
-share/grub/i386-freebsd/stage2
-share/grub/i386-freebsd/vstafs_stage1_5
-share/grub/i386-freebsd/xfs_stage1_5
-@dirrm share/grub/i386-freebsd
-@dirrm share/grub
generated by cgit (git 2.34.1) at 2024-11-07 09:24:39 +0800