source: branches/stable/mindi/mindi @ 1468

Last change on this file since 1468 was 1468, checked in by Bruno Cornec, 13 years ago
  • Try to improve kernel support and detection for gentoo. (kernel named genkernel-* and not *lin*)
  • Adds support for keyboard for Gentoo

merge -r 1463:1465 $SVN_M/branches/2.2.4

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