source: trunk/mindi/mindi @ 1041

Last change on this file since 1041 was 979, checked in by bruno, 13 years ago

merge -r954:978 $SVN_M/branches/stable

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