Context Navigation

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

Visit:

Last change on this file since 1828 was 1828, checked in by Bruno Cornec, 16 years ago
kqemu is denied. Probably should also be done for kvm stuff
Property svn:keywords set to `Rev Id`
File size: 125.3 KB

Rev	Line
[747]	1	#!/bin/bash
	2
	3	# $Id: mindi 1828 2007-12-01 19:29:20Z 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
[1821]	42	EXTRA_SPACE=32768 # increase if you run out of ramdisk space
	43	BOOT_SIZE=16384 # size of the boot disk
[1599]	44	MAX_DISKS=99
[1821]	45	WRITE_BOOT_FLOPPIES="yes" # do you want to be propted to write floppy images
[747]	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.
[1828]	77	#DENY_MODS="MPS_Driver_Mapper mps octtldrv tscttl streams kqemu"
	78	DENY_MODS="kqemu"
[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`
[1815]	667	#[ "$?" -ne "0" ] && Die "find $1 -name $2.o -type f --- failed"
[747]	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
[1824]	972	if [ -e "/vmfs/volumes" ]; then
	973	# For VMWare ESX 3 get the device names of these volumes
	974	vdf -P \| grep -E '/vmfs/volumes' \| awk '{print $1}'
	975	fi
[747]	976	return
	977	}
	978
	979
	980	ListImagesForUser() {
	981	local path fname
	982	path=$1
	983	echo -en "In the directory '$path' you will find the images:-\n"
	984	for fname in `ls $path \| grep -F mindi-` ; do
	985	printf "%19s " $fname
	986	done
	987	echo " "
	988	}
	989
	990
	991	ListKernelModulePaths() {
	992	local module_list module fname oss r kern
	993	oss="/root/oss/modules"
[1399]	994	module_list="$MODULES"
[1230]	995	# Remove unwanted modules from list
	996	for i in $DENY_MODS; do
	997	module_list=`echo ${module_list} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1726]	998	EXTRA_MODS=`echo ${EXTRA_MODS} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1230]	999	done
[747]	1000	###
	1001	### Sq-Modification ... Use kernelname for module search path if specified
	1002	###
	1003	# kern="`uname -r`"
	1004	if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
	1005	then
	1006	kern=${kernelname}
	1007	else
	1008	kern="`uname -r`"
	1009	fi
	1010	###
	1011	### Sq-Mod End
	1012	###
	1013	for module in $module_list $EXTRA_MODS ; do
	1014	r=`find /lib/modules/$kern -type f \| grep "/${module}\..*o" \| tail -n1`
	1015	echo "module $module --> $r" >> $LOGFILE
	1016	[ "$r" ] && echo "$r"
	1017	[ -f "$oss" ] && find $oss \| grep -F $module
	1018	done
	1019	find /lib/modules/$kern/modules.* -type f 2> /dev/null
	1020	[ -f "$oss" ] && find $oss.* 2> /dev/null
	1021	}
	1022
[1784]	1023	#
	1024	# Critical function which computes all dependencies (dyn. lib.)
	1025	# for a list of binaries
	1026	#
[747]	1027	LocateDeps() {
	1028	local incoming fname deps
[1724]	1029	incoming="$*"
[747]	1030	for fname in $incoming ; do
	1031	if [ ! -e "$fname" ] ; then
[963]	1032	echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
[747]	1033	if echo $fname \| grep lvm &> /dev/null ; then
	1034	echo "This warning only affects you if you are using LVM." >> $LOGFILE
[1399]	1035	if echo "$MODULES" \| grep lvm &> /dev/null ; then
[747]	1036	echo "I think you are, so please take heed!" >> $LOGFILE
	1037	# LogIt "Where is liblvm? You need it."
	1038	else
	1039	echo "I don't think you are, so don't worry about it." >> $LOGFILE
	1040	fi
	1041	fi
	1042	elif [ -h "$fname" ] && [ -x "$fname" ] ; then
	1043	echo "$fname is softlink" >> $LOGFILE
	1044	else
[1526]	1045	ldd $fname 2> /dev/null \| ProcessLDD
[747]	1046	fi
	1047	done
	1048	}
	1049
[925]	1050
[860]	1051	# Give all symlinks recursively of a full path name
	1052	ReadAllLink() {
	1053	file="$1"
[747]	1054
[860]	1055	if [ ! -h $file ]; then
	1056	echo "$file"
	1057	return 0
	1058	fi
[747]	1059
[1021]	1060	link=`readlink -f $file`
[862]	1061	d=`dirname $file`
	1062	if [ ! -e "$link" -a ! -e "$d/$link" ]; then
	1063	echo "Problem with dead link on $file -> $link" >> $LOGFILE
	1064	fi
[1230]	1065	if [ -h "$d" ]; then
[1784]	1066	echo "$link"
	1067	echo "$d"
[860]	1068	else
[1230]	1069	echo "$link"
	1070	fi
[860]	1071	}
	1072
[925]	1073
[747]	1074	LocateFile() {
	1075	local i path fname_to_find location output resolved tmp stub cache_id loclist
	1076	fname_to_find="$1"
[1526]	1077	# It's an absolute path
[747]	1078	if echo "$fname_to_find" \| grep -x "/.*" ; then
[859]	1079	output="$fname_to_find"
[860]	1080	if [ -h "$output" ] ; then
	1081	output="`ReadAllLink $output` $output"
	1082	fi
[859]	1083	echo "$output"
	1084	return 0
[747]	1085	fi
[1526]	1086	# It's not an absolute path
[747]	1087	output=""
[1526]	1088	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
	1089	#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
	1090	[ -h "$path" ] && continue
	1091	[ ! -e "$path/$fname_to_find" ] && continue
	1092	output="$path/$fname_to_find $output"
	1093	if [ -h "$path/$fname_to_find" ] ; then
	1094	output="`ReadAllLink $path/$fname_to_find` $output"
	1095	fi
[747]	1096	done
	1097	if [ "$output" = "" ] ; then
[860]	1098	return 1
[747]	1099	fi
	1100	echo "$output"
	1101	return 0
	1102	}
	1103
	1104
	1105	LogIt() {
	1106	if [ -e /dev/stderr ] ; then
[925]	1107	echo -e "$1" >> /dev/stderr
[747]	1108	elif [ -e /usr/bin/logger ] ; then
[925]	1109	/usr/bin/logger -s $1
[747]	1110	fi
[965]	1111	echo -e "$1" >> $LOGFILE
[747]	1112	}
	1113
	1114
	1115	# Called by TurnTgzIntoRdz, to make /tmp/mondo-restore.cfg
	1116	MakeMondoConfigFile() {
	1117	local outfile use_lzo use_comp use_star
	1118	outfile=$1
	1119	> $outfile
	1120	[ "$TAPESIZE" ] && echo "media-size $TAPESIZE" >> $outfile
	1121	[ "$TAPEDEV" ] && echo "media-dev $TAPEDEV" >> $outfile
[1698]	1122	[ "$USBDEVICE" ] && echo "usb-dev $USBDEVICE" >> $outfile
[747]	1123	[ "$FILES_IN_FILELIST" ] && echo "files-in-filelist $FILES_IN_FILELIST" >> $outfile
	1124	[ "$LAST_FILELIST_NUMBER" ] && echo "last-filelist-number $LAST_FILELIST_NUMBER" >> $outfile
	1125	[ "$INTERNAL_TAPE_BLOCK_SIZE" ] && echo "internal-tape-block-size $INTERNAL_TAPE_BLOCK_SIZE" >> $outfile
	1126	use_lzo=$USE_LZO; [ "$use_lzo" = "" ] && use_lzo="no"
[998]	1127	use_gzip=$USE_GZIP; [ "$use_gzip" = "" ] && use_gzip="no"
[747]	1128	use_comp=$USE_COMP; [ "$use_comp" = "" ] && use_comp="yes"
	1129	use_star=$USE_STAR; [ "$use_star" = "" ] && use_star="no"
	1130	echo "use-lzo $use_lzo" >> $outfile
[998]	1131	echo "use-gzip $use_gzip" >> $outfile
[747]	1132	echo "use-star $use_star" >> $outfile
	1133	echo "use-comp $use_comp" >> $outfile
	1134	echo "datestamp `date`" >> $outfile
	1135	[ "$ESTIMATED_TOTAL_NOOF_SLICES" ] && echo "total-slices $ESTIMATED_TOTAL_NOOF_SLICES" >> $outfile
[940]	1136	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-IPADDR nfs-client-ipaddr $outfile
	1137	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-NETMASK nfs-client-netmask $outfile
	1138	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-BROADCAST nfs-client-broadcast $outfile
	1139	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-DEFGW nfs-client-defgw $outfile
	1140	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-MOUNT nfs-server-mount $outfile
	1141	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-PATH nfs-server-path $outfile
	1142	AddFileToCfgIfExists $MINDI_TMP/NFS-DEV nfs-dev $outfile
	1143	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-IPADDR nfs-server-ipaddr $outfile
	1144	AddFileToCfgIfExists $MINDI_TMP/ISO-DEV iso-dev $outfile
	1145	AddFileToCfgIfExists $MINDI_TMP/ISO-MNT iso-mnt $outfile
	1146	AddFileToCfgIfExists $MINDI_TMP/ISO-PREFIX iso-prefix $outfile
	1147	AddFileToCfgIfExists $MINDI_TMP/ISODIR isodir $outfile
	1148	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.DEVICE bootloader.device $outfile
	1149	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.NAME bootloader.name $outfile
	1150	AddFileToCfgIfExists $MINDI_TMP/KEYMAP-LIVES-HERE keymap-lives-here $outfile
	1151	AddFileToCfgIfExists $MINDI_TMP/TAPEDEV-HAS-DATA-DISKS tapedev-has-data-disks $outfile
	1152	AddFileToCfgIfExists $MINDI_TMP/BACKUP-MEDIA-TYPE backup-media-type $outfile
	1153	AddFileToCfgIfExists $MINDI_TMP/DIFFERENTIAL differential $outfile
[949]	1154	AddFileToCfgIfExists $MINDI_TMP/ACL acl $outfile
	1155	AddFileToCfgIfExists $MINDI_TMP/XATTR xattr $outfile
[747]	1156	}
	1157
	1158
	1159	MakeModuleLoadingScript() {
	1160	local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
	1161	tmpmodprobe_flag=$1
	1162	outfile=$2
	1163	> $outfile \|\| Die "Cannot create empty $outfile"
	1164	echo -en "#\041/bin/sh\n\n" >> $outfile
	1165	echo "echo -en \"Loading your modules...\"" >> $outfile
	1166	if [ "$YOUR_KERNEL_SUCKS" ] ; then
	1167	kver=$FAILSAFE_KVER
[940]	1168	cd $MINDI_TMP
[747]	1169	searchpath=lib/modules/$kver
	1170	else
	1171	###
	1172	### Sq-Modification ... Use kernelname for module search path if specified
	1173	###
	1174	#kver=`uname -r`
	1175	if [ "${kernelname}" != "" ]
	1176	then
[925]	1177	kver=${kernelname}
[747]	1178	else
[925]	1179	kver=`uname -r`
[747]	1180	fi
	1181	###
	1182	### Sq-Modification end
	1183	###
	1184	searchpath=/lib/modules/$kver
	1185	fi
	1186
	1187	echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
[1399]	1188	list_to_echo="$MODULES"
[1230]	1189	# Remove unwanted modules from list
	1190	for i in $DENY_MODS; do
	1191	list_to_echo=`echo ${list_to_echo} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1726]	1192	EXTRA_MODS=`echo ${EXTRA_MODS} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
[1230]	1193	done
[925]	1194
[747]	1195	# Make temporary modprobe.conf file if we are told so
[1342]	1196	if [ "$tmpmodprobe_flag" = "Y" ] ; then
[940]	1197	infile="$MINDI_TMP/modprobe.conf.mindi"
[747]	1198	find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 \| xargs -0 cat > $infile
	1199	else
	1200	infile="/etc/modules.conf"
	1201	fi
[1721]	1202
[747]	1203	for module in $list_to_echo $EXTRA_MODS ; do
	1204	params=`sed -n "s/^options \\+$module \\+//p" $infile`
	1205	modpaths=`FindSpecificModuleInPath $searchpath $module`
	1206	for i in $modpaths ; do
	1207	echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
	1208	\| tr '.' '#' \
	1209	\| sed s/#o#gz/#o/ \
	1210	\| sed s/#o#gz/#o/ \
	1211	\| sed s/#ko#gz/#ko/ \
	1212	\| sed s/#ko#gz/#ko/ \
	1213	\| tr '#' '.' >> $outfile
	1214	echo -en "$i added to module list.\n" >> $LOGFILE
	1215	done
	1216	done
	1217	echo -en "done\n" >> $outfile
	1218	echo "echo \"Done.\"" >> $outfile
	1219	chmod +x $outfile
	1220	cd /
	1221	# Remove temporary modprobe.conf file if we have created one
[1342]	1222	if [ "$tmpmodprobe_flag" = "Y" ] ; then
[747]	1223	rm -f $infile
	1224	fi
	1225	}
	1226
	1227
	1228	MakeMountlist() {
	1229	local scratchdir mountlist all_partitions current_partition \
	1230	partition_size partition_format outstring partition_number \
	1231	partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
	1232	absolute_partition old_partition_fmt current_lvolume
	1233
[967]	1234	echo "Your raw fstab file looks like this:" >> $LOGFILE
	1235	echo "------------------------------------" >> $LOGFILE
[747]	1236	cat $MY_FSTAB >> $LOGFILE
[967]	1237	echo "Your mountlist will look like this:" \| tee -a $LOGFILE
	1238	echo "-----------------------------------" >> $LOGFILE
[747]	1239
	1240	# scratchdir, mountlist(OUT)
[940]	1241	scratchdir=$MINDI_TMP
[747]	1242	mountlist=$1
	1243
	1244	# NB: partition = device
	1245	# NB: mountpt = where the device is mounted
	1246
	1247	[ -e "$MY_FSTAB" ] \|\| Die "Cannot find your fstab file ($MY_FSTAB)"
	1248
[1684]	1249	[ "$mountlist" != "" ] && rm -Rf $mountlist
[747]	1250	> $mountlist
	1251	echo -en "\rHang on...\r"
	1252	all_partitions=""
	1253
	1254	if [ $LVM != "false" ]; then
	1255	echo -en "\rAnalyzing LVM...\r"
[968]	1256	$MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
[971]	1257	if [ $? -ne 0 ]; then
[963]	1258	LVM="false"
	1259	fi
[968]	1260	all_partitions=`cat $MINDI_TMP/lvm.res \| grep -F ">>>" \| cut -d' ' -f2-32`
[747]	1261	fi
	1262	all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
	1263	# echo "all partitions = $all_partitions" > /dev/stderr
	1264	for i in $IMAGE_DEVS ; do
	1265	mount \| grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
	1266	done
	1267	[ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" \| tr ' ' '\n' \| sort -u \| tr '\n ' ' '`"
