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

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

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