Context Navigation

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

Visit:

Last change on this file since 2410 was 2410, checked in by Bruno Cornec, 15 years ago
Better list of mandatory tools Adds fuse and sshfs support in initrd
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 105.3 KB

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

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

Download in other formats: