Context Navigation

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

Visit:

Last change on this file since 1929 was 1929, checked in by Bruno Cornec, 16 years ago
Fix a problem in case of initramfs type of boot file in the path of the file generated
Property svn:keywords set to `Rev Id`
File size: 109.0 KB

Rev	Line
[747]	1	#!/bin/bash
	2
	3	# $Id: mindi 1929 2008-04-20 23:02:10Z 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"
[1667]	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"
[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
[747]	1033	}
	1034
	1035
	1036	MakeMountlist() {
	1037	local scratchdir mountlist all_partitions current_partition \
	1038	partition_size partition_format outstring partition_number \
	1039	partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
	1040	absolute_partition old_partition_fmt current_lvolume
	1041
[967]	1042	echo "Your raw fstab file looks like this:" >> $LOGFILE
	1043	echo "------------------------------------" >> $LOGFILE
[747]	1044	cat $MY_FSTAB >> $LOGFILE
[967]	1045	echo "Your mountlist will look like this:" \| tee -a $LOGFILE
	1046	echo "-----------------------------------" >> $LOGFILE
[747]	1047
	1048	# scratchdir, mountlist(OUT)
[940]	1049	scratchdir=$MINDI_TMP
[747]	1050	mountlist=$1
	1051
	1052	# NB: partition = device
	1053	# NB: mountpt = where the device is mounted
	1054
	1055	[ -e "$MY_FSTAB" ] \|\| Die "Cannot find your fstab file ($MY_FSTAB)"
	1056
[1684]	1057	[ "$mountlist" != "" ] && rm -Rf $mountlist
[747]	1058	> $mountlist
	1059	all_partitions=""
	1060
	1061	if [ $LVM != "false" ]; then
[1885]	1062	echo -en "Analyzing LVM...\n"
[968]	1063	$MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
[971]	1064	if [ $? -ne 0 ]; then
[963]	1065	LVM="false"
	1066	fi
[968]	1067	all_partitions=`cat $MINDI_TMP/lvm.res \| grep -F ">>>" \| cut -d' ' -f2-32`
[747]	1068	fi
	1069	all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
	1070	# echo "all partitions = $all_partitions" > /dev/stderr
	1071	for i in $IMAGE_DEVS ; do
	1072	mount \| grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
	1073	done
	1074	[ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" \| tr ' ' '\n' \| sort -u \| tr '\n ' ' '`"
[1755]	1075	printf " %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID \| tee -a $LOGFILE
[747]	1076	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"
	1077	for c_p in $all_partitions ; do
	1078	[ "`echo "$useless_dev" \| grep -F "$c_p"`" != "" ] \|\| [ "`echo "$c_p" \| grep ":"`" != "" ] && continue
	1079	[ "`echo "$c_p" \| grep -x "/dev/cdroms.*"`" ] && continue
	1080	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]	1081	current_partition=`readlink -f $c_p`
[747]	1082	[ "`echo "$current_partition" \| grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
	1083	[ "`echo "$useless_dev" \| grep -F "$current_partition"`" ] && continue
	1084	else
	1085	current_partition="$c_p"
	1086	fi
	1087	[ "$c_p" = "none" ] && continue
	1088	redhat_label=""
[1831]	1089	label=""
[957]	1090	uuid=""
[861]	1091	absolute_partition=`readlink -f $c_p`
[747]	1092	partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $2}' \| head -n1`
	1093
	1094	# Detects noauto partitions not mounted and exclude them
	1095	partition_option=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $4}' \| head -n1`
	1096	if [ "`echo "$partition_option" \| grep -i noauto`" != "" ] && [ "`mount \| grep -w "$partition_mountpt"`" = "" ] ; then
	1097	continue
	1098	fi
	1099
	1100	# This part tries to retrieve the correct device from a LABEL line in /etc/fstab
	1101	# current_partition contains only first column of /etc/fstab
	1102	if [ "`echo "$current_partition" \| /bin/grep -i "LABEL="`" != "" ]; then
	1103	str_to_find_fmt_with=$current_partition
[980]	1104	redhat_label=`echo "$current_partition" \| cut -d'=' -f2`
[747]	1105	actual_dev=""
[853]	1106
	1107	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1108	if [ -x "/sbin/findfs" ]; then
[855]	1109	actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
[853]	1110	fi
[747]	1111
[853]	1112	# 2nd try : blkid, the good way for all LABEL except swap
	1113	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1114	actual_dev=`/sbin/blkid \| /bin/grep "$redhat_label" \| grep LABEL= \| cut -d':' -f1`
[747]	1115	# For LVM FS it will give a /dev/dm-# which should then be converted
[748]	1116	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1117	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1118	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[747]	1119	for dev in `ls /dev/mapper/*`; do
[963]	1120	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1121	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[747]	1122	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1123	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[747]	1124	break
	1125	fi
	1126	done
	1127	fi
	1128	fi
	1129
[853]	1130	# 3rd try, which works on a standard partition (ext2/3), but not on swap
[747]	1131	# For LVM gives a /dev/mapper entry
	1132	if [ "x$actual_dev" = "x" ]; then
[980]	1133	actual_dev=`/bin/mount -l \| /bin/grep "\[$redhat_label\]" \| cut -d' ' -f1`
[747]	1134	fi
	1135
[853]	1136	# 4th try, with vol_id
[747]	1137	# SWAP only
	1138	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1139	list_swaps=`cat /proc/swaps \| /bin/grep "/dev/" \| $AWK '{ print $1 }' `
[747]	1140	for dev_swap in $list_swaps ; do
	1141	dev_exists=`/sbin/vol_id $dev_swap \| /bin/grep "$redhat_label"`
	1142	if [ "x$dev_exists" != "x" ]; then
	1143	actual_dev=$dev_swap
	1144	break;
	1145	fi
	1146	done
	1147	fi
	1148
[853]	1149	# 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
[789]	1150	# LABEL=SW-cciss/c0d0p3 (RDP)
[853]	1151	# or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
[747]	1152	# SWAP only
[789]	1153	if [ "x$actual_dev" = "x" -a _"`echo $current_partition \| /bin/grep -iE 'LABEL=SWAP\|LABEL=SW-'`" != _"" ]; then
[853]	1154	for try_dev in `tail +2 /proc/swaps \| cut -d' ' -f1`
	1155	do
	1156	# Location of the swap label for kernel 2.6
[1009]	1157	try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
[853]	1158	if [ "x$try_dev_label" = "x$redhat_label" ]; then
[855]	1159	actual_dev=$try_dev
[853]	1160	fi
	1161	done
[747]	1162	fi
[1008]	1163
	1164	# Check if one of all those tries has known success
	1165	if [ "x$actual_dev" != "x" ]; then
	1166	current_partition=$actual_dev
	1167	else
[1885]	1168	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]	1169	fi
[957]	1170	# This part tries to retrieve the correct device from a UUID line in /etc/fstab
	1171	# current_partition contains only first column of /etc/fstab
[1009]	1172	elif [ "`echo "$current_partition" \| /bin/grep -i "UUID="`" != "" ]; then
[957]	1173	str_to_find_fmt_with=$current_partition
[980]	1174	uuid=`echo "$current_partition" \| cut -d'=' -f2`
[957]	1175	actual_dev=""
	1176
	1177	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1178	if [ -x "/sbin/findfs" ]; then
	1179	actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
	1180	fi
	1181
[1531]	1182	# 2nd try : blkid, the good way for all UUID except swap
[957]	1183	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1184	actual_dev=`/sbin/blkid \| /bin/grep "$uuid" \| grep UUID= \| cut -d':' -f1`
[957]	1185	# For LVM FS it will give a /dev/dm-# which should then be converted
	1186	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1187	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1188	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[957]	1189	for dev in `ls /dev/mapper/*`; do
[963]	1190	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1191	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[957]	1192	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1193	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[957]	1194	break
	1195	fi
	1196	done
	1197	fi
	1198	fi
	1199
	1200	# 3th try, with vol_id
	1201	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1202	list_dev=`mount \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
[957]	1203	for dev in $list_dev ; do
	1204	dev_exists=`/sbin/vol_id $dev \| /bin/grep "$uuid"`
	1205	if [ "x$dev_exists" != "x" ]; then
	1206	actual_dev=$dev
	1207	break;
	1208	fi
	1209	done
	1210	fi
	1211
[1531]	1212	# 4th try, with dumpuuid (VMWare only ?) for swap
	1213	if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
	1214	list_dev=`cat /proc/swaps \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
	1215	for dev in $list_dev ; do
	1216	dev_exists=`/sbin/dumpuuid $dev \| /bin/grep "$uuid"`
	1217	if [ "x$dev_exists" != "x" ]; then
	1218	actual_dev=$dev
	1219	break;
	1220	fi
	1221	done
	1222	fi
	1223
[747]	1224	# Check if one of all those tries has known success
	1225	if [ "x$actual_dev" != "x" ]; then
	1226	current_partition=$actual_dev
	1227	else
[1315]	1228	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]	1229	fi
	1230	else
[1863]	1231	# Needs to handle the recent OpenSUSE fancy way of dealing with fstab :-(
	1232	# they use symlinks in fstab unrelated to what is shown in mount !
	1233	if [ _"$partition_mountpt" = _"" ]; then
	1234	for tmpp in `tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -Ev "^#" \| $AWK '{print $1}'`; do
[1864]	1235	if [ _"`readlink -f $tmpp`" = _"$current_partition" ]; then
[1863]	1236	str_to_find_fmt_with=$tmpp
[1865]	1237	partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$tmpp" \| /bin/grep -vx " #." \| $AWK '{print $2}' \| head -n1`
[1864]	1238	break;
[1863]	1239	fi
	1240	done
	1241	else
	1242	str_to_find_fmt_with=$current_partition
	1243	fi
[747]	1244	fi
	1245
	1246	partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
	1247	# Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
	1248	# for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
	1249	# the former is then a link to the latter, so we test whether
	1250	# $current_partition is actually such a link or not and set
[755]	1251	# $current_lvolume accordingly. On Debian you may find more than one answer
	1252	# so we remove the one corresponding to /dev/.static
	1253	# On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
	1254	# principle is the same and we need to find the link to it as well.
	1255	# Note that $current_lvolume may well be an
[747]	1256	# ordinary device. It is just to make sure that we feed the right value
	1257	# into any of the LVM tools if possible.
	1258
	1259	current_lvolume="$current_partition"
[763]	1260	if [ $LVM = "v2" ] && [ "`echo $current_partition \| grep -E '^/dev/mapper/'`" ]; then
[755]	1261	# .static dir are a Debian specificity
[763]	1262	current_lvolume="`find /dev -lname "$current_partition" \| grep -Ev '^/dev/\.static/'`"
[755]	1263	echo $current_lvolume \| grep -q ' '
[784]	1264	if [ $? -eq 0 ]; then
[755]	1265	echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE
	1266	fi
[747]	1267	fi
	1268	#
	1269	# End of LVM device style variation code (other than $current_lvolume).
	1270
[745]	1271	if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
	1272	# Size computed via LVM not directly
[747]	1273	partition_size="lvm"
	1274	else
	1275	partition_size=`SizeOfPartition $current_partition`
	1276	[ "`echo "$current_partition" \| grep "[0-9]"`" = "" ] && continue
	1277	[ "`echo "$current_partition" \| grep -c "^/"`" -ne "1" ] && continue
	1278	if [ "$partition_format" = "swap" ] \|\| [ "$partition_mountpt" = "swap" ] ; then
	1279	partition_size=`grep -Fv "Priority" /proc/swaps \| tr -s '\t' ' ' \| grep -F "$current_partition" \| $AWK '{print $3}'`
	1280	[ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
	1281	[ "$partition_format" != "swap" ] && partition_format="swap"
	1282	if [ "$partition_size" = "" ] ; then
	1283	totalsize=0
	1284	items=0
	1285	for i in `tr -s ' ' '\t' < /proc/swaps \| grep -Fv "Filename" \| cut -f3` ; do
	1286	totalsize=$(($totalsize+$i))
	1287	items=$(($items+1))
	1288	done
	1289	[ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) \|\| partition_size=0
	1290	[ "$partition_size" -lt "125000" ] && partition_size=125000
	1291	echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
	1292	fi
	1293	fi
	1294	fi
	1295	[ "$partition_mountpt" = "swap" ] && partition_format="swap"
	1296	[ "$partition_format" = "swap" ] && partition_mountpt="swap"
	1297	if [ "$partition_mountpt" = "" ] ; then
	1298	if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
	1299	if [ "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
	1300	partition_mountpt="raid"
	1301	partition_format="raid"
	1302	else
	1303	partition_mountpt="lvm"
	1304	partition_format="lvm"
	1305	fi
	1306	fi
	1307	fi
	1308	psz=$partition_size
	1309	echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
	1310	[ "$psz" != "lvm" ] && psz=$(($psz/1024))
	1311	if [ "`echo " $IMAGE_DEVS " \| grep -F " $current_partition "`" != "" ] ; then
	1312	partition_mountpt="image"
	1313	old_partition_fmt=$partition_format
	1314	partition_format="`$FDISK -l 2>> $LOGFILE \| tr '*' ' ' \| tr '+' ' ' \| tr -s ' ' '\t' \| grep -w "$absolute_partition" \| cut -f5`"
	1315	partition_size=$(($partition_size+1)); # just in case
	1316	if [ "$partition_format" = "Linux" ] ; then
	1317	echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
	1318	echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
	1319	partition_format=$old_partition_fmt
	1320	fi
	1321	fi
	1322	if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " \| grep -F " $current_partition "`" ] \|\| [ "`echo " $EXCLUDE_DEVS " \| grep " $current_partition "`" ] ; then
	1323	echo "Excluding $current_partition from mountlist" >> $LOGFILE
	1324	continue
	1325	fi
	1326	if [ ! "$partition_mountpt" ] ; then
[965]	1327	echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
[1883]	1328	for qq in "" `find /dev/ida/cd ! -name 'p' 2> /dev/null`; do
[747]	1329	partition_format=`$FDISK -l $qq 2>> $LOGFILE \| grep -w "$c_p" \| sed 's/12/\|/' \| tr -s '\t' ' ' \| cut -d'\|' -f2 \| cut -d' ' -f2-9`
	1330	[ "$partition_format" ] && break
	1331	done
[965]	1332	echo "------- $FDISK log end ------------" >> $LOGFILE
[747]	1333	if [ "$partition_format" = "Compaq diagnostics" ] ; then
	1334	partition_format="compaq"
	1335	elif [ ! "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
[963]	1336	LogIt "Unable to find mountpoint of $current_partition - ignoring"
[747]	1337	continue
	1338	fi
	1339	fi
[1755]	1340	if [ "$redhat_label" ]; then
	1341	label="$redhat_label"
[1756]	1342	elif [ "$uuid" ]; then
[1755]	1343	label="$uuid"
	1344	fi
[747]	1345	partition_format="`echo "$partition_format" \| cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
[963]	1346	[ "$partition_format" = "auto" ] && partition_format="`mount \| grep -w $current_partition \| $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
[1755]	1347	unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
[747]	1348	if [ "$current_partition" = "" ] ; then
	1349	echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
	1350	elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
	1351	if [ "`grep -F device /etc/raidtab 2>/dev/null \| grep -F $current_partition`" ] ; then
	1352	partition_mountpt=raid
	1353	partition_format=raid
[1755]	1354	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1355	printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1356	else
	1357	echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
	1358	fi
	1359	elif [ "$partition_format" = "" ] ; then
	1360	echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
	1361	elif [ "$partition_size" = "" ] ; then
	1362	echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
	1363	elif [ "$partition_mountpt" = "/proc" ] \|\| [ "$partition_mountpt" = "/dev/pts" ] ; then
	1364	continue
	1365	else
	1366	if [ "$partition_format" = "dos" ] \|\| [ "$partition_format" = "msdos" ] ; then
	1367	echo "Stupid bastard..." >> $LOGFILE
	1368	partition_format="vfat"
	1369	fi
[1755]	1370	printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" \| tee -a $LOGFILE
	1371	printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
[747]	1372	fi
	1373	done
	1374	}
	1375
	1376
	1377	MakeSureNumberIsInteger() {
	1378	res=`echo "$1" \| tr -s '\-[0-9]' ' '`
	1379	if [ "$res" != " " ] && [ "$res" != "" ] ; then
	1380	echo "result = '$res'"
	1381	Die "$1 should be an integer"
	1382	fi
	1383	}
	1384
	1385
	1386	MakeSyslinuxMessageFile() {
	1387	mkdir -p $1
	1388	rmdir $1
	1389	echo -en " " > $1
	1390	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1391	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
	1392	else
	1393	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
	1394	fi
	1395	sed s/%r/"`uname -r`"/ $1.tmp \| sed s/%t/"`hostname`"/ > $1
	1396	rm -f $1.tmp
	1397	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1398	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1399	echo -en "Press <enter> to continue.\n" >> $1
[940]	1400	elif [ ! "$MINDI_TMP" ] ; then
[747]	1401	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
	1402	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1403	echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
	1404	fi
	1405	else
	1406	echo -en "$BOOT_MEDIA_MESSAGE" >> $1
	1407	fi
	1408	else
	1409	echo -en " \
	1410	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1411	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
	1412	fi
	1413	}
	1414
	1415
	1416	OfferToMakeBootableISO() {
	1417	local i old_pwd
[1684]	1418	if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[966]	1419	echo -en "Shall I make a bootable CD image? (y/[n]) "
[747]	1420	read i
	1421	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1422	fi
[1885]	1423	if [ _"$MINDI_TMP" = _"" ]; then
	1424	Die "MINDI_TMP undefined"
[747]	1425	fi
[940]	1426	rm -Rf $MINDI_TMP/iso
	1427	mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
[963]	1428	cp -f $1/.img $1/.gz $MINDI_TMP/iso/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
[747]	1429	old_pwd=`pwd`
[940]	1430	cd $MINDI_TMP/iso
[747]	1431	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1432	for i in memdisk memtest.bin memtest.img ; do
[953]	1433	j=$MINDI_LIB/$i
	1434	k=$MINDI_TMP/iso/isolinux
	1435	if [ -e "$j" ] ; then
[963]	1436	LogIt "Copying $j to $k"
[953]	1437	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1438	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
[1885]	1439	if [ _"$MONDO_SHARE" != _"" ]; then
	1440	cp -f $j $MONDO_ROOT 2>> $LOGFILE \|\| Die "Failed to copy $j to $MONDO_ROOT"
	1441	fi
[953]	1442	fi
[747]	1443	done
[940]	1444	MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
[1885]	1445	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]	1446	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]	1447	if [ _"$MONDO_SHARE" != _"" ]; then
[1929]	1448	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?"
	1449	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]	1450	fi
[747]	1451	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
[940]	1452	cd $MINDI_TMP/iso/isolinux
[1885]	1453	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]	1454	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[1885]	1455	perl -pi -e 's/interactive/iso/' isolinux.cfg
[747]	1456	fi
	1457	if [ "$ARCH" != "ia64" ] ; then
[1885]	1458	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]	1459	cp $ISOLINUX ../ 2>> $LOGFILE
[747]	1460	fi
[940]	1461	cd $MINDI_TMP/iso
[747]	1462	if [ "$ARCH" != "ia64" ] ; then
[1885]	1463	if [ _"$MONDO_SHARE" != _"" ]; then
	1464	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?"
	1465	cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
	1466	fi
	1467	$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]	1468	else
[1885]	1469	$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
[747]	1470	fi
	1471	if [ "$?" -ne "0" ] ; then
[1885]	1472	echo "----------- $ISO_CMD's errors --------------" >> $LOGFILE
[940]	1473	cat $MINDI_TMP/mkisofs.log >> $LOGFILE
[1885]	1474	echo "$ISO_CMD returned the following errors:-"
[940]	1475	cat $MINDI_TMP/mkisofs.log
[963]	1476	LogIt "Failed to create ISO image."
[747]	1477	else
[1880]	1478	echo "Created bootable ISO image at $MINDI_CACHE/mindi.iso" \| tee -a $LOGFILE
[747]	1479	fi
[940]	1480	rm -f $MINDI_TMP/mkisofs.log
[747]	1481	cd $old_pwd
	1482	}
	1483
	1484
[1684]	1485	OfferToMakeBootableUSB() {
	1486	local i old_pwd
	1487	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
[1786]	1488	echo -n "Shall I make a bootable USB image ? (y/[n]) "
[1764]	1489	read i
	1490	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1491	if [ "$USBDEVICE" = "" ]; then
	1492	echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
	1493	read dev
	1494	USBDEVICE=$dev
[1722]	1495	fi
[1764]	1496	echo "WARNING: This will erase all content on $USBDEVICE"
	1497	echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
[1684]	1498	fi
	1499	if [ _"$MINDI_TMP" = _"" ]; then
	1500	Die "MINDI_TMP undefined"
	1501	fi
	1502	rm -Rf $MINDI_TMP/usb
	1503	mkdir -p $MINDI_TMP/usb
	1504	USBPART="${USBDEVICE}1"
	1505
	1506	echo -en "Transforming $USBDEVICE in a Bootable device "
	1507	echo -en "."
	1508	echo "Transforming $USBDEVICE in a Bootable device" >> $LOGFILE
	1509	echo "Checking $USBDEVICE" >> $LOGFILE
[1857]	1510	$FDISK -l $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE
[1684]	1511	if [ $? -ne 0 ]; then
	1512	echo "Unable to access $USBDEVICE" \| tee -a $LOGFILE
	1513	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1514	exit -1
	1515	fi
	1516	echo -en "."
[1691]	1517	echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
[1721]	1518	umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
[1684]	1519	echo "Erasing $USBDEVICE" >> $LOGFILE
[1721]	1520	$FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
[1684]	1521	d
	1522	d
	1523	d
	1524	d
	1525	n
	1526	p
	1527	1
	1528
	1529
	1530	t
	1531	b
	1532	a
	1533	1
	1534	w
	1535	EOF
	1536	if [ $? -ne 0 ]; then
	1537	echo "Unable to create a vfat Filesystem on $USBDEVICE" \| tee -a $LOGFILE
	1538	echo "Make sure your USB device is pluged in" \| tee -a $LOGFILE
	1539	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1540	MindiExit -1
	1541	fi
	1542	echo -en "."
	1543	echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
[1688]	1544	mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
[1684]	1545	if [ $? -ne 0 ]; then
	1546	echo "Unable to create a vfat filesystem on $USBPART" \| tee -a $LOGFILE
	1547	echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" \| tee -a $LOGFILE
	1548	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1549	MindiExit -1
	1550	fi
	1551	echo -en "."
	1552	echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
	1553	mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
	1554	if [ $? -ne 0 ]; then
	1555	echo "Unable to mount $USBPART on $MINDI_TMP/usb" \| tee -a $LOGFILE
	1556	echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" \| tee -a $LOGFILE
	1557	$FDISK -l $USBDEVICE 2>&1 \| tee -a $LOGFILE
	1558	MindiExit -1
	1559	fi
	1560	echo -en "."
[1691]	1561	mkdir -p $MINDI_TMP/usb/images
	1562	cp -f $1/.img $1/.gz $MINDI_TMP/usb/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
[1684]	1563	echo -en "."
	1564	old_pwd=`pwd`
	1565	cd $MINDI_TMP/usb
	1566	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1567	for i in memdisk memtest.bin memtest.img ; do
	1568	j=$MINDI_LIB/$i
	1569	k=$MINDI_TMP/usb
	1570	if [ -e "$j" ] ; then
	1571	LogIt "Copying $j to $k"
	1572	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1573	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1574	fi
	1575	done
	1576	echo -en "."
	1577	MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
	1578	echo -en "."
	1579	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?"
	1580	echo -en "."
	1581	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
	1582	echo -en "."
	1583	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
	1584	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?"
	1585	echo -en "."
	1586	if [ "$NFS_DEV" != "" ] ; then
	1587	perl -pi -e 's/interactive/iso/' syslinux.cfg
	1588	fi
	1589	cd $old_pwd
	1590	echo -en "."
[1721]	1591	umount $MINDI_TMP/usb
[1684]	1592	if [ "$ARCH" != "ia64" ] ; then
	1593	syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
	1594	if [ "$?" -ne "0" ] ; then
	1595	echo "----------- syslinux's errors --------------" \|tee -a $LOGFILE
	1596	cat $MINDI_TMP/syslinux.log \|tee -a $LOGFILE
	1597	LogIt "Failed to create USB image."
	1598	else
	1599	echo -e "$DONE"
	1600	echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
	1601	fi
	1602	rm -f $MINDI_TMP/syslinux.log
	1603	else
	1604	echo "No USB boot support for ia64" \| tee -a $LOGFILE
	1605	MindiExit -1
	1606	fi
	1607	echo -en "."
	1608	}
	1609
	1610
[747]	1611	MakeMessageFile() {
	1612	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1613	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`"/
	1614	else
	1615	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`/
	1616	fi
[1885]	1617	if [ _"$MONDO_SHARE" != _"" ]; then
	1618	if [ "$CDRECOVERY" != "yes" ] ; then
	1619	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
	1620	echo -en "Press <enter> to continue.\n"
	1621	elif [ ! "$MINDI_TMP" ] ; then
	1622	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
	1623	else
	1624	echo -en "$BOOT_MEDIA_MESSAGE"
[747]	1625	fi
	1626	fi
	1627	fi
	1628	if [ "$CDRECOVERY" = "yes" ] ; then
	1629	echo -en "\
	1630	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1631	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
	1632	fi
	1633	echo -en "\n\n\n"
	1634	}
	1635
	1636
	1637	MakeLiloConfFile() {
[1885]	1638	local options i ooo
[747]	1639	options=""
[925]	1640
	1641	if [ "$ARCH" != "ia64" ] ; then
	1642	echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
	1643	echo -en "install=/boot.b\nmap=/boot.map\n"
	1644	fi
[747]	1645	if [ "$CDRECOVERY" = "yes" ] ; then
	1646	echo -en "default=RESTORE\n"
[1885]	1647	elif [ _"$MONDO_SHARE" != _"" ]; then
[940]	1648	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1649	echo -en "default=iso\n"
	1650	else
	1651	echo -en "default=interactive\n"
	1652	fi
	1653	else
	1654	echo -en "default=expert\n"
	1655	fi
	1656
	1657	echo -en "prompt\n"
	1658	if [ "$ARCH" != "ia64" ] ; then
	1659	echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
	1660	fi
	1661	if [ "$CDRECOVERY" != "yes" ] ; then
[925]	1662	echo -en "timeout=300\n"
[747]	1663	fi
	1664	echo -en "\n"
	1665	if [ "$CDRECOVERY" = "yes" ] ; then
[925]	1666	options="RESTORE expert"
[1885]	1667	else
	1668	if [ _"$MONDO_SHARE" != _"" ]; then
[940]	1669	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1670	options="iso"
	1671	else
	1672	options="interactive expert compare iso nuke isonuke"
	1673	# hda hdb hdc hdd"
	1674	fi
	1675	else
	1676	options="expert"
[925]	1677	fi
[747]	1678	fi
	1679	for i in $options ; do
[925]	1680	ooo=$i
	1681	[ "$ooo" = "RESTORE" ] && ooo="nuke"
	1682	if [ "$ARCH" = "ia64" ] ; then
	1683	rootpart="root=/dev/ram0\n\t"
	1684	else
	1685	rootpart=""
	1686	fi
[1230]	1687	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]	1688
[925]	1689	outstr=$outstr" $ooo_mode"
	1690	outstr=$outstr"\"\n"
[1885]	1691	echo -en "$outstr"
[747]	1692	done
	1693	}
	1694
	1695
	1696	PrepareBootDiskImage_LILO() {
[1885]	1697	local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
[747]	1698	imagesdir=$1
[1885]	1699	kernelpath=$2
	1700	ramdisksize=$3
[747]	1701
	1702	retval=0
	1703	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
[1885]	1704	echo -en "Making "$BOOT_SIZE"KB boot disk..."
	1705	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]	1706	echo -en "..."
[1885]	1707	imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
[940]	1708	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	1709	mkdir -p $mountpoint
[1885]	1710	dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null \|\| Die "Cannot dd blank file"
[747]	1711	if [ "$ARCH" = "ia64" ] ; then
[964]	1712	mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
	1713	t=vfat
[747]	1714	else
[1880]	1715	echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
	1716	mke2fs -N 26 -m 0 -F $imagefile &> /dev/null \|\| Die "Unable to create an ext2 file system on $imagefile"
[964]	1717	t=ext2
[747]	1718	fi
[963]	1719	mount -t $t -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[964]	1720	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	1721	mkdir -p $mountpoint/etc
	1722	if [ "$ARCH" != "ia64" ] ; then
	1723	liloconf=$mountpoint/etc/lilo.conf
	1724	else
[925]	1725	liloconf=$mountpoint/elilo.conf
[747]	1726	fi
	1727	old_pwd=`pwd`
	1728	cd $mountpoint
	1729	if [ "$ARCH" != "ia64" ] ; then
[963]	1730	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	1731	fi
	1732	cd $old_pwd
[1311]	1733	# BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
	1734	#losetup /dev/loop0 > /dev/null 2> /dev/null
	1735	#[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1736	CopyBootBFile $mountpoint/boot.b
	1737
[1885]	1738	MakeLiloConfFile > $liloconf
[747]	1739
[1230]	1740	# Copy it so that CD-ROM menu entry is satisfied
	1741	if [ "$ARCH" = "ia64" ] ; then
	1742	mountefi=0
[1796]	1743	df -T \| grep /boot/efi \| grep -q vfat
[1230]	1744	if [ $? -ne 0 ]; then
	1745	mount /boot/efi
	1746	if [ $? -ne 0 ]; then
	1747	echo "You have to mount your EFI partition when using mindi"
	1748	MindiExit -1
	1749	fi
	1750	mountefi=1
	1751	fi
[1735]	1752	el=`find /boot/efi -name elilo.efi`
	1753	cp $el $mountpoint
[1794]	1754	cp $liloconf $mountpoint
[1230]	1755	if [ $mountefi -eq 1 ]; then
	1756	umount /boot/efi 2>&1 > /dev/null
	1757	fi
	1758	fi
	1759
[940]	1760	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
	1761	cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
[747]	1762	if [ "$?" -ne "0" ] ; then
[963]	1763	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	1764	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	1765	LogIt "Please unload some of your modules and try again."
[940]	1766	rm -f $MINDI_TMP/mtpt.$$
[963]	1767	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	1768	retval=$(($retval+1))
	1769	fi
[1885]	1770	MakeMessageFile > $mountpoint/message
[747]	1771
	1772	mkdir -p $mountpoint/tmp
[940]	1773	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	1774	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1775	echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
	1776	echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
	1777	# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
	1778	fi
	1779
