Context Navigation

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

Visit:

Last change on this file since 2393 was 2393, checked in by Bruno Cornec, 15 years ago
Tries to add support for bzip2 and lzma initramfs (preliminary, not tested) for 2.6.30
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 105.1 KB

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

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

Download in other formats: