2010-01-14 BVK Chaitanya <bvk.groups@gmail.com>

Unit testing framework for GRUB.

	* Makefile.in: Test framework build rules for 'make check'.
	* conf/tests.rmk: Build rules for individual tests and framework.

	* include/grub/test.h: Header file for whitebox tests.
	* tests/lib/functional_test.c: Framework support for whitebox
	functional tests.
	* tests/lib/test.c: Common whitebox testing code for unit and
	functional tests.
	* tests/lib/unit_test.c: Framework support for whitebox unit
	tests.

	* tests/util/grub-shell-tester.in: Support utility for grub-script
	tests.
	* tests/util/grub-shell.in: Utility to execute grub-script
	commands in a Qemu instance.

	* tests/example_functional_test.c: Example whitebox functional
	test.
	* tests/example_grub_script_test.in: Example grub-script test.
	* tests/example_scripted_test.in: Example scripted test.
	* tests/example_unit_test.c: Example whitebox unit test.

ChangeLog

@@ -1,3 +1,29 @@
+2010-01-14  BVK Chaitanya  <bvk.groups@gmail.com>
+
+	Unit testing framework for GRUB.
+
+	* Makefile.in: Test framework build rules for 'make check'.
+	* conf/tests.rmk: Build rules for individual tests and framework.
+
+	* include/grub/test.h: Header file for whitebox tests.
+	* tests/lib/functional_test.c: Framework support for whitebox
+	functional tests.
+	* tests/lib/test.c: Common whitebox testing code for unit and
+	functional tests.
+	* tests/lib/unit_test.c: Framework support for whitebox unit
+	tests.
+
+	* tests/util/grub-shell-tester.in: Support utility for grub-script
+	tests.
+	* tests/util/grub-shell.in: Utility to execute grub-script
+	commands in a Qemu instance.
+
+	* tests/example_functional_test.c: Example whitebox functional
+	test.
+	* tests/example_grub_script_test.in: Example grub-script test.
+	* tests/example_scripted_test.in: Example scripted test.
+	* tests/example_unit_test.c: Example whitebox unit test.
+
 2010-01-14  Vladimir Serbinenko  <phcoder@gmail.com>
 
 	* conf/i386-coreboot.rmk (multiboot_mod_SOURCES):

Makefile.in

@@ -167,6 +167,8 @@ ifeq ($(platform), emu)
 include $(srcdir)/conf/any-emu.mk
 else
 include $(srcdir)/conf/$(target_cpu)-$(platform).mk
+# For tests.
+include $(srcdir)/conf/tests.mk
 # For external modules.
 -include $(wildcard $(GRUB_CONTRIB)/*/conf/common.mk)
 endif
@@ -461,7 +463,26 @@ distcheck: dist
 	@echo "$(distdir).tar.gz is ready for distribution" | \
 	  sed 'h;s/./=/g;p;x;p;x'
 
-check:
+check: all $(UNIT_TESTS) $(FUNCTIONAL_TESTS) $(SCRIPTED_TESTS)
+	@list="$(UNIT_TESTS)"; \
+	for file in $$list; do \
+	  $(builddir)/$$file; \
+	done
+	@list="$(FUNCTIONAL_TESTS)"; \
+	for file in $$list; do \
+	  mod=`basename $$file .mod`; \
+	  echo "insmod functional_test; insmod $$mod; functional_test" \
+	    | $(builddir)/grub-shell; \
+	done
+	@list="$(SCRIPTED_TESTS)"; \
+	for file in $$list; do \
+	  echo "$$file:"; \
+	  if $(builddir)/$$file; then \
+	    echo "$$file: PASS"; \
+	  else \
+	    echo "$$file: FAIL"; \
+	  fi; \
+	done
 
 .SUFFIX:
 .SUFFIX: .c .o .S .d

conf/tests.rmk

@@ -0,0 +1,50 @@
+# -*- makefile -*-
+
+# For grub-shell
+grub-shell: tests/util/grub-shell.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+check_SCRIPTS += grub-shell
+CLEANFILES += grub-shell
+
+# For grub-shell-tester
+grub-shell-tester: tests/util/grub-shell-tester.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+check_SCRIPTS += grub-shell-tester
+CLEANFILES += grub-shell-tester
+
+pkglib_MODULES += functional_test.mod
+functional_test_mod_SOURCES = tests/lib/functional_test.c tests/lib/test.c
+functional_test_mod_CFLAGS  = $(COMMON_CFLAGS)
+functional_test_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Rules for unit tests
+check_UTILITIES += example_unit_test
+example_unit_test_SOURCES = tests/example_unit_test.c kern/list.c kern/misc.c tests/lib/test.c tests/lib/unit_test.c
+example_unit_test_CFLAGS  = -Wno-format
+
+# Rules for functional tests
+pkglib_MODULES += example_functional_test.mod
+example_functional_test_mod_SOURCES = tests/example_functional_test.c
+example_functional_test_mod_CFLAGS  = -Wno-format $(COMMON_CFLAGS)
+example_functional_test_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Rules for scripted tests
+check_SCRIPTS += example_scripted_test
+example_scripted_test_SOURCES = tests/example_scripted_test.in
+
+check_SCRIPTS += example_grub_script_test
+example_grub_script_test_SOURCES = tests/example_grub_script_test.in
+
+
+# List of tests to execute on "make check"
+SCRIPTED_TESTS    = example_scripted_test
+SCRIPTED_TESTS   += example_grub_script_test
+UNIT_TESTS        = example_unit_test
+FUNCTIONAL_TESTS  = example_functional_test.mod
+
+# dependencies between tests and testing-tools
+$(SCRIPTED_TESTS): grub-shell grub-shell-tester
+$(FUNCTIONAL_TESTS): functional_test.mod
+

include/grub/test.h

@@ -0,0 +1,67 @@
+#ifndef GRUB_TEST_HEADER
+#define GRUB_TEST_HEADER
+
+#include <grub/dl.h>
+#include <grub/list.h>
+#include <grub/misc.h>
+#include <grub/types.h>
+#include <grub/symbol.h>
+
+struct grub_test
+{
+  /* The next test.  */
+  struct grub_test *next;
+
+  /* The test name.  */
+  char *name;
+
+  /* The test main function.  */
+  void (*main) (void);
+};
+typedef struct grub_test *grub_test_t;
+
+extern grub_test_t grub_test_list;
+
+void grub_test_register   (const char *name, void (*test) (void));
+void grub_test_unregister (const char *name);
+
+/* Execute a test and print results.  */
+int grub_test_run (grub_test_t test);
+
+/* Test `cond' for nonzero; log failure otherwise.  */
+void grub_test_nonzero (int cond, const char *file,
+			const char *func, grub_uint32_t line,
+			const char *fmt, ...)
+  __attribute__ ((format (printf, 5, 6)));
+
+/* Macro to fill in location details and an optional error message.  */
+#define grub_test_assert(cond, ...)				\
+  grub_test_nonzero(cond, __FILE__, __FUNCTION__, __LINE__,	\
+		    ## __VA_ARGS__,				\
+		    "assert failed: %s", #cond)
+
+/* Macro to define a unit test.  */
+#define GRUB_UNIT_TEST(name, funp)		\
+  void grub_unit_test_init (void)		\
+  {						\
+    grub_test_register (name, funp);		\
+  }						\
+						\
+  void grub_unit_test_fini (void)		\
+  {						\
+    grub_test_unregister (name);		\
+  }
+
+/* Macro to define a functional test.  */
+#define GRUB_FUNCTIONAL_TEST(name, funp)	\
+  GRUB_MOD_INIT(functional_test_##funp)		\
+  {						\
+    grub_test_register (name, funp);		\
+  }						\
+						\
+  GRUB_MOD_FINI(functional_test_##funp)		\
+  {						\
+    grub_test_unregister (name);		\
+  }
+
+#endif /* ! GRUB_TEST_HEADER */

tests/example_functional_test.c

@@ -0,0 +1,17 @@
+/* All tests need to include test.h for GRUB testing framework.  */
+#include <grub/test.h>
+
+/* Functional test main method.  */
+static void
+example_test (void)
+{
+  /* Check if 1st argument is true and report with default error message.  */
+  grub_test_assert (1 == 1);
+
+  /* Check if 1st argument is true and report with custom error message.  */
+  grub_test_assert (2 == 2, "2 equal 2 expected");
+  grub_test_assert (2 == 3, "2 is not equal to %d", 3);
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST ("example_functional_test", example_test);

tests/example_grub_script_test.in

@@ -0,0 +1,3 @@
+#! @builddir@/grub-shell-tester --modules=echo
+
+echo "hello world"

tests/example_scripted_test.in

@@ -0,0 +1,3 @@
+#!/bin/sh -e
+
+true

tests/example_unit_test.c

@@ -0,0 +1,20 @@
+/* Unit tests are normal programs, so they can include C library.  */
+#include <string.h>
+
+/* All tests need to include test.h for GRUB testing framework.  */
+#include <grub/test.h>
+
+/* Unit test main method.  */
+static void
+example_test (void)
+{
+  /* Check if 1st argument is true and report with default error message.  */
+  grub_test_assert (1 == 1);
+
+  /* Check if 1st argument is true and report with custom error message.  */
+  grub_test_assert (2 == 2, "2 equal 2 expected");
+  grub_test_assert (2 == 3, "2 is not equal to %d", 3);
+}
+
+/* Register example_test method as a unit test.  */
+GRUB_UNIT_TEST ("example_unit_test", example_test);

tests/lib/functional_test.c

@@ -0,0 +1,35 @@
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/test.h>
+
+static grub_err_t
+grub_functional_test (struct grub_extcmd *cmd __attribute__ ((unused)),
+		      int argc __attribute__ ((unused)),
+		      char **args __attribute__ ((unused)))
+{
+  auto int run_test (grub_test_t test);
+  int run_test (grub_test_t test)
+  {
+    grub_test_run (test);
+    return 0;
+  }
+
+  grub_list_iterate (GRUB_AS_LIST (grub_test_list),
+		     (grub_list_hook_t) run_test);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT (functional_test)
+{
+  cmd = grub_register_extcmd ("functional_test", grub_functional_test,
+			      GRUB_COMMAND_FLAG_CMDLINE, 0,
+			      "Run all functional tests.", 0);
+}
+
+GRUB_MOD_FINI (functional_test)
+{
+  grub_unregister_extcmd (cmd);
+}

tests/lib/test.c

@@ -0,0 +1,146 @@
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/test.h>
+
+struct grub_test_failure
+{
+  /* The next failure.  */
+  struct grub_test_failure *next;
+
+  /* The test source file name.  */
+  char *file;
+
+  /* The test function name.  */
+  char *funp;
+
+  /* The test call line number.  */
+  grub_uint32_t line;
+
+  /* The test failure message.  */
+  char *message;
+};
+typedef struct grub_test_failure *grub_test_failure_t;
+
+grub_test_t grub_test_list;
+static grub_test_failure_t failure_list;
+
+static void
+add_failure (const char *file,
+	     const char *funp,
+	     grub_uint32_t line, const char *fmt, va_list args)
+{
+  char buf[1024];
+  grub_test_failure_t failure;
+
+  failure = (grub_test_failure_t) grub_malloc (sizeof (*failure));
+  if (!failure)
+    return;
+
+  grub_vsprintf (buf, fmt, args);
+
+  failure->file = grub_strdup (file ? : "<unknown_file>");
+  failure->funp = grub_strdup (funp ? : "<unknown_function>");
+  failure->line = line;
+  failure->message = grub_strdup (buf);
+
+  grub_list_push (GRUB_AS_LIST_P (&failure_list), GRUB_AS_LIST (failure));
+}
+
+static void
+free_failures (void)
+{
+  grub_test_failure_t item;
+
+  while ((item = grub_list_pop (GRUB_AS_LIST_P (&failure_list))) != 0)
+    {
+      if (item->message)
+	grub_free (item->message);
+
+      if (item->funp)
+	grub_free (item->funp);
+
+      if (item->file)
+	grub_free (item->file);
+
+      grub_free (item);
+    }
+  failure_list = 0;
+}
+
+void
+grub_test_nonzero (int cond,
+		   const char *file,
+		   const char *funp, grub_uint32_t line, const char *fmt, ...)
+{
+  va_list ap;
+
+  if (cond)
+    return;
+
+  va_start (ap, fmt);
+  add_failure (file, funp, line, fmt, ap);
+  va_end (ap);
+}
+
+void
+grub_test_register (const char *name, void (*test_main) (void))
+{
+  grub_test_t test;
+
+  test = (grub_test_t) grub_malloc (sizeof (*test));
+  if (!test)
+    return;
+
+  test->name = grub_strdup (name);
+  test->main = test_main;
+
+  grub_list_push (GRUB_AS_LIST_P (&grub_test_list), GRUB_AS_LIST (test));
+}
+
+void
+grub_test_unregister (const char *name)
+{
+  grub_test_t test;
+
+  test = (grub_test_t) grub_named_list_find
+    (GRUB_AS_NAMED_LIST (grub_test_list), name);
+
+  if (test)
+    {
+      grub_list_remove (GRUB_AS_LIST_P (&grub_test_list), GRUB_AS_LIST (test));
+
+      if (test->name)
+	grub_free (test->name);
+
+      grub_free (test);
+    }
+}
+
+int
+grub_test_run (grub_test_t test)
+{
+  auto int print_failure (grub_test_failure_t item);
+  int print_failure (grub_test_failure_t item)
+  {
+    grub_test_failure_t failure = (grub_test_failure_t) item;
+
+    grub_printf (" %s:%s:%u: %s\n",
+		 (failure->file ? : "<unknown_file>"),
+		 (failure->funp ? : "<unknown_function>"),
+		 failure->line, (failure->message ? : "<no message>"));
+    return 0;
+  }
+
+  test->main ();
+
+  grub_printf ("%s:\n", test->name);
+  grub_list_iterate (GRUB_AS_LIST (failure_list),
+		     (grub_list_hook_t) print_failure);
+  if (!failure_list)
+    grub_printf ("%s: PASS\n", test->name);
+  else
+    grub_printf ("%s: FAIL\n", test->name);
+
+  free_failures ();
+  return GRUB_ERR_NONE;
+}

tests/lib/unit_test.c

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <grub/list.h>
+#include <grub/test.h>
+#include <grub/handler.h>
+
+int
+main (int argc __attribute__ ((unused)),
+      char *argv[] __attribute__ ((unused)))
+{
+  int status = 0;
+
+  extern void grub_unit_test_init (void);
+  extern void grub_unit_test_fini (void);
+
+  auto int run_test (grub_test_t test);
+  int run_test (grub_test_t test)
+  {
+    status = grub_test_run (test) ? : status;
+    return 0;
+  }
+
+  grub_unit_test_init ();
+  grub_list_iterate (GRUB_AS_LIST (grub_test_list),
+		     (grub_list_hook_t) run_test);
+  grub_unit_test_fini ();
+
+  exit (status);
+}
+
+/* Other misc. functions necessary for successful linking.  */
+
+void
+grub_free (void *ptr)
+{
+  free (ptr);
+}
+
+char *
+grub_env_get (const char *name __attribute__ ((unused)))
+{
+  return NULL;
+}
+
+grub_err_t
+grub_error (grub_err_t n, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+
+  return n;
+}
+
+void *
+grub_malloc (grub_size_t size)
+{
+  return malloc (size);
+}
+
+void
+grub_refresh (void)
+{
+  fflush (stdout);
+}
+
+void
+grub_putchar (int c)
+{
+  putchar (c);
+}
+
+int
+grub_getkey (void)
+{
+  return -1;
+}
+
+void
+grub_exit (void)
+{
+  exit (1);
+}
+
+struct grub_handler_class grub_term_input_class;
+struct grub_handler_class grub_term_output_class;

tests/util/grub-shell-tester.in

@@ -0,0 +1,109 @@
+#! /bin/bash -e
+
+# Compares GRUB script output with BASH output.
+# Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+#
+# GRUB 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 3 of the License, or
+# (at your option) any later version.
+#
+# GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
+
+# Initialize some variables.
+transform="@program_transform_name@"
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+bindir=@bindir@
+libdir=@libdir@
+builddir=@builddir@
+PACKAGE_NAME=@PACKAGE_NAME@
+PACKAGE_TARNAME=@PACKAGE_TARNAME@
+PACKAGE_VERSION=@PACKAGE_VERSION@
+target_cpu=@target_cpu@
+
+# Force build directory components
+PATH=${builddir}:$PATH
+export PATH
+
+# Usage: usage
+# Print the usage.
+usage () {
+    cat <<EOF
+Usage: $0 [OPTION] [SOURCE]
+Compares GRUB script output with BASH shell output.
+
+  -h, --help              print this message and exit
+  -v, --version           print the version information and exit
+  --modules=MODULES       pre-load specified modules MODULES
+  --qemu-opts=OPTIONS     extra options to pass to Qemu instance
+
+$0 compares GRUB script output with BASH shell output and prints their
+differences.
+
+Report bugs to <bug-grub@gnu.org>.
+EOF
+}
+
+# Check the arguments.
+for option in "$@"; do
+    case "$option" in
+    -h | --help)
+	usage
+	exit 0 ;;
+    -v | --version)
+	echo "$0 (GNU GRUB ${PACKAGE_VERSION})"
+	exit 0 ;;
+    --modules=*)
+	ms=`echo "$option" | sed -e 's/--modules=//'`
+	modules="$modules,$ms" ;;
+    --qemu-opts=*)
+        qs=`echo "$option" | sed -e 's/--qemu-opts=//'`
+        qemuopts="$qemuopts $qs" ;;
+    -*)
+	echo "Unrecognized option \`$option'" 1>&2
+	usage
+	exit 1
+	;;
+    *)
+	if [ "x${source}" != x ] ; then
+	    echo "too many parameters at the end" 1>&2
+	    usage
+	    exit 1
+	fi
+	source="${option}" ;;
+    esac
+done
+
+if [ "x${source}" = x ] ; then
+  tmpfile=`mktemp`
+  while read; do
+    echo $REPLY >> ${tmpfile}
+  done
+  source=${tmpfile}
+fi
+
+outfile1=`mktemp`
+@builddir@/grub-shell --qemu-opts="${qemuopts}" --modules=${modules} ${source} >${outfile1}
+
+outfile2=`mktemp`
+bash ${source} >${outfile2}
+
+if ! diff -q ${outfile1} ${outfile2} >/dev/null
+then
+  echo "${source}: GRUB and BASH outputs did not match (see diff -u ${outfile1} ${outfile2})"
+  status=1
+else
+    rm -f ${outfile1} ${outfile2}
+fi
+
+exit $status
+
+

