Context Navigation

source: MondoRescue/branches/2.2.5/mindi/mindi@ 1865

Visit:

Last change on this file since 1865 was 1865, checked in by Bruno Cornec, 16 years ago
Now also fixes when not swap :-)
Property svn:keywords set to `Rev Id`
File size: 126.1 KB

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

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

Download in other formats: