source: branches/2.2.10/mindi/mindi @ 2291

Last change on this file since 2291 was 2291, checked in by Bruno Cornec, 11 years ago
  • Fix a printing error in mindi for the tar command
  • Fix all mr_asprintf which had no second param as a string

(report bug fix done originaly in 2.2.9)

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