source: branches/2.2.5/mindi/mindi @ 1698

Last change on this file since 1698 was 1698, checked in by Bruno Cornec, 13 years ago

Add USB support at restore time (no test done yet). New start-usb script
PB varibale added where useful

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