tests/util/grub-shell.in

@@ -0,0 +1,145 @@
+#! /bin/bash -e
+
+# Run GRUB script in a Qemu instance
+# Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+#
+# GRUB 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 3 of the License, or
+# (at your option) any later version.
+#
+# GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
+
+# Initialize some variables.
+transform="@program_transform_name@"
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+bindir=@bindir@
+libdir=@libdir@
+builddir=@builddir@
+PACKAGE_NAME=@PACKAGE_NAME@
+PACKAGE_TARNAME=@PACKAGE_TARNAME@
+PACKAGE_VERSION=@PACKAGE_VERSION@
+target_cpu=@target_cpu@
+
+# Force build directory components
+PATH=${builddir}:$PATH
+export PATH
+
+# Usage: usage
+# Print the usage.
+usage () {
+    cat <<EOF
+Usage: $0 [OPTION] [SOURCE]
+Run GRUB script in a Qemu instance.
+
+  -h, --help              print this message and exit
+  -v, --version           print the version information and exit
+  --boot=[fd|hd|cd]       boot method for Qemu instance
+  --modules=MODULES       pre-load specified modules MODULES
+  --qemu-opts=OPTIONS     extra options to pass to Qemu instance
+
+$0 runs input GRUB script or SOURCE file in a Qemu instance and prints
+its output.
+
+Report bugs to <bug-grub@gnu.org>.
+EOF
+}
+
+# Check the arguments.
+for option in "$@"; do
+    case "$option" in
+    -h | --help)
+	usage
+	exit 0 ;;
+    -v | --version)
+	echo "$0 (GNU GRUB ${PACKAGE_VERSION})"
+	exit 0 ;;
+    --modules=*)
+	ms=`echo "$option" | sed -e 's/--modules=//' -e 's/,/ /g'`
+	modules="$modules $ms" ;;
+    --qemu-opts=*)
+        qs=`echo "$option" | sed -e 's/--qemu-opts=//'`
+        qemuopts="$qemuopts $qs" ;;
+    --boot=*)
+        dev=`echo "$option" | sed -e 's/--boot=//'`
+	if   [ "$dev" = "fd" ] ; then bootdev=a;
+	elif [ "$dev" = "hd" ] ; then bootdev=c;
+	elif [ "$dev" = "cd" ] ; then bootdev=d;
+	else
+	    echo "Unrecognized boot method \`$dev'" 1>&2
+	    usage
+	    exit 1
+	fi ;;
+    -*)
+	echo "Unrecognized option \`$option'" 1>&2
+	usage
+	exit 1 ;;
+    *)
+	if [ "x${source}" != x ] ; then
+	    echo "too many parameters at the end" 1>&2
+	    usage
+	    exit 1
+	fi
+	source="${option}" ;;
+    esac
+done
+
+if [ "x${source}" = x ] ; then
+    tmpfile=`mktemp`
+    while read; do
+	echo $REPLY >> ${tmpfile}
+    done
+    source=${tmpfile}
+fi
+
+if [ "x${bootdev}" = x ] ; then
+    bootdev=c # default is boot as disk image
+fi
+
+cfgfile=`mktemp`
+cat <<EOF >${cfgfile}
+grubshell=yes
+insmod serial
+serial
+terminal_input serial
+terminal_output serial
+EOF
+
+for mod in ${modules}
+do
+    echo "insmod ${mod}" >> ${cfgfile}
+done
+
+cat <<EOF >>${cfgfile}
+source /boot/grub/testcase.cfg
+halt
+EOF
+
+isofile=`mktemp`
+grub-mkrescue --output=${isofile} --override-directory=${builddir} \
+  /boot/grub/grub.cfg=${cfgfile} /boot/grub/testcase.cfg=${source} \
+  >/dev/null 2>&1
+
+hdafile=`mktemp`
+cp ${isofile} ${hdafile}
+
+fdafile=`mktemp`
+cp ${isofile} ${fdafile}
+
+outfile=`mktemp`
+qemu-system-i386 ${qemuopts} -nographic -serial stdio -hda ${hdafile} -fda ${fdafile} -cdrom ${isofile} -boot ${bootdev} | tr -d "\r" >${outfile}
+
+cat $outfile
+
+rm -f ${tmpfile} ${outfile} ${cfgfile} ${isofile} ${hdafile} ${fdafile}
+exit 0
+
+