Context Navigation

source: MondoRescue/branches/stable/mindi/mindi@ 1904

Visit:

Last change on this file since 1904 was 1904, checked in by Bruno Cornec, 16 years ago
merge -r 1889:1902 svn+ssh://bruno@svn.mondorescue.org/mondo/svn/mondorescue/branches/2.2.6
Property svn:keywords set to `Rev Id`
File size: 108.6 KB

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

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

Download in other formats: