Context Navigation

source: MondoRescue/branches/2.2.2/mindi/mindi@ 1282

Visit:

Last change on this file since 1282 was 1282, checked in by Bruno Cornec, 17 years ago
Fix a bug for FC6 where the boot disk size was again insufficient (Rene.Rabaud_at_free.fr) BOOT_SIZE is now the parameter used globally to declare the size of the boot "floppy" put on the CD (as well as for ia64)
Property svn:keywords set to `Rev Id`
File size: 112.2 KB

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

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

Download in other formats: