Context Navigation

source: MondoRescue/branches/2.2.8/mindi/mindi@ 2072

Visit:

Last change on this file since 2072 was 2072, checked in by Bruno Cornec, 15 years ago
Adds multipath support (as exists on RHEL 5.2) analyze-my-lvm/mindi uses the /dev/mapper/mpath... entry and not /dev/dm-... entry which is not automatically created at restore time Lots of mapth dmsetup commands added to deplist Adds required modules to mindi Fix a bug for this in mindi around real devices with /dev/mapper/mpath... names init has a new StartMpath function to start multipath correctly hopefully mondorestore has a new clean_multiconf function which removes /var/lib/multipath/bindings and edits /etc/multipath.conf if needed
Property svn:keywords set to `Rev Id`
File size: 101.3 KB

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

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

Download in other formats: