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

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

Better log file content in mondoarchive.log from the copy of the mindi log
  • Property svn:keywords set to Rev Id
File size: 113.9 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1350 2007-04-25 16:01:31Z 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
85BOOT_SIZE=$mindi_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"
112FORCE_MODS="mindi_force_mods"
113
114BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
115FDISK=$MINDI_SBIN/parted2fdisk
116MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
117
118# ----------------------------------------------------------------------------
119
120
121AbortHere() {
122 [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
123 Die "Program is terminating in response to signal received from OS/user"
124}
125
126
127HackSyslinuxFile() {
128 local incoming
129 incoming=`ReadLine`
130 while [ "$incoming" ] ; do
131 echo -en "$incoming" | sed s/24000/$1/
132 if [ "`echo "$incoming" | grep append`" ] ; then
133 echo -en " $ADDITIONAL_BOOT_PARAMS"
134 fi
135 echo -en "\n"
136 incoming=`ReadLine`
137 done
138 if [ -e "$MINDI_LIB/memtest.img" ] ; then
139 echo -en "label memtest\n kernel memdisk\n append initrd=memtest.img\n\n"
140 fi
141}
142
143
144Aborted() {
145 trap SIGHUP SIGTERM SIGTRAP SIGINT
146 [ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindi*img $MINDI_CACHE/*gz $MINDI_CACHE/mindi.iso
147 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
148 Die "User abort."
149}
150
151
152AddFileToDir() {
153 local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
154 filename=$1
155 minidir_root=$2
156 noof_disks=$3
157
158 diskno=$noof_disks
159 mkdir -p $minidir_root/$diskno
160 [ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
161 if [ ! -e "$filename" ] ; then
162 if [ -h "$filename" ] ; then
163 cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
164 return $noof_disks
165 else
166 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?"
167 fi
168 fi
169
170 # move to the disk that has room on it (or end up using the last, if all full)
171 while [ "$diskno" -lt "40" ] ; do
172 mkdir -p $minidir_root/$diskno
173 filesize=`du -sk $filename | cut -f1`
174 cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
175 if [ "$filesize" -le "4" ] ; then
176 siz=$filesize
177 elif [ ! -f "$filename" ] ; then
178 siz=0
179 else
180 siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt | cut -f1`
181 [ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
182 siz=$(($siz-2));# to allow for sectors & the fact that they round up
183 fi
184 [ ! "$siz" ] && siz=4
185 [ "$siz" -lt "0" ] && siz=0
186 LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
187 [ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
188 echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
189 LAST_COMPRESSED_SIZE=0
190 rm -f $minidir_root/$diskno/$filename
191 diskno=$(($diskno+1))
192 done
193 return 0 ; # failed
194}
195
196
197AddKeyboardMappingFile() {
198 local mappath r included_list included_item i res ii sss
199 mappath=$1
200 KBDEPTH=$(($KBDEPTH+1))
201 [ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
202 if [ -e "$bigdir/$mappath" ] ; then
203 echo "$mappath already added" >> $LOGFILE
204 return
205 elif [ -d "$bigdir/$mappath" ] ; then
206 echo "Cannot add $mappath: it's a directory. Sorry."
207 return
208 fi
209 echo "Added kbd map $mappath" >> $LOGFILE
210 if [ ! -e "$mappath" ] ; then
211 mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
212 if [ ! -e "$mappath" ] ; then
213 LogIt "Cannot add $mappath: kbd map file not found"
214 return
215 fi
216 else
217 echo -en "`basename $mappath | tr '.' '#' | sed s/#kmap#gz// | sed s/#inc#gz//` " | tr '#' '.'
218 fi
219
220 mkdir -p $bigdir/etc
221 cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE || LogIt "AKMF -- Could not copy $mappath to $bigdir"
222 if [ "`echo $mappath | grep -F ".gz"`" ] ; then
223 included_list=`gzip -dc $mappath | grep -Fi include | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
224 else
225 included_list=`grep -Fi include $mappath | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
226 fi
227 for included_item in $included_list ; do
228 if [ ! -e "$included_item" ] ; then
229 sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
230 [ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
231 for ii in $sss ; do
232 [ -e "$ii" ] && AddKeyboardMappingFile $ii
233 done
234 else
235 AddKeyboardMappingFile $included_item
236 fi
237 done
238}
239
240
241ChopUpAndCopyFile() {
242 local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
243 filename=$1
244 outdir=$2
245 slicesize=$3
246 biggienumber=$4
247
248 [ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
249 mkdir -p $outdir
250
251 sliceno=0
252 scratchfile=$MINDI_TMP/blah.$$.dat
253 cp -f $filename $scratchfile 2>> $LOGFILE || Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
254 [ "`head $scratchfile -n1 | grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
255 [ "`echo "$filename" | grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
256 if [ "`echo "$filename" | grep -F "lib/modules/" | grep "\.*o\.gz"`" != "" ] ; then
257 mv $scratchfile $scratchfile.gz
258 gunzip -f $scratchfile || LogIt "Cannot gunzip $scratchfile.gz"
259 filename=`echo "$filename" | tr '.' '#' | sed s/#o#gz/#o/ | sed s/#ko#gz/#ko/ | tr '#' '.'`
260 fi
261 filesize=`du -sk $scratchfile | cut -f1`
262 noof_slices=$(($filesize/$slicesize))
263 echo "$filename" > $outdir/slice-$biggienumber.name
264 echo "$filesize" > $outdir/slice-$biggienumber.size
265 [ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
266 while [ "$sliceno" -le "$noof_slices" ] ; do
267 dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
268 sliceno=$(($sliceno+1))
269 done
270 rm -f $scratchfile
271}
272
273
274CopyBootBFile() {
275 local copy_to copy_from possible_locations liloc
276 copy_to=$1
277 copy_from=/boot/boot.b
278 liloc=`which lilo.real 2>/dev/null`
279 [ $liloc ] || liloc=`which lilo 2>/dev/null`
280 if [ $liloc ]; then
281 if ! [ `strings $liloc | grep "boot\.b"` ]; then
282 LogIt "boot.b files built into lilo; I'll create a dummy."
283 > $copy_to
284 return 0
285 fi
286 fi
287 if [ ! -f "$copy_from" ] ; then
288 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"
289 copy_from=`grep install= /etc/lilo.conf | grep "\.b" | cut -d'=' -f2`
290 if [ ! -f "$copy_from" ] ; then
291 LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
292 copy_from=`FindSensibleBootBFile`
293 LogIt "I'm going to use '$copy_from'"
294 fi
295 fi
296 cp -f $copy_from $copy_to 2>> $LOGFILE || LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
297}
298
299
300CopyDependenciesToDirectory() {
301 local outdir incoming fname filesize counter
302 outdir=$1
303 mkdir -p $outdir
304 incoming=`ReadLine`
305 counter=0
306 while [ "$incoming" != "" ] ; do
307 if [ -d "$incoming" ] ; then
308 find $incoming/* -maxdepth 0 2> /dev/null | CopyDependenciesToDirectory $outdir
309 elif [ -e "$incoming" ] ; then
310 filesize=`du -sk $incoming | cut -f1`
311 if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
312 ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
313 BIGNO=$(($BIGNO+1))
314 else
315 cp --parents -Rdf $incoming $outdir 2> /dev/null || Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
316 if [ "`echo "$incoming" | grep "lib/modules/.*\..*o\.gz"`" != "" ] ; then
317 gunzip -f $outdir/$incoming || LogIt "Cannot gunzip $outdir/$incoming"
318 fi
319 [ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
320 fi
321 counter=$(($counter+1))
322 if [ "$counter" -ge "5" ] ; then
323 counter=0
324 echo -en "."
325 fi
326 fi
327 incoming=`ReadLine`
328 done
329}
330
331
332CopyImageToDisk() {
333 local image dev procno res comment
334 image=$1
335 dev=$2
336 comment=$3
337 [ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
338 Prompt "About to write $comment. Please press ENTER."
339 echo -en "Formatting disk..."
340 if which fdformat > /dev/null ; then
341 fdformat -n $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
342 elif which superformat > /dev/null ; then
343 superformat $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
344 else
345 Die "Please install either fdformat or superformat."
346 fi
347 echo -en "\nWriting $comment"
348 if echo $image | grep "mindi-[r|b]oot\.1440" &> /dev/null ; then
349 cat $image > $dev &
350 else
351 dd if=$image of=$dev &> /dev/null &
352 fi
353 procno=$!
354 ps $procno > /dev/null 2> /dev/null
355 while [ "$?" -eq "0" ] ; do
356 sleep 3
357 echo -en "."
358 ps $procno > /dev/null 2> /dev/null
359 done
360 echo -e "$DONE"
361 LogIt "$comment has been written."
362}
363
364
365CountItemsIn() {
366 local r
367 r=0
368 for q in $1 ; do
369 r=$(($r+1))
370 done
371 echo $r
372}
373
374
375CreateDataDiskImagesFromTarballs() {
376 local tardir outdir diskno noof_disks kp
377 tardir=$1
378 outdir=$2
379 noof_disks=$3
380
381 mkdir -p $outdir
382 diskno=1
383 echo -en "Creating data disk "
384 while [ "$diskno" -le "$noof_disks" ] ; do
385 echo -en "#$diskno..."
386 cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE || LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
387 CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
388 diskno=$(($diskno+1))
389 done
390 mv -f $tardir/all.tar.gz $outdir
391 du -sk $outdir/*gz >> $LOGFILE
392 echo -e "$DONE"
393}
394
395
396
397CreateOneDataDiskImage() {
398 local tarball imagefile dev diskno noof_disks mountpoint
399 tarball=$1
400 imagefile=$2
401 diskno=$3
402 noof_disks=$4
403
404 mountpoint=$MINDI_TMP/mountpoint.$$
405 mkdir -p $mountpoint
406 dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null || LogIt "Cannot dd (CODI)"
407 echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
408 mke2fs -N 12 -F $imagefile &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
409 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."
410 mv $tarball $mountpoint/
411 if [ "$?" -ne "0" ] ; then
412 umount $mountpoint
413 rmdir $mountpoint
414 Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
415 fi
416 [ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
417 umount $mountpoint || LogIt "Cannot umount (CODI)"
418 rmdir $mountpoint || LogIt "Cannot rmdir (CODI)"
419}
420
421# Last function called before exiting
422# Parameter is exit code value
423MindiExit() {
424 local my_partitions
425
426 echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
427 echo "End date : `date`" >> $LOGFILE
428 if [ _"$MONDO_SHARE" != _"" ] ; then
429 echo "------------- mindi logfile included -------------------------" >> /var/log/mondoarchive.log
430 cat $LOGFILE >> /var/log/mondoarchive.log
431 echo "--------------------------------------------------------------">> /var/log/mondoarchive.log
432 fi
433
434 sync
435 cd /
436
437 # Unmount whtat could remain mounted
438 my_partitions=`mount | grep -F $$ | cut -f1 -d' '`
439 [ "$my_partitions" != "" ] && umount $my_partitions
440 # Clean temporary files only when standalone mindi
441 if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
442 rm -Rf $MINDI_TMP
443 fi
444 exit $1
445}
446
447Die() {
448 local i
449 if [ "$1" = "" ] ; then
450 LogIt "FATAL ERROR"
451 else
452 LogIt "FATAL ERROR. $1"
453 fi
454
455 LogIt "Please e-mail a copy of $LOGFILE 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|$BOOT_SIZE"`
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.$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 || Die "Unable to create an ext2 file system on $image"
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 # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1815 #losetup /dev/loop0 > /dev/null 2> /dev/null
1816 #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1817 CopyBootBFile $mtpt/boot.b
1818
1819 MakeLiloConfFile $disksize >> bdlilo.conf
1820
1821 chmod 644 bdlilo.conf
1822 MakeMessageFile $disksize > message
1823 lilo -v -C bdlilo.conf -r $mtpt
1824 res=$?
1825
1826 cd $old_pwd
1827 umount $mtpt
1828 mv -f $image $2
1829 rmdir $mtpt
1830
1831 return $res
1832}
1833
1834
1835MakeLiloConfFile() {
1836 local disksize options i ooo
1837 disksize=$1
1838 options=""
1839
1840 if [ "$ARCH" != "ia64" ] ; then
1841 echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1842 fi
1843 if [ "$disksize" -eq "2880" ] ; then
1844 echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
1845 elif [ "$disksize" -gt "2880" ] ; then
1846 /bin/true
1847 else
1848 echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
1849 fi
1850 if [ "$ARCH" != "ia64" ] ; then
1851 echo -en "install=/boot.b\nmap=/boot.map\n"
1852 fi
1853 if [ "$CDRECOVERY" = "yes" ] ; then
1854 echo -en "default=RESTORE\n"
1855 elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ]; then
1856 if [ "$NFS_DEV" != "" ] ; then
1857 echo -en "default=iso\n"
1858 else
1859 echo -en "default=interactive\n"
1860 fi
1861 else
1862 echo -en "default=expert\n"
1863 fi
1864
1865 echo -en "prompt\n"
1866 if [ "$ARCH" != "ia64" ] ; then
1867 echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1868 fi
1869 if [ "$CDRECOVERY" != "yes" ] ; then
1870 echo -en "timeout=300\n"
1871 fi
1872 echo -en "\n"
1873 if [ "$CDRECOVERY" = "yes" ] ; then
1874 options="RESTORE expert"
1875 elif [ "$disksize" -gt "2880" ] ; then
1876 if [ _"$MONDO_SHARE" != _"" ]; then
1877 if [ "$NFS_DEV" != "" ] ; then
1878 options="iso"
1879 else
1880 options="interactive expert compare iso nuke isonuke"
1881# hda hdb hdc hdd"
1882 fi
1883 else
1884 options="expert"
1885 fi
1886 else
1887 options="expert"
1888 fi
1889 for i in $options ; do
1890 ooo=$i
1891 [ "$ooo" = "RESTORE" ] && ooo="nuke"
1892 if [ "$ARCH" = "ia64" ] ; then
1893 rootpart="root=/dev/ram0\n\t"
1894 else
1895 rootpart=""
1896 fi
1897 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"
1898
1899 outstr=$outstr" $ooo_mode"
1900 outstr=$outstr"\"\n"
1901 if [ "$disksize" = "1440" ] ; then
1902 echo -en "$outstr" | sed s/initrd=.*// | grep -v root=
1903 else
1904 echo -en "$outstr"
1905 fi
1906 done
1907}
1908
1909
1910PrepareBootDiskImage_LILO() {
1911 local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1912 imagesdir=$1
1913 disksize=$2
1914 kernelpath=$3
1915 ramdisksize=$4
1916
1917 retval=0
1918 [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1919 echo -en "Making "$disksize"KB boot disk..."
1920 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?"
1921 if [ "$ARCH" != "ia64" ] ; then
1922 [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
1923 fi
1924 echo -en "..."
1925 imagefile=$imagesdir/mindi-bootroot.$disksize.img
1926 mountpoint=$MINDI_TMP/mountpoint.$$
1927 mkdir -p $mountpoint
1928 dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
1929 if [ "$ARCH" = "ia64" ] ; then
1930 mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1931 t=vfat
1932 else
1933 echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
1934 mke2fs -N 26 -m 0 -F $imagefile &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
1935 t=ext2
1936 fi
1937 mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1938 # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1939 mkdir -p $mountpoint/etc
1940 if [ "$ARCH" != "ia64" ] ; then
1941 liloconf=$mountpoint/etc/lilo.conf
1942 else
1943 liloconf=$mountpoint/elilo.conf
1944 fi
1945 old_pwd=`pwd`
1946 cd $mountpoint
1947 if [ "$ARCH" != "ia64" ] ; then
1948 tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1949 fi
1950 cd $old_pwd
1951 # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1952 #losetup /dev/loop0 > /dev/null 2> /dev/null
1953 #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1954 CopyBootBFile $mountpoint/boot.b
1955
1956 MakeLiloConfFile $disksize > $liloconf
1957
1958 # Copy it so that CD-ROM menu entry is satisfied
1959 if [ "$ARCH" = "ia64" ] ; then
1960 mountefi=0
1961 df -T | grep /boot/efi | grep -q vfat
1962 if [ $? -ne 0 ]; then
1963 mount /boot/efi
1964 if [ $? -ne 0 ]; then
1965 echo "You have to mount your EFI partition when using mindi"
1966 MindiExit -1
1967 fi
1968 mountefi=1
1969 fi
1970 cp /boot/efi/elilo.efi $mountpoint
1971 cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
1972 if [ $mountefi -eq 1 ]; then
1973 umount /boot/efi 2>&1 > /dev/null
1974 fi
1975 fi
1976
1977 echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1978 cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1979 if [ "$?" -ne "0" ] ; then
1980 LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1981 cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1982 LogIt "Please unload some of your modules and try again."
1983 rm -f $MINDI_TMP/mtpt.$$
1984 LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1985 retval=$(($retval+1))
1986 fi
1987 MakeMessageFile $disksize > $mountpoint/message
1988
1989 mkdir -p $mountpoint/tmp
1990 cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1991 if [ -e "$MINDI_LIB/memtest.img" ] ; then
1992 echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1993 echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1994# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1995 fi
1996
1997 # copy the kernel across
1998 [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1999 dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2000 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2001 cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
2002 if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2003 echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2004 du -sk $mountpoint/* >> $LOGFILE
2005 echo "--- end of list of files ---" >> $LOGFILE
2006 echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2007Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2008 rm -f $mountpoint/vmlinuz
2009 cd $old_pwd
2010 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2011 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2012 # losetup /dev/loop0 -d
2013 res=0
2014 write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2015 res=$(($res+$?))
2016 cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2017 res=$(($res+$?))
2018 rm -f $imagefile
2019 if [ "$res" -ne "0" ]; then
2020 LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2021 rm -f $imagesdir/mindi-*.1440.img
2022 fi
2023 return $res
2024 fi
2025 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2026 max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2027 echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2028 echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2029# make it bootable
2030 rm -f $mountpoint/zero
2031 [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2032 if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
2033 if [ "$ARCH" != "ia64" ] ; then
2034 $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2035 else
2036 /bin/true
2037 fi
2038 elif [ ! "$KERN_DISK_MADE" ] ; then
2039# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
2040 $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2041 else
2042 echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
2043 fi
2044
2045 # BERLIOS does not test necessarily what it expects
2046 if [ $? -ne "0" ] ; then
2047 if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2048 LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2049 LogIt "Please reboot your PC as a workaround."
2050 Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2051 fi
2052 echo "$LILO_EXE -r $mountpoint ...failed."
2053 echo -en "Press ENTER to continue."; read line
2054 LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2055 retval=$(($retval+1))
2056 fi
2057 cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2058 if [ "$ARCH" = "ia64" ] ; then
2059 cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2060 fi
2061 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2062 echo -en "..."
2063 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2064 if [ "$retval" -eq "0" ] ; then
2065 echo -en "...$DONE\n"
2066 if [ "$KERN_DISK_MADE" ] ; then
2067 LogIt "$disksize KB boot disks were created OK\n"
2068 fi
2069 else
2070 echo -en "...failed\n"
2071 LogIt $disksize"KB boot disk was NOT created\n"
2072 rm -f $imagefile
2073 fi
2074 [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2075 return $retval
2076}
2077
2078
2079PrepareBootDiskImage_SYSLINUX() {
2080 local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2081 imagesdir=$1
2082 disksize=$2
2083 kernelpath=$3
2084 ramdisksize=$4
2085 do_boot_root_thingy=""
2086 local retval old_pwd
2087 retval=0
2088
2089 [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2090 echo -en "Making "$disksize"KB boot disk..."
2091 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?"
2092 [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
2093 echo -en "..."
2094 imagefile=$imagesdir/mindi-bootroot.$disksize.img
2095 mountpoint=$MINDI_TMP/mountpoint.$$
2096 mkdir -p $mountpoint
2097 dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2098 echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
2099 mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2100 syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2101
2102 mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2103
2104 # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2105 old_pwd=`pwd`
2106 MakeSyslinuxMessageFile $mountpoint/message.txt
2107 cd $mountpoint
2108 [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2109 cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2110 if [ "$NFS_DEV" != "" ] ; then
2111 perl -pi -e 's/interactive/iso/' syslinux.cfg
2112 fi
2113 cd $old_pwd
2114 echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2115 cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2116 if [ "$?" -ne "0" ] ; then
2117 LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2118 cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2119 LogIt "Please unload some of your modules and try again."
2120 rm -f $MINDI_TMP/mtpt.$$
2121 LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2122 retval=$(($retval+1))
2123 fi
2124
2125 mkdir -p $mountpoint/tmp
2126 cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2127
2128 # copy the kernel across
2129 [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2130 dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2131 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2132 cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2133 if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2134 echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2135 du -sk $mountpoint/* >> $LOGFILE
2136 echo "--- end of list of files ---" >> $LOGFILE
2137 echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2138Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2139 rm -f $mountpoint/vmlinuz
2140 cd $old_pwd
2141 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2142 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2143
2144 res=0
2145 write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2146 res=$(($res+$?))
2147 cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2148 res=$(($res+$?))
2149 rm -f $imagefile
2150 if [ "$res" -ne "0" ]; then
2151 LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2152 rm -f $imagesdir/mindi-*.1440.img
2153 fi
2154 return $res
2155 fi
2156 free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2157 max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2158 echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2159 echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2160
2161 # make it bootable
2162 rm -f $mountpoint/zero
2163 mkdir -p $mountpoint/etc
2164 [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2165 umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2166 echo -en "..."
2167 rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2168
2169 if [ "$retval" -eq "0" ] ; then
2170 echo -en "...$DONE\n"
2171 if [ "$KERN_DISK_MADE" ] ; then
2172 rm -f $imagefile
2173 LogIt "$disksize KB boot disks were created OK\n"
2174 fi
2175 else
2176 echo -en "...failed\n"
2177 LogIt $disksize"KB boot disk was NOT created\n"
2178 rm -f $imagefile
2179 fi
2180 [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2181 return $retval
2182}
2183
2184
2185PrepareDataDiskImages() {
2186 local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
2187
2188 imagesdir=$1
2189 rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2190 needlist=$MINDI_TMP/what-we-need.txt
2191 bigdir=$MINDI_TMP/bigdir
2192 minidir_root=$MINDI_TMP/minidir
2193 mkdir -p $minidir_root
2194 mkdir -p $bigdir/usr/bin
2195 tardir=$MINDI_TMP/tardir
2196
2197 if [ -e "$DEPLIST_FILE" ]; then
2198 lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
2199 else
2200 lfiles="$DEPLIST_DIR/*"
2201 fi
2202 lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
2203 cat $lfiles | GenerateGiantDependencyList $needlist $lines
2204 res=$?
2205 if [ "$YOUR_KERNEL_SUCKS" ]; then
2206 pwd=`pwd`
2207 cd $MINDI_TMP
2208 for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2209 cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2210 if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2211 cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2212 else
2213 ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2214 BIGNO=$(($BIGNO+1))
2215 fi
2216 done
2217 for i in $EXTRA_MODS ; do
2218 j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
2219 [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
2220 for k in $j ; do
2221 if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2222 cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2223 else
2224 ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2225 BIGNO=$(($BIGNO+1))
2226 fi
2227 echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2228 done
2229 done
2230 cd $pwd
2231 else
2232 ListKernelModulePaths >> $needlist
2233 fi
2234 if [ "$res" -ne "0" ] ; then
2235 Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2236 fi
2237 FindAndAddUserKeyboardMappingFile
2238 mkdir -p $bigdir/tmp
2239 if [ _"$MONDO_SHARE" != _"" ]; then
2240 cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
2241 fi
2242 [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2243 DropOptimizedLibraries $needlist $bigdir
2244 echo -en "Assembling dependency files"
2245 CopyDependenciesToDirectory < $needlist $bigdir
2246
2247 # also copy io.sys and msdos.sys, if we can find them
2248 for i in `mount | cut -d' ' -f3` ; do
2249 for j in io.sys msdos.sys ; do
2250 [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2251 done
2252 done
2253
2254 # master boot record, too
2255 if [ _"$MONDORESTORECFG" != _"" ]; then
2256 i=`grep bootloader.device $MONDORESTORECFG | cut -d'=' -f2 2> /dev/null`
2257 if [ "$i" ] ; then
2258 LogIt "Backing up $i's MBR"
2259 dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2260 sleep 1
2261 sync
2262 j=$i
2263 [ -h "$j" ] && j=`readlink -f $j`
2264 LogIt "Creating /dev/boot_device ($j)"
2265 mkdir -p $bigdir/dev
2266 cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2267 fi
2268 fi
2269
2270 old_pwd=`pwd`
2271 cd $bigdir
2272
2273 [ -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'."
2274 cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2275 if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2276 tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2277 fi
2278 if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2279 cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2280 [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2281 fi
2282 [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2283 cd $old_pwd
2284 echo -e "$DONE"
2285 TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2286 SplitDirectoryIntoMinidirs $bigdir $minidir_root
2287 noof_disks=$?
2288 [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2289 MakeMountlist $MINDI_TMP/mountlist.txt
2290 mkdir -p $minidir_root/$noof_disks/tmp
2291 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"
2292 if [ _"$MONDO_SHARE" != _"" ]; then
2293 cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2294 fi
2295 [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2296 cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2297 ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2298 CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2299 FRIENDLY_OUTSTRING="Boot and data disk images were created."
2300 # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2301 rmdir $tardir $bigdir
2302 rm -f $needlist
2303 return $noof_disks
2304}
2305
2306
2307ProcessLDD() {
2308 local main_fname incoming j i fname f newf
2309 main_fname=$1
2310 read incoming
2311 while [ "$incoming" != "" ] ; do
2312 # We take the full path name of the dyn. lib. we want
2313 incoming=`echo "$incoming" | sed '/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*(.*/d ; s/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*\(\/.*\)/\1/ ; s/[[:blank:]]*\(\/.*\)[[:blank:]]*(.*/\1/'`
2314 for f in `echo "$incoming"` ; do
2315 echo "$f `ReadAllLink $f`"
2316 done
2317 read incoming
2318 done
2319}
2320
2321
2322Prompt() {
2323 echo -en "$1"
2324 read line
2325}
2326
2327
2328ReadLine() {
2329 local i incoming
2330 read incoming
2331 i=0
2332 while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2333 i=$(($i+1))
2334 read incoming
2335 done
2336 echo "$incoming"
2337}
2338
2339
2340RejigHyperlinks() {
2341 local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2342 minidir_root=$1
2343 noof_disks=$2
2344
2345 old_pwd=`pwd`
2346 diskno=1
2347 while [ "$diskno" -le "$noof_disks" ] ; do
2348 mkdir -p $minidir_root/$diskno
2349 cd $minidir_root/$diskno
2350 for fname in `find -type d -o -print` ; do
2351 [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2352 done
2353 diskno=$(($diskno+1))
2354 done
2355
2356 cd $old_pwd
2357 return
2358}
2359
2360
2361ReplaceIndividualLine() {
2362 local orig_file new_file lino newstring lines_total lines_remaining
2363
2364 orig_file=$1.orig
2365 mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2366 new_file=$1
2367 lino=$2
2368 newstring="$3"
2369 if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2370 echo "Can't find string" >> $LOGFILE
2371 return 1
2372 fi
2373 lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2374 lines_remaining=$(($lines_total-$lino))
2375 head -n$(($lino-1)) $orig_file > $new_file
2376 echo "$newstring" >> $new_file
2377 echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2378 tail -n$lines_remaining $orig_file >> $new_file
2379 echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2380 [ -x "$orig_file" ] && chmod +x $new_file
2381 rm -f $orig_file
2382 return 0
2383}
2384
2385
2386ScanCDandTape() {
2387 local i
2388
2389 for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2390 dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2391 done
2392}
2393
2394
2395SizeOfPartition() {
2396 local devpath drive res stub
2397 device=$1
2398 if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2399 res=`SizeOfRaidPartition $device`
2400 [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2401 echo "$res"
2402 return 0
2403 fi
2404 # patch from Bill <bill@iwizard.biz> - 2003/08/25
2405 res=`$FDISK -s $device 2>> $LOGFILE`
2406 # end patch
2407 [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2408 [ "$res" = "" ] && res="-1"
2409 echo $res
2410 return 0
2411}
2412
2413
2414SizeOfRaidPartition() {
2415 local real_dev smallest_size silly tmp
2416
2417 silly=999999999
2418 smallest_size=$silly
2419
2420 for real_dev in `GetRaidDevMembers $1` ; do
2421 tmp=`SizeOfPartition $real_dev`
2422 [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2423 done
2424
2425 if [ "$smallest_size" = "$silly" ] ; then
2426 echo "-1"
2427 return 1
2428 else
2429 echo "$smallest_size"
2430 return 0
2431 fi
2432}
2433
2434
2435StripComments()
2436{
2437 local tempfile
2438
2439 tempfile=$MINDI_TMP/$$.strip.txt
2440 cp -f $1 $tempfile 2>> $LOGFILE
2441 $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2442 rm -f $tempfile
2443 echo "Stripped comments from $2" >> $LOGFILE
2444}
2445
2446
2447SplitDirectoryIntoMinidirs() {
2448 local bigdir minidir_root i noof_disks old_pwd res
2449
2450 bigdir=$1
2451 minidir_root=$2
2452 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2453
2454 TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2455 noof_disks=$?
2456 if [ "$noof_disks" -eq "0" ] ; then
2457 echo "Failed to fit data into several dirs."
2458 return 0
2459 fi
2460 RejigHyperlinks $minidir_root $noof_disks
2461 [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2462 return $noof_disks
2463}
2464
2465
2466StripExecutable()
2467{
2468 local tmpfile
2469
2470 tmpfile=$MINDI_TMP/stripped.$$.dat
2471 [ -d "$1" ] || [ -h "$1" ] && return
2472 cp -f $1 $tmpfile 2>> $LOGFILE
2473 strip $tmpfile 2> /dev/null
2474 if [ "$?" -eq "0" ] ; then
2475 cp -f $tmpfile $1 2>> $LOGFILE
2476 echo "Stripped binary $2" >> $LOGFILE
2477 fi
2478 rm -f $tmpfile
2479}
2480
2481
2482TemporarilyCompressAllFiles() {
2483 local i orig_fname out_fname out_list
2484
2485 i=0
2486 out_list=$2/compressed/compressed.txt
2487 mkdir -p $2/compressed
2488 > $out_list
2489 for orig_fname in $1 ; do
2490 out_fname=$2/compressed/$orig_fname.gz
2491 mkdir -p $out_fname 2> /dev/null
2492 rmdir $out_fname 2> /dev/null
2493 gzip -c6 $orig_fname > $out_fname 2> /dev/null
2494 i=$(((($i+1))%15))
2495 [ "$i" -eq "0" ] && echo -en "."
2496 du -sk $out_fname >> $out_list
2497 done
2498}
2499
2500
2501TryToFindKernelPath() {
2502 local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2503
2504 we_want_version=`uname -r`
2505 possible_kernels=""
2506 duff_kernels=""
2507
2508 if [ "$ARCH" = "ia64" ] ; then
2509 root="/boot/efi/efi"
2510 else
2511 root="/"
2512 fi
2513 for fname in `find $root -maxdepth 2 -type f | grep -F lin | grep -Ev '^/proc/|^/net/'` ; do
2514 [ ! -e "$fname" ] && continue
2515 [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2516 file $fname | grep -q gzip
2517 if [ "$?" -eq "0" ] ; then
2518 # Used by ia64
2519 fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2520 else
2521 fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2522 fi
2523 [ "$fkern_ver" = "" ] && continue
2524 [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2525 [ -f "$fname" ] || continue
2526 [ -h "$fname" ] && continue
2527 kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2528 file $fname | grep -q gzip
2529 if [ "$?" -eq "0" ] ; then
2530 # Used by ia64
2531 if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2532 LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2533 duff_kernels="$fname $duff_kernels"
2534 else
2535 [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2536 possible_kernels="$fname $possible_kernels"
2537 fi
2538 else
2539 if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2540 LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2541 duff_kernels="$fname $duff_kernels"
2542 else
2543 [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2544 possible_kernels="$fname $possible_kernels"
2545 fi
2546 fi
2547 done
2548 if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2549 possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2550 fi
2551 if [ ! "$possible_kernels" ] ; then
2552 LogIt "No kernel matches exactly. Are there any duff kernels?"
2553 possible_kernels="$duff_kernels"
2554 if [ ! "$possible_kernels" ] ; then
2555 LogIt "Sorry, no duff kernels either"
2556 else
2557 LogIt "I bet you're running Debian or Gentoo, aren't you?"
2558 LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2559 fi
2560 fi
2561 possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2562 noof_kernels=`CountItemsIn "$possible_kernels"`
2563 if [ "$noof_kernels" -eq "0" ] ; then
2564 LogIt "Could not find your kernel."
2565 if [ -e "/boot/vmlinuz" ] ; then
2566 LogIt "Using /boot/vmlinuz as a last resort."
2567 output=/boot/vmlinuz
2568 else
2569 output=""
2570 fi
2571 elif [ "$noof_kernels" -eq "1" ] ; then
2572 kernelpath=`echo "$possible_kernels" | sed s/' '//`
2573 echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2574 output="$kernelpath"
2575 else
2576 for i in $possible_kernels ; do
2577 if echo $i | grep "`uname -r`" ; then
2578 LogIt "OK, I used my initiative and found that "
2579 LogIt "$i is probably your kernel. "
2580 output="$i"
2581 return
2582 fi
2583 done
2584 if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2585 output=/boot/vmlinuz
2586 echo "Schlomo, this one's for you." >> $LOGFILE
2587 else
2588 LogIt "Two or more possible kernels found. You may specify any one of them and the "
2589 LogIt "boot disks will still work, probably. If one does not work, try another."
2590 LogIt "$possible_kernels"
2591 echo ""
2592 fi
2593 fi
2594 echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2595}
2596
2597
2598TryToFitDataIntoSeveralDirs() {
2599 local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2600 local i retval noof_disks total_files list_of_devs
2601
2602 bigdir=$1
2603 minidir_root=$2
2604 BIG_CLUNKY_SIZE_COUNTER=0
2605 retval=0
2606 noof_disks=1
2607
2608 echo -en "\r \rDividing data into several groups..."
2609 old_pwd=`pwd`
2610 cd $bigdir
2611 list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2612 progress=0
2613 total_files=`CountItemsIn "$list_of_files"`
2614 if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2615 filesize=1
2616 fi
2617 mkdir -p $minidir_root/$noof_disks
2618 if [ -e "dev" ] ; then
2619 echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2620 cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2621 fi
2622 TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2623 for filename in $list_of_files ; do
2624 AddFileToDir $filename $minidir_root $noof_disks
2625 i=$?
2626 if [ "$i" -gt "$noof_disks" ] ; then
2627 noof_disks=$i
2628 echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2629 fi
2630 if [ "$i" -eq "0" ] ; then
2631 LogIt "Cannot add file $filename to minidir $minidir_root"
2632 retval=$(($retval+1))
2633 fi
2634 progress=$(($progress+1))
2635 echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2636 done
2637 cd $old_pwd
2638 echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
2639 [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2640 if [ "$retval" -gt "0" ] ; then
2641 return 0
2642 else
2643 return $noof_disks
2644 fi
2645}
2646
2647
2648TurnTgzIntoRdz() {
2649 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
2650
2651 tgz_dir_fname=$1
2652 rdz_fname=$2
2653 ramdisksize=$3
2654 disksize=$4
2655 kernelsize=$5
2656 maxsize=$(($disksize-$kernelsize))
2657 maxsize=$(($maxsize*2)); # to allow for compression of 50%
2658 tempfile=$MINDI_TMP/temp.rd
2659 mountpoint=$MINDI_TMP/mnt1
2660 res=0
2661 echo -en "..."
2662 dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2663 echo -en "..."
2664 echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2665 mke2fs -b 1024 -m 1 -i 2048 -F $tempfile &> /dev/null || Die "Unable to create an ext2 file system on $tempfile"
2666 echo -en "..."
2667 mkdir -p $mountpoint
2668 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."
2669 echo -en "..."
2670 old_pwd=`pwd`
2671 cd $mountpoint
2672 cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2673 tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2674 cd dev || Die "Can't cd to dev"
2675 tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2676 rm -f dev-entries.tgz
2677 cd ..
2678
2679 for w in insmod.static insmod.static.old ; do
2680 s=`which $w 2> /dev/null`
2681 if [ -e "$s" ] ; then
2682 cp --parents -af $s . 2>> $LOGFILE
2683 fi
2684 done
2685
2686 mkdir -p tmp
2687 [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2688 for w in cdrom floppy groovy-stuff ; do
2689 mkdir -p mnt/$w
2690 done
2691 #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2692 #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2693 #fi
2694 if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2695 ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2696 fi
2697
2698 lsmod > tmp/original-lsmod.txt
2699
2700 cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2701 cd $old_pwd
2702 echo -en "..."
2703 MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2704 echo -en "..."
2705 old_pwd=`pwd`
2706 if [ "$YOUR_KERNEL_SUCKS" ] ; then
2707 cd $MINDI_TMP
2708 floppy_modules_path=lib/modules/$FAILSAFE_KVER
2709 else
2710 cd /
2711###
2712### Sq-Modification... Use kernel name in module path if specified.
2713###
2714 #floppy_modules_path=lib/modules/`uname -r`
2715 if [ "${kernelname}" != "" ]
2716 then
2717 floppy_modules_path=lib/modules/${kernelname}
2718 else
2719 floppy_modules_path=lib/modules/`uname -r`
2720 fi
2721###
2722### Sq-Modification end
2723###
2724 fi
2725 floppy_modules=""
2726 if [ "$disksize" -lt "2880" ] ; then
2727 list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2728 else
2729 list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2730 fi
2731 if [ "$NFS_DEV" != "" ] ; then
2732 # For PXE boot
2733 list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2734 fi
2735 [ -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."
2736 for i in $list_of_groovy_mods ; do
2737 floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2738 done
2739 for i in $floppy_modules ; do
2740 [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2741 [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2742 echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2743 cp -df $i $mountpoint/ 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2744 [ "`echo "$i" | grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
2745 done
2746 if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2747 echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2748 [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2749 [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2750 [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2751 rm -f $mountpoint/sbin/devfsd
2752 fi
2753 cd $old_pwd
2754 [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2755 dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2756 rm -f $mountpoint/zero
2757 mkdir -p $mountpoint/tmp
2758 if [ _"$MONDO_SHARE" != _"" ]; then
2759 cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null || Die "Cannot copy mondo-restore.cfg to ramdisk"
2760 cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2761 fi
2762 mkdir -p $mountpoint/proc
2763 echo "$disksize" > $mountpoint/tmp/$disksize.siz
2764 find $mountpoint -name CVS -exec rm -rf '{}' \;
2765 # Determine what filesystem to use for initrd image
2766 echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2767 gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2768 [ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2769 case "$gvFileSystem" in
2770 "ext2fs")
2771 # say what will be used
2772 echo "Creating an ext2 initrd image..." >> $LOGFILE
2773 # kernel expects linuxrc in ext2 filesystem
2774 ( cd $mountpoint && ln -sf sbin/init linuxrc )
2775 # unmount loop filesystem and create image file using the standard approach
2776 umount $mountpoint || Die "Cannot unmount $tempfile"
2777 dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2778 bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2`
2779 ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2780 gzip -v9 ${rdz_fname}.tmp > $rdz_fname 2> /dev/null
2781 rm -f ${rdz_fname}.tmp
2782 # log that we are done
2783 echo "...done." >> $LOGFILE
2784 ;;
2785 "initramfs")
2786 # say what will be used
2787 echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2788 # make sure that cpio is there
2789 which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2790 # go into filesystem
2791 cd $mountpoint
2792 # kernel expects init in cpio filesystem
2793 ln -sf sbin/init init
2794 # create cpio image file and unmount loop filesystem
2795 find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2796 cd $old_pwd
2797 umount $mountpoint || Die "Cannot unmount $tempfile"
2798 # log that we are done
2799 echo "...done." >> $LOGFILE
2800 ;;
2801 *)
2802 Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2803 ;;
2804 esac
2805 if [ "$res" -eq "0" ] ; then
2806 echo -en "..."
2807 else
2808 echo -en "\rMade an rdz WITH ERRORS. \n"
2809 fi
2810 return 0
2811}
2812
2813
2814WhichOfTheseModulesAreLoaded() {
2815 local modname loaded_modules
2816 loaded_modules=" `lsmod | tr -s ' ' '\t' | cut -f1 | grep -Fvx "Modules" | tr '\n' ' '` "
2817 for modname in $1 ; do
2818 [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2819 done
2820}
2821
2822
2823ZipMinidirsIntoTarballs() {
2824 local minidir_root tardir noof_disks diskno old_pwd i
2825 minidir_root=$1
2826 tardir=$2
2827 noof_disks=$3
2828
2829 echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2830 mkdir -p $tardir
2831 mkdir -p $minidir_root/all
2832 old_pwd=`pwd`
2833 diskno=1
2834 while [ "$diskno" -le "$noof_disks" ] ; do
2835 cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2836 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."
2837 diskno=$(($diskno+1))
2838 echo -n "..."
2839 cp -pRdf * $minidir_root/all 2>> $LOGFILE
2840 done
2841 mkdir -p $minidir_root/all/tmp
2842 cd $minidir_root/all
2843 size_of_all_tools=`du -sk . | cut -f1`
2844 if [ _"$MONDO_SHARE" != _"" ]; then
2845 for q in filelist.full.gz biggielist.txt ; do
2846 [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2847 cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2848 done
2849 mkdir -p $minidir_root/all/tmp
2850 fi
2851 tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2852 dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2853 [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2854 cd $old_pwd
2855 [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2856 echo -e "$DONE"
2857}
2858
2859
2860##############################################################################
2861#----------------------------------- Main -----------------------------------#
2862##############################################################################
2863
2864# Now we can create what we nedd
2865mkdir -p $MINDI_TMP
2866
2867# Purge from potential old run
2868if [ _"$MINDI_CACHE" = _"" ]; then
2869 Die "MINDI_CACHE undefined"
2870fi
2871rm -rf $MINDI_CACHE 2> /dev/null
2872mkdir -p $MINDI_CACHE
2873
2874
2875if [ "$1" = "--printvar" ] ; then
2876 shift
2877 if [ _"$1" != _"" ] ; then
2878 set | egrep "^$1" | cut -d= -f2
2879 fi
2880 MindiExit 0
2881fi
2882
2883> $LOGFILE
2884echo "mindi v$MINDI_VERSION" >> $LOGFILE
2885echo "$ARCH architecture detected" >> $LOGFILE
2886echo "mindi called with the following arguments:" >> $LOGFILE
2887echo "$@" >> $LOGFILE
2888echo "Start date : `date`" >> $LOGFILE
2889echo "-----------------------------" >> $LOGFILE
2890
2891if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2892 LogIt "WARNING - Ancient distro detected." 1
2893 ln -sf /etc/conf.modules /etc/modules.conf
2894fi
2895[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2896
2897# Log some capital variables
2898[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2899echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2900echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2901echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2902[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2903echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2904if [ -f $MINDI_CONF ]; then
2905 echo "-----------------------------" >> $LOGFILE
2906 echo " Mindi configuration file " >> $LOGFILE
2907 echo "-----------------------------" >> $LOGFILE
2908 cat $MINDI_CONF >> $LOGFILE
2909 echo "-----------------------------" >> $LOGFILE
2910fi
2911
2912
2913trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2914
2915# Sanity checks
2916which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2917which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2918which 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."
2919which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2920if which awk &> /dev/null ; then
2921 if ! which gawk &> /dev/null ; then
2922 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"
2923 fi
2924fi
2925which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2926[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2927
2928[ "`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"
2929# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2930# may have the modprobe configuration spread out across multiple files in
2931# directory /etc/modprobe.d. If this is the case we concatenate these files into
2932# a temporary file for further processing. Otherwise we continue in the standard
2933# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2934# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2935# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2936if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
2937 TMPMODPROBE_FLAG="Y"
2938else
2939 TMPMODPROBE_FLAG="N"
2940 [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2941 [ ! -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..."
2942fi
2943
2944# Update the PATH variable if incomplete
2945if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2946 PATH=$PATH:/sbin:/usr/sbin
2947 export PATH
2948 echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2949 echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2950 echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2951fi
2952
2953# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2954if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2955 source $MINDI_LIB/FindDistroFailsafe
2956 # Log kernel image
2957 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2958else
2959 [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2960fi
2961
2962if ! which mkfs.vfat &> /dev/null ; then
2963 Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2964fi
2965
2966### BERLIOS
2967### Fix as it's not mandatory on ia64
2968if [ "$ARCH" = "ia64" ] ; then
2969 if which elilo &> /dev/null ; then
2970 LILO_EXE=elilo
2971 else
2972 LILO_EXE=`which false`
2973 fi
2974else
2975 FindIsolinuxBinary
2976 FindLiloBinary
2977fi
2978trap "Aborted" SIGTERM
2979DONE="\r\t\t\t\t\t\t\t\tDone. "
2980CHOPSIZE=240
2981BIGNO=0
2982MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
2983
2984#
2985# Kernel management: Attempt to locate kernel specific module path
2986# if module path is found then use it other wise use uname -r to set it...
2987#
2988#
2989kernelpath="$mindi_kernel"
2990if [ "$kernelpath" = "NATIVE" ]; then
2991 kernelpath=""
2992fi
2993if [ "$kernelpath" = "" ]; then
2994 kernelpath=`TryToFindKernelPath`
2995fi
2996kernelname=`echo $kernelpath | cut -d'-' -f2-`
2997echo "kernelname = $kernelname" >> $LOGFILE
2998echo "kernelpath = $kernelpath" >> $LOGFILE
2999if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3000then
3001 echo "Module path for ${kernelpath} not found..." >> $LOGFILE
3002 echo "using running kernel\'s modules." >> $LOGFILE
3003 kernelname=`uname -r`
3004else
3005 echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3006fi
3007
3008if [ -d "/proc/lvm" ]; then
3009 # LVM v1
3010 LVMCMD=""
3011 LVM="v1"
3012elif [ -d "/dev/mapper" ]; then
3013 # LVM v2
3014 LVMCMD="lvm"
3015 LVM="v2"
3016else
3017 LVM="false"
3018fi
3019echo "LVM set to $LVM" >> $LOGFILE
3020echo "----------" >> $LOGFILE
3021echo "df result:" >> $LOGFILE
3022echo "----------" >> $LOGFILE
3023df -T >> $LOGFILE
3024echo "-------------" >> $LOGFILE
3025echo "mount result:" >> $LOGFILE
3026echo "-------------" >> $LOGFILE
3027mount >> $LOGFILE
3028echo "-------------" >> $LOGFILE
3029if [ -e /etc/raidtab ]; then
3030 echo "-------------" >> $LOGFILE
3031 echo "/etc/raidtab content:" >> $LOGFILE
3032 echo "-------------" >> $LOGFILE
3033 cat /etc/raidtab >> $LOGFILE
3034fi
3035echo "-------------" >> $LOGFILE
3036echo "lsmod result:" >> $LOGFILE
3037echo "-------------" >> $LOGFILE
3038lsmod >> $LOGFILE
3039echo "-------------" >> $LOGFILE
3040echo "Liste of extra modules is:" >> $LOGFILE
3041echo "$EXTRA_MODS" >> $LOGFILE
3042echo "-------------" >> $LOGFILE
3043
3044
3045FLOPPY_WAS_MOUNTED=""
3046for mtpt in /media/floppy /mnt/floppy /floppy ; do
3047 if mount | grep -w $mtpt &> /dev/null ; then
3048 FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3049 umount $mtpt
3050 fi
3051done
3052
3053#
3054# If we have a USB device we need to store info
3055# and remove it from the parameters line
3056#
3057if [ "$#" -ne "0" ] ; then
3058 if [ "$1" = "--usb" ] ; then
3059 shift
3060 USBDEVICE=$1
3061 if [ _"$USBDEVICE" = _"" ]; then
3062 Die "No USB device specified"
3063 fi
3064 shift
3065 fi
3066fi
3067
3068#
3069# Default value for parameters coming from mondo potentially
3070#
3071if [ "$ARCH" = "ia64" ] ; then
3072 USE_LILO=yes
3073else
3074 USE_LILO=no
3075fi
3076
3077#
3078# These variables are normaly only significant in a mondo environment
3079# Not enforced yet
3080#
3081CDRECOVERY="no"
3082NOT_BOOT="no"
3083EXCLUDE_DEVS=""
3084IMAGE_DEVS=""
3085NFS_DEV=""
3086
3087#
3088# Deal with parameters
3089#
3090if [ "$#" -ne "0" ] ; then
3091 if [ "$1" = "--findkernel" ] ; then
3092 res=`TryToFindKernelPath`
3093 # Avoids logfile content for mondo
3094 export MONDO_SHARE=""
3095 if [ "$res" = "" ] ; then
3096 MindiExit -1
3097 else
3098 echo "$res"
3099 MindiExit 0
3100 fi
3101 elif [ "$1" = "--makemountlist" ] ; then
3102 [ ! "$2" ] && Die "Please specify the output file"
3103 MakeMountlist $2
3104 # Avoids logfile content for mondo
3105 export MONDO_SHARE=""
3106 MindiExit $?
3107 elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3108 echo "Mindi v$MINDI_VERSION"
3109 # Avoids logfile content for mondo
3110 export MONDO_SHARE=""
3111 MindiExit 0
3112 elif [ "$1" = "--custom" ] ; then
3113 if [ _"$MONDO_SHARE" = _"" ]; then
3114 Die "--custom is reserved for mondoarchive calls"
3115 fi
3116 MONDO_TMP=$2
3117 # Change MINDI_TMP for the one provided by mondo
3118 # So that it can get back the built files
3119 mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3120 rmdir $MINDI_TMP
3121 MINDI_TMP=$MONDO_TMP
3122 mkdir -p $MINDI_TMP
3123 # This is the scratch dir in mondo
3124 MINDI_CACHE=$3
3125 if [ _"$MINDI_CACHE" != _"" ]; then
3126 mkdir -p $MINDI_CACHE
3127 fi
3128
3129 if [ ! -e "$MONDORESTORECFG" ]; then
3130 Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3131 fi
3132
3133 if [ ! -e "$MONDO_CACHE" ]; then
3134 Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3135 else
3136 #
3137 # Get from mondo our additional configuration
3138 #
3139 echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3140 if [ -f $MONDO_CACHE/mindi.conf ]; then
3141 . $MONDO_CACHE/mindi.conf
3142 echo "-----------------------------" >> $LOGFILE
3143 echo " Mondo configuration file " >> $LOGFILE
3144 echo "-----------------------------" >> $LOGFILE
3145 cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3146 echo "-----------------------------" >> $LOGFILE
3147 else
3148 Die "No mindi.conf file created by mondo. Aborting"
3149 fi
3150 fi
3151
3152 echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3153 echo "------------------------------------" >> $LOGFILE
3154 cat $MONDORESTORECFG >> $LOGFILE
3155 echo "-----------------------------------" >> $LOGFILE
3156
3157 CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3158 NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3159 USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3160 EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3161 NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3162 VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3163 if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3164 IMAGE_DEVS=""
3165 else
3166 IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3167 fi
3168 [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3169 MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3170 if [ _"$MONDO_ROOT" != _"" ]; then
3171 mkdir -p $MONDO_ROOT
3172 else
3173 Die "MONDO_ROOT is undefined"
3174 fi
3175 else
3176 echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3177 MindiExit -1
3178 fi
3179fi
3180#ScanCDandTape
3181[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3182if [ "$CDRECOVERY" = "yes" ] ; then
3183 iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3184 sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3185else
3186 iso_cfg_file=$MINDI_LIB/isolinux.cfg
3187 sys_cfg_file=$MINDI_LIB/syslinux.cfg
3188fi
3189
3190[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3191if [ _"$MONDO_SHARE" = _"" ]; then
3192 LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3193 LogIt "Latest Mindi is available from http://www.mondorescue.org"
3194 LogIt "BusyBox sources are available from http://www.busybox.net"
3195else
3196 echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3197fi
3198if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3199 LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3200else
3201 LogIt "Unable to find mindi-busybox, please install it"
3202 MindiExit -1
3203fi
3204
3205# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3206insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3207for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3208 insmod $i >> $LOGFILE 2>> $LOGFILE
3209done
3210
3211KERN_DISK_MADE=""
3212
3213if [ "$NOT_BOOT" = "yes" ]; then
3214 LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3215 mkdir -p $MINDI_TMP/small-all/tmp
3216 MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3217 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"
3218 cd $MINDI_TMP/small-all
3219 tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3220 sync
3221 LogIt "Done. Exiting."
3222 MindiExit 0
3223fi
3224
3225if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3226 LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3227fi
3228if [ "$kernelpath" = "" ] ; then
3229 if [ _"$MONDO_SHARE" != _"" ]; then
3230 Die "Please use -k <path> to specify kernel."
3231 fi
3232 if [ "$INTERACTIVE" = "yes" ]; then
3233 echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3234 read ch
3235 if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3236 USE_OWN_KERNEL="yes"
3237 fi
3238 fi
3239 if [ "$USE_OWN_KERNEL" = "yes" ]; then
3240 YOUR_KERNEL_SUCKS=""
3241 kernelpath=`TryToFindKernelPath`
3242 if [ "$kernelpath" = "" ] ; then
3243 echo -n "Please enter kernel path : "
3244 read kernelpath
3245 fi
3246 else
3247 YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3248 fi
3249fi
3250if [ _"$MONDO_SHARE" = _"" ] && [ "$INTERACTIVE" = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3251 echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3252 read ch
3253 if [ "$ch" = "y" ] || [ "$ch" = "Y" ] ; then
3254 USE_LILO=yes
3255 fi
3256fi
3257if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3258 # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3259 if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3260 source $MINDI_LIB/FindDistroFailsafe
3261 # Log kernel image
3262 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3263 kernelpath="$FAILSAFE_KBIN"
3264 LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3265 LogIt "The failsafe kernel is $kernelpath.\n"
3266 LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3267 LogIt "disks then it may still be a result of a problem with your kernel.\n"
3268 pwd=`pwd`
3269 cd $MINDI_TMP
3270 mkdir -p lib/modules
3271 cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3272 cd $pwd
3273 else
3274 kernelpath=$MINDI_LIB/vmlinuz
3275 LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3276 LogIt "However, you are still running your kernel. If Mindi fails to create your"
3277 LogIt "disks then it may still be a result of a problem with your kernel."
3278 pwd=`pwd`
3279 cd $MINDI_TMP
3280 bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3281 cd $pwd
3282 fi
3283 YOUR_KERNEL_SUCKS="Your kernel sucks"
3284fi
3285echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3286[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3287
3288[ "$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."
3289
3290rm -f $MINDI_CACHE/{*img,*gz,*iso}
3291
3292PrepareDataDiskImages $MINDI_CACHE
3293noof_disks=$?
3294ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3295rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3296ramdisk_size=$rds
3297
3298echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3299if [ "$USE_LILO" = "yes" ] ; then
3300 if [ "$ARCH" = "ia64" ] ; then
3301 PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3302 else
3303 if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3304 LogIt "WARNING - failed to create 2.88MB floppy disk image."
3305 LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3306 PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3307 fi
3308 fi
3309else
3310 if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3311 LogIt "WARNING - failed to create 2.88MB floppy disk image."
3312 LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3313 PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
3314 fi
3315fi
3316
3317[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3318...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3319
3320if [ _"$MONDO_SHARE" = _"" ]; then
3321 ListImagesForUser $MINDI_CACHE
3322 if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3323 OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
3324 fi
3325 OfferToMakeBootableISO $MINDI_CACHE
3326 if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3327 OfferToMakeBootableUSB $MINDI_CACHE
3328 fi
3329 LogIt "Finished."
3330elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3331 rm -f $MINDI_CACHE/{*img,*gz,*iso}
3332 OfferToMakeBootableISO $MINDI_CACHE
3333 if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3334 cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3335 else
3336 Die "Cannot find all.tar.gz, to be written to tape"
3337 fi
3338elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3339 OfferToMakeBootableUSB $MINDI_CACHE
3340else
3341 OfferToMakeBootableISO $MINDI_CACHE
3342fi
3343# cleanup
3344LogIt "$FRIENDLY_OUTSTRING"
3345for mtpt in $FLOPPY_WAS_MOUNTED ; do
3346 mount $mtpt
3347done
3348MindiExit 0
Note: See TracBrowser for help on using the repository browser.