Context Navigation

source: MondoRescue/branches/2.2.6/mindi/mindi@ 1950

Visit:

Last change on this file since 1950 was 1950, checked in by Bruno Cornec, 16 years ago
Do not propose to use ILLO in mindi standalone Remove temporary .img files at the end of mindi Push the iso image on the tape the right way
Property svn:keywords set to `Rev Id`
File size: 108.7 KB

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

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

Download in other formats: