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

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

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