Context Navigation

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

Visit:

Last change on this file since 1337 was 1337, checked in by Bruno Cornec, 17 years ago
DidMondoCallme is gone (usage of MONDO_SHARE instead) mindi log file only added to mondo logfile when useful (for --custom not for other options)
Property svn:keywords set to `Rev Id`
File size: 113.7 KB

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

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

Download in other formats: