source: branches/2.2.9/mindi/mindi @ 2754

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