source: MondoRescue/branches/stable/mindi/mindi@ 1903

Last change on this file since 1903 was 1903, checked in by Bruno Cornec, 16 years ago

merge -r 1842:1889 2.2.5
  • Property svn:keywords set to Rev Id
File size: 116.6 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1903 2008-04-09 23:13:58Z 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)
16ARCH=`/bin/uname -m`
17
18#RUN_AFTER_INITIAL_BOOT_PHASE="echo \"Who lives in a pineapple under the sea?\" > /tmp/spongebob.squarepants.txt"
19 # after booting from image/CD but before
20 # accessing auxiliary data disks (or the rest of
21 # the CD), the initscript will run the above command.
22
23RUN_AFTER_BOOT_PHASE_COMPLETE="ide-opt"
24 # after the emergency boot process is complete but
25 # before the init script runs mondorestore, it will
26 # run this command.
27
28MINDI_REV=PBREV
29MINDI_VER=PBVER
30
31MINDI_VERSION=${MINDI_VER}-r$MINDI_REV
32MINDI_PREFIX=XXX
33MINDI_CONF=YYY
34MINDI_SBIN=${MINDI_PREFIX}/sbin
35MINDI_LIB=LLL
36
37MINDI_CONFIG_DIST="$MINDI_CONF/mindi.conf.dist"
38if [ ! -f $MINDI_CONFIG_DIST ]; then
39 echo "Unable to find $MINDI_CONFIG_DIST. Please reinstall mindi"
40 exit -1
41fi
42md5sum --status -c "$MINDI_CONF/mindi.conf.dist.md5"
43if [ $? -ne 0 ]; then
44 echo "$MINDI_CONF/mindi.conf.dist md5 checksum incorrect. Please reinstall mindi"
45 exit -1
46fi
47. $MINDI_CONFIG_DIST
48
49MINDI_CONFIG="$MINDI_CONF/mindi.conf"
50if [ ! -f $MINDI_CONFIG ] && [ "_$1" = "_" ]; then
51 echo "No $MINDI_CONFIG file found using sensible values from $MINDI_CONFIG_DIST"
52else
53 if [ "_$1" = "_" ]; then
54 echo "Using $MINDI_CONFIG as additional config file to $MINDI_CONFIG_DIST"
55 fi
56 . $MINDI_CONFIG
57fi
58
59#
60# Manages defaults coming from conf files
61#
62INTERACTIVE="$mindi_interactive"
63
64if [ "$INTERACTIVE" = "yes" ]; then
65 # Ask if you want to make a CD Image to be written?
66 # if this is set to 'no', then the image will be created automatically
67 PROMPT_MAKE_CD_IMAGE="yes"
68
69 # Ask if you want to make a USB Image to be written?
70 # if this is set to 'no', then the image will be created automatically
71 PROMPT_MAKE_USB_IMAGE="yes"
72
73 # If set to "no", you will be prompted for whether or not
74 # you want to use your own kernel, or the supplied default.
75 # If "yes" mindi will automatically use your own kernel.
76 USE_OWN_KERNEL="no"
77fi
78
79EXTRA_SPACE=$mindi_extra_space
80MAX_DISKS=$mindi_max_disks
81BOOT_SIZE=$mindi_boot_size
82DEPLIST_DIR="$MINDI_CONF/deplist.d"
83DEPLIST_FILE="$MINDI_CONF/$mindi_deplist_file"
84PROMPT_MAKE_CD_IMAGE="$mindi_write_cd"
85PROMPT_MAKE_USB_IMAGE="$mindi_write_usb"
86PROMPT_MAKE_TAPE_IMAGE="$mindi_write_tape"
87USE_OWN_KERNEL="$mindi_use_own_kernel"
88MINDI_CACHE="$mindi_cache_dir"
89TMPDIR="$mindi_tmp_dir"
90USBDEVICE="$mindi_usb_device"
91TAPEDEV="$mindi_tape_device"
92ADDITIONAL_BOOT_PARAMS="$mindi_boot_params"
93MY_FSTAB="$mindi_etc_fstab"
94LOGFILE="$mindi_log_file"
95TAPE_MODS="$mindi_tape_mods"
96SCSI_MODS="$mindi_scsi_mods"
97IDE_MODS="$mindi_ide_mods"
98PCMCIA_MODS="$mindi_pcmcia_mods"
99USB_MODS="$mindi_usb_mods"
100CDROM_MODS="$TAPE_MODS $IDE_MODS $mindi_cdrom_mods $USB_MODS $PCMCIA_MODS"
101NET_MODS="$mindi_net_mods"
102# BERLIOS: Handle the case where all is passed (cloning mode)
103EXTRA_MODS="$CDROM_MODS $mindi_extra_mods $mindi_additional_mods"
104DENY_MODS="$mindi_deny_mods"
105FORCE_MODS="$mindi_force_mods"
106ISO_CMD="$mr_iso_creation_cmd"
107ISO_OPT="$mr_iso_creation_opt"
108
109BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
110FDISK=$MINDI_SBIN/parted2fdisk
111
112# Now we can create what we need
113export MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
114
115# ----------------------------------------------------------------------------
116
117
118AbortHere() {
119 [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
120 Die "Program is terminating in response to signal received from OS/user"
121}
122
123
124HackSyslinuxFile() {
125 local incoming
126 incoming=`ReadLine`
127 while [ "$incoming" ] ; do
128 echo -en "$incoming" | sed s/24000/$1/
129 if [ "`echo "$incoming" | grep append`" ] ; then
130 echo -en " $ADDITIONAL_BOOT_PARAMS"
131 fi
132 echo -en "\n"
133 incoming=`ReadLine`
134 done
135 if [ -e "$MINDI_LIB/memtest.img" ] ; then
136 echo -en "label memtest\n kernel memdisk\n append initrd=memtest.img\n\n"
137 fi
138}
139
140
141Aborted() {
142 trap SIGHUP SIGTERM SIGTRAP SIGINT
143 [ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindi*img $MINDI_CACHE/*gz $MINDI_CACHE/mindi.iso
144 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
145 Die "User abort."
146}
147
148
149AddFileToDir() {
150 local filename minidir_root noof_disks diskno res filesize would_occupy zipsize complevel cutoff compressed_fname siz
151 filename=$1
152 minidir_root=$2
153 noof_disks=$3
154
155 diskno=$noof_disks
156 mkdir -p $minidir_root/$diskno
157 [ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
158 if [ ! -e "$filename" ] ; then
159 if [ -h "$filename" ] ; then
160 cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
161 return $noof_disks
162 else
163 Die "AddFileToDir asked me to add $filename, which does not exist. Oops! Did you run out of disk space or is your Linux distro severely broken?"
164 fi
165 fi
166
167 # move to the disk that has room on it (or end up using the last, if all full)
168 while [ "$diskno" -lt $MAX_DISKS ] ; do
169 mkdir -p $minidir_root/$diskno
170 filesize=`du -sk $filename | cut -f1`
171 cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
172 if [ "$filesize" -le "4" ] ; then
173 siz=$filesize
174 elif [ ! -f "$filename" ] ; then
175 siz=0
176 else
177 siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt | cut -f1`
178 [ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
179 siz=$(($siz-2));# to allow for sectors & the fact that they round up
180 fi
181 [ ! "$siz" ] && siz=4
182 [ "$siz" -lt "0" ] && siz=0
183 LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
184 [ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
185 echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
186 LAST_COMPRESSED_SIZE=0
187 rm -f $minidir_root/$diskno/$filename
188 diskno=$(($diskno+1))
189 done
190 return 0 ; # failed
191}
192
193
194AddKeyboardMappingFile() {
195 local mappath r included_list included_item i res ii sss
196 mappath=$1
197 KBDEPTH=$(($KBDEPTH+1))
198 [ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
199 if [ -e "$bigdir/$mappath" ] ; then
200 echo "$mappath already added" >> $LOGFILE
201 return
202 elif [ -d "$bigdir/$mappath" ] ; then
203 echo "Cannot add $mappath: it's a directory. Sorry."
204 return
205 fi
206 echo "Added kbd map $mappath" >> $LOGFILE
207 if [ ! -e "$mappath" ] ; then
208 mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
209 if [ ! -e "$mappath" ] ; then
210 LogIt "Cannot add $mappath: kbd map file not found"
211 return
212 fi
213 else
214 echo -en "`basename $mappath | tr '.' '#' | sed s/#kmap#gz// | sed s/#inc#gz//` " | tr '#' '.'
215 fi
216
217 mkdir -p $bigdir/etc
218 cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE || LogIt "AKMF -- Could not copy $mappath to $bigdir"
219 if [ "`echo $mappath | grep -F ".gz"`" ] ; then
220 included_list=`gzip -dc $mappath | grep -Fi include | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
221 else
222 included_list=`grep -Fi include $mappath | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
223 fi
224 for included_item in $included_list ; do
225 if [ ! -e "$included_item" ] ; then
226 sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
227 [ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
228 for ii in $sss ; do
229 [ -e "$ii" ] && AddKeyboardMappingFile $ii
230 done
231 else
232 AddKeyboardMappingFile $included_item
233 fi
234 done
235}
236
237
238ChopUpAndCopyFile() {
239 local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
240 filename=$1
241 outdir=$2
242 slicesize=$3
243 biggienumber=$4
244
245 [ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
246 mkdir -p $outdir
247
248 sliceno=0
249 scratchfile=$MINDI_TMP/blah.$$.dat
250 cp -f $filename $scratchfile 2>> $LOGFILE || Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
251 [ "`head $scratchfile -n1 | grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
252 [ "`echo "$filename" | grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
253 if [ "`echo "$filename" | grep -F "lib/modules/" | grep "\.*o\.gz"`" != "" ] ; then
254 mv $scratchfile $scratchfile.gz
255 gunzip -f $scratchfile || LogIt "Cannot gunzip $scratchfile.gz"
256 filename=`echo "$filename" | tr '.' '#' | sed s/#o#gz/#o/ | sed s/#ko#gz/#ko/ | tr '#' '.'`
257 fi
258 filesize=`du -sk $scratchfile | cut -f1`
259 noof_slices=$(($filesize/$slicesize))
260 echo "$filename" > $outdir/slice-$biggienumber.name
261 echo "$filesize" > $outdir/slice-$biggienumber.size
262 [ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
263 while [ "$sliceno" -le "$noof_slices" ] ; do
264 dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
265 sliceno=$(($sliceno+1))
266 done
267 rm -f $scratchfile
268}
269
270
271CopyBootBFile() {
272 local copy_to copy_from possible_locations liloc
273 copy_to=$1
274 copy_from=/boot/boot.b
275 liloc=`which lilo.real 2>/dev/null`
276 [ $liloc ] || liloc=`which lilo 2>/dev/null`
277 if [ $liloc ]; then
278 if ! [ `strings $liloc | grep "boot\.b"` ]; then
279 LogIt "boot.b files built into lilo; I'll create a dummy."
280 > $copy_to
281 return 0
282 fi
283 fi
284 if [ ! -f "$copy_from" ] ; then
285 LogIt "OK, you don't have a /boot/boot.b file, which is odd because\n most _good_ Linux distributions come with one, even if it's only a softlink"
286 copy_from=`grep install= /etc/lilo.conf | grep "\.b" | cut -d'=' -f2`
287 if [ ! -f "$copy_from" ] ; then
288 LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
289 copy_from=`FindSensibleBootBFile`
290 LogIt "I'm going to use '$copy_from'"
291 fi
292 fi
293 cp -f $copy_from $copy_to 2>> $LOGFILE || LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
294}
295
296
297CopyDependenciesToDirectory() {
298 local outdir incoming fname filesize counter d found
299 outdir=$1
300 mkdir -p $outdir
301 incoming=`ReadLine`
302 counter=0
303 while [ "$incoming" != "" ] ; do
304 # Non absolute file names should not arrive till here => skipped
305 if [ `echo "$incoming" | cut -c1` != '/' ]; then
306 LogIt "Unable to handle $incoming"
307 incoming=`ReadLine`
308 continue
309 fi
310 # no parent directory of incoming should be a link, copy is not possible in that case
311 d=`dirname "$incoming"`
312 found="false"
313 while [ $d != "/" -a $found = "false" ]; do
314 [ -h "$d" ] && found="true"
315 d=`dirname "$d"`
316 done
317 if [ -d "$incoming" ] && [ ! -h "$incoming" ]; then
318 find $incoming/* -maxdepth 0 2> /dev/null | CopyDependenciesToDirectory $outdir
319 elif [ -e "$incoming" ] && [ $found = "false" ]; then
320 filesize=`du -sk $incoming | cut -f1`
321 if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
322 ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
323 BIGNO=$(($BIGNO+1))
324 else
325 cp --parents -Rdf $incoming $outdir 2> /dev/null || Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
326 if [ "`echo "$incoming" | grep "lib/modules/.*\..*o\.gz"`" != "" ] ; then
327 gunzip -f $outdir/$incoming || LogIt "Cannot gunzip $outdir/$incoming"
328 fi
329 [ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
330 fi
331 counter=$(($counter+1))
332 if [ "$counter" -ge "5" ] ; then
333 counter=0
334 echo -en "."
335 fi
336 fi
337 incoming=`ReadLine`
338 done
339}
340
341
342CopyImageToDisk() {
343 local image dev procno res comment
344 image=$1
345 dev=$2
346 comment=$3
347 [ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
348 Prompt "About to write $comment. Please press ENTER."
349 echo -en "Formatting disk..."
350 if which fdformat > /dev/null ; then
351 fdformat -n $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
352 elif which superformat > /dev/null ; then
353 superformat $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
354 else
355 Die "Please install either fdformat or superformat."
356 fi
357 echo -en "\nWriting $comment"
358 if echo $image | grep "mindi-[r|b]oot\.1440" &> /dev/null ; then
359 cat $image > $dev &
360 else
361 dd if=$image of=$dev &> /dev/null &
362 fi
363 procno=$!
364 ps $procno > /dev/null 2> /dev/null
365 while [ "$?" -eq "0" ] ; do
366 sleep 3
367 echo -en "."
368 ps $procno > /dev/null 2> /dev/null
369 done
370 echo -e "$DONE"
371 LogIt "$comment has been written."
372}
373
374
375CountItemsIn() {
376 local r
377 r=0
378 for q in $1 ; do
379 r=$(($r+1))
380 done
381 echo $r
382}
383
384
385CreateDataDiskImagesFromTarballs() {
386 local tardir outdir diskno noof_disks kp
387 tardir=$1
388 outdir=$2
389 noof_disks=$3
390
391 mkdir -p $outdir
392 diskno=1
393 echo -en "Creating data disk "
394 while [ "$diskno" -le "$noof_disks" ] ; do
395 echo -en "#$diskno..."
396 cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE || LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
397 CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
398 diskno=$(($diskno+1))
399 done
400 mv -f $tardir/all.tar.gz $outdir
401 du -sk $outdir/*gz >> $LOGFILE
402 echo -e "$DONE"
403}
404
405
406
407CreateOneDataDiskImage() {
408 local tarball imagefile dev diskno noof_disks mountpoint
409 tarball=$1
410 imagefile=$2
411 diskno=$3
412 noof_disks=$4
413
414 mountpoint=$MINDI_TMP/mountpoint.$$
415 mkdir -p $mountpoint
416 dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null || LogIt "Cannot dd (CODI)"
417 echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
418 mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE || Die "Unable to create an ext2 file system on $imagefile"
419 mount -t ext2 -o loop $imagefile $mountpoint || Die "Can't loopmount $imagefile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
420 mv $tarball $mountpoint/
421 if [ "$?" -ne "0" ] ; then
422 umount $mountpoint
423 rmdir $mountpoint
424 Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
425 fi
426 [ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
427 umount $mountpoint || LogIt "Cannot umount (CODI)"
428 rmdir $mountpoint || LogIt "Cannot rmdir (CODI)"
429}
430
431
432# Last function called before exiting
433# Parameter is exit code value
434MindiExit() {
435 local my_partitions
436
437 echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
438 echo "End date : `date`" >> $LOGFILE
439 if [ _"$MONDO_SHARE" != _"" ] ; then
440 echo "------------- mindi logfile included -------------------------" >> /var/log/mondoarchive.log
441 cat $LOGFILE >> /var/log/mondoarchive.log
442 echo "--------------------------------------------------------------">> /var/log/mondoarchive.log
443 fi
444
445 cd /
446 sync&
447
448 # Unmount what could remain mounted
449 my_partitions=`mount | grep -F $$ | cut -f1 -d' '`
450 [ "$my_partitions" != "" ] && umount $my_partitions
451 # Clean temporary files only when standalone mindi
452 if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
453 rm -Rf $MINDI_TMP
454 fi
455 exit $1
456}
457
458Die() {
459 local i
460 if [ "$1" = "" ] ; then
461 LogIt "FATAL ERROR"
462 else
463 LogIt "FATAL ERROR. $1"
464 fi
465
466 LogIt "Please e-mail a copy of $LOGFILE to the mailing list."
467 LogIt "See http://www.mondorescue.org for more information."
468 LogIt "WE CANNOT HELP unless you enclose that file.\n"
469 MindiExit -1
470}
471
472
473DropOptimizedLibraries() {
474 local outdir filelist list_of_optimized_libraries optimized_lib_name vanilla_lib_name reason msg resolved res
475 filelist=$1
476 outdir=$2
477
478 list_of_optimized_libraries=`grep "lib/i[5-7]86/" $filelist`
479 if [ "$list_of_optimized_libraries" = "" ] ; then
480 return 0
481 fi
482 echo -en "Dropping i686-optimized libraries if appropriate"
483 for optimized_lib_name in $list_of_optimized_libraries ; do
484 echo -en "."
485 reason=""
486 vanilla_lib_name=`echo "$optimized_lib_name" | sed -e 's/i[5-7]86//' -e 's/cmov//' -e 's/nosegneg//' | tr -s '/' '/'`
487 echo "$vanilla_lib_name" >> $filelist
488 resolved=$vanilla_lib_name
489 echo "Adding $resolved to filelist" >> $LOGFILE
490 resolved=`ReadAllLink $resolved`
491 echo "Adding $resolved to filelist" >> $LOGFILE
492 mkdir -p $outdir$optimized_lib_name > /dev/null 2> /dev/null
493 rmdir $outdir$optimized_lib_name > /dev/null 2> /dev/null
494 ln -sf $vanilla_lib_name $outdir$optimized_lib_name
495 echo "Excluding $optimized_lib_name" >> $LOGFILE
496 grep -Fvx "$optimized_lib_name" "$filelist" > $filelist.tmp
497 echo "Replacing it with $vanilla_lib_name" >> $LOGFILE
498 echo "$vanilla_lib_name" >> $filelist.tmp
499 mv -f $filelist.tmp $filelist
500 done
501 $AWK '{ print $1; }' $filelist | sort -u > $filelist.tmp
502 mv -f $filelist.tmp $filelist
503 echo -e "$DONE"
504}
505
506
507FindAndAddUserKeyboardMappingFile() {
508 local r res mapfile mappath included_item included_list keyfile mp locale
509 LogIt "Analyzing your keyboard's configuration."
510 KEYDIR=/lib/kbd
511 [ ! -e "$KEYDIR" ] && KEYDIR=/usr/share/kbd # Slackware
512 [ ! -e "$KEYDIR" ] && KEYDIR=/usr/lib/kbd
513 [ ! -e "$KEYDIR" ] && KEYDIR=/usr/share
514 [ ! -e "$KEYDIR" ] && KEYDIR=/etc/condole
515 [ ! -e "$KEYDIR" ] && KEYDIR=/etc/condole-setup
516 if [ ! -e "$KEYDIR" ] ; then
517 LogIt "Keyboard mapping directory not found. I shall use default map at boot-time."
518 return 0
519 fi
520 if [ -e "/etc/sysconfig/keyboard" ] ; then
521 echo "Red Hat-style config detected." >> $LOGFILE
522 keyfile=/etc/sysconfig/keyboard
523 elif [ -e "/etc/rc.d/rc.keymap" ] ; then
524 echo "Slackware-style config detected." >> $LOGFILE
525 keyfile=/etc/rc.d/rc.keymap
526 elif [ -e "/etc/rc.config" ] ; then
527 echo "Debian-style config detected." >> $LOGFILE
528 keyfile=/etc/rc.config
529 elif [ -e "/etc/console/boottime.kmap.gz" ] ; then
530 echo "Debian-style config detected." >> $LOGFILE
531 echo -en "Adding the following keyboard mapping tables: "
532 mkdir -p $bigdir/tmp
533 echo "keymap-lives-here=/etc/console/boottime.kmap.gz" >> $MINDI_TMP/mondo-restore.cfg
534 KBDEPTH=0
535 mkdir -p $bigdir/etc/console
536 cp /etc/console/boottime.kmap.gz $bigdir/etc/console 2>> $LOGFILE
537 echo -e "$DONE"
538 return 0
539 elif [ -e "/etc/console-setup/boottime.kmap.gz" ] ; then
540 echo "Ubuntu-style config detected." >> $LOGFILE
541 echo -en "Adding the following keyboard mapping tables: "
542 mkdir -p $bigdir/tmp
543 echo "/etc/console-setup/boottime.kmap.gz" > $bigdir/tmp/KEYMAP-LIVES-HERE
544 KBDEPTH=0
545 mkdir -p $bigdir/etc/console-setup
546 cp /etc/console-setup/boottime.kmap.gz $bigdir/etc/console-setup 2>> $LOGFILE
547 echo -e "$DONE"
548 return 0
549 elif [ -e "/etc/conf.d/keymaps" ] ; then
550 echo "Gentoo-style config detected." >> $LOGFILE
551 keyfile=/etc/conf.d/keymaps
552 else
553 echo -en "Searching for rc.config ..."
554 keyfile=`find /etc -name rc.config | head -n1`
555 if [ "$keyfile" = "" ] || [ ! -e "$keyfile" ] ; then
556 LogIt "Unknown config detected. Default keyboard map will be used."
557 return
558 else
559 echo "Found $keyfile" >> $LOGFILE
560 fi
561 fi
562 if [ ! -e "$KEYDIR/keymaps" ] ; then
563 LogIt "Keyboard mapping directory not found. Default keyboard map will be used."
564 return
565 fi
566 echo "keyfile=$keyfile" >> $LOGFILE
567 locale=`grep -F KEYTABLE "$keyfile" | tr -d '"' |cut -d'=' -f2`
568 [ ! "$locale" ] && locale=`grep '.map$' "$keyfile" | sed 's/^.* //'` # Slackware
569 [ ! "$locale" ] && locale=`grep -E '^KEYMAP=' "$keyfile" | tr -d '"' |cut -d'=' -f2` # Gentoo
570 echo "locale=$locale" >> $LOGFILE
571 #
572 # Process the keymaps dir once for all
573 # AddKeyboardMappingFile will use it recursively
574 #
575 find $KEYDIR/keymaps > $MINDI_TMP/keymaps.find
576 mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep -F "/${locale}." | grep -vx " *#.*"`
577 [ ! "$mp" ] && mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
578 # If we have multiple keymaps then log it !!
579 echo "$mp" | grep -q " "
580 if [ $? -eq 0 ]; then
581 echo "WARNING: Multiple keymaps found: $mp" | tee -a $LOGFILE
582 echo "The following one will be used" >> $LOGFILE
583 fi
584 for i in $mp ; do
585 mappath=$i
586 [ -e "$i" ] && [ ! -d "$i" ] && break
587 done
588 if [ ! -e "$mappath" ] || [ -d "$mappath" ] ; then
589 mappath=$(find / -name "*/kbd/keymaps/*/$locale")
590 fi
591 echo "mappath = $mappath" >> $LOGFILE
592 if [ ! -e "$mappath" ] || [ -d "$mappath" ] ; then
593 LogIt "Keyboard mapping file not found. Default keyboard map will be used."
594 return
595 fi
596 echo -en "Adding the following keyboard mapping tables: "
597 mkdir -p $bigdir/tmp
598 echo "keymap-lives-here=$mappath" >> $MINDI_TMP/mondo-restore.cfg
599 KBDEPTH=0
600 AddKeyboardMappingFile $mappath
601 echo -e "$DONE"
602 rm -f $MINDI_TMP/keymaps.find
603 return 0
604}
605
606
607FindIsolinuxBinary() {
608 ISOLINUX=/usr/lib/isolinux.bin
609 [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib/syslinux/isolinux.bin
610 [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib64/syslinux/isolinux.bin
611 [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/syslinux/isolinux.bin
612 [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib/syslinux/isolinux.bin
613 [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib64/syslinux/isolinux.bin
614 [ ! -e "$ISOLINUX" ] && ISOLINUX=`find / -name isolinux.bin | grep -x "/.*/isolinux.bin"`
615 [ ! -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'"
616 echo "Found isolinux.bin at $ISOLINUX" >> $LOGFILE
617}
618
619
620FindLiloBinary() {
621 if which lilo &> /dev/null ; then
622 if which lilo.real > /dev/null 2> /dev/null ; then
623 LILO_EXE=lilo.real
624 LogIt "lilo.real found; will be used instead of lilo (*grumble* *mutter*)"
625 else
626 LILO_EXE=lilo
627 fi
628 $LILO_EXE -V | grep -F "21.6" > /dev/null && Die "Please upgrade LILO. Your version has a serious bug. If you're not _using_ LILO, fine, uninstall it. :)"
629 else
630 LILO_EXE=`which false`
631 fi
632}
633
634
635FindSensibleBootBFile() {
636 local i out last
637 out=""
638 last=""
639 for i in `find /boot -type f | grep -v chain | grep -v os2 | sort -u` ; do
640 if [ "`strings $i 2> /dev/null | head -n1`" = "LILO" ] ; then
641 out="$out $i"
642 last="$i"
643 fi
644 done
645 echo "$last"
646}
647
648
649FindSpecificModuleInPath() {
650 local modpaths pwd line
651 pwd=`pwd`
652 if [ "$YOUR_KERNEL_SUCKS" ] ; then
653 cd $MINDI_TMP
654 else
655 cd /
656 fi
657 if [ ! -e "$1" ] ; then
658 LogIt "WARNING - cannot search specific path '$1'"
659 return 1
660 fi
661 modpaths=`find $1 -name $2.*o -type f`
662 #[ "$?" -ne "0" ] && Die "find $1 -name $2.o -type f --- failed"
663 [ "$modpaths" = "" ] && modpaths=`find $1 -name $2.o.gz -type f`
664 [ "$modpaths" = "" ] && modpaths=`find $1 -name $2.ko.gz -type f`
665 [ "$modpaths" = "" ] && modpaths=`find $1 -name $2 -type f`
666 echo "$modpaths"
667 cd $pwd
668}
669
670
671GenerateGiantDependencyList() {
672 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
673
674 echo -en "Analyzing dependency requirements"
675 outfile=$1
676 tempfile=$MINDI_TMP/$$.txt
677 incoming=`ReadLine`
678
679 > $tempfile
680 progress=0
681 res=0
682 noof_lines=$2
683 while [ "$incoming" != "" ] ; do
684 if echo "$incoming" | grep -x " *#.*" &> /dev/null ; then
685 incoming=`ReadLine`
686 continue
687 fi
688 if [ "$incoming" = "LVMFILES:" ] ; then
689 break
690 fi
691 filelist=`GenerateListForFile "$incoming"`
692 r=$?
693 [ "$r" -ne "0" ] && LogIt "$incoming not found"
694 res=$(($res+$r))
695# echo "'$incoming' generates filelist '$filelist'" >> $LOGFILE
696 for fname in $filelist ; do
697 [ "$fname" != "" ] && echo "$fname" >> $tempfile
698 done
699 progress=$(($progress+1))
700 echo -en "\r\t\t\t\t\t\t\t\t"
701 i=$(($progress*100))
702 i=$(($i/$noof_lines))
703 echo -en "$i"
704 echo -en "%"
705 modres=$(($progress%4))
706 [ "$modres" -eq "0" ] && echo -en "\t/"
707 [ "$modres" -eq "1" ] && echo -en "\t-"
708 [ "$modres" -eq "2" ] && echo -en "\t\\"
709 [ "$modres" -eq "3" ] && echo -en "\t|"
710 incoming=`ReadLine`
711 done
712 if [ "$incoming" = "LVMFILES:" ] ; then
713 incoming=`ReadLine`
714 lvmversion=""
715 while [ "$incoming" != "" ] ; do
716 if echo "$incoming" | grep -x " *#.*" &> /dev/null ; then
717 incoming=`ReadLine`
718 continue
719 fi
720 filelist=`GenerateListForFile "$incoming"`
721 for tool in $filelist ; do
722 lvmresolved=`readlink -f $tool`
723 if [ "$tool" = "$lvmresolved" ]; then
724 echo "$tool" >> $tempfile
725 elif echo "$lvmresolved" | grep "lvmiopversion" &> /dev/null ; then
726 if [ "$lvmversion" = "" ] ; then
727 lvmversion=`$lvmresolved`
728 echo "$lvmresolved" >> $tempfile
729 fi
730 toolstripped=`echo $tool | $AWK -F / '{print $NF;}'`
731 if [ "$lvmversion" = "200" ]; then
732 # pvdata and lvmcreate_initrd don't exist in LVM2
733 case "$toolstripped" in
734 "pvdata")
735 continue
736 ;;
737 "lvmcreate_initrd")
738 continue
739 ;;
740 esac
741 fi
742 toolpath="/sbin/lvm-"$lvmversion"/"$toolstripped
743 if [ -e "$toolpath" ] ; then
744 echo "$toolpath" >> $tempfile
745 echo "$tool" >> $tempfile
746 else
747 toolpath="/lib/lvm-"$lvmversion"/"$toolstripped
748 fi
749 if [ -e "$toolpath" ] ; then
750 echo "$toolpath" >> $tempfile
751 echo "$tool" >> $tempfile
752 else
753 echo "Where are your LVM-Tools? Couldn't find $tool"
754 fi
755 else
756 echo "$tool" >> $tempfile
757 fi
758 done
759 progress=$(($progress+1))
760 echo -en "\r\t\t\t\t\t\t\t\t"
761 i=$(($progress*100))
762 i=$(($i/$noof_lines))
763 echo -en "$i"
764 echo -en "%"
765 modres=$(($progress%4))
766 [ "$modres" -eq "0" ] && echo -en "\t/"
767 [ "$modres" -eq "1" ] && echo -en "\t-"
768 [ "$modres" -eq "2" ] && echo -en "\t\\"
769 [ "$modres" -eq "3" ] && echo -en "\t|"
770 incoming=`ReadLine`
771 done
772 fi
773 echo -en "$DONE\nMaking complete dependency list"
774
775 tr -s '/' '/' < $tempfile | sort -u > $tempfile.new
776 mv -f $tempfile.new $tempfile
777 > $outfile.pre
778 progress=0
779 noof_lines=`cat $tempfile | wc -l`
780 echo "---------------------------------" >> $LOGFILE
781 echo "List of dependencies: " >> $LOGFILE
782 echo "---------------------------------" >> $LOGFILE
783 for fname in `cat $tempfile` ; do
784 echo "$fname" | tee -a $LOGFILE >> $outfile.pre
785 LocateDeps $fname | tee -a $LOGFILE >> $outfile.pre
786 progress=$(($progress+1))
787 echo -en "\r\t\t\t\t\t\t\t\t"
788 i=$(($progress*100))
789 i=$(($i/$noof_lines))
790 echo -en "$i"
791 echo -en "%"
792 modres=$(($progress%4))
793 [ "$modres" -eq "0" ] && echo -en "\t/"
794 [ "$modres" -eq "1" ] && echo -en "\t-"
795 [ "$modres" -eq "2" ] && echo -en "\t\\"
796 [ "$modres" -eq "3" ] && echo -en "\t|"
797 done
798 if [ _"$MONDO_SHARE" != _"" ]; then
799 mkdir -p $bigdir/tmp
800 mkdir -p $bigdir/sbin
801 mkdir -p $bigdir/bin
802 if [ -e "$MINDI_TMP/post-nuke.tgz" ] ; then
803 LogIt "\nIncorporating post-nuke tarball"
804 old_pwd=`pwd`
805 cd $bigdir
806 tar -zxf $MINDI_TMP/post-nuke.tgz || LogIt "Error occurred when untarring post-nuke tarball"
807 cd $old_pwd
808 fi
809 if cp -f $MINDI_TMP/mondo*restore $bigdir/usr/bin 2>> $LOGFILE ; then
810 LocateDeps $bigdir/usr/bin/mondo*restore >> $outfile.pre
811 else
812 LogIt "Cannot find mondo*restore in mondo's tempdir, $MINDI_TMP"
813 LogIt "I bet you've got a spare copy of Mondo or Mindi floating around on your system."
814 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."
815 Die "Odd."
816 fi
817 cp -f $MINDI_TMP/BOOTLOADER.* $bigdir 2> /dev/null || LogIt "\nMondo v1.2x defaults to LILO as the bootloader, BTW."
818 if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
819 LogIt "Incorporating NFS-related settings"
820 for r in NFS-* ISO-PREFIX ; do
821 cp -f $MINDI_TMP/$r $bigdir/tmp 2>> $LOGFILE || Die "Cannot copy $r - did you run out of disk space?"
822 echo "Copying $r to ramdisk" >> $LOGFILE
823 done
824 fi
825 fi
826 tr ' ' '\n' < $outfile.pre | tr -s '/' '/' | grep -Fvx "" | sort -u | grep -Ev "/libX11|/libXext|/libXi|/libgtk|/libgdk" > $outfile
827 rm -f $tempfile $outfile.pre
828 [ "$res" -eq "0" ] && echo -e "\r\t\t\t\t\t\t\t\t$DONE" || echo "\nFailed."
829 return $res
830}
831
832
833GenerateListForFile() {
834 local files_found loc fname incoming i res
835 incoming="$1"
836 files_found=""
837 res=0
838
839 for fname in $incoming ; do
840 files_found="$files_found `LocateFile $fname`"
841 done
842
843 echo "$files_found" | tr ' ' '\n' | sort -u | tr '\n' ' '
844}
845
846
847# Returns all disk devices which are part of a raid array
848GetAllRaidMembers() {
849 $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*device/ if(\$2) {print \$2}" < /etc/raidtab
850}
851
852
853GetFileSizeList() {
854 local i
855 for i in `find $1 -type d -o -print` ; do
856 du -sk $i
857 done
858}
859
860
861GetHomeDir() {
862 local res loc
863 loc=`which $1 2>/dev/null`
864 res=`file $loc | $AWK '{print $NF;}'`
865 dirname $res
866}
867
868
869# Check kernel filesystem capabilites for accessing initrd image
870#
871# Interface definition:
872# param #1: absolute path to kernel image
873GetInitrdFilesystemToUse() {
874
875 # interface test: make sure we have one parameter
876 if [ $# -ne 1 ]; then
877 Die "GetInitrdFilesystemToUse(): Expected 1 parameter, got $#."
878 fi
879
880 # interface parameters
881 local lvKernelImage=$1
882
883 # local constants (filesystem magic strings)
884 local lcMagicCramfs="<3>cramfs: wrong magic"
885 local lcMagicExt2fs="<3>EXT2-fs: blocksize too small for device."
886 local lcMagicInitfs="<6>checking if image is initramfs...|<6>Unpacking initramfs..."
887
888 # local variables
889 local lvOffset
890 local lvScanRes
891 local lvUseFilesystem
892
893 # say where we are.
894 echo " GetInitrdFilesystemToUse(): called with parameter: $lvKernelImage.\n" >> $LOGFILE
895
896 # verify that file exists
897 [ ! -f $lvKernelImage ] && Die "File $lvKernelImage not found. Terminating."
898
899 # Kernel may be gzip compressed
900 file $lvKernelImage 2>&1 | grep -q gzip
901 if [ $? -eq 0 ]; then
902 lvScanRes=`gzip -cd $lvKernelImage | strings | grep -E "$lcMagicCramfs|$lcMagicExt2fs|$lcMagicInitfs"`
903 else
904 # get offet of gzip magic "1f8b0800" in file
905 lvOffset=`od -vA n -t x1 $lvKernelImage | tr -d '[:space:]' | awk '{ print match($0, "1f8b0800")}'`
906 [ $lvOffset -eq 0 ] && Die "gzip magic not found in file $lvKernelImage. Terminating."
907 lvOffset=`expr $lvOffset / 2`
908 echo " GetInitrdFilesystemToUse(): gzip magic found at lvOffset $lvOffset.\n" >> $LOGFILE
909
910 # scan kernel image for initrd filessystem support
911 lvScanRes=`dd ibs=1 skip=$lvOffset if=$lvKernelImage obs=1M 2>/dev/null | gunzip -c 2> /dev/null | strings | grep -E "$lcMagicCramfs|$lcMagicExt2fs|$lcMagicInitfs"`
912 fi
913
914 # determine which filesystem to use for initrd image: ext2fs, gzip'ed cpio (initramfs ) or cramfs
915 if [ `echo $lvScanRes | grep -Ec "$lcMagicExt2fs"` -eq 1 ]; then
916 lvUseFilesystem="ext2fs"
917 elif [ `echo $lvScanRes | grep -Ec "$lcMagicInitfs"` -eq 1 ]; then
918 lvUseFilesystem="initramfs"
919 elif [ `echo $lvScanRes | grep -Ec "$lcMagicCramfs"` -eq 1 ]; then
920 lvUseFilesystem="cramfs"
921 else
922 lvUseFilesystem="UNSUPPORTED"
923 fi
924
925 # say what we are using
926 echo " GetInitrdFilesystemToUse(): Filesytem to use for initrd is $lvUseFilesystem.\n" >> $LOGFILE
927
928 # return file system to use
929 echo "$lvUseFilesystem"
930
931}
932
933# Searches parent raid device of given disk device
934# $1: disk device (i.e. /dev/hda1)
935GetParentRaidDev() {
936 $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {dev=\$2} /^[[:space:]]*device/ {if(\$2==\"$1\") {print dev; exit}}" < /etc/raidtab
937}
938
939
940# Searches members of raid device
941# $1: raid device (/dev/md...)
942GetRaidDevMembers() {
943 $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {if(dev) exit; if(\$2 == \"$1\") dev=\$2} /^[[:space:]]*device/ {if(dev) {print \$2}}" < /etc/raidtab
944}
945
946
947HackPathsToFailsafe() {
948 local incoming newpath kver stub i pwd
949 kver=`uname -r`
950 incoming=`ReadLine`
951 pwd=`pwd`
952 cd $MINDI_TMP
953 while [ "$incoming" != "" ] ; do
954 stub=`basename $incoming`
955 newpath=`FindSpecificModuleInPath lib/modules/$FAILSAFE_KVER $stub`
956 for i in $newpath ; do
957 echo "$i"
958 done
959 read incoming
960 done
961 cd $pwd
962}
963
964
965ListAllPartitions() {
966 local res currline partition all_partitions ap_orig remaining i j
967
968 grep -vx " *#.*" $MY_FSTAB | grep -vx " *none.*" | $AWK '/^\/dev\/[imhs]d||^LABEL=\/|^UUID=/ && !/fdd|cdr|zip|floppy/ {print $1}'
969 [ -e "/etc/raidtab" ] && $AWK '/^ *device/ {print $2}' /etc/raidtab
970 if [ -e "/vmfs/volumes" ]; then
971 # For VMWare ESX 3 get the device names of these volumes
972 vdf -P | grep -E '/vmfs/volumes' | awk '{print $1}'
973 fi
974 return
975}
976
977
978ListImagesForUser() {
979 local path fname
980 path=$1
981 echo -en "In the directory '$path' you will find the images:-\n"
982 for fname in `ls $path | grep -F mindi-` ; do
983 printf "%19s " $fname
984 done
985 echo " "
986}
987
988
989ListKernelModulePaths() {
990 local module_list module fname oss r kern
991 oss="/root/oss/modules"
992 module_list="$MODULES"
993 # Remove unwanted modules from list
994 for i in $DENY_MODS; do
995 module_list=`echo ${module_list} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
996 EXTRA_MODS=`echo ${EXTRA_MODS} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
997 done
998###
999### Sq-Modification ... Use kernelname for module search path if specified
1000###
1001 # kern="`uname -r`"
1002 if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
1003 then
1004 kern=${kernelname}
1005 else
1006 kern="`uname -r`"
1007 fi
1008###
1009### Sq-Mod End
1010###
1011 for module in $module_list $EXTRA_MODS ; do
1012 r=`find /lib/modules/$kern -type f | grep "/${module}\..*o" | tail -n1`
1013 echo "module $module --> $r" >> $LOGFILE
1014 [ "$r" ] && echo "$r"
1015 [ -f "$oss" ] && find $oss | grep -F $module
1016 done
1017 find /lib/modules/$kern/modules.* -type f 2> /dev/null
1018 [ -f "$oss" ] && find $oss.* 2> /dev/null
1019}
1020
1021#
1022# Critical function which computes all dependencies (dyn. lib.)
1023# for a list of binaries
1024#
1025LocateDeps() {
1026 local incoming fname deps
1027 incoming="$*"
1028 for fname in $incoming ; do
1029 if [ ! -e "$fname" ] ; then
1030 echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
1031 if echo $fname | grep lvm &> /dev/null ; then
1032 echo "This warning only affects you if you are using LVM." >> $LOGFILE
1033 if echo "$MODULES" | grep lvm &> /dev/null ; then
1034 echo "I think you are, so please take heed!" >> $LOGFILE
1035 else
1036 echo "I don't think you are, so don't worry about it." >> $LOGFILE
1037 fi
1038 fi
1039 elif [ -h "$fname" ] && [ -x "$fname" ] ; then
1040 echo "$fname is softlink" >> $LOGFILE
1041 else
1042 ldd $fname 2> /dev/null | ProcessLDD
1043 fi
1044 done
1045}
1046
1047
1048# Give all symlinks recursively of a full path name
1049ReadAllLink() {
1050 file="$1"
1051
1052 echo "$file"
1053 if [ ! -h $file ]; then
1054 return 0
1055 fi
1056
1057 link=`readlink $file`
1058 d=`dirname $file`
1059 fchar=`echo $link | cut -c1`
1060 # If mother dir is a link print it
1061 if [ -h "$d" ]; then
1062 echo "$d"
1063 d=`readlink $d`
1064 fi
1065 if [ "$fchar" != "/" ]; then
1066 # Relative or local link
1067 ReadAllLink "$d/$link"
1068 else
1069 # Absolute path
1070 ReadAllLink $link
1071 fi
1072}
1073
1074
1075LocateFile() {
1076 local i path fname_to_find location output resolved tmp stub cache_id loclist
1077 fname_to_find="$1"
1078 # It's an absolute path
1079 if echo "$fname_to_find" | grep -x "/.*" ; then
1080 output="$fname_to_find"
1081 if [ -h "$output" ] ; then
1082 output="`ReadAllLink $output` $output"
1083 fi
1084 echo "$output"
1085 return 0
1086 fi
1087 # It's not an absolute path
1088 output=""
1089 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
1090 #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
1091 [ -h "$path" ] && continue
1092 [ ! -e "$path/$fname_to_find" ] && continue
1093 output="$path/$fname_to_find $output"
1094 if [ -h "$path/$fname_to_find" ] ; then
1095 output="`ReadAllLink $path/$fname_to_find` $output"
1096 fi
1097 done
1098 if [ "$output" = "" ] ; then
1099 return 1
1100 fi
1101 echo "$output"
1102 return 0
1103}
1104
1105
1106LogIt() {
1107 if [ -e /dev/stderr ] ; then
1108 echo -e "$1" >> /dev/stderr
1109 elif [ -e /usr/bin/logger ] ; then
1110 /usr/bin/logger -s $1
1111 fi
1112 echo -e "$1" >> $LOGFILE
1113}
1114
1115
1116MakeModuleLoadingScript() {
1117 local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
1118 tmpmodprobe_flag=$1
1119 outfile=$2
1120 > $outfile || Die "Cannot create empty $outfile"
1121 echo -en "#\041/bin/sh\n\n" >> $outfile
1122 echo "echo -en \"Loading your modules...\"" >> $outfile
1123 if [ "$YOUR_KERNEL_SUCKS" ] ; then
1124 kver=$FAILSAFE_KVER
1125 cd $MINDI_TMP
1126 searchpath=lib/modules/$kver
1127 else
1128###
1129### Sq-Modification ... Use kernelname for module search path if specified
1130###
1131 #kver=`uname -r`
1132 if [ "${kernelname}" != "" ]
1133 then
1134 kver=${kernelname}
1135 else
1136 kver=`uname -r`
1137 fi
1138###
1139### Sq-Modification end
1140###
1141 searchpath=/lib/modules/$kver
1142 fi
1143
1144 echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
1145 list_to_echo="$MODULES"
1146 # Remove unwanted modules from list
1147 for i in $DENY_MODS; do
1148 list_to_echo=`echo ${list_to_echo} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
1149 EXTRA_MODS=`echo ${EXTRA_MODS} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
1150 done
1151
1152 # Make temporary modprobe.conf file if we are told so
1153 if [ "$tmpmodprobe_flag" = "Y" ] ; then
1154 infile="$MINDI_TMP/modprobe.conf.mindi"
1155 find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 | xargs -0 cat > $infile
1156 else
1157 infile="/etc/modules.conf"
1158 fi
1159
1160 for module in $list_to_echo $EXTRA_MODS ; do
1161 params=`sed -n "s/^options \\+$module \\+//p" $infile`
1162 modpaths=`FindSpecificModuleInPath $searchpath $module`
1163 for i in $modpaths ; do
1164 echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
1165 | tr '.' '#' \
1166 | sed s/#o#gz/#o/ \
1167 | sed s/#o#gz/#o/ \
1168 | sed s/#ko#gz/#ko/ \
1169 | sed s/#ko#gz/#ko/ \
1170 | tr '#' '.' >> $outfile
1171 echo -en "$i added to module list.\n" >> $LOGFILE
1172 done
1173 done
1174 echo -en "done\n" >> $outfile
1175 echo "echo \"Done.\"" >> $outfile
1176 chmod +x $outfile
1177 cd /
1178 # Remove temporary modprobe.conf file if we have created one
1179 if [ "$tmpmodprobe_flag" = "Y" ] ; then
1180 rm -f $infile
1181 fi
1182}
1183
1184
1185MakeMountlist() {
1186 local scratchdir mountlist all_partitions current_partition \
1187partition_size partition_format outstring partition_number \
1188partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
1189absolute_partition old_partition_fmt current_lvolume
1190
1191 echo "Your raw fstab file looks like this:" >> $LOGFILE
1192 echo "------------------------------------" >> $LOGFILE
1193 cat $MY_FSTAB >> $LOGFILE
1194 echo "Your mountlist will look like this:" | tee -a $LOGFILE
1195 echo "-----------------------------------" >> $LOGFILE
1196
1197# scratchdir, mountlist(OUT)
1198 scratchdir=$MINDI_TMP
1199 mountlist=$1
1200
1201# NB: partition = device
1202# NB: mountpt = where the device is mounted
1203
1204 [ -e "$MY_FSTAB" ] || Die "Cannot find your fstab file ($MY_FSTAB)"
1205
1206 [ "$mountlist" != "" ] && rm -Rf $mountlist
1207 > $mountlist
1208 all_partitions=""
1209
1210 if [ $LVM != "false" ]; then
1211 echo -en "Analyzing LVM...\n"
1212 $MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
1213 if [ $? -ne 0 ]; then
1214 LVM="false"
1215 fi
1216 all_partitions=`cat $MINDI_TMP/lvm.res | grep -F ">>>" | cut -d' ' -f2-32`
1217 fi
1218 all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
1219# echo "all partitions = $all_partitions" > /dev/stderr
1220 for i in $IMAGE_DEVS ; do
1221 mount | grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
1222 done
1223 [ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" | tr ' ' '\n' | sort -u | tr '\n ' ' '`"
1224 printf " %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID | tee -a $LOGFILE
1225 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"
1226 for c_p in $all_partitions ; do
1227 [ "`echo "$useless_dev" | grep -F "$c_p"`" != "" ] || [ "`echo "$c_p" | grep ":"`" != "" ] && continue
1228 [ "`echo "$c_p" | grep -x "/dev/cdroms.*"`" ] && continue
1229 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
1230 current_partition=`readlink -f $c_p`
1231 [ "`echo "$current_partition" | grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
1232 [ "`echo "$useless_dev" | grep -F "$current_partition"`" ] && continue
1233 else
1234 current_partition="$c_p"
1235 fi
1236 [ "$c_p" = "none" ] && continue
1237 redhat_label=""
1238 label=""
1239 uuid=""
1240 absolute_partition=`readlink -f $c_p`
1241 partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1242
1243 # Detects noauto partitions not mounted and exclude them
1244 partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1245 if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" = "" ] ; then
1246 continue
1247 fi
1248
1249 # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1250 # current_partition contains only first column of /etc/fstab
1251 if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1252 str_to_find_fmt_with=$current_partition
1253 redhat_label=`echo "$current_partition" | cut -d'=' -f2`
1254 actual_dev=""
1255
1256 # 1st try, findfs - the RHEL way of finding labels and their partitions
1257 if [ -x "/sbin/findfs" ]; then
1258 actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1259 fi
1260
1261 # 2nd try : blkid, the good way for all LABEL except swap
1262 if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1263 actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | cut -d':' -f1`
1264 # For LVM FS it will give a /dev/dm-# which should then be converted
1265 if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1266 major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1267 minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1268 for dev in `ls /dev/mapper/*`; do
1269 major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1270 minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1271 if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1272 actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1273 break
1274 fi
1275 done
1276 fi
1277 fi
1278
1279 # 3rd try, which works on a standard partition (ext2/3), but not on swap
1280 # For LVM gives a /dev/mapper entry
1281 if [ "x$actual_dev" = "x" ]; then
1282 actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | cut -d' ' -f1`
1283 fi
1284
1285 # 4th try, with vol_id
1286 # SWAP only
1287 if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1288 list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | $AWK '{ print $1 }' `
1289 for dev_swap in $list_swaps ; do
1290 dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1291 if [ "x$dev_exists" != "x" ]; then
1292 actual_dev=$dev_swap
1293 break;
1294 fi
1295 done
1296 fi
1297
1298 # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1299 # LABEL=SW-cciss/c0d0p3 (RDP)
1300 # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1301 # SWAP only
1302 if [ "x$actual_dev" = "x" -a _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1303 for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1304 do
1305 # Location of the swap label for kernel 2.6
1306 try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
1307 if [ "x$try_dev_label" = "x$redhat_label" ]; then
1308 actual_dev=$try_dev
1309 fi
1310 done
1311 fi
1312
1313 # Check if one of all those tries has known success
1314 if [ "x$actual_dev" != "x" ]; then
1315 current_partition=$actual_dev
1316 else
1317 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"
1318 fi
1319 # This part tries to retrieve the correct device from a UUID line in /etc/fstab
1320 # current_partition contains only first column of /etc/fstab
1321 elif [ "`echo "$current_partition" | /bin/grep -i "UUID="`" != "" ]; then
1322 str_to_find_fmt_with=$current_partition
1323 uuid=`echo "$current_partition" | cut -d'=' -f2`
1324 actual_dev=""
1325
1326 # 1st try, findfs - the RHEL way of finding labels and their partitions
1327 if [ -x "/sbin/findfs" ]; then
1328 actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
1329 fi
1330
1331 # 2nd try : blkid, the good way for all UUID except swap
1332 if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1333 actual_dev=`/sbin/blkid | /bin/grep "$uuid" | grep UUID= | cut -d':' -f1`
1334 # For LVM FS it will give a /dev/dm-# which should then be converted
1335 if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1336 major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1337 minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1338 for dev in `ls /dev/mapper/*`; do
1339 major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1340 minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1341 if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1342 actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1343 break
1344 fi
1345 done
1346 fi
1347 fi
1348
1349 # 3th try, with vol_id
1350 if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1351 list_dev=`mount | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1352 for dev in $list_dev ; do
1353 dev_exists=`/sbin/vol_id $dev | /bin/grep "$uuid"`
1354 if [ "x$dev_exists" != "x" ]; then
1355 actual_dev=$dev
1356 break;
1357 fi
1358 done
1359 fi
1360
1361 # 4th try, with dumpuuid (VMWare only ?) for swap
1362 if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
1363 list_dev=`cat /proc/swaps | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1364 for dev in $list_dev ; do
1365 dev_exists=`/sbin/dumpuuid $dev | /bin/grep "$uuid"`
1366 if [ "x$dev_exists" != "x" ]; then
1367 actual_dev=$dev
1368 break;
1369 fi
1370 done
1371 fi
1372
1373 # Check if one of all those tries has known success
1374 if [ "x$actual_dev" != "x" ]; then
1375 current_partition=$actual_dev
1376 else
1377 Die "Your system uses a UUID 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"
1378 fi
1379 else
1380 # Needs to handle the recent OpenSUSE fancy way of dealing with fstab :-(
1381 # they use symlinks in fstab unrelated to what is shown in mount !
1382 if [ _"$partition_mountpt" = _"" ]; then
1383 for tmpp in `tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -Ev "^#" | $AWK '{print $1}'`; do
1384 if [ _"`readlink -f $tmpp`" = _"$current_partition" ]; then
1385 str_to_find_fmt_with=$tmpp
1386 partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$tmpp" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1387 break;
1388 fi
1389 done
1390 else
1391 str_to_find_fmt_with=$current_partition
1392 fi
1393 fi
1394
1395 partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1396 # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1397 # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1398 # the former is then a link to the latter, so we test whether
1399 # $current_partition is actually such a link or not and set
1400 # $current_lvolume accordingly. On Debian you may find more than one answer
1401 # so we remove the one corresponding to /dev/.static
1402 # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1403 # principle is the same and we need to find the link to it as well.
1404 # Note that $current_lvolume may well be an
1405 # ordinary device. It is just to make sure that we feed the right value
1406 # into any of the LVM tools if possible.
1407
1408 current_lvolume="$current_partition"
1409 if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1410 # .static dir are a Debian specificity
1411 current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1412 echo $current_lvolume | grep -q ' '
1413 if [ $? -eq 0 ]; then
1414 echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE
1415 fi
1416 fi
1417 #
1418 # End of LVM device style variation code (other than $current_lvolume).
1419
1420 if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1421 # Size computed via LVM not directly
1422 partition_size="lvm"
1423 else
1424 partition_size=`SizeOfPartition $current_partition`
1425 [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1426 [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1427 if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1428 partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1429 [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1430 [ "$partition_format" != "swap" ] && partition_format="swap"
1431 if [ "$partition_size" = "" ] ; then
1432 totalsize=0
1433 items=0
1434 for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1435 totalsize=$(($totalsize+$i))
1436 items=$(($items+1))
1437 done
1438 [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1439 [ "$partition_size" -lt "125000" ] && partition_size=125000
1440 echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1441 fi
1442 fi
1443 fi
1444 [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1445 [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1446 if [ "$partition_mountpt" = "" ] ; then
1447 if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1448 if [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1449 partition_mountpt="raid"
1450 partition_format="raid"
1451 else
1452 partition_mountpt="lvm"
1453 partition_format="lvm"
1454 fi
1455 fi
1456 fi
1457 psz=$partition_size
1458 echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1459 [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1460 if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1461 partition_mountpt="image"
1462 old_partition_fmt=$partition_format
1463 partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1464 partition_size=$(($partition_size+1)); # just in case
1465 if [ "$partition_format" = "Linux" ] ; then
1466 echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1467 echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1468 partition_format=$old_partition_fmt
1469 fi
1470 fi
1471 if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1472 echo "Excluding $current_partition from mountlist" >> $LOGFILE
1473 continue
1474 fi
1475 if [ ! "$partition_mountpt" ] ; then
1476 echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1477 for qq in "" `find /dev/ida/c*d* ! -name '*p*' 2> /dev/null`; do
1478 partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1479 [ "$partition_format" ] && break
1480 done
1481 echo "------- $FDISK log end ------------" >> $LOGFILE
1482 if [ "$partition_format" = "Compaq diagnostics" ] ; then
1483 partition_format="compaq"
1484 elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1485 LogIt "Unable to find mountpoint of $current_partition - ignoring"
1486 continue
1487 fi
1488 fi
1489 if [ "$redhat_label" ]; then
1490 label="$redhat_label"
1491 elif [ "$uuid" ]; then
1492 label="$uuid"
1493 fi
1494 partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1495 [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1496 unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
1497 if [ "$current_partition" = "" ] ; then
1498 echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1499 elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1500 if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1501 partition_mountpt=raid
1502 partition_format=raid
1503 printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1504 printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1505 else
1506 echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1507 fi
1508 elif [ "$partition_format" = "" ] ; then
1509 echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1510 elif [ "$partition_size" = "" ] ; then
1511 echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1512 elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1513 continue
1514 else
1515 if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1516 echo "Stupid bastard..." >> $LOGFILE
1517 partition_format="vfat"
1518 fi
1519 printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1520 printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1521 fi
1522 done
1523}
1524
1525
1526MakeSureNumberIsInteger() {
1527 res=`echo "$1" | tr -s '\-[0-9]' ' '`
1528 if [ "$res" != " " ] && [ "$res" != "" ] ; then
1529 echo "result = '$res'"
1530 Die "$1 should be an integer"
1531 fi
1532}
1533
1534
1535MakeSyslinuxMessageFile() {
1536 mkdir -p $1
1537 rmdir $1
1538 echo -en " " > $1
1539 if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1540 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 /etc/issue.net` `hostname`"% | sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ | sed s/TTTTT/"`LC_TIME=C date`"/ >> $1.tmp
1541 else
1542 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" /etc/issue.net | head -n1 | tr -s ' ' ' '`"/ | sed s/KKKKK/"`grep -i "kernel" /etc/issue.net | head -n1 | tr -s ' ' ' '`"/ | sed s/TTTTT/"`LC_TIME=C date`"/ | sed s/' '\\r' 'on' 'an' '\/' '`uname -r`' 'on' 'an' '`uname -m`/ >> $1.tmp
1543 fi
1544 sed s/%r/"`uname -r`"/ $1.tmp | sed s/%t/"`hostname`"/ > $1
1545 rm -f $1.tmp
1546 if [ "$CDRECOVERY" != "yes" ] ; then
1547 if [ "$NFS_DEV" != "" ] ; then
1548 echo -en "Press <enter> to continue.\n" >> $1
1549 elif [ ! "$MINDI_TMP" ] ; then
1550 echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
1551 if [ -e "$MINDI_LIB/memtest.img" ] ; then
1552 echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
1553 fi
1554 else
1555 echo -en "$BOOT_MEDIA_MESSAGE" >> $1
1556 fi
1557 else
1558 echo -en " \
1559To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1560CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1561 fi
1562}
1563
1564
1565MoveHyperlinkSensibly() {
1566 local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
1567 filename=$1
1568 minidir_root=$2
1569 resides_on_diskno=$3
1570 noof_disks=$4
1571
1572 [ -h "$minidir_root/$resides_on_diskno/$filename" ] || Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
1573
1574 old_diskno=$resides_on_diskno
1575 d=1
1576 while [ "$d" -le "$noof_disks" ] ; do
1577 if [ "$d" -ne "$old_diskno" ] ; then
1578 old_pwd=`pwd`
1579 cd $minidir_root/$old_diskno
1580 cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE || Die "Can't move $filename (sensibly) from $old_diskno to $d"
1581 rm -f $filename
1582 cd $old_pwd
1583 fi
1584# when the softlink is resolvable, our work here is done
1585 [ -e "$minidir_root/$d/$filename" ] && return 0
1586 old_diskno=$d
1587 d=$(($d+1))
1588 done
1589 return 1
1590}
1591
1592
1593OfferToMakeBootableISO() {
1594 local i old_pwd
1595 if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1596 echo -en "Shall I make a bootable CD image? (y/[n]) "
1597 read i
1598 [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1599 fi
1600 if [ _"$MINDI_TMP" = _"" ]; then
1601 Die "MINDI_TMP undefined"
1602 fi
1603 rm -Rf $MINDI_TMP/iso
1604 mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
1605 cp -f $1/*.img $1/*.gz $MINDI_TMP/iso/images 2>> $LOGFILE || LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
1606 old_pwd=`pwd`
1607 cd $MINDI_TMP/iso
1608 echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1609 for i in memdisk memtest.bin memtest.img ; do
1610 j=$MINDI_LIB/$i
1611 k=$MINDI_TMP/iso/isolinux
1612 if [ -e "$j" ] ; then
1613 LogIt "Copying $j to $k"
1614 cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1615 cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1616 if [ _"$MONDO_SHARE" != _"" ]; then
1617 cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1618 fi
1619 fi
1620 done
1621 MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
1622 cp $kernelpath $MINDI_TMP/iso/isolinux/vmlinuz 2>> $LOGFILE || Die "Cannot copy vmlinuz ($kernelpath) to mindi tmp ($MINDI_TMP/iso/isolinux/vmlinuz). Did you run out of disk space?"
1623 cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
1624 if [ _"$MONDO_SHARE" != _"" ]; then
1625 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?"/dev/null
1626 cp $MINDI_TMP/mindi.rdz $MONDO_ROOT/initrd.img 2>> $LOGFILE || Die "Cannot copy mindi.rdz ($MINDI_TMP/mindi.rdz) to mondo root ($MONDO_ROOT/vmlinuz). Did you run out of disk space?"
1627
1628 fi
1629 [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1630 cd $MINDI_TMP/iso/isolinux
1631 cat $iso_cfg_file | HackSyslinuxFile $ramdisk_size $MINDI_TMP/iso > isolinux.cfg || Die "Cannot copy isolinux.cfg to $MINDI_TMP/iso/isolinux - did you run out of disk space?"
1632 if [ "$NFS_DEV" != "" ] ; then
1633 perl -pi -e 's/interactive/iso/' isolinux.cfg
1634 fi
1635 if [ "$ARCH" != "ia64" ] ; then
1636 cp $ISOLINUX isolinux.bin 2> /dev/null || Die "Cannot copy isolinux.bin ($ISOLINUX) to $MINDI_TMP/iso/isolinux - did you run out of disk space?"
1637 cp $ISOLINUX ../ 2>> $LOGFILE
1638 fi
1639 cd $MINDI_TMP/iso
1640 if [ "$ARCH" != "ia64" ] ; then
1641 if [ _"$MONDO_SHARE" != _"" ]; then
1642 cp -f $MINDI_TMP/iso/isolinux/{isolinux.cfg,initrd.img,vmlinuz,isolinux.bin,message.txt} $MONDO_ROOT 2> /dev/null || Die "Cannot copy core files to ramdisk for boot disk (under $MONDO_ROOT). Did you run out of disk space?"
1643 cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
1644 fi
1645 $ISO_CMD -U $ISO_OPT -V Mindi_Image -o $MINDI_CACHE/mindi.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table . > /dev/null 2> $MINDI_TMP/mkisofs.log
1646 else
1647 $ISO_CMD $ISO_OPT -V Mindi_Image -o $MINDI_CACHE/mindi.iso -b images/mindi-bootroot.$BOOT_SIZE.img -c isolinux/boot.cat -no-emul-boot . > /dev/null 2> $MINDI_TMP/mkisofs.log
1648 fi
1649 if [ "$?" -ne "0" ] ; then
1650 echo "----------- $ISO_CMD's errors --------------" >> $LOGFILE
1651 cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1652 echo "$ISO_CMD returned the following errors:-"
1653 cat $MINDI_TMP/mkisofs.log
1654 LogIt "Failed to create ISO image."
1655 else
1656 echo "Created bootable ISO image at $MINDI_CACHE/mindi.iso" | tee -a $LOGFILE
1657 fi
1658 rm -f $MINDI_TMP/mkisofs.log
1659 cd $old_pwd
1660}
1661
1662
1663OfferToMakeBootableUSB() {
1664 local i old_pwd
1665 if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1666 echo -n "Shall I make a bootable USB image ? (y/[n]) "
1667 read i
1668 [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1669 if [ "$USBDEVICE" = "" ]; then
1670 echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
1671 read dev
1672 USBDEVICE=$dev
1673 fi
1674 echo "WARNING: This will erase all content on $USBDEVICE"
1675 echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
1676 fi
1677 if [ _"$MINDI_TMP" = _"" ]; then
1678 Die "MINDI_TMP undefined"
1679 fi
1680 rm -Rf $MINDI_TMP/usb
1681 mkdir -p $MINDI_TMP/usb
1682 USBPART="${USBDEVICE}1"
1683
1684 echo -en "Transforming $USBDEVICE in a Bootable device "
1685 echo -en "."
1686 echo "Transforming $USBDEVICE in a Bootable device" >> $LOGFILE
1687 echo "Checking $USBDEVICE" >> $LOGFILE
1688 $FDISK -l $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE
1689 if [ $? -ne 0 ]; then
1690 echo "Unable to access $USBDEVICE" | tee -a $LOGFILE
1691 echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1692 exit -1
1693 fi
1694 echo -en "."
1695 echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
1696 umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
1697 echo "Erasing $USBDEVICE" >> $LOGFILE
1698 $FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
1699d
1700d
1701d
1702d
1703n
1704p
17051
1706
1707
1708t
1709b
1710a
17111
1712w
1713EOF
1714 if [ $? -ne 0 ]; then
1715 echo "Unable to create a vfat Filesystem on $USBDEVICE" | tee -a $LOGFILE
1716 echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1717 $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1718 MindiExit -1
1719 fi
1720 echo -en "."
1721 echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
1722 mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
1723 if [ $? -ne 0 ]; then
1724 echo "Unable to create a vfat filesystem on $USBPART" | tee -a $LOGFILE
1725 echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" | tee -a $LOGFILE
1726 $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1727 MindiExit -1
1728 fi
1729 echo -en "."
1730 echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
1731 mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1732 if [ $? -ne 0 ]; then
1733 echo "Unable to mount $USBPART on $MINDI_TMP/usb" | tee -a $LOGFILE
1734 echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" | tee -a $LOGFILE
1735 $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1736 MindiExit -1
1737 fi
1738 echo -en "."
1739 mkdir -p $MINDI_TMP/usb/images
1740 cp -f $1/*.img $1/*.gz $MINDI_TMP/usb/images 2>> $LOGFILE || LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
1741 echo -en "."
1742 old_pwd=`pwd`
1743 cd $MINDI_TMP/usb
1744 echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1745 for i in memdisk memtest.bin memtest.img ; do
1746 j=$MINDI_LIB/$i
1747 k=$MINDI_TMP/usb
1748 if [ -e "$j" ] ; then
1749 LogIt "Copying $j to $k"
1750 cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1751 cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1752 fi
1753 done
1754 echo -en "."
1755 MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
1756 echo -en "."
1757 cp $kernelpath $MINDI_TMP/usb/vmlinuz 2> /dev/null || Die "Cannot copy vmlinuz ($kernelpath) to mindi tmp ($MINDI_TMP/usb/syslinux/vmlinuz). Did you run out of disk space?"
1758 echo -en "."
1759 cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
1760 echo -en "."
1761 [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1762 cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $MINDI_TMP/usb > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to $MINDI_TMP/usb - did you run out of disk space?"
1763 echo -en "."
1764 if [ "$NFS_DEV" != "" ] ; then
1765 perl -pi -e 's/interactive/iso/' syslinux.cfg
1766 fi
1767 cd $old_pwd
1768 echo -en "."
1769 umount $MINDI_TMP/usb
1770 if [ "$ARCH" != "ia64" ] ; then
1771 syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
1772 if [ "$?" -ne "0" ] ; then
1773 echo "----------- syslinux's errors --------------" |tee -a $LOGFILE
1774 cat $MINDI_TMP/syslinux.log |tee -a $LOGFILE
1775 LogIt "Failed to create USB image."
1776 else
1777 echo -e "$DONE"
1778 echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
1779 fi
1780 rm -f $MINDI_TMP/syslinux.log
1781 else
1782 echo "No USB boot support for ia64" | tee -a $LOGFILE
1783 MindiExit -1
1784 fi
1785 echo -en "."
1786}
1787
1788
1789PluralOrNot() {
1790 [ "$1" -gt "1" ] && echo -en "s"
1791}
1792
1793
1794MakeMessageFile() {
1795 if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1796 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 /etc/issue.net` `hostname`"% | sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ | sed s/TTTTT/"`LC_TIME=C date`"/
1797 else
1798 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" /etc/issue.net | head -n1 | tr -s ' ' ' '`"/ | sed s/KKKKK/"`grep -i "kernel" /etc/issue.net | head -n1 | tr -s ' ' ' '`"/ | sed s/TTTTT/"`LC_TIME=C date`"/ | sed s/' 'r' 'on' 'an' 'm/' '`uname -r`' 'on' 'an' '`uname -m`/
1799 fi
1800 if [ _"$MONDO_SHARE" != _"" ]; then
1801 if [ "$CDRECOVERY" != "yes" ] ; then
1802 if [ "$NFS_DEV" != "" ] ; then
1803 echo -en "Press <enter> to continue.\n"
1804 elif [ ! "$MINDI_TMP" ] ; then
1805 echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1806 else
1807 echo -en "$BOOT_MEDIA_MESSAGE"
1808 fi
1809 fi
1810 fi
1811 if [ "$CDRECOVERY" = "yes" ] ; then
1812 echo -en "\
1813To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1814CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1815 fi
1816 echo -en "\n\n\n"
1817}
1818
1819
1820MakeLiloConfFile() {
1821 local options i ooo
1822 options=""
1823
1824 if [ "$ARCH" != "ia64" ] ; then
1825 echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1826 echo -en "install=/boot.b\nmap=/boot.map\n"
1827 fi
1828 if [ "$CDRECOVERY" = "yes" ] ; then
1829 echo -en "default=RESTORE\n"
1830 elif [ _"$MONDO_SHARE" != _"" ]; then
1831 if [ "$NFS_DEV" != "" ] ; then
1832 echo -en "default=iso\n"
1833 else
1834 echo -en "default=interactive\n"
1835 fi
1836 else
1837 echo -en "default=expert\n"
1838 fi
1839
1840 echo -en "prompt\n"
1841 if [ "$ARCH" != "ia64" ] ; then
1842 echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1843 fi
1844 if [ "$CDRECOVERY" != "yes" ] ; then
1845 echo -en "timeout=300\n"
1846 fi
1847 echo -en "\n"
1848 if [ "$CDRECOVERY" = "yes" ] ; then
1849 options="RESTORE expert"
1850 else
1851 if [ _"$MONDO_SHARE" != _"" ]; then
1852 if [ "$NFS_DEV" != "" ] ; then
1853 options="iso"
1854 else
1855 options="interactive expert compare iso nuke isonuke"
1856# hda hdb hdc hdd"
1857 fi
1858 else
1859 options="expert"
1860 fi
1861 fi
1862 for i in $options ; do
1863 ooo=$i
1864 [ "$ooo" = "RESTORE" ] && ooo="nuke"
1865 if [ "$ARCH" = "ia64" ] ; then
1866 rootpart="root=/dev/ram0\n\t"
1867 else
1868 rootpart=""
1869 fi
1870 outstr="image=/vmlinuz\n\tlabel=$i\n\tinitrd=/mindi.rdz\n\t${rootpart}append=\" rw ramdisk=$ramdisksize ramdisk_size=$ramdisksize maxcpus=1 $ooo_mode $ADDITIONAL_BOOT_PARAMS"
1871
1872 outstr=$outstr" $ooo_mode"
1873 outstr=$outstr"\"\n"
1874 echo -en "$outstr"
1875 done
1876}
1877
1878
1879PrepareBootDiskImage_LILO() {
1880 local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1881 imagesdir=$1
1882 kernelpath=$2
1883 ramdisksize=$3
1884
1885 retval=0
1886 [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1887 echo -en "Making "$BOOT_SIZE"KB boot disk..."
1888 TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize `du -sk $kernelpath | cut -f1` || Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
1889 echo -en "..."
1890 imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
1891 mountpoint=$MINDI_TMP/mountpoint.$$
1892 mkdir -p $mountpoint
1893 dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
1894 if [ "$ARCH" = "ia64" ] ; then
1895 mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1896 t=vfat
1897 else
1898 echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
1899 mke2fs -N 26 -m 0 -F $imagefile &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
1900 t=ext2
1901 fi
1902 mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1903 # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1904 mkdir -p $mountpoint/etc
1905 if [ "$ARCH" != "ia64" ] ; then
1906 liloconf=$mountpoint/etc/lilo.conf
1907 else
1908 liloconf=$mountpoint/elilo.conf
1909 fi
1910 old_pwd=`pwd`
1911 cd $mountpoint
1912 if [ "$ARCH" != "ia64" ] ; then
1913 tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1914 fi
1915 cd $old_pwd
1916 # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1917 #losetup /dev/loop0 > /dev/null 2> /dev/null
1918 #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1919 CopyBootBFile $mountpoint/boot.b
1920
1921 MakeLiloConfFile > $liloconf
1922
1923 # Copy it so that CD-ROM menu entry is satisfied
1924 if [ "$ARCH" = "ia64" ] ; then
1925 mountefi=0
1926 df -T | grep /boot/efi | grep -q vfat
1927 if [ $? -ne 0 ]; then
1928 mount /boot/efi
1929 if [ $? -ne 0 ]; then
1930 echo "You have to mount your EFI partition when using mindi"
1931 MindiExit -1
1932 fi
1933 mountefi=1
1934 fi
1935 el=`find /boot/efi -name elilo.efi`
1936 cp $el $mountpoint
1937 cp $liloconf $mountpoint
1938 if [ $mountefi -eq 1 ]; then
1939 umount /boot/efi 2>&1 > /dev/null
1940 fi
1941 fi
1942
1943 echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1944 cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1945 if [ "$?" -ne "0" ] ; then
1946 LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1947 cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1948 LogIt "Please unload some of your modules and try again."
1949 rm -f $MINDI_TMP/mtpt.$$
1950 LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1951 retval=$(($retval+1))
1952 fi
1953 MakeMessageFile > $mountpoint/message
1954
1955 mkdir -p $mountpoint/tmp
1956 cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1957 if [ -e "$MINDI_LIB/memtest.img" ] ; then
1958 echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1959 echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1960# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1961 fi
1962
1963 # copy the kernel across
1964 [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1965 dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1966 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1967 cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
1968 if [ "$?" -ne "0" ] ; then
1969 echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1970 du -sk $mountpoint/* >> $LOGFILE
1971 echo "--- end of list of files ---" >> $LOGFILE
1972 echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1973Sorry, your kernel is too big for your image.\n" >> $LOGFILE
1974 rm -f $mountpoint/vmlinuz
1975 cd $old_pwd
1976 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1977 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1978 # losetup /dev/loop0 -d
1979 rm -f $imagefile
1980 return 0
1981 fi
1982 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1983 max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1984 echo "Free space left on image = $free_space KB" >> $LOGFILE
1985 echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
1986 # make it bootable
1987 rm -f $mountpoint/zero
1988 [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
1989 if [ ! "$KERN_DISK_MADE" ] ; then
1990 if [ "$ARCH" != "ia64" ] ; then
1991 $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
1992 else
1993 /bin/true
1994 fi
1995 else
1996 echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
1997 fi
1998
1999 # BERLIOS does not test necessarily what it expects
2000 if [ $? -ne "0" ] ; then
2001 if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2002 LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2003 LogIt "Please reboot your PC as a workaround."
2004 Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2005 fi
2006 echo "$LILO_EXE -r $mountpoint ...failed."
2007 echo -en "Press ENTER to continue."; read line
2008 LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2009 retval=$(($retval+1))
2010 fi
2011 cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2012 if [ "$ARCH" = "ia64" ] ; then
2013 cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2014 fi
2015 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2016 echo -en "..."
2017 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2018 if [ "$retval" -eq "0" ] ; then
2019 echo -en "...$DONE\n"
2020 if [ "$KERN_DISK_MADE" ] ; then
2021 LogIt "$BOOT_SIZE KB boot disks were created OK\n"
2022 fi
2023 else
2024 echo -en "...failed\n"
2025 LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
2026 rm -f $imagefile
2027 fi
2028 [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2029 return $retval
2030}
2031
2032
2033PrepareBootDiskImage_SYSLINUX() {
2034 local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2035 imagesdir=$1
2036 kernelpath=$2
2037 ramdisksize=$3
2038 do_boot_root_thingy=""
2039 local retval old_pwd
2040 retval=0
2041
2042 [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2043 echo -en "Making "$BOOT_SIZE"KB boot disk..."
2044 TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize `du -sk $kernelpath | cut -f1` || Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
2045 echo -en "..."
2046 imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
2047 mountpoint=$MINDI_TMP/mountpoint.$$
2048 mkdir -p $mountpoint
2049 dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
2050 echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
2051 mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2052 syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2053
2054 mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2055
2056 # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2057 old_pwd=`pwd`
2058 MakeSyslinuxMessageFile $mountpoint/message.txt
2059 cd $mountpoint
2060 [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2061 cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2062 if [ "$NFS_DEV" != "" ] ; then
2063 perl -pi -e 's/interactive/iso/' syslinux.cfg
2064 fi
2065 cd $old_pwd
2066 echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2067 cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2068 if [ "$?" -ne "0" ] ; then
2069 LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2070 cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2071 LogIt "Please unload some of your modules and try again."
2072 rm -f $MINDI_TMP/mtpt.$$
2073 LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2074 retval=$(($retval+1))
2075 fi
2076
2077 mkdir -p $mountpoint/tmp
2078 cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2079
2080 # copy the kernel across
2081 [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2082 dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2083 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2084 cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2085 if [ "$?" -ne "0" ] ; then
2086 echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2087 du -sk $mountpoint/* >> $LOGFILE
2088 echo "--- end of list of files ---" >> $LOGFILE
2089 echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2090Sorry, your kernel is too big for your image.\n" >> $LOGFILE
2091 rm -f $mountpoint/vmlinuz
2092 cd $old_pwd
2093 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2094 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2095
2096 rm -f $imagefile
2097 return 0
2098 fi
2099 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2100 max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2101 echo "Free space left on image = $free_space KB" >> $LOGFILE
2102 echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
2103
2104 # make it bootable
2105 rm -f $mountpoint/zero
2106 mkdir -p $mountpoint/etc
2107 [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2108 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2109 echo -en "..."
2110 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2111
2112 if [ "$retval" -eq "0" ] ; then
2113 echo -en "...$DONE\n"
2114 if [ "$KERN_DISK_MADE" ] ; then
2115 rm -f $imagefile
2116 LogIt "$BOOT_SIZE KB boot disks were created OK\n"
2117 fi
2118 else
2119 echo -en "...failed\n"
2120 LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
2121 rm -f $imagefile
2122 fi
2123 [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2124 return $retval
2125}
2126
2127
2128PrepareDataDiskImages() {
2129 local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
2130
2131 imagesdir=$1
2132 rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2133 needlist=$MINDI_TMP/what-we-need.txt
2134 bigdir=$MINDI_TMP/bigdir
2135 minidir_root=$MINDI_TMP/minidir
2136 mkdir -p $minidir_root
2137 mkdir -p $bigdir/usr/bin
2138 tardir=$MINDI_TMP/tardir
2139
2140 if [ -e "$DEPLIST_FILE" ]; then
2141 lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
2142 else
2143 lfiles="$DEPLIST_DIR/*"
2144 fi
2145 lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
2146 cat $lfiles | GenerateGiantDependencyList $needlist $lines
2147 res=$?
2148 if [ "$YOUR_KERNEL_SUCKS" ]; then
2149 pwd=`pwd`
2150 cd $MINDI_TMP
2151 for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2152 cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2153 if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2154 cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2155 else
2156 ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2157 BIGNO=$(($BIGNO+1))
2158 fi
2159 done
2160 for i in $EXTRA_MODS ; do
2161 j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
2162 [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
2163 for k in $j ; do
2164 if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2165 cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2166 else
2167 ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2168 BIGNO=$(($BIGNO+1))
2169 fi
2170 echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2171 done
2172 done
2173 cd $pwd
2174 else
2175 ListKernelModulePaths >> $needlist
2176 fi
2177 if [ "$res" -ne "0" ] ; then
2178 Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2179 fi
2180 FindAndAddUserKeyboardMappingFile
2181 mkdir -p $bigdir/tmp
2182 if [ _"$MONDO_SHARE" != _"" ]; then
2183 cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
2184 fi
2185 [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2186 DropOptimizedLibraries $needlist $bigdir
2187 echo -en "Assembling dependency files"
2188 CopyDependenciesToDirectory < $needlist $bigdir
2189
2190 # also copy io.sys and msdos.sys, if we can find them
2191 for i in `mount | cut -d' ' -f3` ; do
2192 for j in io.sys msdos.sys ; do
2193 [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2194 done
2195 done
2196
2197 # master boot record, too
2198 if [ _"$MONDORESTORECFG" != _"" ]; then
2199 i=`grep bootloader.device $MONDORESTORECFG | cut -d'=' -f2 2> /dev/null`
2200 if [ "$i" ] ; then
2201 LogIt "Backing up $i's MBR"
2202 dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2203 sleep 1
2204 sync
2205 j=$i
2206 [ -h "$j" ] && j=`readlink -f $j`
2207 LogIt "Creating /dev/boot_device ($j)"
2208 mkdir -p $bigdir/dev
2209 cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2210 fi
2211 fi
2212
2213 old_pwd=`pwd`
2214 cd $bigdir
2215
2216 [ -e "$MINDI_LIB/aux-tools" ] || Die "aux-tools not found in Mindi's home dir. Do you have multiple copies of Mindi lying around? Please delete them. No, don't e-mail me and ask how. ;) Use 'rm'."
2217 cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2218 if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2219 tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2220 fi
2221 if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2222 cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2223 [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2224 fi
2225 [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2226 cd $old_pwd
2227 echo -e "$DONE"
2228 TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2229 SplitDirectoryIntoMinidirs $bigdir $minidir_root
2230 noof_disks=$?
2231 [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2232 MakeMountlist $MINDI_TMP/mountlist.txt
2233 mkdir -p $minidir_root/$noof_disks/tmp
2234 cp -f $MINDI_TMP/mountlist.txt $minidir_root/$noof_disks/tmp/mountlist.txt 2> /dev/null || Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
2235 if [ _"$MONDO_SHARE" != _"" ]; then
2236 cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2237 fi
2238 [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2239 cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2240 ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2241 CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2242 FRIENDLY_OUTSTRING="Boot and data disk images were created."
2243 # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2244 rmdir $tardir $bigdir
2245 rm -f $needlist
2246 return $noof_disks
2247}
2248
2249
2250ProcessLDD() {
2251 local incoming f d nd bd bnd
2252 read incoming
2253 while [ "$incoming" != "" ]; do
2254 # We take the full path name of the dyn. lib. we want
2255 incoming=`echo "$incoming" | awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
2256 for f in $incoming ; do
2257 # echo modified file name if one of the parent dir is a link
2258 # by replacing the original dirname by the destination of the link
2259 d="`dirname $f`"
2260 found="false"
2261 while [ "$d" != "/" ]; do
2262 if [ -h "$d" ]; then
2263 nd=`readlink -f $d`
2264 bd=`basename $d`
2265 bnd=`basename $nd`
2266 f=`echo $f | sed "s~/$bd/~/$bnd/~"`
2267 echo $d
2268 fi
2269 d="`dirname $d`"
2270 done
2271
2272 echo "$f"
2273 echo "`ReadAllLink $f`"
2274 done
2275 read incoming
2276 done
2277}
2278
2279
2280Prompt() {
2281 echo -en "$1"
2282 read line
2283}
2284
2285
2286ReadLine() {
2287 local i incoming
2288 read incoming
2289 i=0
2290 while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2291 i=$(($i+1))
2292 read incoming
2293 done
2294 echo "$incoming"
2295}
2296
2297
2298RejigHyperlinks() {
2299 local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2300 minidir_root=$1
2301 noof_disks=$2
2302
2303 old_pwd=`pwd`
2304 diskno=1
2305 while [ "$diskno" -le "$noof_disks" ] ; do
2306 mkdir -p $minidir_root/$diskno
2307 cd $minidir_root/$diskno
2308 for fname in `find -type d -o -print` ; do
2309 [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2310 done
2311 diskno=$(($diskno+1))
2312 done
2313
2314 cd $old_pwd
2315 return
2316}
2317
2318
2319ReplaceIndividualLine() {
2320 local orig_file new_file lino newstring lines_total lines_remaining
2321
2322 orig_file=$1.orig
2323 mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2324 new_file=$1
2325 lino=$2
2326 newstring="$3"
2327 if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2328 echo "Can't find string" >> $LOGFILE
2329 return 1
2330 fi
2331 lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2332 lines_remaining=$(($lines_total-$lino))
2333 head -n$(($lino-1)) $orig_file > $new_file
2334 echo "$newstring" >> $new_file
2335 echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2336 tail -n$lines_remaining $orig_file >> $new_file
2337 echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2338 [ -x "$orig_file" ] && chmod +x $new_file
2339 rm -f $orig_file
2340 return 0
2341}
2342
2343
2344ScanCDandTape() {
2345 local i
2346
2347 for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2348 dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2349 done
2350}
2351
2352
2353SizeOfPartition() {
2354 local devpath drive res stub
2355 device=$1
2356 if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2357 res=`SizeOfRaidPartition $device`
2358 [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2359 echo "$res"
2360 return 0
2361 fi
2362 # patch from Bill <bill@iwizard.biz> - 2003/08/25
2363 res=`$FDISK -s $device 2>> $LOGFILE`
2364 # end patch
2365 [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2366 [ "$res" = "" ] && res="-1"
2367 echo $res
2368 return 0
2369}
2370
2371
2372SizeOfRaidPartition() {
2373 local real_dev smallest_size silly tmp
2374
2375 silly=999999999
2376 smallest_size=$silly
2377
2378 for real_dev in `GetRaidDevMembers $1` ; do
2379 tmp=`SizeOfPartition $real_dev`
2380 [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2381 done
2382
2383 if [ "$smallest_size" = "$silly" ] ; then
2384 echo "-1"
2385 return 1
2386 else
2387 echo "$smallest_size"
2388 return 0
2389 fi
2390}
2391
2392
2393StripComments()
2394{
2395 local tempfile
2396
2397 tempfile=$MINDI_TMP/$$.strip.txt
2398 cp -f $1 $tempfile 2>> $LOGFILE
2399 $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2400 rm -f $tempfile
2401 echo "Stripped comments from $2" >> $LOGFILE
2402}
2403
2404
2405SplitDirectoryIntoMinidirs() {
2406 local bigdir minidir_root i noof_disks old_pwd res
2407
2408 bigdir=$1
2409 minidir_root=$2
2410 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2411
2412 TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2413 noof_disks=$?
2414 if [ "$noof_disks" -eq "0" ] ; then
2415 echo "Failed to fit data into several dirs."
2416 return 0
2417 fi
2418 RejigHyperlinks $minidir_root $noof_disks
2419 [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2420 return $noof_disks
2421}
2422
2423
2424StripExecutable()
2425{
2426 local tmpfile
2427
2428 tmpfile=$MINDI_TMP/stripped.$$.dat
2429 [ -d "$1" ] || [ -h "$1" ] && return
2430 cp -f $1 $tmpfile 2>> $LOGFILE
2431 strip $tmpfile 2> /dev/null
2432 if [ "$?" -eq "0" ] ; then
2433 cp -f $tmpfile $1 2>> $LOGFILE
2434 echo "Stripped binary $2" >> $LOGFILE
2435 fi
2436 rm -f $tmpfile
2437}
2438
2439
2440TemporarilyCompressAllFiles() {
2441 local i orig_fname out_fname out_list
2442
2443 i=0
2444 out_list=$2/compressed/compressed.txt
2445 mkdir -p $2/compressed
2446 > $out_list
2447 for orig_fname in $1 ; do
2448 out_fname=$2/compressed/$orig_fname.gz
2449 mkdir -p $out_fname 2> /dev/null
2450 rmdir $out_fname 2> /dev/null
2451 gzip -c6 $orig_fname > $out_fname 2> /dev/null
2452 i=$(((($i+1))%15))
2453 [ "$i" -eq "0" ] && echo -en "."
2454 du -sk $out_fname >> $out_list
2455 done
2456}
2457
2458
2459TryToFindKernelPath() {
2460 local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2461
2462 we_want_version=`uname -r`
2463 possible_kernels=""
2464 duff_kernels=""
2465
2466 if [ "$ARCH" = "ia64" ] ; then
2467 root="/boot/efi/efi"
2468 else
2469 root="/"
2470 fi
2471 for fname in `find $root -maxdepth 2 -type f | grep -E 'lin|kern' | grep -Ev '^/proc/|^/net/'` ; do
2472 [ ! -e "$fname" ] && continue
2473 [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2474 file $fname | grep -q gzip
2475 if [ "$?" -eq "0" ] ; then
2476 # Used by ia64
2477 fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2478 else
2479 fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2480 fi
2481 [ "$fkern_ver" = "" ] && continue
2482 [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2483 [ -f "$fname" ] || continue
2484 [ -h "$fname" ] && continue
2485 kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2486 file $fname | grep -q gzip
2487 if [ "$?" -eq "0" ] ; then
2488 # Used by ia64
2489 if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2490 LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2491 duff_kernels="$fname $duff_kernels"
2492 else
2493 [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2494 possible_kernels="$fname $possible_kernels"
2495 fi
2496 else
2497 if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2498 LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2499 duff_kernels="$fname $duff_kernels"
2500 else
2501 [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2502 possible_kernels="$fname $possible_kernels"
2503 fi
2504 fi
2505 done
2506 if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2507 possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2508 fi
2509 if [ ! "$possible_kernels" ] ; then
2510 LogIt "No kernel matches exactly. Are there any duff kernels?"
2511 possible_kernels="$duff_kernels"
2512 if [ ! "$possible_kernels" ] ; then
2513 LogIt "Sorry, no duff kernels either"
2514 else
2515 LogIt "I bet you're running Debian or Gentoo, aren't you?"
2516 LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2517 fi
2518 fi
2519 possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2520 noof_kernels=`CountItemsIn "$possible_kernels"`
2521 if [ "$noof_kernels" -eq "0" ] ; then
2522 LogIt "Could not find your kernel."
2523 if [ -e "/boot/vmlinuz" ] ; then
2524 LogIt "Using /boot/vmlinuz as a last resort."
2525 output=/boot/vmlinuz
2526 else
2527 output=""
2528 fi
2529 elif [ "$noof_kernels" -eq "1" ] ; then
2530 kernelpath=`echo "$possible_kernels" | sed s/' '//`
2531 echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2532 output="$kernelpath"
2533 else
2534 for i in $possible_kernels ; do
2535 if echo $i | grep "`uname -r`" ; then
2536 LogIt "OK, I used my initiative and found that "
2537 LogIt "$i is probably your kernel. "
2538 output="$i"
2539 return
2540 fi
2541 done
2542 if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2543 output=/boot/vmlinuz
2544 echo "Schlomo, this one's for you." >> $LOGFILE
2545 else
2546 LogIt "Two or more possible kernels found. You may specify any one of them and the "
2547 LogIt "boot disks will still work, probably. If one does not work, try another."
2548 LogIt "$possible_kernels"
2549 echo ""
2550 fi
2551 fi
2552 echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2553}
2554
2555
2556TryToFitDataIntoSeveralDirs() {
2557 local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2558 local i retval noof_disks total_files list_of_devs
2559
2560 bigdir=$1
2561 minidir_root=$2
2562 BIG_CLUNKY_SIZE_COUNTER=0
2563 retval=0
2564 noof_disks=1
2565
2566 echo -en "\r \rDividing data into several groups..."
2567 old_pwd=`pwd`
2568 cd $bigdir
2569 list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2570 progress=0
2571 total_files=`CountItemsIn "$list_of_files"`
2572 if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2573 filesize=1
2574 fi
2575 mkdir -p $minidir_root/$noof_disks
2576 if [ -e "dev" ] ; then
2577 echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2578 cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2579 fi
2580 TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2581 for filename in $list_of_files ; do
2582 AddFileToDir $filename $minidir_root $noof_disks
2583 i=$?
2584 if [ "$i" -gt "$noof_disks" ] ; then
2585 noof_disks=$i
2586 echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2587 fi
2588 if [ "$i" -eq "0" ] ; then
2589 LogIt "Cannot add file $filename to minidir $minidir_root"
2590 retval=$(($retval+1))
2591 fi
2592 progress=$(($progress+1))
2593 echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2594 done
2595 cd $old_pwd
2596 echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
2597 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2598 if [ "$retval" -gt "0" ] ; then
2599 return 0
2600 else
2601 return $noof_disks
2602 fi
2603}
2604
2605
2606TurnTgzIntoRdz() {
2607 local tgz_dir_fname rdz_fname ramdisksize tempfile mountpoint old_pwd nodes kernelsize maxsize res currsize not_copied j k s w needed_modules_path
2608
2609 tgz_dir_fname=$1
2610 rdz_fname=$2
2611 ramdisksize=$3
2612 kernelsize=$4
2613 maxsize=$(($BOOT_SIZE-$kernelsize))
2614 maxsize=$(($maxsize*2)); # to allow for compression of 50%
2615 tempfile=$MINDI_TMP/temp.rd
2616 mountpoint=$MINDI_TMP/mnt1
2617 res=0
2618 echo -en "..."
2619 dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2620 echo -en "..."
2621 echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2622 mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE || Die "Unable to create an ext2 file system on $tempfile"
2623 echo -en "..."
2624 mkdir -p $mountpoint
2625 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."
2626 echo -en "..."
2627 old_pwd=`pwd`
2628 cd $mountpoint
2629 cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2630 tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2631 cd dev || Die "Can't cd to dev"
2632 tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2633 rm -f dev-entries.tgz
2634 cd ..
2635
2636 for w in insmod.static insmod.static.old ; do
2637 s=`which $w 2> /dev/null`
2638 if [ -e "$s" ] ; then
2639 cp --parents -af $s . 2>> $LOGFILE
2640 fi
2641 done
2642
2643 mkdir -p tmp
2644 [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2645
2646 # Handle the case where busybox and mount are dynamically linked
2647 # Should be done first so that if /lib64 is a link, it's
2648 # created first like that, instead of as a real dir later on
2649 file $MINDI_LIB/rootfs/bin/busybox 2>&1 | grep -q "dynamically"
2650 if [ $? -eq 0 ]; then
2651 LocateDeps $MINDI_LIB/rootfs/bin/busybox /bin/mount > $MINDI_TMP/busy.lis
2652 cp --parents -Rdf `sort -u $MINDI_TMP/busy.lis` .
2653 rm -f $MINDI_TMP/busy.lis
2654 fi
2655
2656 # Management of udev (which includes modprobe in rules)
2657 ps auxww | grep -v grep | grep -qw udevd
2658 if [ $? -eq 0 ]; then
2659 echo "udev device manager found" > tmp/USE-UDEV
2660 LogIt "udev device manager found"
2661 cp --parents -Rdf /etc/udev . 2> /dev/null
2662 # This avoids NIC remapping if on another machine at restore time on Debian at least
2663 rm -f ./etc/udev/rules.d/z25_persistent-net.rules
2664 cp --parents -Rdf /lib/udev /lib64/udev . 2> /dev/null
2665 if [ -x /sbin/udevd ]; then
2666 lis2=`grep -Ev '^#' $MINDI_CONF/udev.files`
2667 lis=""
2668 # Get only the files which exist in that list
2669 # and potentially their symlink structure
2670 for i in $lis2; do
2671 if [ -h $i ]; then
2672 j=$i
2673 while [ -h $j ]; do
2674 lis="$lis $j"
2675 j=`readlink $j`
2676 done
2677 lis="$lis $j"
2678 elif [ -f $i ]; then
2679 lis="$lis $i"
2680 fi
2681 done
2682 # And their deps
2683 LocateDeps $lis > $MINDI_TMP/udev.lis
2684 for i in $lis; do
2685 if [ "`echo $i | cut -c1`" = "/" ]; then
2686 j=`echo $i | cut -c2-`
2687 rm -f $j
2688 fi
2689 done
2690 cp --parents -Rdf $lis `sort -u $MINDI_TMP/udev.lis` .
2691 rm -f $MINDI_TMP/udev.lis
2692 else
2693 echo "udevd daemon not in standard place (/sbin)" 2>&1 | tee -a $LOGFILE
2694 echo "mindi will use static devices which may cause problems" 2>&1 | tee -a $LOGFILE
2695 rm -f tmp/USE-UDEV
2696 fi
2697 fi
2698
2699 # Management of potential HW info (Proliant only at the moment)
2700 rm -rf $MINDI_CACHE/bkphw
2701 mindi-bkphw $MINDI_CACHE $MINDI_CONF | tee -a $LOGFILE
2702 if [ -d $MINDI_CACHE/bkphw ]; then
2703 LogIt "Hardware Information found and saved ..."
2704 cp -rp $MINDI_CACHE/bkphw .
2705 if [ -f $MINDI_CACHE/tools.files ]; then
2706 lis=`grep -Ev '^#' $MINDI_CACHE/tools.files`
2707 LocateDeps $lis > $MINDI_TMP/tools.lis
2708 cp --parents -Rdf $lis `sort -u $MINDI_TMP/tools.lis` .
2709 fi
2710 if [ -f $MINDI_CACHE/mindi-rsthw ]; then
2711 mv -f $MINDI_CACHE/mindi-rsthw .
2712 chmod 755 ./mindi-rsthw
2713 fi
2714 rm -f $MINDI_TMP/tools.lis $MINDI_CACHE/tools.files
2715 fi
2716
2717 for w in cdrom groovy-stuff ; do
2718 mkdir -p mnt/$w
2719 done
2720 #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2721 #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2722 #fi
2723 if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2724 ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2725 fi
2726
2727 cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2728
2729 cd $old_pwd
2730 echo -en "..."
2731 MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2732 echo -en "..."
2733 old_pwd=`pwd`
2734 if [ "$YOUR_KERNEL_SUCKS" ] ; then
2735 cd $MINDI_TMP
2736 needed_modules_path=lib/modules/$FAILSAFE_KVER
2737 else
2738 cd /
2739 if [ "${kernelname}" != "" ]
2740 then
2741 needed_modules_path=lib/modules/${kernelname}
2742 else
2743 needed_modules_path=lib/modules/`uname -r`
2744 fi
2745 fi
2746
2747 needed_modules=""
2748 list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2749
2750 if [ "$NFS_DEV" != "" ] ; then
2751 # For PXE boot
2752 list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2753 fi
2754 if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2755 list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
2756 fi
2757 for i in $DENY_MODS; do
2758 echo "Removing $i from the list of modules to load" >> $LOGFILE
2759 list_of_groovy_mods=`echo ${list_of_groovy_mods} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
2760 done
2761
2762 [ -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."
2763 for i in $list_of_groovy_mods ; do
2764 needed_modules="$needed_modules `FindSpecificModuleInPath $needed_modules_path $i`"
2765 done
2766 for i in $needed_modules ; do
2767 [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2768 [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2769 echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2770 cp --parents -pdf $i $mountpoint 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2771 # Uncompress modules if not useing udev and native modprobe
2772 if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
2773 if [ "`echo "$i" | grep -F ".gz"`" ]; then
2774 gunzip -f $mountpoint/$i
2775 #i=`echo $i | sed 's/.gz//'`
2776 fi
2777 fi
2778 done
2779
2780 # Also copy modules.dep in case of udev so that normal modprobe works
2781 cp --parents -pdf /$needed_modules_path/modules.dep $mountpoint 2>/dev/null || LogIt "Unable to copy modules.dep to $mountpoint"
2782
2783 # For all modules supported, create symlinks under the mountpoint
2784 for i in $EXTRA_MODS $NET_MODS $SCSI_MODS; do
2785 all_modules="$all_modules `FindSpecificModuleInPath $mountpoint $i | sed 's~^$mountpoint/~~g'`"
2786 done
2787 for i in $all_modules; do
2788 (cd $mountpoint ; ln -s $i . 2>/dev/null)
2789 done
2790 if [ ! -e "/sbin/devfsd" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2791 echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2792 [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2793 [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2794 rm -f $mountpoint/sbin/devfsd
2795 fi
2796 cd $old_pwd
2797 [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2798 dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2799 rm -f $mountpoint/zero
2800 mkdir -p $mountpoint/tmp
2801 if [ _"$MONDO_SHARE" != _"" ]; then
2802 cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null || Die "Cannot copy mondo-restore.cfg to ramdisk"
2803 cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2804 fi
2805 mkdir -p $mountpoint/proc
2806 echo "$BOOT_SIZE" > $mountpoint/tmp/$BOOT_SIZE.siz
2807 # Determine what filesystem to use for initrd image
2808 echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2809 gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2810 [ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2811 case "$gvFileSystem" in
2812 "ext2fs")
2813 # say what will be used
2814 echo "Creating an ext2 initrd image..." >> $LOGFILE
2815 # kernel expects linuxrc in ext2 filesystem
2816 ( cd $mountpoint && ln -sf sbin/init linuxrc )
2817 # unmount loop filesystem and create image file using the standard approach
2818 umount $mountpoint || Die "Cannot unmount $tempfile"
2819 dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2820 bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2 | sed 's/^ *//'`
2821 ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2822 gzip -c9 ${rdz_fname}.tmp > $rdz_fname
2823 rm -f ${rdz_fname}.tmp
2824 # log that we are done
2825 echo "...done." >> $LOGFILE
2826 ;;
2827 "initramfs")
2828 # say what will be used
2829 echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2830 # make sure that cpio is there
2831 which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2832 # go into filesystem
2833 cd $mountpoint
2834 # kernel expects init in cpio filesystem
2835 ln -sf sbin/init init
2836 # create cpio image file and unmount loop filesystem
2837 find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2838 cd $old_pwd
2839 umount $mountpoint || Die "Cannot unmount $tempfile"
2840 # log that we are done
2841 echo "...done." >> $LOGFILE
2842 ;;
2843 *)
2844 Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2845 ;;
2846 esac
2847 if [ "$res" -eq "0" ] ; then
2848 echo -en "..."
2849 else
2850 echo -en "\rMade an rdz WITH ERRORS. \n"
2851 fi
2852 return 0
2853}
2854
2855
2856WhichOfTheseModulesAreLoaded() {
2857 local modname loaded_modules
2858 loaded_modules="$MODULES"
2859 for modname in $1 ; do
2860 [ "`echo "$loaded_modules" | grep -w "$modname"`" ] && echo "$modname"
2861 done
2862}
2863
2864
2865ZipMinidirsIntoTarballs() {
2866 local minidir_root tardir noof_disks diskno old_pwd i
2867 minidir_root=$1
2868 tardir=$2
2869 noof_disks=$3
2870
2871 echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2872 mkdir -p $tardir
2873 mkdir -p $minidir_root/all
2874 old_pwd=`pwd`
2875 diskno=1
2876 while [ "$diskno" -le "$noof_disks" ] ; do
2877 cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2878 tar -cf - . 2>> $LOGFILE | gzip -9 > $tardir/$diskno.tar.gz || Die "Can't tar/gzip disk#$diskno; please tell Dev Team -exactly- what the errors where."
2879 diskno=$(($diskno+1))
2880 echo -n "..."
2881 cp -pRdf * $minidir_root/all 2>> $LOGFILE
2882 done
2883 mkdir -p $minidir_root/all/tmp
2884 cd $minidir_root/all
2885 size_of_all_tools=`du -sk . | cut -f1`
2886 if [ _"$MONDO_SHARE" != _"" ]; then
2887 for q in filelist.full.gz biggielist.txt ; do
2888 [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2889 cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2890 done
2891 mkdir -p $minidir_root/all/tmp
2892 fi
2893 tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2894 dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2895 [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2896 cd $old_pwd
2897 [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2898 echo -e "$DONE"
2899}
2900
2901
2902##############################################################################
2903#----------------------------------- Main -----------------------------------#
2904##############################################################################
2905
2906# Now we can create what we need
2907mkdir -p $MINDI_TMP
2908
2909# Purge from potential old run
2910if [ _"$MINDI_CACHE" = _"" ]; then
2911 Die "MINDI_CACHE undefined"
2912fi
2913rm -rf $MINDI_CACHE/* 2> /dev/null
2914mkdir -p $MINDI_CACHE
2915
2916if [ "$1" = "--printvar" ] ; then
2917 shift
2918 if [ _"$1" != _"" ] ; then
2919 set | grep -Ew "^$1" | cut -d= -f2
2920 fi
2921 MindiExit 0
2922fi
2923
2924> $LOGFILE
2925echo "mindi v$MINDI_VERSION" >> $LOGFILE
2926echo "$ARCH architecture detected" >> $LOGFILE
2927echo "mindi called with the following arguments:" >> $LOGFILE
2928echo "$@" >> $LOGFILE
2929echo "Start date : `date`" >> $LOGFILE
2930echo "-----------------------------" >> $LOGFILE
2931
2932if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2933 LogIt "WARNING - Ancient distro detected." 1
2934 ln -sf /etc/conf.modules /etc/modules.conf
2935fi
2936[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2937
2938# Log some capital variables
2939[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2940echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2941echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2942echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2943[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2944echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2945if [ -f $MINDI_CONFIG ]; then
2946 echo "-----------------------------" >> $LOGFILE
2947 echo " Mindi configuration file " >> $LOGFILE
2948 echo "-----------------------------" >> $LOGFILE
2949 grep -Ev '^#' $MINDI_CONFIG >> $LOGFILE
2950 echo "-----------------------------" >> $LOGFILE
2951fi
2952
2953
2954trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2955
2956# Sanity checks
2957which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2958which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2959which 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."
2960which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2961if which awk &> /dev/null ; then
2962 if ! which gawk &> /dev/null ; then
2963 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"
2964 fi
2965fi
2966which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2967[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2968
2969[ "`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"
2970# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2971# may have the modprobe configuration spread out across multiple files in
2972# directory /etc/modprobe.d. If this is the case we concatenate these files into
2973# a temporary file for further processing. Otherwise we continue in the standard
2974# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2975# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2976# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2977if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
2978 TMPMODPROBE_FLAG="Y"
2979else
2980 TMPMODPROBE_FLAG="N"
2981 [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2982 [ ! -e "/etc/modules.conf" ] && Die "/etc/modules.conf not found; you may have to create a softlink from /etc/conf.modules to /etc/modules.conf; of course, all good distros use modules.conf anyway..."
2983fi
2984
2985# Update the PATH variable if incomplete
2986if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2987 PATH=$PATH:/sbin:/usr/sbin
2988 export PATH
2989 echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2990 echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2991 echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2992fi
2993
2994# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2995if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2996 source $MINDI_LIB/FindDistroFailsafe
2997 # Log kernel image
2998 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2999else
3000 [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
3001fi
3002
3003if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
3004 Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
3005fi
3006
3007### BERLIOS
3008### Fix as it's not mandatory on ia64
3009if [ "$ARCH" = "ia64" ] ; then
3010 if which elilo &> /dev/null ; then
3011 LILO_EXE=elilo
3012 else
3013 LILO_EXE=`which false`
3014 fi
3015else
3016 FindIsolinuxBinary
3017 FindLiloBinary
3018fi
3019trap "Aborted" SIGTERM
3020DONE="\r\t\t\t\t\t\t\t\tDone. "
3021CHOPSIZE=240
3022BIGNO=0
3023MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
3024
3025#
3026# Kernel management: Attempt to locate kernel specific module path
3027# if module path is found then use it other wise use uname -r to set it...
3028#
3029#
3030kernelpath="$mindi_kernel"
3031if [ "$kernelpath" = "NATIVE" ]; then
3032 kernelpath=""
3033fi
3034if [ "$kernelpath" = "" ]; then
3035 kernelpath=`TryToFindKernelPath`
3036fi
3037kernelname=`echo $kernelpath | cut -d'-' -f2-`
3038echo "kernelname = $kernelname" >> $LOGFILE
3039echo "kernelpath = $kernelpath" >> $LOGFILE
3040if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3041then
3042 echo "Module path for ${kernelpath} not found..." >> $LOGFILE
3043 echo "using running kernel\'s modules." >> $LOGFILE
3044 kernelname=`uname -r`
3045else
3046 echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3047fi
3048
3049if [ -d "/proc/lvm" ]; then
3050 # LVM v1
3051 LVMCMD=""
3052 LVM="v1"
3053elif [ -d "/dev/mapper" ]; then
3054 # LVM v2
3055 LVMCMD="lvm"
3056 LVM="v2"
3057else
3058 LVM="false"
3059fi
3060echo "LVM set to $LVM" >> $LOGFILE
3061echo "----------" >> $LOGFILE
3062echo "mount result:" >> $LOGFILE
3063echo "-------------" >> $LOGFILE
3064mount >> $LOGFILE
3065echo "-------------" >> $LOGFILE
3066if [ -e /etc/raidtab ]; then
3067 echo "-------------" >> $LOGFILE
3068 echo "/etc/raidtab content:" >> $LOGFILE
3069 echo "-------------" >> $LOGFILE
3070 cat /etc/raidtab >> $LOGFILE
3071fi
3072echo "-------------" >> $LOGFILE
3073echo "cat /proc/cmdline:" >> $LOGFILE
3074echo "-------------" >> $LOGFILE
3075cat /proc/cmdline >> $LOGFILE
3076echo "-------------" >> $LOGFILE
3077echo "lsmod result:" >> $LOGFILE
3078echo "-------------" >> $LOGFILE
3079lsmod >> $LOGFILE
3080MODULES="`cat /proc/modules | awk '{print $1}'`"
3081if [ -x /usr/sbin/esxcfg-module ]; then
3082 echo "-------------" >> $LOGFILE
3083 echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
3084 echo "-------------" >> $LOGFILE
3085 echo "VMWare modules" >> $LOGFILE
3086 echo "-------------" >> $LOGFILE
3087 /usr/sbin/esxcfg-module -l >> $LOGFILE
3088 MODULES="$MODULES `/usr/sbin/esxcfg-module -l | awk '{print $1}'`"
3089fi
3090echo "FORCE_MODS:" >> $LOGFILE
3091echo "-------------" >> $LOGFILE
3092echo $FORCE_MODS >> $LOGFILE
3093echo "-------------" >> $LOGFILE
3094echo "DENY_MODS:" >> $LOGFILE
3095echo "-------------" >> $LOGFILE
3096echo $DENY_MODS >> $LOGFILE
3097echo "-------------" >> $LOGFILE
3098echo "df result:" >> $LOGFILE
3099echo "----------" >> $LOGFILE
3100df -T >> $LOGFILE
3101echo "-------------" >> $LOGFILE
3102echo "Liste of extra modules is:" >> $LOGFILE
3103echo "$EXTRA_MODS" >> $LOGFILE
3104echo "-------------" >> $LOGFILE
3105
3106# Compute libata version
3107laver=`modinfo libata | grep -Ei '^Version:' | cut -d: -f2 | cut -d. -f1 | sed 's/ *//g' 2> /dev/null`
3108# If libata v2 is used then remove ide-generic as it will perturbate boot
3109if [ "`echo $MODULES | grep libata`" ]; then
3110 if [ "$laver" = "2" ]; then
3111 DENY_MODS="$DENY_MODS ide-generic"
3112 echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
3113 echo "-------------" >> $LOGFILE
3114 fi
3115fi
3116
3117FLOPPY_WAS_MOUNTED=""
3118for mtpt in /media/floppy /mnt/floppy /floppy ; do
3119 if mount | grep -w $mtpt &> /dev/null ; then
3120 FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3121 umount $mtpt
3122 fi
3123done
3124
3125#
3126# If we have a USB device we need to store info
3127# and remove it from the parameters line
3128#
3129if [ "$#" -ne "0" ] ; then
3130 if [ "$1" = "--usb" ] ; then
3131 shift
3132 USBDEVICE=$1
3133 if [ _"$USBDEVICE" = _"" ]; then
3134 Die "No USB device specified"
3135 fi
3136 shift
3137 fi
3138fi
3139
3140#
3141# Default value for parameters coming from mondo potentially
3142#
3143if [ "$ARCH" = "ia64" ] ; then
3144 USE_LILO=yes
3145else
3146 USE_LILO=no
3147fi
3148
3149#
3150# These variables are normaly only significant in a mondo environment
3151# Not enforced yet
3152#
3153CDRECOVERY="no"
3154NOT_BOOT="no"
3155EXCLUDE_DEVS=""
3156IMAGE_DEVS=""
3157NFS_DEV=""
3158
3159#
3160# Deal with parameters
3161#
3162if [ "$#" -ne "0" ] ; then
3163 if [ "$1" = "--findkernel" ] ; then
3164 res=`TryToFindKernelPath`
3165 # Avoids logfile content for mondo
3166 export MONDO_SHARE=""
3167 if [ "$res" = "" ] ; then
3168 MindiExit -1
3169 else
3170 echo "$res"
3171 MindiExit 0
3172 fi
3173 elif [ "$1" = "--locatedeps" ] ; then
3174 [ ! "$2" ] && Die "Please specify the binary to look at"
3175 LocateDeps $2
3176 # Avoids logfile content for mondo
3177 export MONDO_SHARE=""
3178 MindiExit $?
3179 elif [ "$1" = "--readalllink" ] ; then
3180 [ ! "$2" ] && Die "Please specify the binary to look at"
3181 ReadAllLink $2
3182 # Avoids logfile content for mondo
3183 export MONDO_SHARE=""
3184 MindiExit $?
3185 elif [ "$1" = "--makemountlist" ] ; then
3186 [ ! "$2" ] && Die "Please specify the output file"
3187 MakeMountlist $2
3188 # Avoids logfile content for mondo
3189 export MONDO_SHARE=""
3190 MindiExit $?
3191 elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3192 echo "Mindi v$MINDI_VERSION"
3193 # Avoids logfile content for mondo
3194 export MONDO_SHARE=""
3195 MindiExit 0
3196 elif [ "$1" = "--custom" ] ; then
3197 if [ _"$MONDO_SHARE" = _"" ]; then
3198 Die "--custom is reserved for mondoarchive calls"
3199 fi
3200 MONDO_TMP=$2
3201 # Change MINDI_TMP for the one provided by mondo
3202 # So that it can get back the built files
3203 mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3204 rmdir $MINDI_TMP
3205 export MINDI_TMP=$MONDO_TMP
3206 mkdir -p $MINDI_TMP
3207 # This is the scratch dir in mondo - subdir images
3208 MINDI_CACHE=$3
3209 if [ _"$MINDI_CACHE" != _"" ]; then
3210 mkdir -p $MINDI_CACHE
3211 fi
3212
3213 if [ ! -e "$MONDORESTORECFG" ]; then
3214 Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3215 fi
3216
3217 if [ ! -e "$MONDO_CACHE" ]; then
3218 Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3219 else
3220 #
3221 # Get from mondo our additional configuration
3222 #
3223 echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3224 if [ -f $MONDO_CACHE/mindi.conf ]; then
3225 . $MONDO_CACHE/mindi.conf
3226 echo "-----------------------------" >> $LOGFILE
3227 echo " Mondo configuration file " >> $LOGFILE
3228 echo "-----------------------------" >> $LOGFILE
3229 cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3230 echo "-----------------------------" >> $LOGFILE
3231 else
3232 Die "No mindi.conf file created by mondo. Aborting"
3233 fi
3234 fi
3235
3236 echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3237 echo "------------------------------------" >> $LOGFILE
3238 cat $MONDORESTORECFG >> $LOGFILE
3239 echo "-----------------------------------" >> $LOGFILE
3240
3241 CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3242 NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3243 USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3244 EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3245 NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3246 VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3247 if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3248 IMAGE_DEVS=""
3249 else
3250 IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3251 fi
3252 [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3253 # MONDO_ROOT is the real scratchdir
3254 MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3255 if [ _"$MONDO_ROOT" != _"" ]; then
3256 mkdir -p $MONDO_ROOT
3257 else
3258 Die "MONDO_ROOT is undefined"
3259 fi
3260 else
3261 echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3262 MindiExit -1
3263 fi
3264fi
3265#ScanCDandTape
3266[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3267if [ "$CDRECOVERY" = "yes" ] ; then
3268 iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3269 sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3270else
3271 iso_cfg_file=$MINDI_LIB/isolinux.cfg
3272 sys_cfg_file=$MINDI_LIB/syslinux.cfg
3273fi
3274
3275[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3276if [ _"$MONDO_SHARE" = _"" ]; then
3277 LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3278 LogIt "Latest Mindi is available from http://www.mondorescue.org"
3279 LogIt "BusyBox sources are available from http://www.busybox.net"
3280 LogIt "------------------------------------------------------------------------------"
3281else
3282 echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3283fi
3284if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3285 LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3286else
3287 LogIt "Unable to find mindi-busybox, please install it"
3288 MindiExit -1
3289fi
3290
3291# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3292insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3293for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3294 insmod $i >> $LOGFILE 2>> $LOGFILE
3295done
3296
3297KERN_DISK_MADE=""
3298
3299if [ "$NOT_BOOT" = "yes" ]; then
3300 LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3301 mkdir -p $MINDI_TMP/small-all/tmp
3302 MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3303 cp -f $MINDI_TMP/{filelist.full.gz,biggielist.txt} $MONDO_CACHE/mondo-restore.cfg $MINDI_CACHE/small-all/tmp 2>/dev/null || Die "Cannot copy small all.tar.gz"
3304 cd $MINDI_TMP/small-all
3305 tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3306 sync
3307 LogIt "Done. Exiting."
3308 MindiExit 0
3309fi
3310
3311if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3312 LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3313fi
3314
3315if [ "$kernelpath" = "" ] ; then
3316 if [ _"$MONDO_SHARE" != _"" ]; then
3317 Die "Please use -k <path> to specify kernel."
3318 else
3319 USE_OWN_KERNEL="no"
3320 fi
3321 if [ "$INTERACTIVE" = "yes" ]; then
3322 echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3323 read ch
3324 if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3325 USE_OWN_KERNEL="yes"
3326 fi
3327 fi
3328 if [ "$USE_OWN_KERNEL" = "yes" ]; then
3329 YOUR_KERNEL_SUCKS=""
3330 kernelpath=`TryToFindKernelPath`
3331 if [ "$kernelpath" = "" ] ; then
3332 echo -n "Please enter kernel path : "
3333 read kernelpath
3334 fi
3335 else
3336 YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3337 fi
3338fi
3339if [ _"$MONDO_SHARE" = _"" ] && [ "$INTERACTIVE" = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3340 echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot image (y/[n]) ?"
3341 read ch
3342 if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
3343 USE_LILO=no
3344 else
3345 USE_LILO=yes
3346 fi
3347fi
3348if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3349 # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3350 if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3351 source $MINDI_LIB/FindDistroFailsafe
3352 # Log kernel image
3353 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3354 kernelpath="$FAILSAFE_KBIN"
3355 LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3356 LogIt "The failsafe kernel is $kernelpath.\n"
3357 LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3358 LogIt "disks then it may still be a result of a problem with your kernel.\n"
3359 pwd=`pwd`
3360 cd $MINDI_TMP
3361 mkdir -p lib/modules
3362 cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3363 cd $pwd
3364 else
3365 kernelpath=$MINDI_LIB/vmlinuz
3366 LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3367 LogIt "However, you are still running your kernel. If Mindi fails to create your"
3368 LogIt "disks then it may still be a result of a problem with your kernel."
3369 pwd=`pwd`
3370 cd $MINDI_TMP
3371 bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3372 cd $pwd
3373 fi
3374 YOUR_KERNEL_SUCKS="Your kernel sucks"
3375fi
3376echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3377[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3378
3379[ "$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."
3380
3381PrepareDataDiskImages $MINDI_CACHE
3382noof_disks=$?
3383ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3384rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3385ramdisk_size=$rds
3386
3387echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3388if [ "$ARCH" = "ia64" ] ; then
3389 PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create ia64 image disk image."
3390else
3391 if [ "$USE_LILO" = "yes" ] ; then
3392 PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE MB disk image."
3393 else
3394 PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE MB disk image."
3395 fi
3396fi
3397
3398[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3399...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3400
3401if [ _"$MONDO_SHARE" = _"" ]; then
3402 ListImagesForUser $MINDI_CACHE
3403 OfferToMakeBootableISO $MINDI_CACHE
3404 if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3405 OfferToMakeBootableUSB $MINDI_CACHE
3406 fi
3407 LogIt "Finished."
3408elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3409 rm -f $MINDI_CACHE/{*img,*gz,*iso}
3410 OfferToMakeBootableISO $MINDI_CACHE
3411 if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3412 cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3413 else
3414 Die "Cannot find all.tar.gz, to be written to tape"
3415 fi
3416elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3417 OfferToMakeBootableUSB $MINDI_CACHE
3418else
3419 OfferToMakeBootableISO $MINDI_CACHE
3420fi
3421# cleanup
3422LogIt "$FRIENDLY_OUTSTRING"
3423for mtpt in $FLOPPY_WAS_MOUNTED ; do
3424 mount $mtpt
3425done
3426MindiExit 0
Note: See TracBrowser for help on using the repository browser.