[925]	1780	# copy the kernel across
[1230]	1781	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	1782	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
[1796]	1783	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	1784	cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
[1885]	1785	if [ "$?" -ne "0" ] ; then
[925]	1786	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	1787	du -sk $mountpoint/* >> $LOGFILE
	1788	echo "--- end of list of files ---" >> $LOGFILE
	1789	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[1885]	1790	Sorry, your kernel is too big for your image.\n" >> $LOGFILE
[747]	1791	rm -f $mountpoint/vmlinuz
[925]	1792	cd $old_pwd
[747]	1793	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	1794	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[925]	1795	# losetup /dev/loop0 -d
	1796	rm -f $imagefile
[1885]	1797	return 0
[747]	1798	fi
[1796]	1799	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	1800	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
[1885]	1801	echo "Free space left on image = $free_space KB" >> $LOGFILE
	1802	echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
[1794]	1803	# make it bootable
[747]	1804	rm -f $mountpoint/zero
[963]	1805	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[1885]	1806	if [ ! "$KERN_DISK_MADE" ] ; then
[747]	1807	if [ "$ARCH" != "ia64" ] ; then
[1794]	1808	$LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	1809	else
	1810	/bin/true
	1811	fi
	1812	else
[925]	1813	echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
[747]	1814	fi
[925]	1815
	1816	# BERLIOS does not test necessarily what it expects
[747]	1817	if [ $? -ne "0" ] ; then
[925]	1818	if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
[963]	1819	LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
	1820	LogIt "Please reboot your PC as a workaround."
	1821	Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
[925]	1822	fi
	1823	echo "$LILO_EXE -r $mountpoint ...failed."
	1824	echo -en "Press ENTER to continue."; read line
[963]	1825	LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
[925]	1826	retval=$(($retval+1))
[747]	1827	fi
[963]	1828	cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
[747]	1829	if [ "$ARCH" = "ia64" ] ; then
[963]	1830	cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
[747]	1831	fi
	1832	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	1833	echo -en "..."
[963]	1834	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	1835	if [ "$retval" -eq "0" ] ; then
[1885]	1836	echo -en "...$DONE\n"
[747]	1837	if [ "$KERN_DISK_MADE" ] ; then
[1885]	1838	LogIt "$BOOT_SIZE KB boot disks were created OK\n"
[747]	1839	fi
	1840	else
[1885]	1841	echo -en "...failed\n"
	1842	LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
[747]	1843	rm -f $imagefile
	1844	fi
[963]	1845	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	1846	return $retval
	1847	}
	1848
	1849
	1850	PrepareBootDiskImage_SYSLINUX() {
[1885]	1851	local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
[747]	1852	imagesdir=$1
[1885]	1853	kernelpath=$2
	1854	ramdisksize=$3
[747]	1855	do_boot_root_thingy=""
	1856	local retval old_pwd
	1857	retval=0
[925]	1858
[747]	1859	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
[1885]	1860	echo -en "Making "$BOOT_SIZE"KB boot disk..."
	1861	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]	1862	echo -en "..."
[1885]	1863	imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
[940]	1864	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	1865	mkdir -p $mountpoint
[1885]	1866	dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null \|\| Die "Cannot dd blank file"
	1867	echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
	1868	mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
	1869	syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
	1870
[963]	1871	mount -t vfat -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[925]	1872
	1873	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	1874	old_pwd=`pwd`
	1875	MakeSyslinuxMessageFile $mountpoint/message.txt
	1876	cd $mountpoint
	1877	[ -e "$sys_cfg_file" ] \|\| Die "Obi Wan, word up?"
	1878	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
[940]	1879	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[1885]	1880	perl -pi -e 's/interactive/iso/' syslinux.cfg
[747]	1881	fi
	1882	cd $old_pwd
[940]	1883	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
	1884	cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
[747]	1885	if [ "$?" -ne "0" ] ; then
[963]	1886	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	1887	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	1888	LogIt "Please unload some of your modules and try again."
[940]	1889	rm -f $MINDI_TMP/mtpt.$$
[963]	1890	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	1891	retval=$(($retval+1))
	1892	fi
	1893
	1894	mkdir -p $mountpoint/tmp
[940]	1895	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	1896
[925]	1897	# copy the kernel across
[1230]	1898	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	1899	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
[1796]	1900	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	1901	cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
[1885]	1902	if [ "$?" -ne "0" ] ; then
[747]	1903	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	1904	du -sk $mountpoint/* >> $LOGFILE
	1905	echo "--- end of list of files ---" >> $LOGFILE
	1906	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[1885]	1907	Sorry, your kernel is too big for your image.\n" >> $LOGFILE
[747]	1908	rm -f $mountpoint/vmlinuz
	1909	cd $old_pwd
	1910	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	1911	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	1912
	1913	rm -f $imagefile
[1885]	1914	return 0
[747]	1915	fi
[1796]	1916	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
[747]	1917	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
[1885]	1918	echo "Free space left on image = $free_space KB" >> $LOGFILE
	1919	echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
[925]	1920
	1921	# make it bootable
[747]	1922	rm -f $mountpoint/zero
	1923	mkdir -p $mountpoint/etc
[963]	1924	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	1925	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	1926	echo -en "..."
[963]	1927	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	1928
	1929	if [ "$retval" -eq "0" ] ; then
[1885]	1930	echo -en "...$DONE\n"
[747]	1931	if [ "$KERN_DISK_MADE" ] ; then
	1932	rm -f $imagefile
[1885]	1933	LogIt "$BOOT_SIZE KB boot disks were created OK\n"
[747]	1934	fi
	1935	else
[1885]	1936	echo -en "...failed\n"
	1937	LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
[747]	1938	rm -f $imagefile
	1939	fi
[963]	1940	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	1941	return $retval
	1942	}
	1943
	1944
	1945	PrepareDataDiskImages() {
[1902]	1946	local needlist bigdir diskdir imagesdir res i j k old_pwd lines lfiles
[747]	1947
	1948	imagesdir=$1
[1902]	1949	rm -f $imagesdir/mindi.iso
[940]	1950	needlist=$MINDI_TMP/what-we-need.txt
	1951	bigdir=$MINDI_TMP/bigdir
[747]	1952	mkdir -p $bigdir/usr/bin
	1953
[1885]	1954	lfiles="$DEPLIST_FILE"
	1955	lines=`grep -vx " #." $lfiles \| grep -vx "" \| wc -l`
	1956	cat $lfiles \| GenerateGiantDependencyList $needlist $lines
[747]	1957	res=$?
	1958	if [ "$YOUR_KERNEL_SUCKS" ]; then
[925]	1959	pwd=`pwd`
[940]	1960	cd $MINDI_TMP
[747]	1961	for i in `ListKernelModulePaths \| HackPathsToFailsafe` ; do
[1914]	1962	tar cf - ./$i 2>> $LOGFILE \| (cd $bigdir ; tar xf -) \|\| Die "PDDI can't copy $i->$bigdir"
[925]	1963	if [ "`du -sk $i \| cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
[1914]	1964	tar cf - $i 2>> $LOGFILE \| (cd $bigdir ; tar xf -)
[925]	1965	else
	1966	ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
	1967	BIGNO=$(($BIGNO+1))
	1968	fi
[747]	1969	done
[925]	1970	for i in $EXTRA_MODS ; do
[1810]	1971	j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
	1972	[ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
[925]	1973	for k in $j ; do
	1974	if [ "`du -sk $k \| cut -f1`" -lt "$CHOPSIZE" ] ; then
[1914]	1975	tar cf - $k 2>> $LOGFILE \| (cd $bigdir ; tar xf -)
[925]	1976	else
	1977	ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
	1978	BIGNO=$(($BIGNO+1))
	1979	fi
	1980	echo "Added failsafe module $k to ramdisk" >> $LOGFILE
	1981	done
	1982	done
	1983	cd $pwd
[747]	1984	else
[925]	1985	ListKernelModulePaths >> $needlist
[747]	1986	fi
	1987	if [ "$res" -ne "0" ] ; then
[1902]	1988	Die "You have $res files present in dependency list\nbut absent from filesystem."
[747]	1989	fi
	1990	FindAndAddUserKeyboardMappingFile
	1991	mkdir -p $bigdir/tmp
[1885]	1992	if [ _"$MONDO_SHARE" != _"" ]; then
[940]	1993	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	1994	cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
[747]	1995	fi
	1996	[ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
	1997	DropOptimizedLibraries $needlist $bigdir
	1998	echo -en "Assembling dependency files"
	1999	CopyDependenciesToDirectory < $needlist $bigdir
	2000
[925]	2001	# also copy io.sys and msdos.sys, if we can find them
[747]	2002	for i in `mount \| cut -d' ' -f3` ; do
[925]	2003	for j in io.sys msdos.sys ; do
[963]	2004	[ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
[925]	2005	done
[747]	2006	done
	2007
[925]	2008	# master boot record, too
[940]	2009	i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
[747]	2010	if [ "$i" ] ; then
[963]	2011	LogIt "Backing up $i's MBR"
[925]	2012	dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
	2013	sleep 1
	2014	sync
	2015	j=$i
	2016	[ -h "$j" ] && j=`readlink -f $j`
[963]	2017	LogIt "Creating /dev/boot_device ($j)"
[925]	2018	mkdir -p $bigdir/dev
[953]	2019	cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null \|\| Die "Unable to create /dev/boot_device on ramdisk"
[747]	2020	fi
	2021
	2022	old_pwd=`pwd`
	2023	cd $bigdir
	2024
	2025	[ -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]	2026	cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping aux-tools"
[747]	2027	if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
[963]	2028	tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
[747]	2029	fi
[1764]	2030	if [ -e "$MONDO_SHARE/restore-scripts" ]; then
[747]	2031	cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
[1335]	2032	[ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
[747]	2033	fi
[1914]	2034	#[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
	2035	[ -d "/lib/dev-state" ] && tar cf - /lib/dev-state 2>> $LOGFILE \| tar xf -
[747]	2036	cd $old_pwd
	2037	echo -e "$DONE"
	2038	TOTAL_BIGDIR_SIZE=`du -sk $bigdir \| cut -f1`
[940]	2039	MakeMountlist $MINDI_TMP/mountlist.txt
[1902]	2040	mkdir -p $bigdir/tmp
	2041	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]	2042	if [ _"$MONDO_SHARE" != _"" ]; then
[1902]	2043	cp -f $bigdir/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
[1885]	2044	fi
[1902]	2045	[ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $bigdir/tmp/i-want-my-lvm \|\| LVM="false"
	2046	cat $bigdir/tmp/mountlist.txt >> $LOGFILE
	2047	echo -en "$FILES_IN_FILELIST" > $bigdir/FILES-IN-FILELIST 2> /dev/null
	2048	echo -en "$LAST_FILELIST_NUMBER" > $bigdir/LAST-FILELIST-NUMBER 2> /dev/null
	2049	if [ _"$MONDO_SHARE" != _"" ]; then
	2050	for q in filelist.full.gz biggielist.txt ; do
	2051	[ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
	2052	cp -pRdf $MINDI_TMP/$q $bigdir/tmp 2>> $LOGFILE
	2053	done
	2054	fi
	2055
	2056	echo -en "Tarring and zipping the data content..."
	2057	size_of_all_tools=`du -sk $bigdir \| cut -f1`
	2058	(cd $bigdir ; tar -b 4096 -cf - . 2> /dev/null \| gzip -9 > $imagesdir/all.tar.gz)
	2059	du -sk $imagesdir/*gz >> $LOGFILE
	2060	echo -e "$DONE"
	2061
[747]	2062	FRIENDLY_OUTSTRING="Boot and data disk images were created."
[1902]	2063	rm -rf $bigdir
[747]	2064	rm -f $needlist
	2065	}
	2066
	2067
	2068	ProcessLDD() {
[1784]	2069	local incoming f d nd bd bnd
[747]	2070	read incoming
[1784]	2071	while [ "$incoming" != "" ]; do
[859]	2072	# We take the full path name of the dyn. lib. we want
[1526]	2073	incoming=`echo "$incoming" \| awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
	2074	for f in $incoming ; do
[1784]	2075	# echo modified file name if one of the parent dir is a link
	2076	# by replacing the original dirname by the destination of the link
	2077	d="`dirname $f`"
	2078	found="false"
	2079	while [ "$d" != "/" ]; do
	2080	if [ -h "$d" ]; then
	2081	nd=`readlink -f $d`
	2082	bd=`basename $d`
	2083	bnd=`basename $nd`
	2084	f=`echo $f \| sed "s~/$bd/~/$bnd/~"`
	2085	echo $d
	2086	fi
	2087	d="`dirname $d`"
	2088	done
	2089
[1721]	2090	echo "$f"
	2091	echo "`ReadAllLink $f`"
[747]	2092	done
	2093	read incoming
	2094	done
	2095	}
	2096
	2097
	2098	Prompt() {
	2099	echo -en "$1"
	2100	read line
	2101	}
	2102
	2103
	2104	ReadLine() {
	2105	local i incoming
	2106	read incoming
	2107	i=0
	2108	while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
[925]	2109	i=$(($i+1))
	2110	read incoming
[747]	2111	done
	2112	echo "$incoming"
	2113	}
	2114
	2115
	2116	ReplaceIndividualLine() {
	2117	local orig_file new_file lino newstring lines_total lines_remaining
[925]	2118
[747]	2119	orig_file=$1.orig
	2120	mv -f $1 $orig_file \|\| Die "Cannot move $1 to $orig_file"
	2121	new_file=$1
	2122	lino=$2
	2123	newstring="$3"
	2124	if [ "$lino" = "" ] \|\| [ "$lino" -lt "1" ] ; then
[925]	2125	echo "Can't find string" >> $LOGFILE
	2126	return 1
[747]	2127	fi
[963]	2128	lines_total=`wc -l $orig_file \| $AWK '{print $1;}'`
[747]	2129	lines_remaining=$(($lines_total-$lino))
	2130	head -n$(($lino-1)) $orig_file > $new_file
	2131	echo "$newstring" >> $new_file
	2132	echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
	2133	tail -n$lines_remaining $orig_file >> $new_file
	2134	echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
	2135	[ -x "$orig_file" ] && chmod +x $new_file
	2136	rm -f $orig_file
	2137	return 0
	2138	}
	2139
	2140
	2141	ScanCDandTape() {
	2142	local i
	2143
	2144	for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
	2145	dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
	2146	done
	2147	}
	2148
	2149
	2150	SizeOfPartition() {
	2151	local devpath drive res stub
	2152	device=$1
	2153	if [ "`echo "$device" \| grep -F "/dev/md"`" != "" ] ; then
[925]	2154	res=`SizeOfRaidPartition $device`
	2155	[ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
	2156	echo "$res"
	2157	return 0
[747]	2158	fi
[925]	2159	# patch from Bill <bill@iwizard.biz> - 2003/08/25
[960]	2160	res=`$FDISK -s $device 2>> $LOGFILE`
[925]	2161	# end patch
[1796]	2162	[ "$res" = "" ] && res=`df -k -P -x supermount \| tr -s '\t' ' ' \| grep -F "$device " \| cut -d' ' -f2`
[747]	2163	[ "$res" = "" ] && res="-1"
	2164	echo $res
	2165	return 0
	2166	}
	2167
	2168
	2169	SizeOfRaidPartition() {
	2170	local real_dev smallest_size silly tmp
	2171
	2172	silly=999999999
	2173	smallest_size=$silly
	2174
	2175	for real_dev in `GetRaidDevMembers $1` ; do
[925]	2176	tmp=`SizeOfPartition $real_dev`
	2177	[ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
[747]	2178	done
	2179
	2180	if [ "$smallest_size" = "$silly" ] ; then
[925]	2181	echo "-1"
	2182	return 1
[747]	2183	else
[925]	2184	echo "$smallest_size"
	2185	return 0
[747]	2186	fi
	2187	}
	2188
	2189
	2190	StripComments()
	2191	{
	2192	local tempfile
[925]	2193
[940]	2194	tempfile=$MINDI_TMP/$$.strip.txt
[963]	2195	cp -f $1 $tempfile 2>> $LOGFILE
[747]	2196	$AWK '{if (substr($0,0,1)!="#" \|\| substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
	2197	rm -f $tempfile
	2198	echo "Stripped comments from $2" >> $LOGFILE
	2199	}
	2200
	2201
[925]	2202
[747]	2203	StripExecutable()
	2204	{
	2205	local tmpfile
[925]	2206
[940]	2207	tmpfile=$MINDI_TMP/stripped.$$.dat
[747]	2208	[ -d "$1" ] \|\| [ -h "$1" ] && return
[963]	2209	cp -f $1 $tmpfile 2>> $LOGFILE
[747]	2210	strip $tmpfile 2> /dev/null
	2211	if [ "$?" -eq "0" ] ; then
[963]	2212	cp -f $tmpfile $1 2>> $LOGFILE
[925]	2213	echo "Stripped binary $2" >> $LOGFILE
[747]	2214	fi
	2215	rm -f $tmpfile
	2216	}
	2217
	2218
	2219	TryToFindKernelPath() {
	2220	local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
[925]	2221
[747]	2222	we_want_version=`uname -r`
	2223	possible_kernels=""
	2224	duff_kernels=""
	2225
	2226	if [ "$ARCH" = "ia64" ] ; then
	2227	root="/boot/efi/efi"
	2228	else
	2229	root="/"
	2230	fi
[1466]	2231	for fname in `find $root -maxdepth 2 -type f \| grep -E 'lin\|kern' \| grep -Ev '^/proc/\|^/net/'` ; do
[925]	2232	[ ! -e "$fname" ] && continue
[747]	2233	[ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
[925]	2234	file $fname \| grep -q gzip
	2235	if [ "$?" -eq "0" ] ; then
	2236	# Used by ia64
[747]	2237	fkern_ver=`gzip -cd $fname \| strings 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2238	else
[747]	2239	fkern_ver=`strings $fname 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2240	fi
[747]	2241	[ "$fkern_ver" = "" ] && continue
	2242	[ "`echo "$fkern_ver" \|grep -F "$we_want_version "`" = "" ] && continue
[925]	2243	[ -f "$fname" ] \|\| continue
	2244	[ -h "$fname" ] && continue
	2245	kdate=`uname -v \| $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' \| $AWK '{print $NF;}'`
	2246	file $fname \| grep -q gzip
	2247	if [ "$?" -eq "0" ] ; then
	2248	# Used by ia64
	2249	if [ "`gzip -cd $fname \| strings 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2250	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
[925]	2251	duff_kernels="$fname $duff_kernels"
	2252	else
[747]	2253	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2254	possible_kernels="$fname $possible_kernels"
[925]	2255	fi
[747]	2256	else
[925]	2257	if [ "`strings $fname 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2258	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
[925]	2259	duff_kernels="$fname $duff_kernels"
	2260	else
[747]	2261	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2262	possible_kernels="$fname $possible_kernels"
[925]	2263	fi
[747]	2264	fi
	2265	done
	2266	if [ ! "$possible_kernels" ] && uname -a \| grep Knoppix > /dev/null ; then
[925]	2267	possible_kernels=`find /boot/vmlinuz-2.* \| tail -n1`
[747]	2268	fi
	2269	if [ ! "$possible_kernels" ] ; then
[963]	2270	LogIt "No kernel matches exactly. Are there any duff kernels?"
[747]	2271	possible_kernels="$duff_kernels"
	2272	if [ ! "$possible_kernels" ] ; then
[963]	2273	LogIt "Sorry, no duff kernels either"
[747]	2274	else
[963]	2275	LogIt "I bet you're running Debian or Gentoo, aren't you?"
	2276	LogIt "Your kernel doesn't have a sane builddate. Oh well..."
[747]	2277	fi
	2278	fi
	2279	possible_kernels=`echo "$possible_kernels" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '`
	2280	noof_kernels=`CountItemsIn "$possible_kernels"`
	2281	if [ "$noof_kernels" -eq "0" ] ; then
[963]	2282	LogIt "Could not find your kernel."
[925]	2283	if [ -e "/boot/vmlinuz" ] ; then
[963]	2284	LogIt "Using /boot/vmlinuz as a last resort."
[925]	2285	output=/boot/vmlinuz
[747]	2286	else
[925]	2287	output=""
	2288	fi
[747]	2289	elif [ "$noof_kernels" -eq "1" ] ; then
	2290	kernelpath=`echo "$possible_kernels" \| sed s/' '//`
	2291	echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
	2292	output="$kernelpath"
	2293	else
	2294	for i in $possible_kernels ; do
	2295	if echo $i \| grep "`uname -r`" ; then
[925]	2296	LogIt "OK, I used my initiative and found that "
[963]	2297	LogIt "$i is probably your kernel. "
[925]	2298	output="$i"
	2299	return
	2300	fi
[747]	2301	done
[925]	2302	if echo " $possible_kernels " \| grep -F "/boot/vmlinuz " &> /dev/null ; then
	2303	output=/boot/vmlinuz
	2304	echo "Schlomo, this one's for you." >> $LOGFILE
	2305	else
[963]	2306	LogIt "Two or more possible kernels found. You may specify any one of them and the "
	2307	LogIt "boot disks will still work, probably. If one does not work, try another."
	2308	LogIt "$possible_kernels"
[747]	2309	echo ""
[925]	2310	fi
[747]	2311	fi
	2312	echo "$output" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '
	2313	}
	2314
	2315
	2316	TurnTgzIntoRdz() {
[1885]	2317	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]	2318
[747]	2319	tgz_dir_fname=$1
	2320	rdz_fname=$2
	2321	ramdisksize=$3
[1885]	2322	kernelsize=$4
	2323	maxsize=$(($BOOT_SIZE-$kernelsize))
[747]	2324	maxsize=$(($maxsize*2)); # to allow for compression of 50%
[940]	2325	tempfile=$MINDI_TMP/temp.rd
	2326	mountpoint=$MINDI_TMP/mnt1
[747]	2327	res=0
	2328	echo -en "..."
	2329	dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null \|\| Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
	2330	echo -en "..."
[1764]	2331	echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
	2332	mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE \|\| Die "Unable to create an ext2 file system on $tempfile"
[747]	2333	echo -en "..."
	2334	mkdir -p $mountpoint
	2335	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."
	2336	echo -en "..."
	2337	old_pwd=`pwd`
	2338	cd $mountpoint
[959]	2339	cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
[747]	2340	tar -zxf symlinks.tgz \|\| Die "Cannot untar symlinks.tgz"
[1914]	2341
[747]	2342	cd dev \|\| Die "Can't cd to dev"
	2343	tar -zxf dev-entries.tgz \|\| Die "Cannot untar dev-entries.tgz"
	2344	rm -f dev-entries.tgz
	2345	cd ..
	2346
	2347	for w in insmod.static insmod.static.old ; do
[925]	2348	s=`which $w 2> /dev/null`
	2349	if [ -e "$s" ] ; then
[1913]	2350	tar cf - $s 2> /dev/null \| tar xf -
[925]	2351	fi
[747]	2352	done
	2353
	2354	[ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
[1724]	2355
[1882]	2356	# Handle the case where busybox and mount are dynamically linked
[1786]	2357	file $MINDI_LIB/rootfs/bin/busybox 2>&1 \| grep -q "dynamically"
	2358	if [ $? -eq 0 ]; then
[1927]	2359	# We want to use the real mount and all the supported variants (nfs, cifs, ...)
	2360	rm -f bin/mount $MINDI_TMP/busy.lis
	2361	mountlis=`grep mount $DEPLIST_FILE`
	2362	for f in $MINDI_LIB/rootfs/bin/busybox $mountlis ; do
	2363	if [ -f $f ]; then
	2364	LocateDeps $f >> $MINDI_TMP/busy.lis
	2365	fi
	2366	done
	2367	tar cf - $mountlis `sort -u $MINDI_TMP/busy.lis` 2> /dev/null \| tar xf -
[1786]	2368	rm -f $MINDI_TMP/busy.lis
	2369	fi
	2370
[1914]	2371	mkdir -p $mountpoint/tmp
[1724]	2372	# Management of udev (which includes modprobe in rules)
[1759]	2373	ps auxww \| grep -v grep \| grep -qw udevd
[1716]	2374	if [ $? -eq 0 ]; then
[1914]	2375	echo "udev device manager found" > $mountpoint/tmp/USE-UDEV
[1759]	2376	LogIt "udev device manager found"
[1913]	2377	tar cf - /etc/udev 2> /dev/null \| tar xf -
[1790]	2378	# This avoids NIC remapping if on another machine at restore time on Debian at least
	2379	rm -f ./etc/udev/rules.d/z25_persistent-net.rules
[1913]	2380	tar cf - /lib*/udev 2> /dev/null \| tar xf -
[1720]	2381	if [ -x /sbin/udevd ]; then
[1781]	2382	lis2=`grep -Ev '^#' $MINDI_CONF/udev.files`
	2383	lis=""
	2384	# Get only the files which exist in that list
[1815]	2385	# and potentially their symlink structure
[1781]	2386	for i in $lis2; do
[1815]	2387	if [ -h $i ]; then
	2388	j=$i
	2389	while [ -h $j ]; do
	2390	lis="$lis $j"
	2391	j=`readlink $j`
	2392	done
	2393	lis="$lis $j"
	2394	elif [ -f $i ]; then
[1781]	2395	lis="$lis $i"
	2396	fi
	2397	done
	2398	# And their deps
[1759]	2399	LocateDeps $lis > $MINDI_TMP/udev.lis
	2400	for i in $lis; do
	2401	if [ "`echo $i \| cut -c1`" = "/" ]; then
	2402	j=`echo $i \| cut -c2-`
	2403	rm -f $j
	2404	fi
	2405	done
[1913]	2406	tar cf - $lis `sort -u $MINDI_TMP/udev.lis` 2> /dev/null \| tar xf -
[1721]	2407	rm -f $MINDI_TMP/udev.lis
[1720]	2408	else
	2409	echo "udevd daemon not in standard place (/sbin)" 2>&1 \| tee -a $LOGFILE
[1724]	2410	echo "mindi will use static devices which may cause problems" 2>&1 \| tee -a $LOGFILE
[1914]	2411	rm -f $mountpoint/tmp/USE-UDEV
[1720]	2412	fi
[1716]	2413	fi
[1786]	2414
[1761]	2415	# Management of potential HW info (Proliant only at the moment)
[1880]	2416	rm -rf $MINDI_CACHE/bkphw
	2417	mindi-bkphw $MINDI_CACHE $MINDI_CONF \| tee -a $LOGFILE
	2418	if [ -d $MINDI_CACHE/bkphw ]; then
[1761]	2419	LogIt "Hardware Information found and saved ..."
[1880]	2420	cp -rp $MINDI_CACHE/bkphw .
	2421	if [ -f $MINDI_CACHE/tools.files ]; then
	2422	lis=`grep -Ev '^#' $MINDI_CACHE/tools.files`
[1863]	2423	LocateDeps $lis > $MINDI_TMP/tools.lis
[1913]	2424	tar cf - $lis `sort -u $MINDI_TMP/tools.lis` 2> /dev/null \| tar xf -
[1863]	2425	fi
[1880]	2426	if [ -f $MINDI_CACHE/mindi-rsthw ]; then
	2427	mv -f $MINDI_CACHE/mindi-rsthw .
[1761]	2428	chmod 755 ./mindi-rsthw
	2429	fi
[1880]	2430	rm -f $MINDI_TMP/tools.lis $MINDI_CACHE/tools.files
[1761]	2431	fi
	2432
[1885]	2433	for w in cdrom groovy-stuff ; do
[747]	2434	mkdir -p mnt/$w
	2435	done
[925]	2436	#if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
	2437	#ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
	2438	#fi
[747]	2439	if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
[925]	2440	ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
[747]	2441	fi
	2442
[1913]	2443	tar cf - /dev/fd0[1,2][4,7,8] 2> /dev/null \| tar xf -
[1721]	2444
[747]	2445	cd $old_pwd
	2446	echo -en "..."
	2447	old_pwd=`pwd`
	2448	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	2449	cd $MINDI_TMP
[1885]	2450	needed_modules_path=lib/modules/$FAILSAFE_KVER
[747]	2451	else
	2452	cd /
	2453	if [ "${kernelname}" != "" ]
	2454	then
[1885]	2455	needed_modules_path=lib/modules/${kernelname}
[747]	2456	else
[1885]	2457	needed_modules_path=lib/modules/`uname -r`
[747]	2458	fi
	2459	fi
[1885]	2460
	2461	needed_modules=""
	2462	list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
	2463
[940]	2464	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2465	# For PXE boot
	2466	list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
	2467	fi
[1715]	2468	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
	2469	list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
	2470	fi
[1727]	2471	for i in $DENY_MODS; do
	2472	echo "Removing $i from the list of modules to load" >> $LOGFILE
	2473	list_of_groovy_mods=`echo ${list_of_groovy_mods} \| tr ' ' '\n' \| grep -Ev "^${i}$" \| tr '\n' ' '`
	2474	done
	2475