[1755]	1268	printf " %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID \| tee -a $LOGFILE
[747]	1269	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"
	1270	for c_p in $all_partitions ; do
	1271	[ "`echo "$useless_dev" \| grep -F "$c_p"`" != "" ] \|\| [ "`echo "$c_p" \| grep ":"`" != "" ] && continue
	1272	[ "`echo "$c_p" \| grep -x "/dev/cdroms.*"`" ] && continue
	1273	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]	1274	current_partition=`readlink -f $c_p`
[747]	1275	[ "`echo "$current_partition" \| grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
	1276	[ "`echo "$useless_dev" \| grep -F "$current_partition"`" ] && continue
	1277	else
	1278	current_partition="$c_p"
	1279	fi
	1280	[ "$c_p" = "none" ] && continue
	1281	redhat_label=""
[957]	1282	uuid=""
[861]	1283	absolute_partition=`readlink -f $c_p`
[747]	1284	partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $2}' \| head -n1`
	1285
	1286	# Detects noauto partitions not mounted and exclude them
	1287	partition_option=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $4}' \| head -n1`
	1288	if [ "`echo "$partition_option" \| grep -i noauto`" != "" ] && [ "`mount \| grep -w "$partition_mountpt"`" = "" ] ; then
	1289	continue
	1290	fi
	1291
	1292	# This part tries to retrieve the correct device from a LABEL line in /etc/fstab
	1293	# current_partition contains only first column of /etc/fstab
	1294	if [ "`echo "$current_partition" \| /bin/grep -i "LABEL="`" != "" ]; then
	1295	str_to_find_fmt_with=$current_partition
[980]	1296	redhat_label=`echo "$current_partition" \| cut -d'=' -f2`
[747]	1297	actual_dev=""
[853]	1298
	1299	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1300	if [ -x "/sbin/findfs" ]; then
[855]	1301	actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
[853]	1302	fi
[747]	1303
[853]	1304	# 2nd try : blkid, the good way for all LABEL except swap
	1305	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1306	actual_dev=`/sbin/blkid \| /bin/grep "$redhat_label" \| grep LABEL= \| cut -d':' -f1`
[747]	1307	# For LVM FS it will give a /dev/dm-# which should then be converted
[748]	1308	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1309	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1310	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[747]	1311	for dev in `ls /dev/mapper/*`; do
[963]	1312	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1313	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[747]	1314	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1315	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[747]	1316	break
	1317	fi
	1318	done
	1319	fi
	1320	fi
	1321
[853]	1322	# 3rd try, which works on a standard partition (ext2/3), but not on swap
[747]	1323	# For LVM gives a /dev/mapper entry
	1324	if [ "x$actual_dev" = "x" ]; then
[980]	1325	actual_dev=`/bin/mount -l \| /bin/grep "\[$redhat_label\]" \| cut -d' ' -f1`
[747]	1326	fi
	1327
[853]	1328	# 4th try, with vol_id
[747]	1329	# SWAP only
	1330	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1331	list_swaps=`cat /proc/swaps \| /bin/grep "/dev/" \| $AWK '{ print $1 }' `
[747]	1332	for dev_swap in $list_swaps ; do
	1333	dev_exists=`/sbin/vol_id $dev_swap \| /bin/grep "$redhat_label"`
	1334	if [ "x$dev_exists" != "x" ]; then
	1335	actual_dev=$dev_swap
	1336	break;
	1337	fi
	1338	done
	1339	fi
	1340
[853]	1341	# 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
[789]	1342	# LABEL=SW-cciss/c0d0p3 (RDP)
[853]	1343	# or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
[747]	1344	# SWAP only
[789]	1345	if [ "x$actual_dev" = "x" -a _"`echo $current_partition \| /bin/grep -iE 'LABEL=SWAP\|LABEL=SW-'`" != _"" ]; then
[853]	1346	for try_dev in `tail +2 /proc/swaps \| cut -d' ' -f1`
	1347	do
	1348	# Location of the swap label for kernel 2.6
[1009]	1349	try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
[853]	1350	if [ "x$try_dev_label" = "x$redhat_label" ]; then
[855]	1351	actual_dev=$try_dev
[853]	1352	fi
	1353	done
[747]	1354	fi
[1008]	1355
	1356	# Check if one of all those tries has known success
	1357	if [ "x$actual_dev" != "x" ]; then
	1358	current_partition=$actual_dev
	1359	else
	1360	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"
	1361	fi
[957]	1362	# This part tries to retrieve the correct device from a UUID line in /etc/fstab
	1363	# current_partition contains only first column of /etc/fstab
[1009]	1364	elif [ "`echo "$current_partition" \| /bin/grep -i "UUID="`" != "" ]; then
[957]	1365	str_to_find_fmt_with=$current_partition
[980]	1366	uuid=`echo "$current_partition" \| cut -d'=' -f2`
[957]	1367	actual_dev=""
	1368
	1369	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1370	if [ -x "/sbin/findfs" ]; then
	1371	actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
	1372	fi
	1373
[1531]	1374	# 2nd try : blkid, the good way for all UUID except swap
[957]	1375	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1376	actual_dev=`/sbin/blkid \| /bin/grep "$uuid" \| grep UUID= \| cut -d':' -f1`
[957]	1377	# For LVM FS it will give a /dev/dm-# which should then be converted
	1378	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1379	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1380	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[957]	1381	for dev in `ls /dev/mapper/*`; do
[963]	1382	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1383	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[957]	1384	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1385	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[957]	1386	break
	1387	fi
	1388	done
	1389	fi
	1390	fi
	1391
	1392	# 3th try, with vol_id
	1393	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1394	list_dev=`mount \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
[957]	1395	for dev in $list_dev ; do
	1396	dev_exists=`/sbin/vol_id $dev \| /bin/grep "$uuid"`
	1397	if [ "x$dev_exists" != "x" ]; then
	1398	actual_dev=$dev
	1399	break;
	1400	fi
	1401	done
	1402	fi
	1403
[1531]	1404	# 4th try, with dumpuuid (VMWare only ?) for swap
	1405	if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
	1406	list_dev=`cat /proc/swaps \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
	1407	for dev in $list_dev ; do
	1408	dev_exists=`/sbin/dumpuuid $dev \| /bin/grep "$uuid"`
	1409	if [ "x$dev_exists" != "x" ]; then
	1410	actual_dev=$dev
	1411	break;
	1412	fi
	1413	done
	1414	fi
	1415
[747]	1416	# Check if one of all those tries has known success
	1417	if [ "x$actual_dev" != "x" ]; then
	1418	current_partition=$actual_dev
	1419	else
[1315]	1420	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]	1421	fi
	1422	else
	1423	str_to_find_fmt_with=$current_partition
	1424	fi
	1425
	1426	partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
	1427	# Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
	1428	# for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
	1429	# the former is then a link to the latter, so we test whether
	1430	# $current_partition is actually such a link or not and set
[755]	1431	# $current_lvolume accordingly. On Debian you may find more than one answer
	1432	# so we remove the one corresponding to /dev/.static
	1433	# On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
	1434	# principle is the same and we need to find the link to it as well.
	1435	# Note that $current_lvolume may well be an
[747]	1436	# ordinary device. It is just to make sure that we feed the right value
	1437	# into any of the LVM tools if possible.
	1438
	1439	current_lvolume="$current_partition"
[763]	1440	if [ $LVM = "v2" ] && [ "`echo $current_partition \| grep -E '^/dev/mapper/'`" ]; then
[755]	1441	# .static dir are a Debian specificity
[763]	1442	current_lvolume="`find /dev -lname "$current_partition" \| grep -Ev '^/dev/\.static/'`"
[755]	1443	echo $current_lvolume \| grep -q ' '
[784]	1444	if [ $? -eq 0 ]; then
[755]	1445	echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE
	1446	fi
[747]	1447	fi
	1448	#
	1449	# End of LVM device style variation code (other than $current_lvolume).
	1450
[745]	1451	if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
	1452	# Size computed via LVM not directly
[747]	1453	partition_size="lvm"
	1454	else
	1455	partition_size=`SizeOfPartition $current_partition`
	1456	[ "`echo "$current_partition" \| grep "[0-9]"`" = "" ] && continue
	1457	[ "`echo "$current_partition" \| grep -c "^/"`" -ne "1" ] && continue
	1458	if [ "$partition_format" = "swap" ] \|\| [ "$partition_mountpt" = "swap" ] ; then
	1459	partition_size=`grep -Fv "Priority" /proc/swaps \| tr -s '\t' ' ' \| grep -F "$current_partition" \| $AWK '{print $3}'`
	1460	[ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
	1461	[ "$partition_format" != "swap" ] && partition_format="swap"
	1462	if [ "$partition_size" = "" ] ; then
	1463	totalsize=0
	1464	items=0
	1465	for i in `tr -s ' ' '\t' < /proc/swaps \| grep -Fv "Filename" \| cut -f3` ; do
	1466	totalsize=$(($totalsize+$i))
	1467	items=$(($items+1))
	1468	done
	1469	[ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) \|\| partition_size=0
	1470	[ "$partition_size" -lt "125000" ] && partition_size=125000
	1471	echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
	1472	fi
	1473	fi
	1474	fi
	1475	[ "$partition_mountpt" = "swap" ] && partition_format="swap"
	1476	[ "$partition_format" = "swap" ] && partition_mountpt="swap"
	1477	if [ "$partition_mountpt" = "" ] ; then
	1478	if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
	1479	if [ "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
	1480	partition_mountpt="raid"
	1481	partition_format="raid"
	1482	else
	1483	partition_mountpt="lvm"
	1484	partition_format="lvm"
	1485	fi
	1486	fi
	1487	fi
	1488	psz=$partition_size
	1489	echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
	1490	[ "$psz" != "lvm" ] && psz=$(($psz/1024))
	1491	if [ "`echo " $IMAGE_DEVS " \| grep -F " $current_partition "`" != "" ] ; then
	1492	partition_mountpt="image"
	1493	old_partition_fmt=$partition_format
	1494	partition_format="`$FDISK -l 2>> $LOGFILE \| tr '*' ' ' \| tr '+' ' ' \| tr -s ' ' '\t' \| grep -w "$absolute_partition" \| cut -f5`"
	1495	partition_size=$(($partition_size+1)); # just in case
	1496	if [ "$partition_format" = "Linux" ] ; then
	1497	echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
	1498	echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
	1499	partition_format=$old_partition_fmt
	1500	fi
	1501	fi
	1502	if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " \| grep -F " $current_partition "`" ] \|\| [ "`echo " $EXCLUDE_DEVS " \| grep " $current_partition "`" ] ; then
	1503	echo "Excluding $current_partition from mountlist" >> $LOGFILE
	1504	continue
	1505	fi
	1506	if [ ! "$partition_mountpt" ] ; then
[965]	1507	echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
[747]	1508	for qq in "" `find /dev/ida/cd ! -name 'p'` ; do
	1509	partition_format=`$FDISK -l $qq 2>> $LOGFILE \| grep -w "$c_p" \| sed 's/12/\|/' \| tr -s '\t' ' ' \| cut -d'\|' -f2 \| cut -d' ' -f2-9`
	1510	[ "$partition_format" ] && break
	1511	done
[965]	1512	echo "------- $FDISK log end ------------" >> $LOGFILE
[747]	1513	if [ "$partition_format" = "Compaq diagnostics" ] ; then
	1514	partition_format="compaq"
	1515	elif [ ! "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
[963]	1516	LogIt "Unable to find mountpoint of $current_partition - ignoring"
[747]	1517	continue
	1518	fi
	1519	fi
[1755]	1520	if [ "$redhat_label" ]; then
	1521	label="$redhat_label"
[1756]	1522	elif [ "$uuid" ]; then
[1755]	1523	label="$uuid"
	1524	fi
[747]	1525	partition_format="`echo "$partition_format" \| cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
[963]	1526	[ "$partition_format" = "auto" ] && partition_format="`mount \| grep -w $current_partition \| $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
[1755]	1527	unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
[747]	1528	if [ "$current_partition" = "" ] ; then
	1529	echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
	1530	elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
	1531	if [ "`grep -F device /etc/raidtab 2>/dev/null \| grep -F $current_partition`" ] ; then
	1532	partition_mountpt=raid
	1533	partition_format=raid
[1755]	1534	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1535	printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1536	else
	1537	echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
	1538	fi
	1539	elif [ "$partition_format" = "" ] ; then
	1540	echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
	1541	elif [ "$partition_size" = "" ] ; then
	1542	echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
	1543	elif [ "$partition_mountpt" = "/proc" ] \|\| [ "$partition_mountpt" = "/dev/pts" ] ; then
	1544	continue
	1545	else
	1546	if [ "$partition_format" = "dos" ] \|\| [ "$partition_format" = "msdos" ] ; then
	1547	echo "Stupid bastard..." >> $LOGFILE
	1548	partition_format="vfat"
	1549	fi
[1755]	1550	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1551	printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1552	fi
	1553	done
	1554	}
	1555
	1556
	1557	MakeSureNumberIsInteger() {
	1558	res=`echo "$1" \| tr -s '\-[0-9]' ' '`
	1559	if [ "$res" != " " ] && [ "$res" != "" ] ; then
	1560	echo "result = '$res'"
	1561	Die "$1 should be an integer"
	1562	fi
	1563	}
	1564
	1565
	1566	MakeSyslinuxMessageFile() {
	1567	mkdir -p $1
	1568	rmdir $1
	1569	echo -en " " > $1
	1570	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1571	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
	1572	else
	1573	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
	1574	fi
	1575	sed s/%r/"`uname -r`"/ $1.tmp \| sed s/%t/"`hostname`"/ > $1
	1576	rm -f $1.tmp
	1577	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1578	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1579	echo -en "Press <enter> to continue.\n" >> $1
[940]	1580	elif [ ! "$MINDI_TMP" ] ; then
[747]	1581	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
	1582	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1583	echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
	1584	fi
	1585	else
	1586	echo -en "$BOOT_MEDIA_MESSAGE" >> $1
	1587	fi
	1588	else
	1589	echo -en " \
	1590	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1591	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
	1592	fi
	1593	}
	1594
	1595
	1596	MoveHyperlinkSensibly() {
	1597	local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
	1598	filename=$1
	1599	minidir_root=$2
	1600	resides_on_diskno=$3
	1601	noof_disks=$4
	1602
	1603	[ -h "$minidir_root/$resides_on_diskno/$filename" ] \|\| Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
	1604
	1605	old_diskno=$resides_on_diskno
	1606	d=1
	1607	while [ "$d" -le "$noof_disks" ] ; do
	1608	if [ "$d" -ne "$old_diskno" ] ; then
	1609	old_pwd=`pwd`
	1610	cd $minidir_root/$old_diskno
[963]	1611	cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE \|\| Die "Can't move $filename (sensibly) from $old_diskno to $d"
[747]	1612	rm -f $filename
	1613	cd $old_pwd
	1614	fi
	1615	# when the softlink is resolvable, our work here is done
	1616	[ -e "$minidir_root/$d/$filename" ] && return 0
	1617	old_diskno=$d
	1618	d=$(($d+1))
	1619	done
	1620	return 1
	1621	}
	1622
	1623
	1624
	1625	OfferToCopyImagesToDisks() {
	1626	local imagesdir i imagename dev count boot_dev data_dev
	1627	imagesdir=$1
	1628	boot_dev=$2
	1629	data_dev=$3
[925]	1630
[966]	1631	echo -en "Would you like to create boot+data floppy disks now (y/[n]) ?"
[747]	1632	read i
	1633	[ "$i" != "y" ] && [ "$i" != "Y" ] && return
	1634	mount \| grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
	1635	echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
	1636	[ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
	1637	[ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
	1638	i=`find $imagesdir -type f \| grep -F "/mindi-root.1" 2> /dev/null`
[1282]	1639	j=`find $imagesdir -type f \| grep -F "/mindi-boot" \| grep -Ev "2880\|$BOOT_SIZE"`
[747]	1640	if [ "$i" ] ; then
	1641	CopyImageToDisk $j $data_dev "boot disk"
	1642	CopyImageToDisk $i $data_dev "root disk"
	1643	else
	1644	CopyImageToDisk $j $boot_dev "boot/root disk"
	1645	fi
	1646	count=1
	1647	for i in `find $imagesdir \| grep -F mindi-data` ; do
	1648	CopyImageToDisk $i $data_dev "data disk #$count"
	1649	count=$(($count+1))
	1650	done
	1651	}
	1652
	1653
	1654	OfferToMakeBootableISO() {
	1655	local i old_pwd
[1684]	1656	if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[966]	1657	echo -en "Shall I make a bootable CD image? (y/[n]) "
[747]	1658	read i
	1659	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1660	fi
[940]	1661	if [ ! "$MINDI_TMP" ] ; then
[963]	1662	LogIt "NB: Mindi's bootable CD always uses isolinux."
	1663	LogIt "For a bootable CD w/LILO, please use Mondo."
[747]	1664	fi
[940]	1665	rm -Rf $MINDI_TMP/iso
	1666	mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
[963]	1667	cp -f $1/.img $1/.gz $MINDI_TMP/iso/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
[747]	1668	old_pwd=`pwd`
[940]	1669	cd $MINDI_TMP/iso
[747]	1670	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1671	for i in memdisk memtest.bin memtest.img ; do
[953]	1672	j=$MINDI_LIB/$i
	1673	k=$MINDI_TMP/iso/isolinux
	1674	if [ -e "$j" ] ; then
[963]	1675	LogIt "Copying $j to $k"
[953]	1676	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1677	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1678	cp -f $j $MONDO_ROOT 2>> $LOGFILE \|\| Die "Failed to copy $j to $MONDO_ROOT"
	1679	fi
[747]	1680	done
[940]	1681	MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
[1010]	1682	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?"
	1683	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]	1684	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
[1010]	1685	cp $MINDI_TMP/mindi.rdz $MONDO_ROOT/initrd.img 2>> $LOGFILE
[747]	1686	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
[940]	1687	cd $MINDI_TMP/iso/isolinux
	1688	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?"
	1689	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1690	mv isolinux.cfg isolinux.cfg.old
	1691	sed s/interactive/iso/ isolinux.cfg.old > isolinux.cfg
	1692	fi
	1693	if [ "$ARCH" != "ia64" ] ; then
[953]	1694	cp $ISOLINUX isolinux.bin 2> /dev/null \|\| Die "Cannot copy isolinux.bin ($ISOLINUX) to tmp_root - did you run out of disk space?"
[963]	1695	cp $ISOLINUX ../ 2>> $LOGFILE
[747]	1696	fi
[940]	1697	cd $MINDI_TMP/iso
[747]	1698	if [ "$ARCH" != "ia64" ] ; then
[953]	1699	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]	1700	fi
[963]	1701	[ "$MONDO_SHARE" ] && cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
[747]	1702	if [ "$ARCH" != "ia64" ] ; then
[940]	1703	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]	1704	else
[1282]	1705	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]	1706	fi
	1707	if [ "$?" -ne "0" ] ; then
[925]	1708	echo "----------- mkisofs's errors --------------" >> $LOGFILE
[940]	1709	cat $MINDI_TMP/mkisofs.log >> $LOGFILE
[925]	1710	echo "mkisofs returned the following errors:-"
[940]	1711	cat $MINDI_TMP/mkisofs.log
[963]	1712	LogIt "Failed to create ISO image."
[747]	1713	else
[1786]	1714	echo "Created bootable ISO image at $CACHE_LOC/mindi.iso" \| tee -a $LOGFILE
[747]	1715	fi
[940]	1716	rm -f $MINDI_TMP/mkisofs.log
[747]	1717	cd $old_pwd
	1718	}
	1719
	1720
[1684]	1721	OfferToMakeBootableUSB() {
	1722	local i old_pwd
	1723	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[1786]	1724	echo -n "Shall I make a bootable USB image ? (y/[n]) "
[1764]	1725	read i
	1726	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1727	if [ "$USBDEVICE" = "" ]; then
	1728	echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
	1729	read dev
	1730	USBDEVICE=$dev
[1722]	1731	fi
[1764]	1732	echo "WARNING: This will erase all content on $USBDEVICE"
	1733	echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
[1684]	1734	fi
	1735	if [ _"$MINDI_TMP" = _"" ]; then
	1736	Die "MINDI_TMP undefined"
	1737	fi
	1738	rm -Rf $MINDI_TMP/usb
	1739	mkdir -p $MINDI_TMP/usb
	1740	USBPART="${USBDEVICE}1"
	1741
	1742	echo -en "Transforming $USBDEVICE in a Bootable device "
	1743	echo -en "."
	1744	echo "Transforming $USBDEVICE in a Bootable device" >> $LOGFILE
	1745	echo "Checking $USBDEVICE" >> $LOGFILE
	1746	$FDISK -l $USBDEVICE 2>&1 >> $LOGFILE
	1747	if [ $? -ne 0 ]; then
	1748	echo "Unable to access $USBDEVICE" \| tee -a $LOGFILE
	1749	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1750	exit -1
	1751	fi
	1752	echo -en "."
[1691]	1753	echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
[1721]	1754	umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
[1684]	1755	echo "Erasing $USBDEVICE" >> $LOGFILE
[1721]	1756	$FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
[1684]	1757	d
	1758	d
	1759	d
	1760	d
	1761	n
	1762	p
	1763	1
	1764
	1765
	1766	t
	1767	b
	1768	a
	1769	1
	1770	w
	1771	EOF
	1772	if [ $? -ne 0 ]; then
	1773	echo "Unable to create a vfat Filesystem on $USBDEVICE" \| tee -a $LOGFILE
	1774	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1775	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1776	MindiExit -1
	1777	fi
	1778	echo -en "."
	1779	echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
[1688]	1780	mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
[1684]	1781	if [ $? -ne 0 ]; then
	1782	echo "Unable to create a vfat filesystem on $USBPART" \| tee -a $LOGFILE
	1783	echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" \| tee -a $LOGFILE
	1784	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1785	MindiExit -1
	1786	fi
	1787	echo -en "."
	1788	echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
	1789	mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
	1790	if [ $? -ne 0 ]; then
	1791	echo "Unable to mount $USBPART on $MINDI_TMP/usb" \| tee -a $LOGFILE
	1792	echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" \| tee -a $LOGFILE
	1793	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1794	MindiExit -1
	1795	fi
	1796	echo -en "."
[1691]	1797	mkdir -p $MINDI_TMP/usb/images
	1798	cp -f $1/.img $1/.gz $MINDI_TMP/usb/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
[1684]	1799	echo -en "."
	1800	old_pwd=`pwd`
	1801	cd $MINDI_TMP/usb
	1802	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1803	for i in memdisk memtest.bin memtest.img ; do
	1804	j=$MINDI_LIB/$i
	1805	k=$MINDI_TMP/usb
	1806	if [ -e "$j" ] ; then
	1807	LogIt "Copying $j to $k"
	1808	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1809	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1810	fi
	1811	done
	1812	echo -en "."
	1813	MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
	1814	echo -en "."
	1815	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?"
	1816	echo -en "."
	1817	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
	1818	echo -en "."
	1819	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
	1820	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?"
	1821	echo -en "."
	1822	if [ "$NFS_DEV" != "" ] ; then
	1823	perl -pi -e 's/interactive/iso/' syslinux.cfg
	1824	fi
	1825	cd $old_pwd
	1826	echo -en "."
[1721]	1827	umount $MINDI_TMP/usb
[1684]	1828	if [ "$ARCH" != "ia64" ] ; then
	1829	syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
	1830	if [ "$?" -ne "0" ] ; then
	1831	echo "----------- syslinux's errors --------------" \|tee -a $LOGFILE
	1832	cat $MINDI_TMP/syslinux.log \|tee -a $LOGFILE
	1833	LogIt "Failed to create USB image."
	1834	else
	1835	echo -e "$DONE"
	1836	echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
	1837	fi
	1838	rm -f $MINDI_TMP/syslinux.log
	1839	else
	1840	echo "No USB boot support for ia64" \| tee -a $LOGFILE
	1841	MindiExit -1
	1842	fi
	1843	echo -en "."
	1844	}
	1845
	1846
[747]	1847	PluralOrNot() {
	1848	[ "$1" -gt "1" ] && echo -en "s"
	1849	}
	1850
	1851
	1852	MakeMessageFile() {
	1853	local disksize
	1854	disksize=$1
	1855	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1856	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`"/
	1857	else
	1858	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`/
	1859	fi
	1860	if [ "$disksize" -gt "2880" ] ; then
[1335]	1861	if [ _"$MONDO_SHARE" != _"" ] ; then
[925]	1862	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1863	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[925]	1864	echo -en "Press <enter> to continue.\n"
[940]	1865	elif [ ! "$MINDI_TMP" ] ; then
[925]	1866	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
	1867	else
	1868	echo -en "$BOOT_MEDIA_MESSAGE"
	1869	fi
[747]	1870	fi
	1871	fi
	1872	fi
	1873	if [ "$CDRECOVERY" = "yes" ] ; then
	1874	echo -en "\
	1875	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1876	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
	1877	fi
	1878	echo -en "\n\n\n"
	1879	}
	1880
	1881
	1882	write_full_floppy_of_kernel() {
	1883	local mtpt image old_pwd res disksize
	1884
	1885	res=0
	1886	old_pwd=`pwd`
	1887	KERN_DISK_MADE=1
	1888	disksize=$3
	1889	rand1=$RANDOM
	1890	rand2=$RANDOM
[940]	1891	image=$MINDI_TMP/$rand1.$rand2.img
	1892	mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
[963]	1893	dd if=/dev/zero of=$image bs=1k count=$disksize &> /dev/null
[964]	1894	mke2fs -N 26 -F $image &> /dev/null
[747]	1895	mkdir -p $mtpt
	1896	mount -o loop $image $mtpt
	1897	cd $mtpt
	1898	mkdir -p {dev,tmp,boot}
[963]	1899	cp -f $1 vmlinuz 2>> $LOGFILE
[747]	1900	if [ "$?" -ne "0" ] ; then
[963]	1901	LogIt "Failed to copy $1 to ramdisk"
[747]	1902	cd $old_pwd
	1903	umount $mtpt
	1904	rmdir $mtpt
	1905	rm $image
	1906	return 1
	1907	fi
	1908
	1909	rdev vmlinuz 2,0
	1910	rdev -R vmlinuz 0
	1911	rdev -r vmlinuz 49152
	1912
[963]	1913	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[1311]	1914	# BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
[1301]	1915	#losetup /dev/loop0 > /dev/null 2> /dev/null
	1916	#[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1917	CopyBootBFile $mtpt/boot.b
	1918
	1919	MakeLiloConfFile $disksize >> bdlilo.conf
	1920
	1921	chmod 644 bdlilo.conf
	1922	MakeMessageFile $disksize > message
	1923	lilo -v -C bdlilo.conf -r $mtpt
	1924	res=$?
	1925
	1926	cd $old_pwd
	1927	umount $mtpt
	1928	mv -f $image $2
	1929	rmdir $mtpt
	1930
	1931	return $res
	1932	}
	1933
	1934
	1935	MakeLiloConfFile() {
	1936	local disksize options i ooo
	1937	disksize=$1
	1938	options=""
[925]	1939
	1940	if [ "$ARCH" != "ia64" ] ; then
	1941	echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
	1942	fi
	1943	if [ "$disksize" -eq "2880" ] ; then
	1944	echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
	1945	elif [ "$disksize" -eq "1722" ] ; then
	1946	echo -en "bios=0x00\nsectors=21\nheads=2\ncylinders=82\n"
	1947	elif [ "$disksize" -gt "2880" ] ; then
	1948	/bin/true
	1949	else
	1950	echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
	1951	fi
	1952	if [ "$ARCH" != "ia64" ] ; then
	1953	echo -en "install=/boot.b\nmap=/boot.map\n"
	1954	fi
[747]	1955	if [ "$CDRECOVERY" = "yes" ] ; then
	1956	echo -en "default=RESTORE\n"
[1335]	1957	elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ] ; then
[940]	1958	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1959	echo -en "default=iso\n"
	1960	else
	1961	echo -en "default=interactive\n"
	1962	fi
	1963	else
	1964	echo -en "default=expert\n"
	1965	fi
	1966
	1967	echo -en "prompt\n"
	1968	if [ "$ARCH" != "ia64" ] ; then
	1969	echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
	1970	fi
	1971	if [ "$CDRECOVERY" != "yes" ] ; then
[925]	1972	echo -en "timeout=300\n"
[747]	1973	fi
	1974	echo -en "\n"
	1975	if [ "$CDRECOVERY" = "yes" ] ; then
[925]	1976	options="RESTORE expert"
[747]	1977	elif [ "$disksize" -gt "2880" ] ; then
[1335]	1978	if [ _"$MONDO_SHARE" != _"" ] ; then
[940]	1979	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1980	options="iso"
	1981	else
	1982	options="interactive expert compare iso nuke isonuke"
	1983	# hda hdb hdc hdd"
	1984	fi
	1985	else
	1986	options="expert"
[925]	1987	fi
[747]	1988	else
	1989	options="expert"
	1990	fi
	1991	for i in $options ; do
[925]	1992	ooo=$i
	1993	[ "$ooo" = "RESTORE" ] && ooo="nuke"
	1994	if [ "$ARCH" = "ia64" ] ; then
	1995	rootpart="root=/dev/ram0\n\t"
	1996	else
	1997	rootpart=""
	1998	fi
[1230]	1999	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]	2000
[925]	2001	outstr=$outstr" $ooo_mode"
	2002	outstr=$outstr"\"\n"
	2003	if [ "$disksize" = "1440" ] ; then
	2004	echo -en "$outstr" \| sed s/initrd=.*// \| grep -v root=
	2005	else
	2006	echo -en "$outstr"
	2007	fi
[747]	2008	done
	2009	}
	2010
	2011
	2012	PrepareBootDiskImage_LILO() {
	2013	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
	2014	imagesdir=$1
	2015	disksize=$2
	2016	kernelpath=$3
	2017	ramdisksize=$4
	2018
	2019	retval=0
	2020	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	2021	echo -en "Making "$disksize"KB boot disk..."
[940]	2022	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]	2023	if [ "$ARCH" != "ia64" ] ; then
[1282]	2024	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	2025	fi
	2026	echo -en "..."
	2027	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	2028	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	2029	mkdir -p $mountpoint
	2030	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
	2031	if [ "$ARCH" = "ia64" ] ; then
[964]	2032	mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
	2033	t=vfat
[747]	2034	else
[964]	2035	mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
	2036	t=ext2
[747]	2037	fi
[963]	2038	mount -t $t -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[964]	2039	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	2040	mkdir -p $mountpoint/etc
	2041	if [ "$ARCH" != "ia64" ] ; then
	2042	liloconf=$mountpoint/etc/lilo.conf
	2043	else
[925]	2044	liloconf=$mountpoint/elilo.conf
[747]	2045	fi
	2046	old_pwd=`pwd`
	2047	cd $mountpoint
	2048	if [ "$ARCH" != "ia64" ] ; then
[963]	2049	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	2050	fi
	2051	cd $old_pwd
[1311]	2052	# BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
	2053	#losetup /dev/loop0 > /dev/null 2> /dev/null
	2054	#[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	2055	CopyBootBFile $mountpoint/boot.b
	2056
	2057	MakeLiloConfFile $disksize > $liloconf
	2058
[1230]	2059	# Copy it so that CD-ROM menu entry is satisfied
	2060	if [ "$ARCH" = "ia64" ] ; then
	2061	mountefi=0
[1796]	2062	df -T \| grep /boot/efi \| grep -q vfat
[1230]	2063	if [ $? -ne 0 ]; then
	2064	mount /boot/efi
	2065	if [ $? -ne 0 ]; then
	2066	echo "You have to mount your EFI partition when using mindi"
	2067	MindiExit -1
	2068	fi
	2069	mountefi=1
	2070	fi
[1735]	2071	el=`find /boot/efi -name elilo.efi`
	2072	cp $el $mountpoint
[1794]	2073	cp $liloconf $mountpoint
[1230]	2074	if [ $mountefi -eq 1 ]; then
	2075	umount /boot/efi 2>&1 > /dev/null
	2076	fi
	2077	fi
	2078
[940]	2079	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
	2080	cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
[747]	2081	if [ "$?" -ne "0" ] ; then
[963]	2082	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	2083	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	2084	LogIt "Please unload some of your modules and try again."
[940]	2085	rm -f $MINDI_TMP/mtpt.$$
[963]	2086	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	2087	retval=$(($retval+1))
	2088	fi
	2089	MakeMessageFile $disksize > $mountpoint/message
	2090
	2091	mkdir -p $mountpoint/tmp
[940]	2092	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2093	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	2094	echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
	2095	echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
	2096	# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
	2097	fi
	2098
[925]	2099	# copy the kernel across
[1230]	2100	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	2101	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
[1796]	2102	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	2103	cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
	2104	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
[925]	2105	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2106	du -sk $mountpoint/* >> $LOGFILE
	2107	echo "--- end of list of files ---" >> $LOGFILE
	2108	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[747]	2109	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2110	rm -f $mountpoint/vmlinuz
[925]	2111	cd $old_pwd
[747]	2112	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2113	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[925]	2114	# losetup /dev/loop0 -d
	2115	res=0
[747]	2116	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
[925]	2117	res=$(($res+$?))
[963]	2118	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[925]	2119	res=$(($res+$?))
	2120	rm -f $imagefile
	2121	if [ "$res" -ne "0" ]; then
[963]	2122	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[925]	2123	rm -f $imagesdir/mindi-*.1440.img
	2124	fi
	2125	return $res
[747]	2126	fi
[1796]	2127	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	2128	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2129	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2130	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
[1794]	2131	# make it bootable
[747]	2132	rm -f $mountpoint/zero
[963]	2133	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2134	if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
	2135	if [ "$ARCH" != "ia64" ] ; then
[1794]	2136	$LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	2137	else
	2138	/bin/true
	2139	fi
	2140	elif [ ! "$KERN_DISK_MADE" ] ; then
[1794]	2141	# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
[925]	2142	$LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	2143	else
[925]	2144	echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
[747]	2145	fi
[925]	2146
	2147	# BERLIOS does not test necessarily what it expects
[747]	2148	if [ $? -ne "0" ] ; then
[925]	2149	if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
[963]	2150	LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
	2151	LogIt "Please reboot your PC as a workaround."
	2152	Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
[925]	2153	fi
	2154	echo "$LILO_EXE -r $mountpoint ...failed."
	2155	echo -en "Press ENTER to continue."; read line
[963]	2156	LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
[925]	2157	retval=$(($retval+1))
[747]	2158	fi
[963]	2159	cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
[747]	2160	if [ "$ARCH" = "ia64" ] ; then
[963]	2161	cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
[747]	2162	fi
	2163	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2164	echo -en "..."
[963]	2165	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2166	if [ "$retval" -eq "0" ] ; then
	2167	echo -en "...$DONE\r"
	2168	if [ "$KERN_DISK_MADE" ] ; then
	2169	LogIt "... $disksize KB boot disks were created OK\r"
	2170	fi
	2171	else
	2172	echo -en "...failed\r"
	2173	LogIt $disksize"KB boot disk was NOT created\r"
	2174	rm -f $imagefile
	2175	fi
[963]	2176	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2177	return $retval
	2178	}
	2179
	2180
	2181	PrepareBootDiskImage_SYSLINUX() {
	2182	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
	2183	imagesdir=$1
	2184	disksize=$2
	2185	kernelpath=$3
	2186	ramdisksize=$4
	2187	do_boot_root_thingy=""
	2188	local retval old_pwd
	2189	retval=0
[925]	2190
[747]	2191	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	2192	echo -en "Making "$disksize"KB boot disk..."
[940]	2193	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]	2194	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	2195	echo -en "..."
	2196	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	2197	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	2198	mkdir -p $mountpoint
	2199	# If I format a 1722KB data file & run syslinux on it, the resultant image
	2200	# won't boot. So, I have formatted a floppy, called syslinux on/to it, and
	2201	# used 'dd' to copy it to sys-disk.raw (zipped to sys-disk.raw.gz).
	2202	# If I extract it, mount it, copy my files to it, etc. then the resultant
	2203	# image _is_ bootable. I don't know why syslinux and/or mkfs.vfat won't
	2204	# play nicely and I don't care. :) I have worked around the problem. -Hugo, 06/27/2002
	2205	if [ "$disksize" = "1722" ] ; then
	2206	gzip -dc $MINDI_LIB/sys-disk.raw.gz > $imagefile \|\| Die "Cannot dd blank file"
	2207	else
	2208	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
[964]	2209	mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
	2210	syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
[747]	2211	fi
[963]	2212	mount -t vfat -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[925]	2213
	2214	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	2215	old_pwd=`pwd`
	2216	MakeSyslinuxMessageFile $mountpoint/message.txt
	2217	cd $mountpoint
	2218	[ -e "$sys_cfg_file" ] \|\| Die "Obi Wan, word up?"
	2219	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
[940]	2220	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2221	mv syslinux.cfg syslinux.cfg.orig
	2222	sed s/interactive/iso/ syslinux.cfg.orig > syslinux.cfg
	2223	fi
	2224	cd $old_pwd
[940]	2225	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
	2226	cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
[747]	2227	if [ "$?" -ne "0" ] ; then
[963]	2228	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	2229	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	2230	LogIt "Please unload some of your modules and try again."
[940]	2231	rm -f $MINDI_TMP/mtpt.$$
[963]	2232	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	2233	retval=$(($retval+1))
	2234	fi
	2235
	2236	mkdir -p $mountpoint/tmp
[940]	2237	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2238
[925]	2239	# copy the kernel across
[1230]	2240	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	2241	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
[1796]	2242	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	2243	cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
	2244	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
	2245	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2246	du -sk $mountpoint/* >> $LOGFILE
	2247	echo "--- end of list of files ---" >> $LOGFILE
	2248	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
	2249	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2250	rm -f $mountpoint/vmlinuz
	2251	cd $old_pwd
	2252	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2253	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2254
	2255	res=0
	2256	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
	2257	res=$(($res+$?))
[963]	2258	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[747]	2259	res=$(($res+$?))
	2260	rm -f $imagefile
	2261	if [ "$res" -ne "0" ]; then
[963]	2262	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[747]	2263	rm -f $imagesdir/mindi-*.1440.img
	2264	fi
	2265	return $res
	2266	fi
[1796]	2267	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	2268	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2269	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2270	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
[925]	2271
	2272	# make it bootable
[747]	2273	rm -f $mountpoint/zero
	2274	mkdir -p $mountpoint/etc
[963]	2275	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2276	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2277	echo -en "..."
[963]	2278	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2279
	2280	if [ "$retval" -eq "0" ] ; then
	2281	echo -en "...$DONE\r"
	2282	if [ "$KERN_DISK_MADE" ] ; then
	2283	rm -f $imagefile
	2284	LogIt "... $disksize KB boot disks were created OK\r"
	2285	fi
	2286	else
	2287	echo -en "...failed\r"
	2288	LogIt $disksize"KB boot disk was NOT created\r"
	2289	rm -f $imagefile
	2290	fi
[963]	2291	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2292	return $retval
	2293	}
	2294
	2295
	2296	PrepareDataDiskImages() {
	2297	local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines
	2298
	2299	imagesdir=$1
	2300	rm -f $imagesdir/mindi-.img $imagesdir/[0-9].tar.gz $imagesdir/mindi.iso
[940]	2301	needlist=$MINDI_TMP/what-we-need.txt
	2302	bigdir=$MINDI_TMP/bigdir
	2303	minidir_root=$MINDI_TMP/minidir
[747]	2304	mkdir -p $minidir_root
	2305	mkdir -p $bigdir/usr/bin
[940]	2306	tardir=$MINDI_TMP/tardir
[747]	2307
	2308	lines=`grep -vx " #." $MINDI_CONF/deplist.txt \| grep -vx "" \| wc -l`
	2309	cat $MINDI_CONF/deplist.txt \| GenerateGiantDependencyList $needlist $lines
	2310	res=$?
	2311	if [ "$YOUR_KERNEL_SUCKS" ]; then
[925]	2312	pwd=`pwd`
[940]	2313	cd $MINDI_TMP
[747]	2314	for i in `ListKernelModulePaths \| HackPathsToFailsafe` ; do
[963]	2315	cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE \|\| Die "PDDI can't cp $i->$bigdir"
[925]	2316	if [ "`du -sk $i \| cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
[963]	2317	cp --parents -pRdf $i $bigdir 2>> $LOGFILE
[925]	2318	else
	2319	ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
	2320	BIGNO=$(($BIGNO+1))
	2321	fi
[747]	2322	done
[925]	2323	for i in $EXTRA_MODS ; do
[1810]	2324	j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
	2325	[ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
[925]	2326	for k in $j ; do
	2327	if [ "`du -sk $k \| cut -f1`" -lt "$CHOPSIZE" ] ; then
[963]	2328	cp --parents -pRdf $k $bigdir 2>> $LOGFILE
[925]	2329	else
	2330	ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
	2331	BIGNO=$(($BIGNO+1))
	2332	fi
	2333	echo "Added failsafe module $k to ramdisk" >> $LOGFILE
	2334	done
	2335	done
	2336	cd $pwd
[747]	2337	else
[925]	2338	ListKernelModulePaths >> $needlist
[747]	2339	fi
	2340	if [ "$res" -ne "0" ] ; then
	2341	Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
	2342	fi
	2343	FindAndAddUserKeyboardMappingFile
	2344	mkdir -p $bigdir/tmp
[1335]	2345	if [ _"$MONDO_SHARE" != _"" ] ; then
[940]	2346	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	2347	cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
[747]	2348	fi
	2349	[ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
	2350	DropOptimizedLibraries $needlist $bigdir
	2351	echo -en "Assembling dependency files"
	2352	CopyDependenciesToDirectory < $needlist $bigdir
	2353
[925]	2354	# also copy io.sys and msdos.sys, if we can find them
[747]	2355	for i in `mount \| cut -d' ' -f3` ; do
[925]	2356	for j in io.sys msdos.sys ; do
[963]	2357	[ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
[925]	2358	done
[747]	2359	done
	2360
[925]	2361	# master boot record, too
[940]	2362	i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
[747]	2363	if [ "$i" ] ; then
[963]	2364	LogIt "Backing up $i's MBR"
[925]	2365	dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
	2366	sleep 1
	2367	sync
	2368	j=$i
	2369	[ -h "$j" ] && j=`readlink -f $j`
[963]	2370	LogIt "Creating /dev/boot_device ($j)"
[925]	2371	mkdir -p $bigdir/dev
[953]	2372	cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null \|\| Die "Unable to create /dev/boot_device on ramdisk"
[747]	2373	fi
	2374
	2375	old_pwd=`pwd`
	2376	cd $bigdir
	2377
	2378	[ -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]	2379	cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping aux-tools"
[747]	2380	if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
[963]	2381	tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
[747]	2382	fi
[1764]	2383	if [ -e "$MONDO_SHARE/restore-scripts" ]; then
[747]	2384	cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
[1335]	2385	[ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
[747]	2386	fi
[963]	2387	[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
[747]	2388	cd $old_pwd
	2389	echo -e "$DONE"
	2390	TOTAL_BIGDIR_SIZE=`du -sk $bigdir \| cut -f1`
	2391	SplitDirectoryIntoMinidirs $bigdir $minidir_root
	2392	noof_disks=$?
	2393	[ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
	2394	# if [ "$noof_disks" -ge "8" ] ; then
	2395	# LogIt "You are putting a ludicrously large amount of data on these disks."
	2396	# LogIt "I shall therefore double EXTRA_SPACE, just in case your ramdisk is too small."
	2397	# EXTRA_SPACE=$(($EXTRA_SPACE*2))
	2398	# fi
[940]	2399	MakeMountlist $MINDI_TMP/mountlist.txt
[747]	2400	mkdir -p $minidir_root/$noof_disks/tmp
[953]	2401	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]	2402	[ _"$MONDO_SHARE" != _"" ] && cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
[964]	2403	[ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm \|\| LVM="false"
[747]	2404	cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
	2405	ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
	2406	CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
	2407	FRIENDLY_OUTSTRING="Boot and data disk images were created."
[925]	2408	# One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
[747]	2409	rmdir $tardir $bigdir
	2410	rm -f $needlist
	2411	return $noof_disks
	2412	}
	2413
	2414
	2415	ProcessLDD() {
[1784]	2416	local incoming f d nd bd bnd
[747]	2417	read incoming
[1784]	2418	while [ "$incoming" != "" ]; do
[859]	2419	# We take the full path name of the dyn. lib. we want
[1526]	2420	incoming=`echo "$incoming" \| awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
	2421	for f in $incoming ; do
[1784]	2422	# echo modified file name if one of the parent dir is a link
	2423	# by replacing the original dirname by the destination of the link
	2424	d="`dirname $f`"
	2425	found="false"
	2426	while [ "$d" != "/" ]; do
	2427	if [ -h "$d" ]; then
	2428	nd=`readlink -f $d`
	2429	bd=`basename $d`
	2430	bnd=`basename $nd`
	2431	f=`echo $f \| sed "s~/$bd/~/$bnd/~"`
	2432	echo $d
	2433	fi
	2434	d="`dirname $d`"
	2435	done
	2436
[1721]	2437	echo "$f"
	2438	echo "`ReadAllLink $f`"
[747]	2439	done
	2440	read incoming
	2441	done
	2442	}
	2443
	2444
	2445	Prompt() {
	2446	echo -en "$1"
	2447	read line
	2448	}
	2449
	2450
	2451	ReadLine() {
	2452	local i incoming
	2453	read incoming
	2454	i=0
	2455	while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
[925]	2456	i=$(($i+1))
	2457	read incoming
[747]	2458	done
	2459	echo "$incoming"
	2460	}
	2461
	2462
	2463	RejigHyperlinks() {
	2464	local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
	2465	minidir_root=$1
	2466	noof_disks=$2
	2467
	2468	old_pwd=`pwd`
	2469	diskno=1
	2470	while [ "$diskno" -le "$noof_disks" ] ; do
[859]	2471	mkdir -p $minidir_root/$diskno
[747]	2472	cd $minidir_root/$diskno
	2473	for fname in `find -type d -o -print` ; do
	2474	[ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
	2475	done
[925]	2476	diskno=$(($diskno+1))
[747]	2477	done
	2478
	2479	cd $old_pwd
	2480	return
	2481	}
	2482
	2483
	2484	ReplaceIndividualLine() {
	2485	local orig_file new_file lino newstring lines_total lines_remaining
[925]	2486
[747]	2487	orig_file=$1.orig
	2488	mv -f $1 $orig_file \|\| Die "Cannot move $1 to $orig_file"
	2489	new_file=$1
	2490	lino=$2
	2491	newstring="$3"
	2492	if [ "$lino" = "" ] \|\| [ "$lino" -lt "1" ] ; then
[925]	2493	echo "Can't find string" >> $LOGFILE
	2494	return 1
[747]	2495	fi
[963]	2496	lines_total=`wc -l $orig_file \| $AWK '{print $1;}'`
[747]	2497	lines_remaining=$(($lines_total-$lino))
	2498	head -n$(($lino-1)) $orig_file > $new_file
	2499	echo "$newstring" >> $new_file
	2500	echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
	2501	tail -n$lines_remaining $orig_file >> $new_file
	2502	echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
	2503	[ -x "$orig_file" ] && chmod +x $new_file
	2504	rm -f $orig_file
	2505	return 0
	2506	}
	2507
	2508
	2509	ScanCDandTape() {
	2510	local i
	2511
	2512	for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
	2513	dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
	2514	done
	2515	}
	2516
	2517
	2518	SizeOfPartition() {
	2519	local devpath drive res stub
	2520	device=$1
	2521	if [ "`echo "$device" \| grep -F "/dev/md"`" != "" ] ; then
[925]	2522	res=`SizeOfRaidPartition $device`
	2523	[ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
	2524	echo "$res"
	2525	return 0
[747]	2526	fi
[925]	2527	# patch from Bill <bill@iwizard.biz> - 2003/08/25
[960]	2528	res=`$FDISK -s $device 2>> $LOGFILE`
[925]	2529	# end patch
[1796]	2530	[ "$res" = "" ] && res=`df -k -P -x supermount \| tr -s '\t' ' ' \| grep -F "$device " \| cut -d' ' -f2`
[747]	2531	[ "$res" = "" ] && res="-1"
	2532	echo $res
	2533	return 0
	2534	}
	2535
	2536
	2537	SizeOfRaidPartition() {
	2538	local real_dev smallest_size silly tmp
	2539
	2540	silly=999999999
	2541	smallest_size=$silly
	2542
	2543	for real_dev in `GetRaidDevMembers $1` ; do
[925]	2544	tmp=`SizeOfPartition $real_dev`
	2545	[ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
[747]	2546	done
	2547
	2548	if [ "$smallest_size" = "$silly" ] ; then
[925]	2549	echo "-1"
	2550	return 1
[747]	2551	else
[925]	2552	echo "$smallest_size"
	2553	return 0
[747]	2554	fi
	2555	}
	2556
	2557
	2558	StripComments()
	2559	{
	2560	local tempfile
[925]	2561
[940]	2562	tempfile=$MINDI_TMP/$$.strip.txt
[963]	2563	cp -f $1 $tempfile 2>> $LOGFILE
[747]	2564	$AWK '{if (substr($0,0,1)!="#" \|\| substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
	2565	rm -f $tempfile
	2566	echo "Stripped comments from $2" >> $LOGFILE
	2567	}
	2568
	2569
	2570	SplitDirectoryIntoMinidirs() {
	2571	local bigdir minidir_root i noof_disks old_pwd res
[925]	2572
[747]	2573	bigdir=$1
	2574	minidir_root=$2
[1230]	2575	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
[747]	2576
	2577	TryToFitDataIntoSeveralDirs $bigdir $minidir_root
	2578	noof_disks=$?
	2579	if [ "$noof_disks" -eq "0" ] ; then
[925]	2580	echo "Failed to fit data into several dirs."
[747]	2581	return 0
	2582	fi
	2583	RejigHyperlinks $minidir_root $noof_disks
[1230]	2584	[ "$bigdir" != "" ] && rm -Rf $bigdir/*
[925]	2585	return $noof_disks
[747]	2586	}
	2587
	2588
	2589	StripExecutable()
	2590	{
	2591	local tmpfile
[925]	2592
[940]	2593	tmpfile=$MINDI_TMP/stripped.$$.dat
[747]	2594	[ -d "$1" ] \|\| [ -h "$1" ] && return
[963]	2595	cp -f $1 $tmpfile 2>> $LOGFILE
[747]	2596	strip $tmpfile 2> /dev/null
	2597	if [ "$?" -eq "0" ] ; then
[963]	2598	cp -f $tmpfile $1 2>> $LOGFILE
[925]	2599	echo "Stripped binary $2" >> $LOGFILE
[747]	2600	fi
	2601	rm -f $tmpfile
	2602	}
	2603
	2604
	2605	TemporarilyCompressAllFiles() {
	2606	local i orig_fname out_fname out_list
	2607
	2608	i=0
	2609	out_list=$2/compressed/compressed.txt
	2610	mkdir -p $2/compressed
	2611	> $out_list
	2612	for orig_fname in $1 ; do
	2613	out_fname=$2/compressed/$orig_fname.gz
	2614	mkdir -p $out_fname 2> /dev/null
	2615	rmdir $out_fname 2> /dev/null
	2616	gzip -c6 $orig_fname > $out_fname 2> /dev/null
	2617	i=$(((($i+1))%15))
	2618	[ "$i" -eq "0" ] && echo -en "."
	2619	du -sk $out_fname >> $out_list
	2620	done
	2621	}
	2622
	2623
	2624	TryToFindKernelPath() {
	2625	local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
[925]	2626
[747]	2627	we_want_version=`uname -r`
	2628	possible_kernels=""
	2629	duff_kernels=""
	2630
	2631	if [ "$ARCH" = "ia64" ] ; then
	2632	root="/boot/efi/efi"
	2633	else
	2634	root="/"
	2635	fi
[1466]	2636	for fname in `find $root -maxdepth 2 -type f \| grep -E 'lin\|kern' \| grep -Ev '^/proc/\|^/net/'` ; do
[925]	2637	[ ! -e "$fname" ] && continue
[747]	2638	[ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
[925]	2639	file $fname \| grep -q gzip
	2640	if [ "$?" -eq "0" ] ; then
	2641	# Used by ia64
[747]	2642	fkern_ver=`gzip -cd $fname \| strings 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2643	else
[747]	2644	fkern_ver=`strings $fname 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2645	fi
[747]	2646	[ "$fkern_ver" = "" ] && continue
	2647	[ "`echo "$fkern_ver" \|grep -F "$we_want_version "`" = "" ] && continue
[925]	2648	[ -f "$fname" ] \|\| continue
	2649	[ -h "$fname" ] && continue
	2650	kdate=`uname -v \| $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' \| $AWK '{print $NF;}'`
	2651	file $fname \| grep -q gzip
	2652	if [ "$?" -eq "0" ] ; then
	2653	# Used by ia64
	2654	if [ "`gzip -cd $fname \| strings 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2655	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
[925]	2656	duff_kernels="$fname $duff_kernels"
	2657	else
[747]	2658	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2659	possible_kernels="$fname $possible_kernels"
[925]	2660	fi
[747]	2661	else
[925]	2662	if [ "`strings $fname 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2663	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
[925]	2664	duff_kernels="$fname $duff_kernels"
	2665	else
[747]	2666	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2667	possible_kernels="$fname $possible_kernels"
[925]	2668	fi
[747]	2669	fi
	2670	done
	2671	if [ ! "$possible_kernels" ] && uname -a \| grep Knoppix > /dev/null ; then
[925]	2672	possible_kernels=`find /boot/vmlinuz-2.* \| tail -n1`
[747]	2673	fi
	2674	if [ ! "$possible_kernels" ] ; then
[963]	2675	LogIt "No kernel matches exactly. Are there any duff kernels?"
[747]	2676	possible_kernels="$duff_kernels"
	2677	if [ ! "$possible_kernels" ] ; then
[963]	2678	LogIt "Sorry, no duff kernels either"
[747]	2679	else
[963]	2680	LogIt "I bet you're running Debian or Gentoo, aren't you?"
	2681	LogIt "Your kernel doesn't have a sane builddate. Oh well..."
[747]	2682	fi
	2683	fi
	2684	possible_kernels=`echo "$possible_kernels" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '`
	2685	noof_kernels=`CountItemsIn "$possible_kernels"`
	2686	if [ "$noof_kernels" -eq "0" ] ; then
[963]	2687	LogIt "Could not find your kernel."
[925]	2688	if [ -e "/boot/vmlinuz" ] ; then
[963]	2689	LogIt "Using /boot/vmlinuz as a last resort."
[925]	2690	output=/boot/vmlinuz
[747]	2691	else
[925]	2692	output=""
	2693	fi
[747]	2694	elif [ "$noof_kernels" -eq "1" ] ; then
	2695	kernelpath=`echo "$possible_kernels" \| sed s/' '//`
	2696	echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
	2697	output="$kernelpath"
	2698	else
	2699	for i in $possible_kernels ; do
	2700	if echo $i \| grep "`uname -r`" ; then
[925]	2701	LogIt "OK, I used my initiative and found that "
[963]	2702	LogIt "$i is probably your kernel. "
[925]	2703	output="$i"
	2704	return
	2705	fi
[747]	2706	done
[925]	2707	if echo " $possible_kernels " \| grep -F "/boot/vmlinuz " &> /dev/null ; then
	2708	output=/boot/vmlinuz
	2709	echo "Schlomo, this one's for you." >> $LOGFILE
	2710	else
[963]	2711	LogIt "Two or more possible kernels found. You may specify any one of them and the "
	2712	LogIt "boot disks will still work, probably. If one does not work, try another."
	2713	LogIt "$possible_kernels"
[747]	2714	echo ""
[925]	2715	fi
[747]	2716	fi
	2717	echo "$output" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '
	2718	}
	2719
	2720
	2721	TryToFitDataIntoSeveralDirs() {
	2722	local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
	2723	local i retval noof_disks total_files list_of_devs
[925]	2724
[747]	2725	bigdir=$1
	2726	minidir_root=$2
	2727	BIG_CLUNKY_SIZE_COUNTER=0
	2728	retval=0
	2729	noof_disks=1
	2730
	2731	echo -en "\r \rDividing data into several groups..."
	2732	old_pwd=`pwd`
	2733	cd $bigdir
	2734	list_of_files=`GetFileSizeList . \| sort -nr \| cut -f2 \| grep -Fv "/dev/"`
	2735	progress=0
	2736	total_files=`CountItemsIn "$list_of_files"`
	2737	if [ "`echo "$filename" \| grep -x "/dev/.*"`" ] ; then
	2738	filesize=1
	2739	fi
	2740	mkdir -p $minidir_root/$noof_disks
	2741	if [ -e "dev" ] ; then
	2742	echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
[963]	2743	cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
[747]	2744	fi
	2745	TemporarilyCompressAllFiles "$list_of_files" $minidir_root
	2746	for filename in $list_of_files ; do
	2747	AddFileToDir $filename $minidir_root $noof_disks
[925]	2748	i=$?
	2749	if [ "$i" -gt "$noof_disks" ] ; then
	2750	noof_disks=$i
	2751	echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
	2752	fi
	2753	if [ "$i" -eq "0" ] ; then
[963]	2754	LogIt "Cannot add file $filename to minidir $minidir_root"
[925]	2755	retval=$(($retval+1))
	2756	fi
[747]	2757	progress=$(($progress+1))
[925]	2758	echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
[747]	2759	done
	2760	cd $old_pwd
	2761	echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
[1230]	2762	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
[747]	2763	if [ "$retval" -gt "0" ] ; then
[925]	2764	return 0
[747]	2765	else
[925]	2766	return $noof_disks
[747]	2767	fi
	2768	}
	2769
	2770
	2771	TurnTgzIntoRdz() {
	2772	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]	2773
[747]	2774	tgz_dir_fname=$1
	2775	rdz_fname=$2
	2776	ramdisksize=$3
	2777	disksize=$4
	2778	kernelsize=$5
	2779	maxsize=$(($disksize-$kernelsize))
	2780	maxsize=$(($maxsize*2)); # to allow for compression of 50%
[940]	2781	tempfile=$MINDI_TMP/temp.rd
	2782	mountpoint=$MINDI_TMP/mnt1
[747]	2783	res=0
	2784	echo -en "..."
	2785	dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null \|\| Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
	2786	echo -en "..."
[1764]	2787	echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
	2788	mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE \|\| Die "Unable to create an ext2 file system on $tempfile"
[747]	2789	echo -en "..."
	2790	mkdir -p $mountpoint
	2791	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."
	2792	echo -en "..."
	2793	old_pwd=`pwd`
	2794	cd $mountpoint
[959]	2795	cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
[747]	2796	tar -zxf symlinks.tgz \|\| Die "Cannot untar symlinks.tgz"
	2797	cd dev \|\| Die "Can't cd to dev"
	2798	tar -zxf dev-entries.tgz \|\| Die "Cannot untar dev-entries.tgz"
	2799	rm -f dev-entries.tgz
	2800	cd ..
	2801
	2802	for w in insmod.static insmod.static.old ; do
[925]	2803	s=`which $w 2> /dev/null`
	2804	if [ -e "$s" ] ; then
[963]	2805	cp --parents -af $s . 2>> $LOGFILE
[925]	2806	fi
[747]	2807	done
	2808
	2809	mkdir -p tmp
	2810	[ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
[1724]	2811
[1786]	2812	# Handle the case where busybox is dynamically linked
	2813	# Should be done first so that if /lib64 is a link, it's
	2814	# created first like that, instead of as a real dir later on
	2815	file $MINDI_LIB/rootfs/bin/busybox 2>&1 \| grep -q "dynamically"
	2816	if [ $? -eq 0 ]; then
	2817	LocateDeps $MINDI_LIB/rootfs/bin/busybox > $MINDI_TMP/busy.lis
	2818	cp --parents -Rdf `sort -u $MINDI_TMP/busy.lis` .
	2819	rm -f $MINDI_TMP/busy.lis
	2820	fi
	2821
[1724]	2822	# Management of udev (which includes modprobe in rules)
[1759]	2823	ps auxww \| grep -v grep \| grep -qw udevd
[1716]	2824	if [ $? -eq 0 ]; then
	2825	echo "udev device manager found" > tmp/USE-UDEV
[1759]	2826	LogIt "udev device manager found"
[1716]	2827	cp --parents -Rdf /etc/udev . 2> /dev/null
[1790]	2828	# This avoids NIC remapping if on another machine at restore time on Debian at least
	2829	rm -f ./etc/udev/rules.d/z25_persistent-net.rules
[1718]	2830	cp --parents -Rdf /lib/udev /lib64/udev . 2> /dev/null
[1720]	2831	if [ -x /sbin/udevd ]; then
[1781]	2832	lis2=`grep -Ev '^#' $MINDI_CONF/udev.files`
	2833	lis=""
	2834	# Get only the files which exist in that list
[1815]	2835	# and potentially their symlink structure
[1781]	2836	for i in $lis2; do
[1815]	2837	if [ -h $i ]; then
	2838	j=$i
	2839	while [ -h $j ]; do
	2840	lis="$lis $j"
	2841	j=`readlink $j`
	2842	done
	2843	lis="$lis $j"
	2844	elif [ -f $i ]; then
[1781]	2845	lis="$lis $i"
	2846	fi
	2847	done
	2848	# And their deps
[1759]	2849	LocateDeps $lis > $MINDI_TMP/udev.lis
	2850	for i in $lis; do
	2851	if [ "`echo $i \| cut -c1`" = "/" ]; then
	2852	j=`echo $i \| cut -c2-`
	2853	rm -f $j
	2854	fi
	2855	done
	2856	cp --parents -Rdf $lis `sort -u $MINDI_TMP/udev.lis` .
[1721]	2857	rm -f $MINDI_TMP/udev.lis
[1720]	2858	else
	2859	echo "udevd daemon not in standard place (/sbin)" 2>&1 \| tee -a $LOGFILE
[1724]	2860	echo "mindi will use static devices which may cause problems" 2>&1 \| tee -a $LOGFILE
[1720]	2861	rm -f tmp/USE-UDEV
	2862	fi
[1716]	2863	fi
[1786]	2864
[1761]	2865	# Management of potential HW info (Proliant only at the moment)
[1819]	2866	rm -rf $CACHE_LOC/bkphw
[1761]	2867	mindi-bkphw $CACHE_LOC $MINDI_CONF \| tee -a $LOGFILE
	2868	if [ -d $CACHE_LOC/bkphw ]; then
	2869	LogIt "Hardware Information found and saved ..."
	2870	cp -rp $CACHE_LOC/bkphw .
	2871	lis=`grep -Ev '^#' $CACHE_LOC/tools.files`
	2872	LocateDeps $lis > $MINDI_TMP/tools.lis
	2873	cp --parents -Rdf $lis `sort -u $MINDI_TMP/tools.lis` .
	2874	if [ -f $CACHE_LOC/mindi-rsthw ]; then
	2875	mv -f $CACHE_LOC/mindi-rsthw .
	2876	chmod 755 ./mindi-rsthw
	2877	fi
	2878	rm -f $MINDI_TMP/tools.lis $CACHE_LOC/tools.files
	2879	fi
	2880
[747]	2881	for w in cdrom floppy groovy-stuff ; do
	2882	mkdir -p mnt/$w
	2883	done
[925]	2884	#if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
	2885	#ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
	2886	#fi
[747]	2887	if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
[925]	2888	ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
[747]	2889	fi
	2890
	2891	cp --parents -Rdf /dev/fd0[1,2][4,7,8] . 2> /dev/null
[1721]	2892
[747]	2893	cd $old_pwd
	2894	echo -en "..."
	2895	MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
	2896	echo -en "..."
	2897	old_pwd=`pwd`
	2898	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	2899	cd $MINDI_TMP
[747]	2900	floppy_modules_path=lib/modules/$FAILSAFE_KVER
	2901	else
	2902	cd /
	2903	###
	2904	### Sq-Modification... Use kernel name in module path if specified.
	2905	###
	2906	#floppy_modules_path=lib/modules/`uname -r`
	2907	if [ "${kernelname}" != "" ]
	2908	then
	2909	floppy_modules_path=lib/modules/${kernelname}
	2910	else
	2911	floppy_modules_path=lib/modules/`uname -r`
	2912	fi
	2913	###
	2914	### Sq-Modification end
	2915	###
	2916	fi
	2917	floppy_modules=""
	2918	if [ "$disksize" -lt "2880" ] ; then
[1354]	2919	list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
[747]	2920	else
[1354]	2921	list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
[747]	2922	fi
[940]	2923	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2924	# For PXE boot
	2925	list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
	2926	fi
[1715]	2927	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
	2928	list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
	2929	fi
[1727]	2930	for i in $DENY_MODS; do
	2931	echo "Removing $i from the list of modules to load" >> $LOGFILE
	2932	list_of_groovy_mods=`echo ${list_of_groovy_mods} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
	2933	done
	2934
[963]	2935	[ -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]	2936	for i in $list_of_groovy_mods ; do
	2937	floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
	2938	done
	2939	for i in $floppy_modules ; do
	2940	[ -e "$i" ] && s=`du -sk $i \| cut -f1` \|\| s=""
[940]	2941	[ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
[747]	2942	echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
[1727]	2943	cp --parents -pdf $i $mountpoint 2>/dev/null \|\| LogIt "Unable to copy $i to $mountpoint"
[1815]	2944	# Uncompress modules if not useing udev and native modprobe
	2945	if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
	2946	if [ "`echo "$i" \| grep -F ".gz"`" ]; then
[1727]	2947	gunzip -f $mountpoint/$i
[1815]	2948	#i=`echo $i \| sed 's/.gz//'`
	2949	fi
[1727]	2950	fi
[747]	2951	done
[1815]	2952
	2953	# Also copy modules.dep in case of udev so that normal modprobe works
	2954	cp --parents -pdf /$floppy_modules_path/modules.dep $mountpoint 2>/dev/null \|\| LogIt "Unable to copy modules.dep to $mountpoint"
	2955
[1798]	2956	# For all modules supported, create symlinks under the mountpoint
[1827]	2957	for i in $EXTRA_MODS $NET_MODS $SCSI_MODS; do
	2958	all_modules="$all_modules `FindSpecificModuleInPath $mountpoint $i \| sed 's~^$mountpoint/~~g'`"
	2959	done
[1798]	2960	for i in $all_modules; do
	2961	(cd $mountpoint ; ln -s $i . 2>/dev/null)
	2962	done
[747]	2963	if [ ! -e "/sbin/devfsd" ] \|\| [ "$disksize" -lt "2880" ] \|\| [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
	2964	echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
	2965	[ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
	2966	[ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
	2967	[ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
	2968	rm -f $mountpoint/sbin/devfsd
	2969	fi
	2970	cd $old_pwd
	2971	[ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
	2972	dd if=/dev/zero of=$mountpoint/zero &> /dev/null
	2973	rm -f $mountpoint/zero
[1335]	2974	if [ _"$MONDO_SHARE" != _"" ] ; then
[747]	2975	MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
[940]	2976	cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
[953]	2977	cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null \|\| Die "Cannot copy mountlist to ramdisk"
[747]	2978	echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
	2979	echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
	2980	[ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
[998]	2981	[ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
[747]	2982	[ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
	2983	[ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
	2984	fi
	2985	mkdir -p $mountpoint/tmp
	2986	mkdir -p $mountpoint/proc
	2987	echo "$disksize" > $mountpoint/tmp/$disksize.siz
	2988	find $mountpoint -name CVS -exec rm -rf '{}' \;
[1230]	2989	# Determine what filesystem to use for initrd image
	2990	echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
	2991	gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
	2992	[ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
	2993	case "$gvFileSystem" in
	2994	"ext2fs")
	2995	# say what will be used
[1821]	2996	echo "Creating an ext2 initrd image..." >> $LOGFILE
[1230]	2997	# kernel expects linuxrc in ext2 filesystem
	2998	( cd $mountpoint && ln -sf sbin/init linuxrc )
	2999	# unmount loop filesystem and create image file using the standard approach
	3000	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
[1764]	3001	dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
[1794]	3002	bs=`tune2fs -l ${rdz_fname}.tmp \| grep -E '^Block size:' \| cut -d: -f2 \| sed 's/^ *//'`
[1764]	3003	ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
[1799]	3004	gzip -c9 ${rdz_fname}.tmp > $rdz_fname
[1764]	3005	rm -f ${rdz_fname}.tmp
[1230]	3006	# log that we are done
[1821]	3007	echo "...done." >> $LOGFILE
[1230]	3008	;;
	3009	"initramfs")
	3010	# say what will be used
[1821]	3011	echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
[1230]	3012	# make sure that cpio is there
	3013	which cpio &> /dev/null; [ $? -eq 0 ] \|\| Die "cpio not found. Please install package cpio and try again."
	3014	# go into filesystem
	3015	cd $mountpoint
	3016	# kernel expects init in cpio filesystem
	3017	ln -sf sbin/init init
	3018	# create cpio image file and unmount loop filesystem
	3019	find . -print \| cpio -o -H newc \| gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
	3020	cd $old_pwd
	3021	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	3022	# log that we are done
	3023	echo "...done." >> $LOGFILE
	3024	;;
	3025	*)
	3026	Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
	3027	;;
	3028	esac
[747]	3029	if [ "$res" -eq "0" ] ; then
	3030	echo -en "..."
	3031	else
	3032	echo -en "\rMade an rdz WITH ERRORS. \n"
	3033	fi
	3034	return 0
	3035	}
	3036
	3037
	3038	WhichOfTheseModulesAreLoaded() {
	3039	local modname loaded_modules
[1399]	3040	loaded_modules="$MODULES"
[747]	3041	for modname in $1 ; do
[1506]	3042	[ "`echo "$loaded_modules" \| grep -w "$modname"`" ] && echo "$modname"
[747]	3043	done
	3044	}
	3045
	3046
	3047	ZipMinidirsIntoTarballs() {
	3048	local minidir_root tardir noof_disks diskno old_pwd i
	3049	minidir_root=$1
	3050	tardir=$2
	3051	noof_disks=$3
	3052
	3053	echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
	3054	mkdir -p $tardir
	3055	mkdir -p $minidir_root/all
	3056	old_pwd=`pwd`
	3057	diskno=1
	3058	while [ "$diskno" -le "$noof_disks" ] ; do
[963]	3059	cd $minidir_root/$diskno \|\| LogIt "WARNING - cannot cd to $minidir_root/$diskno"
[747]	3060	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."
	3061	diskno=$(($diskno+1))
	3062	echo -n "..."
[963]	3063	cp -pRdf * $minidir_root/all 2>> $LOGFILE
[747]	3064	done
	3065	mkdir -p $minidir_root/all/tmp
	3066	cd $minidir_root/all
	3067	size_of_all_tools=`du -sk . \| cut -f1`
[1684]	3068	if [ _"$MONDO_SHARE" != _"" ]; then
[747]	3069	for q in filelist.full.gz biggielist.txt ; do
[940]	3070	[ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
[963]	3071	cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
[747]	3072	done
	3073	mkdir -p $minidir_root/all/tmp
	3074	echo -en "$FILES_IN_FILELIST" > $minidir_root/all/tmp/FILES-IN-FILELIST 2> /dev/null
	3075	echo -en "$LAST_FILELIST_NUMBER" > $minidir_root/all/tmp/LAST-FILELIST-NUMBER 2> /dev/null
	3076	fi
	3077	tar -b 4096 -cf - * 2> /dev/null \| gzip -9 > $tardir/all.tar.gz
	3078	dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
	3079	[ "`du -sm $imagesdir/all.tar.gz \| cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
	3080	cd $old_pwd
[1230]	3081	[ "$minidir_root" != "" ] && rm -Rf $minidir_root
[747]	3082	echo -e "$DONE"
	3083	}
	3084
	3085
	3086	##############################################################################
[1021]	3087	#----------------------------------- Main -----------------------------------#
[747]	3088	##############################################################################
	3089
	3090
	3091	> $LOGFILE
	3092	echo "mindi v$MINDI_VERSION" >> $LOGFILE
	3093	echo "$ARCH architecture detected" >> $LOGFILE
	3094	echo "mindi called with the following arguments:" >> $LOGFILE
	3095	echo "$@" >> $LOGFILE
[800]	3096	echo "Start date : `date`" >> $LOGFILE
[1684]	3097	echo "-----------------------------" >> $LOGFILE
[747]	3098
	3099	if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
[963]	3100	LogIt "WARNING - Ancient distro detected." 1
[747]	3101	ln -sf /etc/conf.modules /etc/modules.conf
	3102	fi
	3103	[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
	3104
[1010]	3105	# Log some capital variables
	3106	[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
	3107	echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
	3108	echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
	3109	[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
	3110	echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
	3111	echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
	3112
[747]	3113	trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
[1010]	3114
	3115	# Sanity checks
	3116	which which > /dev/null 2> /dev/null \|\| Die "Please install 'which'."
	3117	which strings > /dev/null 2> /dev/null \|\| Die "Please install binutils and libbinutils; you have no 'strings' executable."
	3118	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."
	3119	which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` \|\| AWK="`which awk 2>/dev/null`"
	3120	if which awk &> /dev/null ; then
	3121	if ! which gawk &> /dev/null ; then
	3122	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"
	3123	fi
	3124	fi
	3125	which mke2fs > /dev/null 2> /dev/null \|\| Die "Please put mke2fs in system path"
	3126	[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
	3127
[747]	3128	[ "`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"
	3129	# If we have a 2.6 kernel, the system uses module-init-tools which means that we
	3130	# may have the modprobe configuration spread out across multiple files in
	3131	# directory /etc/modprobe.d. If this is the case we concatenate these files into
	3132	# a temporary file for further processing. Otherwise we continue in the standard
	3133	# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
	3134	# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
	3135	# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
[1684]	3136	if [ -d "/etc/modprobe.d" ] && [ "`uname -r \| cut -c1-3`" = "2.6" ] ; then
[925]	3137	TMPMODPROBE_FLAG="Y"
[747]	3138	else
[925]	3139	TMPMODPROBE_FLAG="N"
	3140	[ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
	3141	[ ! -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]	3142	fi
[1010]	3143
	3144	# Update the PATH variable if incomplete
	3145	if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
	3146	PATH=$PATH:/sbin:/usr/sbin
	3147	export PATH
	3148	echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
	3149	echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
	3150	echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
	3151	fi
	3152
[747]	3153	[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null \| grep -E "2\.[46]" \| cut -d' ' -f1`
[1010]	3154
[1737]	3155	if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
[1010]	3156	Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
	3157	fi
	3158
[925]	3159	### BERLIOS
[747]	3160	### Fix as it's not mandatory on ia64
	3161	if [ "$ARCH" = "ia64" ] ; then
[1010]	3162	if which elilo &> /dev/null ; then
	3163	LILO_EXE=elilo
	3164	else
	3165	LILO_EXE=`which false`
	3166	fi
[747]	3167	else
	3168	FindIsolinuxBinary
	3169	FindLiloBinary
	3170	fi
[925]	3171	# BERLIOS: Remove as too dangerous and now useless
[940]	3172	#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]	3173	trap "Aborted" SIGTERM
	3174	DONE="\r\t\t\t\t\t\t\t\tDone. "
	3175	CHOPSIZE=240
	3176	BIGNO=0
	3177	MAX_COMPRESSED_SIZE=1300
	3178	kernelpath=""
[1010]	3179	MONDO_ROOT=/var/cache/mondo
[747]	3180	mkdir -p $MONDO_ROOT
	3181
	3182	if [ -d "/proc/lvm" ]; then
	3183	# LVM v1
	3184	LVMCMD=""
	3185	LVM="v1"
	3186	elif [ -d "/dev/mapper" ]; then
	3187	# LVM v2
	3188	LVMCMD="lvm"
	3189	LVM="v2"
	3190	else
	3191	LVM="false"
	3192	fi
[1021]	3193	echo "LVM set to $LVM" >> $LOGFILE
	3194	echo "----------" >> $LOGFILE
[1230]	3195	echo "mount result:" >> $LOGFILE
	3196	echo "-------------" >> $LOGFILE
	3197	mount >> $LOGFILE
	3198	echo "-------------" >> $LOGFILE
[1315]	3199	if [ -e /etc/raidtab ]; then
	3200	echo "-------------" >> $LOGFILE
	3201	echo "/etc/raidtab content:" >> $LOGFILE
	3202	echo "-------------" >> $LOGFILE
	3203	cat /etc/raidtab >> $LOGFILE
	3204	fi
	3205	echo "-------------" >> $LOGFILE
[1418]	3206	echo "cat /proc/cmdline:" >> $LOGFILE
	3207	echo "-------------" >> $LOGFILE
	3208	cat /proc/cmdline >> $LOGFILE
	3209	echo "-------------" >> $LOGFILE
[1021]	3210	echo "lsmod result:" >> $LOGFILE
	3211	echo "-------------" >> $LOGFILE
	3212	lsmod >> $LOGFILE
[1399]	3213	MODULES="`cat /proc/modules \| awk '{print $1}'`"
[1531]	3214	if [ -x /usr/sbin/esxcfg-module ]; then
[1797]	3215	echo "-------------" >> $LOGFILE
[1497]	3216	echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
	3217	echo "-------------" >> $LOGFILE
	3218	echo "VMWare modules" >> $LOGFILE
	3219	echo "-------------" >> $LOGFILE
[1531]	3220	/usr/sbin/esxcfg-module -l >> $LOGFILE
[1764]	3221	MODULES="$MODULES `/usr/sbin/esxcfg-module -l \| awk '{print $1}'`"
[1497]	3222	fi
[1021]	3223	echo "-------------" >> $LOGFILE
[1796]	3224	echo "df result:" >> $LOGFILE
[1785]	3225	echo "----------" >> $LOGFILE
[1796]	3226	df -T >> $LOGFILE
[1785]	3227	echo "-------------" >> $LOGFILE
[1230]	3228	echo "Liste of extra modules is:" >> $LOGFILE
	3229	echo "$EXTRA_MODS" >> $LOGFILE
	3230	echo "-------------" >> $LOGFILE
[747]	3231
[1723]	3232	# Compute libata version
[1797]	3233	laver=`modinfo libata \| grep -Ei '^Version:' \| cut -d: -f2 \| cut -d. -f1 \| sed 's/ *//g' 2> /dev/null`
[1723]	3234	# If libata v2 is used then remove ide-generic as it will perturbate boot
[1726]	3235	if [ "`echo $MODULES \| grep libata`" ]; then
[1727]	3236	if [ "$laver" = "2" ]; then
[1726]	3237	DENY_MODS="$DENY_MODS ide-generic"
[1727]	3238	echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
[1726]	3239	echo "-------------" >> $LOGFILE
	3240	fi
[1723]	3241	fi
	3242
[747]	3243	if [ "$#" -ge "2" ] ; then
	3244	if [ "$1" = "--max-compressed-size" ] ; then
	3245	MAX_COMPRESSED_SIZE=$2
	3246	shift; shift
	3247	fi
	3248	fi
	3249
	3250	FLOPPY_WAS_MOUNTED=""
	3251	for mtpt in /media/floppy /mnt/floppy /floppy ; do
	3252	if mount \| grep -w $mtpt &> /dev/null ; then
	3253	FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
	3254	umount $mtpt
	3255	fi
	3256	done
	3257
[1684]	3258	#
	3259	# If we have a USB device we need to store info
	3260	# and remove it from the parameters line
	3261	#
[747]	3262	if [ "$#" -ne "0" ] ; then
[1684]	3263	if [ "$1" = "--usb" ] ; then
	3264	shift
	3265	USBDEVICE=$1
	3266	if [ _"$USBDEVICE" = _"" ]; then
	3267	Die "No USB device specified"
	3268	fi
	3269	shift
	3270	fi
	3271	fi
	3272
	3273	if [ "$#" -ne "0" ] ; then
[747]	3274	if [ "$1" = "--findkernel" ] ; then
	3275	res=`TryToFindKernelPath`
[1336]	3276	# Avoids logfile content for mondo
	3277	export MONDO_SHARE=""
[747]	3278	if [ "$res" = "" ] ; then
[925]	3279	MindiExit -1
[747]	3280	else
	3281	echo "$res"
[925]	3282	MindiExit 0
[747]	3283	fi
[1720]	3284	elif [ "$1" = "--locatedeps" ] ; then
	3285	[ ! "$2" ] && Die "Please specify the binary to look at"
	3286	LocateDeps $2
	3287	# Avoids logfile content for mondo
	3288	export MONDO_SHARE=""
	3289	MindiExit $?
[1815]	3290	elif [ "$1" = "--readalllink" ] ; then
	3291	[ ! "$2" ] && Die "Please specify the binary to look at"
	3292	ReadAllLink $2
	3293	# Avoids logfile content for mondo
	3294	export MONDO_SHARE=""
	3295	MindiExit $?
[747]	3296	elif [ "$1" = "--makemountlist" ] ; then
	3297	[ ! "$2" ] && Die "Please specify the output file"
	3298	MakeMountlist $2
[1336]	3299	# Avoids logfile content for mondo
	3300	export MONDO_SHARE=""
[925]	3301	MindiExit $?
	3302	elif [ "$1" = "-V" ] \|\| [ "$1" = "-v" ] \|\| [ "$1" = "--version" ] \|\| [ "$1" = "-version" ] ; then
	3303	echo "Mindi v$MINDI_VERSION"
[1336]	3304	# Avoids logfile content for mondo
	3305	export MONDO_SHARE=""
[925]	3306	MindiExit 0
[747]	3307	elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
[940]	3308	MONDO_TMP=$2
	3309	# Change MINDI_TMP for the one provided by mondo
	3310	# So that it can get back the built files
[1010]	3311	mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
	3312	rmdir $MINDI_TMP
[1486]	3313	export MINDI_TMP=$MONDO_TMP
[953]	3314	mkdir -p $MINDI_TMP
[1696]	3315	# This is the scratch dir in mondo - subdir images
[938]	3316	CACHE_LOC=$3
	3317	if [ _"$CACHE_LOC" != _"" ]; then
	3318	mkdir -p $CACHE_LOC
	3319	fi
[925]	3320	kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
[747]	3321	###
	3322	### Sq-Modification...
	3323	### Attempt to locate kernel specific module path
	3324	### if module path is found then use it other wise use uname -r to set it...
	3325	###
	3326	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
[963]	3327	LogIt "kernelname = $kernelname"
	3328	LogIt "kernelpath = $kernelpath"
[747]	3329	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	3330	then
[963]	3331	LogIt "Module path for ${kernelpath} not found..."
	3332	LogIt "using running kernel\'s modules."
[747]	3333	kernelname=`uname -r`
	3334	else
[963]	3335	LogIt "Using modules for kernel: ${kernelname}"
[747]	3336	fi
	3337	###
	3338	### end of Sq-Modification
	3339	###
[925]	3340	TAPEDEV=$5
	3341	TAPESIZE=$6
	3342	FILES_IN_FILELIST=$7
	3343	USE_LZO=$8
	3344	CDRECOVERY=$9
[747]	3345	if [ "${10}" = "(null)" ] \|\| [ "${10}" = "" ] ; then
	3346	IMAGE_DEVS=""
	3347	else
	3348	IMAGE_DEVS="`echo "${10}" \| tr '\|' ' '`"
	3349	fi
[925]	3350	if [ "${11}" ] ; then
	3351	LILO_OPTIONS=""
	3352	# LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
	3353	fi
	3354	LAST_FILELIST_NUMBER=${12}
[747]	3355	ESTIMATED_TOTAL_NOOF_SLICES=${13}
	3356	EXCLUDE_DEVS="${14}"
	3357	USE_COMP="${15}"
	3358	USE_LILO="${16}"
[925]	3359	USE_STAR="${17}"
	3360	INTERNAL_TAPE_BLOCK_SIZE="${18}"
[747]	3361	DIFFERENTIAL="${19}"
[998]	3362	USE_GZIP="${20}"
	3363	NOT_BOOT="${21}"
[747]	3364	[ "$USE_COMP" = "" ] && USE_COMP=yes
[998]	3365	[ "$USE_GZIP" = "" ] && USE_GZIP=no
[747]	3366	[ "$NOT_BOOT" = "" ] && NOT_BOOT=no
[963]	3367	[ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
[925]	3368	[ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
[747]	3369	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
	3370	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	3371	then
[963]	3372	LogIt "Module path for ${kernelpath} not found..."
	3373	LogIt "using running kernel\'s modules."
[747]	3374	kernelname=`uname -r`
	3375	else
[963]	3376	LogIt "Using modules for kernel: ${kernelname}"
[747]	3377	fi
[925]	3378	[ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
[1696]	3379	# MONDO_ROOT is the real scratchdir
[925]	3380	MONDO_ROOT=`echo $CACHE_LOC \| sed 's/\(.\)\/./\1/'`
[938]	3381	if [ _"$MONDO_ROOT" != _"" ]; then
	3382	mkdir -p $MONDO_ROOT
	3383	else
	3384	Die "MONDO_ROOT is undefined"
	3385	fi
[747]	3386	else
[925]	3387	echo "Syntax: mindi (--custom ....)" >> /dev/stderr
	3388	MindiExit -1
[747]	3389	fi
	3390	fi
	3391	#ScanCDandTape
	3392	[ "$CDRECOVERY" = "yes" ] \|\| CDRECOVERY=no
	3393	if [ "$CDRECOVERY" = "yes" ] ; then
	3394	iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
	3395	sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
	3396	else
	3397	iso_cfg_file=$MINDI_LIB/isolinux.cfg
	3398	sys_cfg_file=$MINDI_LIB/syslinux.cfg
	3399	fi
	3400
	3401	[ -e "$iso_cfg_file" ] \|\| Die "Cannot find $iso_cfg_file"
[1684]	3402	if [ _"$MONDO_SHARE" = _"" ]; then
[963]	3403	LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
	3404	LogIt "Latest Mindi is available from http://www.mondorescue.org"
	3405	LogIt "BusyBox sources are available from http://www.busybox.net"
[747]	3406	LogIt "------------------------------------------------------------------------------"
	3407	else
[1315]	3408	echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
[747]	3409	fi
[1005]	3410	if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
	3411	LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 \| head -1`"
	3412	else
	3413	LogIt "Unable to find mindi-busybox, please install it"
	3414	MindiExit -1
	3415	fi
[747]	3416
	3417	# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
	3418	insmod /lib/modules/`uname -r`///misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
	3419	for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
	3420	insmod $i >> $LOGFILE 2>> $LOGFILE
	3421	done
	3422
	3423	KERN_DISK_MADE=""
	3424
	3425	echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
	3426	echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
	3427	echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
	3428	if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
[963]	3429	LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
[940]	3430	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	3431	MakeMountlist $MINDI_TMP/mountlist.txt
	3432	mkdir -p $MINDI_TMP/small-all/tmp
	3433	cd $MINDI_TMP/small-all
[953]	3434	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]	3435	tar -cv tmp \| gzip -9 > $MINDI_TMP/all.tar.gz \|\| Die "Cannot make small all.tar.gz"
[747]	3436	sleep 2
[963]	3437	LogIt "Done. Exiting."
[925]	3438	MindiExit 0
[747]	3439	fi
	3440
[1690]	3441	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1684]	3442	LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
	3443	fi
	3444
[747]	3445	if [ "$kernelpath" = "" ] ; then
[1335]	3446	[ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
[966]	3447	echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
	3448	read ch
	3449	if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
	3450	USE_OWN_KERNEL="yes"
[1809]	3451	else
	3452	USE_OWN_KERNEL="no"
[747]	3453	fi
	3454	if [ "$USE_OWN_KERNEL" = "yes" ]; then
[925]	3455	YOUR_KERNEL_SUCKS=""
	3456	kernelpath=`TryToFindKernelPath`
	3457	if [ "$kernelpath" = "" ] ; then
	3458	echo -n "Please enter kernel path : "
	3459	read kernelpath
	3460	fi
[747]	3461	else
[925]	3462	YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
[747]	3463	fi
	3464	fi
[1575]	3465	if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
[966]	3466	echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
[747]	3467	read ch
[966]	3468	if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
	3469	USE_LILO=no
	3470	else
[747]	3471	USE_LILO=yes
	3472	fi
	3473	fi
	3474	if [ "$YOUR_KERNEL_SUCKS" != "" ] \|\| [ "$kernelpath" = "" ] \|\| [ "$kernelpath" = "SUCKS" ] \|\| [ "$kernelpath" = "FAILSAFE" ] ; then
	3475	kernelpath=$MINDI_LIB/vmlinuz
[963]	3476	LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
	3477	LogIt "However, you are still running your kernel. If Mindi fails to create your"
	3478	LogIt "disks then it may still be a result of a problem with your kernel."
[747]	3479	pwd=`pwd`
[940]	3480	cd $MINDI_TMP
[747]	3481	bzip2 -dc $MINDI_LIB/lib.tar.bz2 \| tar -x \|\| Die "Cannot unzip lib.tar.bz2"
	3482	cd $pwd
	3483	YOUR_KERNEL_SUCKS="Your kernel sucks"
	3484	fi
[940]	3485	echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
[963]	3486	[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
[747]	3487
[965]	3488	[ "$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]	3489
[925]	3490	PrepareDataDiskImages $CACHE_LOC
[747]	3491	noof_disks=$?
	3492	ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
	3493	rds=$(($ramdisk_size-$((ramdisk_size%4096))))
	3494	ramdisk_size=$rds
	3495
	3496	echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
[1567]	3497	if [ "$ARCH" = "ia64" ] ; then
	3498	PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create ia64 floppy disk image."
	3499	else
	3500	if [ "$USE_LILO" = "yes" ] ; then
[925]	3501	if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
[964]	3502	LogIt "WARNING - failed to create 1.72MB boot image."
	3503	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
[747]	3504	fi
[925]	3505	if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
[963]	3506	LogIt "WARNING - failed to create 2.88MB floppy disk image."
[964]	3507	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[1282]	3508	PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create 2.88MB floppy disk image."
[747]	3509	fi
[1567]	3510	else
	3511	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
	3512	LogIt "WARNING - failed to create 1.72MB boot image."
	3513	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
	3514	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
	3515	LogIt "WARNING - failed to create 2.88MB floppy disk image."
	3516	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[1815]	3517	PrepareBootDiskImage_SYSLINUX $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create $BOOT_SIZE kB floppy disk image."
[1567]	3518	fi
[747]	3519	fi
	3520	fi
	3521	fi
	3522
	3523	[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
	3524	...Or type 'memtest' to test your PC's RAM thoroughly.\n"
	3525
[1684]	3526	if [ _"$MONDO_SHARE" = _"" ]; then
[925]	3527	ListImagesForUser $CACHE_LOC
[747]	3528	boot_dev=/dev/fd0u1722
	3529	[ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
	3530	[ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
	3531	[ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
	3532	if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
[925]	3533	OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
[747]	3534	fi
[1684]	3535	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
	3536	OfferToMakeBootableUSB $CACHE_LOC
	3537	fi
[925]	3538	OfferToMakeBootableISO $CACHE_LOC
[963]	3539	LogIt "Finished."
[747]	3540	elif [ "$TAPEDEV" ] ; then
[925]	3541	OfferToMakeBootableISO $CACHE_LOC
	3542	if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
[963]	3543	cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
[747]	3544	else
[925]	3545	Die "Cannot find all.tar.gz, to be written to tape"
[747]	3546	fi
[1695]	3547	elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1684]	3548	OfferToMakeBootableUSB $CACHE_LOC
[747]	3549	else
[925]	3550	OfferToMakeBootableISO $CACHE_LOC
[747]	3551	fi
	3552	# cleanup
[963]	3553	LogIt "$FRIENDLY_OUTSTRING"
[747]	3554	for mtpt in $FLOPPY_WAS_MOUNTED ; do
	3555	mount $mtpt
	3556	done
[925]	3557	MindiExit 0

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

Download in other formats: