source: branches/2.2.5/mindi/mindi @ 1865

Last change on this file since 1865 was 1865, checked in by Bruno Cornec, 12 years ago

Now also fixes when not swap :-)

  • Property svn:keywords set to Rev Id
File size: 126.1 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1865 2008-01-16 11:18:46Z 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 pata_serverworks"
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 nls_utf8 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=$(find / -name "*/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=`find / -name 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        label=""
1283        uuid=""
1284        absolute_partition=`readlink -f $c_p`
1285        partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1286
1287        # Detects noauto partitions not mounted and exclude them
1288        partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1289        if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" =  "" ] ; then
1290            continue
1291        fi
1292
1293        # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1294        # current_partition contains only first column of /etc/fstab
1295        if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1296            str_to_find_fmt_with=$current_partition
1297            redhat_label=`echo "$current_partition" | cut -d'=' -f2`
1298            actual_dev=""
1299
1300            # 1st try, findfs - the RHEL way of finding labels and their partitions
1301            if [ -x "/sbin/findfs" ]; then
1302                actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1303            fi
1304   
1305            # 2nd try : blkid, the good way for all LABEL except swap
1306            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1307                actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | cut -d':' -f1`
1308                # For LVM FS it will give a /dev/dm-# which should then be converted
1309                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1310                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1311                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1312                    for dev in `ls /dev/mapper/*`; do
1313                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1314                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1315                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1316                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1317                            break
1318                        fi
1319                    done
1320                fi
1321            fi
1322   
1323            # 3rd try, which works on a standard partition (ext2/3), but not on swap
1324            # For LVM gives a /dev/mapper entry
1325            if [ "x$actual_dev" = "x" ]; then
1326                actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | cut -d' ' -f1`
1327            fi
1328   
1329            # 4th try, with vol_id
1330            # SWAP only
1331            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1332                list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | $AWK '{ print $1 }' `
1333                for dev_swap in $list_swaps ; do
1334                    dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1335                    if [ "x$dev_exists" != "x" ]; then
1336                        actual_dev=$dev_swap
1337                        break;
1338                    fi
1339                done
1340            fi
1341
1342            # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1343            # LABEL=SW-cciss/c0d0p3 (RDP)
1344            # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1345            # SWAP only
1346            if [ "x$actual_dev" = "x" -a  _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1347                    for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1348                    do
1349                        # Location of the swap label for kernel 2.6
1350                        try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
1351                        if [ "x$try_dev_label" = "x$redhat_label" ]; then
1352                            actual_dev=$try_dev
1353                        fi
1354                    done
1355            fi
1356
1357            # Check if one of all those tries has known success
1358            if [ "x$actual_dev" != "x" ]; then
1359                current_partition=$actual_dev
1360            else
1361                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"
1362            fi
1363        # This part tries to retrieve the correct device from a UUID line in /etc/fstab
1364        # current_partition contains only first column of /etc/fstab
1365        elif [ "`echo "$current_partition" | /bin/grep -i "UUID="`" != "" ]; then
1366            str_to_find_fmt_with=$current_partition
1367            uuid=`echo "$current_partition" | cut -d'=' -f2`
1368            actual_dev=""
1369
1370            # 1st try, findfs - the RHEL way of finding labels and their partitions
1371            if [ -x "/sbin/findfs" ]; then
1372                actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
1373            fi
1374   
1375            # 2nd try : blkid, the good way for all UUID except swap
1376            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1377                actual_dev=`/sbin/blkid | /bin/grep "$uuid" | grep UUID= | cut -d':' -f1`
1378                # For LVM FS it will give a /dev/dm-# which should then be converted
1379                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1380                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1381                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1382                    for dev in `ls /dev/mapper/*`; do
1383                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1384                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1385                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1386                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1387                            break
1388                        fi
1389                    done
1390                fi
1391            fi
1392   
1393            # 3th try, with vol_id
1394            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1395                list_dev=`mount | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1396                for dev in $list_dev ; do
1397                    dev_exists=`/sbin/vol_id $dev | /bin/grep "$uuid"`
1398                    if [ "x$dev_exists" != "x" ]; then
1399                        actual_dev=$dev
1400                        break;
1401                    fi
1402                done
1403            fi
1404
1405            # 4th try, with dumpuuid (VMWare only ?) for swap
1406            if [ "x$actual_dev" = "x" -a -x "/sbin/dumpuuid" ]; then
1407                list_dev=`cat /proc/swaps | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1408                for dev in $list_dev ; do
1409                    dev_exists=`/sbin/dumpuuid $dev | /bin/grep "$uuid"`
1410                    if [ "x$dev_exists" != "x" ]; then
1411                        actual_dev=$dev
1412                        break;
1413                    fi
1414                done
1415            fi
1416
1417            # Check if one of all those tries has known success
1418            if [ "x$actual_dev" != "x" ]; then
1419                current_partition=$actual_dev
1420            else
1421                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"
1422            fi
1423        else
1424            # Needs to handle the recent OpenSUSE fancy way of dealing with fstab :-(
1425            # they use symlinks in fstab unrelated to what is shown in mount !
1426            if [ _"$partition_mountpt" = _"" ]; then
1427                for tmpp in `tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -Ev "^#" | $AWK '{print $1}'`; do
1428                        if [ _"`readlink -f $tmpp`" = _"$current_partition" ]; then
1429                            str_to_find_fmt_with=$tmpp
1430                            partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$tmpp" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1431                            break;
1432                        fi
1433                done
1434            else
1435                str_to_find_fmt_with=$current_partition
1436            fi
1437        fi
1438
1439        partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1440        # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1441        # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1442        # the former is then a link to the latter, so we test whether
1443        # $current_partition is actually such a link or not and set
1444        # $current_lvolume accordingly. On Debian you may find more than one answer
1445        # so we remove the one corresponding to /dev/.static
1446        # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1447        # principle is the same and we need to find the link to it as well.
1448        # Note that $current_lvolume may well be an
1449        # ordinary device. It is just to make sure that we feed the right value
1450        # into any of the LVM tools if possible.
1451
1452        current_lvolume="$current_partition"
1453        if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1454            # .static dir are a Debian specificity
1455            current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1456            echo $current_lvolume | grep -q ' '
1457            if [ $? -eq 0 ]; then
1458                echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE 
1459            fi
1460        fi
1461        #
1462        # End of LVM device style variation code (other than $current_lvolume).
1463
1464        if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1465            # Size computed via LVM not directly
1466            partition_size="lvm"
1467        else
1468            partition_size=`SizeOfPartition $current_partition`
1469            [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1470            [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1471            if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1472                partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1473                [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1474                [ "$partition_format" != "swap" ] && partition_format="swap"
1475                if [ "$partition_size" = "" ] ; then
1476                    totalsize=0
1477                    items=0
1478                    for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1479                        totalsize=$(($totalsize+$i))
1480                        items=$(($items+1))
1481                    done
1482                    [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1483                    [ "$partition_size" -lt "125000" ] && partition_size=125000
1484                    echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1485                fi
1486            fi
1487        fi
1488        [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1489        [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1490        if [ "$partition_mountpt" = "" ] ; then
1491            if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1492                if  [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1493                    partition_mountpt="raid"
1494                    partition_format="raid"
1495                else
1496                    partition_mountpt="lvm"
1497                    partition_format="lvm"
1498                fi
1499            fi
1500        fi
1501        psz=$partition_size
1502        echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1503        [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1504        if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1505            partition_mountpt="image"
1506            old_partition_fmt=$partition_format
1507            partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1508            partition_size=$(($partition_size+1)); # just in case
1509            if [ "$partition_format" = "Linux" ] ; then
1510                echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1511                echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1512                partition_format=$old_partition_fmt
1513            fi
1514        fi
1515        if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1516            echo "Excluding $current_partition from mountlist" >> $LOGFILE
1517            continue
1518        fi
1519        if [ ! "$partition_mountpt" ] ; then
1520            echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1521            for qq in "" `find /dev/ida/c*d* ! -name '*p*'` ; do
1522                partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1523                [ "$partition_format" ] && break
1524            done
1525            echo "------- $FDISK log end ------------" >> $LOGFILE
1526            if [ "$partition_format" = "Compaq diagnostics" ] ; then
1527                partition_format="compaq"
1528            elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1529                LogIt "Unable to find mountpoint of $current_partition - ignoring"
1530                continue
1531            fi
1532        fi
1533        if [ "$redhat_label" ]; then
1534            label="$redhat_label"
1535        elif [ "$uuid" ]; then
1536            label="$uuid"
1537        fi
1538        partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1539        [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1540        unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label"`
1541        if [ "$current_partition" = "" ] ; then
1542            echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1543        elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1544            if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1545                partition_mountpt=raid
1546                partition_format=raid
1547                printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1548                printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1549            else
1550                echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1551            fi
1552        elif [ "$partition_format" = "" ] ; then
1553            echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1554        elif [ "$partition_size" = "" ] ; then
1555            echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1556        elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1557            continue
1558        else
1559            if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1560                echo "Stupid bastard..." >> $LOGFILE
1561                partition_format="vfat"
1562            fi
1563            printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$label" | tee -a $LOGFILE
1564            printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$label" >> $mountlist
1565        fi
1566    done
1567}
1568
1569
1570MakeSureNumberIsInteger() {
1571    res=`echo "$1" | tr -s '\-[0-9]' ' '`
1572    if [ "$res" != " " ] && [ "$res" != "" ] ; then
1573    echo "result = '$res'"
1574        Die "$1 should be an integer"
1575    fi
1576}
1577
1578
1579MakeSyslinuxMessageFile() {
1580    mkdir -p $1
1581    rmdir $1
1582    echo -en "  " > $1
1583    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1584        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
1585    else
1586        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
1587    fi
1588    sed s/%r/"`uname -r`"/ $1.tmp | sed s/%t/"`hostname`"/ > $1
1589    rm -f $1.tmp
1590    if [ "$CDRECOVERY" != "yes" ] ; then
1591        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1592            echo -en "Press <enter> to continue.\n" >> $1
1593        elif [ ! "$MINDI_TMP" ] ; then
1594            echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
1595            if [ -e "$MINDI_LIB/memtest.img" ] ; then
1596                echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
1597            fi
1598        else
1599            echo -en "$BOOT_MEDIA_MESSAGE" >> $1
1600        fi
1601    else
1602        echo -en " \
1603To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1604CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1605    fi
1606}
1607
1608
1609MoveHyperlinkSensibly() {
1610    local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
1611    filename=$1
1612    minidir_root=$2
1613    resides_on_diskno=$3
1614    noof_disks=$4
1615
1616    [ -h "$minidir_root/$resides_on_diskno/$filename" ] || Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
1617
1618    old_diskno=$resides_on_diskno
1619    d=1
1620    while [ "$d" -le "$noof_disks" ] ; do
1621        if [ "$d" -ne "$old_diskno" ] ; then
1622            old_pwd=`pwd`
1623            cd $minidir_root/$old_diskno
1624            cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE || Die "Can't move $filename (sensibly) from $old_diskno to $d"
1625            rm -f $filename
1626            cd $old_pwd
1627        fi
1628# when the softlink is resolvable, our work here is done
1629        [ -e "$minidir_root/$d/$filename" ] && return 0
1630        old_diskno=$d
1631        d=$(($d+1))
1632    done
1633    return 1
1634}
1635
1636
1637
1638OfferToCopyImagesToDisks() {
1639    local imagesdir i imagename dev count boot_dev data_dev
1640    imagesdir=$1
1641    boot_dev=$2
1642    data_dev=$3
1643
1644    echo -en "Would you like to create boot+data floppy disks now (y/[n]) ?"
1645    read i
1646    [ "$i" != "y" ] && [ "$i" != "Y" ] && return
1647    mount | grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
1648    echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
1649    [ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
1650    [ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
1651    i=`find $imagesdir -type f | grep -F "/mindi-root.1" 2> /dev/null`
1652    j=`find $imagesdir -type f | grep -F "/mindi-boot" | grep -Ev "2880|$BOOT_SIZE"`
1653    if [ "$i" ] ; then
1654        CopyImageToDisk $j $data_dev "boot disk"
1655        CopyImageToDisk $i $data_dev "root disk"
1656    else
1657        CopyImageToDisk $j $boot_dev "boot/root disk"
1658    fi
1659    count=1
1660    for i in `find $imagesdir | grep -F mindi-data` ; do
1661        CopyImageToDisk $i $data_dev "data disk #$count"
1662        count=$(($count+1))
1663    done
1664}
1665
1666
1667OfferToMakeBootableISO() {
1668    local i old_pwd
1669    if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1670        echo -en "Shall I make a bootable CD image? (y/[n]) "
1671        read i
1672        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1673    fi
1674    if [ ! "$MINDI_TMP" ] ; then
1675        LogIt "NB: Mindi's bootable CD always uses isolinux."
1676        LogIt "For a bootable CD w/LILO, please use Mondo."
1677    fi
1678    rm -Rf $MINDI_TMP/iso
1679    mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
1680    cp -f $1/*.img $1/*.gz $MINDI_TMP/iso/images 2>> $LOGFILE || LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
1681    old_pwd=`pwd`
1682    cd $MINDI_TMP/iso
1683    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1684    for i in memdisk memtest.bin memtest.img ; do
1685        j=$MINDI_LIB/$i
1686        k=$MINDI_TMP/iso/isolinux
1687        if [ -e "$j" ] ; then
1688            LogIt "Copying $j to $k"
1689            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1690            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1691            cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1692        fi
1693    done
1694    MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
1695    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?"
1696    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?"
1697    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
1698    cp $MINDI_TMP/mindi.rdz $MONDO_ROOT/initrd.img 2>> $LOGFILE
1699    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1700    cd $MINDI_TMP/iso/isolinux
1701    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?"
1702    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1703        mv isolinux.cfg isolinux.cfg.old
1704        sed s/interactive/iso/ isolinux.cfg.old > isolinux.cfg
1705    fi
1706    if [ "$ARCH" != "ia64" ] ; then
1707        cp $ISOLINUX isolinux.bin 2> /dev/null || Die "Cannot copy isolinux.bin ($ISOLINUX) to tmp_root - did you run out of disk space?"
1708        cp $ISOLINUX ../ 2>> $LOGFILE
1709    fi
1710    cd $MINDI_TMP/iso
1711    if [ "$ARCH" != "ia64" ] ; then
1712        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?"
1713    fi
1714    [ "$MONDO_SHARE" ] && cp -f $MONDO_SHARE/autorun .    2>> $LOGFILE
1715    if [ "$ARCH" != "ia64" ] ; then
1716        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
1717    else
1718        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
1719    fi
1720    if [ "$?" -ne "0" ] ; then
1721        echo "----------- mkisofs's errors --------------" >> $LOGFILE
1722        cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1723        echo "mkisofs returned the following errors:-"
1724        cat $MINDI_TMP/mkisofs.log
1725        LogIt "Failed to create ISO image."
1726    else
1727        echo "Created bootable ISO image at $CACHE_LOC/mindi.iso" | tee -a $LOGFILE
1728    fi
1729    rm -f $MINDI_TMP/mkisofs.log
1730    cd $old_pwd
1731}
1732
1733
1734OfferToMakeBootableUSB() {
1735    local i old_pwd
1736    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1737        echo -n "Shall I make a bootable USB image ? (y/[n]) "
1738        read i
1739        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1740        if [ "$USBDEVICE" = "" ]; then
1741            echo -en "Please enter the device name of your USB device (e.g. /dev/sda) : "
1742            read dev
1743            USBDEVICE=$dev
1744        fi
1745        echo "WARNING: This will erase all content on $USBDEVICE"
1746        echo -en "Are you sure you want to use $USBDEVICE (y/[n]) "
1747    fi
1748    if [ _"$MINDI_TMP" = _"" ]; then
1749        Die "MINDI_TMP undefined"
1750    fi
1751    rm -Rf $MINDI_TMP/usb
1752    mkdir -p $MINDI_TMP/usb
1753    USBPART="${USBDEVICE}1"
1754
1755    echo -en "Transforming $USBDEVICE in a Bootable device " 
1756    echo -en "."
1757    echo "Transforming $USBDEVICE in a Bootable device"  >> $LOGFILE
1758    echo "Checking $USBDEVICE" >> $LOGFILE
1759    $FDISK -l $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE
1760    if [ $? -ne 0 ]; then
1761        echo "Unable to access $USBDEVICE" | tee -a $LOGFILE
1762        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1763        exit -1
1764    fi
1765    echo -en "."
1766    echo "Unmounting $USBDEVICE just in case" >> $LOGFILE
1767    umount $USBPART 2>> $LOGFILE 1>> $LOGFILE
1768    echo "Erasing $USBDEVICE" >> $LOGFILE
1769    $FDISK $USBDEVICE 2>> $LOGFILE 1>> $LOGFILE << EOF
1770d
1771d
1772d
1773d
1774n
1775p
17761
1777
1778
1779t
1780b
1781a
17821
1783w
1784EOF
1785    if [ $? -ne 0 ]; then
1786        echo "Unable to create a vfat Filesystem on $USBDEVICE" | tee -a $LOGFILE
1787        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1788        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1789        MindiExit -1
1790    fi
1791    echo -en "."
1792    echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
1793    mkdosfs -F 32 $USBPART 2>&1 >> $LOGFILE
1794    if [ $? -ne 0 ]; then
1795        echo "Unable to create a vfat filesystem on $USBPART" | tee -a $LOGFILE
1796        echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" | tee -a $LOGFILE
1797        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1798        MindiExit -1
1799    fi
1800    echo -en "."
1801    echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
1802    mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1803    if [ $? -ne 0 ]; then
1804        echo "Unable to mount $USBPART on $MINDI_TMP/usb" | tee -a $LOGFILE
1805        echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" | tee -a $LOGFILE
1806        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1807        MindiExit -1
1808    fi
1809    echo -en "."
1810    mkdir -p $MINDI_TMP/usb/images
1811    cp -f $1/*.img $1/*.gz $MINDI_TMP/usb/images 2>> $LOGFILE || LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/usb/images"
1812    echo -en "."
1813    old_pwd=`pwd`
1814    cd $MINDI_TMP/usb
1815    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1816    for i in memdisk memtest.bin memtest.img ; do
1817        j=$MINDI_LIB/$i
1818        k=$MINDI_TMP/usb
1819        if [ -e "$j" ] ; then
1820            LogIt "Copying $j to $k"
1821            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1822            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1823        fi
1824    done
1825    echo -en "."
1826    MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
1827    echo -en "."
1828    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?"
1829    echo -en "."
1830    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
1831    echo -en "."
1832    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1833    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?"
1834    echo -en "."
1835    if [ "$NFS_DEV" != "" ] ; then
1836        perl -pi -e 's/interactive/iso/' syslinux.cfg
1837    fi
1838    cd $old_pwd
1839    echo -en "."
1840    umount $MINDI_TMP/usb
1841    if [ "$ARCH" != "ia64" ] ; then
1842        syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
1843        if [ "$?" -ne "0" ] ; then
1844            echo "----------- syslinux's errors --------------" |tee -a $LOGFILE
1845            cat $MINDI_TMP/syslinux.log |tee -a $LOGFILE
1846            LogIt "Failed to create USB image."
1847        else
1848            echo -e "$DONE"
1849            echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
1850        fi
1851        rm -f $MINDI_TMP/syslinux.log
1852    else
1853        echo "No USB boot support for ia64" | tee -a $LOGFILE
1854        MindiExit -1
1855    fi
1856    echo -en "."
1857}
1858
1859
1860PluralOrNot() {
1861    [ "$1" -gt "1" ] && echo -en "s"
1862}
1863
1864
1865MakeMessageFile() {
1866    local disksize
1867    disksize=$1
1868    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1869        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`"/
1870    else
1871        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`/
1872    fi
1873    if [ "$disksize" -gt "2880" ] ; then
1874        if [ _"$MONDO_SHARE" != _"" ] ; then
1875            if [ "$CDRECOVERY" != "yes" ] ; then
1876                if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1877                    echo -en "Press <enter> to continue.\n"
1878                elif [ ! "$MINDI_TMP" ] ; then
1879                    echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1880                else
1881                    echo -en "$BOOT_MEDIA_MESSAGE"
1882                fi
1883            fi
1884        fi
1885    fi
1886    if [ "$CDRECOVERY" = "yes" ] ; then
1887        echo -en "\
1888To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1889CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1890    fi
1891    echo -en "\n\n\n"
1892}
1893
1894
1895write_full_floppy_of_kernel() {
1896    local mtpt image old_pwd res disksize
1897
1898    res=0
1899    old_pwd=`pwd`
1900    KERN_DISK_MADE=1
1901    disksize=$3
1902    rand1=$RANDOM
1903    rand2=$RANDOM
1904    image=$MINDI_TMP/$rand1.$rand2.img
1905    mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
1906    dd if=/dev/zero of=$image bs=1k count=$disksize &> /dev/null
1907    mke2fs -N 26 -F $image &> /dev/null
1908    mkdir -p $mtpt
1909    mount -o loop $image $mtpt
1910    cd $mtpt
1911    mkdir -p {dev,tmp,boot}
1912    cp -f $1 vmlinuz 2>> $LOGFILE
1913    if [ "$?" -ne "0" ] ; then
1914        LogIt "Failed to copy $1 to ramdisk"
1915        cd $old_pwd
1916        umount $mtpt
1917        rmdir $mtpt
1918        rm $image
1919        return 1
1920    fi
1921
1922    rdev vmlinuz 2,0
1923    rdev -R vmlinuz 0
1924    rdev -r vmlinuz 49152
1925
1926    tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1927    # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1928    #losetup /dev/loop0 > /dev/null 2> /dev/null
1929    #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1930    CopyBootBFile $mtpt/boot.b
1931
1932    MakeLiloConfFile $disksize >> bdlilo.conf
1933
1934    chmod 644 bdlilo.conf
1935    MakeMessageFile $disksize > message
1936    lilo -v -C bdlilo.conf -r $mtpt
1937    res=$?
1938
1939    cd $old_pwd
1940    umount $mtpt
1941    mv -f $image $2
1942    rmdir $mtpt
1943
1944    return $res
1945}
1946
1947
1948MakeLiloConfFile() {
1949    local disksize options i ooo
1950    disksize=$1
1951    options=""
1952
1953    if [ "$ARCH" != "ia64" ] ; then
1954        echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1955    fi
1956    if [ "$disksize" -eq "2880" ] ; then
1957        echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
1958    elif [ "$disksize" -eq "1722" ] ; then
1959        echo -en "bios=0x00\nsectors=21\nheads=2\ncylinders=82\n"
1960    elif [ "$disksize" -gt "2880" ] ; then
1961        /bin/true
1962    else
1963        echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
1964    fi
1965    if [ "$ARCH" != "ia64" ] ; then
1966        echo -en "install=/boot.b\nmap=/boot.map\n"
1967    fi
1968    if [ "$CDRECOVERY" = "yes" ] ; then
1969        echo -en "default=RESTORE\n"
1970    elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ] ; then
1971        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1972            echo -en "default=iso\n"
1973        else
1974            echo -en "default=interactive\n"
1975        fi
1976    else
1977        echo -en "default=expert\n"
1978    fi
1979
1980    echo -en "prompt\n"
1981    if [ "$ARCH" != "ia64" ] ; then
1982        echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1983    fi
1984    if [ "$CDRECOVERY" != "yes" ] ; then
1985        echo -en "timeout=300\n"
1986    fi
1987    echo -en "\n"
1988    if [ "$CDRECOVERY" = "yes" ] ; then
1989        options="RESTORE expert"
1990    elif [ "$disksize" -gt "2880" ] ; then
1991        if [ _"$MONDO_SHARE" != _"" ] ; then
1992            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1993                options="iso"
1994            else
1995                options="interactive expert compare iso nuke isonuke"
1996# hda hdb hdc hdd"
1997            fi
1998        else
1999            options="expert"
2000        fi
2001    else
2002        options="expert"
2003    fi
2004    for i in $options ; do
2005        ooo=$i
2006        [ "$ooo" = "RESTORE" ] && ooo="nuke"
2007        if [ "$ARCH" = "ia64" ] ; then
2008            rootpart="root=/dev/ram0\n\t"
2009        else
2010            rootpart=""
2011        fi
2012        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"
2013   
2014        outstr=$outstr" $ooo_mode"
2015        outstr=$outstr"\"\n"
2016        if [ "$disksize" = "1440" ] ; then
2017            echo -en "$outstr" | sed s/initrd=.*// | grep -v root=
2018        else
2019            echo -en "$outstr"
2020        fi
2021    done
2022}
2023
2024
2025PrepareBootDiskImage_LILO() {
2026    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
2027    imagesdir=$1
2028    disksize=$2
2029    kernelpath=$3
2030    ramdisksize=$4
2031
2032    retval=0
2033    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2034    echo -en "Making "$disksize"KB boot disk..."
2035    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?"
2036    if [ "$ARCH" != "ia64" ] ; then
2037        [ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
2038    fi
2039    echo -en "..."
2040    imagefile=$imagesdir/mindi-bootroot.$disksize.img
2041    mountpoint=$MINDI_TMP/mountpoint.$$
2042    mkdir -p $mountpoint
2043    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2044    if [ "$ARCH" = "ia64" ] ; then
2045        mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
2046        t=vfat
2047    else
2048        mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
2049        t=ext2
2050    fi
2051    mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2052    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2053    mkdir -p $mountpoint/etc
2054    if [ "$ARCH" != "ia64" ] ; then
2055        liloconf=$mountpoint/etc/lilo.conf
2056    else
2057        liloconf=$mountpoint/elilo.conf
2058    fi
2059    old_pwd=`pwd`
2060    cd $mountpoint
2061    if [ "$ARCH" != "ia64" ] ; then
2062        tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
2063    fi
2064    cd $old_pwd
2065    # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
2066    #losetup /dev/loop0 > /dev/null 2> /dev/null
2067    #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary."
2068    CopyBootBFile $mountpoint/boot.b
2069
2070    MakeLiloConfFile $disksize > $liloconf
2071
2072    # Copy it so that CD-ROM menu entry is satisfied
2073    if [ "$ARCH" = "ia64" ] ; then
2074        mountefi=0
2075        df -T | grep /boot/efi | grep -q vfat
2076        if [ $? -ne 0 ]; then
2077            mount /boot/efi
2078            if [ $? -ne 0 ]; then
2079                echo "You have to mount your EFI partition when using mindi"
2080                MindiExit -1
2081            fi
2082            mountefi=1
2083        fi
2084        el=`find /boot/efi -name elilo.efi`
2085        cp $el $mountpoint
2086        cp $liloconf $mountpoint
2087        if [ $mountefi -eq 1 ]; then
2088            umount /boot/efi 2>&1 > /dev/null
2089        fi
2090    fi
2091
2092    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
2093    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
2094    if [ "$?" -ne "0" ] ; then
2095        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2096        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2097        LogIt "Please unload some of your modules and try again."
2098        rm -f $MINDI_TMP/mtpt.$$
2099        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2100        retval=$(($retval+1))
2101    fi
2102    MakeMessageFile $disksize > $mountpoint/message
2103
2104    mkdir -p $mountpoint/tmp
2105    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2106    if [ -e "$MINDI_LIB/memtest.img" ] ; then
2107        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
2108        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
2109#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
2110    fi
2111
2112    # copy the kernel across
2113    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2114    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2115    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2116    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
2117    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2118        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2119        du -sk $mountpoint/* >> $LOGFILE
2120        echo "--- end of list of files ---" >> $LOGFILE
2121        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2122Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2123        rm -f $mountpoint/vmlinuz
2124        cd $old_pwd
2125        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2126        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2127    #   losetup /dev/loop0 -d
2128        res=0
2129        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2130        res=$(($res+$?))
2131        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2132        res=$(($res+$?))
2133        rm -f $imagefile
2134        if [ "$res" -ne "0" ]; then
2135            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2136            rm -f $imagesdir/mindi-*.1440.img
2137        fi
2138        return $res
2139    fi
2140    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2141    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2142    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2143    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2144    # make it bootable
2145    rm -f $mountpoint/zero
2146    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2147    if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
2148        if [ "$ARCH" != "ia64" ] ; then
2149            $LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2150        else
2151            /bin/true
2152        fi
2153    elif [ ! "$KERN_DISK_MADE" ] ; then
2154        # 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
2155        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2156    else
2157        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
2158    fi
2159
2160    # BERLIOS  does not test necessarily what it expects
2161    if [ $? -ne "0" ] ; then
2162        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2163            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2164            LogIt "Please reboot your PC as a workaround."
2165            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2166        fi
2167        echo "$LILO_EXE -r $mountpoint ...failed."
2168        echo -en "Press ENTER to continue."; read line
2169        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2170        retval=$(($retval+1))
2171    fi
2172    cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2173    if [ "$ARCH" = "ia64" ] ; then
2174        cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2175    fi
2176    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2177    echo -en "..."
2178    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2179    if [ "$retval" -eq "0" ] ; then
2180        echo -en "...$DONE\r"
2181        if [ "$KERN_DISK_MADE" ] ; then
2182            LogIt "... $disksize KB boot disks were created OK\r"
2183        fi
2184    else
2185        echo -en "...failed\r"
2186        LogIt $disksize"KB boot disk was NOT created\r"
2187        rm -f $imagefile
2188    fi
2189    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2190    return $retval
2191}
2192
2193
2194PrepareBootDiskImage_SYSLINUX() {
2195    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2196    imagesdir=$1
2197    disksize=$2
2198    kernelpath=$3
2199    ramdisksize=$4
2200    do_boot_root_thingy=""
2201    local retval old_pwd
2202    retval=0
2203
2204    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2205    echo -en "Making "$disksize"KB boot disk..."
2206    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?"
2207    [ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
2208    echo -en "..."
2209    imagefile=$imagesdir/mindi-bootroot.$disksize.img
2210    mountpoint=$MINDI_TMP/mountpoint.$$
2211    mkdir -p $mountpoint
2212# If I format a 1722KB data file & run syslinux on it, the resultant image
2213# won't boot. So, I have formatted a floppy, called syslinux on/to it, and
2214# used 'dd' to copy it to sys-disk.raw (zipped to sys-disk.raw.gz).
2215# If I extract it, mount it, copy my files to it, etc. then the resultant
2216# image _is_ bootable. I don't know why syslinux and/or mkfs.vfat won't
2217# play nicely and I don't care. :) I have worked around the problem. -Hugo, 06/27/2002
2218    if [ "$disksize" = "1722" ] ; then
2219        gzip -dc $MINDI_LIB/sys-disk.raw.gz > $imagefile || Die "Cannot dd blank file"
2220    else
2221        dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2222        mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2223        syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2224    fi
2225    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2226
2227    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2228    old_pwd=`pwd`
2229    MakeSyslinuxMessageFile $mountpoint/message.txt
2230    cd $mountpoint
2231    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2232    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2233    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
2234        mv syslinux.cfg syslinux.cfg.orig
2235        sed s/interactive/iso/ syslinux.cfg.orig > syslinux.cfg
2236    fi
2237    cd $old_pwd
2238    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2239    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2240    if [ "$?" -ne "0" ] ; then
2241        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2242        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2243        LogIt "Please unload some of your modules and try again."
2244        rm -f $MINDI_TMP/mtpt.$$
2245        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2246        retval=$(($retval+1))
2247    fi
2248
2249    mkdir -p $mountpoint/tmp
2250    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2251
2252    # copy the kernel across
2253    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2254    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2255    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2256    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2257    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2258        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2259        du -sk $mountpoint/* >> $LOGFILE
2260        echo "--- end of list of files ---" >> $LOGFILE
2261        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2262Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2263        rm -f $mountpoint/vmlinuz
2264        cd $old_pwd
2265        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2266        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2267
2268        res=0
2269        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2270        res=$(($res+$?))
2271        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2272        res=$(($res+$?))
2273        rm -f $imagefile
2274        if [ "$res" -ne "0" ]; then
2275            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2276            rm -f $imagesdir/mindi-*.1440.img
2277        fi
2278        return $res
2279    fi
2280    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2281    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2282    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2283    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2284
2285    # make it bootable
2286    rm -f $mountpoint/zero
2287    mkdir -p $mountpoint/etc
2288    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2289    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2290    echo -en "..."
2291    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2292
2293    if [ "$retval" -eq "0" ] ; then
2294        echo -en "...$DONE\r"
2295        if [ "$KERN_DISK_MADE" ] ; then
2296            rm -f $imagefile
2297            LogIt "... $disksize KB boot disks were created OK\r"
2298        fi
2299    else
2300        echo -en "...failed\r"
2301        LogIt $disksize"KB boot disk was NOT created\r"
2302        rm -f $imagefile
2303    fi
2304    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2305    return $retval
2306}
2307
2308
2309PrepareDataDiskImages() {
2310    local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines
2311
2312    imagesdir=$1
2313    rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2314    needlist=$MINDI_TMP/what-we-need.txt
2315    bigdir=$MINDI_TMP/bigdir
2316    minidir_root=$MINDI_TMP/minidir
2317    mkdir -p $minidir_root
2318    mkdir -p $bigdir/usr/bin
2319    tardir=$MINDI_TMP/tardir
2320
2321    lines=`grep -vx " *#.*" $MINDI_CONF/deplist.txt | grep -vx "" | wc -l`
2322    cat $MINDI_CONF/deplist.txt | GenerateGiantDependencyList $needlist $lines
2323    res=$?
2324    if [ "$YOUR_KERNEL_SUCKS" ]; then
2325        pwd=`pwd`
2326        cd $MINDI_TMP
2327        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2328            cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2329            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2330                cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2331            else
2332                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2333                BIGNO=$(($BIGNO+1))
2334            fi
2335        done
2336        for i in $EXTRA_MODS ; do
2337            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o.gz 2> /dev/null`
2338            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o.gz" >> $LOGFILE
2339            for k in $j ; do
2340                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2341                    cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2342                else
2343                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2344                    BIGNO=$(($BIGNO+1))
2345                fi
2346                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2347            done
2348        done
2349        cd $pwd
2350    else
2351        ListKernelModulePaths >> $needlist
2352    fi
2353    if [ "$res" -ne "0" ] ; then
2354        Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2355    fi
2356    FindAndAddUserKeyboardMappingFile
2357    mkdir -p $bigdir/tmp
2358    if [ _"$MONDO_SHARE" != _"" ] ; then
2359        MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
2360        cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
2361    fi
2362    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2363    DropOptimizedLibraries $needlist $bigdir
2364    echo -en "Assembling dependency files"
2365    CopyDependenciesToDirectory < $needlist $bigdir
2366
2367    # also copy io.sys and msdos.sys, if we can find them
2368    for i in `mount | cut -d' ' -f3` ; do
2369        for j in io.sys msdos.sys ; do
2370            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2371        done
2372    done
2373
2374    # master boot record, too
2375    i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
2376    if [ "$i" ] ; then
2377        LogIt "Backing up $i's MBR"
2378        dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2379        sleep 1
2380        sync
2381        j=$i
2382        [ -h "$j" ] && j=`readlink -f $j`
2383        LogIt "Creating /dev/boot_device ($j)"
2384        mkdir -p $bigdir/dev
2385        cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2386    fi
2387
2388    old_pwd=`pwd`
2389    cd $bigdir
2390
2391    [ -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'."
2392    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2393    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2394        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2395    fi
2396    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2397        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2398        [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2399    fi
2400    [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2401    cd $old_pwd
2402    echo -e "$DONE"
2403    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2404    SplitDirectoryIntoMinidirs $bigdir $minidir_root
2405    noof_disks=$?
2406    [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2407#    if [ "$noof_disks" -ge "8" ] ; then
2408#        LogIt "You are putting a ludicrously large amount of data on these disks."
2409#        LogIt "I shall therefore double EXTRA_SPACE, just in case your ramdisk is too small."
2410#        EXTRA_SPACE=$(($EXTRA_SPACE*2))
2411#    fi
2412    MakeMountlist $MINDI_TMP/mountlist.txt
2413    mkdir -p $minidir_root/$noof_disks/tmp
2414    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"
2415    [ _"$MONDO_SHARE" != _"" ] && cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2416    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2417    cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2418    ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2419    CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2420    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2421    # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2422    rmdir $tardir $bigdir
2423    rm -f $needlist
2424    return $noof_disks
2425}
2426
2427
2428ProcessLDD() {
2429    local incoming f d nd bd bnd
2430    read incoming
2431    while [ "$incoming" != "" ]; do
2432        # We take the full path name of the dyn. lib. we want
2433        incoming=`echo "$incoming" | awk '{if (match($1,/\//)) {print $1} else {if (match($3,/\//)) print $3} fi}'`
2434        for f in $incoming ; do
2435            # echo modified file name if one of the parent dir is a link
2436            # by replacing the original dirname by the destination of the link
2437            d="`dirname $f`"
2438            found="false"
2439            while [ "$d" != "/" ]; do
2440                if [ -h "$d" ]; then
2441                    nd=`readlink -f $d`
2442                    bd=`basename $d`
2443                    bnd=`basename $nd`
2444                    f=`echo $f | sed "s~/$bd/~/$bnd/~"`
2445                    echo $d
2446                fi
2447                d="`dirname $d`"
2448            done
2449
2450            echo "$f"
2451            echo "`ReadAllLink $f`"
2452        done
2453        read incoming
2454    done
2455}
2456
2457
2458Prompt() {
2459    echo -en "$1"
2460    read line
2461}
2462
2463
2464ReadLine() {
2465    local i incoming
2466    read incoming
2467    i=0
2468    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2469        i=$(($i+1))
2470        read incoming
2471    done
2472    echo "$incoming"
2473}
2474
2475
2476RejigHyperlinks() {
2477    local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2478    minidir_root=$1
2479    noof_disks=$2
2480
2481    old_pwd=`pwd`
2482    diskno=1
2483    while [ "$diskno" -le "$noof_disks" ] ; do
2484        mkdir -p $minidir_root/$diskno
2485        cd $minidir_root/$diskno
2486        for fname in `find -type d -o -print` ; do
2487            [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2488        done
2489        diskno=$(($diskno+1))
2490    done
2491
2492    cd $old_pwd
2493    return
2494}
2495
2496
2497ReplaceIndividualLine() {
2498    local orig_file new_file lino newstring lines_total lines_remaining
2499
2500    orig_file=$1.orig
2501    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2502    new_file=$1
2503    lino=$2
2504    newstring="$3"
2505    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2506        echo "Can't find string" >> $LOGFILE
2507        return 1
2508    fi
2509    lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2510    lines_remaining=$(($lines_total-$lino))
2511    head -n$(($lino-1)) $orig_file > $new_file
2512    echo "$newstring" >> $new_file
2513    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2514    tail -n$lines_remaining $orig_file >> $new_file
2515    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2516    [ -x "$orig_file" ] && chmod +x $new_file
2517    rm -f $orig_file
2518    return 0
2519}
2520
2521
2522ScanCDandTape() {
2523    local i
2524
2525    for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2526        dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2527    done
2528}
2529
2530
2531SizeOfPartition() {
2532    local devpath drive res stub
2533    device=$1
2534    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2535        res=`SizeOfRaidPartition $device`
2536        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2537        echo "$res"
2538        return 0
2539    fi
2540    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2541    res=`$FDISK -s $device 2>> $LOGFILE`
2542    # end patch
2543    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2544    [ "$res" = "" ] && res="-1"
2545    echo $res
2546    return 0
2547}
2548
2549
2550SizeOfRaidPartition() {
2551    local real_dev smallest_size silly tmp
2552
2553    silly=999999999
2554    smallest_size=$silly
2555
2556    for real_dev in `GetRaidDevMembers $1` ; do
2557        tmp=`SizeOfPartition $real_dev`
2558        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2559    done
2560
2561    if [ "$smallest_size" = "$silly" ] ; then
2562        echo "-1"
2563        return 1
2564    else
2565        echo "$smallest_size"
2566        return 0
2567    fi
2568}
2569
2570
2571StripComments()
2572{
2573    local tempfile
2574
2575    tempfile=$MINDI_TMP/$$.strip.txt
2576    cp -f $1 $tempfile 2>> $LOGFILE
2577    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2578    rm -f $tempfile
2579    echo "Stripped comments from $2" >> $LOGFILE
2580}
2581
2582
2583SplitDirectoryIntoMinidirs() {
2584    local bigdir minidir_root i noof_disks old_pwd res
2585
2586    bigdir=$1
2587    minidir_root=$2
2588    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2589
2590    TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2591    noof_disks=$?
2592    if [ "$noof_disks" -eq "0" ] ; then
2593        echo "Failed to fit data into several dirs."
2594        return 0
2595    fi
2596    RejigHyperlinks $minidir_root $noof_disks
2597    [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2598    return $noof_disks
2599}
2600
2601
2602StripExecutable()
2603{
2604    local tmpfile
2605
2606    tmpfile=$MINDI_TMP/stripped.$$.dat
2607    [ -d "$1" ] || [ -h "$1" ] && return
2608    cp -f $1 $tmpfile 2>> $LOGFILE
2609    strip $tmpfile 2> /dev/null
2610    if [ "$?" -eq "0" ] ; then
2611        cp -f $tmpfile $1 2>> $LOGFILE
2612        echo "Stripped binary $2" >> $LOGFILE
2613    fi
2614    rm -f $tmpfile
2615}
2616
2617
2618TemporarilyCompressAllFiles() {
2619    local i orig_fname out_fname out_list
2620
2621    i=0
2622    out_list=$2/compressed/compressed.txt
2623    mkdir -p $2/compressed
2624    > $out_list
2625    for orig_fname in $1 ; do
2626        out_fname=$2/compressed/$orig_fname.gz
2627        mkdir -p $out_fname 2> /dev/null
2628        rmdir $out_fname 2> /dev/null
2629        gzip -c6 $orig_fname > $out_fname 2> /dev/null
2630        i=$(((($i+1))%15))
2631        [ "$i" -eq "0" ] && echo -en "."
2632        du -sk $out_fname >> $out_list
2633    done
2634}
2635
2636
2637TryToFindKernelPath() {
2638    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2639
2640    we_want_version=`uname -r`
2641    possible_kernels=""
2642    duff_kernels=""
2643   
2644    if [ "$ARCH" = "ia64" ] ; then
2645       root="/boot/efi/efi"
2646    else
2647       root="/"
2648    fi
2649    for fname in `find $root -maxdepth 2 -type f | grep -E 'lin|kern' | grep -Ev '^/proc/|^/net/'` ; do
2650        [ ! -e "$fname" ] && continue
2651        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2652        file $fname | grep -q gzip
2653        if [ "$?" -eq "0" ] ; then
2654            # Used by ia64
2655            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2656        else
2657            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2658        fi
2659        [ "$fkern_ver" = "" ] && continue
2660        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2661        [ -f "$fname" ] || continue
2662        [ -h "$fname" ] && continue
2663        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2664        file $fname | grep -q gzip
2665        if [ "$?" -eq "0" ] ; then
2666            # Used by ia64
2667            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2668                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2669                duff_kernels="$fname $duff_kernels"
2670            else
2671                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2672                possible_kernels="$fname $possible_kernels"
2673            fi
2674        else
2675            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2676                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2677                duff_kernels="$fname $duff_kernels"
2678            else
2679                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2680                possible_kernels="$fname $possible_kernels"
2681            fi
2682        fi
2683    done
2684    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2685        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2686    fi
2687    if [ ! "$possible_kernels" ] ; then
2688        LogIt "No kernel matches exactly. Are there any duff kernels?"
2689        possible_kernels="$duff_kernels"
2690        if [ ! "$possible_kernels" ] ; then
2691            LogIt "Sorry, no duff kernels either"
2692        else
2693            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2694            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2695        fi
2696    fi
2697    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2698    noof_kernels=`CountItemsIn "$possible_kernels"`
2699    if [ "$noof_kernels" -eq "0" ] ; then
2700        LogIt "Could not find your kernel."
2701        if [ -e "/boot/vmlinuz" ] ; then
2702            LogIt "Using /boot/vmlinuz as a last resort."
2703            output=/boot/vmlinuz
2704        else
2705            output=""
2706        fi
2707    elif [ "$noof_kernels" -eq "1" ] ; then
2708        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2709        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2710        output="$kernelpath"
2711    else
2712        for i in $possible_kernels ; do
2713            if echo $i | grep "`uname -r`" ; then
2714                LogIt "OK, I used my initiative and found that "
2715                LogIt "$i is probably your kernel. "
2716                output="$i"
2717                return
2718            fi
2719        done
2720        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2721            output=/boot/vmlinuz
2722            echo "Schlomo, this one's for you." >> $LOGFILE
2723        else
2724            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2725            LogIt "boot disks will still work, probably. If one does not work, try another."
2726            LogIt "$possible_kernels"
2727            echo ""
2728        fi
2729    fi
2730    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2731}
2732
2733
2734TryToFitDataIntoSeveralDirs() {
2735    local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2736    local i retval noof_disks total_files list_of_devs
2737
2738    bigdir=$1
2739    minidir_root=$2
2740    BIG_CLUNKY_SIZE_COUNTER=0
2741    retval=0
2742    noof_disks=1
2743
2744    echo -en "\r                                                                            \rDividing data into several groups..."
2745    old_pwd=`pwd`
2746    cd $bigdir
2747    list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2748    progress=0
2749    total_files=`CountItemsIn "$list_of_files"`
2750    if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2751        filesize=1
2752    fi
2753    mkdir -p $minidir_root/$noof_disks
2754    if [ -e "dev" ] ; then
2755        echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2756        cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2757    fi
2758    TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2759    for filename in $list_of_files ; do
2760        AddFileToDir $filename $minidir_root $noof_disks
2761        i=$?
2762        if [ "$i" -gt "$noof_disks" ] ; then
2763            noof_disks=$i
2764            echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2765        fi
2766        if [ "$i" -eq "0" ] ; then
2767            LogIt "Cannot add file $filename to minidir $minidir_root"
2768            retval=$(($retval+1))
2769        fi
2770        progress=$(($progress+1))
2771        echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2772    done
2773    cd $old_pwd
2774    echo -en "\rThe files have been subdivided into $noof_disks directories.                                                            \r"
2775    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2776    if [ "$retval" -gt "0" ] ; then
2777        return 0
2778    else
2779        return $noof_disks
2780    fi
2781}
2782
2783
2784TurnTgzIntoRdz() {
2785    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
2786
2787    tgz_dir_fname=$1
2788    rdz_fname=$2
2789    ramdisksize=$3
2790    disksize=$4
2791    kernelsize=$5
2792    maxsize=$(($disksize-$kernelsize))
2793    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2794    tempfile=$MINDI_TMP/temp.rd
2795    mountpoint=$MINDI_TMP/mnt1
2796    res=0
2797    echo -en "..."
2798    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2799    echo -en "..."
2800    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2801    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE || Die "Unable to create an ext2 file system on $tempfile"
2802    echo -en "..."
2803    mkdir -p $mountpoint
2804    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."
2805    echo -en "..."
2806    old_pwd=`pwd`
2807    cd $mountpoint
2808    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2809    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2810    cd dev || Die "Can't cd to dev"
2811    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2812    rm -f dev-entries.tgz
2813    cd ..
2814
2815    for w in insmod.static insmod.static.old ; do
2816        s=`which $w 2> /dev/null`
2817        if [ -e "$s" ] ; then
2818            cp --parents -af $s . 2>> $LOGFILE
2819        fi
2820    done
2821
2822    mkdir -p tmp
2823    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2824
2825    # Handle the case where busybox is dynamically linked
2826    # Should be done first so that if /lib64 is a link, it's
2827    # created first like that, instead of as a real dir later on
2828    file $MINDI_LIB/rootfs/bin/busybox 2>&1 | grep -q "dynamically" 
2829    if [ $? -eq 0 ]; then
2830        LocateDeps $MINDI_LIB/rootfs/bin/busybox > $MINDI_TMP/busy.lis
2831        cp --parents -Rdf `sort -u $MINDI_TMP/busy.lis` .
2832        rm -f $MINDI_TMP/busy.lis
2833    fi
2834
2835    # Management of udev (which includes modprobe in rules)
2836    ps auxww | grep -v grep | grep -qw udevd
2837    if [ $? -eq 0 ]; then
2838        echo "udev device manager found" > tmp/USE-UDEV
2839        LogIt "udev device manager found"
2840        cp --parents -Rdf /etc/udev . 2> /dev/null
2841        # This avoids NIC remapping if on another machine at restore time on Debian at least
2842        rm -f ./etc/udev/rules.d/z25_persistent-net.rules
2843        cp --parents -Rdf /lib/udev /lib64/udev . 2> /dev/null
2844        if [ -x /sbin/udevd ]; then
2845            lis2=`grep -Ev '^#' $MINDI_CONF/udev.files` 
2846            lis=""
2847            # Get only the files which exist in that list
2848            # and potentially their symlink structure
2849            for i in $lis2; do
2850                if [ -h $i ]; then
2851                    j=$i
2852                    while [ -h $j ]; do
2853                        lis="$lis $j"
2854                        j=`readlink $j`
2855                    done
2856                    lis="$lis $j"
2857                elif [ -f $i ]; then
2858                    lis="$lis $i"
2859                fi
2860            done
2861            # And their deps
2862            LocateDeps $lis > $MINDI_TMP/udev.lis
2863            for i in $lis; do
2864                if [ "`echo $i | cut -c1`" = "/" ]; then
2865                    j=`echo $i | cut -c2-`
2866                    rm -f $j
2867                fi
2868            done
2869            cp --parents -Rdf $lis `sort -u $MINDI_TMP/udev.lis` .
2870            rm -f $MINDI_TMP/udev.lis
2871        else
2872            echo "udevd daemon not in standard place (/sbin)" 2>&1 | tee -a $LOGFILE
2873            echo "mindi will use static devices which may cause problems" 2>&1 | tee -a $LOGFILE
2874            rm -f tmp/USE-UDEV
2875        fi
2876    fi
2877
2878    # Management of potential HW info (Proliant only at the moment)
2879    rm -rf $CACHE_LOC/bkphw
2880    mindi-bkphw $CACHE_LOC $MINDI_CONF | tee -a $LOGFILE
2881    if [ -d $CACHE_LOC/bkphw ]; then
2882        LogIt "Hardware Information found and saved ..."
2883        cp -rp $CACHE_LOC/bkphw .
2884        if [ -f $CACHE_LOC/tools.files ]; then
2885            lis=`grep -Ev '^#' $CACHE_LOC/tools.files` 
2886            LocateDeps $lis > $MINDI_TMP/tools.lis
2887            cp --parents -Rdf $lis `sort -u $MINDI_TMP/tools.lis` .
2888        fi
2889        if [ -f $CACHE_LOC/mindi-rsthw ]; then
2890            mv -f $CACHE_LOC/mindi-rsthw .
2891            chmod 755 ./mindi-rsthw
2892        fi
2893        rm -f $MINDI_TMP/tools.lis $CACHE_LOC/tools.files
2894    fi
2895
2896    for w in cdrom floppy groovy-stuff ; do
2897        mkdir -p mnt/$w
2898    done
2899    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2900        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2901    #fi
2902    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2903        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2904    fi
2905
2906    cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2907
2908    cd $old_pwd
2909    echo -en "..."
2910    MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2911    echo -en "..."
2912    old_pwd=`pwd`
2913    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2914        cd $MINDI_TMP
2915        floppy_modules_path=lib/modules/$FAILSAFE_KVER
2916    else
2917        cd /
2918###
2919### Sq-Modification... Use kernel name in module path if specified.
2920###
2921        #floppy_modules_path=lib/modules/`uname -r`
2922        if [ "${kernelname}" != "" ]
2923        then
2924            floppy_modules_path=lib/modules/${kernelname}
2925        else
2926            floppy_modules_path=lib/modules/`uname -r`
2927        fi
2928###
2929### Sq-Modification end
2930###
2931    fi
2932    floppy_modules=""
2933    if [ "$disksize" -lt "2880" ] ; then
2934        list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2935    else
2936        list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2937    fi
2938    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
2939        # For PXE boot
2940        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2941    fi
2942    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
2943        list_of_groovy_mods="$list_of_groovy_mods $EXTRA_MODS"
2944    fi
2945    for i in $DENY_MODS; do
2946        echo "Removing $i from the list of modules to load" >> $LOGFILE
2947        list_of_groovy_mods=`echo ${list_of_groovy_mods} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
2948    done
2949
2950    [ -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."
2951    for i in $list_of_groovy_mods ; do
2952        floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2953    done
2954    for i in $floppy_modules ; do
2955        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2956        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2957        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2958        cp --parents -pdf $i $mountpoint 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2959        # Uncompress modules if not useing udev and native modprobe
2960        if [ ! -f $mountpoint/tmp/USE-UDEV ]; then
2961            if [ "`echo "$i" | grep -F ".gz"`" ]; then
2962                gunzip -f $mountpoint/$i
2963                #i=`echo $i | sed 's/.gz//'`
2964            fi
2965        fi
2966    done
2967
2968    # Also copy modules.dep in case of udev so that normal modprobe works
2969    cp --parents -pdf /$floppy_modules_path/modules.dep $mountpoint 2>/dev/null || LogIt "Unable to copy modules.dep to $mountpoint"
2970
2971    # For all modules supported, create symlinks under the mountpoint
2972    for i in $EXTRA_MODS $NET_MODS $SCSI_MODS; do 
2973        all_modules="$all_modules `FindSpecificModuleInPath $mountpoint $i | sed 's~^$mountpoint/~~g'`"
2974    done
2975    for i in $all_modules; do
2976        (cd $mountpoint ; ln -s $i . 2>/dev/null)
2977    done
2978    if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2979        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2980        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2981        [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2982        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2983        rm -f $mountpoint/sbin/devfsd
2984    fi
2985    cd $old_pwd
2986    [ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2987    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2988    rm -f $mountpoint/zero
2989    if [ _"$MONDO_SHARE" != _"" ] ; then
2990        MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
2991        cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
2992        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2993        echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
2994        echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
2995        [ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
2996        [ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
2997        [ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
2998        [ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
2999    fi
3000    mkdir -p $mountpoint/tmp
3001    mkdir -p $mountpoint/proc
3002    echo "$disksize" > $mountpoint/tmp/$disksize.siz
3003    find $mountpoint -name CVS -exec rm -rf '{}' \;
3004    # Determine what filesystem to use for initrd image
3005    echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
3006    gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
3007    [ -z  gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
3008    case "$gvFileSystem" in
3009    "ext2fs")
3010        # say what will be used
3011        echo "Creating an ext2 initrd image..." >> $LOGFILE
3012        # kernel expects linuxrc in ext2 filesystem
3013        ( cd $mountpoint && ln -sf sbin/init linuxrc )
3014        # unmount loop filesystem and create image file using the standard approach
3015        umount $mountpoint || Die "Cannot unmount $tempfile"
3016        dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
3017        bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2 | sed 's/^ *//'`
3018        ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
3019        gzip -c9 ${rdz_fname}.tmp > $rdz_fname
3020        rm -f ${rdz_fname}.tmp
3021        # log that we are done
3022        echo "...done." >> $LOGFILE
3023    ;;
3024    "initramfs")
3025        # say what will be used
3026        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
3027        # make sure that cpio is there
3028        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
3029        # go into filesystem
3030        cd $mountpoint
3031        # kernel expects init in cpio filesystem
3032        ln -sf sbin/init init
3033        # create cpio image file and unmount loop filesystem
3034        find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
3035        cd $old_pwd
3036        umount $mountpoint || Die "Cannot unmount $tempfile"
3037        # log that we are done
3038        echo "...done." >> $LOGFILE
3039    ;;
3040    *)
3041        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
3042    ;;
3043    esac
3044    if [ "$res" -eq "0" ] ; then
3045        echo -en "..."
3046    else
3047        echo -en "\rMade an rdz WITH ERRORS.           \n"
3048    fi
3049    return 0
3050}
3051
3052
3053WhichOfTheseModulesAreLoaded() {
3054    local modname loaded_modules
3055    loaded_modules="$MODULES"
3056    for modname in $1 ; do
3057        [ "`echo "$loaded_modules" | grep -w "$modname"`" ] && echo "$modname"
3058    done
3059}
3060
3061
3062ZipMinidirsIntoTarballs() {
3063    local minidir_root tardir noof_disks diskno old_pwd i
3064    minidir_root=$1
3065    tardir=$2
3066    noof_disks=$3
3067
3068    echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
3069    mkdir -p $tardir
3070    mkdir -p $minidir_root/all
3071    old_pwd=`pwd`
3072    diskno=1
3073    while [ "$diskno" -le "$noof_disks" ] ; do
3074        cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
3075        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."
3076        diskno=$(($diskno+1))
3077        echo -n "..."
3078        cp -pRdf * $minidir_root/all 2>> $LOGFILE
3079    done
3080    mkdir -p $minidir_root/all/tmp
3081    cd $minidir_root/all
3082    size_of_all_tools=`du -sk . | cut -f1`
3083    if [ _"$MONDO_SHARE" != _"" ]; then
3084        for q in filelist.full.gz biggielist.txt ; do
3085            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
3086            cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
3087        done
3088        mkdir -p $minidir_root/all/tmp
3089        echo -en "$FILES_IN_FILELIST" > $minidir_root/all/tmp/FILES-IN-FILELIST 2> /dev/null
3090        echo -en "$LAST_FILELIST_NUMBER" > $minidir_root/all/tmp/LAST-FILELIST-NUMBER 2> /dev/null
3091    fi
3092    tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
3093    dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
3094    [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
3095    cd $old_pwd
3096    [ "$minidir_root" != "" ] && rm -Rf $minidir_root
3097    echo -e "$DONE"
3098}
3099
3100
3101##############################################################################
3102#----------------------------------- Main -----------------------------------#
3103##############################################################################
3104
3105
3106> $LOGFILE
3107echo "mindi v$MINDI_VERSION" >> $LOGFILE
3108echo "$ARCH architecture detected" >> $LOGFILE
3109echo "mindi called with the following arguments:" >> $LOGFILE
3110echo "$@" >> $LOGFILE
3111echo "Start date : `date`" >> $LOGFILE
3112echo "-----------------------------" >> $LOGFILE
3113
3114if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
3115    LogIt "WARNING - Ancient distro detected." 1
3116    ln -sf /etc/conf.modules /etc/modules.conf
3117fi
3118[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
3119
3120# Log some capital variables
3121[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
3122echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
3123echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
3124[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
3125echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
3126echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
3127
3128trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
3129
3130# Sanity checks
3131which which > /dev/null 2> /dev/null || Die "Please install 'which'."
3132which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
3133which 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."
3134which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
3135if which awk &> /dev/null ; then
3136    if ! which gawk &> /dev/null ; then
3137        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"
3138    fi
3139fi
3140which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
3141[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
3142
3143[ "`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"
3144# If we have a 2.6 kernel, the system uses module-init-tools which means that we
3145# may have the modprobe configuration spread out across multiple files in
3146# directory /etc/modprobe.d. If this is the case we concatenate these files into
3147# a temporary file for further processing. Otherwise we continue in the standard
3148# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
3149# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
3150# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
3151if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
3152    TMPMODPROBE_FLAG="Y"
3153else
3154    TMPMODPROBE_FLAG="N"
3155    [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
3156    [ ! -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..."
3157fi
3158
3159# Update the PATH variable if incomplete
3160if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
3161    PATH=$PATH:/sbin:/usr/sbin
3162    export PATH
3163    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
3164    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
3165    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
3166fi
3167
3168[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
3169
3170if ! which mkfs.vfat 1> /dev/null 2> /dev/null ; then
3171    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
3172fi
3173
3174### BERLIOS
3175### Fix as it's not mandatory on ia64
3176if [ "$ARCH" = "ia64" ] ; then
3177    if which elilo &> /dev/null ; then
3178        LILO_EXE=elilo
3179    else
3180        LILO_EXE=`which false`
3181    fi
3182else
3183    FindIsolinuxBinary
3184    FindLiloBinary
3185fi
3186# BERLIOS: Remove as too dangerous and now useless
3187#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
3188trap "Aborted" SIGTERM
3189DONE="\r\t\t\t\t\t\t\t\tDone.         "
3190CHOPSIZE=240
3191BIGNO=0
3192MAX_COMPRESSED_SIZE=1300
3193kernelpath=""
3194MONDO_ROOT=/var/cache/mondo
3195mkdir -p $MONDO_ROOT
3196
3197if [ -d "/proc/lvm" ]; then
3198    # LVM v1
3199    LVMCMD=""
3200    LVM="v1"
3201elif [ -d "/dev/mapper" ]; then
3202    # LVM v2
3203    LVMCMD="lvm"
3204    LVM="v2"
3205else
3206    LVM="false"
3207fi
3208echo "LVM set to $LVM" >> $LOGFILE
3209echo "----------" >> $LOGFILE
3210echo "mount result:" >> $LOGFILE
3211echo "-------------" >> $LOGFILE
3212mount >> $LOGFILE
3213echo "-------------" >> $LOGFILE
3214if [ -e /etc/raidtab ]; then
3215    echo "-------------" >> $LOGFILE
3216    echo "/etc/raidtab content:" >> $LOGFILE
3217    echo "-------------" >> $LOGFILE
3218    cat /etc/raidtab >> $LOGFILE
3219fi
3220echo "-------------" >> $LOGFILE
3221echo "cat /proc/cmdline:" >> $LOGFILE
3222echo "-------------" >> $LOGFILE
3223cat /proc/cmdline >> $LOGFILE
3224echo "-------------" >> $LOGFILE
3225echo "lsmod result:" >> $LOGFILE
3226echo "-------------" >> $LOGFILE
3227lsmod >> $LOGFILE
3228MODULES="`cat /proc/modules | awk '{print $1}'`"
3229if [ -x /usr/sbin/esxcfg-module ]; then
3230    echo "-------------" >> $LOGFILE
3231    echo "VMWare ESX server detected - Enabling dedicated support" >> $LOGFILE
3232    echo "-------------" >> $LOGFILE
3233    echo "VMWare modules" >> $LOGFILE
3234    echo "-------------" >> $LOGFILE
3235    /usr/sbin/esxcfg-module -l >> $LOGFILE
3236    MODULES="$MODULES `/usr/sbin/esxcfg-module -l | awk '{print $1}'`"
3237fi
3238echo "FORCE_MODS:" >> $LOGFILE
3239echo "-------------" >> $LOGFILE
3240echo $FORCE_MODS >> $LOGFILE
3241echo "DENY_MODS:" >> $LOGFILE
3242echo "-------------" >> $LOGFILE
3243echo $DENY_MODS >> $LOGFILE
3244echo "-------------" >> $LOGFILE
3245echo "df result:" >> $LOGFILE
3246echo "----------" >> $LOGFILE
3247df -T >> $LOGFILE
3248echo "-------------" >> $LOGFILE
3249echo "Liste of extra modules is:" >> $LOGFILE
3250echo "$EXTRA_MODS" >> $LOGFILE
3251echo "-------------" >> $LOGFILE
3252
3253# Compute libata version
3254laver=`modinfo libata | grep -Ei '^Version:' | cut -d: -f2 | cut -d. -f1 | sed 's/  *//g' 2> /dev/null`
3255# If libata v2 is used then remove ide-generic as it will perturbate boot
3256if [ "`echo $MODULES | grep libata`" ]; then
3257    if [ "$laver" = "2" ]; then
3258        DENY_MODS="$DENY_MODS ide-generic"
3259        echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
3260        echo "-------------" >> $LOGFILE
3261    fi
3262fi
3263
3264if [ "$#" -ge "2" ] ; then
3265    if [ "$1" = "--max-compressed-size" ] ; then
3266        MAX_COMPRESSED_SIZE=$2
3267        shift; shift
3268    fi
3269fi
3270
3271FLOPPY_WAS_MOUNTED=""
3272for mtpt in /media/floppy /mnt/floppy /floppy ; do
3273    if mount | grep -w $mtpt &> /dev/null ; then
3274        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3275        umount $mtpt
3276    fi
3277done
3278
3279#
3280# If we have a USB device we need to store info
3281# and remove it from the parameters line
3282#
3283if [ "$#" -ne "0" ] ; then
3284    if [ "$1" = "--usb" ] ; then
3285        shift
3286        USBDEVICE=$1
3287        if [ _"$USBDEVICE" = _"" ]; then
3288            Die "No USB device specified"
3289        fi
3290        shift
3291    fi
3292fi
3293
3294if [ "$#" -ne "0" ] ; then
3295    if [ "$1" = "--findkernel" ] ; then
3296        res=`TryToFindKernelPath`
3297        # Avoids logfile content for mondo
3298        export MONDO_SHARE=""
3299        if [ "$res" = "" ] ; then
3300            MindiExit -1
3301        else
3302            echo "$res"
3303            MindiExit 0
3304        fi
3305    elif [ "$1" = "--locatedeps" ] ; then
3306        [ ! "$2" ] && Die "Please specify the binary to look at"
3307        LocateDeps $2
3308        # Avoids logfile content for mondo
3309        export MONDO_SHARE=""
3310        MindiExit $?
3311    elif [ "$1" = "--readalllink" ] ; then
3312        [ ! "$2" ] && Die "Please specify the binary to look at"
3313        ReadAllLink $2
3314        # Avoids logfile content for mondo
3315        export MONDO_SHARE=""
3316        MindiExit $?
3317    elif [ "$1" = "--makemountlist" ] ; then
3318        [ ! "$2" ] && Die "Please specify the output file"
3319        MakeMountlist $2
3320        # Avoids logfile content for mondo
3321        export MONDO_SHARE=""
3322        MindiExit $?
3323    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3324        echo "Mindi v$MINDI_VERSION"
3325        # Avoids logfile content for mondo
3326        export MONDO_SHARE=""
3327        MindiExit 0
3328    elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
3329        MONDO_TMP=$2
3330        # Change MINDI_TMP for the one provided by mondo
3331        # So that it can get back the built files
3332        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3333        rmdir $MINDI_TMP
3334        export MINDI_TMP=$MONDO_TMP
3335        mkdir -p $MINDI_TMP
3336        # This is the scratch dir in mondo - subdir images
3337        CACHE_LOC=$3
3338        if [ _"$CACHE_LOC" != _"" ]; then
3339            mkdir -p $CACHE_LOC
3340        fi
3341        kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
3342###
3343### Sq-Modification...
3344### Attempt to locate kernel specific module path
3345### if module path is found then use it other wise use uname -r to set it...
3346###
3347        kernelname=`echo $kernelpath | cut -d'-' -f2-`
3348        LogIt "kernelname = $kernelname"
3349        LogIt "kernelpath = $kernelpath"
3350        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3351        then
3352           LogIt "Module path for ${kernelpath} not found..."
3353           LogIt "using running kernel\'s modules."
3354           kernelname=`uname -r`
3355        else
3356           LogIt "Using modules for kernel: ${kernelname}"
3357        fi
3358###
3359### end of Sq-Modification
3360###
3361        TAPEDEV=$5
3362        TAPESIZE=$6
3363        FILES_IN_FILELIST=$7
3364        USE_LZO=$8
3365        CDRECOVERY=$9
3366        if [ "${10}" = "(null)" ] || [ "${10}" = "" ] ; then
3367            IMAGE_DEVS=""
3368        else
3369            IMAGE_DEVS="`echo "${10}" | tr '|' ' '`"
3370        fi
3371        if [ "${11}" ] ; then
3372            LILO_OPTIONS=""
3373    #       LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
3374        fi
3375        LAST_FILELIST_NUMBER=${12}
3376        ESTIMATED_TOTAL_NOOF_SLICES=${13}
3377        EXCLUDE_DEVS="${14}"
3378        USE_COMP="${15}"
3379        USE_LILO="${16}"
3380        USE_STAR="${17}"
3381        INTERNAL_TAPE_BLOCK_SIZE="${18}"
3382        DIFFERENTIAL="${19}"
3383        USE_GZIP="${20}"
3384        NOT_BOOT="${21}"
3385        [ "$USE_COMP" = "" ] && USE_COMP=yes
3386        [ "$USE_GZIP" = "" ] && USE_GZIP=no
3387        [ "$NOT_BOOT" = "" ] && NOT_BOOT=no
3388        [ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
3389        [ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
3390        kernelname=`echo $kernelpath | cut -d'-' -f2-`
3391        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3392        then
3393           LogIt "Module path for ${kernelpath} not found..."
3394           LogIt "using running kernel\'s modules."
3395           kernelname=`uname -r`
3396        else
3397           LogIt "Using modules for kernel: ${kernelname}"
3398        fi
3399        [ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3400        # MONDO_ROOT is the real scratchdir
3401        MONDO_ROOT=`echo $CACHE_LOC | sed 's/\(.*\)\/.*/\1/'`
3402        if [ _"$MONDO_ROOT" != _"" ]; then
3403            mkdir -p $MONDO_ROOT
3404        else
3405            Die "MONDO_ROOT is undefined"
3406        fi
3407    else
3408        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3409        MindiExit -1
3410    fi
3411fi
3412#ScanCDandTape
3413[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3414if [ "$CDRECOVERY" = "yes" ] ; then
3415    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3416    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3417else
3418    iso_cfg_file=$MINDI_LIB/isolinux.cfg
3419    sys_cfg_file=$MINDI_LIB/syslinux.cfg
3420fi
3421
3422[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3423if [ _"$MONDO_SHARE" = _"" ]; then
3424    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3425    LogIt "Latest Mindi is available from http://www.mondorescue.org"
3426    LogIt "BusyBox sources are available from http://www.busybox.net"
3427    LogIt "------------------------------------------------------------------------------"
3428else
3429    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3430fi
3431if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3432    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3433else
3434    LogIt "Unable to find mindi-busybox, please install it"
3435    MindiExit -1
3436fi
3437
3438# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3439insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3440for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3441    insmod $i >> $LOGFILE 2>> $LOGFILE
3442done
3443
3444KERN_DISK_MADE=""
3445
3446echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
3447echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
3448echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
3449if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
3450    LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
3451    MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
3452    MakeMountlist $MINDI_TMP/mountlist.txt
3453    mkdir -p $MINDI_TMP/small-all/tmp
3454    cd $MINDI_TMP/small-all
3455    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"
3456    tar -cv tmp | gzip -9 > $MINDI_TMP/all.tar.gz || Die "Cannot make small all.tar.gz"
3457    sleep 2
3458    LogIt "Done. Exiting."
3459    MindiExit 0
3460fi
3461
3462if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3463    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3464fi
3465
3466if [ "$kernelpath" = "" ] ; then
3467    [ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
3468    echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3469    read ch
3470    if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3471        USE_OWN_KERNEL="yes"
3472    else
3473        USE_OWN_KERNEL="no"
3474    fi
3475    if [ "$USE_OWN_KERNEL" = "yes" ]; then
3476        YOUR_KERNEL_SUCKS=""
3477        kernelpath=`TryToFindKernelPath`
3478        if [ "$kernelpath" = "" ] ; then
3479            echo -n "Please enter kernel path : "
3480            read kernelpath
3481        fi
3482    else
3483        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3484    fi
3485fi
3486if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
3487    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3488    read ch
3489    if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
3490        USE_LILO=no
3491    else
3492        USE_LILO=yes
3493    fi
3494fi
3495if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3496    kernelpath=$MINDI_LIB/vmlinuz
3497    LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3498    LogIt "However, you are still running your kernel. If Mindi fails to create your"
3499    LogIt "disks then it may still be a result of a problem with your kernel."
3500    pwd=`pwd`
3501    cd $MINDI_TMP
3502    bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3503    cd $pwd
3504    YOUR_KERNEL_SUCKS="Your kernel sucks"
3505fi
3506echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
3507[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3508
3509[ "$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."
3510
3511PrepareDataDiskImages $CACHE_LOC
3512noof_disks=$?
3513ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3514rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3515ramdisk_size=$rds
3516
3517echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3518if [ "$ARCH" = "ia64" ] ; then
3519    PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3520else
3521    if [ "$USE_LILO" = "yes" ] ; then
3522        if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
3523            LogIt "WARNING - failed to create 1.72MB boot image."
3524            LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
3525        fi
3526        if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ;  then
3527            LogIt "WARNING - failed to create 2.88MB floppy disk image."
3528            LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3529            PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3530        fi
3531    else
3532        if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
3533            LogIt "WARNING - failed to create 1.72MB boot image."
3534            LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
3535            if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
3536                LogIt "WARNING - failed to create 2.88MB floppy disk image."
3537                LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3538                PrepareBootDiskImage_SYSLINUX $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE kB floppy disk image."
3539            fi
3540        fi
3541    fi
3542fi
3543
3544[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3545...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3546
3547if [ _"$MONDO_SHARE" = _"" ]; then
3548    ListImagesForUser $CACHE_LOC
3549    boot_dev=/dev/fd0u1722
3550    [ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
3551    [ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
3552    [ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
3553    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3554        OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
3555    fi
3556    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3557        OfferToMakeBootableUSB $CACHE_LOC
3558    fi
3559    OfferToMakeBootableISO $CACHE_LOC
3560    LogIt "Finished."
3561elif [ "$TAPEDEV" ] ; then
3562    OfferToMakeBootableISO $CACHE_LOC
3563    if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
3564        cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3565    else
3566        Die "Cannot find all.tar.gz, to be written to tape"
3567    fi
3568elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3569    OfferToMakeBootableUSB $CACHE_LOC
3570else
3571    OfferToMakeBootableISO $CACHE_LOC
3572fi
3573# cleanup
3574LogIt "$FRIENDLY_OUTSTRING"
3575for mtpt in $FLOPPY_WAS_MOUNTED ; do
3576    mount $mtpt
3577done
3578MindiExit 0
Note: See TracBrowser for help on using the repository browser.