Context Navigation

source: MondoRescue/branches/2.2.9/mindi/mindi@ 2190

Visit:

Last change on this file since 2190 was 2190, checked in by Bruno Cornec, 15 years ago
Fix lack of formating (discovered by the new Mandriva build process, and adopted here as well as it's good practice).
Property svn:keywords set to `Rev Id`
File size: 104.1 KB

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

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

Download in other formats: