Context Navigation

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

Visit:

Last change on this file since 1312 was 1312, checked in by Bruno Cornec, 17 years ago
Suppress losetup usage in start-nfs (unreliable and doesn't work with QEMU)
Property svn:keywords set to `Rev Id`
File size: 113.5 KB

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

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

Download in other formats: