Context Navigation

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

Visit:

Last change on this file since 2584 was 2584, checked in by Bruno Cornec, 14 years ago
Adds a missing module for iSCSI support
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 107.9 KB

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

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

Download in other formats: