Context Navigation

mindi@ 1663

Visit:

Last change on this file since 1663 was 1663, checked in by Bruno Cornec, 17 years ago

Fix bug #197 (based on an initial patch of Scott Cummings)
Fix a bug where df was using locale to print messages and wasn't filtered correctly
mkdtemp checked in configure
reset_bkpinfo called as early as possible by both main program.
It creates a tmpdir cleanly with mkdtemp in setup_tmpdir subfunction, which takes in account TMPIR and TMP env var. Remains to see what tmpfs does and tests
configure.in should also be filtered.
Remove g_bkpinfo_DONTUSETHIS
remove bkpinfo also from header files
Render bkpinfo global (potential issue on thread, but should not be a problem as that structure is indeed static during archive)
Apply patch from Andree Leidenfrost, modified a bit to use bkpinfo->tmpdir instead of /tmp or MINDI_CACHE when appropriate. Fix security issues in mondo. Thanks al ot Andree for catching all those issues.
/tmp => /var/log for mondorestore.log in mindi
Update linux terminfo to fix a color issue (Andree Leidenfrost)
Removes useless log file (Andree Leidenfrost)
replace vi with find_my_editor during restore (Andree Leidenfrost)
sync in bg in mindi (VMWare issue to look at)
mindi/mindi-busybox have a different version than mondo for pb
PB-SUF also added to spec file
Fix a bug for pb build (omission of PB-SUF declaration)

(merge -r1631:1662 $SVN_M/branches/2.2.5)

Property svn:keywords set to Rev Id

File size: 110.3 KB

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

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

Context Navigation

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

Download in other formats: