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

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

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