source: branches/stable/mindi/mindi @ 998

Last change on this file since 998 was 998, checked in by Bruno Cornec, 14 years ago

Attempt to solve #113

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