Context Navigation

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

Visit:

Last change on this file since 2439 was 2439, checked in by Bruno Cornec, 15 years ago
Avoids error message if some ssh conf files do not exist
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 105.7 KB

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

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

Download in other formats: