Context Navigation

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

Visit:

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

r3744@localhost: bruno | 2010-03-16 01:44:33 +0100

Fix a bug on Mandriva modules analysis (at least) (Backport from mindi 2.1.0)

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

File size: 107.7 KB

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

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

Download in other formats: