Context Navigation

source: MondoRescue/branches/2.2.10/mindi/mindi@ 2291

Visit:

Last change on this file since 2291 was 2291, checked in by Bruno Cornec, 15 years ago

Fix a printing error in mindi for the tar command
Fix all mr_asprintf which had no second param as a string

(report bug fix done originaly in 2.2.9)

Property svn:executable set to *
Property svn:keywords set to Rev Id

File size: 104.2 KB

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

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

Download in other formats: