Context Navigation

source: MondoRescue/branches/2.2.10/mindi/mindi@ 2589

Visit:

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

r3721@localhost: bruno | 2010-03-09 22:59:21 +0100

Fix a printing issue on screen during modules analyze

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

File size: 94.6 KB

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

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

Download in other formats: