Context Navigation

source: MondoRescue/branches/2.2.5/mindi/mindi@ 1781

Visit:

Last change on this file since 1781 was 1781, checked in by Bruno Cornec, 16 years ago
Do not copy udev files if they do not exist Fix syntax error in bkphw (end)
Property svn:keywords set to `Rev Id`
File size: 123.7 KB

Rev	Line
[747]	1	#!/bin/bash
	2
	3	# $Id: mindi 1781 2007-11-09 20:03:48Z bruno $
	4	#
	5	#-----------------------------------------------------------------------------
	6	# mindi - mini-Linux distro based on the user's filesystem & distribution
	7	#
	8	# Mindi can create a multi-floppy boot/root kit. The first floppy is the boot
	9	# disk: it contains a kernel, a ramdisk etc. The second disk is data disk #1;
	10	# the third disk is data disk #2; and so it goes.
	11	#
	12	# See http://www.mondorescue.org for details.
	13	#-----------------------------------------------------------------------------
	14
	15	### Which arch are we on (useful for ia64 port)
[1565]	16	ARCH=`/bin/uname -m`
[747]	17
[1511]	18	ADDITIONAL_BOOT_PARAMS="devfs=nomount noresume selinux=0 barrier=off"
[747]	19
[925]	20	#RUN_AFTER_INITIAL_BOOT_PHASE="echo \"Who lives in a pineapple under the sea?\" > /tmp/spongebob.squarepants.txt"
[747]	21	# after booting from floppy/CD image but before
	22	# accessing auxiliary data disks (or the rest of
	23	# the CD), the initscript will run the above command.
	24
	25	RUN_AFTER_BOOT_PHASE_COMPLETE="ide-opt"
	26	# after the emergency boot process is complete but
	27	# before the init script runs mondorestore, it will
	28	# run this command.
	29
[1691]	30	MINDI_REV=PBREV
	31	MINDI_VER=PBVER
[747]	32
	33	MINDI_VERSION=${MINDI_VER}-r$MINDI_REV
	34	MINDI_PREFIX=XXX
	35	MINDI_CONF=YYY
	36	MINDI_SBIN=${MINDI_PREFIX}/sbin
[934]	37	MINDI_LIB=LLL
[747]	38
[925]	39	# Temporary directory for mindi
	40	TMPDIR=/tmp
	41
[747]	42	EXTRA_SPACE=24576 ; # increase if you run out of ramdisk space
[1282]	43	BOOT_SIZE=8192 ; # size of the boot disk
[1599]	44	MAX_DISKS=99
[747]	45	WRITE_BOOT_FLOPPIES="yes" ; # do you want to be propted to write floppy images
	46	PROMPT_WRITE_BOOT_FLOPPIES="yes"
	47	# do you want to be prompted to write
	48	# floppy images out to floppy disks?
	49	# if 'no', images will not be written to floppies
	50
	51	PROMPT_MAKE_CD_IMAGE="yes"
	52	# Ask if you want to make a CD Image to be written?
	53	# if this is set to 'no', then the image will be created automatically
	54
[1684]	55	PROMPT_MAKE_USB_IMAGE="yes"
	56	# Ask if you want to make a USB Image to be written?
	57	# if this is set to 'no', then the image will be created automatically
	58
[966]	59	USE_OWN_KERNEL="yes"
[747]	60	# If set to "no", you will be prompted for whether or not
	61	# you want to use your own kernel, or the supplied default.
	62	# If "yes" mindi will automatically use your own kernel.
[925]	63
[747]	64	MY_FSTAB=/etc/fstab
	65	FLOPPY_MODS="ide-floppy floppy"
	66	TAPE_MODS="ht st osst ide-tape ide_tape"
[1667]	67	SCSI_MODS="3w-xxxx 3w_xxxx 3w_9xxx 3w-9xxx 53c7,8xx a100u2w a320raid aacraid adpahci advansys aha152x aha1542 aha1740 aic79xx aic79xx_mod aic7xxx aic7xxx_mod aic7xxx_old AM53C974 atp870u BusLogic cciss cpqfc dmx3191d dpt_i2o dtc eata eata_dma eata_pio fdomain gdth g_NCR5380 i2o_block i2o_core ide-scsi ieee1394 imm in2000 initio ips iscsi isp megaraid megaraid_mm megaraid_mbox megaraid_sas mptbase mptscsih mptsas mptspi mptfc mptscsi mptctl NCR53c406a ncr53c8xx nsp32 pas16 pci2000 pci2220i pcmcia ppa psi240i qla1280 qla2200 qla2300 qlogicfas qlogicfc qlogicisp raw1394 scsi_debug scsi_mod scsi_transport_sas scsi_transport_spi sd_mod seagate sg sim710 sr_mod sym53c416 sym53c8xx sym53c8xx_2 t128 tmscsim u14-34f ultrastor wd7000 vmhgfs"
[747]	68
	69	# ide-probe-mod
[1597]	70	IDE_MODS="ide ide-generic ide-detect ide-mod ide-disk ide-cd ide_cd ide-cs ide-core ide_core edd paride ata_generic ata_piix libata via82cxxx generic nvidia ahci sata_nv cmd64x pata_amd pata_marvell"
[747]	71	PCMCIA_MODS="pcmcia_core ds yenta_socket"
[1714]	72	USB_MODS="usb-storage usb-ohci usb-uhci usbcore usb_storage input hid uhci_hcd ehci_hcd uhci-hcd ehci-hcd ohci-hcd ohci_hcd usbkbd usbhid keybdev mousedev libusual"
[747]	73	CDROM_MODS="$TAPE_MODS $FLOPPY_MODS $IDE_MODS af_packet cdrom isocd isofs inflate_fs nls_iso8859-1 nls_cp437 sg sr_mod zlib_inflate $USB_MODS $PCMCIA_MODS"
[1430]	74	NET_MODS="sunrpc nfs nfs_acl lockd fscache loop mii 3c59x e100 bcm5700 bnx2 e1000 eepro100 ne2k-pci tg3 pcnet32 8139cp 8139too 8390 forcedeth vmxnet vmnet"
[1258]	75	EXTRA_MODS="$CDROM_MODS vfat fat loop md-mod linear raid0 raid1 xor raid5 raid456 lvm-mod dm-mod dm-snapshot dm-zero dm-mirror jfs xfs xfs_support pagebuf reiserfs ext2 ext3 minix nfs nfs_acl nfsd lockd sunrpc jbd mbcache"
[1230]	76	# Replace with that line for HP OCMP e.g.
	77	#DENY_MODS="MPS_Driver_Mapper mps octtldrv tscttl streams"
	78	DENY_MODS=""
[1399]	79	# Force some modules to be included
[1354]	80	FORCE_MODS=""
[925]	81
[747]	82	LOGFILE=/var/log/mindi.log
	83	FDDEVICE=/dev/fd0 ; # 1.44MB floppy #0
[925]	84	CACHE_LOC=/var/cache/mindi
[747]	85	FORCE_DUAL_FLOPPIES=no
	86	BOOT_MEDIA_MESSAGE="\
	87	To format and restore all files automatically, type 'nuke' <enter>.\n\
	88	To restore some/all files interactively, type 'interactive' <enter>.\n\
	89	To compare the archives with your filesystem, type 'compare' <enter>.\n\
	90	To boot to a command-line prompt (expert mode), type 'expert' <enter>.\n\
	91	You may add one or more of the following parameters as well:-\n\n\
	92	donteject - mondorestore will not eject the CD; this is useful if, for\n\
	93	instance, your PC's case has a concealed CD-ROM drive\n\
	94	noresize - your mountlist will not be adjusted to use your unallocated\n\
	95	hard disk space\n\
	96	textonly - do not call any Newt library routines; this is unattractive\n\
	97	but valuable if you find your Newt library has bugs in it\n\n\
	98	e.g. Type 'nuke donteject textonly' if you have an unstable Newt library and \n\
	99	a PC whose CD-ROM drive tray would be damaged if it unexpectedly ejected.\n\
	100	"
[925]	101	FDISK=$MINDI_SBIN/parted2fdisk
[747]	102
[925]	103	# Using a config file allow to overwrite some values
	104	MINDI_CONFIG="$MINDI_CONF/mindi.conf"
	105	if [ -f $MINDI_CONFIG ]; then
	106	. $MINDI_CONFIG
	107	fi
	108
[1485]	109	# Now we can create what we need
[1486]	110	export MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
[940]	111	mkdir -p $MINDI_TMP
	112
	113	# Purge from potential old run
	114	rm -rf $CACHE_LOC/* 2> /dev/null
[925]	115	mkdir -p $CACHE_LOC
[747]	116	# ----------------------------------------------------------------------------
	117
	118
	119	AbortHere() {
	120	[ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
	121	Die "Program is terminating in response to signal received from OS/user"
	122	}
	123
	124
	125	HackSyslinuxFile() {
	126	local incoming
	127	incoming=`ReadLine`
	128	while [ "$incoming" ] ; do
	129	echo -en "$incoming" \| sed s/24000/$1/
	130	if [ "`echo "$incoming" \| grep append`" ] ; then
	131	echo -en " $ADDITIONAL_BOOT_PARAMS"
	132	fi
	133	echo -en "\n"
	134	incoming=`ReadLine`
	135	done
	136	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	137	echo -en "label memtest\n kernel memdisk\n append initrd=memtest.img\n\n"
	138	fi
	139	}
	140
	141
	142	Aborted() {
	143	trap SIGHUP SIGTERM SIGTRAP SIGINT
[925]	144	[ "$CACHE_LOC" != "" ] && rm -f $CACHE_LOC/mindiimg $CACHE_LOC/gz $CACHE_LOC/mindi.iso
[747]	145	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
	146	Die "User abort."
	147	}
	148
	149
	150	AddFileToCfgIfExists() {
	151	[ -e "$1" ] && echo -en "$2 `cat $1`\n" >> $3
	152	}
	153
	154
	155	AddFileToDir() {
[1764]	156	local filename minidir_root noof_disks diskno res filesize would_occupy zipsize complevel cutoff compressed_fname siz
[747]	157	filename=$1
	158	minidir_root=$2
	159	noof_disks=$3
	160
	161	diskno=$noof_disks
	162	mkdir -p $minidir_root/$diskno
	163	[ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
	164	if [ ! -e "$filename" ] ; then
[925]	165	if [ -h "$filename" ] ; then
[963]	166	cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
[925]	167	return $noof_disks
	168	else
	169	Die "AddFileToDir asked me to add $filename, which does not exist. Oops! Did you run out of disk space or is your Linux distro severely broken?"
	170	fi
[747]	171	fi
[925]	172
	173	# move to the disk that has room on it (or end up using the last, if all full)
[1599]	174	while [ "$diskno" -lt $MAX_DISKS ] ; do
[925]	175	mkdir -p $minidir_root/$diskno
[747]	176	filesize=`du -sk $filename \| cut -f1`
[963]	177	cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
[747]	178	if [ "$filesize" -le "4" ] ; then
	179	siz=$filesize
	180	elif [ ! -f "$filename" ] ; then
	181	siz=0
	182	else
	183	siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt \| cut -f1`
	184	[ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
	185	siz=$(($siz-2));# to allow for sectors & the fact that they round up
	186	fi
[925]	187	[ ! "$siz" ] && siz=4
	188	[ "$siz" -lt "0" ] && siz=0
[747]	189	LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
[925]	190	[ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
	191	echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
	192	LAST_COMPRESSED_SIZE=0
	193	rm -f $minidir_root/$diskno/$filename
[747]	194	diskno=$(($diskno+1))
	195	done
	196	return 0 ; # failed
	197	}
	198
	199
	200	AddKeyboardMappingFile() {
	201	local mappath r included_list included_item i res ii sss
	202	mappath=$1
	203	KBDEPTH=$(($KBDEPTH+1))
	204	[ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
	205	if [ -e "$bigdir/$mappath" ] ; then
	206	echo "$mappath already added" >> $LOGFILE
	207	return
	208	elif [ -d "$bigdir/$mappath" ] ; then
	209	echo "Cannot add $mappath: it's a directory. Sorry."
	210	return
	211	fi
	212	echo "Added kbd map $mappath" >> $LOGFILE
	213	if [ ! -e "$mappath" ] ; then
[1764]	214	mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find \| grep "$locale[^r][^/]" \| grep -vx " #."`
[747]	215	if [ ! -e "$mappath" ] ; then
[963]	216	LogIt "Cannot add $mappath: kbd map file not found"
[747]	217	return
	218	fi
	219	else
	220	echo -en "`basename $mappath \| tr '.' '#' \| sed s/#kmap#gz// \| sed s/#inc#gz//` " \| tr '#' '.'
	221	fi
	222
	223	mkdir -p $bigdir/etc
[963]	224	cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE \|\| LogIt "AKMF -- Could not copy $mappath to $bigdir"
[747]	225	if [ "`echo $mappath \| grep -F ".gz"`" ] ; then
	226	included_list=`gzip -dc $mappath \| grep -Fi include \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	227	else
	228	included_list=`grep -Fi include $mappath \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	229	fi
	230	for included_item in $included_list ; do
[925]	231	if [ ! -e "$included_item" ] ; then
[1764]	232	sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
	233	[ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
[925]	234	for ii in $sss ; do
[747]	235	[ -e "$ii" ] && AddKeyboardMappingFile $ii
[925]	236	done
	237	else
	238	AddKeyboardMappingFile $included_item
	239	fi
[747]	240	done
	241	}
	242
	243
	244	ChopUpAndCopyFile() {
	245	local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
	246	filename=$1
	247	outdir=$2
	248	slicesize=$3
	249	biggienumber=$4
	250
	251	[ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend deplist.txt accordingly."
	252	mkdir -p $outdir
	253
	254	sliceno=0
[940]	255	scratchfile=$MINDI_TMP/blah.$$.dat
[963]	256	cp -f $filename $scratchfile 2>> $LOGFILE \|\| Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
[747]	257	[ "`head $scratchfile -n1 \| grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
	258	[ "`echo "$filename" \| grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
	259	if [ "`echo "$filename" \| grep -F "lib/modules/" \| grep "\.*o\.gz"`" != "" ] ; then
[925]	260	mv $scratchfile $scratchfile.gz
[963]	261	gunzip -f $scratchfile \|\| LogIt "Cannot gunzip $scratchfile.gz"
[925]	262	filename=`echo "$filename" \| tr '.' '#' \| sed s/#o#gz/#o/ \| sed s/#ko#gz/#ko/ \| tr '#' '.'`
[747]	263	fi
	264	filesize=`du -sk $scratchfile \| cut -f1`
	265	noof_slices=$(($filesize/$slicesize))
	266	echo "$filename" > $outdir/slice-$biggienumber.name
	267	echo "$filesize" > $outdir/slice-$biggienumber.size
	268	[ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
	269	while [ "$sliceno" -le "$noof_slices" ] ; do
[963]	270	dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
[747]	271	sliceno=$(($sliceno+1))
	272	done
	273	rm -f $scratchfile
	274	}
	275
	276
	277	CopyBootBFile() {
	278	local copy_to copy_from possible_locations liloc
	279	copy_to=$1
	280	copy_from=/boot/boot.b
	281	liloc=`which lilo.real 2>/dev/null`
	282	[ $liloc ] \|\| liloc=`which lilo 2>/dev/null`
	283	if [ $liloc ]; then
	284	if ! [ `strings $liloc \| grep "boot\.b"` ]; then
[963]	285	LogIt "boot.b files built into lilo; I'll create a dummy."
[747]	286	> $copy_to
	287	return 0
	288	fi
	289	fi
	290	if [ ! -f "$copy_from" ] ; then
	291	LogIt "OK, you don't have a /boot/boot.b file, which is odd because\n most _good_ Linux distributions come with one, even if it's only a softlink"
	292	copy_from=`grep install= /etc/lilo.conf \| grep "\.b" \| cut -d'=' -f2`
	293	if [ ! -f "$copy_from" ] ; then
[963]	294	LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
[747]	295	copy_from=`FindSensibleBootBFile`
[963]	296	LogIt "I'm going to use '$copy_from'"
[747]	297	fi
	298	fi
[963]	299	cp -f $copy_from $copy_to 2>> $LOGFILE \|\| LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
[747]	300	}
	301
	302
	303	CopyDependenciesToDirectory() {
[1526]	304	local outdir incoming fname filesize counter d found
[747]	305	outdir=$1
	306	mkdir -p $outdir
	307	incoming=`ReadLine`
	308	counter=0
	309	while [ "$incoming" != "" ] ; do
[1526]	310	# Non absolute file names should not arrive till here => skipped
	311	if [ `echo "$incoming" \| cut -c1` != '/' ]; then
	312	LogIt "Unable to handle $incoming"
	313	incoming=`ReadLine`
	314	continue
	315	fi
	316	# no parent directory of incoming should be a link, copy is not possible in that case
	317	d=`dirname "$incoming"`
	318	found="false"
	319	while [ $d != "/" -a $found = "false" ]; do
	320	[ -h "$d" ] && found="true"
	321	d=`dirname "$d"`
	322	done
	323	if [ -d "$incoming" ] && [ ! -h "$incoming" ]; then
[747]	324	find $incoming/* -maxdepth 0 2> /dev/null \| CopyDependenciesToDirectory $outdir
[1526]	325	elif [ -e "$incoming" ] && [ $found = "false" ]; then
[747]	326	filesize=`du -sk $incoming \| cut -f1`
	327	if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
	328	ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
	329	BIGNO=$(($BIGNO+1))
	330	else
[953]	331	cp --parents -Rdf $incoming $outdir 2> /dev/null \|\| Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
[925]	332	if [ "`echo "$incoming" \| grep "lib/modules/.\..o\.gz"`" != "" ] ; then
[963]	333	gunzip -f $outdir/$incoming \|\| LogIt "Cannot gunzip $outdir/$incoming"
[925]	334	fi
	335	[ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
	336	fi
	337	counter=$(($counter+1))
	338	if [ "$counter" -ge "5" ] ; then
	339	counter=0
	340	echo -en "."
	341	fi
[747]	342	fi
	343	incoming=`ReadLine`
	344	done
	345	}
	346
	347
	348	CopyImageToDisk() {
	349	local image dev procno res comment
	350	image=$1
	351	dev=$2
	352	comment=$3
	353	[ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
	354	Prompt "About to write $comment. Please press ENTER."
	355	echo -en "Formatting disk..."
	356	if which fdformat > /dev/null ; then
[925]	357	fdformat -n $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	358	elif which superformat > /dev/null ; then
[925]	359	superformat $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	360	else
[925]	361	Die "Please install either fdformat or superformat."
[747]	362	fi
	363	echo -en "\rWriting $comment"
	364	if echo $image \| grep "mindi-[r\|b]oot\.1440" &> /dev/null ; then
[925]	365	cat $image > $dev &
[747]	366	else
[925]	367	dd if=$image of=$dev &> /dev/null &
[747]	368	fi
	369	procno=$!
	370	ps $procno > /dev/null 2> /dev/null
	371	while [ "$?" -eq "0" ] ; do
	372	sleep 3
	373	echo -en "."
	374	ps $procno > /dev/null 2> /dev/null
	375	done
	376	echo -e "$DONE"
[963]	377	LogIt "$comment has been written."
[747]	378	}
	379
	380
	381	CountItemsIn() {
	382	local r
	383	r=0
	384	for q in $1 ; do
	385	r=$(($r+1))
	386	done
	387	echo $r
	388	}
	389
	390
	391	CreateDataDiskImagesFromTarballs() {
	392	local tardir outdir diskno noof_disks kp
	393	tardir=$1
	394	outdir=$2
	395	noof_disks=$3
	396
	397	mkdir -p $outdir
	398	diskno=1
	399	echo -en "Creating data disk "
	400	while [ "$diskno" -le "$noof_disks" ] ; do
[925]	401	echo -en "#$diskno..."
[963]	402	cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE \|\| LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
[747]	403	CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
	404	diskno=$(($diskno+1))
	405	done
	406	mv -f $tardir/all.tar.gz $outdir
	407	du -sk $outdir/*gz >> $LOGFILE
	408	echo -e "$DONE"
	409	}
	410
	411
	412
	413	CreateOneDataDiskImage() {
	414	local tarball imagefile dev diskno noof_disks mountpoint
	415	tarball=$1
	416	imagefile=$2
	417	diskno=$3
	418	noof_disks=$4
	419
[940]	420	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	421	mkdir -p $mountpoint
[963]	422	dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null \|\| LogIt "Cannot dd (CODI)"
[1764]	423	echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
	424	mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE \|\| Die "Unable to create an ext2 file system on $imagefile"
[747]	425	mount -t ext2 -o loop $imagefile $mountpoint \|\| Die "Can't loopmount $imagefile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
	426	mv $tarball $mountpoint/
	427	if [ "$?" -ne "0" ] ; then
[925]	428	umount $mountpoint
	429	Die "Tarball $tarball is too big for disk! (CODI)\nTell Dev Team to adjust MAX_COMPRESSED_SIZE"
[747]	430	fi
	431	[ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
[963]	432	umount $mountpoint \|\| LogIt "Cannot umount (CODI)"
	433	rmdir $mountpoint \|\| LogIt "Cannot rmdir (CODI)"
[747]	434	}
	435
	436
[925]	437	# Last function called before exiting
	438	# Parameter is exit code value
[931]	439	MindiExit() {
[925]	440	local my_partitions
[747]	441
[925]	442	echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
	443	echo "End date : `date`" >> $LOGFILE
[1335]	444	if [ _"$MONDO_SHARE" != _"" ] ; then
[1349]	445	echo "------------- mindi logfile included -------------------------" >> /var/log/mondoarchive.log
[1315]	446	cat $LOGFILE >> /var/log/mondoarchive.log
[1349]	447	echo "--------------------------------------------------------------">> /var/log/mondoarchive.log
[1315]	448	fi
[747]	449
[925]	450	cd /
[1636]	451	sync&
[747]	452
[1636]	453	# Unmount what could remain mounted
[925]	454	my_partitions=`mount \| grep -F $$ \| cut -f1 -d' '`
	455	[ "$my_partitions" != "" ] && umount $my_partitions
[940]	456	# Clean temporary files only when standalone mindi
[948]	457	if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
[940]	458	rm -Rf $MINDI_TMP
	459	fi
[925]	460	exit $1
	461	}
	462
[747]	463	Die() {
[925]	464	local i
[747]	465	if [ "$1" = "" ] ; then
[963]	466	LogIt "FATAL ERROR"
[747]	467	else
[963]	468	LogIt "FATAL ERROR. $1"
[747]	469	fi
	470
[1315]	471	LogIt "Please e-mail a copy of $LOGFILE to the mailing list."
[963]	472	LogIt "See http://www.mondorescue.org for more information."
[747]	473	LogIt "WE CANNOT HELP unless you enclose that file.\n"
[925]	474	MindiExit -1
[747]	475	}
	476
	477
	478	DropOptimizedLibraries() {
	479	local outdir filelist list_of_optimized_libraries optimized_lib_name vanilla_lib_name reason msg resolved res
	480	filelist=$1
	481	outdir=$2
	482
	483	list_of_optimized_libraries=`grep "lib/i[5-7]86/" $filelist`
	484	if [ "$list_of_optimized_libraries" = "" ] ; then
[859]	485	return 0
[747]	486	fi
	487	echo -en "Dropping i686-optimized libraries if appropriate"
	488	for optimized_lib_name in $list_of_optimized_libraries ; do
[859]	489	echo -en "."
	490	reason=""
[1483]	491	vanilla_lib_name=`echo "$optimized_lib_name" \| sed -e 's/i[5-7]86//' -e 's/cmov//' -e 's/nosegneg//' \| tr -s '/' '/'`
[859]	492	echo "$vanilla_lib_name" >> $filelist
	493	resolved=$vanilla_lib_name
[747]	494	echo "Adding $resolved to filelist" >> $LOGFILE
[861]	495	resolved=`ReadAllLink $resolved`
	496	echo "Adding $resolved to filelist" >> $LOGFILE
[859]	497	mkdir -p $outdir$optimized_lib_name > /dev/null 2> /dev/null
	498	rmdir $outdir$optimized_lib_name > /dev/null 2> /dev/null
	499	ln -sf $vanilla_lib_name $outdir$optimized_lib_name
	500	echo "Excluding $optimized_lib_name" >> $LOGFILE
[935]	501	grep -Fvx "$optimized_lib_name" "$filelist" > $filelist.tmp
[859]	502	echo "Replacing it with $vanilla_lib_name" >> $LOGFILE
	503	echo "$vanilla_lib_name" >> $filelist.tmp
	504	mv -f $filelist.tmp $filelist
[747]	505	done
[925]	506	$AWK '{ print $1; }' $filelist \| sort -u > $filelist.tmp
[747]	507	mv -f $filelist.tmp $filelist
	508	echo -e "$DONE"
	509	}
	510
	511
	512	FindAndAddUserKeyboardMappingFile() {
	513	local r res mapfile mappath included_item included_list keyfile mp locale
[963]	514	LogIt "Analyzing your keyboard's configuration."
[747]	515	KEYDIR=/lib/kbd
	516	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/share/kbd # Slackware
	517	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/lib/kbd
	518	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/share
[1713]	519	[ ! -e "$KEYDIR" ] && KEYDIR=/etc/condole
	520	[ ! -e "$KEYDIR" ] && KEYDIR=/etc/condole-setup
[747]	521	if [ ! -e "$KEYDIR" ] ; then
[963]	522	LogIt "Keyboard mapping directory not found. I shall use default map at boot-time."
[747]	523	return 0
	524	fi
	525	if [ -e "/etc/sysconfig/keyboard" ] ; then
	526	echo "Red Hat-style config detected." >> $LOGFILE
	527	keyfile=/etc/sysconfig/keyboard
	528	elif [ -e "/etc/rc.d/rc.keymap" ] ; then
	529	echo "Slackware-style config detected." >> $LOGFILE
	530	keyfile=/etc/rc.d/rc.keymap
	531	elif [ -e "/etc/rc.config" ] ; then
	532	echo "Debian-style config detected." >> $LOGFILE
	533	keyfile=/etc/rc.config
	534	elif [ -e "/etc/console/boottime.kmap.gz" ] ; then
	535	echo "Debian-style config detected." >> $LOGFILE
	536	echo -en "Adding the following keyboard mapping tables: "
	537	mkdir -p $bigdir/tmp
	538	echo "/etc/console/boottime.kmap.gz" > $bigdir/tmp/KEYMAP-LIVES-HERE
	539	KBDEPTH=0
	540	mkdir -p $bigdir/etc/console
[963]	541	cp /etc/console/boottime.kmap.gz $bigdir/etc/console 2>> $LOGFILE
[747]	542	echo -e "$DONE"
	543	return 0
[1713]	544	elif [ -e "/etc/console-setup/boottime.kmap.gz" ] ; then
	545	echo "Ubuntu-style config detected." >> $LOGFILE
	546	echo -en "Adding the following keyboard mapping tables: "
	547	mkdir -p $bigdir/tmp
	548	echo "/etc/console-setup/boottime.kmap.gz" > $bigdir/tmp/KEYMAP-LIVES-HERE
	549	KBDEPTH=0
	550	mkdir -p $bigdir/etc/console-setup
	551	cp /etc/console-setup/boottime.kmap.gz $bigdir/etc/console-setup 2>> $LOGFILE
	552	echo -e "$DONE"
	553	return 0
[1465]	554	elif [ -e "/etc/conf.d/keymaps" ] ; then
	555	echo "Gentoo-style config detected." >> $LOGFILE
	556	keyfile=/etc/conf.d/keymaps
[747]	557	else
	558	echo -en "Searching for rc.config ..."
	559	keyfile=`find /etc -name rc.config \| head -n1`
	560	if [ "$keyfile" = "" ] \|\| [ ! -e "$keyfile" ] ; then
[963]	561	LogIt "Unknown config detected. Default keyboard map will be used."
[747]	562	return
	563	else
	564	echo "Found $keyfile" >> $LOGFILE
	565	fi
	566	fi
	567	if [ ! -e "$KEYDIR/keymaps" ] ; then
[963]	568	LogIt "Keyboard mapping directory not found. Default keyboard map will be used."
[747]	569	return
	570	fi
	571	echo "keyfile=$keyfile" >> $LOGFILE
	572	locale=`grep -F KEYTABLE "$keyfile" \| tr -d '"' \|cut -d'=' -f2`
	573	[ ! "$locale" ] && locale=`grep '.map$' "$keyfile" \| sed 's/^.* //'` # Slackware
[1465]	574	[ ! "$locale" ] && locale=`grep -E '^KEYMAP=' "$keyfile" \| tr -d '"' \|cut -d'=' -f2` # Gentoo
[747]	575	echo "locale=$locale" >> $LOGFILE
[1764]	576	#
	577	# Process the keymaps dir once for all
	578	# AddKeyboardMappingFile will use it recursively
	579	#
	580	find $KEYDIR/keymaps > $MINDI_TMP/keymaps.find
	581	mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find \| grep -F "/${locale}." \| grep -vx " #."`
	582	[ ! "$mp" ] && mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find \| grep "$locale[^r][^/]" \| grep -vx " #."`
[747]	583	# If we have multiple keymaps then log it !!
	584	echo "$mp" \| grep -q " "
	585	if [ $? -eq 0 ]; then
	586	echo "WARNING: Multiple keymaps found: $mp" \| tee -a $LOGFILE
	587	echo "The following one will be used" >> $LOGFILE
	588	fi
	589	for i in $mp ; do
	590	mappath=$i
	591	[ -e "$i" ] && [ ! -d "$i" ] && break
	592	done
	593	if [ ! -e "$mappath" ] \|\| [ -d "$mappath" ] ; then
	594	mappath=$(locate /kbd/keymaps//$locale)
	595	fi
	596	echo "mappath = $mappath" >> $LOGFILE
	597	if [ ! -e "$mappath" ] \|\| [ -d "$mappath" ] ; then
[963]	598	LogIt "Keyboard mapping file not found. Default keyboard map will be used."
[747]	599	return
	600	fi
	601	echo -en "Adding the following keyboard mapping tables: "
	602	mkdir -p $bigdir/tmp
	603	echo "$mappath" > $bigdir/tmp/KEYMAP-LIVES-HERE
	604	KBDEPTH=0
	605	AddKeyboardMappingFile $mappath
	606	echo -e "$DONE"
[1764]	607	rm -f $MINDI_TMP/keymaps.find
[747]	608	return 0
	609	}
	610
	611
	612	FindIsolinuxBinary() {
	613	ISOLINUX=/usr/lib/isolinux.bin
	614	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib/syslinux/isolinux.bin
[1491]	615	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib64/syslinux/isolinux.bin
[747]	616	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/syslinux/isolinux.bin
	617	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib/syslinux/isolinux.bin
[1491]	618	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib64/syslinux/isolinux.bin
[747]	619	[ ! -e "$ISOLINUX" ] && ISOLINUX=`locate isolinux.bin \| grep -x "/.*/isolinux.bin"`
	620	[ ! -e "$ISOLINUX" ] && Die "Please install isolinux first. If your syslinux RPM doesn't include isolinux, you may download an isolinux RPM from Mondo's website - go to http://www.mondorescue.com and click on 'Download'"
	621	echo "Found isolinux.bin at $ISOLINUX" >> $LOGFILE
	622	}
	623
	624
	625	FindLiloBinary() {
	626	if which lilo &> /dev/null ; then
[925]	627	if which lilo.real > /dev/null 2> /dev/null ; then
	628	LILO_EXE=lilo.real
[963]	629	LogIt "lilo.real found; will be used instead of lilo (grumble mutter)"
[925]	630	else
	631	LILO_EXE=lilo
	632	fi
	633	$LILO_EXE -V \| grep -F "21.6" > /dev/null && Die "Please upgrade LILO. Your version has a serious bug. If you're not _using_ LILO, fine, uninstall it. :)"
[747]	634	else
[925]	635	LILO_EXE=`which false`
[747]	636	fi
	637	}
	638
