source: branches/2.2.10/mindi/mindi @ 2599

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

r3743@localhost: bruno | 2010-03-16 01:44:07 +0100

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