source: branches/2.2.9/mindi/mindi @ 2447

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