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

Last change on this file since 1163 was 1163, checked in by Bruno Cornec, 17 years ago

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