Context Navigation

mindi@ 1842

Visit:

Last change on this file since 1842 was 1842, checked in by Bruno Cornec, 16 years ago

Fix lack of /etc/raidtab at restore rime in the right place
Adds support for nls_utf8 and pata_serverworks Patches from Dirk Husung (husung_at_tu-harburg.de)
Add efibootmgr to deplist.txt in order to be able to modify EFI menu at restore time on ia64
Usage of the new testver param of pb 0.8.12 to deliver 2.2.5 packages in a test dir.
Update pbcl files for upcoming delivery of 2.2.5
Fix an issue on parted output (K instead of KB) in parted2fdisk at restore time
Adds support for alb/aft types of bonding on Intel cards (Mark Pinkerton <Mark.Pinkerton_at_emageon.com>)
Escape variables in a perl script like mindi-bkphw
Better Proliant support at restore time now.
Fix a label bug where the variable label should also be re-initialized at each loop
start-nfs should NOT do exit => kernel panix as init exits
some other fixes for init on denymods
Adds boot options denymods (for udev) and forcemods (if not udev)
kqemu is denied. Probably should also be done for kvm stuff
Fix again the bug on modules link at root of the initrd. Hopefully for good.
Wait more around the USB CD emulated by iLO as it takes up to 5 seconds to come up
Attempt to fix udev support for RHEL 5.1
Better support for automatic iLO Virtual Media with udev
Some VMWare support improvements (however, it seems that VMWare support won't be possible anytime soon)
during init at restore time, copy all static evices availble for udev, as some distro implementation are no

t yet supported correctly for udev. Not very elegant, but should solve our current issues

Fedora 8 now supported as a build target for pb
svn.log removed.
dependencies reviewd for rhel_3
Attempt to fix the lack of modules loaded at restore time - especially fs device drivers
removes bkphw dir before potential creation
render mount command more vebose at restore time
Should fix #217
Increase BOOT_SIZE and EXTRA_SIZE to support features such as HW recovery
Handles udev.files files which could be symlinks
Improve udev support for distro with compressed modules (mdv e.g.)
Fix modules.dep copy
/sbin/pam_console_apply is needed by mdv udev conf
Adds support for nohw boot option to avoid re-setuping the HW conf
Improved support for Proliant on cpqacuxe
RstHW should be called after driver initialization
For debian/ubuntu mindi dpends on mindi-busybox
Update mindi-busybox pbcl for correct debian changelog generation, and up2date infos
Should fix #215
Fix #214 (Thanks to xdelaruelle)
Fix again svn.log not used anymore with new pb version
Adaptation of build process to upcoming 0.8.12 version of pb
Remove MONOTONIC clock to continue to support 2.4 kernels (RHEL 3 e.g. or ESX)
Attempt to solve ia64 BMC access through the serial port
parted2fdisk binary no more generated
do not require perl modules (strict.pm) at restore time
try to avoid modprobe messages at restore time
on ia64 now use the perl script parted2fdisk at retore time also
Also modprobe modules for udev after decompressing the additional ones
replace gzip -v9 by gzip -c9. Fix a bug at least on ia64
For all modules supported, create symlinks under the mountpoint and extract dev files as some are not automat ically created at the moment
Support /vmfs/volumes for ESX
Finally do not use vdf for ESX. Only creates issues.
Avoids continuing hw support if no product name found
Improves ia64 support for bootable image build
Fix a potential problem with ramdisk_blocksize param
MAKEDEV should also be included in deplist.txt
More fixes for udev support for Debian
Do not mount /boot if it's already mounted - avoids ESX hang
Fix NICs renumbering on Debian at least
Udev startup improvement to support iLO + NFS so modprobing all modules seems required as of now
Update to version 1.7.3 of busybox for pb
Load USB earlier in order to support KBD such as with iLO
Do busybox ldd first in order to create a potential /lib64 link correctly and then use it later in the image
Use variable DF in mindi to be able to support the ESX vdf
Fix mindi for Debian x86_64 where /lib64 is a link
Fix issue at restore time for ext2fs params not reused (Fix from Klaus Ade Johnstad <klaus_at_skolelinux.no>)
Do not copy udev files if they do not exist In udev case do not insert modules at all (udev should do it alone) May avoid the issue with rhel4.5 kernel ? To be tested
Update dependencies for rpm base build as well
And also perl is a debian/ubuntu dep
Better debian/ubuntu dependecies requirements (mtools)
Fix modes on mindi-bkphw (Thanks Phil Walker phil.walker_at_hp.com)
Complete rev [1771] for upper case RESTORE cli with syslinux as well
Update mindi-busybox to 1.7.3
Use RESTORE consistently across mondo to restore without interaction (report from Takeshi Shoji t.shoji_at_tripodw.jp)

(merge -r1769:1841 $SVN_M/branches/2.2.5)

Property svn:keywords set to Rev Id

File size: 115.1 KB

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

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

Context Navigation

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

Download in other formats: