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

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

mindi will now report /proc/cmdline to help debuging
  • Property svn:keywords set to Rev Id
File size: 113.9 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1420 2007-05-07 20:52:15Z 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 -e 's/i[5-7]86//' -e 's/cmov//' | 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="$MODULES"
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 echo "$MODULES" | 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="$MODULES"
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 cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2699 cd $old_pwd
2700 echo -en "..."
2701 MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2702 echo -en "..."
2703 old_pwd=`pwd`
2704 if [ "$YOUR_KERNEL_SUCKS" ] ; then
2705 cd $MINDI_TMP
2706 floppy_modules_path=lib/modules/$FAILSAFE_KVER
2707 else
2708 cd /
2709###
2710### Sq-Modification... Use kernel name in module path if specified.
2711###
2712 #floppy_modules_path=lib/modules/`uname -r`
2713 if [ "${kernelname}" != "" ]
2714 then
2715 floppy_modules_path=lib/modules/${kernelname}
2716 else
2717 floppy_modules_path=lib/modules/`uname -r`
2718 fi
2719###
2720### Sq-Modification end
2721###
2722 fi
2723 floppy_modules=""
2724 if [ "$disksize" -lt "2880" ] ; then
2725 list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2726 else
2727 list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2728 fi
2729 if [ "$NFS_DEV" != "" ] ; then
2730 # For PXE boot
2731 list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2732 fi
2733 [ -e "$floppy_modules_path" ] || LogIt "path $floppy_modules_path does not exist.\n If you're not using a modular kernel then you're NUTS."
2734 for i in $list_of_groovy_mods ; do
2735 floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2736 done
2737 for i in $floppy_modules ; do
2738 [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2739 [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2740 echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2741 cp -df $i $mountpoint/ 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2742 [ "`echo "$i" | grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
2743 done
2744 if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2745 echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2746 [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2747 [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2748 [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2749 rm -f $mountpoint/sbin/devfsd
2750 fi
2751 cd $old_pwd
2752 [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2753 dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2754 rm -f $mountpoint/zero
2755 mkdir -p $mountpoint/tmp
2756 if [ _"$MONDO_SHARE" != _"" ]; then
2757 cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null || Die "Cannot copy mondo-restore.cfg to ramdisk"
2758 cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2759 fi
2760 mkdir -p $mountpoint/proc
2761 echo "$disksize" > $mountpoint/tmp/$disksize.siz
2762 find $mountpoint -name CVS -exec rm -rf '{}' \;
2763 # Determine what filesystem to use for initrd image
2764 echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2765 gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2766 [ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2767 case "$gvFileSystem" in
2768 "ext2fs")
2769 # say what will be used
2770 echo "Creating an ext2 initrd image..." >> $LOGFILE
2771 # kernel expects linuxrc in ext2 filesystem
2772 ( cd $mountpoint && ln -sf sbin/init linuxrc )
2773 # unmount loop filesystem and create image file using the standard approach
2774 umount $mountpoint || Die "Cannot unmount $tempfile"
2775 dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2776 bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2`
2777 ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2778 gzip -v9 ${rdz_fname}.tmp > $rdz_fname 2> /dev/null
2779 rm -f ${rdz_fname}.tmp
2780 # log that we are done
2781 echo "...done." >> $LOGFILE
2782 ;;
2783 "initramfs")
2784 # say what will be used
2785 echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2786 # make sure that cpio is there
2787 which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2788 # go into filesystem
2789 cd $mountpoint
2790 # kernel expects init in cpio filesystem
2791 ln -sf sbin/init init
2792 # create cpio image file and unmount loop filesystem
2793 find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2794 cd $old_pwd
2795 umount $mountpoint || Die "Cannot unmount $tempfile"
2796 # log that we are done
2797 echo "...done." >> $LOGFILE
2798 ;;
2799 *)
2800 Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2801 ;;
2802 esac
2803 if [ "$res" -eq "0" ] ; then
2804 echo -en "..."
2805 else
2806 echo -en "\rMade an rdz WITH ERRORS. \n"
2807 fi
2808 return 0
2809}
2810
2811
2812WhichOfTheseModulesAreLoaded() {
2813 local modname loaded_modules
2814 loaded_modules="$MODULES"
2815 for modname in $1 ; do
2816 [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2817 done
2818}
2819
2820
2821ZipMinidirsIntoTarballs() {
2822 local minidir_root tardir noof_disks diskno old_pwd i
2823 minidir_root=$1
2824 tardir=$2
2825 noof_disks=$3
2826
2827 echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2828 mkdir -p $tardir
2829 mkdir -p $minidir_root/all
2830 old_pwd=`pwd`
2831 diskno=1
2832 while [ "$diskno" -le "$noof_disks" ] ; do
2833 cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2834 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."
2835 diskno=$(($diskno+1))
2836 echo -n "..."
2837 cp -pRdf * $minidir_root/all 2>> $LOGFILE
2838 done
2839 mkdir -p $minidir_root/all/tmp
2840 cd $minidir_root/all
2841 size_of_all_tools=`du -sk . | cut -f1`
2842 if [ _"$MONDO_SHARE" != _"" ]; then
2843 for q in filelist.full.gz biggielist.txt ; do
2844 [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2845 cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2846 done
2847 mkdir -p $minidir_root/all/tmp
2848 fi
2849 tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2850 dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2851 [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2852 cd $old_pwd
2853 [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2854 echo -e "$DONE"
2855}
2856
2857
2858##############################################################################
2859#----------------------------------- Main -----------------------------------#
2860##############################################################################
2861
2862# Now we can create what we nedd
2863mkdir -p $MINDI_TMP
2864
2865# Purge from potential old run
2866if [ _"$MINDI_CACHE" = _"" ]; then
2867 Die "MINDI_CACHE undefined"
2868fi
2869rm -rf $MINDI_CACHE/* 2> /dev/null
2870mkdir -p $MINDI_CACHE
2871
2872
2873if [ "$1" = "--printvar" ] ; then
2874 shift
2875 if [ _"$1" != _"" ] ; then
2876 set | egrep "^$1" | cut -d= -f2
2877 fi
2878 MindiExit 0
2879fi
2880
2881> $LOGFILE
2882echo "mindi v$MINDI_VERSION" >> $LOGFILE
2883echo "$ARCH architecture detected" >> $LOGFILE
2884echo "mindi called with the following arguments:" >> $LOGFILE
2885echo "$@" >> $LOGFILE
2886echo "Start date : `date`" >> $LOGFILE
2887echo "-----------------------------" >> $LOGFILE
2888
2889if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2890 LogIt "WARNING - Ancient distro detected." 1
2891 ln -sf /etc/conf.modules /etc/modules.conf
2892fi
2893[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2894
2895# Log some capital variables
2896[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2897echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2898echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2899echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2900[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2901echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2902if [ -f $MINDI_CONF ]; then
2903 echo "-----------------------------" >> $LOGFILE
2904 echo " Mindi configuration file " >> $LOGFILE
2905 echo "-----------------------------" >> $LOGFILE
2906 cat $MINDI_CONF >> $LOGFILE
2907 echo "-----------------------------" >> $LOGFILE
2908fi
2909
2910
2911trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2912
2913# Sanity checks
2914which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2915which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2916which 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."
2917which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2918if which awk &> /dev/null ; then
2919 if ! which gawk &> /dev/null ; then
2920 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"
2921 fi
2922fi
2923which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2924[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2925
2926[ "`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"
2927# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2928# may have the modprobe configuration spread out across multiple files in
2929# directory /etc/modprobe.d. If this is the case we concatenate these files into
2930# a temporary file for further processing. Otherwise we continue in the standard
2931# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2932# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2933# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2934if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
2935 TMPMODPROBE_FLAG="Y"
2936else
2937 TMPMODPROBE_FLAG="N"
2938 [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2939 [ ! -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..."
2940fi
2941
2942# Update the PATH variable if incomplete
2943if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2944 PATH=$PATH:/sbin:/usr/sbin
2945 export PATH
2946 echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2947 echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2948 echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2949fi
2950
2951# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2952if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2953 source $MINDI_LIB/FindDistroFailsafe
2954 # Log kernel image
2955 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2956else
2957 [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2958fi
2959
2960if ! which mkfs.vfat &> /dev/null ; then
2961 Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2962fi
2963
2964### BERLIOS
2965### Fix as it's not mandatory on ia64
2966if [ "$ARCH" = "ia64" ] ; then
2967 if which elilo &> /dev/null ; then
2968 LILO_EXE=elilo
2969 else
2970 LILO_EXE=`which false`
2971 fi
2972else
2973 FindIsolinuxBinary
2974 FindLiloBinary
2975fi
2976trap "Aborted" SIGTERM
2977DONE="\r\t\t\t\t\t\t\t\tDone. "
2978CHOPSIZE=240
2979BIGNO=0
2980MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
2981
2982#
2983# Kernel management: Attempt to locate kernel specific module path
2984# if module path is found then use it other wise use uname -r to set it...
2985#
2986#
2987kernelpath="$mindi_kernel"
2988if [ "$kernelpath" = "NATIVE" ]; then
2989 kernelpath=""
2990fi
2991if [ "$kernelpath" = "" ]; then
2992 kernelpath=`TryToFindKernelPath`
2993fi
2994kernelname=`echo $kernelpath | cut -d'-' -f2-`
2995echo "kernelname = $kernelname" >> $LOGFILE
2996echo "kernelpath = $kernelpath" >> $LOGFILE
2997if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2998then
2999 echo "Module path for ${kernelpath} not found..." >> $LOGFILE
3000 echo "using running kernel\'s modules." >> $LOGFILE
3001 kernelname=`uname -r`
3002else
3003 echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3004fi
3005
3006if [ -d "/proc/lvm" ]; then
3007 # LVM v1
3008 LVMCMD=""
3009 LVM="v1"
3010elif [ -d "/dev/mapper" ]; then
3011 # LVM v2
3012 LVMCMD="lvm"
3013 LVM="v2"
3014else
3015 LVM="false"
3016fi
3017echo "LVM set to $LVM" >> $LOGFILE
3018echo "----------" >> $LOGFILE
3019echo "df result:" >> $LOGFILE
3020echo "----------" >> $LOGFILE
3021df -T >> $LOGFILE
3022echo "-------------" >> $LOGFILE
3023echo "mount result:" >> $LOGFILE
3024echo "-------------" >> $LOGFILE
3025mount >> $LOGFILE
3026echo "-------------" >> $LOGFILE
3027if [ -e /etc/raidtab ]; then
3028 echo "-------------" >> $LOGFILE
3029 echo "/etc/raidtab content:" >> $LOGFILE
3030 echo "-------------" >> $LOGFILE
3031 cat /etc/raidtab >> $LOGFILE
3032fi
3033echo "-------------" >> $LOGFILE
3034echo "cat /proc/cmdline:" >> $LOGFILE
3035echo "-------------" >> $LOGFILE
3036cat /proc/cmdline >> $LOGFILE
3037echo "-------------" >> $LOGFILE
3038echo "lsmod result:" >> $LOGFILE
3039echo "-------------" >> $LOGFILE
3040lsmod >> $LOGFILE
3041MODULES="`cat /proc/modules | awk '{print $1}'`"
3042echo "-------------" >> $LOGFILE
3043echo "Liste of extra modules is:" >> $LOGFILE
3044echo "$EXTRA_MODS" >> $LOGFILE
3045echo "-------------" >> $LOGFILE
3046
3047
3048FLOPPY_WAS_MOUNTED=""
3049for mtpt in /media/floppy /mnt/floppy /floppy ; do
3050 if mount | grep -w $mtpt &> /dev/null ; then
3051 FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3052 umount $mtpt
3053 fi
3054done
3055
3056#
3057# If we have a USB device we need to store info
3058# and remove it from the parameters line
3059#
3060if [ "$#" -ne "0" ] ; then
3061 if [ "$1" = "--usb" ] ; then
3062 shift
3063 USBDEVICE=$1
3064 if [ _"$USBDEVICE" = _"" ]; then
3065 Die "No USB device specified"
3066 fi
3067 shift
3068 fi
3069fi
3070
3071#
3072# Default value for parameters coming from mondo potentially
3073#
3074if [ "$ARCH" = "ia64" ] ; then
3075 USE_LILO=yes
3076else
3077 USE_LILO=no
3078fi
3079
3080#
3081# These variables are normaly only significant in a mondo environment
3082# Not enforced yet
3083#
3084CDRECOVERY="no"
3085NOT_BOOT="no"
3086EXCLUDE_DEVS=""
3087IMAGE_DEVS=""
3088NFS_DEV=""
3089
3090#
3091# Deal with parameters
3092#
3093if [ "$#" -ne "0" ] ; then
3094 if [ "$1" = "--findkernel" ] ; then
3095 res=`TryToFindKernelPath`
3096 # Avoids logfile content for mondo
3097 export MONDO_SHARE=""
3098 if [ "$res" = "" ] ; then
3099 MindiExit -1
3100 else
3101 echo "$res"
3102 MindiExit 0
3103 fi
3104 elif [ "$1" = "--makemountlist" ] ; then
3105 [ ! "$2" ] && Die "Please specify the output file"
3106 MakeMountlist $2
3107 # Avoids logfile content for mondo
3108 export MONDO_SHARE=""
3109 MindiExit $?
3110 elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3111 echo "Mindi v$MINDI_VERSION"
3112 # Avoids logfile content for mondo
3113 export MONDO_SHARE=""
3114 MindiExit 0
3115 elif [ "$1" = "--custom" ] ; then
3116 if [ _"$MONDO_SHARE" = _"" ]; then
3117 Die "--custom is reserved for mondoarchive calls"
3118 fi
3119 MONDO_TMP=$2
3120 # Change MINDI_TMP for the one provided by mondo
3121 # So that it can get back the built files
3122 mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3123 rmdir $MINDI_TMP
3124 MINDI_TMP=$MONDO_TMP
3125 mkdir -p $MINDI_TMP
3126 # This is the scratch dir in mondo
3127 MINDI_CACHE=$3
3128 if [ _"$MINDI_CACHE" != _"" ]; then
3129 mkdir -p $MINDI_CACHE
3130 fi
3131
3132 if [ ! -e "$MONDORESTORECFG" ]; then
3133 Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3134 fi
3135
3136 if [ ! -e "$MONDO_CACHE" ]; then
3137 Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3138 else
3139 #
3140 # Get from mondo our additional configuration
3141 #
3142 echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3143 if [ -f $MONDO_CACHE/mindi.conf ]; then
3144 . $MONDO_CACHE/mindi.conf
3145 echo "-----------------------------" >> $LOGFILE
3146 echo " Mondo configuration file " >> $LOGFILE
3147 echo "-----------------------------" >> $LOGFILE
3148 cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3149 echo "-----------------------------" >> $LOGFILE
3150 else
3151 Die "No mindi.conf file created by mondo. Aborting"
3152 fi
3153 fi
3154
3155 echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3156 echo "------------------------------------" >> $LOGFILE
3157 cat $MONDORESTORECFG >> $LOGFILE
3158 echo "-----------------------------------" >> $LOGFILE
3159
3160 CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3161 NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3162 USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3163 EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3164 NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3165 VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3166 if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3167 IMAGE_DEVS=""
3168 else
3169 IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3170 fi
3171 [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3172 MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3173 if [ _"$MONDO_ROOT" != _"" ]; then
3174 mkdir -p $MONDO_ROOT
3175 else
3176 Die "MONDO_ROOT is undefined"
3177 fi
3178 else
3179 echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3180 MindiExit -1
3181 fi
3182fi
3183#ScanCDandTape
3184[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3185if [ "$CDRECOVERY" = "yes" ] ; then
3186 iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3187 sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3188else
3189 iso_cfg_file=$MINDI_LIB/isolinux.cfg
3190 sys_cfg_file=$MINDI_LIB/syslinux.cfg
3191fi
3192
3193[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3194if [ _"$MONDO_SHARE" = _"" ]; then
3195 LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3196 LogIt "Latest Mindi is available from http://www.mondorescue.org"
3197 LogIt "BusyBox sources are available from http://www.busybox.net"
3198else
3199 echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3200fi
3201if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3202 LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3203else
3204 LogIt "Unable to find mindi-busybox, please install it"
3205 MindiExit -1
3206fi
3207
3208# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3209insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3210for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3211 insmod $i >> $LOGFILE 2>> $LOGFILE
3212done
3213
3214KERN_DISK_MADE=""
3215
3216if [ "$NOT_BOOT" = "yes" ]; then
3217 LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3218 mkdir -p $MINDI_TMP/small-all/tmp
3219 MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3220 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"
3221 cd $MINDI_TMP/small-all
3222 tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3223 sync
3224 LogIt "Done. Exiting."
3225 MindiExit 0
3226fi
3227
3228if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3229 LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3230fi
3231if [ "$kernelpath" = "" ] ; then
3232 if [ _"$MONDO_SHARE" != _"" ]; then
3233 Die "Please use -k <path> to specify kernel."
3234 fi
3235 if [ "$INTERACTIVE" = "yes" ]; then
3236 echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3237 read ch
3238 if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3239 USE_OWN_KERNEL="yes"
3240 fi
3241 fi
3242 if [ "$USE_OWN_KERNEL" = "yes" ]; then
3243 YOUR_KERNEL_SUCKS=""
3244 kernelpath=`TryToFindKernelPath`
3245 if [ "$kernelpath" = "" ] ; then
3246 echo -n "Please enter kernel path : "
3247 read kernelpath
3248 fi
3249 else
3250 YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3251 fi
3252fi
3253if [ _"$MONDO_SHARE" = _"" ] && [ "$INTERACTIVE" = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3254 echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3255 read ch
3256 if [ "$ch" = "y" ] || [ "$ch" = "Y" ] ; then
3257 USE_LILO=yes
3258 fi
3259fi
3260if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3261 # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3262 if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3263 source $MINDI_LIB/FindDistroFailsafe
3264 # Log kernel image
3265 LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3266 kernelpath="$FAILSAFE_KBIN"
3267 LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3268 LogIt "The failsafe kernel is $kernelpath.\n"
3269 LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3270 LogIt "disks then it may still be a result of a problem with your kernel.\n"
3271 pwd=`pwd`
3272 cd $MINDI_TMP
3273 mkdir -p lib/modules
3274 cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3275 cd $pwd
3276 else
3277 kernelpath=$MINDI_LIB/vmlinuz
3278 LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3279 LogIt "However, you are still running your kernel. If Mindi fails to create your"
3280 LogIt "disks then it may still be a result of a problem with your kernel."
3281 pwd=`pwd`
3282 cd $MINDI_TMP
3283 bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3284 cd $pwd
3285 fi
3286 YOUR_KERNEL_SUCKS="Your kernel sucks"
3287fi
3288echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3289[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3290
3291[ "$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."
3292
3293PrepareDataDiskImages $MINDI_CACHE
3294noof_disks=$?
3295ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3296rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3297ramdisk_size=$rds
3298
3299echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3300if [ "$USE_LILO" = "yes" ] ; then
3301 if [ "$ARCH" = "ia64" ] ; then
3302 PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3303 else
3304 if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3305 LogIt "WARNING - failed to create 2.88MB floppy disk image."
3306 LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3307 PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3308 fi
3309 fi
3310else
3311 if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3312 LogIt "WARNING - failed to create 2.88MB floppy disk image."
3313 LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3314 PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
3315 fi
3316fi
3317
3318[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3319...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3320
3321if [ _"$MONDO_SHARE" = _"" ]; then
3322 ListImagesForUser $MINDI_CACHE
3323 if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3324 OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
3325 fi
3326 OfferToMakeBootableISO $MINDI_CACHE
3327 if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3328 OfferToMakeBootableUSB $MINDI_CACHE
3329 fi
3330 LogIt "Finished."
3331elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3332 rm -f $MINDI_CACHE/{*img,*gz,*iso}
3333 OfferToMakeBootableISO $MINDI_CACHE
3334 if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3335 cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3336 else
3337 Die "Cannot find all.tar.gz, to be written to tape"
3338 fi
3339elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3340 OfferToMakeBootableUSB $MINDI_CACHE
3341else
3342 OfferToMakeBootableISO $MINDI_CACHE
3343fi
3344# cleanup
3345LogIt "$FRIENDLY_OUTSTRING"
3346for mtpt in $FLOPPY_WAS_MOUNTED ; do
3347 mount $mtpt
3348done
3349MindiExit 0
Note: See TracBrowser for help on using the repository browser.