#!/usr/bin/env bash
set -e
+#
+# This script creates a bootable image and should at some point in the future
+# be replaced by makefs.
+#
+
#
# Source settings if present
#
: ${FSTAB=${DESTDIR}/etc/fstab}
: ${BUILDVARS=-V MKGCCCMDS=yes -V MKLLVM=no}
: ${BUILDSH=build.sh}
+: ${CREATE_IMAGE_ONLY=0}
+: ${RC=minix_x86.rc}
+
+# Where the kernel & boot modules will be
+MODDIR=${DESTDIR}/boot/minix/.temp
#
# Directory where to store temporary file system images
#
: ${IMG_DIR=${OBJ}/img}
-: ${IMG=minix_arm_sd.img}
: ${MLO=MLO}
: ${UBOOT=u-boot.img}
-
# Beagleboard-xm
: ${U_BOOT_BIN_DIR=build/omap3_beagle/}
: ${CONSOLE=tty02}
-
# BeagleBone (and black)
#: ${U_BOOT_BIN_DIR=build/am335x_evm/}
#: ${CONSOLE=tty00}
-#
#
# We host u-boot binaries.
+#
U_BOOT_GIT_VERSION=cb5178f12787c690cb1c888d88733137e5a47b15
-# Set the vfat mkfs command. We need to re-evaluate MKFS_VFAT_OPTS after
-# FAT_SIZE is set :-(
+#
+# All sized are written in 512 byte blocks
+#
+# we create a disk image of about 2 gig's
+# for alignment reasons, prefer sizes which are multiples of 4096 bytes
+#
+: ${IMG_SIZE=$(( 2*(2**30) / 512))}
+: ${FAT_SIZE=$(( 10*(2**20) / 512))}
+: ${ROOT_SIZE=$(( 64*(2**20) / 512))}
+: ${HOME_SIZE=$(( 128*(2**20) / 512))}
+: ${USR_SIZE=$(( 1792*(2**20) / 512))}
+
+#
+# Do some math to determine the start addresses of the partitions.
+# Don't leave holes so the 'partition' invocation later is easy.
+#
+FAT_START=2048
+ROOT_START=$(($FAT_START + $FAT_SIZE))
+USR_START=$(($ROOT_START + $ROOT_SIZE))
+HOME_START=$(($USR_START + $USR_SIZE))
+
case $(uname -s) in
Darwin)
MKFS_VFAT_CMD=newfs_msdos
;;
esac
-
if [ -n "$BASE_URL" ]
then
#we no longer download u-boot but do a checkout
#BASE_URL used to be the base url for u-boot
#Downloads
echo "Warning:** Setting BASE_URL (u-boot) is no longer possible use U_BOOT_BIN_DIR"
- echo "Look in ./releasetools/arm_sdimage.sh for suggested values"
+ echo "Look in ${RELEASETOOLSDIR}/arm_sdimage.sh for suggested values"
exit 1
fi
exit 1
fi
-export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:$PATH
+export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:${PATH}
for needed in mcopy dd ${MKFS_VFAT_CMD} git
do
fi
done
+: ${IMG=minix_arm_sd.img}
+
+#
+# Are we going to build the minix sources?
+#
+
+if [ ${CREATE_IMAGE_ONLY} -eq 1 ]
+then
+ if [ ! -d ${DESTDIR} ]
+ then
+ echo "Minix source code does'nt appear to have been built."
+ echo "Please try with \$CREATE_IMAGE_ONLY set to 0."
+ exit 1
+ fi
+fi
+
#
# Artifacts from this script are stored in the IMG_DIR
#
-mkdir -p $IMG_DIR
+rm -rf ${IMG_DIR} ${IMG}
+mkdir -p ${IMG_DIR}
#
# Download the stage 1 bootloader and u-boot
#
-./releasetools/fetch_u-boot.sh -o ${RELEASETOOLSDIR}/u-boot -n $U_BOOT_GIT_VERSION
+${RELEASETOOLSDIR}/fetch_u-boot.sh -o ${RELEASETOOLSDIR}/u-boot -n $U_BOOT_GIT_VERSION
cp ${RELEASETOOLSDIR}/u-boot/${U_BOOT_BIN_DIR}/u-boot.img ${IMG_DIR}/
cp ${RELEASETOOLSDIR}/u-boot/${U_BOOT_BIN_DIR}/MLO ${IMG_DIR}/
-#
-# Remove the generated files to allow us call build.sh without '-V SLOPPY_FLIST=yes'.
-#
-rm -f ${FSTAB}
-
-#
-# Now start the build
-#
-export CPPFLAGS=${FLAG}
-sh ${BUILDSH} -j ${JOBS} -m ${ARCH} -O ${OBJ} -D ${DESTDIR} ${BUILDVARS} -U -u distribution
+if [ ${CREATE_IMAGE_ONLY} -eq 0 ]
+then
+ echo "Going to build Minix source code..."
+ #
+ # Remove the generated files to allow us call build.sh without '-V SLOPPY_FLIST=yes'.
+ #
+ rm -f ${FSTAB}
-#
-# This script creates a bootable image and should at some point in the future
-# be replaced by makefs.
-#
-# All sized are written in 512 byte blocks
-#
-# we create a disk image of about 2 gig's
-: ${IMG_SIZE=$(( 2*(2**30) / 512))}
-: ${FAT_SIZE=$(( 10*(2**20) / 512))}
-: ${ROOT_SIZE=$(( 64*(2**20) / 512))}
-: ${HOME_SIZE=$(( 128*(2**20) / 512))}
-: ${USR_SIZE=$(( 1536*(2**20) / 512))}
+ #
+ # Now start the build.
+ #
+ sh ${BUILDSH} -j ${JOBS} -m ${ARCH} -O ${OBJ} -D ${DESTDIR} ${BUILDVARS} -U -u distribution
-eval MKFS_VFAT_OPTS="\"$MKFS_VFAT_OPTS\""
+fi
#
# create a fstab entry in /etc this is normally done during the
# setup phase on x86
#
cat >${FSTAB} <<END_FSTAB
-/dev/c0d0p2 /home mfs rw 0 2
-/dev/c0d0p3 /usr mfs rw 0 2
-none /sys devman rw,rslabel=devman 0 0
+/dev/c0d0p2 /usr mfs rw 0 2
+/dev/c0d0p3 /home mfs rw 0 2
+none /sys devman rw,rslabel=devman 0 0
END_FSTAB
rm -f ${DESTDIR}/SETS.*
${CROSS_TOOLS}/nbpwd_mkdb -V 0 -p -d ${DESTDIR} ${DESTDIR}/etc/master.passwd
#
-# Now given the sizes above use DD to create separate files representing
-# the partitions we are going to use.
+# make the different file system. this part is *also* hacky. We first convert
+# the METALOG.sanitised using mtree into a input METALOG containing uids and
+# gids.
+# After that we do some magic processing to add device nodes (also missing from METALOG)
+# and convert the METALOG into a proto file that can be used by mkfs.mfs
#
-dd if=/dev/zero of=${IMG_DIR}/fat.img bs=512 count=1 seek=$(($FAT_SIZE -1)) 2>/dev/null
+echo "Creating the file systems"
#
-# Create the empty image where we later will put the partitions in.
+# read METALOG and use mtree to convert the user and group names into uid and gids
+# FIX put "input somewhere clean"
#
-rm -f ${IMG}
-dd if=/dev/zero of=${IMG} bs=512 count=1 seek=$(($IMG_SIZE -1))
+cat ${DESTDIR}/METALOG.sanitised | ${CROSS_TOOLS}/nbmtree -N ${DESTDIR}/etc -C -K device > ${IMG_DIR}/input
+
+# add rc (if any)
+if [ -f ${RC} ]; then
+ cp ${RC} ${DESTDIR}/usr/etc/rc.local
+ echo "./usr/etc/rc.local type=file uid=0 gid=0 mode=0644" >> ${IMG_DIR}/input
+fi
+
+# add fstab
+echo "./etc/fstab type=file uid=0 gid=0 mode=0755 size=747 time=1365060731.000000000" >> ${IMG_DIR}/input
+
+# fill root.img (skipping /usr entries while keeping the /usr directory)
+cat ${IMG_DIR}/input | grep -v "^./usr/" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR} -o ${IMG_DIR}/root.proto
#
-# Do some math to determine the start addresses of the partitions.
-# Don't leave holes so the 'partition' invocation later is easy.
+# Create proto files for /usr and /home using toproto.
#
-FAT_START=2048
-ROOT_START=$(($FAT_START + $FAT_SIZE))
-HOME_START=$(($ROOT_START + $ROOT_SIZE))
-USR_START=$(($HOME_START + $HOME_SIZE))
+cat ${IMG_DIR}/input | grep "^\./usr/\|^. " | sed "s,\./usr,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/usr -o ${IMG_DIR}/usr.proto
+cat ${IMG_DIR}/input | grep "^\./home/\|^. " | sed "s,\./home,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/home -o ${IMG_DIR}/home.proto
#
-# Write the partition table using the natively compiled
-# minix partition utility
+# Create the FAT partition, which contains the bootloader files, kernel and modules
#
-${CROSS_TOOLS}/nbpartition -m ${IMG} ${FAT_START} "c:${FAT_SIZE}*" 81:${ROOT_SIZE} 81:${HOME_SIZE} 81:${USR_SIZE}
+dd if=/dev/zero of=${IMG_DIR}/fat.img bs=512 count=1 seek=$(($FAT_SIZE -1)) 2>/dev/null
#
# Format the fat partition and put the bootloaders
# -p add a prefix to the network booted files (e.g. xm/"
# -c set console e.g. tty02 or tty00
# -v set verbosity e.g. 0 to 3
-#./releasetools/gen_uEnv.txt.sh -c ${CONSOLE} -n -p bb/ > ${IMG_DIR}/uEnv.txt
-./releasetools/gen_uEnv.txt.sh -c ${CONSOLE} > ${IMG_DIR}/uEnv.txt
+#${RELEASETOOLSDIR}/gen_uEnv.txt.sh -c ${CONSOLE} -n -p bb/ > ${IMG_DIR}/uEnv.txt
+${RELEASETOOLSDIR}/gen_uEnv.txt.sh -c ${CONSOLE} > ${IMG_DIR}/uEnv.txt
echo "Copying configuration kernel and boot modules"
mcopy -bsp -i ${IMG_DIR}/fat.img ${IMG_DIR}/$MLO ::MLO
mcopy -bsp -i ${IMG_DIR}/fat.img ${IMG_DIR}/uEnv.txt ::uEnv.txt
#
-# For tftp booting
-#
-cp ${IMG_DIR}/uEnv.txt ${OBJ}/
-
-#
-# Do some last processing of the kernel and servers before also putting
-# them on the FAT
+# Do some last processing of the kernel and servers and then put them on the FAT
+# partition.
#
${CROSS_PREFIX}objcopy ${OBJ}/minix/kernel/kernel -O binary ${OBJ}/kernel.bin
done
#
-# make the different file system. this part is *also* hacky. We first convert
-# the METALOG.sanitised using mtree into a input METALOG containing uids and
-# gids.
-# Afther that we do some processing to convert the METALOG into a proto file
-# that can be used by mkfs.mfs
+# For tftp booting
#
-echo "creating the file systems"
+cp ${IMG_DIR}/uEnv.txt ${OBJ}/
#
-# read METALOG and use mtree to conver the user and group names into uid and gids
-# FIX put "input somwhere clean"
+# Create the empty image where we later will put the partitions in.
+# Make sure it is at least 2GB, otherwise the SD card will not be detected
+# correctly in qemu / HW.
#
-cat ${DESTDIR}/METALOG.sanitised | ${CROSS_TOOLS}/nbmtree -N ${DESTDIR}/etc -C -K device > ${IMG_DIR}/input
-
-# add fstab
-echo "./etc/fstab type=file uid=0 gid=0 mode=0755 size=747 time=1365060731.000000000" >> ${IMG_DIR}/input
-
-# fill root.img (skipping /usr entries while keeping the /usr directory)
-cat ${IMG_DIR}/input | grep -v "^./usr/" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR} -o ${IMG_DIR}/root.proto
+dd if=/dev/zero of=${IMG} bs=512 count=1 seek=$(($IMG_SIZE -1))
-#
-# Create proto files for /usr and /home using toproto.
-#
-cat ${IMG_DIR}/input | grep "^\./usr/\|^. " | sed "s,\./usr,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/usr -o ${IMG_DIR}/usr.proto
-cat ${IMG_DIR}/input | grep "^\./home/\|^. " | sed "s,\./home,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/home -o ${IMG_DIR}/home.proto
#
# Generate /root, /usr and /home partition images.
#
echo "Writing Minix filesystem images"
echo " - ROOT"
-${CROSS_TOOLS}/nbmkfs.mfs -I $((${ROOT_START} * 512)) -b $((${ROOT_SIZE} / 8)) ${IMG} ${IMG_DIR}/root.proto
+_ROOT_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -I $((${ROOT_START} * 512)) -b $((${ROOT_SIZE} / 8)) ${IMG} ${IMG_DIR}/root.proto`/512))
echo " - USR"
-${CROSS_TOOLS}/nbmkfs.mfs -I $((${USR_START} * 512)) -b $((${USR_SIZE} / 8)) ${IMG} ${IMG_DIR}/usr.proto
+_USR_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -I $((${USR_START} * 512)) -b $((${USR_SIZE} / 8)) ${IMG} ${IMG_DIR}/usr.proto`/512))
echo " - HOME"
-${CROSS_TOOLS}/nbmkfs.mfs -I $((${HOME_START} * 512)) -b $((${HOME_SIZE} / 8)) ${IMG} ${IMG_DIR}/home.proto
+_HOME_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -I $((${HOME_START} * 512)) -b $((${HOME_SIZE} / 8)) ${IMG} ${IMG_DIR}/home.proto`/512))
+
+#
+# Write the partition table using the natively compiled
+# minix partition utility
+#
+${CROSS_TOOLS}/nbpartition -m ${IMG} ${FAT_START} "c:${FAT_SIZE}*" \
+ 81:${_ROOT_SIZE} 81:${_USR_SIZE} 81:${_HOME_SIZE}
#
# Merge the partitions into a single image.
-#!/bin/bash
+#!/usr/bin/env bash
set -e
+#
+# This script creates a bootable image and should at some point in the future
+# be replaced by makefs.
+#
+
: ${ARCH=i386}
: ${OBJ=../obj.${ARCH}}
: ${CROSS_TOOLS=${OBJ}/"tooldir.`uname -s`-`uname -r`-`uname -m`"/bin}
: ${CROSS_PREFIX=${CROSS_TOOLS}/i586-elf32-minix-}
: ${JOBS=1}
: ${DESTDIR=${OBJ}/destdir.$ARCH}
+: ${RELEASETOOLSDIR=./releasetools/}
: ${FSTAB=${DESTDIR}/etc/fstab}
: ${BUILDVARS=}
: ${BUILDSH=build.sh}
: ${CREATE_IMAGE_ONLY=0}
-
-# Where the kernel & boot modules will be
-MODDIR=${DESTDIR}/boot/minix/.temp
+: ${RC=minix_x86.rc}
#
# Directory where to store temporary file system images
#
: ${IMG_DIR=${OBJ}/img}
+: ${CDFILES=${IMG_DIR}/cd}
+
+# All sized are written in 512 byte blocks
+#
+# we create a disk image of about 2 gig's
+# for alignment reasons, prefer sizes which are multiples of 4096 bytes
+#
+: ${ROOT_SIZE=$(( 64*(2**20) / 512))}
+: ${HOME_SIZE=$(( 128*(2**20) / 512))}
+: ${USR_SIZE=$(( 1792*(2**20) / 512))}
-CDFILES=${IMG_DIR}/cd
+#
+# Do some math to determine the start addresses of the partitions.
+# Don't leave holes so the 'partition' invocation later is easy.
+#
-if [ ! -f ${BUILDSH} ]
-then
- echo "Please invoke me from the root source dir, where ${BUILDSH} is."
- exit 1
-fi
-export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:${PATH}
+# Where the kernel & boot modules will be
+MODDIR=${DESTDIR}/boot/minix/.temp
while getopts "i" c
do
done
: ${IMG=minix_x86.img}
-: ${RC=minix_x86.rc}
+
+if [ "x${ISOMODE}" = "x1" ]
+then
+ # In iso mode, make all FSes fit (i.e. as small as possible), but
+ # leave some space on /
+ ROOTSIZEARG="-x 5"
+else
+ # In hd image mode, FSes have fixed sizes
+ ROOTSIZEARG="-b $((${ROOT_SIZE} / 8))"
+ USRSIZEARG="-b $((${USR_SIZE} / 8))"
+ HOMESIZEARG="-b $((${HOME_SIZE} / 8))"
+fi
+
+if [ ! -f ${BUILDSH} ]
+then
+ echo "Please invoke me from the root source dir, where ${BUILDSH} is."
+ exit 1
+fi
+
+export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:${PATH}
#
# Are we going to build the minix sources?
#
# Now start the build.
#
- export CPPFLAGS=${FLAG}
sh ${BUILDSH} -j ${JOBS} -m ${ARCH} -O ${OBJ} -D ${DESTDIR} ${BUILDVARS} -U -u distribution
fi
-if [ "x${ISOMODE}" = "x1" ]
-then
- cp ${DESTDIR}/usr/mdec/boot_monitor ${CDFILES}/boot
- cp ${MODDIR}/* ${CDFILES}/
- . ./releasetools/release.functions
- cd_root_changes # uses $CDFILES and writes $CDFILES/boot.cfg
- # start the image off with the iso image; reduce root size to reserve
- ${CROSS_TOOLS}/nbwriteisofs -s0x0 -l MINIX -B ${DESTDIR}/usr/mdec/bootxx_cd9660 -n ${CDFILES} ${IMG}
- ISO_SIZE=$((`${CROSS_TOOLS}/nbstat -f %z ${IMG}` / 512))
-else
- # just make an empty iso partition
- ISO_SIZE=8
-fi
-
#
# create a fstab entry in /etc this is normally done during the
# setup phase on x86
#
cat >${FSTAB} <<END_FSTAB
-/dev/c0d0p2 /usr mfs rw 0 2
-/dev/c0d0p3 /home mfs rw 0 2
-none /sys devman rw,rslabel=devman 0 0
+/dev/c0d0p2 /usr mfs rw 0 2
+/dev/c0d0p3 /home mfs rw 0 2
+none /sys devman rw,rslabel=devman 0 0
END_FSTAB
rm -f ${DESTDIR}/SETS.*
# After that we do some magic processing to add device nodes (also missing from METALOG)
# and convert the METALOG into a proto file that can be used by mkfs.mfs
#
-echo "creating the file systems"
+echo "Creating the file systems"
#
# read METALOG and use mtree to convert the user and group names into uid and gids
cat ${IMG_DIR}/input | grep "^\./usr/\|^. " | sed "s,\./usr,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/usr -o ${IMG_DIR}/usr.proto
cat ${IMG_DIR}/input | grep "^\./home/\|^. " | sed "s,\./home,\.,g" | ${CROSS_TOOLS}/nbtoproto -b ${DESTDIR}/home -o ${IMG_DIR}/home.proto
-#
-# This script creates a bootable image and should at some point in the future
-# be replaced by makefs.
-#
-# All sized are written in 512 byte blocks
-#
-# we create a disk image of about 2 gig's
-# for alignment reasons, prefer sizes which are multiples of 4096 bytes
-#
-: ${ROOT_SIZE=$(( 64*(2**20) / 512))}
-: ${HOME_SIZE=$(( 128*(2**20) / 512))}
-: ${USR_SIZE=$(( 1536*(2**20) / 512))}
-
if [ "x${ISOMODE}" = "x1" ]
-then
- # In iso mode, make all FSes fit (i.e. as small as possible), but
- # leave some space on /
- ROOTSIZEARG="-x 5"
-else
- # In hd image mode, FSes have fixed sizes
- ROOTSIZEARG="-b $((${ROOT_SIZE} / 8))"
- USRSIZEARG="-b $((${USR_SIZE} / 8))"
- HOMESIZEARG="-b $((${HOME_SIZE} / 8))"
+then
+ cp ${DESTDIR}/usr/mdec/boot_monitor ${CDFILES}/boot
+ cp ${MODDIR}/* ${CDFILES}/
+ . ${RELEASETOOLSDIR}/release.functions
+ cd_root_changes # uses $CDFILES and writes $CDFILES/boot.cfg
+ # start the image off with the iso image; reduce root size to reserve
+ ${CROSS_TOOLS}/nbwriteisofs -s0x0 -l MINIX -B ${DESTDIR}/usr/mdec/bootxx_cd9660 -n ${CDFILES} ${IMG}
+ ISO_SIZE=$((`${CROSS_TOOLS}/nbstat -f %z ${IMG}` / 512))
+else
+ # just make an empty iso partition
+ ISO_SIZE=8
fi
-echo "Writing Minix filesystem images"
-
#
-# Do some math to determine the start addresses of the partitions.
-# Ensure the start of the partitions are always aligned, the end will
-# always be as we assume the sizes are multiples of 4096 bytes, which
-# is always true as soon as you have an integer multiple of 1MB.
+# Generate /root, /usr and /home partition images.
#
+echo "Writing Minix filesystem images"
ROOT_START=${ISO_SIZE}
-
echo " - ROOT"
-ROOT_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d $ROOTSIZEARG -I $(($ROOT_START*512)) ${IMG} ${IMG_DIR}/root.proto`/512))
-USR_START=$((${ROOT_START} + ${ROOT_SIZE}))
+_ROOT_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d ${ROOTSIZEARG} -I $((${ROOT_START}*512)) ${IMG} ${IMG_DIR}/root.proto`/512))
+USR_START=$((${ROOT_START} + ${_ROOT_SIZE}))
echo " - USR"
-USR_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d $USRSIZEARG -I $(($USR_START*512)) ${IMG} ${IMG_DIR}/usr.proto`/512))
-HOME_START=$((${USR_START} + $USR_SIZE))
+_USR_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d ${USRSIZEARG} -I $((${USR_START}*512)) ${IMG} ${IMG_DIR}/usr.proto`/512))
+HOME_START=$((${USR_START} + ${_USR_SIZE}))
echo " - HOME"
-HOME_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d $HOMESIZEARG -I $(($HOME_START*512)) ${IMG} ${IMG_DIR}/home.proto`/512))
+_HOME_SIZE=$((`${CROSS_TOOLS}/nbmkfs.mfs -d ${HOMESIZEARG} -I $((${HOME_START}*512)) ${IMG} ${IMG_DIR}/home.proto`/512))
-${CROSS_TOOLS}/nbpartition -m ${IMG} 0 81:${ISO_SIZE} 81:${ROOT_SIZE} 81:${USR_SIZE} 81:${HOME_SIZE}
+#
+# Write the partition table using the natively compiled
+# minix partition utility
+#
+${CROSS_TOOLS}/nbpartition -m ${IMG} 0 81:${ISO_SIZE} \
+ 81:${_ROOT_SIZE} 81:${_USR_SIZE} 81:${_HOME_SIZE}
mods="`( cd ${MODDIR}; echo mod* | tr ' ' ',' )`"
if [ "x${ISOMODE}" = "x1" ]
echo "CD image at `pwd`/${IMG}"
else
echo "To boot this image on kvm:"
- echo "cd ${MODDIR} && kvm -display none -serial stdio -kernel kernel -append \"console=tty00 rootdevname=c0d0p1\" -initrd \"${mods}\" -hda `pwd`/${IMG}"
+ echo "cd ${MODDIR} && qemu-system-i386 -display none -serial stdio -kernel kernel -append \"console=tty00 rootdevname=c0d0p1\" -initrd \"${mods}\" -hda `pwd`/${IMG} --enable-kvm"
fi