source: MondoRescue/branches/2.2.5/mindi/mindi @ 1694

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

umount the USB partition before attempting to use it

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