Context Navigation

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

Visit:

Last change on this file since 1581 was 1581, checked in by Bruno Cornec, 17 years ago
Continue to remove floppy support
Property svn:keywords set to `Rev Id`
File size: 110.3 KB

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

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

Download in other formats: