Context Navigation

source: MondoRescue/branches/2.2.9/mindi/mindi@ 2529

Visit:

Last change on this file since 2529 was 2529, checked in by Bruno Cornec, 14 years ago

r3745@localhost: bruno | 2010-01-08 10:53:15 +0100

Do not report Duplicate mount point when lvm is used
each device of the EXCLUDE_DEVS list is now used correctly and partitions found on this device are excluded

Property svn:executable set to *
Property svn:keywords set to Rev Id

File size: 107.2 KB

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

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

Download in other formats: