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

Last change on this file since 2329 was 2329, checked in by Bruno Cornec, 11 years ago

r3340@localhost: bruno | 2009-08-12 00:17:29 +0200
Improve portability by defining all cmdline usage in 1 include (/tmp for FreeBSD and /proc fior LInux). Also doing tht for scripts.

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