Context Navigation

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

Visit:

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

r3783@localhost: bruno | 2010-04-11 11:57:27 +0200

Use MINDI_CACHE for temp file communication between archive/restore
Remove some now useless globals in mondo
Remove function get_cfg_file_from_archive_or_bust and get_cfg_file_from_archive
Adds function get_cfg_file_from_initrd (Not finished)
Recovery doesn't work in that version atm (checkpoint version)

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

File size: 93.9 KB

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

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

Download in other formats: