source: branches/stable/mindi/mindi @ 1312

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

Suppress losetup usage in start-nfs (unreliable and doesn't work with QEMU)

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