[1885]	2476	[ -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]	2477	for i in $list_of_groovy_mods ; do
[1885]	2478	needed_modules="$needed_modules `FindSpecificModuleInPath $needed_modules_path $i`"
[747]	2479	done
[1914]	2480
[1885]	2481	for i in $needed_modules ; do
[747]	2482	[ -e "$i" ] && s=`du -sk $i \| cut -f1` \|\| s=""
[940]	2483	[ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
[747]	2484	echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
[1913]	2485	tar cf - $i 2>/dev/null \| (cd $mountpoint ; tar xf -) \|\| LogIt "Unable to copy $i to $mountpoint"
[1914]	2486	# Uncompress modules if not using udev and native modprobe
[1815]	2487	if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
	2488	if [ "`echo "$i" \| grep -F ".gz"`" ]; then
[1914]	2489	echo "Uncompressing $i" >> $LOGFILE
[1727]	2490	gunzip -f $mountpoint/$i
[1815]	2491	fi
[1727]	2492	fi
[747]	2493	done
[1815]	2494
	2495	# Also copy modules.dep in case of udev so that normal modprobe works
[1913]	2496	tar cf - /$needed_modules_path/modules.dep 2>/dev/null \| (cd $mountpoint ; tar xf -) \|\| LogIt "Unable to copy modules.dep to $mountpoint"
[1815]	2497
[1885]	2498	if [ ! -e "/sbin/devfsd" ] \|\| [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
[747]	2499	echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
	2500	[ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
	2501	[ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
	2502	rm -f $mountpoint/sbin/devfsd
	2503	fi
	2504	cd $old_pwd
	2505	[ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
	2506	dd if=/dev/zero of=$mountpoint/zero &> /dev/null
	2507	rm -f $mountpoint/zero
[1885]	2508	if [ _"$MONDO_SHARE" != _"" ]; then
[747]	2509	MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
[940]	2510	cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
[953]	2511	cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null \|\| Die "Cannot copy mountlist to ramdisk"
[747]	2512	echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
	2513	echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
	2514	[ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
[998]	2515	[ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
[747]	2516	[ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
	2517	[ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
	2518	fi
	2519	mkdir -p $mountpoint/proc
[1885]	2520	echo "$BOOT_SIZE" > $mountpoint/tmp/$BOOT_SIZE.siz
[1230]	2521	# Determine what filesystem to use for initrd image
	2522	echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
	2523	gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
	2524	[ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
	2525	case "$gvFileSystem" in
	2526	"ext2fs")
	2527	# say what will be used
[1821]	2528	echo "Creating an ext2 initrd image..." >> $LOGFILE
[1230]	2529	# kernel expects linuxrc in ext2 filesystem
	2530	( cd $mountpoint && ln -sf sbin/init linuxrc )
	2531	# unmount loop filesystem and create image file using the standard approach
	2532	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
[1764]	2533	dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
[1794]	2534	bs=`tune2fs -l ${rdz_fname}.tmp \| grep -E '^Block size:' \| cut -d: -f2 \| sed 's/^ *//'`
[1764]	2535	ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
[1799]	2536	gzip -c9 ${rdz_fname}.tmp > $rdz_fname
[1764]	2537	rm -f ${rdz_fname}.tmp
[1230]	2538	# log that we are done
[1821]	2539	echo "...done." >> $LOGFILE
[1230]	2540	;;
	2541	"initramfs")
	2542	# say what will be used
[1821]	2543	echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
[1230]	2544	# make sure that cpio is there
	2545	which cpio &> /dev/null; [ $? -eq 0 ] \|\| Die "cpio not found. Please install package cpio and try again."
	2546	# go into filesystem
	2547	cd $mountpoint
	2548	# kernel expects init in cpio filesystem
	2549	ln -sf sbin/init init
	2550	# create cpio image file and unmount loop filesystem
[1929]	2551	find . -print \| cpio -o -H newc \| gzip -9 > $rdz_fname 2> /dev/null
[1230]	2552	cd $old_pwd
	2553	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	2554	# log that we are done
	2555	echo "...done." >> $LOGFILE
	2556	;;
	2557	*)
	2558	Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
	2559	;;
	2560	esac
[747]	2561	if [ "$res" -eq "0" ] ; then
	2562	echo -en "..."
	2563	else
	2564	echo -en "\rMade an rdz WITH ERRORS. \n"
	2565	fi
	2566	return 0
	2567	}
	2568
	2569
	2570	WhichOfTheseModulesAreLoaded() {
	2571	local modname loaded_modules
[1399]	2572	loaded_modules="$MODULES"
[747]	2573	for modname in $1 ; do
[1506]	2574	[ "`echo "$loaded_modules" \| grep -w "$modname"`" ] && echo "$modname"
[747]	2575	done
	2576	}
	2577
	2578
	2579
	2580	##############################################################################
[1021]	2581	#----------------------------------- Main -----------------------------------#
[747]	2582	##############################################################################
	2583
[1885]	2584	# Now we can create what we need
	2585	mkdir -p $MINDI_TMP
[747]	2586
[1885]	2587	# Purge from potential old run
	2588	if [ _"$MINDI_CACHE" = _"" ]; then
	2589	Die "MINDI_CACHE undefined"
	2590	fi
	2591	rm -rf $MINDI_CACHE/* 2> /dev/null
	2592	mkdir -p $MINDI_CACHE
	2593
	2594	if [ "$1" = "--printvar" ] ; then
	2595	shift
	2596	if [ _"$1" != _"" ] ; then
	2597	set \| grep -Ew "^$1" \| cut -d= -f2
	2598	fi
	2599	MindiExit 0
	2600	fi
	2601
[747]	2602	> $LOGFILE
	2603	echo "mindi v$MINDI_VERSION" >> $LOGFILE
	2604	echo "$ARCH architecture detected" >> $LOGFILE
	2605	echo "mindi called with the following arguments:" >> $LOGFILE
	2606	echo "$@" >> $LOGFILE
[800]	2607	echo "Start date : `date`" >> $LOGFILE
[1684]	2608	echo "-----------------------------" >> $LOGFILE
[747]	2609
	2610	[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
	2611
[1010]	2612	# Log some capital variables
	2613	[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
[1885]	2614	echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
[1010]	2615	echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
	2616	echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
	2617	[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
	2618	echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
[1885]	2619	if [ -f $MINDI_CONFIG ]; then
	2620	echo "-----------------------------" >> $LOGFILE
	2621	echo " Mindi configuration file " >> $LOGFILE
	2622	echo "-----------------------------" >> $LOGFILE
	2623	grep -Ev '^#' $MINDI_CONFIG >> $LOGFILE
	2624	echo "-----------------------------" >> $LOGFILE
	2625	fi
[1010]	2626
[1885]	2627
[747]	2628	trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
[1010]	2629
	2630	# Sanity checks
	2631	which which > /dev/null 2> /dev/null \|\| Die "Please install 'which'."
	2632	which strings > /dev/null 2> /dev/null \|\| Die "Please install binutils and libbinutils; you have no 'strings' executable."
	2633	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."
	2634	which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` \|\| AWK="`which awk 2>/dev/null`"
	2635	if which awk &> /dev/null ; then
	2636	if ! which gawk &> /dev/null ; then
	2637	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"
	2638	fi
	2639	fi
	2640	which mke2fs > /dev/null 2> /dev/null \|\| Die "Please put mke2fs in system path"
	2641	[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
	2642
[747]	2643	[ "`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]	2644
	2645	# Update the PATH variable if incomplete
	2646	if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
	2647	PATH=$PATH:/sbin:/usr/sbin
	2648	export PATH
	2649	echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
	2650	echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
	2651	echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
	2652	fi
	2653
[1885]	2654	# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
	2655	if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
	2656	source $MINDI_LIB/FindDistroFailsafe
	2657	# Log kernel image
	2658	LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
	2659	else
	2660	[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null \| grep -E "2\.[46]" \| cut -d' ' -f1`
	2661	fi
[1010]	2662
[1737]	2663	if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
[1010]	2664	Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
	2665	fi
	2666
[925]	2667	### BERLIOS
[747]	2668	### Fix as it's not mandatory on ia64
	2669	if [ "$ARCH" = "ia64" ] ; then
[1010]	2670	if which elilo &> /dev/null ; then
	2671	LILO_EXE=elilo
	2672	else
	2673	LILO_EXE=`which false`
	2674	fi
[747]	2675	else
	2676	FindIsolinuxBinary
	2677	FindLiloBinary
	2678	fi
	2679	trap "Aborted" SIGTERM
	2680	DONE="\r\t\t\t\t\t\t\t\tDone. "
	2681	CHOPSIZE=240
	2682	BIGNO=0
	2683	MAX_COMPRESSED_SIZE=1300
	2684	kernelpath=""
[1010]	2685	MONDO_ROOT=/var/cache/mondo
[747]	2686	mkdir -p $MONDO_ROOT
	2687
	2688	if [ -d "/proc/lvm" ]; then
	2689	# LVM v1
	2690	LVMCMD=""
	2691	LVM="v1"
	2692	elif [ -d "/dev/mapper" ]; then
	2693	# LVM v2
	2694	LVMCMD="lvm"
	2695	LVM="v2"
	2696	else
	2697	LVM="false"
	2698	fi
[1021]	2699	echo "LVM set to $LVM" >> $LOGFILE
	2700	echo "----------" >> $LOGFILE
[1230]	2701	echo "mount result:" >> $LOGFILE
	2702	echo "-------------" >> $LOGFILE
	2703	mount >> $LOGFILE
	2704	echo "-------------" >> $LOGFILE
[1315]	2705	if [ -e /etc/raidtab ]; then
	2706	echo "-------------" >> $LOGFILE
	2707	echo "/etc/raidtab content:" >> $LOGFILE
	2708	echo "-------------" >> $LOGFILE
	2709	cat /etc/raidtab >> $LOGFILE
	2710	fi
	2711	echo "-------------" >> $LOGFILE
[1418]	2712	echo "cat /proc/cmdline:" >> $LOGFILE
	2713	echo "-------------" >> $LOGFILE
	2714	cat /proc/cmdline >> $LOGFILE
	2715	echo "-------------" >> $LOGFILE
[1021]	2716	echo "lsmod result:" >> $LOGFILE
	2717	echo "-------------" >> $LOGFILE
	2718	lsmod >> $LOGFILE
[1399]	2719	MODULES="`cat /proc/modules \| awk '{print $1}'`"
[1531]	2720	if [ -x /usr/sbin/esxcfg-module ]; then
[1797]	2721	echo "-------------" >> $LOGFILE
[1497]	2722	echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
	2723	echo "-------------" >> $LOGFILE
	2724	echo "VMWare modules" >> $LOGFILE
	2725	echo "-------------" >> $LOGFILE
[1531]	2726	/usr/sbin/esxcfg-module -l >> $LOGFILE
[1764]	2727	MODULES="$MODULES `/usr/sbin/esxcfg-module -l \| awk '{print $1}'`"
[1497]	2728	fi
[1851]	2729	echo "FORCE_MODS:" >> $LOGFILE
[1021]	2730	echo "-------------" >> $LOGFILE
[1851]	2731	echo $FORCE_MODS >> $LOGFILE
[1882]	2732	echo "-------------" >> $LOGFILE
[1851]	2733	echo "DENY_MODS:" >> $LOGFILE
	2734	echo "-------------" >> $LOGFILE
	2735	echo $DENY_MODS >> $LOGFILE
	2736	echo "-------------" >> $LOGFILE
[1796]	2737	echo "df result:" >> $LOGFILE
[1785]	2738	echo "----------" >> $LOGFILE
[1796]	2739	df -T >> $LOGFILE
[1785]	2740	echo "-------------" >> $LOGFILE
[1230]	2741	echo "Liste of extra modules is:" >> $LOGFILE
	2742	echo "$EXTRA_MODS" >> $LOGFILE
	2743	echo "-------------" >> $LOGFILE
[747]	2744
[1723]	2745	# Compute libata version
[1797]	2746	laver=`modinfo libata \| grep -Ei '^Version:' \| cut -d: -f2 \| cut -d. -f1 \| sed 's/ *//g' 2> /dev/null`
[1723]	2747	# If libata v2 is used then remove ide-generic as it will perturbate boot
[1726]	2748	if [ "`echo $MODULES \| grep libata`" ]; then
[1727]	2749	if [ "$laver" = "2" ]; then
[1726]	2750	DENY_MODS="$DENY_MODS ide-generic"
[1727]	2751	echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
[1726]	2752	echo "-------------" >> $LOGFILE
	2753	fi
[1723]	2754	fi
	2755
[747]	2756	if [ "$#" -ge "2" ] ; then
	2757	if [ "$1" = "--max-compressed-size" ] ; then
	2758	MAX_COMPRESSED_SIZE=$2
	2759	shift; shift
	2760	fi
	2761	fi
	2762
	2763	FLOPPY_WAS_MOUNTED=""
	2764	for mtpt in /media/floppy /mnt/floppy /floppy ; do
	2765	if mount \| grep -w $mtpt &> /dev/null ; then
	2766	FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
	2767	umount $mtpt
	2768	fi
	2769	done
	2770
[1684]	2771	#
	2772	# If we have a USB device we need to store info
	2773	# and remove it from the parameters line
	2774	#
[747]	2775	if [ "$#" -ne "0" ] ; then
[1684]	2776	if [ "$1" = "--usb" ] ; then
	2777	shift
	2778	USBDEVICE=$1
	2779	if [ _"$USBDEVICE" = _"" ]; then
	2780	Die "No USB device specified"
	2781	fi
	2782	shift
	2783	fi
	2784	fi
	2785
	2786	if [ "$#" -ne "0" ] ; then
[747]	2787	if [ "$1" = "--findkernel" ] ; then
	2788	res=`TryToFindKernelPath`
[1336]	2789	# Avoids logfile content for mondo
	2790	export MONDO_SHARE=""
[747]	2791	if [ "$res" = "" ] ; then
[925]	2792	MindiExit -1
[747]	2793	else
	2794	echo "$res"
[925]	2795	MindiExit 0
[747]	2796	fi
[1720]	2797	elif [ "$1" = "--locatedeps" ] ; then
	2798	[ ! "$2" ] && Die "Please specify the binary to look at"
	2799	LocateDeps $2
	2800	# Avoids logfile content for mondo
	2801	export MONDO_SHARE=""
	2802	MindiExit $?
[1815]	2803	elif [ "$1" = "--readalllink" ] ; then
	2804	[ ! "$2" ] && Die "Please specify the binary to look at"
	2805	ReadAllLink $2
	2806	# Avoids logfile content for mondo
	2807	export MONDO_SHARE=""
	2808	MindiExit $?
[747]	2809	elif [ "$1" = "--makemountlist" ] ; then
	2810	[ ! "$2" ] && Die "Please specify the output file"
	2811	MakeMountlist $2
[1336]	2812	# Avoids logfile content for mondo
	2813	export MONDO_SHARE=""
[925]	2814	MindiExit $?
	2815	elif [ "$1" = "-V" ] \|\| [ "$1" = "-v" ] \|\| [ "$1" = "--version" ] \|\| [ "$1" = "-version" ] ; then
	2816	echo "Mindi v$MINDI_VERSION"
[1336]	2817	# Avoids logfile content for mondo
	2818	export MONDO_SHARE=""
[925]	2819	MindiExit 0
[747]	2820	elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
[940]	2821	MONDO_TMP=$2
	2822	# Change MINDI_TMP for the one provided by mondo
	2823	# So that it can get back the built files
[1010]	2824	mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
	2825	rmdir $MINDI_TMP
[1486]	2826	export MINDI_TMP=$MONDO_TMP
[953]	2827	mkdir -p $MINDI_TMP
[1696]	2828	# This is the scratch dir in mondo - subdir images
[1880]	2829	MINDI_CACHE=$3
	2830	if [ _"$MINDI_CACHE" != _"" ]; then
	2831	mkdir -p $MINDI_CACHE
[938]	2832	fi
[925]	2833	kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
[747]	2834	###
	2835	### Sq-Modification...
	2836	### Attempt to locate kernel specific module path
	2837	### if module path is found then use it other wise use uname -r to set it...
	2838	###
	2839	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
[963]	2840	LogIt "kernelname = $kernelname"
	2841	LogIt "kernelpath = $kernelpath"
[747]	2842	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	2843	then
[963]	2844	LogIt "Module path for ${kernelpath} not found..."
	2845	LogIt "using running kernel\'s modules."
[747]	2846	kernelname=`uname -r`
	2847	else
[963]	2848	LogIt "Using modules for kernel: ${kernelname}"
[747]	2849	fi
	2850	###
	2851	### end of Sq-Modification
	2852	###
[925]	2853	TAPEDEV=$5
	2854	TAPESIZE=$6
	2855	FILES_IN_FILELIST=$7
	2856	USE_LZO=$8
	2857	CDRECOVERY=$9
[747]	2858	if [ "${10}" = "(null)" ] \|\| [ "${10}" = "" ] ; then
	2859	IMAGE_DEVS=""
	2860	else
	2861	IMAGE_DEVS="`echo "${10}" \| tr '\|' ' '`"
	2862	fi
[925]	2863	if [ "${11}" ] ; then
	2864	LILO_OPTIONS=""
	2865	# LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
	2866	fi
	2867	LAST_FILELIST_NUMBER=${12}
[747]	2868	ESTIMATED_TOTAL_NOOF_SLICES=${13}
	2869	EXCLUDE_DEVS="${14}"
	2870	USE_COMP="${15}"
	2871	USE_LILO="${16}"
[925]	2872	USE_STAR="${17}"
	2873	INTERNAL_TAPE_BLOCK_SIZE="${18}"
[747]	2874	DIFFERENTIAL="${19}"
[998]	2875	USE_GZIP="${20}"
	2876	NOT_BOOT="${21}"
[747]	2877	[ "$USE_COMP" = "" ] && USE_COMP=yes
[998]	2878	[ "$USE_GZIP" = "" ] && USE_GZIP=no
[747]	2879	[ "$NOT_BOOT" = "" ] && NOT_BOOT=no
[963]	2880	[ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
[925]	2881	[ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
[747]	2882	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
	2883	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	2884	then
[963]	2885	LogIt "Module path for ${kernelpath} not found..."
	2886	LogIt "using running kernel\'s modules."
[747]	2887	kernelname=`uname -r`
	2888	else
[963]	2889	LogIt "Using modules for kernel: ${kernelname}"
[747]	2890	fi
[925]	2891	[ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
[1696]	2892	# MONDO_ROOT is the real scratchdir
[1880]	2893	MONDO_ROOT=`echo $MINDI_CACHE \| sed 's/\(.\)\/./\1/'`
[938]	2894	if [ _"$MONDO_ROOT" != _"" ]; then
	2895	mkdir -p $MONDO_ROOT
	2896	else
	2897	Die "MONDO_ROOT is undefined"
	2898	fi
[747]	2899	else
[925]	2900	echo "Syntax: mindi (--custom ....)" >> /dev/stderr
	2901	MindiExit -1
[747]	2902	fi
	2903	fi
	2904	#ScanCDandTape
	2905	[ "$CDRECOVERY" = "yes" ] \|\| CDRECOVERY=no
	2906	if [ "$CDRECOVERY" = "yes" ] ; then
	2907	iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
	2908	sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
	2909	else
	2910	iso_cfg_file=$MINDI_LIB/isolinux.cfg
	2911	sys_cfg_file=$MINDI_LIB/syslinux.cfg
	2912	fi
	2913
	2914	[ -e "$iso_cfg_file" ] \|\| Die "Cannot find $iso_cfg_file"
[1684]	2915	if [ _"$MONDO_SHARE" = _"" ]; then
[963]	2916	LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
	2917	LogIt "Latest Mindi is available from http://www.mondorescue.org"
	2918	LogIt "BusyBox sources are available from http://www.busybox.net"
[747]	2919	LogIt "------------------------------------------------------------------------------"
	2920	else
[1315]	2921	echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
[747]	2922	fi
[1005]	2923	if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
	2924	LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 \| head -1`"
	2925	else
	2926	LogIt "Unable to find mindi-busybox, please install it"
	2927	MindiExit -1
	2928	fi
[747]	2929
	2930	# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
	2931	insmod /lib/modules/`uname -r`///misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
	2932	for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
	2933	insmod $i >> $LOGFILE 2>> $LOGFILE
	2934	done
	2935
	2936	KERN_DISK_MADE=""
	2937
	2938	echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
	2939	echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
	2940	echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
	2941	if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
[963]	2942	LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
[940]	2943	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	2944	MakeMountlist $MINDI_TMP/mountlist.txt
	2945	mkdir -p $MINDI_TMP/small-all/tmp
	2946	cd $MINDI_TMP/small-all
[953]	2947	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]	2948	tar -cv ./tmp \| gzip -9 > $MINDI_TMP/all.tar.gz \|\| Die "Cannot make small all.tar.gz"
[747]	2949	sleep 2
[963]	2950	LogIt "Done. Exiting."
[925]	2951	MindiExit 0
[747]	2952	fi
	2953
[1690]	2954	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1684]	2955	LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
	2956	fi
	2957
[747]	2958	if [ "$kernelpath" = "" ] ; then
[1335]	2959	[ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
[966]	2960	echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
	2961	read ch
	2962	if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
	2963	USE_OWN_KERNEL="yes"
[1809]	2964	else
	2965	USE_OWN_KERNEL="no"
[747]	2966	fi
	2967	if [ "$USE_OWN_KERNEL" = "yes" ]; then
[925]	2968	YOUR_KERNEL_SUCKS=""
	2969	kernelpath=`TryToFindKernelPath`
	2970	if [ "$kernelpath" = "" ] ; then
	2971	echo -n "Please enter kernel path : "
	2972	read kernelpath
	2973	fi
[747]	2974	else
[925]	2975	YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
[747]	2976	fi
	2977	fi
[1575]	2978	if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
[1885]	2979	echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot image (y/[n]) ?"
[747]	2980	read ch
[966]	2981	if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
	2982	USE_LILO=no
	2983	else
[747]	2984	USE_LILO=yes
	2985	fi
	2986	fi
	2987	if [ "$YOUR_KERNEL_SUCKS" != "" ] \|\| [ "$kernelpath" = "" ] \|\| [ "$kernelpath" = "SUCKS" ] \|\| [ "$kernelpath" = "FAILSAFE" ] ; then
[1885]	2988	# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
	2989	if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
	2990	source $MINDI_LIB/FindDistroFailsafe
	2991	# Log kernel image
	2992	LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
	2993	kernelpath="$FAILSAFE_KBIN"
	2994	LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
	2995	LogIt "The failsafe kernel is $kernelpath.\n"
	2996	LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
	2997	LogIt "disks then it may still be a result of a problem with your kernel.\n"
	2998	pwd=`pwd`
	2999	cd $MINDI_TMP
	3000	mkdir -p lib/modules
	3001	cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" \|\| Die "Cannot copy kernel modules."
	3002	cd $pwd
	3003	else
	3004	kernelpath=$MINDI_LIB/vmlinuz
	3005	LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
	3006	LogIt "However, you are still running your kernel. If Mindi fails to create your"
	3007	LogIt "disks then it may still be a result of a problem with your kernel."
	3008	pwd=`pwd`
	3009	cd $MINDI_TMP
	3010	bzip2 -dc $MINDI_LIB/lib.tar.bz2 \| tar -x \|\| Die "Cannot unzip lib.tar.bz2"
	3011	cd $pwd
	3012	fi
[747]	3013	YOUR_KERNEL_SUCKS="Your kernel sucks"
	3014	fi
[1880]	3015	echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
[963]	3016	[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
[747]	3017
[965]	3018	[ "$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]	3019
[1880]	3020	PrepareDataDiskImages $MINDI_CACHE
[747]	3021	ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
	3022	rds=$(($ramdisk_size-$((ramdisk_size%4096))))
	3023	ramdisk_size=$rds
	3024
	3025	echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
[1567]	3026	if [ "$ARCH" = "ia64" ] ; then
[1885]	3027	PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size \|\| Die "Failed to create ia64 image disk image."
[1567]	3028	else
	3029	if [ "$USE_LILO" = "yes" ] ; then
[1885]	3030	PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size \|\| Die "Failed to create $BOOT_SIZE MB disk image."
[1567]	3031	else
[1885]	3032	PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $kernelpath $ramdisk_size \|\| Die "Failed to create $BOOT_SIZE MB disk image."
[747]	3033	fi
	3034	fi
	3035
	3036	[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
	3037	...Or type 'memtest' to test your PC's RAM thoroughly.\n"
	3038
[1684]	3039	if [ _"$MONDO_SHARE" = _"" ]; then
[1880]	3040	ListImagesForUser $MINDI_CACHE
[1885]	3041	OfferToMakeBootableISO $MINDI_CACHE
[1684]	3042	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
[1880]	3043	OfferToMakeBootableUSB $MINDI_CACHE
[1684]	3044	fi
[963]	3045	LogIt "Finished."
[747]	3046	elif [ "$TAPEDEV" ] ; then
[1901]	3047	rm -f $MINDI_CACHE/{img,iso}
[1898]	3048	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
	3049	OfferToMakeBootableUSB $MINDI_CACHE
	3050	fi
[1880]	3051	OfferToMakeBootableISO $MINDI_CACHE
	3052	if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
	3053	cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
[747]	3054	else
[925]	3055	Die "Cannot find all.tar.gz, to be written to tape"
[747]	3056	fi
[1695]	3057	elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
[1880]	3058	OfferToMakeBootableUSB $MINDI_CACHE
[747]	3059	else
[1880]	3060	OfferToMakeBootableISO $MINDI_CACHE
[747]	3061	fi
	3062	# cleanup
[963]	3063	LogIt "$FRIENDLY_OUTSTRING"
[747]	3064	for mtpt in $FLOPPY_WAS_MOUNTED ; do
	3065	mount $mtpt
	3066	done
[925]	3067	MindiExit 0

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

Download in other formats: