#!/bin/sh

fstype=minix
dircomm=$(dirname $0)
comm=$(basename $0)
if [ ! -x "./$comm" ] ; then
	echo "$comm should be executed in home: cd $dircomm"
	cd $dircomm
fi

. Config


rm -rf root/usr/X11R6

if [ "$1" = "cram" ]
then
cram=cram
echo "Creating cramfs"
mkcramfs X11R6/ cramimg
else
cram=
cp -R X11R6 root/usr/
sync
fi


while [ "$1" != "" ] ; do
	eval "$1"
	shift
done

mkdir $MNTDIR 2>/dev/null
MY_DEST_DIR=$(cd $RD_ROOT ; pwd)



echo 
echo "---------------------------------------------------"
echo "Creating ramdisk image..."
echo "                    --> this takes up to 2 minutes"
echo "---------------------------------------------------"

if [ -d $RD_MODULES -a "$(ls $RD_MODULES 2> /dev/null)" ] ; then
	echo "Copying modules to root dir... "
	MY_DEST_DIR=$(cd $RD_ROOT ; pwd)
	rm -R $MY_DEST_DIR/lib/modules 2> /dev/null
	( cd $RD_LINUX ; INSTALL_MOD_PATH=$MY_DEST_DIR make modules_install )
	find $RD_LINUX/lib/modules -name "*.o" -exec strip {} \; &> /dev/null
	depmod -a -F $RD_LINUX/System.map -b $MY_DEST_DIR
	chown -R 0.0 $MY_DEST_DIR/lib/modules
	echo "done."
fi



echo ; echo "Make a file of ${RD_SIZE}k and use loop device on it"
dd if=/dev/zero of=$TMPFILE bs=1k count=$RD_SIZE
# > /dev/null
if ! `losetup $LOOPDEV $TMPFILE`; then
	echo "losetup did NOT run correctly."
	echo "Please make sure you have loop device, losetup, and are root."
	rm -f $TMPFILE
	exit 0
fi

echo "Make $fstype fs on loopdev and mount it"
#mke2fs -m 0 $LOOPDEV > /dev/null
mkfs.$fstype $LOOPDEV > /dev/null
if [ "$?" != "0" ] ; then
	echo "ERROR $? MAKING $fstype FS!"
	exit $?
fi
mount $LOOPDEV $MNTDIR -t $fstype
if [ "$?" != "0" ] ; then
	echo "ERROR $? MOUNTING LOOPDEV!"
	losetup -d $LOOPDEV
	exit $?
fi

echo -n "Copying ramdisk contents to loopdev... "
cp -a $RD_SOURCE $MNTDIR
echo "done."

echo "Umount and undo loop"
umount $MNTDIR
rmdir $MNTDIR 2>/dev/null
losetup -d $LOOPDEV

echo "Create rd image compressed with ${ZIP}"
dd if=$TMPFILE | ${ZIP} -9 > $RD_IMAGE
rm -f $TMPFILE

echo -n "Waiting until everthing is written... "
sync

####################################################################################################

PACKING=50
KERNELSIZE=$(ls -s $RD_KERNEL | (read KS DUMMY; echo $KS))
IMAGESIZE=$(ls -s $RD_IMAGE | (read IS DUMMY; echo $IS))
BOOTBSIZE=$(ls -s $LILO_BOOT | (read BS DUMMY; echo $BS))

# Look total size

TOTAL=$(du -c $RD_KERNEL $RD_IMAGE $LILO_BOOT |tail -1|cut -f1)
TOTAL=$[ $TOTAL + $PACKING ]

if [ $TOTAL -gt $MAXSIZE ] ; then
	echo "*** THE SIZE SHOULD NOT EXCEED $MAXSIZE !!!"
	echo "*** You can continue, but only if you are absolutely sure that it's correct!"
	echo "*** If you are not sure type ctrl-c now and reconfigure root distribution"
	echo -n "*** and/or your kernel image; otherwise press [enter]..."
else
	echo "*** OK! It seems that size don't exceed ${MAXSIZE}."
	echo -n "*** If something is wrong type ctrl-c now; otherwise and press [enter]..."
fi


#echo "Make a file of ${MAXSIZE}k and use loop device on it"
#dd if=/dev/zero of=$DEST_IMG bs=1k count=$MAXSIZE
#if ! `losetup $LOOPDEV $DEST_IMG`; then
#	echo "losetup did NOT run correctly."
#	echo "Please make sure that you are root and that the losetup binary is in the path."
#	echo "Also make sure that you have the loop device compiled in the kernel or the module loaded."
#	rm -f $DEST_IMG
#	exit 0
#fi

#mkdir $MNTDIR 2>/dev/null

#echo "Make minix fs on loopdev and mount it"
#echo "mkfs.minix $LOOPDEV > /dev/null"
#mkfs.minix $LOOPDEV > /dev/null
#if [ "$?" != "0" ] ; then
#	echo "ERROR $? MAKING MINIX FS!"
#	losetup -d $LOOPDEV
#	exit $?
#fi
#mount $LOOPDEV $MNTDIR -t minix
#if [ "$?" != "0" ] ; then
#	echo "ERROR $? MOUNTING LOOPDEV!"
#	losetup -d $LOOPDEV
#	exit $?
#fi


#echo -n "Copying kernel image to image dir... "
#rm -rf $MNTDIR/lost+found/ &> /dev/null
#if ! cp -a $RD_KERNEL $MNTDIR ; then
#	umount $MNTDIR
#	losetup -d $LOOPDEV
#	exit $?
#fi
#echo "done."

#echo -n "Copying initrd image to image dir... "
#if ! cp -a $RD_IMAGE $MNTDIR ; then
#	umount $MNTDIR
#	losetup -d $LOOPDEV
#	exit $?
#fi
#echo "done."

if [ "$cram" = "cram" ]
then
echo -n "Copying cramfs image to image dir... "
if ! cp -a cramimg $MNTDIR ; then
	umount $MNTDIR
	losetup -d $LOOPDEV
	exit $?
fi
echo "done."
fi

#echo "Copying other/ config data to image (the other directory should \
#contain optional drivers and config script for driver setup)"
#cp other/* $MNTDIR

#echo -n "Copying LILO boot sector image to image dir... "
#if ! cp -a $LILO_BOOT $MNTDIR ; then
#	umount $MNTDIR
#	losetup -d $LOOPDEV
#	exit $?
#fi
#echo "done."

#echo -n "Building lilo.conf... "

#LILOMAP=$(basename $LILO_MAP)
#LILOBOOT=$(basename $LILO_BOOT)
#RDKERNEL=$(basename $RD_KERNEL)
#RDIMAGE=$(basename $RD_IMAGE)

#eval DISK_GEOMETRY=\$DISK_GEOMETRY_$MAXSIZE
#eval $DISK_GEOMETRY
#eval DISK_BIOS=$BIOS
#eval DISK_CYLINDERS=$CYLINDERS
#eval DISK_SECTORS=$SECTORS
#eval DISK_HEADS=$HEADS

#LOOPDEV=/dev/fd0
#echo -e "\n# autogen\n" > $LILO_CONF
#echo "boot = $LOOPDEV" >> $LILO_CONF
#echo "#compact" >> $LILO_CONF
#echo "map = $MNTDIR/$LILOMAP" >> $LILO_CONF
#echo "install = $MNTDIR/$LILOBOOT" >> $LILO_CONF
#echo >> $LILO_CONF
#echo "disk = $LOOPDEV" >> $LILO_CONF
#echo "  bios = $DISK_BIOS" >> $LILO_CONF
#echo "  sectors = $DISK_SECTORS" >> $LILO_CONF
#echo "  heads = $DISK_HEADS" >> $LILO_CONF
#echo "  cylinders = $DISK_CYLINDERS" >> $LILO_CONF
#echo >> $LILO_CONF
#echo "image = $MNTDIR/$RDKERNEL" >> $LILO_CONF
#echo "  label = 1diskxwin" >> $LILO_CONF
#echo "  root = /dev/ram0" >> $LILO_CONF
##echo "  root = /dev/fd0" >> $LILO_CONF
#echo "  initrd = $MNTDIR/$RDIMAGE" >> $LILO_CONF
#echo >> $LILO_CONF
#echo "# End of file" >> $LILO_CONF
#echo "done."

#echo "Running LILO"
#if ! lilo -C $LILO_CONF ; then
#	umount $MNTDIR
#	losetup -d $LOOPDEV
#	exit $?
#fi
#echo "done."

#echo "Umount and undo loop"
#umount $MNTDIR
#rmdir $MNTDIR 2>/dev/null
#losetup -d $LOOPDEV

if [ "$DEST_DEV" ] ; then
	echo; echo -n "*** Insert floppy in $DEST_DEV and press [enter]..."
	read DUMMY
	echo

echo "format floppy Y/n?"
read MINOR

	if [ $MINOR = "n" ] ; then
echo ;
else
		echo "Formatting disk... "
		fdformat $DEST_DEV
	fi
	echo "Writing kernel to floppy..."
dd if=vmlinuz of=/dev/fd0 bs=1k > /tmp/kernsize.mung 2>&1
rdev /dev/fd0 /dev/fd0 ; rdev -R /dev/fd0 0 

cat /tmp/kernsize.mung | while read aa; do
set $aa
let r="$1"
mmd=`echo $ddsize`
let ddsize="$r + 16384"
eval rdev -r /dev/fd0 $ddsize
eval dd if=Image.gz of=/dev/fd0 bs=1k seek=$r
break

done

fi

echo -n "Waiting until everthing is written... "
sync

echo "done."

if [ "$DEST_DEV" -a "$WERR" = "true" ] ; then
	echo
	echo "*** Maybe an error occurred during writing process:"
	echo "*** try to format devide with  fdformat  and then $0 again."
	echo
elif [ "$DEST_DEV" ] ; then
	echo
	echo "*** disk written. You can reboot the system with disk in floppy drive."
	echo
else
	echo
	echo "*** image written in file ${DEST_IMG}."
	echo "*** You can put it on a floppy disk using 'dd' or 'cat'."
	if [ $MINOR -ne 0 ] ; then
		echo "*** Probably you need also to execute  fdformat $DEST_DEV  first."
	fi
	echo
fi









