source: MondoRescue/branches/2.2.9/mindi/mindi @ 2440

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