[925]	639
[747]	640	FindSensibleBootBFile() {
	641	local i out last
	642	out=""
	643	last=""
	644	for i in `find /boot -type f \| grep -v chain \| grep -v os2 \| sort -u` ; do
	645	if [ "`strings $i 2> /dev/null \| head -n1`" = "LILO" ] ; then
	646	out="$out $i"
[925]	647	last="$i"
[747]	648	fi
	649	done
	650	echo "$last"
	651	}
	652
	653
	654	FindSpecificModuleInPath() {
	655	local modpaths pwd line
	656	pwd=`pwd`
	657	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	658	cd $MINDI_TMP
[747]	659	else
	660	cd /
	661	fi
	662	if [ ! -e "$1" ] ; then
[963]	663	LogIt "WARNING - cannot search specific path '$1'"
[747]	664	return 1
	665	fi
	666	modpaths=`find $1 -name $2.*o -type f`
	667	[ "$?" -ne "0" ] && Die "find $1 -name $2.o -type f --- failed"
	668	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2.o.gz -type f`
	669	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2.ko.gz -type f`
	670	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2 -type f`
	671	echo "$modpaths"
	672	cd $pwd
	673	}
	674
	675
	676	GenerateGiantDependencyList() {
	677	local incoming loc fname list_of_files i tempfile outfile progress filelist res r mapfile mappath included_list included_item old_pwd tempdepfile modres noof_lines lvmversion lvmresolved
	678
	679	echo -en "Analyzing dependency requirements"
	680	outfile=$1
[940]	681	tempfile=$MINDI_TMP/$$.txt
[747]	682	incoming=`ReadLine`
	683
	684	> $tempfile
	685	progress=0
	686	res=0
	687	noof_lines=$2
	688	while [ "$incoming" != "" ] ; do
[861]	689	if echo "$incoming" \| grep -x " #." &> /dev/null ; then
	690	incoming=`ReadLine`
	691	continue
	692	fi
	693	if [ "$incoming" = "LVMFILES:" ] ; then
	694	break
	695	fi
[747]	696	filelist=`GenerateListForFile "$incoming"`
	697	r=$?
[963]	698	[ "$r" -ne "0" ] && LogIt "$incoming not found"
[747]	699	res=$(($res+$r))
[861]	700	# echo "'$incoming' generates filelist '$filelist'" >> $LOGFILE
[747]	701	for fname in $filelist ; do
[861]	702	[ "$fname" != "" ] && echo "$fname" >> $tempfile
[747]	703	done
	704	progress=$(($progress+1))
	705	echo -en "\r\t\t\t\t\t\t\t\t"
	706	i=$(($progress*100))
	707	i=$(($i/$noof_lines))
	708	echo -en "$i"
	709	echo -en "%"
	710	modres=$(($progress%4))
	711	[ "$modres" -eq "0" ] && echo -en "\t/"
	712	[ "$modres" -eq "1" ] && echo -en "\t-"
	713	[ "$modres" -eq "2" ] && echo -en "\t\\"
	714	[ "$modres" -eq "3" ] && echo -en "\t\|"
	715	incoming=`ReadLine`
	716	done
[861]	717	if [ "$incoming" = "LVMFILES:" ] ; then
	718	incoming=`ReadLine`
	719	lvmversion=""
	720	while [ "$incoming" != "" ] ; do
	721	if echo "$incoming" \| grep -x " #." &> /dev/null ; then
	722	incoming=`ReadLine`
	723	continue
	724	fi
	725	filelist=`GenerateListForFile "$incoming"`
	726	for tool in $filelist ; do
	727	lvmresolved=`readlink -f $tool`
[1342]	728	if [ "$tool" = "$lvmresolved" ]; then
[861]	729	echo "$tool" >> $tempfile
	730	elif echo "$lvmresolved" \| grep "lvmiopversion" &> /dev/null ; then
	731	if [ "$lvmversion" = "" ] ; then
	732	lvmversion=`$lvmresolved`
	733	echo "$lvmresolved" >> $tempfile
	734	fi
	735	toolstripped=`echo $tool \| $AWK -F / '{print $NF;}'`
[1342]	736	if [ "$lvmversion" = "200" ]; then
[861]	737	# pvdata and lvmcreate_initrd don't exist in LVM2
	738	case "$toolstripped" in
	739	"pvdata")
	740	continue
	741	;;
	742	"lvmcreate_initrd")
	743	continue
	744	;;
	745	esac
	746	fi
	747	toolpath="/sbin/lvm-"$lvmversion"/"$toolstripped
	748	if [ -e "$toolpath" ] ; then
	749	echo "$toolpath" >> $tempfile
	750	echo "$tool" >> $tempfile
	751	else
	752	toolpath="/lib/lvm-"$lvmversion"/"$toolstripped
	753	fi
	754	if [ -e "$toolpath" ] ; then
	755	echo "$toolpath" >> $tempfile
	756	echo "$tool" >> $tempfile
	757	else
	758	echo "Where are your LVM-Tools? Couldn't find $tool"
	759	fi
	760	else
	761	echo "$tool" >> $tempfile
	762	fi
	763	done
	764	progress=$(($progress+1))
	765	echo -en "\r\t\t\t\t\t\t\t\t"
	766	i=$(($progress*100))
	767	i=$(($i/$noof_lines))
	768	echo -en "$i"
	769	echo -en "%"
	770	modres=$(($progress%4))
	771	[ "$modres" -eq "0" ] && echo -en "\t/"
	772	[ "$modres" -eq "1" ] && echo -en "\t-"
	773	[ "$modres" -eq "2" ] && echo -en "\t\\"
	774	[ "$modres" -eq "3" ] && echo -en "\t\|"
	775	incoming=`ReadLine`
	776	done
[747]	777	fi
	778	echo -en "$DONE\nMaking complete dependency list"
	779
	780	tr -s '/' '/' < $tempfile \| sort -u > $tempfile.new
	781	mv -f $tempfile.new $tempfile
	782	> $outfile.pre
	783	progress=0
	784	noof_lines=`cat $tempfile \| wc -l`
	785	for fname in `cat $tempfile` ; do
[925]	786	echo "$fname" >> $outfile.pre
	787	LocateDeps $fname >> $outfile.pre
	788	progress=$(($progress+1))
[747]	789	echo -en "\r\t\t\t\t\t\t\t\t"
	790	i=$(($progress*100))
	791	i=$(($i/$noof_lines))
	792	echo -en "$i"
	793	echo -en "%"
[925]	794	modres=$(($progress%4))
[747]	795	[ "$modres" -eq "0" ] && echo -en "\t/"
	796	[ "$modres" -eq "1" ] && echo -en "\t-"
	797	[ "$modres" -eq "2" ] && echo -en "\t\\"
	798	[ "$modres" -eq "3" ] && echo -en "\t\|"
	799	done
[1684]	800	if [ _"$MONDO_SHARE" != _"" ]; then
[925]	801	mkdir -p $bigdir/tmp
	802	mkdir -p $bigdir/sbin
	803	mkdir -p $bigdir/bin
[940]	804	if [ -e "$MINDI_TMP/post-nuke.tgz" ] ; then
[963]	805	LogIt "\nIncorporating post-nuke tarball"
[925]	806	old_pwd=`pwd`
	807	cd $bigdir
[963]	808	tar -zxf $MINDI_TMP/post-nuke.tgz \|\| LogIt "Error occurred when untarring post-nuke tarball"
[925]	809	cd $old_pwd
[747]	810	fi
[963]	811	if cp -f $MINDI_TMP/mondo*restore $bigdir/usr/bin 2>> $LOGFILE ; then
[925]	812	LocateDeps $bigdir/usr/bin/mondo*restore >> $outfile.pre
	813	else
[963]	814	LogIt "Cannot find mondo*restore in mondo's tempdir, $MINDI_TMP"
	815	LogIt "I bet you've got a spare copy of Mondo or Mindi floating around on your system."
[925]	816	LogIt "If Mindi was called by Mondo then send me a bug report.\n It not, type 'ps ax' to see which Mondo-related process is still running;\n then kill it. :-)\n Finally, run Mindi again."
	817	Die "Odd."
	818	fi
[963]	819	cp -f $MINDI_TMP/BOOTLOADER.* $bigdir 2> /dev/null \|\| LogIt "\nMondo v1.2x defaults to LILO as the bootloader, BTW."
[940]	820	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[963]	821	LogIt "Incorporating NFS-related settings"
[925]	822	for r in NFS-* ISO-PREFIX ; do
[963]	823	cp -f $MINDI_TMP/$r $bigdir/tmp 2>> $LOGFILE \|\| Die "Cannot copy $r - did you run out of disk space?"
[925]	824	echo "Copying $r to ramdisk" >> $LOGFILE
	825	done
	826	fi
[747]	827	fi
[925]	828	tr ' ' '\n' < $outfile.pre \| tr -s '/' '/' \| grep -Fvx "" \| sort -u \| grep -Ev "/libX11\|/libXext\|/libXi\|/libgtk\|/libgdk" > $outfile
[747]	829	rm -f $tempfile $outfile.pre
	830	[ "$res" -eq "0" ] && echo -e "\r\t\t\t\t\t\t\t\t$DONE" \|\| echo "\nFailed."
	831	return $res
	832	}
	833
	834
	835	GenerateListForFile() {
	836	local files_found loc fname incoming i res
	837	incoming="$1"
	838	files_found=""
	839	res=0
	840
	841	for fname in $incoming ; do
	842	files_found="$files_found `LocateFile $fname`"
	843	done
	844
	845	echo "$files_found" \| tr ' ' '\n' \| sort -u \| tr '\n' ' '
	846	}
	847
	848
	849	# Returns all disk devices which are part of a raid array
	850	GetAllRaidMembers() {
	851	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]device/ if(\$2) {print \$2}" < /etc/raidtab
	852	}
	853
	854
	855	GetFileSizeList() {
	856	local i
	857	for i in `find $1 -type d -o -print` ; do
	858	du -sk $i
	859	done
	860	}
	861
	862
	863	GetHomeDir() {
	864	local res loc
	865	loc=`which $1 2>/dev/null`
	866	res=`file $loc \| $AWK '{print $NF;}'`
	867	dirname $res
	868	}
	869
	870
[1230]	871	# Check kernel filesystem capabilites for accessing initrd image
	872	#
	873	# Interface definition:
	874	# param #1: absolute path to kernel image
	875	GetInitrdFilesystemToUse() {
	876
	877	# interface test: make sure we have one parameter
	878	if [ $# -ne 1 ]; then
	879	Die "GetInitrdFilesystemToUse(): Expected 1 parameter, got $#."
	880	fi
	881
	882	# interface parameters
	883	local lvKernelImage=$1
	884
	885	# local constants (filesystem magic strings)
	886	local lcMagicCramfs="<3>cramfs: wrong magic"
	887	local lcMagicExt2fs="<3>EXT2-fs: blocksize too small for device."
[1730]	888	local lcMagicInitfs="<6>checking if image is initramfs...\|<6>Unpacking initramfs..."
[1230]	889
	890	# local variables
	891	local lvOffset
	892	local lvScanRes
	893	local lvUseFilesystem
	894
	895	# say where we are.
	896	echo " GetInitrdFilesystemToUse(): called with parameter: $lvKernelImage.\n" >> $LOGFILE
	897
	898	# verify that file exists
	899	[ ! -f $lvKernelImage ] && Die "File $lvKernelImage not found. Terminating."
	900
[1566]	901	# Kernel may be gzip compressed
[1730]	902	file $lvKernelImage 2>&1 \| grep -q gzip
[1566]	903	if [ $? -eq 0 ]; then
[1730]	904	lvScanRes=`gzip -cd $lvKernelImage \| strings \| grep -E "$lcMagicCramfs\|$lcMagicExt2fs\|$lcMagicInitfs"`
[1566]	905	else
	906	# get offet of gzip magic "1f8b0800" in file
	907	lvOffset=`od -vA n -t x1 $lvKernelImage \| tr -d '[:space:]' \| awk '{ print match($0, "1f8b0800")}'`
	908	[ $lvOffset -eq 0 ] && Die "gzip magic not found in file $lvKernelImage. Terminating."
	909	lvOffset=`expr $lvOffset / 2`
	910	echo " GetInitrdFilesystemToUse(): gzip magic found at lvOffset $lvOffset.\n" >> $LOGFILE
[1230]	911
[1566]	912	# scan kernel image for initrd filessystem support
[1730]	913	lvScanRes=`dd ibs=1 skip=$lvOffset if=$lvKernelImage obs=1M 2>/dev/null \| gunzip -c 2> /dev/null \| strings \| grep -E "$lcMagicCramfs\|$lcMagicExt2fs\|$lcMagicInitfs"`
[1566]	914	fi
[1230]	915
	916	# determine which filesystem to use for initrd image: ext2fs, gzip'ed cpio (initramfs ) or cramfs
[1730]	917	if [ `echo $lvScanRes \| grep -Ec "$lcMagicExt2fs"` -eq 1 ]; then
[1230]	918	lvUseFilesystem="ext2fs"
[1730]	919	elif [ `echo $lvScanRes \| grep -Ec "$lcMagicInitfs"` -eq 1 ]; then
[1230]	920	lvUseFilesystem="initramfs"
[1730]	921	elif [ `echo $lvScanRes \| grep -Ec "$lcMagicCramfs"` -eq 1 ]; then
[1230]	922	lvUseFilesystem="cramfs"
	923	else
	924	lvUseFilesystem="UNSUPPORTED"
	925	fi
	926
	927	# say what we are using
	928	echo " GetInitrdFilesystemToUse(): Filesytem to use for initrd is $lvUseFilesystem.\n" >> $LOGFILE
	929
	930	# return file system to use
	931	echo "$lvUseFilesystem"
	932
	933	}
	934
[747]	935	# Searches parent raid device of given disk device
	936	# $1: disk device (i.e. /dev/hda1)
	937	GetParentRaidDev() {
	938	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]raiddev/ {dev=\$2} /^[[:space:]]*device/ {if(\$2==\"$1\") {print dev; exit}}" < /etc/raidtab
	939	}
	940
	941
	942	# Searches members of raid device
	943	# $1: raid device (/dev/md...)
	944	GetRaidDevMembers() {
	945	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]raiddev/ {if(dev) exit; if(\$2 == \"$1\") dev=\$2} /^[[:space:]]*device/ {if(dev) {print \$2}}" < /etc/raidtab
	946	}
	947
	948
	949	HackPathsToFailsafe() {
	950	local incoming newpath kver stub i pwd
	951	kver=`uname -r`
	952	incoming=`ReadLine`
	953	pwd=`pwd`
[940]	954	cd $MINDI_TMP
[747]	955	while [ "$incoming" != "" ] ; do
[925]	956	stub=`basename $incoming`
	957	newpath=`FindSpecificModuleInPath lib/modules/$FAILSAFE_KVER $stub`
	958	for i in $newpath ; do
	959	echo "$i"
	960	done
	961	read incoming
[747]	962	done
	963	cd $pwd
	964	}
	965
	966
	967	ListAllPartitions() {
	968	local res currline partition all_partitions ap_orig remaining i j
	969
[1755]	970	grep -vx " #." $MY_FSTAB \| grep -vx " none." \| $AWK '/^\/dev\/[imhs]d\|\|^LABEL=\/\|^UUID=/ && !/fdd\|cdr\|zip\|floppy/ {print $1}'
[747]	971	[ -e "/etc/raidtab" ] && $AWK '/^ *device/ {print $2}' /etc/raidtab
	972	return
	973	}
	974
	975
	976	ListImagesForUser() {
	977	local path fname
	978	path=$1
	979	echo -en "In the directory '$path' you will find the images:-\n"
	980	for fname in `ls $path \| grep -F mindi-` ; do
	981	printf "%19s " $fname
	982	done
	983	echo " "
	984	}
	985
	986
	987	ListKernelModulePaths() {
	988	local module_list module fname oss r kern
	989	oss="/root/oss/modules"
[1399]	990	module_list="$MODULES"
[1230]	991	# Remove unwanted modules from list
	992	for i in $DENY_MODS; do
	993	module_list=`echo ${module_list} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1726]	994	EXTRA_MODS=`echo ${EXTRA_MODS} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1230]	995	done
[747]	996	###
	997	### Sq-Modification ... Use kernelname for module search path if specified
	998	###
	999	# kern="`uname -r`"
	1000	if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
	1001	then
	1002	kern=${kernelname}
	1003	else
	1004	kern="`uname -r`"
	1005	fi
	1006	###
	1007	### Sq-Mod End
	1008	###
	1009	for module in $module_list $EXTRA_MODS ; do
	1010	r=`find /lib/modules/$kern -type f \| grep "/${module}\..*o" \| tail -n1`
	1011	echo "module $module --> $r" >> $LOGFILE
	1012	[ "$r" ] && echo "$r"
	1013	[ -f "$oss" ] && find $oss \| grep -F $module
	1014	done
	1015	find /lib/modules/$kern/modules.* -type f 2> /dev/null
	1016	[ -f "$oss" ] && find $oss.* 2> /dev/null
	1017	}
	1018
	1019
	1020	LocateDeps() {
	1021	local incoming fname deps
[1724]	1022	incoming="$*"
[747]	1023	for fname in $incoming ; do
	1024	if [ ! -e "$fname" ] ; then
[963]	1025	echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
[747]	1026	if echo $fname \| grep lvm &> /dev/null ; then
	1027	echo "This warning only affects you if you are using LVM." >> $LOGFILE
[1399]	1028	if echo "$MODULES" \| grep lvm &> /dev/null ; then
[747]	1029	echo "I think you are, so please take heed!" >> $LOGFILE
	1030	# LogIt "Where is liblvm? You need it."
	1031	else
	1032	echo "I don't think you are, so don't worry about it." >> $LOGFILE
	1033	fi
	1034	fi
	1035	elif [ -h "$fname" ] && [ -x "$fname" ] ; then
	1036	echo "$fname is softlink" >> $LOGFILE
	1037	else
[1526]	1038	ldd $fname 2> /dev/null \| ProcessLDD
[747]	1039	fi
	1040	done
	1041	}
	1042
[925]	1043
[860]	1044	# Give all symlinks recursively of a full path name
	1045	ReadAllLink() {
	1046	file="$1"
[747]	1047
[860]	1048	if [ ! -h $file ]; then
	1049	echo "$file"
	1050	return 0
	1051	fi
[747]	1052
[1021]	1053	link=`readlink -f $file`
[862]	1054	d=`dirname $file`
	1055	if [ ! -e "$link" -a ! -e "$d/$link" ]; then
	1056	echo "Problem with dead link on $file -> $link" >> $LOGFILE
	1057	fi
[1230]	1058	if [ -h "$d" ]; then
	1059	echo "$link $d"
[860]	1060	else
[1230]	1061	echo "$link"
	1062	fi
[860]	1063	}
	1064
[925]	1065
[747]	1066	LocateFile() {
	1067	local i path fname_to_find location output resolved tmp stub cache_id loclist
	1068	fname_to_find="$1"
[1526]	1069	# It's an absolute path
[747]	1070	if echo "$fname_to_find" \| grep -x "/.*" ; then
[859]	1071	output="$fname_to_find"
[860]	1072	if [ -h "$output" ] ; then
	1073	output="`ReadAllLink $output` $output"
	1074	fi
[859]	1075	echo "$output"
	1076	return 0
[747]	1077	fi
[1526]	1078	# It's not an absolute path
[747]	1079	output=""
[1526]	1080	for path in /etc /usr /usr/bin /usr/sbin /bin /usr/X11R6/bin /sbin /usr/local/bin /usr/local/sbin `find /usr/lib /lib /usr/local/lib /usr/X11R6/lib /usr/lib64 /lib64 /usr/local/lib64 /usr/X11R6/lib64 -type d -maxdepth 1 2> /dev/null` ; do
	1081	#for path in /etc /usr /usr/bin /usr/sbin /bin /usr/X11R6/bin /sbin /usr/local/bin /usr/local/sbin /usr/lib /usr/lib64 /usr/lib64/* /lib /lib64 /lib64/* /usr/local/lib /usr/local/lib64 /usr/local/lib64/* /usr/X11R6/lib /usr/X11R6/lib64 /usr/X11R6/lib64/* ; do
	1082	[ -h "$path" ] && continue
	1083	[ ! -e "$path/$fname_to_find" ] && continue
	1084	output="$path/$fname_to_find $output"
	1085	if [ -h "$path/$fname_to_find" ] ; then
	1086	output="`ReadAllLink $path/$fname_to_find` $output"
	1087	fi
[747]	1088	done
	1089	if [ "$output" = "" ] ; then
[860]	1090	return 1
[747]	1091	fi
	1092	echo "$output"
	1093	return 0
	1094	}
	1095
	1096
	1097	LogIt() {
	1098	if [ -e /dev/stderr ] ; then
[925]	1099	echo -e "$1" >> /dev/stderr
[747]	1100	elif [ -e /usr/bin/logger ] ; then
[925]	1101	/usr/bin/logger -s $1
[747]	1102	fi
[965]	1103	echo -e "$1" >> $LOGFILE
[747]	1104	}
	1105
	1106
	1107	# Called by TurnTgzIntoRdz, to make /tmp/mondo-restore.cfg
	1108	MakeMondoConfigFile() {
	1109	local outfile use_lzo use_comp use_star
	1110	outfile=$1
	1111	> $outfile
	1112	[ "$TAPESIZE" ] && echo "media-size $TAPESIZE" >> $outfile
	1113	[ "$TAPEDEV" ] && echo "media-dev $TAPEDEV" >> $outfile
[1698]	1114	[ "$USBDEVICE" ] && echo "usb-dev $USBDEVICE" >> $outfile
[747]	1115	[ "$FILES_IN_FILELIST" ] && echo "files-in-filelist $FILES_IN_FILELIST" >> $outfile
	1116	[ "$LAST_FILELIST_NUMBER" ] && echo "last-filelist-number $LAST_FILELIST_NUMBER" >> $outfile
	1117	[ "$INTERNAL_TAPE_BLOCK_SIZE" ] && echo "internal-tape-block-size $INTERNAL_TAPE_BLOCK_SIZE" >> $outfile
	1118	use_lzo=$USE_LZO; [ "$use_lzo" = "" ] && use_lzo="no"
[998]	1119	use_gzip=$USE_GZIP; [ "$use_gzip" = "" ] && use_gzip="no"
[747]	1120	use_comp=$USE_COMP; [ "$use_comp" = "" ] && use_comp="yes"
	1121	use_star=$USE_STAR; [ "$use_star" = "" ] && use_star="no"
	1122	echo "use-lzo $use_lzo" >> $outfile
[998]	1123	echo "use-gzip $use_gzip" >> $outfile
[747]	1124	echo "use-star $use_star" >> $outfile
	1125	echo "use-comp $use_comp" >> $outfile
	1126	echo "datestamp `date`" >> $outfile
	1127	[ "$ESTIMATED_TOTAL_NOOF_SLICES" ] && echo "total-slices $ESTIMATED_TOTAL_NOOF_SLICES" >> $outfile
[940]	1128	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-IPADDR nfs-client-ipaddr $outfile
	1129	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-NETMASK nfs-client-netmask $outfile
	1130	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-BROADCAST nfs-client-broadcast $outfile
	1131	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-DEFGW nfs-client-defgw $outfile
	1132	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-MOUNT nfs-server-mount $outfile
	1133	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-PATH nfs-server-path $outfile
	1134	AddFileToCfgIfExists $MINDI_TMP/NFS-DEV nfs-dev $outfile
	1135	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-IPADDR nfs-server-ipaddr $outfile
	1136	AddFileToCfgIfExists $MINDI_TMP/ISO-DEV iso-dev $outfile
	1137	AddFileToCfgIfExists $MINDI_TMP/ISO-MNT iso-mnt $outfile
	1138	AddFileToCfgIfExists $MINDI_TMP/ISO-PREFIX iso-prefix $outfile
	1139	AddFileToCfgIfExists $MINDI_TMP/ISODIR isodir $outfile
	1140	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.DEVICE bootloader.device $outfile
	1141	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.NAME bootloader.name $outfile
	1142	AddFileToCfgIfExists $MINDI_TMP/KEYMAP-LIVES-HERE keymap-lives-here $outfile
	1143	AddFileToCfgIfExists $MINDI_TMP/TAPEDEV-HAS-DATA-DISKS tapedev-has-data-disks $outfile
	1144	AddFileToCfgIfExists $MINDI_TMP/BACKUP-MEDIA-TYPE backup-media-type $outfile
	1145	AddFileToCfgIfExists $MINDI_TMP/DIFFERENTIAL differential $outfile
[949]	1146	AddFileToCfgIfExists $MINDI_TMP/ACL acl $outfile
	1147	AddFileToCfgIfExists $MINDI_TMP/XATTR xattr $outfile
[747]	1148	}
	1149
	1150
	1151	MakeModuleLoadingScript() {
	1152	local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
	1153	tmpmodprobe_flag=$1
	1154	outfile=$2
	1155	> $outfile \|\| Die "Cannot create empty $outfile"
	1156	echo -en "#\041/bin/sh\n\n" >> $outfile
	1157	echo "echo -en \"Loading your modules...\"" >> $outfile
	1158	if [ "$YOUR_KERNEL_SUCKS" ] ; then
	1159	kver=$FAILSAFE_KVER
[940]	1160	cd $MINDI_TMP
[747]	1161	searchpath=lib/modules/$kver
	1162	else
	1163	###
	1164	### Sq-Modification ... Use kernelname for module search path if specified
	1165	###
	1166	#kver=`uname -r`
	1167	if [ "${kernelname}" != "" ]
	1168	then
[925]	1169	kver=${kernelname}
[747]	1170	else
[925]	1171	kver=`uname -r`
[747]	1172	fi
	1173	###
	1174	### Sq-Modification end
	1175	###
	1176	searchpath=/lib/modules/$kver
	1177	fi
	1178
	1179	echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
[1399]	1180	list_to_echo="$MODULES"
[1230]	1181	# Remove unwanted modules from list
	1182	for i in $DENY_MODS; do
	1183	list_to_echo=`echo ${list_to_echo} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1726]	1184	EXTRA_MODS=`echo ${EXTRA_MODS} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1230]	1185	done
[925]	1186
[747]	1187	# Make temporary modprobe.conf file if we are told so
[1342]	1188	if [ "$tmpmodprobe_flag" = "Y" ] ; then
[940]	1189	infile="$MINDI_TMP/modprobe.conf.mindi"
[747]	1190	find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 \| xargs -0 cat > $infile
	1191	else
	1192	infile="/etc/modules.conf"
	1193	fi
[1721]	1194
[747]	1195	for module in $list_to_echo $EXTRA_MODS ; do
	1196	params=`sed -n "s/^options \\+$module \\+//p" $infile`
	1197	modpaths=`FindSpecificModuleInPath $searchpath $module`
	1198	for i in $modpaths ; do
	1199	echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
	1200	\| tr '.' '#' \
	1201	\| sed s/#o#gz/#o/ \
	1202	\| sed s/#o#gz/#o/ \
	1203	\| sed s/#ko#gz/#ko/ \
	1204	\| sed s/#ko#gz/#ko/ \
	1205	\| tr '#' '.' >> $outfile
	1206	echo -en "$i added to module list.\n" >> $LOGFILE
	1207	done
	1208	done
	1209	echo -en "done\n" >> $outfile
	1210	echo "echo \"Done.\"" >> $outfile
	1211	chmod +x $outfile
	1212	cd /
	1213	# Remove temporary modprobe.conf file if we have created one
[1342]	1214	if [ "$tmpmodprobe_flag" = "Y" ] ; then
[747]	1215	rm -f $infile
	1216	fi
	1217	}
	1218
	1219
	1220	MakeMountlist() {
	1221	local scratchdir mountlist all_partitions current_partition \
	1222	partition_size partition_format outstring partition_number \
	1223	partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
	1224	absolute_partition old_partition_fmt current_lvolume
	1225
[967]	1226	echo "Your raw fstab file looks like this:" >> $LOGFILE
	1227	echo "------------------------------------" >> $LOGFILE
[747]	1228	cat $MY_FSTAB >> $LOGFILE
[967]	1229	echo "Your mountlist will look like this:" \| tee -a $LOGFILE
	1230	echo "-----------------------------------" >> $LOGFILE
[747]	1231
	1232	# scratchdir, mountlist(OUT)
[940]	1233	scratchdir=$MINDI_TMP
[747]	1234	mountlist=$1
	1235
	1236	# NB: partition = device
	1237	# NB: mountpt = where the device is mounted
	1238
	1239	[ -e "$MY_FSTAB" ] \|\| Die "Cannot find your fstab file ($MY_FSTAB)"
	1240
[1684]	1241	[ "$mountlist" != "" ] && rm -Rf $mountlist
[747]	1242	> $mountlist
	1243	echo -en "\rHang on...\r"
	1244	all_partitions=""
	1245
	1246	if [ $LVM != "false" ]; then
	1247	echo -en "\rAnalyzing LVM...\r"
[968]	1248	$MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
[971]	1249	if [ $? -ne 0 ]; then
[963]	1250	LVM="false"
	1251	fi
[968]	1252	all_partitions=`cat $MINDI_TMP/lvm.res \| grep -F ">>>" \| cut -d' ' -f2-32`
[747]	1253	fi
	1254	all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
	1255	# echo "all partitions = $all_partitions" > /dev/stderr
	1256	for i in $IMAGE_DEVS ; do
	1257	mount \| grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
	1258	done
	1259	[ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" \| tr ' ' '\n' \| sort -u \| tr '\n ' ' '`"
