source: MondoRescue/branches/2.2.10/mindi/mindi @ 2338

Last change on this file since 2338 was 2338, checked in by Bruno Cornec, 11 years ago
  • Adds LZMA support (Fix #309)
  • Change
  • Property svn:executable set to *
  • Property svn:keywords set to Rev Id
File size: 104.4 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 2338 2009-08-20 23:47:12Z 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"
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 fuse"
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/NFS-DEV" ] ; then
595            LogIt "\nIncorporating NFS-related settings"
596            for r in NFS-* 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 lcMagicInitfs="<6>checking if image is initramfs...|<6>Unpacking initramfs...|<6>Trying to unpack rootfs image as
663initramfs"
664
665    # local variables
666    local lvOffset
667    local lvScanRes
668    local lvUseFilesystem
669
670    # say where we are.
671    echo "  GetInitrdFilesystemToUse(): called with parameter: $lvKernelImage.\n" >> $LOGFILE
672
673    # verify that file exists
674    [ ! -f $lvKernelImage ] && Die "File $lvKernelImage not found. Terminating."
675
676    # Kernel may be gzip compressed
677    file $lvKernelImage 2>&1 | grep -q gzip
678    if [ $? -eq 0 ]; then
679        lvScanRes=`gzip -cd $lvKernelImage | strings | grep -E "$lcMagicCramfs|$lcMagicExt2fs|$lcMagicInitfs"`
680    else
681        # get offet of gzip magic "1f8b0800" in file
682        lvOffset=`od -vA n -t x1 $lvKernelImage | tr -d '[:space:]' | awk '{ print match($0, "1f8b0800")}'`
683        [ $lvOffset -eq 0 ] && Die "gzip magic not found in file $lvKernelImage. Terminating."
684        lvOffset=`expr $lvOffset / 2`
685        echo "  GetInitrdFilesystemToUse(): gzip magic found at lvOffset $lvOffset.\n" >> $LOGFILE
686
687        # scan kernel image for initrd filessystem support
688        lvScanRes=`dd ibs=1 skip=$lvOffset if=$lvKernelImage obs=1M 2>/dev/null | gunzip -c 2> /dev/null | strings | grep -E "$lcMagicCramfs|$lcMagicExt2fs|$lcMagicInitfs"`
689    fi
690
691    # determine which filesystem to use for initrd image: ext2fs, gzip'ed cpio (initramfs ) or cramfs
692    if [ `echo $lvScanRes | grep -Ec "$lcMagicExt2fs"` -eq 1 ]; then
693        lvUseFilesystem="ext2fs"
694    elif [ `echo $lvScanRes | grep -Ec "$lcMagicInitfs"` -eq 1 ]; then
695        lvUseFilesystem="initramfs"
696    elif [ `echo $lvScanRes | grep -Ec "$lcMagicCramfs"` -eq 1 ]; then
697        lvUseFilesystem="cramfs"
698    else
699        lvUseFilesystem="UNSUPPORTED"
700    fi
701
702    # say what we are using
703    echo "  GetInitrdFilesystemToUse(): Filesytem to use for initrd is $lvUseFilesystem.\n" >> $LOGFILE
704
705    # return file system to use
706    echo "$lvUseFilesystem"
707
708}
709
710# Searches parent raid device of given disk device
711# $1: disk device (i.e. /dev/hda1)
712GetParentRaidDev() {
713    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {dev=\$2} /^[[:space:]]*device/ {if(\$2==\"$1\") {print dev; exit}}" < /etc/raidtab
714}
715
716
717# Searches members of raid device
718# $1: raid device (/dev/md...)
719GetRaidDevMembers() {
720    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {if(dev) exit; if(\$2 == \"$1\") dev=\$2} /^[[:space:]]*device/ {if(dev) {print \$2}}" < /etc/raidtab
721}
722
723
724HackPathsToFailsafe() {
725    local incoming newpath stub i pwd
726    incoming=`ReadLine`
727    pwd=`pwd`
728    cd $MINDI_TMP
729    while [ "$incoming" != "" ] ; do
730        stub=`basename $incoming`
731        newpath=`FindSpecificModuleInPath lib/modules/$FAILSAFE_KVER $stub`
732        for i in $newpath ; do
733            echo "$i"
734        done
735        read incoming
736    done
737    cd $pwd
738}
739
740
741ListAllPartitions() {
742    local res currline partition all_partitions ap_orig remaining i j
743
744    grep -Evx " *#.*| *none.*" $MY_FSTAB | $AWK '/^\/dev\/[imhs]d||^LABEL=\/|^UUID=/ && !/\/fdd|\/cdr|\/zip|\/floppy/ {print $1}'
745    [ -e "/etc/raidtab" ] && $AWK '/^ *device/ {print $2}' /etc/raidtab
746    if [ -e "/vmfs/volumes" ]; then
747        # For VMWare ESX 3 get the device names of these volumes
748        vdf -P | grep -E '/vmfs/volumes' | awk '{print $1}'
749    fi
750    return
751}
752
753
754ListImagesForUser() {
755    local path fname
756    path=$MINDI_CACHE
757    echo -en "In the directory '$path' you will find the images:-\n"
758    for fname in `ls $path | grep -F mindi-` ; do
759        printf "%19s " $fname
760    done
761    echo " "
762}
763
764
765ListKernelModulePaths() {
766    local module_list module fname oss r kern
767    oss="/root/oss/modules"
768    module_list="$MODULES"
769    # Remove unwanted modules from list
770    for i in $DENY_MODS; do
771        module_list=`echo ${module_list} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
772        EXTRA_MODS=`echo ${EXTRA_MODS} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
773    done
774###
775### Sq-Modification ... Use kernelname for module search path if specified
776###
777    if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
778    then
779        kern=${kernelname}
780    else
781        kern="$KERVERRUN"
782    fi
783    export KERVER=$kern
784###
785### Sq-Mod End
786###
787    for module in $module_list $EXTRA_MODS ; do
788        r=`find /lib/modules/$kern -type f | grep "/${module}\..*o" | tail -n1`
789        echo "module $module --> $r" >> $LOGFILE
790        [ "$r" ] && echo "$r"
791        [ -f "$oss" ] && find $oss | grep -F $module
792    done
793    find /lib/modules/$kern/modules.* -type f 2> /dev/null
794    [ -f "$oss" ] && find $oss.* 2> /dev/null
795}
796
797#
798# Critical function which computes all dependencies (dyn. lib.)
799# for a list of binaries
800#
801LocateDeps() {
802    local incoming fname deps
803    incoming="$*"
804    for fname in $incoming ; do
805        if [ ! -e "$fname" ] ; then
806            echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
807            if echo $fname | grep lvm &> /dev/null ; then
808                echo "This warning only affects you if you are using LVM." >> $LOGFILE
809                if echo "$MODULES" | grep lvm &> /dev/null ; then
810                    echo "I think you are, so please take heed!" >> $LOGFILE
811                else
812                    echo "I don't think you are, so don't worry about it." >> $LOGFILE
813                fi
814            fi
815        elif [ -h "$fname" ] && [ -x "$fname" ] ; then
816            echo "$fname is softlink" >> $LOGFILE
817        else
818            ldd $fname 2> /dev/null | ProcessLDD
819        fi
820    done
821}
822
823
824# Give all symlinks recursively of a full path name
825ReadAllLink() {
826    file="$1"
827
828    echo $file | grep -q '\.\./'
829    if [ $? -eq 0 ]; then
830        # We need to normalise the path with .. in it
831        file=`echo $file | perl -pi -e 's|([^/]+)/([^/]+)/\.\./([^/]+)|$1/$3|'`
832    fi
833    echo "$file"
834    if [ ! -h $file ]; then
835        return 0
836    fi
837
838    link=`readlink $file`
839    d=`dirname $file`
840    fchar=`echo $link | cut -c1`
841    # If mother dir is a link print it
842    if [ -h "$d" ]; then
843        echo "$d"
844        d=`readlink $d`
845    fi
846    if [ "$fchar" != "/" ]; then
847        # Relative or local link
848        ReadAllLink "$d/$link" 
849    else
850        # Absolute path
851        ReadAllLink $link 
852    fi
853}
854
855
856LocateFile() {
857    local i path fname_to_find location output resolved tmp stub cache_id loclist
858    fname_to_find="$1"
859    # It's an absolute path
860    if echo "$fname_to_find" | grep -x "/.*" ; then
861        output="$fname_to_find"
862        if [ -h "$output" ] ; then
863            output="`ReadAllLink $output` $output"
864        fi
865        echo "$output"
866        return 0
867    fi
868    # It's not an absolute path
869    output=""
870    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
871    #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
872        [ -h "$path" ] && continue
873        [ ! -e "$path/$fname_to_find" ] && continue
874        output="$path/$fname_to_find $output"
875        if [ -h "$path/$fname_to_find" ] ; then
876            output="`ReadAllLink $path/$fname_to_find` $output"
877        fi
878    done
879    if [ "$output" = "" ] ; then
880        return 1
881    fi
882    echo "$output"
883    return 0
884}
885
886
887LogIt() {
888    if [ -e /dev/stderr ] ; then
889        echo -e "$1" >> /dev/stderr
890    elif [ -e /usr/bin/logger ] ; then
891        /usr/bin/logger -s $1
892    fi
893    echo -e "$1" >> $LOGFILE
894    if [ _"$2" != _"" ]; then
895        grep -Ev "tar: Removing \`/\'" "$2" >> $LOGFILE
896    fi
897    rm -f "$2"
898}
899
900
901# Called by TurnTgzIntoRdz, to make /tmp/mondo-restore.cfg
902MakeMondoConfigFile() {
903    local outfile use_lzo use_comp use_star
904    outfile=$1
905    > $outfile
906    [ "$TAPESIZE" ]     && echo "media-size $TAPESIZE" >> $outfile
907    [ "$TAPEDEV" ]          && echo "media-dev $TAPEDEV" >> $outfile
908    [ "$USBDEVICE" ]            && echo "usb-dev $USBDEVICE" >> $outfile
909    [ "$FILES_IN_FILELIST" ]    && echo "files-in-filelist $FILES_IN_FILELIST" >> $outfile
910    [ "$LAST_FILELIST_NUMBER" ] && echo "last-filelist-number $LAST_FILELIST_NUMBER" >> $outfile
911    [ "$INTERNAL_TAPE_BLOCK_SIZE" ] && echo "internal-tape-block-size $INTERNAL_TAPE_BLOCK_SIZE" >> $outfile
912    use_lzo=$USE_LZO; [ "$use_lzo" = "" ] && use_lzo="no"
913    use_gzip=$USE_GZIP; [ "$use_gzip" = "" ] && use_gzip="no"
914    use_lzma=$USE_LZMA; [ "$use_lzma" = "" ] && use_lzma="no"
915    use_comp=$USE_COMP; [ "$use_comp" = "" ] && use_comp="yes"
916    use_star=$USE_STAR; [ "$use_star" = "" ] && use_star="no"
917    echo "use-lzo $use_lzo" >> $outfile
918    echo "use-lzma $use_lzma" >> $outfile
919    echo "use-star $use_star" >> $outfile
920    echo "use-comp $use_comp" >> $outfile
921    echo "datestamp `date`" >> $outfile
922    [ "$ESTIMATED_TOTAL_NOOF_SLICES" ] && echo "total-slices $ESTIMATED_TOTAL_NOOF_SLICES" >> $outfile
923    AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-IPADDR nfs-client-ipaddr $outfile
924    AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-NETMASK nfs-client-netmask $outfile
925    AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-BROADCAST nfs-client-broadcast $outfile
926    AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-DEFGW  nfs-client-defgw  $outfile
927    AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-MOUNT  nfs-server-mount  $outfile
928    AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-PATH   nfs-server-path   $outfile
929    AddFileToCfgIfExists $MINDI_TMP/NFS-DEV           nfs-dev           $outfile
930    AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-IPADDR nfs-server-ipaddr $outfile
931    AddFileToCfgIfExists $MINDI_TMP/ISO-DEV           iso-dev           $outfile
932    AddFileToCfgIfExists $MINDI_TMP/ISO-MNT           iso-mnt           $outfile
933    AddFileToCfgIfExists $MINDI_TMP/ISO-PREFIX        iso-prefix        $outfile
934    AddFileToCfgIfExists $MINDI_TMP/ISODIR            isodir            $outfile
935    AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.DEVICE bootloader.device $outfile
936    AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.NAME   bootloader.name   $outfile
937    AddFileToCfgIfExists $MINDI_TMP/KEYMAP-LIVES-HERE keymap-lives-here $outfile
938    AddFileToCfgIfExists $MINDI_TMP/TAPEDEV-HAS-DATA-DISKS tapedev-has-data-disks $outfile
939    AddFileToCfgIfExists $MINDI_TMP/BACKUP-MEDIA-TYPE backup-media-type $outfile
940    AddFileToCfgIfExists $MINDI_TMP/DIFFERENTIAL      differential      $outfile
941    AddFileToCfgIfExists $MINDI_TMP/ACL      acl      $outfile
942    AddFileToCfgIfExists $MINDI_TMP/XATTR      xattr      $outfile
943    AddFileToCfgIfExists $MINDI_TMP/OBDR      obdr      $outfile
944}
945
946
947MakeMountlist() {
948    local scratchdir mountlist all_partitions current_partition \
949partition_size partition_format outstring partition_number \
950partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
951absolute_partition old_partition_fmt current_lvolume uname skip
952
953    echo "Your raw fstab file looks like this:" >> $LOGFILE
954    echo "------------------------------------" >> $LOGFILE
955    cat $MY_FSTAB >> $LOGFILE
956    echo "Your mountlist will look like this:" | tee -a $LOGFILE
957    echo "-----------------------------------" >> $LOGFILE
958
959# scratchdir, mountlist(OUT)
960    scratchdir=$MINDI_TMP
961    mountlist=$1
962
963# NB: partition = device
964# NB: mountpt = where the device is mounted
965
966    [ -e "$MY_FSTAB" ] || Die "Cannot find your fstab file ($MY_FSTAB)"
967
968    [ "$mountlist" != "" ] && rm -Rf $mountlist
969    > $mountlist
970    all_partitions=""
971   
972    if [ $LVM != "false" ]; then
973        echo -en "Analyzing LVM...\n"
974        $MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
975        if [ $? -ne 0 ]; then
976            LVM="false"
977        fi
978        all_partitions=`cat $MINDI_TMP/lvm.res | grep -F ">>>" | cut -d' ' -f2-32`
979    fi
980    all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
981#    echo "all partitions = $all_partitions" > /dev/stderr
982    for i in $IMAGE_DEVS ; do
983        mount | grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
984    done
985    [ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" | tr ' ' '\n' | sort -u | tr '\n ' ' '`"
986    printf "        %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL/UUID | tee -a $LOGFILE
987    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"
988    for c_p in $all_partitions ; do
989        [ "`echo "$useless_dev" | grep -F "$c_p"`" != "" ] || [ "`echo "$c_p" | grep ":"`" != "" ] && continue
990        [ "`echo "$c_p" | grep -x "/dev/cdroms.*"`" ] && continue
991        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
992            current_partition=`readlink -f $c_p`
993            [ "`echo "$current_partition" | grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
994            [ "`echo "$useless_dev" | grep -F "$current_partition"`" ] && continue
995        else
996            current_partition="$c_p"
997        fi
998        [ "$c_p" = "none" ] && continue
999        # Debian 5 does that
1000        [ "$c_p" = "proc" ] && continue
1001        redhat_label=""
1002        label=""
1003        uuid=""
1004        absolute_partition=`readlink -f $c_p`
1005        partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1006
1007        # Detects noauto partitions not mounted and exclude them
1008        partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1009        if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" =  "" ] ; then
1010            continue
1011        fi
1012
1013        # set default in case we dont't find it
1014        str_to_find_fmt_with=$current_partition
1015
1016        # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1017        # current_partition contains only first column of /etc/fstab
1018        if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1019            redhat_label=`echo "$current_partition" | cut -d'=' -f2`
1020            actual_dev=""
1021
1022            # 1st try, findfs - the RHEL way of finding labels and their partitions
1023            if [ -x "/sbin/findfs" ]; then
1024                actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1025            fi
1026   
1027            # 2nd try : blkid, the good way for all LABEL except swap
1028            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1029                actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | cut -d':' -f1`
1030                # For LVM FS it will give a /dev/dm-# which should then be converted
1031                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1032                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1033                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1034                    for dev in `ls /dev/mapper/*`; do
1035                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1036                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1037                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1038                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1039                            break
1040                        fi
1041                    done
1042                fi
1043            fi
1044   
1045            # 3rd try, which works on a standard partition (ext2/3), but not on swap
1046            # For LVM gives a /dev/mapper entry
1047            if [ "x$actual_dev" = "x" ]; then
1048                actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | cut -d' ' -f1`
1049            fi
1050   
1051            # 4th try, with vol_id
1052            # SWAP only
1053            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1054                list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | $AWK '{ print $1 }' `
1055                for dev_swap in $list_swaps ; do
1056                    dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1057                    if [ "x$dev_exists" != "x" ]; then
1058                        actual_dev=$dev_swap
1059                        break;
1060                    fi
1061                done
1062            fi
1063
1064            # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1065            # LABEL=SW-cciss/c0d0p3 (RDP)
1066            # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1067            # SWAP only
1068            if [ "x$actual_dev" = "x" -a  _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1069                    skip=""
1070                    uname=$KERVERRUN
1071                    [ "`echo $uname | grep "2.4.[0-9]"`" != "" ] && skip=16
1072                    # 2.6.12 needs 16 (FC3)
1073                    [ "`echo $uname | grep "2.6.[0-1]"`" != "" ] && skip=16
1074                    # 2.6.19 and upper needs 1052
1075                    [ "`echo $uname | grep "2.6.19"`" != "" ] && skip=1052
1076                    [ "`echo $uname | grep "2.6.[2-9]"`" != "" ] && skip=1052
1077                    if [ $skip = "" ]; then
1078                        Die "Your kernel is too old. I don't know how to support labelled swap spaces with it"
1079                    fi
1080                    for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1081                    do
1082                        # Location of the swap label for kernel 2.6
1083                        try_dev_label=`dd bs=1 count=16 skip=$skip if=$try_dev 2> /dev/null`
1084                        if [ "x$try_dev_label" = "x$redhat_label" ]; then
1085                            actual_dev=$try_dev
1086                        fi
1087                    done
1088            fi
1089
1090            # Check if one of all those tries has known success
1091            if [ "x$actual_dev" != "x" ]; then
1092                current_partition=$actual_dev
1093            else
1094                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"
1095            fi
1096        # This part tries to retrieve the correct device from a UUID line in /etc/fstab
1097        # current_partition contains only first column of /etc/fstab
1098        elif [ "`echo "$current_partition" | /bin/grep -i "UUID="`" != "" ]; then
1099            uuid=`echo "$current_partition" | cut -d'=' -f2`
1100            actual_dev=""
1101
1102            # 1st try, findfs - the RHEL way of finding labels and their partitions
1103            if [ -x "/sbin/findfs" ]; then
1104                actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
1105            fi
1106   
1107            # 2nd try : blkid, the good way for all UUID except swap
1108            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1109                actual_dev=`/sbin/blkid | /bin/grep "$uuid" | grep UUID= | cut -d':' -f1`
1110                # For LVM FS it will give a /dev/dm-# which should then be converted
1111                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1112                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1113                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1114                    for dev in `ls /dev/mapper/*`; do
1115                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1116                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1117                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1118                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1119                            break
1120                        fi
1121                    done
1122                fi
1123            fi
1124   
1125            # 3th try, with vol_id
1126            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1127                list_dev=`mount | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1128                for dev in $list_dev ; do
1129                    dev_exists=`/sbin/vol_id $dev | /bin/grep "$uuid"`
1130                    if [ "x$dev_exists" != "x" ]; then
1131                        actual_dev=$dev
1132                        break;
1133                    fi
1134                done
1135            fi
1136
1137            # 4th try, with dumpuuid (VMWare only ?) for swap
1138            if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
1139                list_dev=`cat /proc/swaps | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1140                for dev in $list_dev ; do
1141                    dev_exists=`/sbin/dumpuuid $dev | /bin/grep "$uuid"`
1142                    if [ "x$dev_exists" != "x" ]; then
1143                        actual_dev=$dev
1144                        break;
1145                    fi
1146                done
1147            fi
1148
1149            # Check if one of all those tries has known success
1150            if [ "x$actual_dev" != "x" ]; then
1151                current_partition=$actual_dev
1152            else
1153                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."
1154            fi
1155        else
1156            # Needs to handle the recent OpenSUSE fancy way of dealing with fstab :-(
1157            # they use symlinks in fstab unrelated to what is shown in mount !
1158            if [ _"$partition_mountpt" = _"" ]; then
1159                # set default in case we dont't find it
1160                for tmpp in `tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -Ev "^#" | $AWK '{print $1}'`; do
1161                        if [ _"`readlink -f $tmpp`" = _"$current_partition" ]; then
1162                            str_to_find_fmt_with=$tmpp
1163                            partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$tmpp" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1164                            break;
1165                        fi
1166                done
1167            fi
1168        fi
1169
1170        partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1171        # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1172        # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1173        # the former is then a link to the latter, so we test whether
1174        # $current_partition is actually such a link or not and set
1175        # $current_lvolume accordingly. On Debian you may find more than one answer
1176        # so we remove the one corresponding to /dev/.static
1177        # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1178        # principle is the same and we need to find the link to it as well.
1179        # Note that $current_lvolume may well be an
1180        # ordinary device. It is just to make sure that we feed the right value
1181        # into any of the LVM tools if possible.
1182
1183        current_lvolume="$current_partition"
1184        if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1185            # .static dir are a Debian specificity
1186            current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1187            echo $current_lvolume | grep -q ' '
1188            if [ $? -eq 0 ]; then
1189                echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE 
1190            fi
1191            # if it's not found, it may well be a real device such as a multipath one
1192            # /dev/mapper/mpath... Thus we revert the situation so that next test succeed
1193            if [ _"$current_lvolume" = _"" ]; then
1194                current_lvolume="$current_partition"
1195            fi
1196        fi
1197        #
1198        # End of LVM device style variation code (other than $current_lvolume).
1199
1200        if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1201            # Size computed via LVM not directly
1202            partition_size="lvm"
1203        else
1204            partition_size=`SizeOfPartition $current_partition`
1205            [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1206            [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1207            if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1208                partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1209                [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1210                [ "$partition_format" != "swap" ] && partition_format="swap"
1211                if [ "$partition_size" = "" ] ; then
1212                    totalsize=0
1213                    items=0
1214                    for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1215                        totalsize=$(($totalsize+$i))
1216                        items=$(($items+1))
1217                    done
1218                    [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1219                    [ "$partition_size" -lt "125000" ] && partition_size=125000
1220                    echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1221                fi
1222            fi
1223        fi
1224        [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1225        [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1226        if [ "$partition_mountpt" = "" ] ; then
1227            if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1228                if  [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1229                    partition_mountpt="raid"
1230                    partition_format="raid"
1231                else
1232                    partition_mountpt="lvm"
1233                    partition_format="lvm"
1234                fi
1235            fi
1236        fi
1237        psz=$partition_size
1238        echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1239        [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1240        if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1241            partition_mountpt="image"
1242            old_partition_fmt=$partition_format
1243            partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1244            partition_size=$(($partition_size+1)); # just in case
1245            if [ "$partition_format" = "Linux" ] ; then
1246                echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1247                echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1248                partition_format=$old_partition_fmt
1249            fi
1250        fi
1251        if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1252            echo "Excluding $current_partition from mountlist" >> $LOGFILE
1253            continue
1254        fi
1255        if [ ! "$partition_mountpt" ] ; then
1256            echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1257            for qq in "" `find /dev/ida/c*d* ! -name '*p*' 2> /dev/null`; do
1258                partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1259                [ "$partition_format" ] && break
1260            done
1261            echo "------- $FDISK log end ------------" >> $LOGFILE
1262            if [ "$partition_format" = "Compaq diagnostics" ] ; then
1263                partition_format="compaq"
1264            elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1265                LogIt "Unable to find mountpoint of $current_partition - ignoring"
1266                continue
1267            fi
1268        fi
1269        if [ "$redhat_label" ]; then
1270            label="$redhat_label"
1271        elif [ "$uuid" ]; then
1272            label="$uuid"
1273        fi
1274        partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1275        [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1276        unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
1277        if [ "$current_partition" = "" ] ; then
1278            echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1279        elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1280            if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1281                partition_mountpt=raid
1282                partition_format=raid
1283                printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1284                printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1285            else
1286                echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1287            fi
1288        elif [ "$partition_format" = "" ] ; then
1289            echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1290        elif [ "$partition_size" = "" ] ; then
1291            echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1292        elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1293            continue
1294        else
1295            if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1296                echo "Stupid bastard..." >> $LOGFILE
1297                partition_format="vfat"
1298            fi
1299            printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1300            printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1301        fi
1302    done
1303}
1304
1305
1306MakeSureNumberIsInteger() {
1307    res=`echo "$1" | tr -s '\-[0-9]' ' '`
1308    if [ "$res" != " " ] && [ "$res" != "" ] ; then
1309    echo "result = '$res'"
1310        Die "$1 should be an integer"
1311    fi
1312}
1313
1314
1315OfferToMakeBootableISO() {
1316    local i old_pwd
1317    if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1318        echo -en "Shall I make a bootable CD image? (y/[n]) "
1319        read i
1320        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1321    fi
1322    rm -Rf $MINDI_TMP/iso
1323    mkdir -p $MINDI_TMP/iso/{images,archives}
1324    cp -f $MINDI_CACHE/{*.gz,*.img} $MINDI_TMP/iso/images 2>> $LOGFILE || LogIt "OfferToMakeBootableISO: Cannot copy $MINDI_CACHE/*.gz to $MINDI_TMP/iso/images"
1325    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1326    for i in memdisk memtest.bin memtest.img ; do
1327        j=$MINDI_LIB/$i
1328        k=$MINDI_TMP/iso
1329        if [ -e "$j" ] ; then
1330            LogIt "Copying $j to $k"
1331            cp -f $j $k 2>> $LOGFILE || Die "Failed to copy $j to $k"
1332            cp -f $j $MINDI_TMP 2>> $LOGFILE || Die "Failed to copy $j to $MINDI_TMP"
1333            if [ _"$MONDO_SHARE" != _"" ]; then 
1334                cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1335            fi
1336        fi
1337    done
1338    MakeMessageFile > $MINDI_TMP/iso/message.txt
1339    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?"
1340    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?"
1341    if [ _"$MONDO_SHARE" != _"" ]; then 
1342        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?"
1343        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?"
1344    fi
1345    MakeBootConfFile isolinux > $MINDI_TMP/iso/isolinux.cfg
1346    if [ "$ARCH" != "ia64" ] ; then
1347        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?"
1348    fi
1349    old_pwd=`pwd`
1350    cd $MINDI_TMP/iso
1351    if [ "$ARCH" != "ia64" ] ; then
1352        if [ _"$MONDO_SHARE" != _"" ]; then 
1353            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?"
1354            cp -f $MONDO_SHARE/autorun $MINDI_TMP/iso 2>> $LOGFILE
1355        fi
1356        $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
1357    else
1358        $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
1359        rm -f images/mindi-bootroot.$BOOT_SIZE.img
1360    fi
1361    if [ "$?" -ne "0" ] ; then
1362        echo "----------- $ISO_CMD's errors --------------" >> $LOGFILE
1363        cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1364        echo "$ISO_CMD returned the following errors:-"
1365        cat $MINDI_TMP/mkisofs.log
1366        LogIt "Failed to create ISO image."
1367    else
1368        echo "Created bootable ISO image at $MINDI_CACHE/mindi.iso" | tee -a $LOGFILE
1369    fi
1370    rm -f $MINDI_TMP/mkisofs.log
1371    cd $old_pwd
1372}
1373
1374
1375OfferToMakeBootableUSB() {
1376    local i
1377    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1378        echo -n "Shall I make a bootable USB image ? (y/[n]) "
1379        read i
1380        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1381        if [ "$USBDEVICE" = "" ]; then
1382            echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
1383            read dev
1384            USBDEVICE=$dev
1385        fi
1386        echo "WARNING: This will erase all content on $USBDEVICE"
1387        echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
1388        read i
1389        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1390    fi
1391    rm -Rf $MINDI_TMP/usb
1392    mkdir -p $MINDI_TMP/usb
1393    USBPART="${USBDEVICE}1"
1394
1395    echo -en "Transforming $USBDEVICE in a Bootable device " 
1396    echo -en "."
1397    echo "Transforming $USBDEVICE in a Bootable device"  >> $LOGFILE
1398    echo "Checking $USBDEVICE" >> $LOGFILE
1399    $FDISK -l $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE
1400    if [ $? -ne 0 ]; then
1401        echo "Unable to access $USBDEVICE" | tee -a $LOGFILE
1402        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1403        exit -1
1404    fi
1405    echo -en "."
1406    echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
1407    umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
1408    # If your key has no MBR it may cause an issue
1409    # Use dd if=mbr.bin of=$USBDEVICE or ms-sys -s $USBDEVICE
1410    echo "Preparing $USBDEVICE" >> $LOGFILE
1411    $FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
1412d
1413d
1414d
1415d
1416n
1417p
14181
1419
1420
1421t
1422b
1423a
14241
1425w
1426EOF
1427    if [ $? -ne 0 ]; then
1428        echo "Unable to create a vfat Filesystem on $USBDEVICE" | tee -a $LOGFILE
1429        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1430        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1431        MindiExit -1
1432    fi
1433    echo "The USB device $USBDEVICE now looks like this:" >> $LOGFILE
1434    $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1435    echo -en "."
1436    echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
1437    mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
1438    if [ $? -ne 0 ]; then
1439        echo "Unable to create a vfat filesystem on $USBPART" | tee -a $LOGFILE
1440        echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" | tee -a $LOGFILE
1441        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1442        MindiExit -1
1443    fi
1444    echo -en "."
1445    echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
1446    mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1447    if [ $? -ne 0 ]; then
1448        echo "Unable to mount $USBPART on $MINDI_TMP/usb" | tee -a $LOGFILE
1449        echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" | tee -a $LOGFILE
1450        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1451        MindiExit -1
1452    fi
1453    echo -en "."
1454    mkdir -p $MINDI_TMP/usb/images
1455    cp -f $MINDI_CACHE/*.img $MINDI_CACHE/*.gz $MINDI_TMP/usb/images 2>> $LOGFILE || LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
1456    echo -en "."
1457    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1458    for i in memdisk memtest.bin memtest.img ; do
1459        j=$MINDI_LIB/$i
1460        k=$MINDI_TMP/usb
1461        if [ -e "$j" ] ; then
1462            LogIt "Copying $j to $k"
1463            cp -f $j $k 2>> $LOGFILE || Die "Failed to copy $j to $k"
1464            cp -f $j $MINDI_TMP 2>> $LOGFILE || Die "Failed to copy $j to $MINDI_TMP"
1465        fi
1466    done
1467    echo -en "."
1468    MakeMessageFile > $MINDI_TMP/usb/message.txt
1469    echo -en "."
1470    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?"
1471    echo -en "."
1472    cp $MINDI_TMP/initrd.img $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
1473    echo -en "."
1474    MakeBootConfFile syslinux > $MINDI_TMP/usb/syslinux.cfg
1475    echo -en "."
1476    umount $MINDI_TMP/usb
1477    if [ "$ARCH" != "ia64" ] ; then
1478        syslinux -s $USBPART 2>> $MINDI_TMP/syslinux.log
1479        if [ "$?" -ne "0" ] ; then
1480            echo "----------- syslinux's errors --------------" |tee -a $LOGFILE
1481            cat $MINDI_TMP/syslinux.log |tee -a $LOGFILE
1482            LogIt "Failed to create USB image."
1483        else
1484            echo -e "$DONE"
1485            echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
1486        fi
1487        rm -f $MINDI_TMP/syslinux.log
1488    else
1489        echo "No USB boot support for ia64" | tee -a $LOGFILE
1490        MindiExit -1
1491    fi
1492}
1493
1494
1495MakeMessageFile() {
1496   
1497    if [ -x "/bin/lsb_release" ]; then
1498        DESC=`/bin/lsb_release -d | cut -d: -f2 | sed "s/[ \t]*//"`
1499    elif [ -x "/usr/bin/pbdistrocheck" ]; then
1500        # For pb >= 0.9.8
1501        DESC=`/usr/bin/pbdistrocheck -d`
1502    else
1503        iss="/dev/null"
1504        [ -r /etc/issue.net ] && iss="/etc/issue.net"
1505        [ -r /etc/issue ] && iss="/etc/issue"
1506        DESC=`head -1 $iss`
1507    fi
1508    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/"
1509    if [ _"$MONDO_SHARE" != _"" ]; then
1510        if [ "$CDRECOVERY" != "yes" ] ; then
1511            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1512                echo -en "Press <enter> to continue.\n"
1513            elif [ ! "$MINDI_TMP" ] ; then
1514                echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1515                if [ -e "$MINDI_LIB/memtest.img" ] ; then
1516                 echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n"
1517                fi
1518            else
1519                echo -en "$BOOT_MEDIA_MESSAGE"
1520            fi
1521        else
1522            echo -en "\
1523To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1524CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1525        fi
1526    fi
1527    echo -en "\n\n\n"
1528}
1529
1530
1531MakeBootConfFile() {
1532    local options i ooo
1533    options=""
1534    # Type of boot file (elilo or syslinux/isolinux)
1535    type=$1
1536    if [ "$type" = "elilo" ]; then
1537        sep="="
1538    else
1539        sep=" "
1540    fi
1541
1542    # Generic header for conf file
1543    if [ "$type" != "elilo" ] ; then
1544        echo -en "prompt 1\ndisplay message.txt\n"
1545    else
1546        echo -en "prompt\n"
1547    fi
1548
1549    # Compute which default option to boot from
1550    if [ "$CDRECOVERY" = "yes" ] ; then
1551        echo -en "default${sep}RESTORE\n"
1552    # In case it's mondoarchive
1553    elif [ _"$MONDO_SHARE" != _"" ]; then
1554        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1555            echo -en "default${sep}iso\n"
1556        else
1557            echo -en "default${sep}interactive\n"
1558        fi
1559    else
1560        echo -en "default${sep}expert\n"
1561    fi
1562
1563    # Handle timeout
1564    if [ "$CDRECOVERY" != "yes" ] ; then
1565        echo -en "timeout${sep}300\n"
1566    else
1567        echo -en "timeout${sep}10000\n"
1568    fi
1569    echo -en "\n"
1570
1571    # prepare which labels will be generated
1572    if [ "$CDRECOVERY" = "yes" ] ; then
1573        options="RESTORE expert"
1574    else
1575        if [ _"$MONDO_SHARE" != _"" ]; then
1576            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1577                options="iso"
1578            else
1579                options="interactive expert compare iso nuke isonuke"
1580            fi
1581        else
1582            options="expert"
1583        fi
1584    fi
1585
1586    # Generate rest of conf file
1587    for i in $options ; do
1588        ooo=$i
1589        [ "$ooo" = "RESTORE" ] && ooo="nuke"
1590        if [ "$type" = "elilo" ]; then
1591            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"
1592        else
1593            ps="/"
1594            if [ "$type" = "syslinux" ]; then
1595                ps=""
1596            fi
1597            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"
1598        fi
1599        echo -en "$outstr"
1600    done
1601
1602    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1603        if [ "$type" = "elilo" ]; then
1604            echo -en "image=/memtest.bin\n\tlabel=memtest\n"
1605            echo -en "image=/memdisk\n\tlabel=memdisk\nappend=\"initrd=memtest.img\"\n"
1606        else
1607            ps="/"
1608            if [ "$type" = "syslinux" ]; then
1609                ps=""
1610            fi
1611            echo -en "label memtest\n\tkernel ${ps}memtest.bin\n"
1612            echo -en "label memdisk\n\tkernel ${ps}memdisk\nappend initrd=${ps}memtest.img\n"
1613        fi
1614    fi
1615}
1616
1617
1618PrepareBootDiskImage_LILO() {
1619    local imagesdir dev imagefile mountpoint fname i kernelpath cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1620    imagesdir=$MINDI_CACHE
1621    kernelpath=$1
1622
1623    retval=0
1624    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1625    echo -en "Making "$BOOT_SIZE"KB boot disk..."
1626    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?"
1627    echo -en "..."
1628    imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
1629    mountpoint=$MINDI_TMP/mountpoint.$$
1630    mkdir -p $mountpoint
1631    dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
1632    mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1633    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1634    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1635    mkdir -p $mountpoint/etc
1636    liloconf=$mountpoint/elilo.conf
1637
1638    MakeBootConfFile elilo > $liloconf
1639
1640    # Copy it so that CD-ROM menu entry is satisfied
1641    mountefi=0
1642    df -T | grep /boot/efi | grep -q vfat
1643    if [ $? -ne 0 ]; then
1644        mount /boot/efi
1645        if [ $? -ne 0 ]; then
1646            echo "You have to mount your EFI partition when using mindi"
1647            MindiExit -1
1648        fi
1649        mountefi=1
1650    fi
1651    el=`find /boot/efi -name elilo.efi`
1652    cp $el $mountpoint
1653    cp $liloconf $mountpoint
1654    if [ $mountefi -eq 1 ]; then
1655        umount /boot/efi 2>&1 > /dev/null
1656    fi
1657
1658    echo "Copying $MINDI_TMP/initrd.img to $mountpoint..." >> $LOGFILE
1659    cp -f $MINDI_TMP/initrd.img $mountpoint 2>> $LOGFILE
1660    if [ "$?" -ne "0" ] ; then
1661        LogIt "Failed to copy $MINDI_TMP/initrd.img to $mountpoint"
1662        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1663        LogIt "Please unload some of your modules and try again."
1664        rm -f $MINDI_TMP/mtpt.$$
1665        LogIt "Cannot incorporate initrd.img in bootdisk (kernel / modules too big?)"
1666        retval=$(($retval+1))
1667    fi
1668    MakeMessageFile > $mountpoint/message.txt
1669
1670    mkdir -p $mountpoint/tmp
1671    if [ -f "$MINDI_TMP/mondo-restore.cfg" ]; then
1672        cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp
1673    fi
1674
1675    # copy the kernel across
1676    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1677    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1678    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1679    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2>> $LOGFILE
1680    if [ "$?" -ne "0" ] ; then
1681        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1682        du -sk $mountpoint/* >> $LOGFILE
1683        echo "--- end of list of files ---" >> $LOGFILE
1684        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1685Sorry, your kernel is too big for your image.\n" >> $LOGFILE
1686        [ "$mountpoint" != "" ] && rm -f $mountpoint/vmlinuz
1687        cd $old_pwd
1688        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1689        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1690    #   losetup /dev/loop0 -d
1691        [ "$imagefile" != "" ] && rm -f $imagefile
1692        return 0
1693    fi
1694    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1695    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1696    echo "Free space left on image = $free_space KB" >> $LOGFILE
1697    echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
1698    # make it bootable
1699    [ "$mountpoint" != "" ] && rm -f $mountpoint/zero
1700    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
1701    if [ "$KERN_DISK_MADE" ] ; then
1702        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
1703    fi
1704
1705    cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
1706    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1707    echo -en "..."
1708    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1709    if [ "$retval" -eq "0" ] ; then
1710        echo -en "...$DONE\n"
1711        if [ "$KERN_DISK_MADE" ] ; then
1712            LogIt "$BOOT_SIZE KB boot disks were created OK\n"
1713        fi
1714    else
1715        echo -en "...failed\n"
1716        LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
1717        [ "$imagefile" != "" ] && rm -f $imagefile
1718    fi
1719    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
1720    return $retval
1721}
1722
1723
1724PrepareBootDiskImage_ISOLINUX() {
1725    local imagesdir dev imagefile mountpoint fname i kernelpath cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
1726    imagesdir=$MINDI_CACHE
1727    kernelpath=$1
1728    do_boot_root_thingy=""
1729    local retval old_pwd
1730    retval=0
1731
1732    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1733    echo -en "Making "$BOOT_SIZE"KB boot disk..."
1734    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?"
1735    echo -en "..."
1736    imagefile=$MINDI_TMP/mindi-bootroot.$BOOT_SIZE.img
1737    mountpoint=$MINDI_TMP/mountpoint.$$
1738    mkdir -p $mountpoint
1739    dd if=/dev/zero of=$imagefile bs=1k count=$BOOT_SIZE &> /dev/null || Die "Cannot dd blank file"
1740    echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
1741    mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
1742    # syslinux should be run on a  local file (doen't work through NFS Cf: #297)
1743    syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
1744
1745    # Only move it now to its final destination abd use it now
1746    mv $imagefile $imagesdir
1747    imagefile=$imagesdir/mindi-bootroot.$BOOT_SIZE.img
1748
1749    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1750
1751    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1752    MakeMessageFile > $mountpoint/message.txt
1753    MakeBootConfFile isolinux > $mountpoint/syslinux.cfg
1754    echo "Copying $MINDI_TMP/initrd.img to $mountpoint/initrd.img..." >> $LOGFILE
1755    cp -f $MINDI_TMP/initrd.img $mountpoint/initrd.img 2>> $LOGFILE
1756    if [ "$?" -ne "0" ] ; then
1757        LogIt "Failed to copy $MINDI_TMP/initrd.img to $mountpoint"
1758        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1759        LogIt "Please unload some of your modules and try again."
1760        rm -f $MINDI_TMP/mtpt.$$
1761        LogIt "Cannot incorporate initrd.img in bootdisk (kernel / modules too big?)"
1762        retval=$(($retval+1))
1763    fi
1764
1765    mkdir -p $mountpoint/tmp
1766    if [ -f "$MINDI_TMP/mondo-restore.cfg" ]; then
1767        cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp
1768    fi
1769
1770    # copy the kernel across
1771    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1772    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1773    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1774    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
1775    if [ "$?" -ne "0" ] ; then
1776        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1777        du -sk $mountpoint/* >> $LOGFILE
1778        echo "--- end of list of files ---" >> $LOGFILE
1779        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1780Sorry, your kernel is too big for your image.\n" >> $LOGFILE
1781        [ "$mountpoint" != "" ] && rm -f $mountpoint/vmlinuz
1782        cd $old_pwd
1783        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1784        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1785
1786        [ "$imagefile" != "" ] && rm -f $imagefile
1787        return 0
1788    fi
1789    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1790    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1791    echo "Free space left on image = $free_space KB" >> $LOGFILE
1792    echo "Max kernel size on $BOOT_SIZE KB image (est'd) = $max_kernel_size K" >> $LOGFILE
1793
1794    # make it bootable
1795    [ "$mountpoint" != "" ] && rm -f $mountpoint/zero
1796    mkdir -p $mountpoint/etc
1797    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
1798    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1799    echo -en "..."
1800    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
1801
1802    if [ "$retval" -eq "0" ] ; then
1803        echo -en "...$DONE\n"
1804        if [ "$KERN_DISK_MADE" ] ; then
1805            [ "$imagefile" != "" ] && rm -f $imagefile
1806            LogIt "$BOOT_SIZE KB boot disks were created OK\n"
1807        fi
1808    else
1809        echo -en "...failed\n"
1810        LogIt $BOOT_SIZE"KB boot disk was NOT created\n"
1811        [ "$imagefile" != "" ] && rm -f $imagefile
1812    fi
1813    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
1814    return $retval
1815}
1816
1817
1818ParseModprobeForIncludes() {
1819local MODPROBE_CONF mpincfile includes include
1820
1821MODPROBE_CONF=/etc/modprobe.conf
1822mpincfile=$1
1823touch $mpincfile
1824if [ -a $MODPROBE_CONF ]; then
1825    includes=$(awk '/^[ \t]*include[ \t]+/ {if(NF>=2){print $2}}' $MODPROBE_CONF|sort -u)
1826    if [ -n "$includes" ]; then
1827        for include in $includes
1828        do
1829            if [ -a "$include" ]; then
1830                echo $include >> $mpincfile
1831            fi
1832        done
1833    fi
1834fi
1835}
1836
1837
1838PrepareDataDiskImages() {
1839    local needlist bigdir diskdir imagesdir res i j k old_pwd lines lfiles includefile
1840
1841    imagesdir=$MINDI_CACHE
1842    rm -f $imagesdir/mindi.iso
1843    needlist=$MINDI_TMP/what-we-need.txt
1844    bigdir=$MINDI_TMP/bigdir
1845    mkdir -p $bigdir/usr/bin
1846    mkdir -p $bigdir/usr/sbin
1847    includefile=$MINDI_TMP/$$.includefile.txt
1848
1849    lfiles="$DEPLIST_FILE"
1850    lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
1851    ParseModprobeForIncludes $includefile
1852    lines=$(($lines+`cat $includefile | wc -l`))
1853    cat $lfiles $includefile | GenerateGiantDependencyList $needlist $lines
1854    res=$?
1855    rm -f $includefile
1856    if [ "$YOUR_KERNEL_SUCKS" ]; then
1857        pwd=`pwd`
1858        cd $MINDI_TMP
1859        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
1860            tar cf - ./$i 2>> $MINDI_TMP/$$.log | (cd $bigdir ; tar xf -) || Die "PDDI can't copy $i->$bigdir" $MINDI_TMP/$$.log
1861        done
1862        for i in $EXTRA_MODS ; do
1863            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
1864            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
1865            for k in $j ; do
1866                tar cf - $k 2>> $MINDI_TMP/$$.log | (cd $bigdir ; tar xf -) || LogIt "ERROR on module $k" $MINDI_TMP/$$.log
1867                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
1868            done
1869        done
1870        cd $pwd
1871    else
1872        ListKernelModulePaths >> $needlist
1873    fi
1874    if [ "$res" -ne "0" ] ; then
1875        Die "You have $res files present in dependency list\nbut absent from filesystem."
1876    fi
1877    FindAndAddUserKeyboardMappingFile
1878    mkdir -p $bigdir/tmp
1879    if [ _"$MONDO_SHARE" != _"" ]; then
1880        MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
1881        cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
1882    fi
1883    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
1884    DropOptimizedLibraries $needlist $bigdir
1885    echo -en "Assembling dependency files"
1886    CopyDependenciesToDirectory < $needlist $bigdir
1887
1888    # also copy io.sys and msdos.sys, if we can find them
1889    for i in `mount | cut -d' ' -f3` ; do
1890        for j in io.sys msdos.sys ; do
1891            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
1892        done
1893    done
1894
1895    # master boot record, too
1896    i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
1897    if [ "$i" ] ; then
1898        LogIt "Backing up $i's MBR"
1899        dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
1900        sleep 1
1901        sync
1902        j=$i
1903        [ -h "$j" ] && j=`readlink -f $j`
1904        LogIt "Creating /dev/boot_device ($j)"
1905        mkdir -p $bigdir/dev
1906        cp -pRdf $j $bigdir/dev/boot_device 2>> $LOGFILE || Die "Unable to create /dev/boot_device on ramdisk"
1907    fi
1908
1909    old_pwd=`pwd`
1910    cd $bigdir
1911
1912    # Get terminfo content
1913    ti="usr/share/terminfo/l"
1914    if [ -d /$ti ]; then
1915        mkdir -p $ti
1916        cp -Rdf /$ti/* $ti 2>> $LOGFILE || LogIt "WARNING - error occurred while copying terminfo"
1917    fi
1918    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
1919        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
1920        [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
1921    fi
1922    if [ -d "/lib/dev-state" ]; then 
1923        tar cf - -C / ./lib/dev-state 2>> $MINDI_TMP/$$.log | tar xf - || LogIt "Unable to handle /lib/dev-state" $MINDI_TMP/$$.log
1924    fi
1925    cd $old_pwd
1926    echo -e "$DONE"
1927    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
1928    MakeMountlist $MINDI_TMP/mountlist.txt
1929    mkdir -p $bigdir/tmp
1930    cp -f $MINDI_TMP/mountlist.txt $bigdir/tmp/mountlist.txt 2>> $LOGFILE || Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
1931    if [ _"$MONDO_SHARE" != _"" ]; then
1932        cp -f $bigdir/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
1933    fi
1934    if [ $LVM != "false" ]; then
1935        $MINDI_LIB/analyze-my-lvm > $bigdir/tmp/i-want-my-lvm
1936        if [ "$?" -ne "0" ]; then
1937            LVM="false"
1938            rm -f $bigdir/tmp/i-want-my-lvm
1939        fi
1940    fi
1941    cat $bigdir/tmp/mountlist.txt >> $LOGFILE
1942    echo -en "$FILES_IN_FILELIST" > $bigdir/FILES-IN-FILELIST 2>> $LOGFILE
1943    echo -en "$LAST_FILELIST_NUMBER" > $bigdir/LAST-FILELIST-NUMBER 2>> $LOGFILE
1944    if [ _"$MONDO_SHARE" != _"" ]; then
1945        for q in filelist.full.gz biggielist.txt ; do
1946            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
1947            cp -pRdf $MINDI_TMP/$q $bigdir/tmp 2>> $LOGFILE
1948        done
1949    fi
1950
1951    echo -en "Tarring and zipping the data content..."
1952    size_of_all_tools=`du -sk $bigdir | cut -f1`
1953    (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)
1954    du -sk $imagesdir/*gz >> $LOGFILE
1955    echo -e "$DONE"
1956
1957    FRIENDLY_OUTSTRING="Boot and data disk images were created."
1958    rm -rf $bigdir
1959    rm -f $needlist
1960}
1961
1962
1963ProcessLDD() {
1964    local incoming f d nd bd bnd
1965    read incoming
1966    while [ "$incoming" != "" ]; do
1967        # We take the full path name of the dyn. lib. we want
1968        incoming=`echo "$incoming" | awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
1969        for f in $incoming ; do
1970            # echo modified file name if one of the parent dir is a link
1971            # by replacing the original dirname by the destination of the link
1972            d="`dirname $f`"
1973            found="false"
1974            while [ "$d" != "/" ]; do
1975                if [ -h "$d" ]; then
1976                    nd=`readlink -f $d`
1977                    bd=`basename $d`
1978                    bnd=`basename $nd`
1979                    f=`echo $f | sed "s~/$bd/~/$bnd/~"`
1980                    echo $d
1981                fi
1982                d="`dirname $d`"
1983            done
1984
1985            echo "$f"
1986            echo "`ReadAllLink $f`"
1987        done
1988        read incoming
1989    done
1990}
1991
1992
1993Prompt() {
1994    echo -en "$1"
1995    read line
1996}
1997
1998
1999ReadLine() {
2000    local i incoming
2001    read incoming
2002    i=0
2003    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2004        i=$(($i+1))
2005        read incoming
2006    done
2007    echo "$incoming"
2008}
2009
2010
2011SizeOfPartition() {
2012    local devpath drive res stub
2013    device=$1
2014    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2015        res=`SizeOfRaidPartition $device`
2016        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2017        echo "$res"
2018        return 0
2019    fi
2020    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2021    res=`$FDISK -s $device 2>> $LOGFILE`
2022    # end patch
2023    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2024    [ "$res" = "" ] && res="-1"
2025    echo $res
2026    return 0
2027}
2028
2029
2030SizeOfRaidPartition() {
2031    local real_dev smallest_size silly tmp
2032
2033    silly=999999999
2034    smallest_size=$silly
2035
2036    for real_dev in `GetRaidDevMembers $1` ; do
2037        tmp=`SizeOfPartition $real_dev`
2038        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2039    done
2040
2041    if [ "$smallest_size" = "$silly" ] ; then
2042        echo "-1"
2043        return 1
2044    else
2045        echo "$smallest_size"
2046        return 0
2047    fi
2048}
2049
2050
2051StripComments()
2052{
2053    local tempfile
2054
2055    tempfile=$MINDI_TMP/$$.strip.txt
2056    cp -f $1 $tempfile 2>> $LOGFILE
2057    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2058    rm -f $tempfile
2059    echo "Stripped comments from $2" >> $LOGFILE
2060}
2061
2062
2063
2064StripExecutable()
2065{
2066    local tmpfile
2067
2068    tmpfile=$MINDI_TMP/stripped.$$.dat
2069    [ -d "$1" ] || [ -h "$1" ] && return
2070    cp -f $1 $tmpfile 2>> $LOGFILE
2071    strip $tmpfile 2> /dev/null
2072    if [ "$?" -eq "0" ] ; then
2073        cp -f $tmpfile $1 2>> $LOGFILE
2074        echo "Stripped binary $2" >> $LOGFILE
2075    fi
2076    rm -f $tmpfile
2077}
2078
2079KernelVer() {
2080        local fkern_ver fname
2081
2082        fname=$1
2083        file $fname | grep -q gzip
2084        if [ "$?" -eq "0" ] ; then
2085            # Used by ia64
2086            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2087        else
2088            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2089        fi
2090        echo "$fkern_ver"
2091}
2092
2093
2094TryToFindKernelPath() {
2095    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2096
2097    we_want_version=$KERVERRUN
2098    possible_kernels=""
2099    duff_kernels=""
2100   
2101    if [ "$ARCH" = "ia64" ] ; then
2102       root="/boot/efi/efi"
2103    else
2104       root="/"
2105    fi
2106    for fname in `find $root -maxdepth 2 -type f | grep -E 'lin|kern' | grep -Ev '^/proc/|^/net/'` ; do
2107        [ ! -e "$fname" ] && continue
2108        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2109        fkern_ver=`KernelVer $fname`
2110        [ "$fkern_ver" = "" ] && continue
2111        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2112        [ -f "$fname" ] || continue
2113        [ -h "$fname" ] && continue
2114        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2115        file $fname | grep -q gzip
2116        if [ "$?" -eq "0" ] ; then
2117            # Used by ia64
2118            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2119                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2120                duff_kernels="$fname $duff_kernels"
2121            else
2122                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2123                possible_kernels="$fname $possible_kernels"
2124            fi
2125        else
2126            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2127                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2128                duff_kernels="$fname $duff_kernels"
2129            else
2130                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2131                possible_kernels="$fname $possible_kernels"
2132            fi
2133        fi
2134    done
2135    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2136        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2137    fi
2138    if [ ! "$possible_kernels" ] ; then
2139        LogIt "No kernel matches exactly. Are there any duff kernels?"
2140        possible_kernels="$duff_kernels"
2141        if [ ! "$possible_kernels" ] ; then
2142            LogIt "Sorry, no duff kernels either"
2143        else
2144            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2145            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2146        fi
2147    fi
2148    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2149    noof_kernels=`CountItemsIn "$possible_kernels"`
2150    if [ "$noof_kernels" -eq "0" ] ; then
2151        LogIt "Could not find your kernel."
2152        if [ -e "/boot/vmlinuz" ] ; then
2153            LogIt "Using /boot/vmlinuz as a last resort."
2154            output=/boot/vmlinuz
2155        else
2156            output=""
2157        fi
2158    elif [ "$noof_kernels" -eq "1" ] ; then
2159        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2160        echo "Your kernel is $kernelpath (v$KERVERRUN)" >> $LOGFILE
2161        output="$kernelpath"
2162    else
2163        for i in $possible_kernels ; do
2164            if echo $i | grep "$KERVERRUN" ; then
2165                LogIt "OK, I used my initiative and found that "
2166                LogIt "$i is probably your kernel. "
2167                output="$i"
2168                return
2169            fi
2170        done
2171        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2172            output=/boot/vmlinuz
2173            echo "Schlomo, this one's for you." >> $LOGFILE
2174        else
2175            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2176            LogIt "boot disks will still work, probably. If one does not work, try another."
2177            LogIt "$possible_kernels"
2178            echo ""
2179        fi
2180    fi
2181    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2182}
2183
2184
2185TurnTgzIntoRdz() {
2186    local tgz_dir_fname rdz_fname tempfile mountpoint old_pwd nodes kernelsize maxsize res currsize not_copied j k s w needed_modules_path
2187
2188    tgz_dir_fname=$1
2189    rdz_fname=$2
2190    kernelsize=$3
2191    maxsize=$(($BOOT_SIZE-$kernelsize))
2192    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2193    tempfile=$MINDI_TMP/temp.rd
2194    mountpoint=$MINDI_TMP/mnt1
2195    res=0
2196    echo -en "..."
2197    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2198    echo -en "..."
2199    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2200    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE || Die "Unable to create an ext2 file system on $tempfile"
2201    echo -en "..."
2202    mkdir -p $mountpoint
2203    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."
2204    echo -en "..."
2205    old_pwd=`pwd`
2206    cd $mountpoint
2207
2208    # AL04Oct08: Check whether /lib64 is a link and if so explicitly create one in rootfs
2209    if [ -h "/lib64" ]; then
2210        mkdir -p lib || LogIt "Unable to create lib in $mountpoint."
2211        ln -s lib lib64 || LogIt "/lib64 is a symbolic link, but I couldn't create it in $mountpoint."
2212    fi
2213
2214    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2215    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2216
2217    cd dev || Die "Can't cd to dev"
2218    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2219    rm -f dev-entries.tgz
2220    cd ..
2221
2222    for w in insmod.static insmod.static.old ; do
2223        s=`which $w 2> /dev/null`
2224        if [ -e "$s" ] ; then
2225            tar cf - -C / $s 2> /dev/null | tar xf -
2226        fi
2227    done
2228
2229    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2230
2231    # Handle the case where busybox and mount are dynamically linked
2232    file $MINDI_LIB/rootfs/bin/busybox 2>&1 | grep -q "dynamically" 
2233    if [ $? -eq 0 ]; then
2234        # We want to use the real mount and all the supported variants (nfs, cifs, ...)
2235        rm -f bin/mount $MINDI_TMP/busy.lis
2236        mountlis=`grep mount $DEPLIST_FILE`
2237        for f in $MINDI_LIB/rootfs/bin/busybox $mountlis ; do
2238            if [ -f $f ]; then
2239                LocateDeps $f >> $MINDI_TMP/busy.lis
2240            fi
2241        done
2242        tar cf - $mountlis `sort -u $MINDI_TMP/busy.lis` 2>> $MINDI_TMP/$$.log | tar xf - || LogIt "Problem in mount analysis" $MINDI_TMP/$$.log
2243        rm -f $MINDI_TMP/busy.lis
2244    fi
2245
2246    # Copy of files mandatory for ld.so
2247    cp -rp /etc/ld.so.c* $mountpoint/etc
2248
2249    # Avoid an issue on some distro (RHEL5)
2250    rm -f $mountpoint/etc/ld.so.conf.d/kernelcap*
2251
2252    mkdir -p $mountpoint/tmp
2253    # Management of udev (which includes modprobe in rules)
2254    ps auxww | grep -v grep | grep -qw udevd
2255    if [ $? -eq 0 ]; then
2256        echo "udev device manager found" > $mountpoint/tmp/USE-UDEV
2257        LogIt "udev device manager found"
2258        tar cf - -C / /etc/udev 2>> $MINDI_TMP/$$.log | tar xf -  || LogIt "Problem in /etc/udev analysis" $MINDI_TMP/$$.log
2259        # This avoids NIC remapping if on another machine at restore time on Debian at least
2260        rm -f ./etc/udev/rules.d/z[0-9][0-9]_persistent-net.rules
2261        # This avoids NIC remapping if on another machine at restore time on Ubuntu at least
2262        rm -f ./etc/udev/rules.d/[0-9][0-9]-persistent-net.rules
2263        tar cf - -C / /lib*/udev 2>> $MINDI_TMP/$$.log | tar xf -  || LogIt "Problem in /lib/udev analysis" $MINDI_TMP/$$.log
2264        if [ -x /sbin/udevd ]; then
2265            lis2=`grep -Ev '^#' $MINDI_CONF/udev.files` 
2266            lis=""
2267            # Get only the files which exist in that list
2268            # and potentially their symlink structure
2269            for i in $lis2; do
2270                if [ -h $i ]; then
2271                    j=$i
2272                    while [ -h $j ]; do
2273                        lis="$lis $j"
2274                        j=`readlink $j`
2275                    done
2276                    lis="$lis $j"
2277                elif [ -f $i ]; then
2278                    lis="$lis $i"
2279                fi
2280            done
2281            # And their deps
2282            LocateDeps $lis > $MINDI_TMP/udev.lis
2283            for i in $lis; do
2284                if [ "`echo $i | cut -c1`" = "/" ]; then
2285                    j=`echo $i | cut -c2-`
2286                    [ "$j" != "" ] && rm -f $j
2287                fi
2288            done
2289            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
2290            rm -f $MINDI_TMP/udev.lis
2291        else
2292            echo "udevd daemon not in standard place (/sbin)" 2>&1 | tee -a $LOGFILE
2293            echo "mindi will use static devices which may cause problems" 2>&1 | tee -a $LOGFILE
2294            rm -f $mountpoint/tmp/USE-UDEV
2295        fi
2296    fi
2297
2298    # Management of potential HW info (Proliant only at the moment)
2299    rm -rf $MINDI_CACHE/bkphw
2300    mindi-bkphw $MINDI_CACHE $MINDI_CONF | tee -a $LOGFILE
2301    if [ -d $MINDI_CACHE/bkphw ]; then
2302        LogIt "Hardware Information found and saved ..."
2303        cp -rp $MINDI_CACHE/bkphw .
2304        if [ -f $MINDI_CACHE/tools.files ]; then
2305            lis=`grep -Ev '^#' $MINDI_CACHE/tools.files` 
2306            LocateDeps $lis > $MINDI_TMP/tools.lis
2307            tar cf - $lis `sort -u $MINDI_TMP/tools.lis` 2>> $MINDI_TMP/$$.log | tar xf - || LogIt "Problem in tools.lis analysis" $MINDI_TMP/$$.log
2308        fi
2309        if [ -f $MINDI_CACHE/mindi-rsthw ]; then
2310            mv -f $MINDI_CACHE/mindi-rsthw .
2311            chmod 755 ./mindi-rsthw
2312        fi
2313        rm -f $MINDI_TMP/tools.lis $MINDI_CACHE/tools.files
2314    fi
2315
2316    # Management of perl scripts delivered needed at restore time
2317    mindi-get-perl-modules `cat $MINDI_CONF/perl-scripts` > $MINDI_TMP/perl.lis
2318    tar cf - `cat $MINDI_TMP/perl.lis` 2>> $MINDI_TMP/$$.log | tar xf - || LogIt "Problem in perl scripts analysis" $MINDI_TMP/$$.log
2319
2320    for w in cdrom groovy-stuff ; do
2321        mkdir -p mnt/$w
2322    done
2323
2324    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
2325
2326    cd $old_pwd
2327    echo -en "..."
2328    old_pwd=`pwd`
2329    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2330        cd $MINDI_TMP
2331        needed_modules_path=lib/modules/$FAILSAFE_KVER
2332    else
2333        cd /
2334        if [ "${kernelname}" != "" ]
2335        then
2336            needed_modules_path=lib/modules/${kernelname}
2337        else
2338            needed_modules_path=lib/modules/$KERVERRUN
2339        fi
2340    fi
2341
2342    needed_modules=""
2343    list_of_groovy_mods="$CDROM_MODS $FORCE_MODS"
2344
2345    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
2346        # For PXE boot
2347        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2348    fi
2349    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2350        list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
2351    fi
2352    for i in $DENY_MODS; do
2353        echo "Removing $i from the list of modules to load" >> $LOGFILE
2354        list_of_groovy_mods=`echo ${list_of_groovy_mods} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
2355    done
2356
2357    [ -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."
2358    for i in $list_of_groovy_mods ; do
2359        needed_modules="$needed_modules `FindSpecificModuleInPath $needed_modules_path $i`"
2360    done
2361
2362    for i in $needed_modules ; do
2363        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2364        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2365        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2366        tar cf - -C / $i 2>> $MINDI_TMP/$$.log | (cd $mountpoint ; tar xf -) || LogIt "Unable to copy $i to $mountpoint" $MINDI_TMP/$$.log
2367        # Uncompress modules if not using udev and native modprobe
2368        if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
2369            if [ "`echo "$i" | grep -F ".gz"`" ]; then
2370                echo "Uncompressing $i" >> $LOGFILE
2371                gunzip -f $mountpoint/$i
2372            fi
2373        fi
2374    done
2375
2376    # Also copy modules.dep in case of udev so that normal modprobe works
2377    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
2378
2379    if [ ! -e "/sbin/devfsd" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2380        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2381        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2382        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2383        rm -f $mountpoint/sbin/devfsd
2384    fi
2385    cd $old_pwd
2386    [ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2387    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2388    rm -f $mountpoint/zero
2389    if [ _"$MONDO_SHARE" != _"" ]; then
2390        MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
2391        cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP 2>> $LOGFILE || Die "Cannot copy mondo-restore.cfg to ramdisk"
2392        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>> $LOGFILE || Die "Cannot copy mountlist to ramdisk"
2393        echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
2394        echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
2395        [ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
2396        [ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
2397        [ "$USE_LZMA" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-LZMA
2398        [ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
2399        [ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
2400    fi
2401    mkdir -p $mountpoint/proc
2402    echo "$BOOT_SIZE" > $mountpoint/tmp/$BOOT_SIZE.siz
2403    # Determine what filesystem to use for initrd image
2404    echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2405    gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2406    [ -z  gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2407    case "$gvFileSystem" in
2408    "ext2fs")
2409        # say what will be used
2410        echo "Creating an ext2 initrd image..." >> $LOGFILE
2411        # kernel expects linuxrc in ext2 filesystem
2412        ( cd $mountpoint && ln -sf sbin/init linuxrc )
2413        # unmount loop filesystem and create image file using the standard approach
2414        umount $mountpoint || Die "Cannot unmount $tempfile"
2415        dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2416        bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2 | sed 's/^ *//'`
2417        ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2418        gzip -c9 ${rdz_fname}.tmp > $rdz_fname
2419        rm -f ${rdz_fname}.tmp
2420        # log that we are done
2421        echo "...done." >> $LOGFILE
2422    ;;
2423    "initramfs")
2424        # say what will be used
2425        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2426        # make sure that cpio is there
2427        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2428        # go into filesystem
2429        cd $mountpoint
2430        # kernel expects init in cpio filesystem
2431        ln -sf sbin/init init
2432        # create cpio image file and unmount loop filesystem
2433        find . -print | cpio -o -H newc | gzip -9 > $rdz_fname 2> /dev/null
2434        cd $old_pwd
2435        umount $mountpoint || Die "Cannot unmount $tempfile"
2436        # log that we are done
2437        echo "...done." >> $LOGFILE
2438    ;;
2439    *)
2440        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2441    ;;
2442    esac
2443    if [ "$res" -eq "0" ] ; then
2444        echo -en "..."
2445    else
2446        echo -en "\rMade an rdz WITH ERRORS.           \n"
2447    fi
2448    return 0
2449}
2450
2451
2452##############################################################################
2453#----------------------------------- Main -----------------------------------#
2454##############################################################################
2455
2456# Now we can create what we need
2457mkdir -p $MINDI_TMP
2458
2459# Purge from potential old run
2460if [ _"$MINDI_CACHE" = _"" ]; then
2461    Die "MINDI_CACHE undefined"
2462fi
2463
2464if [ "$1" = "--printvar" ] ; then
2465    shift
2466    if [ _"$1" != _"" ] ; then
2467        set | grep -Ew "^$1" | cut -d= -f2
2468    fi
2469    exit 0
2470fi
2471
2472> $LOGFILE
2473echo "mindi v$MINDI_VERSION" >> $LOGFILE
2474echo "$ARCH architecture detected" >> $LOGFILE
2475echo "mindi called with the following arguments:" >> $LOGFILE
2476echo "$@" >> $LOGFILE
2477echo "Start date : `date`" >> $LOGFILE
2478echo "-----------------------------" >> $LOGFILE
2479
2480[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2481
2482# Log some capital variables
2483[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2484echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2485echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2486echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2487[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2488echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2489if [ -f $MINDI_CONFIG ]; then
2490    echo "-----------------------------" >> $LOGFILE
2491    echo " Mindi configuration file    " >> $LOGFILE
2492    echo "-----------------------------" >> $LOGFILE
2493    grep -Ev '^#' $MINDI_CONFIG >> $LOGFILE
2494    echo "-----------------------------" >> $LOGFILE
2495fi
2496
2497
2498trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2499
2500# Sanity checks
2501which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2502which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2503which 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."
2504which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2505if which awk &> /dev/null ; then
2506    if ! which gawk &> /dev/null ; then
2507        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"
2508    fi
2509fi
2510which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2511[ ! -e "$FDISK" ] && Die "Cannot find $FDISK"
2512
2513[ "`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"
2514
2515# Update the PATH variable if incomplete
2516if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2517    PATH=$PATH:/sbin:/usr/sbin
2518    export PATH
2519    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2520    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2521    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2522fi
2523
2524# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2525if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2526    source $MINDI_LIB/FindDistroFailsafe
2527    # Log kernel image
2528    LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2529else
2530    [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2531fi
2532
2533if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
2534    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2535fi
2536
2537### BERLIOS
2538### Fix as it's not mandatory on ia64
2539if [ "$ARCH" = "ia64" ] ; then
2540    if which elilo &> /dev/null ; then
2541        LILO_EXE=elilo
2542    else
2543        LILO_EXE=`which false 2> /dev/null`
2544    fi
2545else
2546    FindIsolinuxBinary
2547fi
2548trap "Aborted" SIGTERM
2549DONE="\r\t\t\t\t\t\t\t\tDone.         "
2550kernelpath=""
2551MONDO_ROOT=/var/cache/mondo
2552mkdir -p $MONDO_ROOT
2553
2554if [ -d "/proc/lvm" ]; then
2555    # LVM v1
2556    LVMCMD=""
2557    LVM="v1"
2558elif [ -d "/dev/mapper" ]; then
2559    # LVM v2
2560    LVMCMD="lvm"
2561    LVM="v2"
2562else
2563    LVM="false"
2564fi
2565
2566if [ -e "/proc/cmdline" ]; then
2567    CMDLINE="/proc/cmdline"
2568elif [ -e "/tmp/cmdline" ]; then
2569    CMDLINE="/tmp/cmdline"
2570else
2571    CMDLINE="/dev/null"
2572fi
2573
2574echo "LVM set to $LVM" >> $LOGFILE
2575echo "----------" >> $LOGFILE
2576echo "mount result:" >> $LOGFILE
2577echo "-------------" >> $LOGFILE
2578mount >> $LOGFILE
2579echo "-------------" >> $LOGFILE
2580if [ -e /etc/raidtab ]; then
2581    echo "-------------" >> $LOGFILE
2582    echo "/etc/raidtab content:" >> $LOGFILE
2583    echo "-------------" >> $LOGFILE
2584    cat /etc/raidtab >> $LOGFILE
2585fi
2586echo "-------------" >> $LOGFILE
2587echo "cat $CMDLINE" >> $LOGFILE
2588echo "-------------" >> $LOGFILE
2589cat $CMDLINE >> $LOGFILE
2590echo "-------------" >> $LOGFILE
2591echo "cat /proc/swaps:" >> $LOGFILE
2592echo "-------------" >> $LOGFILE
2593cat /proc/swaps >> $LOGFILE
2594echo "-------------" >> $LOGFILE
2595echo "cat /proc/partitions:" >> $LOGFILE
2596echo "-------------" >> $LOGFILE
2597cat /proc/partitions >> $LOGFILE
2598echo "-------------" >> $LOGFILE
2599echo "cat /proc/filesystems:" >> $LOGFILE
2600echo "-------------" >> $LOGFILE
2601cat /proc/filesystems >> $LOGFILE
2602echo "-------------" >> $LOGFILE
2603echo "lsmod result:" >> $LOGFILE
2604echo "-------------" >> $LOGFILE
2605lsmod >> $LOGFILE
2606MODULES="`cat /proc/modules | awk '{print $1}'`"
2607if [ -x /usr/sbin/esxcfg-module ]; then
2608    echo "-------------" >> $LOGFILE
2609    echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
2610    echo "-------------" >> $LOGFILE
2611    echo "VMWare modules" >> $LOGFILE
2612    echo "-------------" >> $LOGFILE
2613    /usr/sbin/esxcfg-module -l >> $LOGFILE
2614    MODULES="$MODULES `/usr/sbin/esxcfg-module -l | awk '{print $1}'`"
2615fi
2616echo "FORCE_MODS:" >> $LOGFILE
2617echo "-------------" >> $LOGFILE
2618echo $FORCE_MODS >> $LOGFILE
2619echo "-------------" >> $LOGFILE
2620echo "DENY_MODS:" >> $LOGFILE
2621echo "-------------" >> $LOGFILE
2622echo $DENY_MODS >> $LOGFILE
2623echo "-------------" >> $LOGFILE
2624echo "df result:" >> $LOGFILE
2625echo "----------" >> $LOGFILE
2626df -T >> $LOGFILE
2627echo "-------------" >> $LOGFILE
2628echo "Liste of extra modules is:" >> $LOGFILE
2629echo "$EXTRA_MODS" >> $LOGFILE
2630echo "-------------" >> $LOGFILE
2631
2632# Compute libata version
2633laver=`modinfo libata | grep -Ei '^Version:' | cut -d: -f2 | cut -d. -f1 | sed 's/  *//g' 2> /dev/null`
2634# If libata v2 is used then remove ide-generic as it will perturbate boot
2635if [ "`echo $MODULES | grep libata`" ]; then
2636    if [ "$laver" = "2" ]; then
2637        DENY_MODS="$DENY_MODS ide-generic"
2638        echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
2639        echo "-------------" >> $LOGFILE
2640    fi
2641fi
2642
2643FLOPPY_WAS_MOUNTED=""
2644for mtpt in /media/floppy /mnt/floppy /floppy ; do
2645    if mount | grep -w $mtpt &> /dev/null ; then
2646        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
2647        umount $mtpt
2648    fi
2649done
2650
2651#
2652# If we have a USB device we need to store info
2653# and remove it from the parameters line
2654#
2655if [ "$#" -ne "0" ] ; then
2656    if [ "$1" = "--usb" ] ; then
2657        shift
2658        USBDEVICE=$1
2659        if [ _"$USBDEVICE" = _"" ]; then
2660            Die "No USB device specified"
2661        fi
2662        shift
2663    fi
2664fi
2665
2666if [ "$#" -ne "0" ] ; then
2667    if [ "$1" = "--findkernel" ] ; then
2668        res=`TryToFindKernelPath`
2669        # Avoids logfile content for mondo
2670        export MONDO_SHARE=""
2671        if [ "$res" = "" ] ; then
2672            MindiExit -1
2673        else
2674            echo "$res"
2675            MindiExit 0
2676        fi
2677    elif [ "$1" = "--locatedeps" ] ; then
2678        [ ! "$2" ] && Die "Please specify the binary to look at"
2679        LocateDeps $2
2680        # Avoids logfile content for mondo
2681        export MONDO_SHARE=""
2682        MindiExit $?
2683    elif [ "$1" = "--readalllink" ] ; then
2684        [ ! "$2" ] && Die "Please specify the binary to look at"
2685        ReadAllLink $2
2686        # Avoids logfile content for mondo
2687        export MONDO_SHARE=""
2688        MindiExit $?
2689    elif [ "$1" = "--makemountlist" ] ; then
2690        [ ! "$2" ] && Die "Please specify the output file"
2691        MakeMountlist $2
2692        # Avoids logfile content for mondo
2693        export MONDO_SHARE=""
2694        MindiExit $?
2695    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
2696        echo "Mindi v$MINDI_VERSION"
2697        # Avoids logfile content for mondo
2698        export MONDO_SHARE=""
2699        MindiExit 0
2700    elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
2701        MONDO_TMP=$2
2702        # Change MINDI_TMP for the one provided by mondo
2703        # So that it can get back the built files
2704        if [ _"$MONDO_TMP" = _"" ]; then
2705            Die "MONDO_TMP is empty, aborting"
2706        fi
2707        if [ _"$MONDO_TMP" = _"/" ]; then
2708            Die "MONDO_TMP is /, aborting"
2709        fi
2710        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2>> $LOGFILE
2711        rmdir $MINDI_TMP
2712        export MINDI_TMP=$MONDO_TMP
2713        mkdir -p $MINDI_TMP
2714
2715        # This is the scratch dir in mondo - subdir images
2716        MINDI_CACHE=$3
2717
2718        kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
2719###
2720### Sq-Modification...
2721### Attempt to locate kernel specific module path
2722### if module path is found then use it other wise use uname -r to set it...
2723###
2724        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2725        LogIt "kernelname = $kernelname"
2726        LogIt "kernelpath = $kernelpath"
2727        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2728        then
2729           LogIt "Module path for ${kernelpath} not found..."
2730           LogIt "using running kernel\'s modules."
2731           kernelname=$KERVERRUN
2732        else
2733           LogIt "Using modules for kernel: ${kernelname}"
2734        fi
2735###
2736### end of Sq-Modification
2737###
2738        TAPEDEV=$5
2739        TAPESIZE=$6
2740        FILES_IN_FILELIST=$7
2741        USE_LZO=$8
2742        CDRECOVERY=$9
2743        if [ "${10}" = "(null)" ] || [ "${10}" = "" ] ; then
2744            IMAGE_DEVS=""
2745        else
2746            IMAGE_DEVS="`echo "${10}" | tr '|' ' '`"
2747        fi
2748        if [ "${11}" ] ; then
2749            LILO_OPTIONS=""
2750    #       LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
2751        fi
2752        LAST_FILELIST_NUMBER=${12}
2753        ESTIMATED_TOTAL_NOOF_SLICES=${13}
2754        EXCLUDE_DEVS="${14}"
2755        USE_COMP="${15}"
2756        USE_LILO="${16}"
2757        USE_STAR="${17}"
2758        INTERNAL_TAPE_BLOCK_SIZE="${18}"
2759        DIFFERENTIAL="${19}"
2760        USE_GZIP="${20}"
2761        USE_LZMA="${21}"
2762        NOT_BOOT="${22}"
2763        [ "$USE_COMP" = "" ] && USE_COMP=yes
2764        [ "$USE_GZIP" = "" ] && USE_GZIP=no
2765        [ "$USE_LZMA" = "" ] && USE_LZMA=no
2766        [ "$NOT_BOOT" = "" ] && NOT_BOOT=no
2767        [ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
2768        [ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
2769        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2770        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2771        then
2772           LogIt "Module path for ${kernelpath} not found..."
2773           LogIt "using running kernel\'s modules."
2774           kernelname=$KERVERRUN
2775        else
2776           LogIt "Using modules for kernel: ${kernelname}"
2777        fi
2778        # MONDO_ROOT is the real scratchdir
2779        MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
2780        if [ _"$MONDO_ROOT" != _"" ]; then
2781            mkdir -p $MONDO_ROOT
2782        else
2783            Die "MONDO_ROOT is undefined"
2784        fi
2785    else
2786        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
2787        MindiExit -1
2788    fi
2789fi
2790
2791if [ _"$MINDI_CACHE" != _"" ]; then
2792    rm -rf $MINDI_CACHE/* 2> /dev/null
2793    mkdir -p $MINDI_CACHE
2794fi
2795
2796[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
2797
2798if [ _"$MONDO_SHARE" = _"" ]; then
2799    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
2800    LogIt "Latest Mindi is available from http://www.mondorescue.org"
2801    LogIt "BusyBox sources are available from http://www.busybox.net"
2802    LogIt "------------------------------------------------------------------------------"
2803else
2804    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
2805fi
2806if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
2807    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
2808else
2809    LogIt "Unable to find mindi-busybox, please install it"
2810    MindiExit -1
2811fi
2812
2813# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
2814insmod /lib/modules/$KERVERRUN/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
2815for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
2816    insmod $i >> $LOGFILE 2>> $LOGFILE
2817done
2818
2819KERN_DISK_MADE=""
2820
2821echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
2822echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
2823echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
2824if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
2825    LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
2826    MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
2827    MakeMountlist $MINDI_TMP/mountlist.txt
2828    mkdir -p $MINDI_TMP/small-all/tmp
2829    cd $MINDI_TMP/small-all
2830    cp -f $MINDI_TMP/{mountlist.txt,mondo-restore.cfg,filelist.full.gz,biggielist.txt} tmp 2>> $LOGFILE || Die "Cannot copy small all.tar.gz"
2831    tar -cv ./tmp | gzip -9 > $MINDI_TMP/all.tar.gz 2>> $MINDI_TMP/$$.log || Die "Cannot make small all.tar.gz" $MINDI_TMP/$$.log
2832    sleep 2
2833    LogIt "Done. Exiting."
2834    MindiExit 0
2835fi
2836
2837if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2838    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
2839fi
2840
2841if [ "$kernelpath" = "" ] ; then
2842    [ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
2843    echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
2844    read ch
2845    if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
2846        USE_OWN_KERNEL="yes"
2847    else
2848        USE_OWN_KERNEL="no"
2849    fi
2850    if [ "$USE_OWN_KERNEL" = "yes" ]; then
2851        YOUR_KERNEL_SUCKS=""
2852        kernelpath=`TryToFindKernelPath`
2853        if [ "$kernelpath" = "" ] ; then
2854            echo -n "Please enter kernel path : "
2855            read kernelpath
2856        fi
2857    else
2858        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
2859    fi
2860fi
2861if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
2862    # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2863    if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
2864        source $MINDI_LIB/FindDistroFailsafe
2865        # Log kernel image
2866        LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2867        kernelpath="$FAILSAFE_KBIN"
2868        LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
2869        LogIt "The failsafe kernel is $kernelpath.\n"
2870        LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
2871        LogIt "disks then it may still be a result of a problem with your kernel.\n"
2872        pwd=`pwd`
2873        cd $MINDI_TMP
2874        mkdir -p lib/modules
2875        cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
2876        cd $pwd
2877    else
2878        kernelpath=$MINDI_LIB/vmlinuz
2879        LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
2880        LogIt "However, you are still running your kernel. If Mindi fails to create your"
2881        LogIt "disks then it may still be a result of a problem with your kernel."
2882        pwd=`pwd`
2883        cd $MINDI_TMP
2884        bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
2885        cd $pwd
2886    fi
2887    YOUR_KERNEL_SUCKS="Your kernel sucks"
2888fi
2889echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
2890[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
2891
2892[ "$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."
2893
2894PrepareDataDiskImages
2895
2896ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
2897rds=$(($ramdisk_size-$((ramdisk_size%4096))))
2898export ramdisk_size=$rds
2899
2900echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
2901if [ "$ARCH" = "ia64" ] ; then
2902    PrepareBootDiskImage_LILO $kernelpath || Die "Failed to create ia64 image disk image."
2903else
2904    PrepareBootDiskImage_ISOLINUX $kernelpath || Die "Failed to create $ramdisk_size MB disk image."
2905fi
2906
2907[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
2908...Or type 'memtest' to test your PC's RAM thoroughly.\n"
2909
2910if [ _"$MONDO_SHARE" = _"" ]; then
2911    ListImagesForUser
2912    OfferToMakeBootableISO
2913    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
2914        OfferToMakeBootableUSB
2915    fi
2916    LogIt "Finished."
2917elif [ "$TAPEDEV" ] ; then
2918    if [ "$ARCH" != "ia64" ] ; then
2919        # We need to keep the img file as boot file for ia64 platform
2920        rm -f $MINDI_CACHE/{*img,*iso}
2921    else
2922        rm -f $MINDI_CACHE/*iso
2923    fi
2924    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2925        OfferToMakeBootableUSB
2926    fi
2927    OfferToMakeBootableISO
2928    if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
2929        cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
2930    else
2931        Die "Cannot find all.tar.gz, to be written to tape"
2932    fi
2933elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2934    OfferToMakeBootableUSB
2935else
2936    OfferToMakeBootableISO
2937fi
2938# cleanup
2939LogIt "$FRIENDLY_OUTSTRING"
2940for mtpt in $FLOPPY_WAS_MOUNTED ; do
2941    mount $mtpt
2942done
2943MindiExit 0
Note: See TracBrowser for help on using the repository browser.