source: branches/2.2.9/mindi/mindi @ 2600

Last change on this file since 2600 was 2600, checked in by bruno, 9 years ago

r3744@localhost: bruno | 2010-03-16 01:44:33 +0100

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