[1755]	1260	printf " %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID \| tee -a $LOGFILE
[747]	1261	useless_dev="/dev/floppy /dev/fd0h1440 /dev/fd0H1440 /dev/cdrom /dev/cdrom/cdrom /dev/cdrom/cdrom1 /dev/cdrom/cdrom2 /dev/cdrom0 /dev/cdrom1 /dev/cdrom2 /dev/cdrom3 /dev/cdrw /dev/scd /dev/ram :/ /dev/sr0 /dev/sr1 /dev/cdrom1"
	1262	for c_p in $all_partitions ; do
	1263	[ "`echo "$useless_dev" \| grep -F "$c_p"`" != "" ] \|\| [ "`echo "$c_p" \| grep ":"`" != "" ] && continue
	1264	[ "`echo "$c_p" \| grep -x "/dev/cdroms.*"`" ] && continue
	1265	if [ -h "$c_p" ] && [ "`echo "$c_p" \| grep -F "/dev/hd"`" = "" ] && [ "`echo "$c_p" \| grep -F "/dev/sd"`" = "" ] && [ "`echo "$c_p" \| grep -F "/dev/md"`" = "" ] ; then
[861]	1266	current_partition=`readlink -f $c_p`
[747]	1267	[ "`echo "$current_partition" \| grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
	1268	[ "`echo "$useless_dev" \| grep -F "$current_partition"`" ] && continue
	1269	else
	1270	current_partition="$c_p"
	1271	fi
	1272	[ "$c_p" = "none" ] && continue
	1273	redhat_label=""
[957]	1274	uuid=""
[861]	1275	absolute_partition=`readlink -f $c_p`
[747]	1276	partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $2}' \| head -n1`
	1277
	1278	# Detects noauto partitions not mounted and exclude them
	1279	partition_option=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $4}' \| head -n1`
	1280	if [ "`echo "$partition_option" \| grep -i noauto`" != "" ] && [ "`mount \| grep -w "$partition_mountpt"`" = "" ] ; then
	1281	continue
	1282	fi
	1283
	1284	# This part tries to retrieve the correct device from a LABEL line in /etc/fstab
	1285	# current_partition contains only first column of /etc/fstab
	1286	if [ "`echo "$current_partition" \| /bin/grep -i "LABEL="`" != "" ]; then
	1287	str_to_find_fmt_with=$current_partition
[980]	1288	redhat_label=`echo "$current_partition" \| cut -d'=' -f2`
[747]	1289	actual_dev=""
[853]	1290
	1291	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1292	if [ -x "/sbin/findfs" ]; then
[855]	1293	actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
[853]	1294	fi
[747]	1295
[853]	1296	# 2nd try : blkid, the good way for all LABEL except swap
	1297	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1298	actual_dev=`/sbin/blkid \| /bin/grep "$redhat_label" \| grep LABEL= \| cut -d':' -f1`
[747]	1299	# For LVM FS it will give a /dev/dm-# which should then be converted
[748]	1300	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1301	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1302	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[747]	1303	for dev in `ls /dev/mapper/*`; do
[963]	1304	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1305	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[747]	1306	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1307	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[747]	1308	break
	1309	fi
	1310	done
	1311	fi
	1312	fi
	1313
[853]	1314	# 3rd try, which works on a standard partition (ext2/3), but not on swap
[747]	1315	# For LVM gives a /dev/mapper entry
	1316	if [ "x$actual_dev" = "x" ]; then
[980]	1317	actual_dev=`/bin/mount -l \| /bin/grep "\[$redhat_label\]" \| cut -d' ' -f1`
[747]	1318	fi
	1319
[853]	1320	# 4th try, with vol_id
[747]	1321	# SWAP only
	1322	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1323	list_swaps=`cat /proc/swaps \| /bin/grep "/dev/" \| $AWK '{ print $1 }' `
[747]	1324	for dev_swap in $list_swaps ; do
	1325	dev_exists=`/sbin/vol_id $dev_swap \| /bin/grep "$redhat_label"`
	1326	if [ "x$dev_exists" != "x" ]; then
	1327	actual_dev=$dev_swap
	1328	break;
	1329	fi
	1330	done
	1331	fi
	1332
[853]	1333	# 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
[789]	1334	# LABEL=SW-cciss/c0d0p3 (RDP)
[853]	1335	# or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
[747]	1336	# SWAP only
[789]	1337	if [ "x$actual_dev" = "x" -a _"`echo $current_partition \| /bin/grep -iE 'LABEL=SWAP\|LABEL=SW-'`" != _"" ]; then
[853]	1338	for try_dev in `tail +2 /proc/swaps \| cut -d' ' -f1`
	1339	do
	1340	# Location of the swap label for kernel 2.6
[1009]	1341	try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
[853]	1342	if [ "x$try_dev_label" = "x$redhat_label" ]; then
[855]	1343	actual_dev=$try_dev
[853]	1344	fi
	1345	done
[747]	1346	fi
[1008]	1347
	1348	# Check if one of all those tries has known success
	1349	if [ "x$actual_dev" != "x" ]; then
	1350	current_partition=$actual_dev
	1351	else
	1352	Die "Your system uses a LABEL partition ($current_partition), but you lack the tool to support it.\nPlease replace labels with their correct devices in /etc/fstab or install findfs\|blkid\|vol_id"
	1353	fi
[957]	1354	# This part tries to retrieve the correct device from a UUID line in /etc/fstab
	1355	# current_partition contains only first column of /etc/fstab
[1009]	1356	elif [ "`echo "$current_partition" \| /bin/grep -i "UUID="`" != "" ]; then
[957]	1357	str_to_find_fmt_with=$current_partition
[980]	1358	uuid=`echo "$current_partition" \| cut -d'=' -f2`
[957]	1359	actual_dev=""
	1360
	1361	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1362	if [ -x "/sbin/findfs" ]; then
	1363	actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
	1364	fi
	1365
[1531]	1366	# 2nd try : blkid, the good way for all UUID except swap
[957]	1367	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1368	actual_dev=`/sbin/blkid \| /bin/grep "$uuid" \| grep UUID= \| cut -d':' -f1`
[957]	1369	# For LVM FS it will give a /dev/dm-# which should then be converted
	1370	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1371	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1372	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[957]	1373	for dev in `ls /dev/mapper/*`; do
[963]	1374	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1375	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[957]	1376	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1377	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[957]	1378	break
	1379	fi
	1380	done
	1381	fi
	1382	fi
	1383
	1384	# 3th try, with vol_id
	1385	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1386	list_dev=`mount \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
[957]	1387	for dev in $list_dev ; do
	1388	dev_exists=`/sbin/vol_id $dev \| /bin/grep "$uuid"`
	1389	if [ "x$dev_exists" != "x" ]; then
	1390	actual_dev=$dev
	1391	break;
	1392	fi
	1393	done
	1394	fi
	1395
[1531]	1396	# 4th try, with dumpuuid (VMWare only ?) for swap
	1397	if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
	1398	list_dev=`cat /proc/swaps \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
	1399	for dev in $list_dev ; do
	1400	dev_exists=`/sbin/dumpuuid $dev \| /bin/grep "$uuid"`
	1401	if [ "x$dev_exists" != "x" ]; then
	1402	actual_dev=$dev
	1403	break;
	1404	fi
	1405	done
	1406	fi
	1407
[747]	1408	# Check if one of all those tries has known success
	1409	if [ "x$actual_dev" != "x" ]; then
	1410	current_partition=$actual_dev
	1411	else
[1315]	1412	Die "Your system uses a UUID partition ($current_partition), but you lack the tool to support it.\nPlease replace labels with their correct devices in $MY_FSTAB or install findfs\|blkid\|vol_id"
[747]	1413	fi
	1414	else
	1415	str_to_find_fmt_with=$current_partition
	1416	fi
	1417
	1418	partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
	1419	# Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
	1420	# for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
	1421	# the former is then a link to the latter, so we test whether
	1422	# $current_partition is actually such a link or not and set
[755]	1423	# $current_lvolume accordingly. On Debian you may find more than one answer
	1424	# so we remove the one corresponding to /dev/.static
	1425	# On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
	1426	# principle is the same and we need to find the link to it as well.
	1427	# Note that $current_lvolume may well be an
[747]	1428	# ordinary device. It is just to make sure that we feed the right value
	1429	# into any of the LVM tools if possible.
	1430
	1431	current_lvolume="$current_partition"
[763]	1432	if [ $LVM = "v2" ] && [ "`echo $current_partition \| grep -E '^/dev/mapper/'`" ]; then
[755]	1433	# .static dir are a Debian specificity
[763]	1434	current_lvolume="`find /dev -lname "$current_partition" \| grep -Ev '^/dev/\.static/'`"
[755]	1435	echo $current_lvolume \| grep -q ' '
[784]	1436	if [ $? -eq 0 ]; then
[755]	1437	echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE
	1438	fi
[747]	1439	fi
	1440	#
	1441	# End of LVM device style variation code (other than $current_lvolume).
	1442
[745]	1443	if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
	1444	# Size computed via LVM not directly
