Context Navigation

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

Visit:

Last change on this file since 2553 was 2553, checked in by Bruno Cornec, 14 years ago
-Adds support for links to modules (.ko pointing to .o) such as with VMWare extensions
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 107.6 KB

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

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

Download in other formats: