source: branches/2.2.9/mindi/mindi @ 2708

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

r4184@localhost: bruno | 2011-01-27 15:52:51 +0100

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