[747]	1445	partition_size="lvm"
	1446	else
	1447	partition_size=`SizeOfPartition $current_partition`
	1448	[ "`echo "$current_partition" \| grep "[0-9]"`" = "" ] && continue
	1449	[ "`echo "$current_partition" \| grep -c "^/"`" -ne "1" ] && continue
	1450	if [ "$partition_format" = "swap" ] \|\| [ "$partition_mountpt" = "swap" ] ; then
	1451	partition_size=`grep -Fv "Priority" /proc/swaps \| tr -s '\t' ' ' \| grep -F "$current_partition" \| $AWK '{print $3}'`
	1452	[ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
	1453	[ "$partition_format" != "swap" ] && partition_format="swap"
	1454	if [ "$partition_size" = "" ] ; then
	1455	totalsize=0
	1456	items=0
	1457	for i in `tr -s ' ' '\t' < /proc/swaps \| grep -Fv "Filename" \| cut -f3` ; do
	1458	totalsize=$(($totalsize+$i))
	1459	items=$(($items+1))
	1460	done
	1461	[ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) \|\| partition_size=0
	1462	[ "$partition_size" -lt "125000" ] && partition_size=125000
	1463	echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
	1464	fi
	1465	fi
	1466	fi
	1467	[ "$partition_mountpt" = "swap" ] && partition_format="swap"
	1468	[ "$partition_format" = "swap" ] && partition_mountpt="swap"
	1469	if [ "$partition_mountpt" = "" ] ; then
	1470	if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
	1471	if [ "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
	1472	partition_mountpt="raid"
	1473	partition_format="raid"
	1474	else
	1475	partition_mountpt="lvm"
	1476	partition_format="lvm"
	1477	fi
	1478	fi
	1479	fi
	1480	psz=$partition_size
	1481	echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
	1482	[ "$psz" != "lvm" ] && psz=$(($psz/1024))
	1483	if [ "`echo " $IMAGE_DEVS " \| grep -F " $current_partition "`" != "" ] ; then
	1484	partition_mountpt="image"
	1485	old_partition_fmt=$partition_format
	1486	partition_format="`$FDISK -l 2>> $LOGFILE \| tr '*' ' ' \| tr '+' ' ' \| tr -s ' ' '\t' \| grep -w "$absolute_partition" \| cut -f5`"
	1487	partition_size=$(($partition_size+1)); # just in case
	1488	if [ "$partition_format" = "Linux" ] ; then
	1489	echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
	1490	echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
	1491	partition_format=$old_partition_fmt
	1492	fi
	1493	fi
	1494	if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " \| grep -F " $current_partition "`" ] \|\| [ "`echo " $EXCLUDE_DEVS " \| grep " $current_partition "`" ] ; then
	1495	echo "Excluding $current_partition from mountlist" >> $LOGFILE
	1496	continue
	1497	fi
	1498	if [ ! "$partition_mountpt" ] ; then
[965]	1499	echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
[747]	1500	for qq in "" `find /dev/ida/cd ! -name 'p'` ; do
	1501	partition_format=`$FDISK -l $qq 2>> $LOGFILE \| grep -w "$c_p" \| sed 's/12/\|/' \| tr -s '\t' ' ' \| cut -d'\|' -f2 \| cut -d' ' -f2-9`
	1502	[ "$partition_format" ] && break
	1503	done
[965]	1504	echo "------- $FDISK log end ------------" >> $LOGFILE
[747]	1505	if [ "$partition_format" = "Compaq diagnostics" ] ; then
	1506	partition_format="compaq"
	1507	elif [ ! "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
[963]	1508	LogIt "Unable to find mountpoint of $current_partition - ignoring"
[747]	1509	continue
	1510	fi
	1511	fi
[1755]	1512	if [ "$redhat_label" ]; then
	1513	label="$redhat_label"
[1756]	1514	elif [ "$uuid" ]; then
[1755]	1515	label="$uuid"
	1516	fi
[747]	1517	partition_format="`echo "$partition_format" \| cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
[963]	1518	[ "$partition_format" = "auto" ] && partition_format="`mount \| grep -w $current_partition \| $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
[1755]	1519	unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
[747]	1520	if [ "$current_partition" = "" ] ; then
	1521	echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
	1522	elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
	1523	if [ "`grep -F device /etc/raidtab 2>/dev/null \| grep -F $current_partition`" ] ; then
	1524	partition_mountpt=raid
	1525	partition_format=raid
[1755]	1526	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1527	printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1528	else
	1529	echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
	1530	fi
	1531	elif [ "$partition_format" = "" ] ; then
	1532	echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
	1533	elif [ "$partition_size" = "" ] ; then
	1534	echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
	1535	elif [ "$partition_mountpt" = "/proc" ] \|\| [ "$partition_mountpt" = "/dev/pts" ] ; then
	1536	continue
	1537	else
	1538	if [ "$partition_format" = "dos" ] \|\| [ "$partition_format" = "msdos" ] ; then
	1539	echo "Stupid bastard..." >> $LOGFILE
	1540	partition_format="vfat"
	1541	fi
[1755]	1542	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1543	printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1544	fi
	1545	done
	1546	}
	1547
	1548
	1549	MakeSureNumberIsInteger() {
	1550	res=`echo "$1" \| tr -s '\-[0-9]' ' '`
	1551	if [ "$res" != " " ] && [ "$res" != "" ] ; then
	1552	echo "result = '$res'"
	1553	Die "$1 should be an integer"
	1554	fi
	1555	}
	1556
	1557
	1558	MakeSyslinuxMessageFile() {
	1559	mkdir -p $1
	1560	rmdir $1
	1561	echo -en " " > $1
	1562	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1563	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s%DDDDD%"Debian GNU\/`uname -s` `cut -d ' ' -f 3 /etc/issue.net` `hostname`"% \| sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ >> $1.tmp
	1564	else
	1565	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s/DDDDD/"`grep -i "linux" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/KKKKK/"`grep -i "kernel" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ \| sed s/' '\\r' 'on' 'an' '\/' '`uname -r`' 'on' 'an' '`uname -m`/ >> $1.tmp
	1566	fi
	1567	sed s/%r/"`uname -r`"/ $1.tmp \| sed s/%t/"`hostname`"/ > $1
	1568	rm -f $1.tmp
	1569	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1570	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1571	echo -en "Press <enter> to continue.\n" >> $1
[940]	1572	elif [ ! "$MINDI_TMP" ] ; then
[747]	1573	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
	1574	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1575	echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
	1576	fi
	1577	else
	1578	echo -en "$BOOT_MEDIA_MESSAGE" >> $1
	1579	fi
	1580	else
	1581	echo -en " \
	1582	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1583	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
	1584	fi
	1585	}
	1586
	1587
	1588	MoveHyperlinkSensibly() {
	1589	local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
	1590	filename=$1
	1591	minidir_root=$2
	1592	resides_on_diskno=$3
	1593	noof_disks=$4
	1594
	1595	[ -h "$minidir_root/$resides_on_diskno/$filename" ] \|\| Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
	1596
	1597	old_diskno=$resides_on_diskno
	1598	d=1
	1599	while [ "$d" -le "$noof_disks" ] ; do
	1600	if [ "$d" -ne "$old_diskno" ] ; then
	1601	old_pwd=`pwd`
	1602	cd $minidir_root/$old_diskno
[963]	1603	cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE \|\| Die "Can't move $filename (sensibly) from $old_diskno to $d"
[747]	1604	rm -f $filename
	1605	cd $old_pwd
	1606	fi
	1607	# when the softlink is resolvable, our work here is done
	1608	[ -e "$minidir_root/$d/$filename" ] && return 0
	1609	old_diskno=$d
	1610	d=$(($d+1))
	1611	done
	1612	return 1
	1613	}
	1614
	1615
	1616
	1617	OfferToCopyImagesToDisks() {
	1618	local imagesdir i imagename dev count boot_dev data_dev
	1619	imagesdir=$1
	1620	boot_dev=$2
	1621	data_dev=$3
[925]	1622
[966]	1623	echo -en "Would you like to create boot+data floppy disks now (y/[n]) ?"
[747]	1624	read i
	1625	[ "$i" != "y" ] && [ "$i" != "Y" ] && return
	1626	mount \| grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
	1627	echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
	1628	[ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
	1629	[ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
	1630	i=`find $imagesdir -type f \| grep -F "/mindi-root.1" 2> /dev/null`
[1282]	1631	j=`find $imagesdir -type f \| grep -F "/mindi-boot" \| grep -Ev "2880\|$BOOT_SIZE"`
[747]	1632	if [ "$i" ] ; then
	1633	CopyImageToDisk $j $data_dev "boot disk"
	1634	CopyImageToDisk $i $data_dev "root disk"
	1635	else
	1636	CopyImageToDisk $j $boot_dev "boot/root disk"
	1637	fi
	1638	count=1
	1639	for i in `find $imagesdir \| grep -F mindi-data` ; do
	1640	CopyImageToDisk $i $data_dev "data disk #$count"
	1641	count=$(($count+1))
	1642	done
	1643	}
	1644
	1645
	1646	OfferToMakeBootableISO() {
	1647	local i old_pwd
[1684]	1648	if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[966]	1649	echo -en "Shall I make a bootable CD image? (y/[n]) "
[747]	1650	read i
	1651	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1652	fi
[940]	1653	if [ ! "$MINDI_TMP" ] ; then
[963]	1654	LogIt "NB: Mindi's bootable CD always uses isolinux."
	1655	LogIt "For a bootable CD w/LILO, please use Mondo."
[747]	1656	fi
[940]	1657	rm -Rf $MINDI_TMP/iso
	1658	mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
[963]	1659	cp -f $1/.img $1/.gz $MINDI_TMP/iso/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
[747]	1660	old_pwd=`pwd`
[940]	1661	cd $MINDI_TMP/iso
[747]	1662	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1663	for i in memdisk memtest.bin memtest.img ; do
[953]	1664	j=$MINDI_LIB/$i
	1665	k=$MINDI_TMP/iso/isolinux
	1666	if [ -e "$j" ] ; then
[963]	1667	LogIt "Copying $j to $k"
[953]	1668	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1669	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1670	cp -f $j $MONDO_ROOT 2>> $LOGFILE \|\| Die "Failed to copy $j to $MONDO_ROOT"
	1671	fi
[747]	1672	done
[940]	1673	MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
[1010]	1674	cp $kernelpath $MINDI_TMP/iso/isolinux/vmlinuz 2> /dev/null \|\| Die "Cannot copy vmlinuz ($kernelpath) to mondo root ($MINDI_TMP/iso/isolinux/vmlinuz). Did you run out of disk space?"
	1675	cp $kernelpath $MONDO_ROOT/vmlinuz 2> /dev/null \|\| Die "Cannot copy vmlinuz ($kernelpath) to mondo root ($MONDO_ROOT/vmlinuz). Did you run out of disk space?"
[963]	1676	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
[1010]	1677	cp $MINDI_TMP/mindi.rdz $MONDO_ROOT/initrd.img 2>> $LOGFILE
[747]	1678	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
[940]	1679	cd $MINDI_TMP/iso/isolinux
	1680	cat $iso_cfg_file \| HackSyslinuxFile $ramdisk_size $MINDI_TMP/iso > isolinux.cfg \|\| Die "Cannot copy isolinux.cfg from mindi_home to tmp_root - did you run out of disk space?"
	1681	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1682	mv isolinux.cfg isolinux.cfg.old
	1683	sed s/interactive/iso/ isolinux.cfg.old > isolinux.cfg
	1684	fi
	1685	if [ "$ARCH" != "ia64" ] ; then
[953]	1686	cp $ISOLINUX isolinux.bin 2> /dev/null \|\| Die "Cannot copy isolinux.bin ($ISOLINUX) to tmp_root - did you run out of disk space?"
[963]	1687	cp $ISOLINUX ../ 2>> $LOGFILE
[747]	1688	fi
[940]	1689	cd $MINDI_TMP/iso
[747]	1690	if [ "$ARCH" != "ia64" ] ; then
[953]	1691	cp -f $MINDI_TMP/iso/isolinux/{isolinux.cfg,initrd.img,vmlinuz,isolinux.bin,message.txt} $MONDO_ROOT 2> /dev/null \|\| Die "Cannot copy core files to ramdisk for boot disk. Did you run out of disk space?"
[747]	1692	fi
[963]	1693	[ "$MONDO_SHARE" ] && cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
[747]	1694	if [ "$ARCH" != "ia64" ] ; then
[940]	1695	mkisofs -U -J -r -o $CACHE_LOC/mindi.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table . > /dev/null 2> $MINDI_TMP/mkisofs.log
[747]	1696	else
[1282]	1697	mkisofs -J -r -o $CACHE_LOC/mindi.iso -b images/mindi-bootroot.$BOOT_SIZE.img -c isolinux/boot.cat -no-emul-boot . > /dev/null 2> $MINDI_TMP/mkisofs.log
[747]	1698	fi
	1699	if [ "$?" -ne "0" ] ; then
[925]	1700	echo "----------- mkisofs's errors --------------" >> $LOGFILE
[940]	1701	cat $MINDI_TMP/mkisofs.log >> $LOGFILE
[925]	1702	echo "mkisofs returned the following errors:-"
[940]	1703	cat $MINDI_TMP/mkisofs.log
[963]	1704	LogIt "Failed to create ISO image."
[747]	1705	else
[925]	1706	echo "Created bootable ISO image at $CACHE_LOC/mindi.iso" >> $LOGFILE
[747]	1707	fi
[940]	1708	rm -f $MINDI_TMP/mkisofs.log
[747]	1709	cd $old_pwd
	1710	}
	1711
	1712
[1684]	1713	OfferToMakeBootableUSB() {
	1714	local i old_pwd
	1715	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[1764]	1716	echo "Shall I make a bootable USB image ? (y/[n] "
	1717	read i
	1718	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1719	if [ "$USBDEVICE" = "" ]; then
	1720	echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
	1721	read dev
	1722	USBDEVICE=$dev
[1722]	1723	fi
[1764]	1724	echo "WARNING: This will erase all content on $USBDEVICE"
	1725	echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
[1684]	1726	fi
	1727	if [ _"$MINDI_TMP" = _"" ]; then
	1728	Die "MINDI_TMP undefined"
	1729	fi
	1730	rm -Rf $MINDI_TMP/usb
	1731	mkdir -p $MINDI_TMP/usb
	1732	USBPART="${USBDEVICE}1"
	1733
	1734	echo -en "Transforming $USBDEVICE in a Bootable device "
	1735	echo -en "."
	1736	echo "Transforming $USBDEVICE in a Bootable device" >> $LOGFILE
	1737	echo "Checking $USBDEVICE" >> $LOGFILE
	1738	$FDISK -l $USBDEVICE 2>&1 >> $LOGFILE
	1739	if [ $? -ne 0 ]; then
	1740	echo "Unable to access $USBDEVICE" \| tee -a $LOGFILE
	1741	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1742	exit -1
	1743	fi
	1744	echo -en "."
[1691]	1745	echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
[1721]	1746	umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
[1684]	1747	echo "Erasing $USBDEVICE" >> $LOGFILE
[1721]	1748	$FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
[1684]	1749	d
	1750	d
	1751	d
	1752	d
	1753	n
	1754	p
	1755	1
	1756
	1757
	1758	t
	1759	b
	1760	a
	1761	1
	1762	w
	1763	EOF
	1764	if [ $? -ne 0 ]; then
	1765	echo "Unable to create a vfat Filesystem on $USBDEVICE" \| tee -a $LOGFILE
	1766	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1767	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1768	MindiExit -1
	1769	fi
	1770	echo -en "."
	1771	echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
[1688]	1772	mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
[1684]	1773	if [ $? -ne 0 ]; then
	1774	echo "Unable to create a vfat filesystem on $USBPART" \| tee -a $LOGFILE
	1775	echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" \| tee -a $LOGFILE
	1776	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1777	MindiExit -1
	1778	fi
	1779	echo -en "."
	1780	echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
	1781	mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
	1782	if [ $? -ne 0 ]; then
	1783	echo "Unable to mount $USBPART on $MINDI_TMP/usb" \| tee -a $LOGFILE
	1784	echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" \| tee -a $LOGFILE
	1785	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1786	MindiExit -1
	1787	fi
	1788	echo -en "."
[1691]	1789	mkdir -p $MINDI_TMP/usb/images
	1790	cp -f $1/.img $1/.gz $MINDI_TMP/usb/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
[1684]	1791	echo -en "."
	1792	old_pwd=`pwd`
	1793	cd $MINDI_TMP/usb
	1794	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1795	for i in memdisk memtest.bin memtest.img ; do
	1796	j=$MINDI_LIB/$i
	1797	k=$MINDI_TMP/usb
	1798	if [ -e "$j" ] ; then
	1799	LogIt "Copying $j to $k"
	1800	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1801	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1802	fi
	1803	done
	1804	echo -en "."
	1805	MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
	1806	echo -en "."
	1807	cp $kernelpath $MINDI_TMP/usb/vmlinuz 2> /dev/null \|\| Die "Cannot copy vmlinuz ($kernelpath) to mindi tmp ($MINDI_TMP/usb/syslinux/vmlinuz). Did you run out of disk space?"
	1808	echo -en "."
	1809	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
	1810	echo -en "."
	1811	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
	1812	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $MINDI_TMP/usb > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to $MINDI_TMP/usb - did you run out of disk space?"
	1813	echo -en "."
	1814	if [ "$NFS_DEV" != "" ] ; then
	1815	perl -pi -e 's/interactive/iso/' syslinux.cfg
	1816	fi
	1817	cd $old_pwd
	1818	echo -en "."
[1721]	1819	umount $MINDI_TMP/usb
[1684]	1820	if [ "$ARCH" != "ia64" ] ; then
	1821	syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
	1822	if [ "$?" -ne "0" ] ; then
	1823	echo "----------- syslinux's errors --------------" \|tee -a $LOGFILE
	1824	cat $MINDI_TMP/syslinux.log \|tee -a $LOGFILE
	1825	LogIt "Failed to create USB image."
	1826	else
	1827	echo -e "$DONE"
	1828	echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
	1829	fi
	1830	rm -f $MINDI_TMP/syslinux.log
	1831	else
	1832	echo "No USB boot support for ia64" \| tee -a $LOGFILE
	1833	MindiExit -1
	1834	fi
	1835	echo -en "."
	1836	}
	1837
	1838
[747]	1839	PluralOrNot() {
	1840	[ "$1" -gt "1" ] && echo -en "s"
	1841	}
	1842
	1843
	1844	MakeMessageFile() {
	1845	local disksize
	1846	disksize=$1
	1847	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1848	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s%DDDDD%"Debian GNU\/`uname -s` `cut -d ' ' -f 3 /etc/issue.net` `hostname`"% \| sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/
	1849	else
	1850	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s/DDDDD/"`grep -i "linux" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/KKKKK/"`grep -i "kernel" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ \| sed s/' 'r' 'on' 'an' 'm/' '`uname -r`' 'on' 'an' '`uname -m`/
	1851	fi
	1852	if [ "$disksize" -gt "2880" ] ; then
[1335]	1853	if [ _"$MONDO_SHARE" != _"" ] ; then
[925]	1854	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1855	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[925]	1856	echo -en "Press <enter> to continue.\n"
[940]	1857	elif [ ! "$MINDI_TMP" ] ; then
[925]	1858	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
	1859	else
	1860	echo -en "$BOOT_MEDIA_MESSAGE"
	1861	fi
[747]	1862	fi
	1863	fi
	1864	fi
	1865	if [ "$CDRECOVERY" = "yes" ] ; then
	1866	echo -en "\
	1867	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1868	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
	1869	fi
	1870	echo -en "\n\n\n"
	1871	}
	1872
	1873
	1874	write_full_floppy_of_kernel() {
	1875	local mtpt image old_pwd res disksize
	1876
	1877	res=0
	1878	old_pwd=`pwd`
	1879	KERN_DISK_MADE=1
	1880	disksize=$3
	1881	rand1=$RANDOM
	1882	rand2=$RANDOM
[940]	1883	image=$MINDI_TMP/$rand1.$rand2.img
	1884	mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
[963]	1885	dd if=/dev/zero of=$image bs=1k count=$disksize &> /dev/null
[964]	1886	mke2fs -N 26 -F $image &> /dev/null
[747]	1887	mkdir -p $mtpt
	1888	mount -o loop $image $mtpt
	1889	cd $mtpt
	1890	mkdir -p {dev,tmp,boot}
[963]	1891	cp -f $1 vmlinuz 2>> $LOGFILE
[747]	1892	if [ "$?" -ne "0" ] ; then
[963]	1893	LogIt "Failed to copy $1 to ramdisk"
[747]	1894	cd $old_pwd
	1895	umount $mtpt
	1896	rmdir $mtpt
	1897	rm $image
	1898	return 1
	1899	fi
	1900
	1901	rdev vmlinuz 2,0
	1902	rdev -R vmlinuz 0
	1903	rdev -r vmlinuz 49152
	1904
[963]	1905	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[1311]	1906	# BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
[1301]	1907	#losetup /dev/loop0 > /dev/null 2> /dev/null
	1908	#[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1909	CopyBootBFile $mtpt/boot.b
	1910
	1911	MakeLiloConfFile $disksize >> bdlilo.conf
	1912
	1913	chmod 644 bdlilo.conf
	1914	MakeMessageFile $disksize > message
	1915	lilo -v -C bdlilo.conf -r $mtpt
	1916	res=$?
	1917
	1918	cd $old_pwd
	1919	umount $mtpt
	1920	mv -f $image $2
	1921	rmdir $mtpt
	1922
	1923	return $res
	1924	}
	1925
	1926
	1927	MakeLiloConfFile() {
	1928	local disksize options i ooo
	1929	disksize=$1
	1930	options=""
[925]	1931
	1932	if [ "$ARCH" != "ia64" ] ; then
	1933	echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
	1934	fi
	1935	if [ "$disksize" -eq "2880" ] ; then
	1936	echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
	1937	elif [ "$disksize" -eq "1722" ] ; then
	1938	echo -en "bios=0x00\nsectors=21\nheads=2\ncylinders=82\n"
	1939	elif [ "$disksize" -gt "2880" ] ; then
	1940	/bin/true
	1941	else
	1942	echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
	1943	fi
	1944	if [ "$ARCH" != "ia64" ] ; then
	1945	echo -en "install=/boot.b\nmap=/boot.map\n"
	1946	fi
[747]	1947	if [ "$CDRECOVERY" = "yes" ] ; then
	1948	echo -en "default=RESTORE\n"
[1335]	1949	elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ] ; then
[940]	1950	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1951	echo -en "default=iso\n"
	1952	else
	1953	echo -en "default=interactive\n"
	1954	fi
	1955	else
	1956	echo -en "default=expert\n"
	1957	fi
	1958
	1959	echo -en "prompt\n"
	1960	if [ "$ARCH" != "ia64" ] ; then
	1961	echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
	1962	fi
	1963	if [ "$CDRECOVERY" != "yes" ] ; then
[925]	1964	echo -en "timeout=300\n"
[747]	1965	fi
	1966	echo -en "\n"
	1967	if [ "$CDRECOVERY" = "yes" ] ; then
[925]	1968	options="RESTORE expert"
[747]	1969	elif [ "$disksize" -gt "2880" ] ; then
[1335]	1970	if [ _"$MONDO_SHARE" != _"" ] ; then
[940]	1971	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1972	options="iso"
	1973	else
	1974	options="interactive expert compare iso nuke isonuke"
	1975	# hda hdb hdc hdd"
	1976	fi
	1977	else
	1978	options="expert"
[925]	1979	fi
[747]	1980	else
	1981	options="expert"
	1982	fi
	1983	for i in $options ; do
[925]	1984	ooo=$i
	1985	[ "$ooo" = "RESTORE" ] && ooo="nuke"
	1986	if [ "$ARCH" = "ia64" ] ; then
	1987	rootpart="root=/dev/ram0\n\t"
	1988	else
	1989	rootpart=""
	1990	fi
[1230]	1991	outstr="image=/vmlinuz\n\tlabel=$i\n\tinitrd=/mindi.rdz\n\t${rootpart}append=\" rw ramdisk=$ramdisksize ramdisk_size=$ramdisksize maxcpus=1 $ooo_mode $ADDITIONAL_BOOT_PARAMS"
[747]	1992
[925]	1993	outstr=$outstr" $ooo_mode"
	1994	outstr=$outstr"\"\n"
	1995	if [ "$disksize" = "1440" ] ; then
	1996	echo -en "$outstr" \| sed s/initrd=.*// \| grep -v root=
	1997	else
	1998	echo -en "$outstr"
	1999	fi
[747]	2000	done
	2001	}
	2002
	2003
	2004	PrepareBootDiskImage_LILO() {
	2005	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
	2006	imagesdir=$1
	2007	disksize=$2
	2008	kernelpath=$3
	2009	ramdisksize=$4
	2010
	2011	retval=0
	2012	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	2013	echo -en "Making "$disksize"KB boot disk..."
[940]	2014	TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize $disksize `du -sk $kernelpath \| cut -f1` \|\| Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
[747]	2015	if [ "$ARCH" != "ia64" ] ; then
[1282]	2016	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	2017	fi
	2018	echo -en "..."
	2019	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	2020	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	2021	mkdir -p $mountpoint
	2022	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
	2023	if [ "$ARCH" = "ia64" ] ; then
[964]	2024	mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
	2025	t=vfat
[747]	2026	else
[964]	2027	mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
	2028	t=ext2
[747]	2029	fi
[963]	2030	mount -t $t -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[964]	2031	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	2032	mkdir -p $mountpoint/etc
	2033	if [ "$ARCH" != "ia64" ] ; then
	2034	liloconf=$mountpoint/etc/lilo.conf
	2035	else
[925]	2036	liloconf=$mountpoint/elilo.conf
[747]	2037	fi
	2038	old_pwd=`pwd`
	2039	cd $mountpoint
	2040	if [ "$ARCH" != "ia64" ] ; then
[963]	2041	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	2042	fi
	2043	cd $old_pwd
[1311]	2044	# BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
	2045	#losetup /dev/loop0 > /dev/null 2> /dev/null
	2046	#[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	2047	CopyBootBFile $mountpoint/boot.b
	2048
	2049	MakeLiloConfFile $disksize > $liloconf
	2050
[1230]	2051	# Copy it so that CD-ROM menu entry is satisfied
	2052	if [ "$ARCH" = "ia64" ] ; then
	2053	mountefi=0
	2054	df -T \| grep /boot/efi \| grep -q vfat
	2055	if [ $? -ne 0 ]; then
	2056	mount /boot/efi
	2057	if [ $? -ne 0 ]; then
	2058	echo "You have to mount your EFI partition when using mindi"
	2059	MindiExit -1
	2060	fi
	2061	mountefi=1
	2062	fi
[1735]	2063	el=`find /boot/efi -name elilo.efi`
	2064	cp $el $mountpoint
[1230]	2065	cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
	2066	if [ $mountefi -eq 1 ]; then
	2067	umount /boot/efi 2>&1 > /dev/null
	2068	fi
	2069	fi
	2070
[940]	2071	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
	2072	cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
[747]	2073	if [ "$?" -ne "0" ] ; then
[963]	2074	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	2075	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	2076	LogIt "Please unload some of your modules and try again."
[940]	2077	rm -f $MINDI_TMP/mtpt.$$
[963]	2078	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	2079	retval=$(($retval+1))
	2080	fi
	2081	MakeMessageFile $disksize > $mountpoint/message
	2082
	2083	mkdir -p $mountpoint/tmp
[940]	2084	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2085	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	2086	echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
	2087	echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
	2088	# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
	2089	fi
	2090
[925]	2091	# copy the kernel across
[1230]	2092	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	2093	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	2094	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2095	cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
	2096	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
[925]	2097	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2098	du -sk $mountpoint/* >> $LOGFILE
	2099	echo "--- end of list of files ---" >> $LOGFILE
	2100	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[747]	2101	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2102	rm -f $mountpoint/vmlinuz
[925]	2103	cd $old_pwd
[747]	2104	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2105	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[925]	2106	# losetup /dev/loop0 -d
	2107	res=0
[747]	2108	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
[925]	2109	res=$(($res+$?))
[963]	2110	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[925]	2111	res=$(($res+$?))
	2112	rm -f $imagefile
	2113	if [ "$res" -ne "0" ]; then
[963]	2114	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[925]	2115	rm -f $imagesdir/mindi-*.1440.img
	2116	fi
	2117	return $res
[747]	2118	fi
	2119	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2120	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2121	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2122	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
	2123	# make it bootable
	2124	rm -f $mountpoint/zero
[963]	2125	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2126	if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
	2127	if [ "$ARCH" != "ia64" ] ; then
	2128	$LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
	2129	else
	2130	/bin/true
	2131	fi
	2132	elif [ ! "$KERN_DISK_MADE" ] ; then
	2133	# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
[925]	2134	$LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	2135	else
[925]	2136	echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
[747]	2137	fi
[925]	2138
	2139	# BERLIOS does not test necessarily what it expects
[747]	2140	if [ $? -ne "0" ] ; then
[925]	2141	if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
[963]	2142	LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
	2143	LogIt "Please reboot your PC as a workaround."
	2144	Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
[925]	2145	fi
	2146	echo "$LILO_EXE -r $mountpoint ...failed."
	2147	echo -en "Press ENTER to continue."; read line
[963]	2148	LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
[925]	2149	retval=$(($retval+1))
[747]	2150	fi
[963]	2151	cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
[747]	2152	if [ "$ARCH" = "ia64" ] ; then
[963]	2153	cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
[747]	2154	fi
	2155	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2156	echo -en "..."
[963]	2157	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2158	if [ "$retval" -eq "0" ] ; then
	2159	echo -en "...$DONE\r"
	2160	if [ "$KERN_DISK_MADE" ] ; then
	2161	LogIt "... $disksize KB boot disks were created OK\r"
	2162	fi
	2163	else
	2164	echo -en "...failed\r"
	2165	LogIt $disksize"KB boot disk was NOT created\r"
	2166	rm -f $imagefile
	2167	fi
[963]	2168	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2169	return $retval
	2170	}
	2171
	2172
	2173	PrepareBootDiskImage_SYSLINUX() {
	2174	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
	2175	imagesdir=$1
	2176	disksize=$2
	2177	kernelpath=$3
	2178	ramdisksize=$4
	2179	do_boot_root_thingy=""
	2180	local retval old_pwd
	2181	retval=0
[925]	2182
[747]	2183	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	2184	echo -en "Making "$disksize"KB boot disk..."
[940]	2185	TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize $disksize `du -sk $kernelpath \| cut -f1` \|\| Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
[1282]	2186	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	2187	echo -en "..."
	2188	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	2189	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	2190	mkdir -p $mountpoint
	2191	# If I format a 1722KB data file & run syslinux on it, the resultant image
	2192	# won't boot. So, I have formatted a floppy, called syslinux on/to it, and
	2193	# used 'dd' to copy it to sys-disk.raw (zipped to sys-disk.raw.gz).
	2194	# If I extract it, mount it, copy my files to it, etc. then the resultant
	2195	# image _is_ bootable. I don't know why syslinux and/or mkfs.vfat won't
	2196	# play nicely and I don't care. :) I have worked around the problem. -Hugo, 06/27/2002
	2197	if [ "$disksize" = "1722" ] ; then
	2198	gzip -dc $MINDI_LIB/sys-disk.raw.gz > $imagefile \|\| Die "Cannot dd blank file"
	2199	else
	2200	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
[964]	2201	mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
	2202	syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
[747]	2203	fi
[963]	2204	mount -t vfat -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[925]	2205
	2206	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	2207	old_pwd=`pwd`
	2208	MakeSyslinuxMessageFile $mountpoint/message.txt
	2209	cd $mountpoint
	2210	[ -e "$sys_cfg_file" ] \|\| Die "Obi Wan, word up?"
	2211	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
[940]	2212	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2213	mv syslinux.cfg syslinux.cfg.orig
	2214	sed s/interactive/iso/ syslinux.cfg.orig > syslinux.cfg
	2215	fi
	2216	cd $old_pwd
[940]	2217	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
	2218	cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
[747]	2219	if [ "$?" -ne "0" ] ; then
[963]	2220	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	2221	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	2222	LogIt "Please unload some of your modules and try again."
[940]	2223	rm -f $MINDI_TMP/mtpt.$$
[963]	2224	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	2225	retval=$(($retval+1))
	2226	fi
	2227
	2228	mkdir -p $mountpoint/tmp
[940]	2229	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2230
[925]	2231	# copy the kernel across
[1230]	2232	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	2233	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	2234	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2235	cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
	2236	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
	2237	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2238	du -sk $mountpoint/* >> $LOGFILE
	2239	echo "--- end of list of files ---" >> $LOGFILE
	2240	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
	2241	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2242	rm -f $mountpoint/vmlinuz
	2243	cd $old_pwd
	2244	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2245	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2246
	2247	res=0
	2248	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
	2249	res=$(($res+$?))
[963]	2250	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[747]	2251	res=$(($res+$?))
	2252	rm -f $imagefile
	2253	if [ "$res" -ne "0" ]; then
[963]	2254	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[747]	2255	rm -f $imagesdir/mindi-*.1440.img
	2256	fi
	2257	return $res
	2258	fi
	2259	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2260	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2261	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2262	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
[925]	2263
	2264	# make it bootable
[747]	2265	rm -f $mountpoint/zero
	2266	mkdir -p $mountpoint/etc
[963]	2267	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2268	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2269	echo -en "..."
[963]	2270	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2271
	2272	if [ "$retval" -eq "0" ] ; then
	2273	echo -en "...$DONE\r"
	2274	if [ "$KERN_DISK_MADE" ] ; then
	2275	rm -f $imagefile
	2276	LogIt "... $disksize KB boot disks were created OK\r"
	2277	fi
	2278	else
	2279	echo -en "...failed\r"
	2280	LogIt $disksize"KB boot disk was NOT created\r"
	2281	rm -f $imagefile
	2282	fi
[963]	2283	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2284	return $retval
	2285	}
	2286
	2287
	2288	PrepareDataDiskImages() {
	2289	local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines
	2290
	2291	imagesdir=$1
	2292	rm -f $imagesdir/mindi-.img $imagesdir/[0-9].tar.gz $imagesdir/mindi.iso
[940]	2293	needlist=$MINDI_TMP/what-we-need.txt
	2294	bigdir=$MINDI_TMP/bigdir
	2295	minidir_root=$MINDI_TMP/minidir
[747]	2296	mkdir -p $minidir_root
	2297	mkdir -p $bigdir/usr/bin
[940]	2298	tardir=$MINDI_TMP/tardir
[747]	2299
	2300	lines=`grep -vx " #." $MINDI_CONF/deplist.txt \| grep -vx "" \| wc -l`
	2301	cat $MINDI_CONF/deplist.txt \| GenerateGiantDependencyList $needlist $lines
	2302	res=$?
	2303	if [ "$YOUR_KERNEL_SUCKS" ]; then
[925]	2304	pwd=`pwd`
[940]	2305	cd $MINDI_TMP
[747]	2306	for i in `ListKernelModulePaths \| HackPathsToFailsafe` ; do
[963]	2307	cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE \|\| Die "PDDI can't cp $i->$bigdir"
[925]	2308	if [ "`du -sk $i \| cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
[963]	2309	cp --parents -pRdf $i $bigdir 2>> $LOGFILE
[925]	2310	else
	2311	ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
	2312	BIGNO=$(($BIGNO+1))
	2313	fi
[747]	2314	done
[925]	2315	for i in $EXTRA_MODS ; do
	2316	j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
[963]	2317	[ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
[925]	2318	for k in $j ; do
	2319	if [ "`du -sk $k \| cut -f1`" -lt "$CHOPSIZE" ] ; then
[963]	2320	cp --parents -pRdf $k $bigdir 2>> $LOGFILE
[925]	2321	else
	2322	ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
	2323	BIGNO=$(($BIGNO+1))
	2324	fi
	2325	echo "Added failsafe module $k to ramdisk" >> $LOGFILE
	2326	done
	2327	done
	2328	cd $pwd
[747]	2329	else
[925]	2330	ListKernelModulePaths >> $needlist
[747]	2331	fi
	2332	if [ "$res" -ne "0" ] ; then
	2333	Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
	2334	fi
	2335	FindAndAddUserKeyboardMappingFile
	2336	mkdir -p $bigdir/tmp
[1335]	2337	if [ _"$MONDO_SHARE" != _"" ] ; then
[940]	2338	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	2339	cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
[747]	2340	fi
	2341	[ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
	2342	DropOptimizedLibraries $needlist $bigdir
	2343	echo -en "Assembling dependency files"
	2344	CopyDependenciesToDirectory < $needlist $bigdir
	2345
[925]	2346	# also copy io.sys and msdos.sys, if we can find them
[747]	2347	for i in `mount \| cut -d' ' -f3` ; do
[925]	2348	for j in io.sys msdos.sys ; do
[963]	2349	[ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
[925]	2350	done
[747]	2351	done
	2352
[925]	2353	# master boot record, too
[940]	2354	i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
[747]	2355	if [ "$i" ] ; then
[963]	2356	LogIt "Backing up $i's MBR"
[925]	2357	dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
	2358	sleep 1
	2359	sync
	2360	j=$i
	2361	[ -h "$j" ] && j=`readlink -f $j`
[963]	2362	LogIt "Creating /dev/boot_device ($j)"
[925]	2363	mkdir -p $bigdir/dev
[953]	2364	cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null \|\| Die "Unable to create /dev/boot_device on ramdisk"
[747]	2365	fi
	2366
	2367	old_pwd=`pwd`
	2368	cd $bigdir
	2369
	2370	[ -e "$MINDI_LIB/aux-tools" ] \|\| Die "aux-tools not found in Mindi's home dir. Do you have multiple copies of Mindi lying around? Please delete them. No, don't e-mail me and ask how. ;) Use 'rm'."
[963]	2371	cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping aux-tools"
[747]	2372	if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
[963]	2373	tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
[747]	2374	fi
[1764]	2375	if [ -e "$MONDO_SHARE/restore-scripts" ]; then
[747]	2376	cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
[1335]	2377	[ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
[747]	2378	fi
[963]	2379	[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
[747]	2380	cd $old_pwd
	2381	echo -e "$DONE"
	2382	TOTAL_BIGDIR_SIZE=`du -sk $bigdir \| cut -f1`
	2383	SplitDirectoryIntoMinidirs $bigdir $minidir_root
	2384	noof_disks=$?
	2385	[ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
	2386	# if [ "$noof_disks" -ge "8" ] ; then
	2387	# LogIt "You are putting a ludicrously large amount of data on these disks."
	2388	# LogIt "I shall therefore double EXTRA_SPACE, just in case your ramdisk is too small."
	2389	# EXTRA_SPACE=$(($EXTRA_SPACE*2))
	2390	# fi
[940]	2391	MakeMountlist $MINDI_TMP/mountlist.txt
[747]	2392	mkdir -p $minidir_root/$noof_disks/tmp
[953]	2393	cp -f $MINDI_TMP/mountlist.txt $minidir_root/$noof_disks/tmp/mountlist.txt 2> /dev/null \|\| Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
[1335]	2394	[ _"$MONDO_SHARE" != _"" ] && cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
[964]	2395	[ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm \|\| LVM="false"
[747]	2396	cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
	2397	ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
	2398	CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
	2399	FRIENDLY_OUTSTRING="Boot and data disk images were created."
[925]	2400	# One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
[747]	2401	rmdir $tardir $bigdir
	2402	rm -f $needlist
	2403	return $noof_disks
	2404	}
	2405
	2406
	2407	ProcessLDD() {
[1526]	2408	local incoming f
[747]	2409	read incoming
	2410	while [ "$incoming" != "" ] ; do
[859]	2411	# We take the full path name of the dyn. lib. we want
[1526]	2412	incoming=`echo "$incoming" \| awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
	2413	for f in $incoming ; do
[1721]	2414	echo "$f"
	2415	echo "`ReadAllLink $f`"
[747]	2416	done
	2417	read incoming
	2418	done
	2419	}
	2420
	2421
	2422	Prompt() {
	2423	echo -en "$1"
	2424	read line
	2425	}
	2426
	2427
	2428	ReadLine() {
	2429	local i incoming
	2430	read incoming
	2431	i=0
	2432	while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
[925]	2433	i=$(($i+1))
	2434	read incoming
[747]	2435	done
	2436	echo "$incoming"
	2437	}
	2438
	2439
	2440	RejigHyperlinks() {
	2441	local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
	2442	minidir_root=$1
	2443	noof_disks=$2
	2444
	2445	old_pwd=`pwd`
	2446	diskno=1
	2447	while [ "$diskno" -le "$noof_disks" ] ; do
[859]	2448	mkdir -p $minidir_root/$diskno
[747]	2449	cd $minidir_root/$diskno
	2450	for fname in `find -type d -o -print` ; do
	2451	[ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
	2452	done
[925]	2453	diskno=$(($diskno+1))
[747]	2454	done
	2455
	2456	cd $old_pwd
	2457	return
	2458	}
	2459
	2460
	2461	ReplaceIndividualLine() {
	2462	local orig_file new_file lino newstring lines_total lines_remaining
[925]	2463
[747]	2464	orig_file=$1.orig
	2465	mv -f $1 $orig_file \|\| Die "Cannot move $1 to $orig_file"
	2466	new_file=$1
	2467	lino=$2
	2468	newstring="$3"
	2469	if [ "$lino" = "" ] \|\| [ "$lino" -lt "1" ] ; then
[925]	2470	echo "Can't find string" >> $LOGFILE
	2471	return 1
[747]	2472	fi
[963]	2473	lines_total=`wc -l $orig_file \| $AWK '{print $1;}'`
[747]	2474	lines_remaining=$(($lines_total-$lino))
	2475	head -n$(($lino-1)) $orig_file > $new_file
	2476	echo "$newstring" >> $new_file
	2477	echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
	2478	tail -n$lines_remaining $orig_file >> $new_file
	2479	echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
	2480	[ -x "$orig_file" ] && chmod +x $new_file
	2481	rm -f $orig_file
	2482	return 0
	2483	}
	2484
	2485
	2486	ScanCDandTape() {
	2487	local i
	2488
	2489	for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
	2490	dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
	2491	done
	2492	}
	2493
	2494
	2495	SizeOfPartition() {
	2496	local devpath drive res stub
	2497	device=$1
	2498	if [ "`echo "$device" \| grep -F "/dev/md"`" != "" ] ; then
[925]	2499	res=`SizeOfRaidPartition $device`
	2500	[ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
	2501	echo "$res"
	2502	return 0
[747]	2503	fi
[925]	2504	# patch from Bill <bill@iwizard.biz> - 2003/08/25
[960]	2505	res=`$FDISK -s $device 2>> $LOGFILE`
[925]	2506	# end patch
[747]	2507	[ "$res" = "" ] && res=`df -k -P -x supermount \| tr -s '\t' ' ' \| grep -F "$device " \| cut -d' ' -f2`
	2508	[ "$res" = "" ] && res="-1"
	2509	echo $res
	2510	return 0
	2511	}
	2512
	2513
	2514	SizeOfRaidPartition() {
	2515	local real_dev smallest_size silly tmp
	2516
	2517	silly=999999999
	2518	smallest_size=$silly
	2519
	2520	for real_dev in `GetRaidDevMembers $1` ; do
[925]	2521	tmp=`SizeOfPartition $real_dev`
	2522	[ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
[747]	2523	done
	2524
	2525	if [ "$smallest_size" = "$silly" ] ; then
[925]	2526	echo "-1"
	2527	return 1
[747]	2528	else
[925]	2529	echo "$smallest_size"
	2530	return 0
[747]	2531	fi
	2532	}
	2533
	2534
	2535	StripComments()
	2536	{
	2537	local tempfile
[925]	2538
[940]	2539	tempfile=$MINDI_TMP/$$.strip.txt
[963]	2540	cp -f $1 $tempfile 2>> $LOGFILE
[747]	2541	$AWK '{if (substr($0,0,1)!="#" \|\| substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
	2542	rm -f $tempfile
	2543	echo "Stripped comments from $2" >> $LOGFILE
	2544	}
	2545
	2546
	2547	SplitDirectoryIntoMinidirs() {
	2548	local bigdir minidir_root i noof_disks old_pwd res
[925]	2549
[747]	2550	bigdir=$1
	2551	minidir_root=$2
[1230]	2552	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
[747]	2553
	2554	TryToFitDataIntoSeveralDirs $bigdir $minidir_root
	2555	noof_disks=$?
	2556	if [ "$noof_disks" -eq "0" ] ; then
[925]	2557	echo "Failed to fit data into several dirs."
[747]	2558	return 0
	2559	fi
	2560	RejigHyperlinks $minidir_root $noof_disks
[1230]	2561	[ "$bigdir" != "" ] && rm -Rf $bigdir/*
[925]	2562	return $noof_disks
[747]	2563	}
	2564
	2565
	2566	StripExecutable()
	2567	{
	2568	local tmpfile
[925]	2569
[940]	2570	tmpfile=$MINDI_TMP/stripped.$$.dat
[747]	2571	[ -d "$1" ] \|\| [ -h "$1" ] && return
[963]	2572	cp -f $1 $tmpfile 2>> $LOGFILE
[747]	2573	strip $tmpfile 2> /dev/null
	2574	if [ "$?" -eq "0" ] ; then
[963]	2575	cp -f $tmpfile $1 2>> $LOGFILE
[925]	2576	echo "Stripped binary $2" >> $LOGFILE
[747]	2577	fi
	2578	rm -f $tmpfile
	2579	}
	2580
	2581
	2582	TemporarilyCompressAllFiles() {
	2583	local i orig_fname out_fname out_list
	2584
	2585	i=0
	2586	out_list=$2/compressed/compressed.txt
	2587	mkdir -p $2/compressed
	2588	> $out_list
	2589	for orig_fname in $1 ; do
	2590	out_fname=$2/compressed/$orig_fname.gz
	2591	mkdir -p $out_fname 2> /dev/null
	2592	rmdir $out_fname 2> /dev/null
	2593	gzip -c6 $orig_fname > $out_fname 2> /dev/null
	2594	i=$(((($i+1))%15))
	2595	[ "$i" -eq "0" ] && echo -en "."
	2596	du -sk $out_fname >> $out_list
	2597	done
	2598	}
	2599
	2600
	2601	TryToFindKernelPath() {
	2602	local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
[925]	2603
[747]	2604	we_want_version=`uname -r`
	2605	possible_kernels=""
	2606	duff_kernels=""
	2607
	2608	if [ "$ARCH" = "ia64" ] ; then
	2609	root="/boot/efi/efi"
	2610	else
	2611	root="/"
	2612	fi
[1466]	2613	for fname in `find $root -maxdepth 2 -type f \| grep -E 'lin\|kern' \| grep -Ev '^/proc/\|^/net/'` ; do
[925]	2614	[ ! -e "$fname" ] && continue
[747]	2615	[ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
[925]	2616	file $fname \| grep -q gzip
	2617	if [ "$?" -eq "0" ] ; then
	2618	# Used by ia64
[747]	2619	fkern_ver=`gzip -cd $fname \| strings 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2620	else
[747]	2621	fkern_ver=`strings $fname 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2622	fi
[747]	2623	[ "$fkern_ver" = "" ] && continue
	2624	[ "`echo "$fkern_ver" \|grep -F "$we_want_version "`" = "" ] && continue
[925]	2625	[ -f "$fname" ] \|\| continue
	2626	[ -h "$fname" ] && continue
	2627	kdate=`uname -v \| $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' \| $AWK '{print $NF;}'`
	2628	file $fname \| grep -q gzip
	2629	if [ "$?" -eq "0" ] ; then
	2630	# Used by ia64
	2631	if [ "`gzip -cd $fname \| strings 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2632	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
[925]	2633	duff_kernels="$fname $duff_kernels"
	2634	else
[747]	2635	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2636	possible_kernels="$fname $possible_kernels"
[925]	2637	fi
[747]	2638	else
[925]	2639	if [ "`strings $fname 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2640	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
[925]	2641	duff_kernels="$fname $duff_kernels"
	2642	else
[747]	2643	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2644	possible_kernels="$fname $possible_kernels"
[925]	2645	fi
[747]	2646	fi
	2647	done
	2648	if [ ! "$possible_kernels" ] && uname -a \| grep Knoppix > /dev/null ; then
[925]	2649	possible_kernels=`find /boot/vmlinuz-2.* \| tail -n1`
[747]	2650	fi
	2651	if [ ! "$possible_kernels" ] ; then
[963]	2652	LogIt "No kernel matches exactly. Are there any duff kernels?"
[747]	2653	possible_kernels="$duff_kernels"
	2654	if [ ! "$possible_kernels" ] ; then
[963]	2655	LogIt "Sorry, no duff kernels either"
[747]	2656	else
[963]	2657	LogIt "I bet you're running Debian or Gentoo, aren't you?"
	2658	LogIt "Your kernel doesn't have a sane builddate. Oh well..."
[747]	2659	fi
	2660	fi
	2661	possible_kernels=`echo "$possible_kernels" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '`
	2662	noof_kernels=`CountItemsIn "$possible_kernels"`
	2663	if [ "$noof_kernels" -eq "0" ] ; then
[963]	2664	LogIt "Could not find your kernel."
[925]	2665	if [ -e "/boot/vmlinuz" ] ; then
[963]	2666	LogIt "Using /boot/vmlinuz as a last resort."
[925]	2667	output=/boot/vmlinuz
[747]	2668	else
[925]	2669	output=""
	2670	fi
[747]	2671	elif [ "$noof_kernels" -eq "1" ] ; then
	2672	kernelpath=`echo "$possible_kernels" \| sed s/' '//`
	2673	echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
	2674	output="$kernelpath"
	2675	else
	2676	for i in $possible_kernels ; do
	2677	if echo $i \| grep "`uname -r`" ; then
[925]	2678	LogIt "OK, I used my initiative and found that "
[963]	2679	LogIt "$i is probably your kernel. "
[925]	2680	output="$i"
	2681	return
	2682	fi
[747]	2683	done
[925]	2684	if echo " $possible_kernels " \| grep -F "/boot/vmlinuz " &> /dev/null ; then
	2685	output=/boot/vmlinuz
	2686	echo "Schlomo, this one's for you." >> $LOGFILE
	2687	else
[963]	2688	LogIt "Two or more possible kernels found. You may specify any one of them and the "
	2689	LogIt "boot disks will still work, probably. If one does not work, try another."
	2690	LogIt "$possible_kernels"
[747]	2691	echo ""
[925]	2692	fi
[747]	2693	fi
	2694	echo "$output" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '
	2695	}
	2696
	2697
	2698	TryToFitDataIntoSeveralDirs() {
	2699	local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
	2700	local i retval noof_disks total_files list_of_devs
[925]	2701
[747]	2702	bigdir=$1
	2703	minidir_root=$2
	2704	BIG_CLUNKY_SIZE_COUNTER=0
	2705	retval=0
	2706	noof_disks=1
	2707
	2708	echo -en "\r \rDividing data into several groups..."
	2709	old_pwd=`pwd`
	2710	cd $bigdir
	2711	list_of_files=`GetFileSizeList . \| sort -nr \| cut -f2 \| grep -Fv "/dev/"`
	2712	progress=0
	2713	total_files=`CountItemsIn "$list_of_files"`
	2714	if [ "`echo "$filename" \| grep -x "/dev/.*"`" ] ; then
	2715	filesize=1
	2716	fi
	2717	mkdir -p $minidir_root/$noof_disks
	2718	if [ -e "dev" ] ; then
	2719	echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
[963]	2720	cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
[747]	2721	fi
	2722	TemporarilyCompressAllFiles "$list_of_files" $minidir_root
	2723	for filename in $list_of_files ; do
	2724	AddFileToDir $filename $minidir_root $noof_disks
[925]	2725	i=$?
	2726	if [ "$i" -gt "$noof_disks" ] ; then
	2727	noof_disks=$i
	2728	echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
	2729	fi
	2730	if [ "$i" -eq "0" ] ; then
[963]	2731	LogIt "Cannot add file $filename to minidir $minidir_root"
[925]	2732	retval=$(($retval+1))
	2733	fi
[747]	2734	progress=$(($progress+1))
[925]	2735	echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
[747]	2736	done
	2737	cd $old_pwd
	2738	echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
[1230]	2739	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
[747]	2740	if [ "$retval" -gt "0" ] ; then
[925]	2741	return 0
[747]	2742	else
[925]	2743	return $noof_disks
[747]	2744	fi
	2745	}
	2746
	2747
	2748	TurnTgzIntoRdz() {
	2749	local tgz_dir_fname rdz_fname ramdisksize tempfile mountpoint old_pwd nodes disksize kernelsize maxsize res currsize not_copied j k floppy_modules s w
[925]	2750
[747]	2751	tgz_dir_fname=$1
	2752	rdz_fname=$2
	2753	ramdisksize=$3
	2754	disksize=$4
	2755	kernelsize=$5
	2756	maxsize=$(($disksize-$kernelsize))
	2757	maxsize=$(($maxsize*2)); # to allow for compression of 50%
[940]	2758	tempfile=$MINDI_TMP/temp.rd
	2759	mountpoint=$MINDI_TMP/mnt1
[747]	2760	res=0
	2761	echo -en "..."
	2762	dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null \|\| Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
	2763	echo -en "..."
[1764]	2764	echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
	2765	mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE \|\| Die "Unable to create an ext2 file system on $tempfile"
[747]	2766	echo -en "..."
	2767	mkdir -p $mountpoint
	2768	mount -t ext2 -o loop $tempfile $mountpoint \|\| Die "Cannot loopmount $tempfile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
	2769	echo -en "..."
	2770	old_pwd=`pwd`
	2771	cd $mountpoint
[959]	2772	cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
[747]	2773	tar -zxf symlinks.tgz \|\| Die "Cannot untar symlinks.tgz"
	2774	cd dev \|\| Die "Can't cd to dev"
	2775	tar -zxf dev-entries.tgz \|\| Die "Cannot untar dev-entries.tgz"
	2776	rm -f dev-entries.tgz
	2777	cd ..
	2778
	2779	for w in insmod.static insmod.static.old ; do
[925]	2780	s=`which $w 2> /dev/null`
	2781	if [ -e "$s" ] ; then
[963]	2782	cp --parents -af $s . 2>> $LOGFILE
[925]	2783	fi
[747]	2784	done
	2785
	2786	mkdir -p tmp
	2787	[ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
[1724]	2788
	2789	# Management of udev (which includes modprobe in rules)
[1759]	2790	ps auxww \| grep -v grep \| grep -qw udevd
[1716]	2791	if [ $? -eq 0 ]; then
	2792	echo "udev device manager found" > tmp/USE-UDEV
[1759]	2793	LogIt "udev device manager found"
[1716]	2794	cp --parents -Rdf /etc/udev . 2> /dev/null
[1718]	2795	cp --parents -Rdf /lib/udev /lib64/udev . 2> /dev/null
[1720]	2796	if [ -x /sbin/udevd ]; then
[1781]	2797	lis2=`grep -Ev '^#' $MINDI_CONF/udev.files`
	2798	lis=""
	2799	# Get only the files which exist in that list
	2800	for i in $lis2; do
	2801	if [ -f $i ]; then
	2802	lis="$lis $i"
	2803	fi
	2804	done
	2805	# And their deps
[1759]	2806	LocateDeps $lis > $MINDI_TMP/udev.lis
	2807	for i in $lis; do
	2808	if [ "`echo $i \| cut -c1`" = "/" ]; then
	2809	j=`echo $i \| cut -c2-`
	2810	rm -f $j
	2811	fi
	2812	done
	2813	cp --parents -Rdf $lis `sort -u $MINDI_TMP/udev.lis` .
[1721]	2814	rm -f $MINDI_TMP/udev.lis
[1720]	2815	else
	2816	echo "udevd daemon not in standard place (/sbin)" 2>&1 \| tee -a $LOGFILE
[1724]	2817	echo "mindi will use static devices which may cause problems" 2>&1 \| tee -a $LOGFILE
[1720]	2818	rm -f tmp/USE-UDEV
	2819	fi
[1716]	2820	fi
[1761]	2821	# Management of potential HW info (Proliant only at the moment)
	2822	mindi-bkphw $CACHE_LOC $MINDI_CONF \| tee -a $LOGFILE
	2823	if [ -d $CACHE_LOC/bkphw ]; then
	2824	LogIt "Hardware Information found and saved ..."
	2825	cp -rp $CACHE_LOC/bkphw .
	2826	lis=`grep -Ev '^#' $CACHE_LOC/tools.files`
	2827	LocateDeps $lis > $MINDI_TMP/tools.lis
	2828	cp --parents -Rdf $lis `sort -u $MINDI_TMP/tools.lis` .
	2829	if [ -f $CACHE_LOC/mindi-rsthw ]; then
	2830	mv -f $CACHE_LOC/mindi-rsthw .
	2831	chmod 755 ./mindi-rsthw
	2832	fi
	2833	rm -f $MINDI_TMP/tools.lis $CACHE_LOC/tools.files
	2834	fi
	2835
[747]	2836	for w in cdrom floppy groovy-stuff ; do
	2837	mkdir -p mnt/$w
	2838	done
[925]	2839	#if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
	2840	#ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
	2841	#fi
[747]	2842	if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
[925]	2843	ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
[747]	2844	fi
	2845
	2846	cp --parents -Rdf /dev/fd0[1,2][4,7,8] . 2> /dev/null
[1721]	2847
	2848	# Handle the case where busybox is dynamically linked
	2849	file $MINDI_LIB/rootfs/bin/busybox 2>&1 \| grep -q "dynamically"
	2850	if [ $? -eq 0 ]; then
	2851	LocateDeps $MINDI_LIB/rootfs/bin/busybox > $MINDI_TMP/busy.lis
	2852	cp --parents -Rdf `sort -u $MINDI_TMP/busy.lis` .
	2853	rm -f $MINDI_TMP/busy.lis
	2854	fi
[747]	2855	cd $old_pwd
	2856	echo -en "..."
	2857	MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
	2858	echo -en "..."
	2859	old_pwd=`pwd`
	2860	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	2861	cd $MINDI_TMP
[747]	2862	floppy_modules_path=lib/modules/$FAILSAFE_KVER
	2863	else
	2864	cd /
	2865	###
	2866	### Sq-Modification... Use kernel name in module path if specified.
	2867	###
	2868	#floppy_modules_path=lib/modules/`uname -r`
	2869	if [ "${kernelname}" != "" ]
	2870	then
	2871	floppy_modules_path=lib/modules/${kernelname}
	2872	else
	2873	floppy_modules_path=lib/modules/`uname -r`
	2874	fi
	2875	###
	2876	### Sq-Modification end
	2877	###
	2878	fi
	2879	floppy_modules=""
	2880	if [ "$disksize" -lt "2880" ] ; then
[1354]	2881	list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
[747]	2882	else
[1354]	2883	list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
[747]	2884	fi
[940]	2885	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2886	# For PXE boot
	2887	list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
	2888	fi
[1715]	2889	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
	2890	list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
	2891	fi
[1727]	2892	for i in $DENY_MODS; do
	2893	echo "Removing $i from the list of modules to load" >> $LOGFILE
	2894	list_of_groovy_mods=`echo ${list_of_groovy_mods} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
	2895	done
	2896
[963]	2897	[ -e "$floppy_modules_path" ] \|\| LogIt "path $floppy_modules_path does not exist.\n If you're not using a modular kernel then you're NUTS."
[747]	2898	for i in $list_of_groovy_mods ; do
	2899	floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
	2900	done
	2901	for i in $floppy_modules ; do
	2902	[ -e "$i" ] && s=`du -sk $i \| cut -f1` \|\| s=""
[940]	2903	[ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
[747]	2904	echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
[1727]	2905	cp --parents -pdf $i $mountpoint 2>/dev/null \|\| LogIt "Unable to copy $i to $mountpoint"
	2906	if [ "`echo "$i" \| grep -F ".gz"`" ]; then
	2907	gunzip -f $mountpoint/$i
	2908	i=`echo $i \| sed 's/.gz//'`
	2909	fi
[1729]	2910	(cd $mountpoint ; ln -s $i . 2>/dev/null)
[747]	2911	[ "`echo "$i" \| grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
	2912	done
[1727]	2913	# Also copy modules.dep in case of udev so that normal modprobe works
	2914	p=`echo $i \| cut -d/ -f1-3`
	2915	cp -df $p/modules.dep $mountpoint/$p 2>/dev/null \|\| LogIt "Unable to copy modules.dep to $mountpoint"
[747]	2916	if [ ! -e "/sbin/devfsd" ] \|\| [ "$disksize" -lt "2880" ] \|\| [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
	2917	echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
	2918	[ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
	2919	[ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
	2920	[ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
	2921	rm -f $mountpoint/sbin/devfsd
	2922	fi
	2923	cd $old_pwd
	2924	[ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
	2925	dd if=/dev/zero of=$mountpoint/zero &> /dev/null
	2926	rm -f $mountpoint/zero
[1335]	2927	if [ _"$MONDO_SHARE" != _"" ] ; then
[747]	2928	MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
[940]	2929	cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
[953]	2930	cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null \|\| Die "Cannot copy mountlist to ramdisk"
[747]	2931	echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
	2932	echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
	2933	[ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
[998]	2934	[ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
[747]	2935	[ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
	2936	[ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
	2937	fi
	2938	mkdir -p $mountpoint/tmp
	2939	mkdir -p $mountpoint/proc
	2940	echo "$disksize" > $mountpoint/tmp/$disksize.siz
	2941	find $mountpoint -name CVS -exec rm -rf '{}' \;
[1230]	2942	# Determine what filesystem to use for initrd image
	2943	echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
	2944	gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
	2945	[ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
	2946	case "$gvFileSystem" in
	2947	"ext2fs")
	2948	# say what will be used
	2949	echo "Creating an ext2 initrd image..." >> $LOGFILE
	2950	# kernel expects linuxrc in ext2 filesystem
	2951	( cd $mountpoint && ln -sf sbin/init linuxrc )
	2952	# unmount loop filesystem and create image file using the standard approach
	2953	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
[1764]	2954	dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
	2955	bs=`tune2fs -l ${rdz_fname}.tmp \| grep -E '^Block size:' \| cut -d: -f2`
	2956	ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
	2957	gzip -v9 ${rdz_fname}.tmp > $rdz_fname 2> /dev/null
	2958	rm -f ${rdz_fname}.tmp
[1230]	2959	# log that we are done
	2960	echo "...done." >> $LOGFILE
	2961	;;
	2962	"initramfs")
	2963	# say what will be used
	2964	echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
	2965	# make sure that cpio is there
	2966	which cpio &> /dev/null; [ $? -eq 0 ] \|\| Die "cpio not found. Please install package cpio and try again."
	2967	# go into filesystem
	2968	cd $mountpoint
	2969	# kernel expects init in cpio filesystem
	2970	ln -sf sbin/init init
	2971	# create cpio image file and unmount loop filesystem
	2972	find . -print \| cpio -o -H newc \| gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
	2973	cd $old_pwd
	2974	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	2975	# log that we are done
	2976	echo "...done." >> $LOGFILE
	2977	;;
	2978	*)
	2979	Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
	2980	;;
	2981	esac
[747]	2982	if [ "$res" -eq "0" ] ; then
	2983	echo -en "..."
	2984	else
	2985	echo -en "\rMade an rdz WITH ERRORS. \n"
	2986	fi
	2987	return 0
	2988	}
	2989
	2990
	2991	WhichOfTheseModulesAreLoaded() {
	2992	local modname loaded_modules
[1399]	2993	loaded_modules="$MODULES"
[747]	2994	for modname in $1 ; do
[1506]	2995	[ "`echo "$loaded_modules" \| grep -w "$modname"`" ] && echo "$modname"
[747]	2996	done
	2997	}
	2998
	2999
	3000	ZipMinidirsIntoTarballs() {
	3001	local minidir_root tardir noof_disks diskno old_pwd i
	3002	minidir_root=$1
	3003	tardir=$2
	3004	noof_disks=$3
	3005
	3006	echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
	3007	mkdir -p $tardir
	3008	mkdir -p $minidir_root/all
	3009	old_pwd=`pwd`
	3010	diskno=1
	3011	while [ "$diskno" -le "$noof_disks" ] ; do
[963]	3012	cd $minidir_root/$diskno \|\| LogIt "WARNING - cannot cd to $minidir_root/$diskno"
[747]	3013	tar -cf - . 2>> $LOGFILE \| gzip -9 > $tardir/$diskno.tar.gz \|\| Die "Can't tar/gzip disk#$diskno; please tell Dev Team -exactly- what the errors where."
	3014	diskno=$(($diskno+1))
	3015	echo -n "..."
[963]	3016	cp -pRdf * $minidir_root/all 2>> $LOGFILE
[747]	3017	done
	3018	mkdir -p $minidir_root/all/tmp
	3019	cd $minidir_root/all
	3020	size_of_all_tools=`du -sk . \| cut -f1`
[1684]	3021	if [ _"$MONDO_SHARE" != _"" ]; then
[747]	3022	for q in filelist.full.gz biggielist.txt ; do
[940]	3023	[ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
[963]	3024	cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
[747]	3025	done
	3026	mkdir -p $minidir_root/all/tmp
	3027	echo -en "$FILES_IN_FILELIST" > $minidir_root/all/tmp/FILES-IN-FILELIST 2> /dev/null
	3028	echo -en "$LAST_FILELIST_NUMBER" > $minidir_root/all/tmp/LAST-FILELIST-NUMBER 2> /dev/null
	3029	fi
	3030	tar -b 4096 -cf - * 2> /dev/null \| gzip -9 > $tardir/all.tar.gz
	3031	dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
	3032	[ "`du -sm $imagesdir/all.tar.gz \| cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
	3033	cd $old_pwd
[1230]	3034	[ "$minidir_root" != "" ] && rm -Rf $minidir_root
[747]	3035	echo -e "$DONE"
	3036	}
	3037
	3038
	3039	##############################################################################
[1021]	3040	#----------------------------------- Main -----------------------------------#
[747]	3041	##############################################################################
	3042
	3043
	3044	> $LOGFILE
	3045	echo "mindi v$MINDI_VERSION" >> $LOGFILE
	3046	echo "$ARCH architecture detected" >> $LOGFILE
	3047	echo "mindi called with the following arguments:" >> $LOGFILE
	3048	echo "$@" >> $LOGFILE
[800]	3049	echo "Start date : `date`" >> $LOGFILE
[1684]	3050	echo "-----------------------------" >> $LOGFILE
[747]	3051
	3052	if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
[963]	3053	LogIt "WARNING - Ancient distro detected." 1
[747]	3054	ln -sf /etc/conf.modules /etc/modules.conf
	3055	fi
	3056	[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
	3057
[1010]	3058	# Log some capital variables
	3059	[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
	3060	echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
	3061	echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
	3062	[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
	3063	echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
	3064	echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
	3065
[747]	3066	trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
[1010]	3067
	3068	# Sanity checks
	3069	which which > /dev/null 2> /dev/null \|\| Die "Please install 'which'."
	3070	which strings > /dev/null 2> /dev/null \|\| Die "Please install binutils and libbinutils; you have no 'strings' executable."
	3071	which gawk > /dev/null 2> /dev/null \|\| Die "Gawk is missing from your computer. Please install gawk. You may find the package on Debian's website. How did I know you're running Debian? Because only Debian would be stupid enough not to include gawk in your distribution."
	3072	which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` \|\| AWK="`which awk 2>/dev/null`"
	3073	if which awk &> /dev/null ; then
	3074	if ! which gawk &> /dev/null ; then
	3075	LogIt "You have awk but not gawk.\nPlease note that mindi works fine with a _sane_ awk binary.\nIf your awk binary misbehaves then please contact your vendor\nor distribution's mailing list for technical support.\n"
	3076	fi
	3077	fi
	3078	which mke2fs > /dev/null 2> /dev/null \|\| Die "Please put mke2fs in system path"
	3079	[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
	3080
[747]	3081	[ "`uname -r \| grep "2.4.[0-6]" \| grep -v "2.4.[0-9][0-9]"`" != "" ] && echo "WARNING! Your kernel may have buggy loopfs code. Consider upgrading to 2.4.7"
	3082	# If we have a 2.6 kernel, the system uses module-init-tools which means that we
	3083	# may have the modprobe configuration spread out across multiple files in
	3084	# directory /etc/modprobe.d. If this is the case we concatenate these files into
	3085	# a temporary file for further processing. Otherwise we continue in the standard
	3086	# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
	3087	# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
	3088	# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
[1684]	3089	if [ -d "/etc/modprobe.d" ] && [ "`uname -r \| cut -c1-3`" = "2.6" ] ; then
[925]	3090	TMPMODPROBE_FLAG="Y"
[747]	3091	else
[925]	3092	TMPMODPROBE_FLAG="N"
	3093	[ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
	3094	[ ! -e "/etc/modules.conf" ] && Die "/etc/modules.conf not found; you may have to create a softlink from /etc/conf.modules to /etc/modules.conf; of course, all good distros use modules.conf anyway..."
[747]	3095	fi
[1010]	3096
	3097	# Update the PATH variable if incomplete
	3098	if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
	3099	PATH=$PATH:/sbin:/usr/sbin
	3100	export PATH
	3101	echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
	3102	echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
	3103	echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
	3104	fi
	3105
[747]	3106	[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null \| grep -E "2\.[46]" \| cut -d' ' -f1`
[1010]	3107
[1737]	3108	if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
[1010]	3109	Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
	3110	fi
	3111
[925]	3112	### BERLIOS
[747]	3113	### Fix as it's not mandatory on ia64
	3114	if [ "$ARCH" = "ia64" ] ; then
[1010]	3115	if which elilo &> /dev/null ; then
	3116	LILO_EXE=elilo
	3117	else
	3118	LILO_EXE=`which false`
	3119	fi
[747]	3120	else
	3121	FindIsolinuxBinary
	3122	FindLiloBinary
	3123	fi
[925]	3124	# BERLIOS: Remove as too dangerous and now useless
[940]	3125	#grep -F " $MINDI_TMP " /proc/mounts \| grep -F tmpfs > /dev/null 2> /dev/null && MINDI_TMP=/home/tmpmondo && mkdir -p $MINDI_TMP && LogIt "Changing MINDI_TMP to $MINDI_TMP because you're using tmpfs for /tmp\n" ; # tmpfs doesn't like Mindi and /tmp, for some reason
[747]	3126	trap "Aborted" SIGTERM
	3127	DONE="\r\t\t\t\t\t\t\t\tDone. "
	3128	CHOPSIZE=240
	3129	BIGNO=0
	3130	MAX_COMPRESSED_SIZE=1300
	3131	kernelpath=""
[1010]	3132	MONDO_ROOT=/var/cache/mondo
[747]	3133	mkdir -p $MONDO_ROOT
	3134
	3135	if [ -d "/proc/lvm" ]; then
	3136	# LVM v1
	3137	LVMCMD=""
	3138	LVM="v1"
	3139	elif [ -d "/dev/mapper" ]; then
	3140	# LVM v2
	3141	LVMCMD="lvm"
	3142	LVM="v2"
	3143	else
	3144	LVM="false"
	3145	fi
[1021]	3146	echo "LVM set to $LVM" >> $LOGFILE
	3147	echo "----------" >> $LOGFILE
	3148	echo "df result:" >> $LOGFILE
	3149	echo "----------" >> $LOGFILE
[1230]	3150	df -T >> $LOGFILE
[1021]	3151	echo "-------------" >> $LOGFILE
[1230]	3152	echo "mount result:" >> $LOGFILE
	3153	echo "-------------" >> $LOGFILE
	3154	mount >> $LOGFILE
	3155	echo "-------------" >> $LOGFILE
[1315]	3156	if [ -e /etc/raidtab ]; then
	3157	echo "-------------" >> $LOGFILE
	3158	echo "/etc/raidtab content:" >> $LOGFILE
	3159	echo "-------------" >> $LOGFILE
	3160	cat /etc/raidtab >> $LOGFILE
	3161	fi
	3162	echo "-------------" >> $LOGFILE
[1418]	3163	echo "cat /proc/cmdline:" >> $LOGFILE
	3164	echo "-------------" >> $LOGFILE
	3165	cat /proc/cmdline >> $LOGFILE
	3166	echo "-------------" >> $LOGFILE
[1021]	3167	echo "lsmod result:" >> $LOGFILE
	3168	echo "-------------" >> $LOGFILE
	3169	lsmod >> $LOGFILE
[1399]	3170	MODULES="`cat /proc/modules \| awk '{print $1}'`"
[1531]	3171	if [ -x /usr/sbin/esxcfg-module ]; then
[1497]	3172	echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
	3173	echo "-------------" >> $LOGFILE
	3174	echo "VMWare modules" >> $LOGFILE
	3175	echo "-------------" >> $LOGFILE
[1531]	3176	/usr/sbin/esxcfg-module -l >> $LOGFILE
[1764]	3177	MODULES="$MODULES `/usr/sbin/esxcfg-module -l \| awk '{print $1}'`"
[1497]	3178	fi
[1021]	3179	echo "-------------" >> $LOGFILE
[1230]	3180	echo "Liste of extra modules is:" >> $LOGFILE
	3181	echo "$EXTRA_MODS" >> $LOGFILE
	3182	echo "-------------" >> $LOGFILE
[747]	3183
[1723]	3184	# Compute libata version
[1726]	3185	laver=`modinfo libata \| grep -Ei '^Version:' \| cut -d: -f2 \| cut -d. -f1 \| sed 's/ *//g'`
[1723]	3186	# If libata v2 is used then remove ide-generic as it will perturbate boot
[1726]	3187	if [ "`echo $MODULES \| grep libata`" ]; then
[1727]	3188	if [ "$laver" = "2" ]; then
[1726]	3189	DENY_MODS="$DENY_MODS ide-generic"
[1727]	3190	echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
[1726]	3191	echo "-------------" >> $LOGFILE
	3192	fi
[1723]	3193	fi
	3194
[747]	3195	if [ "$#" -ge "2" ] ; then
	3196	if [ "$1" = "--max-compressed-size" ] ; then
	3197	MAX_COMPRESSED_SIZE=$2
	3198	shift; shift
	3199	fi
	3200	fi
	3201
	3202	FLOPPY_WAS_MOUNTED=""
	3203	for mtpt in /media/floppy /mnt/floppy /floppy ; do
	3204	if mount \| grep -w $mtpt &> /dev/null ; then
	3205	FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
	3206	umount $mtpt
	3207	fi
	3208	done
	3209
[1684]	3210	#
	3211	# If we have a USB device we need to store info
	3212	# and remove it from the parameters line
	3213	#
[747]	3214	if [ "$#" -ne "0" ] ; then
[1684]	3215	if [ "$1" = "--usb" ] ; then
	3216	shift
	3217	USBDEVICE=$1
	3218	if [ _"$USBDEVICE" = _"" ]; then
	3219	Die "No USB device specified"
	3220	fi
	3221	shift
	3222	fi
	3223	fi
	3224
	3225	if [ "$#" -ne "0" ] ; then
[747]	3226	if [ "$1" = "--findkernel" ] ; then
	3227	res=`TryToFindKernelPath`
[1336]	3228	# Avoids logfile content for mondo
	3229	export MONDO_SHARE=""
[747]	3230	if [ "$res" = "" ] ; then
[925]	3231	MindiExit -1
[747]	3232	else
	3233	echo "$res"
[925]	3234	MindiExit 0
[747]	3235	fi
[1720]	3236	elif [ "$1" = "--locatedeps" ] ; then
	3237	[ ! "$2" ] && Die "Please specify the binary to look at"
	3238	LocateDeps $2
	3239	# Avoids logfile content for mondo
	3240	export MONDO_SHARE=""
	3241	MindiExit $?
[747]	3242	elif [ "$1" = "--makemountlist" ] ; then
	3243	[ ! "$2" ] && Die "Please specify the output file"
	3244	MakeMountlist $2
[1336]	3245	# Avoids logfile content for mondo
	3246	export MONDO_SHARE=""
[925]	3247	MindiExit $?
	3248	elif [ "$1" = "-V" ] \|\| [ "$1" = "-v" ] \|\| [ "$1" = "--version" ] \|\| [ "$1" = "-version" ] ; then
	3249	echo "Mindi v$MINDI_VERSION"
[1336]	3250	# Avoids logfile content for mondo
	3251	export MONDO_SHARE=""
[925]	3252	MindiExit 0
[747]	3253	elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
[940]	3254	MONDO_TMP=$2
	3255	# Change MINDI_TMP for the one provided by mondo
	3256	# So that it can get back the built files
[1010]	3257	mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
	3258	rmdir $MINDI_TMP
[1486]	3259	export MINDI_TMP=$MONDO_TMP
[953]	3260	mkdir -p $MINDI_TMP
[1696]	3261	# This is the scratch dir in mondo - subdir images
[938]	3262	CACHE_LOC=$3
	3263	if [ _"$CACHE_LOC" != _"" ]; then
	3264	mkdir -p $CACHE_LOC
	3265	fi
[925]	3266	kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
[747]	3267	###
	3268	### Sq-Modification...
	3269	### Attempt to locate kernel specific module path
	3270	### if module path is found then use it other wise use uname -r to set it...
	3271	###
	3272	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
[963]	3273	LogIt "kernelname = $kernelname"
	3274	LogIt "kernelpath = $kernelpath"
[747]	3275	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	3276	then
[963]	3277	LogIt "Module path for ${kernelpath} not found..."
	3278	LogIt "using running kernel\'s modules."
[747]	3279	kernelname=`uname -r`
	3280	else
[963]	3281	LogIt "Using modules for kernel: ${kernelname}"
[747]	3282	fi
	3283	###
	3284	### end of Sq-Modification
	3285	###
[925]	3286	TAPEDEV=$5
	3287	TAPESIZE=$6
	3288	FILES_IN_FILELIST=$7
	3289	USE_LZO=$8
	3290	CDRECOVERY=$9
[747]	3291	if [ "${10}" = "(null)" ] \|\| [ "${10}" = "" ] ; then
	3292	IMAGE_DEVS=""
	3293	else
	3294	IMAGE_DEVS="`echo "${10}" \| tr '\|' ' '`"
	3295	fi
[925]	3296	if [ "${11}" ] ; then
	3297	LILO_OPTIONS=""
	3298	# LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
	3299	fi
	3300	LAST_FILELIST_NUMBER=${12}
[747]	3301	ESTIMATED_TOTAL_NOOF_SLICES=${13}
	3302	EXCLUDE_DEVS="${14}"
	3303	USE_COMP="${15}"
	3304	USE_LILO="${16}"
[925]	3305	USE_STAR="${17}"
	3306	INTERNAL_TAPE_BLOCK_SIZE="${18}"
[747]	3307	DIFFERENTIAL="${19}"
[998]	3308	USE_GZIP="${20}"
	3309	NOT_BOOT="${21}"
[747]	3310	[ "$USE_COMP" = "" ] && USE_COMP=yes
[998]	3311	[ "$USE_GZIP" = "" ] && USE_GZIP=no
[747]	3312	[ "$NOT_BOOT" = "" ] && NOT_BOOT=no
[963]	3313	[ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
[925]	3314	[ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
[747]	3315	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
	3316	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	3317	then
[963]	3318	LogIt "Module path for ${kernelpath} not found..."
	3319	LogIt "using running kernel\'s modules."
[747]	3320	kernelname=`uname -r`
	3321	else
[963]	3322	LogIt "Using modules for kernel: ${kernelname}"
[747]	3323	fi
[925]	3324	[ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
[1696]	3325	# MONDO_ROOT is the real scratchdir
[925]	3326	MONDO_ROOT=`echo $CACHE_LOC \| sed 's/\(.\)\/./\1/'`
[938]	3327	if [ _"$MONDO_ROOT" != _"" ]; then
	3328	mkdir -p $MONDO_ROOT
	3329	else
	3330	Die "MONDO_ROOT is undefined"
	3331	fi
[747]	3332	else
[925]	3333	echo "Syntax: mindi (--custom ....)" >> /dev/stderr
	3334	MindiExit -1
[747]	3335	fi
	3336	fi
	3337	#ScanCDandTape
	3338	[ "$CDRECOVERY" = "yes" ] \|\| CDRECOVERY=no
	3339	if [ "$CDRECOVERY" = "yes" ] ; then
	3340	iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
	3341	sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
	3342	else
	3343	iso_cfg_file=$MINDI_LIB/isolinux.cfg
	3344	sys_cfg_file=$MINDI_LIB/syslinux.cfg
	3345	fi
	3346
	3347	[ -e "$iso_cfg_file" ] \|\| Die "Cannot find $iso_cfg_file"
[1684]	3348	if [ _"$MONDO_SHARE" = _"" ]; then
[963]	3349	LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
	3350	LogIt "Latest Mindi is available from http://www.mondorescue.org"
	3351	LogIt "BusyBox sources are available from http://www.busybox.net"
[747]	3352	LogIt "------------------------------------------------------------------------------"
	3353	else
[1315]	3354	echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
[747]	3355	fi
[1005]	3356	if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
	3357	LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 \| head -1`"
	3358	else
	3359	LogIt "Unable to find mindi-busybox, please install it"
	3360	MindiExit -1
	3361	fi
[747]	3362
	3363	# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
	3364	insmod /lib/modules/`uname -r`///misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
	3365	for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
	3366	insmod $i >> $LOGFILE 2>> $LOGFILE
	3367	done
	3368
	3369	KERN_DISK_MADE=""
	3370
	3371	echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
	3372	echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
	3373	echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
	3374	if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
[963]	3375	LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
[940]	3376	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	3377	MakeMountlist $MINDI_TMP/mountlist.txt
	3378	mkdir -p $MINDI_TMP/small-all/tmp
	3379	cd $MINDI_TMP/small-all
[953]	3380	cp -f $MINDI_TMP/{mountlist.txt,mondo-restore.cfg,filelist.full.gz,biggielist.txt} tmp 2>/dev/null \|\| Die "Cannot copy small all.tar.gz"
[940]	3381	tar -cv tmp \| gzip -9 > $MINDI_TMP/all.tar.gz \|\| Die "Cannot make small all.tar.gz"
[747]	3382	sleep 2
[963]	3383	LogIt "Done. Exiting."
[925]	3384	MindiExit 0
[747]	3385	fi
	3386
[1690]	3387	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1684]	3388	LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
	3389	fi
	3390
[747]	3391	if [ "$kernelpath" = "" ] ; then
[1335]	3392	[ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
[966]	3393	echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
	3394	read ch
	3395	if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
	3396	USE_OWN_KERNEL="yes"
[747]	3397	fi
	3398	if [ "$USE_OWN_KERNEL" = "yes" ]; then
[925]	3399	YOUR_KERNEL_SUCKS=""
	3400	kernelpath=`TryToFindKernelPath`
	3401	if [ "$kernelpath" = "" ] ; then
	3402	echo -n "Please enter kernel path : "
	3403	read kernelpath
	3404	fi
[747]	3405	else
[925]	3406	YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
[747]	3407	fi
	3408	fi
[1575]	3409	if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
[966]	3410	echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
[747]	3411	read ch
[966]	3412	if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
	3413	USE_LILO=no
	3414	else
[747]	3415	USE_LILO=yes
	3416	fi
	3417	fi
	3418	if [ "$YOUR_KERNEL_SUCKS" != "" ] \|\| [ "$kernelpath" = "" ] \|\| [ "$kernelpath" = "SUCKS" ] \|\| [ "$kernelpath" = "FAILSAFE" ] ; then
	3419	kernelpath=$MINDI_LIB/vmlinuz
[963]	3420	LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
	3421	LogIt "However, you are still running your kernel. If Mindi fails to create your"
	3422	LogIt "disks then it may still be a result of a problem with your kernel."
[747]	3423	pwd=`pwd`
[940]	3424	cd $MINDI_TMP
[747]	3425	bzip2 -dc $MINDI_LIB/lib.tar.bz2 \| tar -x \|\| Die "Cannot unzip lib.tar.bz2"
	3426	cd $pwd
	3427	YOUR_KERNEL_SUCKS="Your kernel sucks"
	3428	fi
[940]	3429	echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
[963]	3430	[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
[747]	3431
[965]	3432	[ "$YOUR_KERNEL_SUCKS" ] && [ ! "$FAILSAFE_KVER" ] && Die "Please install mindi-kernel package. You need it.\nGo to http://www.mondorescue.org and download it, then install it."
[747]	3433
[925]	3434	PrepareDataDiskImages $CACHE_LOC
[747]	3435	noof_disks=$?
	3436	ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
	3437	rds=$(($ramdisk_size-$((ramdisk_size%4096))))
	3438	ramdisk_size=$rds
	3439
	3440	echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
[1567]	3441	if [ "$ARCH" = "ia64" ] ; then
	3442	PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create ia64 floppy disk image."
	3443	else
	3444	if [ "$USE_LILO" = "yes" ] ; then
[925]	3445	if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
[964]	3446	LogIt "WARNING - failed to create 1.72MB boot image."
	3447	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
[747]	3448	fi
[925]	3449	if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
[963]	3450	LogIt "WARNING - failed to create 2.88MB floppy disk image."
[964]	3451	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[1282]	3452	PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create 2.88MB floppy disk image."
[747]	3453	fi
[1567]	3454	else
	3455	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
	3456	LogIt "WARNING - failed to create 1.72MB boot image."
	3457	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
	3458	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
	3459	LogIt "WARNING - failed to create 2.88MB floppy disk image."
	3460	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
	3461	PrepareBootDiskImage_SYSLINUX $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create 5.76MB floppy disk image."
	3462	fi
[747]	3463	fi
	3464	fi
	3465	fi
	3466
	3467	[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
	3468	...Or type 'memtest' to test your PC's RAM thoroughly.\n"
	3469
[1684]	3470	if [ _"$MONDO_SHARE" = _"" ]; then
[925]	3471	ListImagesForUser $CACHE_LOC
[747]	3472	boot_dev=/dev/fd0u1722
	3473	[ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
	3474	[ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
	3475	[ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
	3476	if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
[925]	3477	OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
[747]	3478	fi
[1684]	3479	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
	3480	OfferToMakeBootableUSB $CACHE_LOC
	3481	fi
[925]	3482	OfferToMakeBootableISO $CACHE_LOC
[963]	3483	LogIt "Finished."
[747]	3484	elif [ "$TAPEDEV" ] ; then
[925]	3485	OfferToMakeBootableISO $CACHE_LOC
	3486	if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
[963]	3487	cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
[747]	3488	else
[925]	3489	Die "Cannot find all.tar.gz, to be written to tape"
[747]	3490	fi
[1695]	3491	elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1684]	3492	OfferToMakeBootableUSB $CACHE_LOC
[747]	3493	else
[925]	3494	OfferToMakeBootableISO $CACHE_LOC
[747]	3495	fi
	3496	# cleanup
[963]	3497	LogIt "$FRIENDLY_OUTSTRING"
[747]	3498	for mtpt in $FLOPPY_WAS_MOUNTED ; do
	3499	mount $mtpt
	3500	done
[925]	3501	MindiExit 0

Note: See TracBrowser for help on using the repository browser.

Download in other formats: