source: branches/2.2.6/mindi/mindi @ 1929

Last change on this file since 1929 was 1929, checked in by Bruno Cornec, 12 years ago

Fix a problem in case of initramfs type of boot file in the path of the file generated

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