source: branches/2.2.9/mindi/mindi @ 2393

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