source: branches/2.2.5/mindi/mindi @ 1828

Last change on this file since 1828 was 1828, checked in by bruno, 12 years ago

kqemu is denied. Probably should also be done for kvm stuff

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