Context Navigation

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

Visit:

Last change on this file since 2754 was 2754, checked in by Bruno Cornec, 13 years ago
Arch Linux support for boot message of mindi (mc_at_carreira.com.pt) using /etc/arch-release and pacman.log
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 112.8 KB

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

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

Download in other formats: