Context Navigation

source: MondoRescue/branches/2.2.8/mindi/mindi@ 2056

Visit:

Last change on this file since 2056 was 2056, checked in by Bruno Cornec, 16 years ago
Use option -s of syslinux in case in improve stuff (still potential pb of FAT32)
Property svn:keywords set to `Rev Id`
File size: 100.8 KB

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

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

Download in other formats: