Context Navigation

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

Visit:

Last change on this file since 2691 was 2691, checked in by Bruno Cornec, 13 years ago
Boot size pushed to 20MB
Property svn:executable set to ``* Property svn:keywords set to `Rev Id`
File size: 111.9 KB

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

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

Download in other formats: