source: branches/2.2.6/mindi/mindi @ 1950

Last change on this file since 1950 was 1950, checked in by bruno, 11 years ago
  • Do not propose to use ILLO in mindi standalone
  • Remove temporary .img files at the end of mindi
  • Push the iso image on the tape the right way
  • Property svn:keywords set to Rev Id
File size: 108.7 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1950 2008-05-26 16:39:48Z 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 intermodule"
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    AddFileToCfgIfExists $MINDI_TMP/OBDR      obdr      $outfile
1034}
1035
1036
1037MakeMountlist() {
1038    local scratchdir mountlist all_partitions current_partition \
1039partition_size partition_format outstring partition_number \
1040partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
1041absolute_partition old_partition_fmt current_lvolume
1042
1043    echo "Your raw fstab file looks like this:" >> $LOGFILE
1044    echo "------------------------------------" >> $LOGFILE
1045    cat $MY_FSTAB >> $LOGFILE
1046    echo "Your mountlist will look like this:" | tee -a $LOGFILE
1047    echo "-----------------------------------" >> $LOGFILE
1048
1049# scratchdir, mountlist(OUT)
1050    scratchdir=$MINDI_TMP
1051    mountlist=$1
1052
1053# NB: partition = device
1054# NB: mountpt = where the device is mounted
1055
1056    [ -e "$MY_FSTAB" ] || Die "Cannot find your fstab file ($MY_FSTAB)"
1057
1058    [ "$mountlist" != "" ] && rm -Rf $mountlist
1059    > $mountlist
1060    all_partitions=""
1061   
1062    if [ $LVM != "false" ]; then
1063        echo -en "Analyzing LVM...\n"
1064        $MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
1065        if [ $? -ne 0 ]; then
1066            LVM="false"
1067        fi
1068        all_partitions=`cat $MINDI_TMP/lvm.res | grep -F ">>>" | cut -d' ' -f2-32`
1069    fi
1070    all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
1071#    echo "all partitions = $all_partitions" > /dev/stderr
1072    for i in $IMAGE_DEVS ; do
1073        mount | grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
1074    done
1075    [ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" | tr ' ' '\n' | sort -u | tr '\n ' ' '`"
1076    printf "        %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID | tee -a $LOGFILE
1077    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"
1078    for c_p in $all_partitions ; do
1079        [ "`echo "$useless_dev" | grep -F "$c_p"`" != "" ] || [ "`echo "$c_p" | grep ":"`" != "" ] && continue
1080        [ "`echo "$c_p" | grep -x "/dev/cdroms.*"`" ] && continue
1081        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
1082            current_partition=`readlink -f $c_p`
1083            [ "`echo "$current_partition" | grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
1084            [ "`echo "$useless_dev" | grep -F "$current_partition"`" ] && continue
1085        else
1086            current_partition="$c_p"
1087        fi
1088        [ "$c_p" = "none" ] && continue
1089        redhat_label=""
1090        label=""
1091        uuid=""
1092        absolute_partition=`readlink -f $c_p`
1093        partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1094
1095        # Detects noauto partitions not mounted and exclude them
1096        partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1097        if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" =  "" ] ; then
1098            continue
1099        fi
1100
1101        # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1102        # current_partition contains only first column of /etc/fstab
1103        if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1104            str_to_find_fmt_with=$current_partition
1105            redhat_label=`echo "$current_partition" | cut -d'=' -f2`
1106            actual_dev=""
1107
1108            # 1st try, findfs - the RHEL way of finding labels and their partitions
1109            if [ -x "/sbin/findfs" ]; then
1110                actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1111            fi
1112   
1113            # 2nd try : blkid, the good way for all LABEL except swap
1114            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1115                actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | cut -d':' -f1`
1116                # For LVM FS it will give a /dev/dm-# which should then be converted
1117                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1118                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1119                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1120                    for dev in `ls /dev/mapper/*`; do
1121                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1122                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1123                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1124                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1125                            break
1126                        fi
1127                    done
1128                fi
1129            fi
1130   
1131            # 3rd try, which works on a standard partition (ext2/3), but not on swap
1132            # For LVM gives a /dev/mapper entry
1133            if [ "x$actual_dev" = "x" ]; then
1134                actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | cut -d' ' -f1`
1135            fi
1136   
1137            # 4th try, with vol_id
1138            # SWAP only
1139            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1140                list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | $AWK '{ print $1 }' `
1141                for dev_swap in $list_swaps ; do
1142                    dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1143                    if [ "x$dev_exists" != "x" ]; then
1144                        actual_dev=$dev_swap
1145                        break;
1146                    fi
1147                done
1148            fi
1149
1150            # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1151            # LABEL=SW-cciss/c0d0p3 (RDP)
1152            # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1153            # SWAP only
1154            if [ "x$actual_dev" = "x" -a  _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1155                    for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1156                    do
1157                        # Location of the swap label for kernel 2.6
1158                        try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
1159                        if [ "x$try_dev_label" = "x$redhat_label" ]; then
1160                            actual_dev=$try_dev
1161                        fi
1162                    done
1163            fi
1164
1165            # Check if one of all those tries has known success
1166            if [ "x$actual_dev" != "x" ]; then
1167                current_partition=$actual_dev
1168            else
1169                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"
1170            fi
1171        # This part tries to retrieve the correct device from a UUID line in /etc/fstab
1172        # current_partition contains only first column of /etc/fstab
1173        elif [ "`echo "$current_partition" | /bin/grep -i "UUID="`" != "" ]; then
1174            str_to_find_fmt_with=$current_partition
1175            uuid=`echo "$current_partition" | cut -d'=' -f2`
1176            actual_dev=""
1177
1178            # 1st try, findfs - the RHEL way of finding labels and their partitions
1179            if [ -x "/sbin/findfs" ]; then
1180                actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
1181            fi
1182   
1183            # 2nd try : blkid, the good way for all UUID except swap
1184            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1185                actual_dev=`/sbin/blkid | /bin/grep "$uuid" | grep UUID= | cut -d':' -f1`
1186                # For LVM FS it will give a /dev/dm-# which should then be converted
1187                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1188                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1189                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1190                    for dev in `ls /dev/mapper/*`; do
1191                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1192                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1193                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1194                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1195                            break
1196                        fi
1197                    done
1198                fi
1199            fi
1200   
1201            # 3th try, with vol_id
1202            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1203                list_dev=`mount | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1204                for dev in $list_dev ; do
1205                    dev_exists=`/sbin/vol_id $dev | /bin/grep "$uuid"`
1206                    if [ "x$dev_exists" != "x" ]; then
1207                        actual_dev=$dev
1208                        break;
1209                    fi
1210                done
1211            fi
1212
1213            # 4th try, with dumpuuid (VMWare only ?) for swap
1214            if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
1215                list_dev=`cat /proc/swaps | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1216                for dev in $list_dev ; do
1217                    dev_exists=`/sbin/dumpuuid $dev | /bin/grep "$uuid"`
1218                    if [ "x$dev_exists" != "x" ]; then
1219                        actual_dev=$dev
1220                        break;
1221                    fi
1222                done
1223            fi
1224
1225            # Check if one of all those tries has known success
1226            if [ "x$actual_dev" != "x" ]; then
1227                current_partition=$actual_dev
1228            else
1229                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"
1230            fi
1231        else
1232            # Needs to handle the recent OpenSUSE fancy way of dealing with fstab :-(
1233            # they use symlinks in fstab unrelated to what is shown in mount !
1234            if [ _"$partition_mountpt" = _"" ]; then
1235                for tmpp in `tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -Ev "^#" | $AWK '{print $1}'`; do
1236                        if [ _"`readlink -f $tmpp`" = _"$current_partition" ]; then
1237                            str_to_find_fmt_with=$tmpp
1238                            partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$tmpp" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1239                            break;
1240                        fi
1241                done
1242            else
1243                str_to_find_fmt_with=$current_partition
1244            fi
1245        fi
1246
1247        partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1248        # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1249        # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1250        # the former is then a link to the latter, so we test whether
1251        # $current_partition is actually such a link or not and set
1252        # $current_lvolume accordingly. On Debian you may find more than one answer
1253        # so we remove the one corresponding to /dev/.static
1254        # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1255        # principle is the same and we need to find the link to it as well.
1256        # Note that $current_lvolume may well be an
1257        # ordinary device. It is just to make sure that we feed the right value
1258        # into any of the LVM tools if possible.
1259
1260        current_lvolume="$current_partition"
1261        if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1262            # .static dir are a Debian specificity
1263            current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1264            echo $current_lvolume | grep -q ' '
1265            if [ $? -eq 0 ]; then
1266                echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE 
1267            fi
1268        fi
1269        #
1270        # End of LVM device style variation code (other than $current_lvolume).
1271
1272        if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1273            # Size computed via LVM not directly
1274            partition_size="lvm"
1275        else
1276            partition_size=`SizeOfPartition $current_partition`
1277            [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1278            [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1279            if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1280                partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1281                [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1282                [ "$partition_format" != "swap" ] && partition_format="swap"
1283                if [ "$partition_size" = "" ] ; then
1284                    totalsize=0
1285                    items=0
1286                    for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1287                        totalsize=$(($totalsize+$i))
1288                        items=$(($items+1))
1289                    done
1290                    [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1291                    [ "$partition_size" -lt "125000" ] && partition_size=125000
1292                    echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1293                fi
1294            fi
1295        fi
1296        [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1297        [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1298        if [ "$partition_mountpt" = "" ] ; then
1299            if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1300                if  [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1301                    partition_mountpt="raid"
1302                    partition_format="raid"
1303                else
1304                    partition_mountpt="lvm"
1305                    partition_format="lvm"
1306                fi
1307            fi
1308        fi
1309        psz=$partition_size
1310        echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1311        [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1312        if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1313            partition_mountpt="image"
1314            old_partition_fmt=$partition_format
1315            partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1316            partition_size=$(($partition_size+1)); # just in case
1317            if [ "$partition_format" = "Linux" ] ; then
1318                echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1319                echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1320                partition_format=$old_partition_fmt
1321            fi
1322        fi
1323        if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1324            echo "Excluding $current_partition from mountlist" >> $LOGFILE
1325            continue
1326        fi
1327        if [ ! "$partition_mountpt" ] ; then
1328            echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1329            for qq in "" `find /dev/ida/c*d* ! -name '*p*' 2> /dev/null`; do
1330                partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1331                [ "$partition_format" ] && break
1332            done
1333            echo "------- $FDISK log end ------------" >> $LOGFILE
1334            if [ "$partition_format" = "Compaq diagnostics" ] ; then
1335                partition_format="compaq"
1336            elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1337                LogIt "Unable to find mountpoint of $current_partition - ignoring"
1338                continue
1339            fi
1340        fi
1341        if [ "$redhat_label" ]; then
1342            label="$redhat_label"
1343        elif [ "$uuid" ]; then
1344            label="$uuid"
1345        fi
1346        partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1347        [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1348        unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
1349        if [ "$current_partition" = "" ] ; then
1350            echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1351        elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1352            if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1353                partition_mountpt=raid
1354                partition_format=raid
1355                printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1356                printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1357            else
1358                echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1359            fi
1360        elif [ "$partition_format" = "" ] ; then
1361            echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1362        elif [ "$partition_size" = "" ] ; then
1363            echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1364        elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1365            continue
1366        else
1367            if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1368                echo "Stupid bastard..." >> $LOGFILE
1369                partition_format="vfat"
1370            fi
1371            printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1372            printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1373        fi
1374    done
1375}
1376
1377
1378MakeSureNumberIsInteger() {
1379    res=`echo "$1" | tr -s '\-[0-9]' ' '`
1380    if [ "$res" != " " ] && [ "$res" != "" ] ; then
1381    echo "result = '$res'"
1382        Die "$1 should be an integer"
1383    fi
1384}
1385
1386
1387MakeSyslinuxMessageFile() {
1388    mkdir -p $1
1389    rmdir $1
1390    echo -en "  " > $1
1391    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1392        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
1393    else
1394        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
1395    fi
1396    sed s/%r/"`uname -r`"/ $1.tmp | sed s/%t/"`hostname`"/ > $1
1397    rm -f $1.tmp
1398    if [ "$CDRECOVERY" != "yes" ] ; then
1399        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1400            echo -en "Press <enter> to continue.\n" >> $1
1401        elif [ ! "$MINDI_TMP" ] ; then
1402            echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
1403            if [ -e "$MINDI_LIB/memtest.img" ] ; then
1404                echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
1405            fi
1406        else
1407            echo -en "$BOOT_MEDIA_MESSAGE" >> $1
1408        fi
1409    else
1410        echo -en " \
1411To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1412CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1413    fi
1414}
1415
1416
1417OfferToMakeBootableISO() {
1418    local i old_pwd
1419    if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1420        echo -en "Shall I make a bootable CD image? (y/[n]) "
1421        read i
1422        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1423    fi
1424    if [ _"$MINDI_TMP" = _"" ]; then
1425        Die "MINDI_TMP undefined"
1426    fi
1427    rm -Rf $MINDI_TMP/iso
1428    mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
1429    cp -f $1/*.gz $MINDI_TMP/iso/images 2>> $LOGFILE || LogIt "OfferToMakeBootableISO: Cannot copy $1/*.gz to $MINDI_TMP/iso/images"
1430    old_pwd=`pwd`
1431    cd $MINDI_TMP/iso
1432    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1433    for i in memdisk memtest.bin memtest.img ; do
1434        j=$MINDI_LIB/$i
1435        k=$MINDI_TMP/iso/isolinux
1436        if [ -e "$j" ] ; then
1437            LogIt "Copying $j to $k"
1438            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1439            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1440            if [ _"$MONDO_SHARE" != _"" ]; then 
1441                cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1442            fi
1443        fi
1444    done
1445    MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
1446    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?"
1447    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?"
1448    if [ _"$MONDO_SHARE" != _"" ]; then 
1449        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?"
1450        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?"
1451    fi
1452    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1453    cd $MINDI_TMP/iso/isolinux
1454    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?"
1455    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1456        perl -pi -e 's/interactive/iso/' isolinux.cfg
1457    fi
1458    if [ "$ARCH" != "ia64" ] ; then
1459        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?"
1460        cp $ISOLINUX ../ 2>> $LOGFILE
1461    fi
1462    cd $MINDI_TMP/iso
1463    if [ "$ARCH" != "ia64" ] ; then
1464        if [ _"$MONDO_SHARE" != _"" ]; then 
1465            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?"
1466            cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
1467        fi
1468        $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
1469    else
1470        $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
1471        rm -f images/mindi-bootroot.$BOOT_SIZE.img
1472    fi
1473    if [ "$?" -ne "0" ] ; then
1474        echo "----------- $ISO_CMD's errors --------------" >> $LOGFILE
1475        cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1476        echo "$ISO_CMD returned the following errors:-"
1477        cat $MINDI_TMP/mkisofs.log
1478        LogIt "Failed to create ISO image."
1479    else
1480        echo "Created bootable ISO image at $MINDI_CACHE/mindi.iso" | tee -a $LOGFILE
1481    fi
1482    rm -f $MINDI_TMP/mkisofs.log
1483    cd $old_pwd
1484}
1485
1486
1487OfferToMakeBootableUSB() {
1488    local i old_pwd
1489    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1490        echo -n "Shall I make a bootable USB image ? (y/[n]) "
1491        read i
1492        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1493        if [ "$USBDEVICE" = "" ]; then
1494            echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
1495            read dev
1496            USBDEVICE=$dev
1497        fi
1498        echo "WARNING: This will erase all content on $USBDEVICE"
1499        echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
1500    fi
1501    if [ _"$MINDI_TMP" = _"" ]; then
1502        Die "MINDI_TMP undefined"
1503    fi
1504    rm -Rf $MINDI_TMP/usb
1505    mkdir -p $MINDI_TMP/usb
1506    USBPART="${USBDEVICE}1"
1507
1508    echo -en "Transforming $USBDEVICE in a Bootable device " 
1509    echo -en "."
1510    echo "Transforming $USBDEVICE in a Bootable device"  >> $LOGFILE
1511    echo "Checking $USBDEVICE" >> $LOGFILE
1512    $FDISK -l $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE
1513    if [ $? -ne 0 ]; then
1514        echo "Unable to access $USBDEVICE" | tee -a $LOGFILE
1515        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1516        exit -1
1517    fi
1518    echo -en "."
1519    echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
1520    umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
1521    echo "Erasing $USBDEVICE" >> $LOGFILE
1522    $FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
1523d
1524d
1525d
1526d
1527n
1528p
15291
1530
1531
1532t
1533b
1534a
15351
1536w
1537EOF
1538    if [ $? -ne 0 ]; then
1539        echo "Unable to create a vfat Filesystem on $USBDEVICE" | tee -a $LOGFILE
1540        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1541        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1542        MindiExit -1
1543    fi
1544    echo -en "."
1545    echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
1546    mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
1547    if [ $? -ne 0 ]; then
1548        echo "Unable to create a vfat filesystem on $USBPART" | tee -a $LOGFILE
1549        echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" | tee -a $LOGFILE
1550        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1551        MindiExit -1
1552    fi
1553    echo -en "."
1554    echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
1555    mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1556    if [ $? -ne 0 ]; then
1557        echo "Unable to mount $USBPART on $MINDI_TMP/usb" | tee -a $LOGFILE
1558        echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" | tee -a $LOGFILE
1559        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1560        MindiExit -1
1561    fi
1562    echo -en "."
1563    mkdir -p $MINDI_TMP/usb/images
1564    cp -f $1/*.img $1/*.gz $MINDI_TMP/usb/images 2>> $LOGFILE || LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
1565    echo -en "."
1566    old_pwd=`pwd`
1567    cd $MINDI_TMP/usb
1568    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1569    for i in memdisk memtest.bin memtest.img ; do
1570        j=$MINDI_LIB/$i
1571        k=$MINDI_TMP/usb
1572        if [ -e "$j" ] ; then
1573            LogIt "Copying $j to $k"
1574            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1575            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1576        fi
1577    done
1578    echo -en "."
1579    MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
1580    echo -en "."
1581    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?"
1582    echo -en "."
1583    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
1584    echo -en "."
1585    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1586    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?"
1587    echo -en "."
1588    if [ "$NFS_DEV" != "" ] ; then
1589        perl -pi -e 's/interactive/iso/' syslinux.cfg
1590    fi
1591    cd $old_pwd
1592    echo -en "."
1593    umount $MINDI_TMP/usb
1594    if [ "$ARCH" != "ia64" ] ; then
1595        syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
1596        if [ "$?" -ne "0" ] ; then
1597            echo "----------- syslinux's errors --------------" |tee -a $LOGFILE
1598            cat $MINDI_TMP/syslinux.log |tee -a $LOGFILE
1599            LogIt "Failed to create USB image."
1600        else
1601            echo -e "$DONE"
1602            echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
1603        fi
1604        rm -f $MINDI_TMP/syslinux.log
1605    else
1606        echo "No USB boot support for ia64" | tee -a $LOGFILE
1607        MindiExit -1
1608    fi
1609    echo -en "."
1610}
1611
1612
1613MakeMessageFile() {
1614    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1615        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`"/
1616    else
1617        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`/
1618    fi
1619    if [ _"$MONDO_SHARE" != _"" ]; then
1620        if [ "$CDRECOVERY" != "yes" ] ; then
1621            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1622                echo -en "Press <enter> to continue.\n"
1623            elif [ ! "$MINDI_TMP" ] ; then
1624                echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1625            else
1626                echo -en "$BOOT_MEDIA_MESSAGE"
1627            fi
1628        fi
1629    fi
1630    if [ "$CDRECOVERY" = "yes" ] ; then
1631        echo -en "\
1632To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1633CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1634    fi
1635    echo -en "\n\n\n"
1636}
1637
1638
1639MakeLiloConfFile() {
1640    local options i ooo
1641    options=""
1642
1643    if [ "$ARCH" != "ia64" ] ; then
1644        echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1645        echo -en "install=/boot.b\nmap=/boot.map\n"
1646    fi
1647    if [ "$CDRECOVERY" = "yes" ] ; then
1648        echo -en "default=RESTORE\n"
1649    elif [ _"$MONDO_SHARE" != _"" ]; then
1650        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1651            echo -en "default=iso\n"
1652        else
1653            echo -en "default=interactive\n"
1654        fi
1655    else
1656        echo -en "default=expert\n"
1657    fi
1658
1659    echo -en "prompt\n"
1660    if [ "$ARCH" != "ia64" ] ; then
1661        echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1662    fi
1663    if [ "$CDRECOVERY" != "yes" ] ; then
1664        echo -en "timeout=300\n"
1665    fi
1666    echo -en "\n"
1667    if [ "$CDRECOVERY" = "yes" ] ; then
1668        options="RESTORE expert"
1669    else
1670        if [ _"$MONDO_SHARE" != _"" ]; then
1671            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1672                options="iso"
1673            else
1674                options="interactive expert compare iso nuke isonuke"
1675# hda hdb hdc hdd"
1676            fi
1677        else
1678            options="expert"
1679        fi
1680    fi
1681    for i in $options ; do
1682        ooo=$i
1683        [ "$ooo" = "RESTORE" ] && ooo="nuke"
1684        if [ "$ARCH" = "ia64" ] ; then
1685            rootpart="root=/dev/ram0\n\t"
1686        else
1687            rootpart=""
1688        fi
1689        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"
1690   
1691        outstr=$outstr" $ooo_mode"
1692        outstr=$outstr"\"\n"
1693        echo -en "$outstr"
1694    done
1695}
1696
1697
1698PrepareBootDiskImage_LILO() {
1699    local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1700    imagesdir=$1
1701    kernelpath=$2
1702    ramdisksize=$3
1703
1704    retval=0
1705    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1706    echo -en "Making "$BOOT_SIZE"KB boot disk..."
1707    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?"
1708    echo -en "..."
1709    imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
1710    mountpoint=$MINDI_TMP/mountpoint.$$
1711    mkdir -p $mountpoint
1712    dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
1713    if [ "$ARCH" = "ia64" ] ; then
1714        mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1715        t=vfat
1716    else
1717        echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
1718        mke2fs -N 26 -m 0 -F $imagefile &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
1719        t=ext2
1720    fi
1721    mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1722    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1723    mkdir -p $mountpoint/etc
1724    if [ "$ARCH" != "ia64" ] ; then
1725        liloconf=$mountpoint/etc/lilo.conf
1726    else
1727        liloconf=$mountpoint/elilo.conf
1728    fi
1729    old_pwd=`pwd`
1730    cd $mountpoint
1731    if [ "$ARCH" != "ia64" ] ; then
1732        tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1733    fi
1734    cd $old_pwd
1735    # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1736    #losetup /dev/loop0 > /dev/null 2> /dev/null
1737    #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary."
1738    CopyBootBFile $mountpoint/boot.b
1739
1740    MakeLiloConfFile > $liloconf
1741
1742    # Copy it so that CD-ROM menu entry is satisfied
1743    if [ "$ARCH" = "ia64" ] ; then
1744        mountefi=0
1745        df -T | grep /boot/efi | grep -q vfat
1746        if [ $? -ne 0 ]; then
1747            mount /boot/efi
1748            if [ $? -ne 0 ]; then
1749                echo "You have to mount your EFI partition when using mindi"
1750                MindiExit -1
1751            fi
1752            mountefi=1
1753        fi
1754        el=`find /boot/efi -name elilo.efi`
1755        cp $el $mountpoint
1756        cp $liloconf $mountpoint
1757        if [ $mountefi -eq 1 ]; then
1758            umount /boot/efi 2>&1 > /dev/null
1759        fi
1760    fi
1761
1762    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1763    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1764    if [ "$?" -ne "0" ] ; then
1765        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1766        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1767        LogIt "Please unload some of your modules and try again."
1768        rm -f $MINDI_TMP/mtpt.$$
1769        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1770        retval=$(($retval+1))
1771    fi
1772    MakeMessageFile > $mountpoint/message
1773
1774    mkdir -p $mountpoint/tmp
1775    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1776    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1777        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1778        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1779#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1780    fi
1781
1782    # copy the kernel across
1783    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1784    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1785    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1786    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
1787    if [ "$?" -ne "0" ] ; then
1788        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1789        du -sk $mountpoint/* >> $LOGFILE
1790        echo "--- end of list of files ---" >> $LOGFILE
1791        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1792Sorry, your kernel is too big for your image.\n" >> $LOGFILE
1793        rm -f $mountpoint/vmlinuz
1794        cd $old_pwd
1795        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1796        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1797    #   losetup /dev/loop0 -d
1798        rm -f $imagefile
1799        return 0
1800    fi
1801    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1802    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1803    echo "Free space left on image = $free_space KB" >> $LOGFILE
1804    echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
1805    # make it bootable
1806    rm -f $mountpoint/zero
1807    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
1808    if [ ! "$KERN_DISK_MADE" ] ; then
1809        if [ "$ARCH" != "ia64" ] ; then
1810            $LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
1811        else
1812            /bin/true
1813        fi
1814    else
1815        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
1816    fi
1817
1818    # BERLIOS  does not test necessarily what it expects
1819    if [ $? -ne "0" ] ; then
1820        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
1821            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
1822            LogIt "Please reboot your PC as a workaround."
1823            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
1824        fi
1825        echo "$LILO_EXE -r $mountpoint ...failed."
1826        echo -en "Press ENTER to continue."; read line
1827        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
1828        retval=$(($retval+1))
1829    fi
1830    cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
1831    if [ "$ARCH" = "ia64" ] ; then
1832        cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
1833    fi
1834    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1835    echo -en "..."
1836    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1837    if [ "$retval" -eq "0" ] ; then
1838        echo -en "...$DONE\n"
1839        if [ "$KERN_DISK_MADE" ] ; then
1840            LogIt "$BOOT_SIZE KB boot disks were created OK\n"
1841        fi
1842    else
1843        echo -en "...failed\n"
1844        LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
1845        rm -f $imagefile
1846    fi
1847    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
1848    return $retval
1849}
1850
1851
1852PrepareBootDiskImage_SYSLINUX() {
1853    local imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
1854    imagesdir=$1
1855    kernelpath=$2
1856    ramdisksize=$3
1857    do_boot_root_thingy=""
1858    local retval old_pwd
1859    retval=0
1860
1861    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1862    echo -en "Making "$BOOT_SIZE"KB boot disk..."
1863    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?"
1864    echo -en "..."
1865    imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
1866    mountpoint=$MINDI_TMP/mountpoint.$$
1867    mkdir -p $mountpoint
1868    dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
1869    echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
1870    mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
1871    syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
1872
1873    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1874
1875    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1876    old_pwd=`pwd`
1877    MakeSyslinuxMessageFile $mountpoint/message.txt
1878    cd $mountpoint
1879    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
1880    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
1881    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1882        perl -pi -e 's/interactive/iso/' syslinux.cfg
1883    fi
1884    cd $old_pwd
1885    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
1886    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
1887    if [ "$?" -ne "0" ] ; then
1888        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1889        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1890        LogIt "Please unload some of your modules and try again."
1891        rm -f $MINDI_TMP/mtpt.$$
1892        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1893        retval=$(($retval+1))
1894    fi
1895
1896    mkdir -p $mountpoint/tmp
1897    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1898
1899    # copy the kernel across
1900    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1901    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1902    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1903    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
1904    if [ "$?" -ne "0" ] ; then
1905        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1906        du -sk $mountpoint/* >> $LOGFILE
1907        echo "--- end of list of files ---" >> $LOGFILE
1908        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1909Sorry, your kernel is too big for your image.\n" >> $LOGFILE
1910        rm -f $mountpoint/vmlinuz
1911        cd $old_pwd
1912        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1913        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1914
1915        rm -f $imagefile
1916        return 0
1917    fi
1918    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1919    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1920    echo "Free space left on image = $free_space KB" >> $LOGFILE
1921    echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
1922
1923    # make it bootable
1924    rm -f $mountpoint/zero
1925    mkdir -p $mountpoint/etc
1926    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
1927    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1928    echo -en "..."
1929    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1930
1931    if [ "$retval" -eq "0" ] ; then
1932        echo -en "...$DONE\n"
1933        if [ "$KERN_DISK_MADE" ] ; then
1934            rm -f $imagefile
1935            LogIt "$BOOT_SIZE KB boot disks were created OK\n"
1936        fi
1937    else
1938        echo -en "...failed\n"
1939        LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
1940        rm -f $imagefile
1941    fi
1942    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
1943    return $retval
1944}
1945
1946
1947PrepareDataDiskImages() {
1948    local needlist bigdir diskdir imagesdir res i j k old_pwd lines lfiles
1949
1950    imagesdir=$1
1951    rm -f $imagesdir/mindi.iso
1952    needlist=$MINDI_TMP/what-we-need.txt
1953    bigdir=$MINDI_TMP/bigdir
1954    mkdir -p $bigdir/usr/bin
1955
1956    lfiles="$DEPLIST_FILE"
1957    lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
1958    cat $lfiles | GenerateGiantDependencyList $needlist $lines
1959    res=$?
1960    if [ "$YOUR_KERNEL_SUCKS" ]; then
1961        pwd=`pwd`
1962        cd $MINDI_TMP
1963        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
1964            tar cf - ./$i 2>> $LOGFILE | (cd $bigdir ; tar xf -) || Die "PDDI can't copy $i->$bigdir"
1965            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
1966                tar cf - $i 2>> $LOGFILE | (cd $bigdir ; tar xf -)
1967            else
1968                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
1969                BIGNO=$(($BIGNO+1))
1970            fi
1971        done
1972        for i in $EXTRA_MODS ; do
1973            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
1974            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
1975            for k in $j ; do
1976                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
1977                    tar cf - $k 2>> $LOGFILE | (cd $bigdir ; tar xf -)
1978                else
1979                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
1980                    BIGNO=$(($BIGNO+1))
1981                fi
1982                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
1983            done
1984        done
1985        cd $pwd
1986    else
1987        ListKernelModulePaths >> $needlist
1988    fi
1989    if [ "$res" -ne "0" ] ; then
1990        Die "You have $res files present in dependency list\nbut absent from filesystem."
1991    fi
1992    FindAndAddUserKeyboardMappingFile
1993    mkdir -p $bigdir/tmp
1994    if [ _"$MONDO_SHARE" != _"" ]; then
1995        MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
1996        cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
1997    fi
1998    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
1999    DropOptimizedLibraries $needlist $bigdir
2000    echo -en "Assembling dependency files"
2001    CopyDependenciesToDirectory < $needlist $bigdir
2002
2003    # also copy io.sys and msdos.sys, if we can find them
2004    for i in `mount | cut -d' ' -f3` ; do
2005        for j in io.sys msdos.sys ; do
2006            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2007        done
2008    done
2009
2010    # master boot record, too
2011    i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
2012    if [ "$i" ] ; then
2013        LogIt "Backing up $i's MBR"
2014        dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2015        sleep 1
2016        sync
2017        j=$i
2018        [ -h "$j" ] && j=`readlink -f $j`
2019        LogIt "Creating /dev/boot_device ($j)"
2020        mkdir -p $bigdir/dev
2021        cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2022    fi
2023
2024    old_pwd=`pwd`
2025    cd $bigdir
2026
2027    [ -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'."
2028    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2029    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2030        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2031    fi
2032    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2033        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2034        [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2035    fi
2036    #[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2037    [ -d "/lib/dev-state" ] && tar cf - /lib/dev-state 2>> $LOGFILE | tar xf -
2038    cd $old_pwd
2039    echo -e "$DONE"
2040    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2041    MakeMountlist $MINDI_TMP/mountlist.txt
2042    mkdir -p $bigdir/tmp
2043    cp -f $MINDI_TMP/mountlist.txt $bigdir/tmp/mountlist.txt 2> /dev/null || Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
2044    if [ _"$MONDO_SHARE" != _"" ]; then
2045        cp -f $bigdir/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2046    fi
2047    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $bigdir/tmp/i-want-my-lvm || LVM="false"
2048    cat $bigdir/tmp/mountlist.txt >> $LOGFILE
2049    echo -en "$FILES_IN_FILELIST" > $bigdir/FILES-IN-FILELIST 2> /dev/null
2050    echo -en "$LAST_FILELIST_NUMBER" > $bigdir/LAST-FILELIST-NUMBER 2> /dev/null
2051    if [ _"$MONDO_SHARE" != _"" ]; then
2052        for q in filelist.full.gz biggielist.txt ; do
2053            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2054            cp -pRdf $MINDI_TMP/$q $bigdir/tmp 2>> $LOGFILE
2055        done
2056    fi
2057
2058    echo -en "Tarring and zipping the data content..."
2059    size_of_all_tools=`du -sk $bigdir | cut -f1`
2060    (cd $bigdir ; tar -b 4096 -cf - . 2> /dev/null | gzip -9 > $imagesdir/all.tar.gz)
2061    du -sk $imagesdir/*gz >> $LOGFILE
2062    echo -e "$DONE"
2063
2064    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2065    rm -rf $bigdir
2066    rm -f $needlist
2067}
2068
2069
2070ProcessLDD() {
2071    local incoming f d nd bd bnd
2072    read incoming
2073    while [ "$incoming" != "" ]; do
2074        # We take the full path name of the dyn. lib. we want
2075        incoming=`echo "$incoming" | awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
2076        for f in $incoming ; do
2077            # echo modified file name if one of the parent dir is a link
2078            # by replacing the original dirname by the destination of the link
2079            d="`dirname $f`"
2080            found="false"
2081            while [ "$d" != "/" ]; do
2082                if [ -h "$d" ]; then
2083                    nd=`readlink -f $d`
2084                    bd=`basename $d`
2085                    bnd=`basename $nd`
2086                    f=`echo $f | sed "s~/$bd/~/$bnd/~"`
2087                    echo $d
2088                fi
2089                d="`dirname $d`"
2090            done
2091
2092            echo "$f"
2093            echo "`ReadAllLink $f`"
2094        done
2095        read incoming
2096    done
2097}
2098
2099
2100Prompt() {
2101    echo -en "$1"
2102    read line
2103}
2104
2105
2106ReadLine() {
2107    local i incoming
2108    read incoming
2109    i=0
2110    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2111        i=$(($i+1))
2112        read incoming
2113    done
2114    echo "$incoming"
2115}
2116
2117
2118ReplaceIndividualLine() {
2119    local orig_file new_file lino newstring lines_total lines_remaining
2120
2121    orig_file=$1.orig
2122    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2123    new_file=$1
2124    lino=$2
2125    newstring="$3"
2126    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2127        echo "Can't find string" >> $LOGFILE
2128        return 1
2129    fi
2130    lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2131    lines_remaining=$(($lines_total-$lino))
2132    head -n$(($lino-1)) $orig_file > $new_file
2133    echo "$newstring" >> $new_file
2134    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2135    tail -n$lines_remaining $orig_file >> $new_file
2136    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2137    [ -x "$orig_file" ] && chmod +x $new_file
2138    rm -f $orig_file
2139    return 0
2140}
2141
2142
2143SizeOfPartition() {
2144    local devpath drive res stub
2145    device=$1
2146    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2147        res=`SizeOfRaidPartition $device`
2148        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2149        echo "$res"
2150        return 0
2151    fi
2152    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2153    res=`$FDISK -s $device 2>> $LOGFILE`
2154    # end patch
2155    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2156    [ "$res" = "" ] && res="-1"
2157    echo $res
2158    return 0
2159}
2160
2161
2162SizeOfRaidPartition() {
2163    local real_dev smallest_size silly tmp
2164
2165    silly=999999999
2166    smallest_size=$silly
2167
2168    for real_dev in `GetRaidDevMembers $1` ; do
2169        tmp=`SizeOfPartition $real_dev`
2170        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2171    done
2172
2173    if [ "$smallest_size" = "$silly" ] ; then
2174        echo "-1"
2175        return 1
2176    else
2177        echo "$smallest_size"
2178        return 0
2179    fi
2180}
2181
2182
2183StripComments()
2184{
2185    local tempfile
2186
2187    tempfile=$MINDI_TMP/$$.strip.txt
2188    cp -f $1 $tempfile 2>> $LOGFILE
2189    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2190    rm -f $tempfile
2191    echo "Stripped comments from $2" >> $LOGFILE
2192}
2193
2194
2195
2196StripExecutable()
2197{
2198    local tmpfile
2199
2200    tmpfile=$MINDI_TMP/stripped.$$.dat
2201    [ -d "$1" ] || [ -h "$1" ] && return
2202    cp -f $1 $tmpfile 2>> $LOGFILE
2203    strip $tmpfile 2> /dev/null
2204    if [ "$?" -eq "0" ] ; then
2205        cp -f $tmpfile $1 2>> $LOGFILE
2206        echo "Stripped binary $2" >> $LOGFILE
2207    fi
2208    rm -f $tmpfile
2209}
2210
2211
2212TryToFindKernelPath() {
2213    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2214
2215    we_want_version=`uname -r`
2216    possible_kernels=""
2217    duff_kernels=""
2218   
2219    if [ "$ARCH" = "ia64" ] ; then
2220       root="/boot/efi/efi"
2221    else
2222       root="/"
2223    fi
2224    for fname in `find $root -maxdepth 2 -type f | grep -E 'lin|kern' | grep -Ev '^/proc/|^/net/'` ; do
2225        [ ! -e "$fname" ] && continue
2226        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2227        file $fname | grep -q gzip
2228        if [ "$?" -eq "0" ] ; then
2229            # Used by ia64
2230            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2231        else
2232            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2233        fi
2234        [ "$fkern_ver" = "" ] && continue
2235        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2236        [ -f "$fname" ] || continue
2237        [ -h "$fname" ] && continue
2238        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2239        file $fname | grep -q gzip
2240        if [ "$?" -eq "0" ] ; then
2241            # Used by ia64
2242            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2243                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2244                duff_kernels="$fname $duff_kernels"
2245            else
2246                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2247                possible_kernels="$fname $possible_kernels"
2248            fi
2249        else
2250            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2251                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2252                duff_kernels="$fname $duff_kernels"
2253            else
2254                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2255                possible_kernels="$fname $possible_kernels"
2256            fi
2257        fi
2258    done
2259    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2260        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2261    fi
2262    if [ ! "$possible_kernels" ] ; then
2263        LogIt "No kernel matches exactly. Are there any duff kernels?"
2264        possible_kernels="$duff_kernels"
2265        if [ ! "$possible_kernels" ] ; then
2266            LogIt "Sorry, no duff kernels either"
2267        else
2268            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2269            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2270        fi
2271    fi
2272    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2273    noof_kernels=`CountItemsIn "$possible_kernels"`
2274    if [ "$noof_kernels" -eq "0" ] ; then
2275        LogIt "Could not find your kernel."
2276        if [ -e "/boot/vmlinuz" ] ; then
2277            LogIt "Using /boot/vmlinuz as a last resort."
2278            output=/boot/vmlinuz
2279        else
2280            output=""
2281        fi
2282    elif [ "$noof_kernels" -eq "1" ] ; then
2283        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2284        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2285        output="$kernelpath"
2286    else
2287        for i in $possible_kernels ; do
2288            if echo $i | grep "`uname -r`" ; then
2289                LogIt "OK, I used my initiative and found that "
2290                LogIt "$i is probably your kernel. "
2291                output="$i"
2292                return
2293            fi
2294        done
2295        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2296            output=/boot/vmlinuz
2297            echo "Schlomo, this one's for you." >> $LOGFILE
2298        else
2299            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2300            LogIt "boot disks will still work, probably. If one does not work, try another."
2301            LogIt "$possible_kernels"
2302            echo ""
2303        fi
2304    fi
2305    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2306}
2307
2308
2309TurnTgzIntoRdz() {
2310    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
2311
2312    tgz_dir_fname=$1
2313    rdz_fname=$2
2314    ramdisksize=$3
2315    kernelsize=$4
2316    maxsize=$(($BOOT_SIZE-$kernelsize))
2317    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2318    tempfile=$MINDI_TMP/temp.rd
2319    mountpoint=$MINDI_TMP/mnt1
2320    res=0
2321    echo -en "..."
2322    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2323    echo -en "..."
2324    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2325    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE || Die "Unable to create an ext2 file system on $tempfile"
2326    echo -en "..."
2327    mkdir -p $mountpoint
2328    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."
2329    echo -en "..."
2330    old_pwd=`pwd`
2331    cd $mountpoint
2332    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2333    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2334
2335    cd dev || Die "Can't cd to dev"
2336    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2337    rm -f dev-entries.tgz
2338    cd ..
2339
2340    for w in insmod.static insmod.static.old ; do
2341        s=`which $w 2> /dev/null`
2342        if [ -e "$s" ] ; then
2343            tar cf - $s 2> /dev/null | tar xf -
2344        fi
2345    done
2346
2347    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2348
2349    # Handle the case where busybox and mount are dynamically linked
2350    file $MINDI_LIB/rootfs/bin/busybox 2>&1 | grep -q "dynamically" 
2351    if [ $? -eq 0 ]; then
2352        # We want to use the real mount and all the supported variants (nfs, cifs, ...)
2353        rm -f bin/mount $MINDI_TMP/busy.lis
2354        mountlis=`grep mount $DEPLIST_FILE`
2355        for f in $MINDI_LIB/rootfs/bin/busybox $mountlis ; do
2356            if [ -f $f ]; then
2357                LocateDeps $f >> $MINDI_TMP/busy.lis
2358            fi
2359        done
2360        tar cf - $mountlis `sort -u $MINDI_TMP/busy.lis` 2> /dev/null | tar xf -
2361        rm -f $MINDI_TMP/busy.lis
2362    fi
2363
2364    mkdir -p $mountpoint/tmp
2365    # Management of udev (which includes modprobe in rules)
2366    ps auxww | grep -v grep | grep -qw udevd
2367    if [ $? -eq 0 ]; then
2368        echo "udev device manager found" > $mountpoint/tmp/USE-UDEV
2369        LogIt "udev device manager found"
2370        tar cf - /etc/udev 2> /dev/null | tar xf -
2371        # This avoids NIC remapping if on another machine at restore time on Debian at least
2372        rm -f ./etc/udev/rules.d/z25_persistent-net.rules
2373        tar cf - /lib*/udev 2> /dev/null | tar xf -
2374        if [ -x /sbin/udevd ]; then
2375            lis2=`grep -Ev '^#' $MINDI_CONF/udev.files` 
2376            lis=""
2377            # Get only the files which exist in that list
2378            # and potentially their symlink structure
2379            for i in $lis2; do
2380                if [ -h $i ]; then
2381                    j=$i
2382                    while [ -h $j ]; do
2383                        lis="$lis $j"
2384                        j=`readlink $j`
2385                    done
2386                    lis="$lis $j"
2387                elif [ -f $i ]; then
2388                    lis="$lis $i"
2389                fi
2390            done
2391            # And their deps
2392            LocateDeps $lis > $MINDI_TMP/udev.lis
2393            for i in $lis; do
2394                if [ "`echo $i | cut -c1`" = "/" ]; then
2395                    j=`echo $i | cut -c2-`
2396                    rm -f $j
2397                fi
2398            done
2399            tar cf - $lis `sort -u $MINDI_TMP/udev.lis` 2> /dev/null | tar xf -
2400            rm -f $MINDI_TMP/udev.lis
2401        else
2402            echo "udevd daemon not in standard place (/sbin)" 2>&1 | tee -a $LOGFILE
2403            echo "mindi will use static devices which may cause problems" 2>&1 | tee -a $LOGFILE
2404            rm -f $mountpoint/tmp/USE-UDEV
2405        fi
2406    fi
2407
2408    # Management of potential HW info (Proliant only at the moment)
2409    rm -rf $MINDI_CACHE/bkphw
2410    mindi-bkphw $MINDI_CACHE $MINDI_CONF | tee -a $LOGFILE
2411    if [ -d $MINDI_CACHE/bkphw ]; then
2412        LogIt "Hardware Information found and saved ..."
2413        cp -rp $MINDI_CACHE/bkphw .
2414        if [ -f $MINDI_CACHE/tools.files ]; then
2415            lis=`grep -Ev '^#' $MINDI_CACHE/tools.files` 
2416            LocateDeps $lis > $MINDI_TMP/tools.lis
2417            tar cf - $lis `sort -u $MINDI_TMP/tools.lis` 2> /dev/null | tar xf -
2418        fi
2419        if [ -f $MINDI_CACHE/mindi-rsthw ]; then
2420            mv -f $MINDI_CACHE/mindi-rsthw .
2421            chmod 755 ./mindi-rsthw
2422        fi
2423        rm -f $MINDI_TMP/tools.lis $MINDI_CACHE/tools.files
2424    fi
2425
2426    for w in cdrom groovy-stuff ; do
2427        mkdir -p mnt/$w
2428    done
2429    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2430        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2431    #fi
2432    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2433        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2434    fi
2435
2436    tar cf - /dev/fd0*[1,2][4,7,8]* 2> /dev/null | tar xf -
2437
2438    cd $old_pwd
2439    echo -en "..."
2440    old_pwd=`pwd`
2441    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2442        cd $MINDI_TMP
2443        needed_modules_path=lib/modules/$FAILSAFE_KVER
2444    else
2445        cd /
2446        if [ "${kernelname}" != "" ]
2447        then
2448            needed_modules_path=lib/modules/${kernelname}
2449        else
2450            needed_modules_path=lib/modules/`uname -r`
2451        fi
2452    fi
2453
2454    needed_modules=""
2455    list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2456
2457    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
2458        # For PXE boot
2459        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2460    fi
2461    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2462        list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
2463    fi
2464    for i in $DENY_MODS; do
2465        echo "Removing $i from the list of modules to load" >> $LOGFILE
2466        list_of_groovy_mods=`echo ${list_of_groovy_mods} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
2467    done
2468
2469    [ -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."
2470    for i in $list_of_groovy_mods ; do
2471        needed_modules="$needed_modules `FindSpecificModuleInPath $needed_modules_path $i`"
2472    done
2473
2474    for i in $needed_modules ; do
2475        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2476        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2477        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2478        tar cf - $i 2>/dev/null | (cd $mountpoint ; tar xf -) || LogIt "Unable to copy $i to $mountpoint"
2479        # Uncompress modules if not using udev and native modprobe
2480        if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
2481            if [ "`echo "$i" | grep -F ".gz"`" ]; then
2482                echo "Uncompressing $i" >> $LOGFILE
2483                gunzip -f $mountpoint/$i
2484            fi
2485        fi
2486    done
2487
2488    # Also copy modules.dep in case of udev so that normal modprobe works
2489    tar cf - /$needed_modules_path/modules.dep 2>/dev/null | (cd $mountpoint ; tar xf -) || LogIt "Unable to copy modules.dep to $mountpoint"
2490
2491    if [ ! -e "/sbin/devfsd" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2492        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2493        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2494        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2495        rm -f $mountpoint/sbin/devfsd
2496    fi
2497    cd $old_pwd
2498    [ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2499    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2500    rm -f $mountpoint/zero
2501    if [ _"$MONDO_SHARE" != _"" ]; then
2502        MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
2503        cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
2504        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2505        echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
2506        echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
2507        [ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
2508        [ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
2509        [ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
2510        [ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
2511    fi
2512    mkdir -p $mountpoint/proc
2513    echo "$BOOT_SIZE" > $mountpoint/tmp/$BOOT_SIZE.siz
2514    # Determine what filesystem to use for initrd image
2515    echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2516    gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2517    [ -z  gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2518    case "$gvFileSystem" in
2519    "ext2fs")
2520        # say what will be used
2521        echo "Creating an ext2 initrd image..." >> $LOGFILE
2522        # kernel expects linuxrc in ext2 filesystem
2523        ( cd $mountpoint && ln -sf sbin/init linuxrc )
2524        # unmount loop filesystem and create image file using the standard approach
2525        umount $mountpoint || Die "Cannot unmount $tempfile"
2526        dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2527        bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2 | sed 's/^ *//'`
2528        ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2529        gzip -c9 ${rdz_fname}.tmp > $rdz_fname
2530        rm -f ${rdz_fname}.tmp
2531        # log that we are done
2532        echo "...done." >> $LOGFILE
2533    ;;
2534    "initramfs")
2535        # say what will be used
2536        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2537        # make sure that cpio is there
2538        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2539        # go into filesystem
2540        cd $mountpoint
2541        # kernel expects init in cpio filesystem
2542        ln -sf sbin/init init
2543        # create cpio image file and unmount loop filesystem
2544        find . -print | cpio -o -H newc | gzip -9 > $rdz_fname 2> /dev/null
2545        cd $old_pwd
2546        umount $mountpoint || Die "Cannot unmount $tempfile"
2547        # log that we are done
2548        echo "...done." >> $LOGFILE
2549    ;;
2550    *)
2551        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2552    ;;
2553    esac
2554    if [ "$res" -eq "0" ] ; then
2555        echo -en "..."
2556    else
2557        echo -en "\rMade an rdz WITH ERRORS.           \n"
2558    fi
2559    return 0
2560}
2561
2562
2563WhichOfTheseModulesAreLoaded() {
2564    local modname loaded_modules
2565    loaded_modules="$MODULES"
2566    for modname in $1 ; do
2567        [ "`echo "$loaded_modules" | grep -w "$modname"`" ] && echo "$modname"
2568    done
2569}
2570
2571
2572
2573##############################################################################
2574#----------------------------------- Main -----------------------------------#
2575##############################################################################
2576
2577# Now we can create what we need
2578mkdir -p $MINDI_TMP
2579
2580# Purge from potential old run
2581if [ _"$MINDI_CACHE" = _"" ]; then
2582    Die "MINDI_CACHE undefined"
2583fi
2584rm -rf $MINDI_CACHE/* 2> /dev/null
2585mkdir -p $MINDI_CACHE
2586
2587if [ "$1" = "--printvar" ] ; then
2588    shift
2589    if [ _"$1" != _"" ] ; then
2590        set | grep -Ew "^$1" | cut -d= -f2
2591    fi
2592    MindiExit 0
2593fi
2594
2595> $LOGFILE
2596echo "mindi v$MINDI_VERSION" >> $LOGFILE
2597echo "$ARCH architecture detected" >> $LOGFILE
2598echo "mindi called with the following arguments:" >> $LOGFILE
2599echo "$@" >> $LOGFILE
2600echo "Start date : `date`" >> $LOGFILE
2601echo "-----------------------------" >> $LOGFILE
2602
2603[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2604
2605# Log some capital variables
2606[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2607echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2608echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2609echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2610[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2611echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2612if [ -f $MINDI_CONFIG ]; then
2613    echo "-----------------------------" >> $LOGFILE
2614    echo " Mindi configuration file    " >> $LOGFILE
2615    echo "-----------------------------" >> $LOGFILE
2616    grep -Ev '^#' $MINDI_CONFIG >> $LOGFILE
2617    echo "-----------------------------" >> $LOGFILE
2618fi
2619
2620
2621trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2622
2623# Sanity checks
2624which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2625which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2626which 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."
2627which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2628if which awk &> /dev/null ; then
2629    if ! which gawk &> /dev/null ; then
2630        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"
2631    fi
2632fi
2633which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2634[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2635
2636[ "`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"
2637
2638# Update the PATH variable if incomplete
2639if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2640    PATH=$PATH:/sbin:/usr/sbin
2641    export PATH
2642    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2643    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2644    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2645fi
2646
2647# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2648if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2649    source $MINDI_LIB/FindDistroFailsafe
2650    # Log kernel image
2651    LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2652else
2653    [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2654fi
2655
2656if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
2657    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2658fi
2659
2660### BERLIOS
2661### Fix as it's not mandatory on ia64
2662if [ "$ARCH" = "ia64" ] ; then
2663    if which elilo &> /dev/null ; then
2664        LILO_EXE=elilo
2665    else
2666        LILO_EXE=`which false`
2667    fi
2668else
2669    FindIsolinuxBinary
2670    FindLiloBinary
2671fi
2672trap "Aborted" SIGTERM
2673DONE="\r\t\t\t\t\t\t\t\tDone.         "
2674CHOPSIZE=240
2675BIGNO=0
2676MAX_COMPRESSED_SIZE=1300
2677kernelpath=""
2678MONDO_ROOT=/var/cache/mondo
2679mkdir -p $MONDO_ROOT
2680
2681if [ -d "/proc/lvm" ]; then
2682    # LVM v1
2683    LVMCMD=""
2684    LVM="v1"
2685elif [ -d "/dev/mapper" ]; then
2686    # LVM v2
2687    LVMCMD="lvm"
2688    LVM="v2"
2689else
2690    LVM="false"
2691fi
2692echo "LVM set to $LVM" >> $LOGFILE
2693echo "----------" >> $LOGFILE
2694echo "mount result:" >> $LOGFILE
2695echo "-------------" >> $LOGFILE
2696mount >> $LOGFILE
2697echo "-------------" >> $LOGFILE
2698if [ -e /etc/raidtab ]; then
2699    echo "-------------" >> $LOGFILE
2700    echo "/etc/raidtab content:" >> $LOGFILE
2701    echo "-------------" >> $LOGFILE
2702    cat /etc/raidtab >> $LOGFILE
2703fi
2704echo "-------------" >> $LOGFILE
2705echo "cat /proc/cmdline:" >> $LOGFILE
2706echo "-------------" >> $LOGFILE
2707cat /proc/cmdline >> $LOGFILE
2708echo "-------------" >> $LOGFILE
2709echo "lsmod result:" >> $LOGFILE
2710echo "-------------" >> $LOGFILE
2711lsmod >> $LOGFILE
2712MODULES="`cat /proc/modules | awk '{print $1}'`"
2713if [ -x /usr/sbin/esxcfg-module ]; then
2714    echo "-------------" >> $LOGFILE
2715    echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
2716    echo "-------------" >> $LOGFILE
2717    echo "VMWare modules" >> $LOGFILE
2718    echo "-------------" >> $LOGFILE
2719    /usr/sbin/esxcfg-module -l >> $LOGFILE
2720    MODULES="$MODULES `/usr/sbin/esxcfg-module -l | awk '{print $1}'`"
2721fi
2722echo "FORCE_MODS:" >> $LOGFILE
2723echo "-------------" >> $LOGFILE
2724echo $FORCE_MODS >> $LOGFILE
2725echo "-------------" >> $LOGFILE
2726echo "DENY_MODS:" >> $LOGFILE
2727echo "-------------" >> $LOGFILE
2728echo $DENY_MODS >> $LOGFILE
2729echo "-------------" >> $LOGFILE
2730echo "df result:" >> $LOGFILE
2731echo "----------" >> $LOGFILE
2732df -T >> $LOGFILE
2733echo "-------------" >> $LOGFILE
2734echo "Liste of extra modules is:" >> $LOGFILE
2735echo "$EXTRA_MODS" >> $LOGFILE
2736echo "-------------" >> $LOGFILE
2737
2738# Compute libata version
2739laver=`modinfo libata | grep -Ei '^Version:' | cut -d: -f2 | cut -d. -f1 | sed 's/  *//g' 2> /dev/null`
2740# If libata v2 is used then remove ide-generic as it will perturbate boot
2741if [ "`echo $MODULES | grep libata`" ]; then
2742    if [ "$laver" = "2" ]; then
2743        DENY_MODS="$DENY_MODS ide-generic"
2744        echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
2745        echo "-------------" >> $LOGFILE
2746    fi
2747fi
2748
2749if [ "$#" -ge "2" ] ; then
2750    if [ "$1" = "--max-compressed-size" ] ; then
2751        MAX_COMPRESSED_SIZE=$2
2752        shift; shift
2753    fi
2754fi
2755
2756FLOPPY_WAS_MOUNTED=""
2757for mtpt in /media/floppy /mnt/floppy /floppy ; do
2758    if mount | grep -w $mtpt &> /dev/null ; then
2759        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
2760        umount $mtpt
2761    fi
2762done
2763
2764#
2765# If we have a USB device we need to store info
2766# and remove it from the parameters line
2767#
2768if [ "$#" -ne "0" ] ; then
2769    if [ "$1" = "--usb" ] ; then
2770        shift
2771        USBDEVICE=$1
2772        if [ _"$USBDEVICE" = _"" ]; then
2773            Die "No USB device specified"
2774        fi
2775        shift
2776    fi
2777fi
2778
2779if [ "$#" -ne "0" ] ; then
2780    if [ "$1" = "--findkernel" ] ; then
2781        res=`TryToFindKernelPath`
2782        # Avoids logfile content for mondo
2783        export MONDO_SHARE=""
2784        if [ "$res" = "" ] ; then
2785            MindiExit -1
2786        else
2787            echo "$res"
2788            MindiExit 0
2789        fi
2790    elif [ "$1" = "--locatedeps" ] ; then
2791        [ ! "$2" ] && Die "Please specify the binary to look at"
2792        LocateDeps $2
2793        # Avoids logfile content for mondo
2794        export MONDO_SHARE=""
2795        MindiExit $?
2796    elif [ "$1" = "--readalllink" ] ; then
2797        [ ! "$2" ] && Die "Please specify the binary to look at"
2798        ReadAllLink $2
2799        # Avoids logfile content for mondo
2800        export MONDO_SHARE=""
2801        MindiExit $?
2802    elif [ "$1" = "--makemountlist" ] ; then
2803        [ ! "$2" ] && Die "Please specify the output file"
2804        MakeMountlist $2
2805        # Avoids logfile content for mondo
2806        export MONDO_SHARE=""
2807        MindiExit $?
2808    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
2809        echo "Mindi v$MINDI_VERSION"
2810        # Avoids logfile content for mondo
2811        export MONDO_SHARE=""
2812        MindiExit 0
2813    elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
2814        MONDO_TMP=$2
2815        # Change MINDI_TMP for the one provided by mondo
2816        # So that it can get back the built files
2817        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
2818        rmdir $MINDI_TMP
2819        export MINDI_TMP=$MONDO_TMP
2820        mkdir -p $MINDI_TMP
2821        # This is the scratch dir in mondo - subdir images
2822        MINDI_CACHE=$3
2823        if [ _"$MINDI_CACHE" != _"" ]; then
2824            mkdir -p $MINDI_CACHE
2825        fi
2826        kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
2827###
2828### Sq-Modification...
2829### Attempt to locate kernel specific module path
2830### if module path is found then use it other wise use uname -r to set it...
2831###
2832        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2833        LogIt "kernelname = $kernelname"
2834        LogIt "kernelpath = $kernelpath"
2835        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2836        then
2837           LogIt "Module path for ${kernelpath} not found..."
2838           LogIt "using running kernel\'s modules."
2839           kernelname=`uname -r`
2840        else
2841           LogIt "Using modules for kernel: ${kernelname}"
2842        fi
2843###
2844### end of Sq-Modification
2845###
2846        TAPEDEV=$5
2847        TAPESIZE=$6
2848        FILES_IN_FILELIST=$7
2849        USE_LZO=$8
2850        CDRECOVERY=$9
2851        if [ "${10}" = "(null)" ] || [ "${10}" = "" ] ; then
2852            IMAGE_DEVS=""
2853        else
2854            IMAGE_DEVS="`echo "${10}" | tr '|' ' '`"
2855        fi
2856        if [ "${11}" ] ; then
2857            LILO_OPTIONS=""
2858    #       LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
2859        fi
2860        LAST_FILELIST_NUMBER=${12}
2861        ESTIMATED_TOTAL_NOOF_SLICES=${13}
2862        EXCLUDE_DEVS="${14}"
2863        USE_COMP="${15}"
2864        USE_LILO="${16}"
2865        USE_STAR="${17}"
2866        INTERNAL_TAPE_BLOCK_SIZE="${18}"
2867        DIFFERENTIAL="${19}"
2868        USE_GZIP="${20}"
2869        NOT_BOOT="${21}"
2870        [ "$USE_COMP" = "" ] && USE_COMP=yes
2871        [ "$USE_GZIP" = "" ] && USE_GZIP=no
2872        [ "$NOT_BOOT" = "" ] && NOT_BOOT=no
2873        [ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
2874        [ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
2875        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2876        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2877        then
2878           LogIt "Module path for ${kernelpath} not found..."
2879           LogIt "using running kernel\'s modules."
2880           kernelname=`uname -r`
2881        else
2882           LogIt "Using modules for kernel: ${kernelname}"
2883        fi
2884        [ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
2885        # MONDO_ROOT is the real scratchdir
2886        MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
2887        if [ _"$MONDO_ROOT" != _"" ]; then
2888            mkdir -p $MONDO_ROOT
2889        else
2890            Die "MONDO_ROOT is undefined"
2891        fi
2892    else
2893        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
2894        MindiExit -1
2895    fi
2896fi
2897[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
2898if [ "$CDRECOVERY" = "yes" ] ; then
2899    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
2900    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
2901else
2902    iso_cfg_file=$MINDI_LIB/isolinux.cfg
2903    sys_cfg_file=$MINDI_LIB/syslinux.cfg
2904fi
2905
2906[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
2907if [ _"$MONDO_SHARE" = _"" ]; then
2908    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
2909    LogIt "Latest Mindi is available from http://www.mondorescue.org"
2910    LogIt "BusyBox sources are available from http://www.busybox.net"
2911    LogIt "------------------------------------------------------------------------------"
2912else
2913    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
2914fi
2915if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
2916    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
2917else
2918    LogIt "Unable to find mindi-busybox, please install it"
2919    MindiExit -1
2920fi
2921
2922# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
2923insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
2924for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
2925    insmod $i >> $LOGFILE 2>> $LOGFILE
2926done
2927
2928KERN_DISK_MADE=""
2929
2930echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
2931echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
2932echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
2933if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
2934    LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
2935    MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
2936    MakeMountlist $MINDI_TMP/mountlist.txt
2937    mkdir -p $MINDI_TMP/small-all/tmp
2938    cd $MINDI_TMP/small-all
2939    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"
2940    tar -cv ./tmp | gzip -9 > $MINDI_TMP/all.tar.gz || Die "Cannot make small all.tar.gz"
2941    sleep 2
2942    LogIt "Done. Exiting."
2943    MindiExit 0
2944fi
2945
2946if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2947    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
2948fi
2949
2950if [ "$kernelpath" = "" ] ; then
2951    [ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
2952    echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
2953    read ch
2954    if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
2955        USE_OWN_KERNEL="yes"
2956    else
2957        USE_OWN_KERNEL="no"
2958    fi
2959    if [ "$USE_OWN_KERNEL" = "yes" ]; then
2960        YOUR_KERNEL_SUCKS=""
2961        kernelpath=`TryToFindKernelPath`
2962        if [ "$kernelpath" = "" ] ; then
2963            echo -n "Please enter kernel path : "
2964            read kernelpath
2965        fi
2966    else
2967        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
2968    fi
2969fi
2970if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
2971    USE_LILO=no
2972fi
2973if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
2974    # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2975    if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
2976        source $MINDI_LIB/FindDistroFailsafe
2977        # Log kernel image
2978        LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2979        kernelpath="$FAILSAFE_KBIN"
2980        LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
2981        LogIt "The failsafe kernel is $kernelpath.\n"
2982        LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
2983        LogIt "disks then it may still be a result of a problem with your kernel.\n"
2984        pwd=`pwd`
2985        cd $MINDI_TMP
2986        mkdir -p lib/modules
2987        cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
2988        cd $pwd
2989    else
2990        kernelpath=$MINDI_LIB/vmlinuz
2991        LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
2992        LogIt "However, you are still running your kernel. If Mindi fails to create your"
2993        LogIt "disks then it may still be a result of a problem with your kernel."
2994        pwd=`pwd`
2995        cd $MINDI_TMP
2996        bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
2997        cd $pwd
2998    fi
2999    YOUR_KERNEL_SUCKS="Your kernel sucks"
3000fi
3001echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3002[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3003
3004[ "$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."
3005
3006PrepareDataDiskImages $MINDI_CACHE
3007ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3008rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3009ramdisk_size=$rds
3010
3011echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3012if [ "$ARCH" = "ia64" ] ; then
3013    PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create ia64 image disk image."
3014else
3015    if [ "$USE_LILO" = "yes" ] ; then
3016        PrepareBootDiskImage_LILO $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE MB disk image."
3017    else
3018        PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE MB disk image."
3019    fi
3020fi
3021
3022[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3023...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3024
3025if [ _"$MONDO_SHARE" = _"" ]; then
3026    ListImagesForUser $MINDI_CACHE
3027    OfferToMakeBootableISO $MINDI_CACHE
3028    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3029        OfferToMakeBootableUSB $MINDI_CACHE
3030    fi
3031    LogIt "Finished."
3032elif [ "$TAPEDEV" ] ; then
3033    rm -f $MINDI_CACHE/{*img,*iso}
3034    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3035        OfferToMakeBootableUSB $MINDI_CACHE
3036    fi
3037    OfferToMakeBootableISO $MINDI_CACHE
3038    if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3039        cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3040    else
3041        Die "Cannot find all.tar.gz, to be written to tape"
3042    fi
3043elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3044    OfferToMakeBootableUSB $MINDI_CACHE
3045else
3046    OfferToMakeBootableISO $MINDI_CACHE
3047fi
3048# cleanup
3049LogIt "$FRIENDLY_OUTSTRING"
3050for mtpt in $FLOPPY_WAS_MOUNTED ; do
3051    mount $mtpt
3052done
3053MindiExit 0
Note: See TracBrowser for help on using the repository browser.