source: branches/2.2.9/mindi/mindi @ 2409

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