source: branches/stable/mindi/mindi @ 1904

Last change on this file since 1904 was 1904, checked in by bruno, 11 years ago

merge -r 1889:1902 svn+ssh://bruno@svn.mondorescue.org/mondo/svn/mondorescue/branches/2.2.6

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