source: branches/2.2.2/mindi/mindi @ 1298

Last change on this file since 1298 was 1298, checked in by bruno, 12 years ago

NFS needs the fscache module on FC6 (at least)

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