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

Last change on this file since 1326 was 1326, checked in by Bruno Cornec, 17 years ago
  • MONDO_LOGFILE is rather a char* exported by each main program (consolidation of those mecanisms in .h files with ps_*)
  • One include has been created for each binary containing only the specific declarations
  • Log files are now consistent: mondoarchive.log for mondoarchive (containing also mindi.log) and mondorestore.log for mondorestore (copied from /tmp (ram) to /var/log (disk) at the end of the restore)
  • Doc updated accordingly
  • LOGFILE in restore process is now passed in the environment and not duplicated a nymore
  • LogIt is not redifined either
  • LOGFILE should be put in environment by mondoarchive for mindi's usage but that's a step left for later.
  • label-partitions-as-necessary should now work correctly for LABEL and UUID (grep -w removed)
  • Remove useless script compare-me

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