source: branches/stable/mindi/mindi @ 1177

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

New configuration option for mindi mindi_deny_mods which allows to specify a list of modules loaded which should NOT go on the boot media made by mindi (Allows HP OCMP with HW cards support)

  • Property svn:keywords set to Rev Id
File size: 112.9 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1177 2007-02-16 18:20:04Z 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
85IA64_BOOT_SIZE=$mindi_ia64_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"
112
113BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
114FDISK=$MINDI_SBIN/parted2fdisk
115MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
116
117# ----------------------------------------------------------------------------
118
119
120AbortHere() {
121    [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
122    Die "Program is terminating in response to signal received from OS/user"
123}
124
125
126HackSyslinuxFile() {
127    local incoming
128    incoming=`ReadLine`
129    while [ "$incoming" ] ; do
130        echo -en "$incoming" | sed s/24000/$1/
131        if [ "`echo "$incoming" | grep append`" ] ; then
132            echo -en " $ADDITIONAL_BOOT_PARAMS"
133        fi
134        echo -en "\n"
135        incoming=`ReadLine`
136    done
137    if [ -e "$MINDI_LIB/memtest.img" ] ; then
138        echo -en "label memtest\n  kernel memdisk\n  append initrd=memtest.img\n\n"
139    fi
140}
141
142
143Aborted() {
144    trap SIGHUP SIGTERM SIGTRAP SIGINT
145    [ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindi*img $MINDI_CACHE/*gz $MINDI_CACHE/mindi.iso
146    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
147    Die "User abort."
148}
149
150
151AddFileToDir() {
152    local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
153    filename=$1
154    minidir_root=$2
155    noof_disks=$3
156
157    diskno=$noof_disks
158    mkdir -p $minidir_root/$diskno
159    [ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
160    if [ ! -e "$filename" ] ; then
161        if [ -h "$filename" ] ; then
162            cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
163            return $noof_disks
164        else
165            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?"
166        fi
167    fi
168
169    # move to the disk that has room on it (or end up using the last, if all full)
170    while [ "$diskno" -lt "40" ] ; do
171        mkdir -p $minidir_root/$diskno
172        filesize=`du -sk $filename | cut -f1`
173        cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
174        if [ "$filesize" -le "4" ] ; then
175            siz=$filesize
176        elif [ ! -f "$filename" ] ; then
177            siz=0
178        else
179            siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt | cut -f1`
180            [ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
181            siz=$(($siz-2));# to allow for sectors & the fact that they round up
182        fi
183        [ ! "$siz" ] && siz=4
184        [ "$siz" -lt "0" ] && siz=0
185        LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
186        [ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
187        echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
188        LAST_COMPRESSED_SIZE=0
189        rm -f $minidir_root/$diskno/$filename
190        diskno=$(($diskno+1))
191    done
192    return 0 ; # failed
193}
194
195
196AddKeyboardMappingFile() {
197    local mappath r included_list included_item i res ii sss
198    mappath=$1
199    KBDEPTH=$(($KBDEPTH+1))
200    [ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
201    if [ -e "$bigdir/$mappath" ] ; then
202        echo "$mappath already added" >> $LOGFILE
203        return
204    elif [ -d "$bigdir/$mappath" ] ; then
205        echo "Cannot add $mappath: it's a directory. Sorry."
206        return
207    fi
208    echo "Added kbd map $mappath" >> $LOGFILE
209    if [ ! -e "$mappath" ] ; then
210            mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
211        if [ ! -e "$mappath" ] ; then
212            LogIt "Cannot add $mappath: kbd map file not found"
213            return
214        fi
215    else
216        echo -en "`basename $mappath | tr '.' '#' | sed s/#kmap#gz// | sed s/#inc#gz//` " | tr '#' '.'
217    fi
218
219    mkdir -p $bigdir/etc
220    cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE || LogIt "AKMF -- Could not copy $mappath to $bigdir"
221    if [ "`echo $mappath | grep -F ".gz"`" ] ; then
222        included_list=`gzip -dc $mappath | grep -Fi include | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
223    else
224        included_list=`grep -Fi include $mappath | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
225    fi
226    for included_item in $included_list ; do
227        if [ ! -e "$included_item" ] ; then
228                sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
229            [ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
230            for ii in $sss ; do
231                [ -e "$ii" ] && AddKeyboardMappingFile $ii
232            done
233        else
234            AddKeyboardMappingFile $included_item
235        fi
236    done
237}
238
239
240ChopUpAndCopyFile() {
241    local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
242    filename=$1
243    outdir=$2
244    slicesize=$3
245    biggienumber=$4
246
247    [ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
248    mkdir -p $outdir
249
250    sliceno=0
251    scratchfile=$MINDI_TMP/blah.$$.dat
252    cp -f $filename $scratchfile 2>> $LOGFILE || Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
253    [ "`head $scratchfile -n1 | grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
254    [ "`echo "$filename" | grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
255    if [ "`echo "$filename" | grep -F "lib/modules/" | grep "\.*o\.gz"`" != "" ] ; then
256        mv $scratchfile $scratchfile.gz
257        gunzip -f $scratchfile || LogIt "Cannot gunzip $scratchfile.gz"
258        filename=`echo "$filename" | tr '.' '#' | sed s/#o#gz/#o/ | sed s/#ko#gz/#ko/ | tr '#' '.'`
259    fi
260    filesize=`du -sk $scratchfile | cut -f1`
261    noof_slices=$(($filesize/$slicesize))
262    echo "$filename" > $outdir/slice-$biggienumber.name
263    echo "$filesize" > $outdir/slice-$biggienumber.size
264    [ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
265    while [ "$sliceno" -le "$noof_slices" ] ; do
266        dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
267        sliceno=$(($sliceno+1))
268    done
269    rm -f $scratchfile
270}
271
272
273CopyBootBFile() {
274    local copy_to copy_from possible_locations liloc
275    copy_to=$1
276    copy_from=/boot/boot.b
277    liloc=`which lilo.real 2>/dev/null`
278    [ $liloc ] || liloc=`which lilo 2>/dev/null`
279    if [ $liloc ]; then
280        if ! [ `strings $liloc | grep "boot\.b"` ]; then
281            LogIt "boot.b files built into lilo; I'll create a dummy."
282            > $copy_to
283            return 0
284        fi
285    fi
286    if [ ! -f "$copy_from" ] ; then
287        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"
288        copy_from=`grep install= /etc/lilo.conf | grep "\.b" | cut -d'=' -f2`
289        if [ ! -f "$copy_from" ] ; then
290            LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
291            copy_from=`FindSensibleBootBFile`
292            LogIt "I'm going to use '$copy_from'"
293        fi
294    fi
295    cp -f $copy_from $copy_to 2>> $LOGFILE || LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
296}
297
298
299CopyDependenciesToDirectory() {
300    local outdir incoming fname filesize counter
301    outdir=$1
302    mkdir -p $outdir
303    incoming=`ReadLine`
304    counter=0
305    while [ "$incoming" != "" ] ; do
306        if [ -d "$incoming" ] ; then
307            find $incoming/* -maxdepth 0 2> /dev/null | CopyDependenciesToDirectory $outdir
308        elif [ -e "$incoming" ] ; then
309            filesize=`du -sk $incoming | cut -f1`
310            if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
311                ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
312                BIGNO=$(($BIGNO+1))
313            else
314                cp --parents -Rdf $incoming $outdir 2> /dev/null || Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
315                if [ "`echo "$incoming" | grep "lib/modules/.*\..*o\.gz"`" != "" ] ; then
316                    gunzip -f $outdir/$incoming || LogIt "Cannot gunzip $outdir/$incoming"
317                fi
318                [ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
319            fi
320            counter=$(($counter+1))
321            if [ "$counter" -ge "5" ] ; then
322                counter=0
323                echo -en "."
324            fi
325        fi
326        incoming=`ReadLine`
327    done
328}
329
330
331CopyImageToDisk() {
332    local image dev procno res comment
333    image=$1
334    dev=$2
335    comment=$3
336    [ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
337    Prompt "About to write $comment. Please press ENTER."
338    echo -en "Formatting disk..."
339    if which fdformat > /dev/null ; then
340        fdformat -n $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
341    elif which superformat > /dev/null ; then
342        superformat $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
343    else
344        Die "Please install either fdformat or superformat."
345    fi
346    echo -en "\rWriting $comment"
347    if echo $image | grep "mindi-[r|b]oot\.1440" &> /dev/null ; then
348        cat $image > $dev &
349    else
350        dd if=$image of=$dev &> /dev/null &
351    fi
352    procno=$!
353    ps $procno > /dev/null 2> /dev/null
354    while [ "$?" -eq "0" ] ; do
355        sleep 3
356        echo -en "."
357        ps $procno > /dev/null 2> /dev/null
358    done
359    echo -e "$DONE"
360    LogIt "$comment has been written."
361}
362
363
364CountItemsIn() {
365    local r
366    r=0
367    for q in $1 ; do
368        r=$(($r+1))
369    done
370    echo $r
371}
372
373
374CreateDataDiskImagesFromTarballs() {
375    local tardir outdir diskno noof_disks kp
376    tardir=$1
377    outdir=$2
378    noof_disks=$3
379
380    mkdir -p $outdir
381    diskno=1
382    echo -en "Creating data disk "
383    while [ "$diskno" -le "$noof_disks" ] ; do
384        echo -en "#$diskno..."
385        cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE || LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
386        CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
387        diskno=$(($diskno+1))
388    done
389    mv -f $tardir/all.tar.gz $outdir
390    du -sk $outdir/*gz >> $LOGFILE
391    echo -e "$DONE"
392}
393
394
395
396CreateOneDataDiskImage() {
397    local tarball imagefile dev diskno noof_disks mountpoint
398    tarball=$1
399    imagefile=$2
400    diskno=$3
401    noof_disks=$4
402
403    mountpoint=$MINDI_TMP/mountpoint.$$
404    mkdir -p $mountpoint
405    dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null || LogIt "Cannot dd (CODI)"
406    echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
407    mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE
408    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."
409    mv $tarball $mountpoint/
410    if [ "$?" -ne "0" ] ; then
411        umount $mountpoint
412        rmdir $mountpoint
413        Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
414    fi
415    [ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
416    umount $mountpoint || LogIt "Cannot umount (CODI)"
417    rmdir $mountpoint || LogIt "Cannot rmdir (CODI)"
418}
419
420# Last function called before exiting
421# Parameter is exit code value
422MindiExit() {
423    local my_partitions
424
425    echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
426    echo "End date : `date`" >> $LOGFILE
427
428    sync
429    cd /
430
431    # Unmount whtat could remain mounted
432    my_partitions=`mount | grep -F $$ | cut -f1 -d' '`
433    [ "$my_partitions" != "" ] && umount $my_partitions
434    # Clean temporary files only when standalone mindi
435    if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
436        rm -Rf $MINDI_TMP
437    fi
438    exit $1
439}
440
441Die() {
442    local i
443    if [ "$1" = "" ] ; then
444        LogIt "FATAL ERROR"
445    else
446        LogIt "FATAL ERROR. $1"
447    fi
448
449    # Creates a tar file containing all required files
450    for i in $MY_FSTAB /etc/lilo.conf /etc/raidtab $LOGFILE /var/log/mondo-archive.log ; do
451        [ -e "$i" ] && cp -f $i $MINDI_TMP 2>> $LOGFILE
452    done
453    rm -f $TMPDIR/mindi.err.*.tgz
454    tar -cf - $MINDI_TMP | gzip -9 > $TMPDIR/mindi.err.$$.tgz
455    LogIt "Please e-mail a copy of $TMPDIR/mindi.err.$$.tgz to the mailing list."
456    LogIt "See http://www.mondorescue.org for more information."
457    LogIt "WE CANNOT HELP unless you enclose that file.\n"
458    MindiExit -1
459}
460
461
462DropOptimizedLibraries() {
463    local outdir filelist list_of_optimized_libraries optimized_lib_name vanilla_lib_name reason msg resolved res
464    filelist=$1
465    outdir=$2
466
467    list_of_optimized_libraries=`grep "lib/i[5-7]86/" $filelist`
468    if [ "$list_of_optimized_libraries" = "" ] ; then
469        return 0
470    fi
471    echo -en "Dropping i686-optimized libraries if appropriate"
472    for optimized_lib_name in $list_of_optimized_libraries ; do
473        echo -en "."
474        reason=""
475        vanilla_lib_name=`echo "$optimized_lib_name" | sed s/i[5-7]86// | tr -s '/' '/'`
476        echo "$vanilla_lib_name" >> $filelist
477        resolved=$vanilla_lib_name
478        echo "Adding $resolved to filelist" >> $LOGFILE
479        resolved=`ReadAllLink $resolved`
480        echo "Adding $resolved to filelist" >> $LOGFILE
481        mkdir -p $outdir$optimized_lib_name > /dev/null 2> /dev/null
482        rmdir $outdir$optimized_lib_name > /dev/null 2> /dev/null
483        ln -sf $vanilla_lib_name $outdir$optimized_lib_name
484        echo "Excluding $optimized_lib_name" >> $LOGFILE
485        grep -Fvx "$optimized_lib_name" "$filelist" > $filelist.tmp
486        echo "Replacing it with $vanilla_lib_name" >> $LOGFILE
487        echo "$vanilla_lib_name" >> $filelist.tmp
488        mv -f $filelist.tmp $filelist
489    done
490    $AWK '{ print $1; }' $filelist | sort -u > $filelist.tmp
491    mv -f $filelist.tmp $filelist
492    echo -e "$DONE"
493}
494
495
496FindAndAddUserKeyboardMappingFile() {
497    local r res mapfile mappath included_item included_list keyfile mp locale
498    LogIt "Analyzing your keyboard's configuration."
499    KEYDIR=/lib/kbd
500    [ ! -e "$KEYDIR" ] && KEYDIR=/usr/share/kbd     # Slackware
501    [ ! -e "$KEYDIR" ] && KEYDIR=/usr/lib/kbd
502    [ ! -e "$KEYDIR" ] && KEYDIR=/usr/share
503    if [ ! -e "$KEYDIR" ] ; then
504        LogIt "Keyboard mapping directory not found. I shall use default map at boot-time."
505        return 0
506    fi
507    if [ -e "/etc/sysconfig/keyboard" ] ; then
508        echo "Red Hat-style config detected." >> $LOGFILE
509        keyfile=/etc/sysconfig/keyboard
510    elif [ -e "/etc/rc.d/rc.keymap" ] ; then
511        echo "Slackware-style config detected." >> $LOGFILE
512        keyfile=/etc/rc.d/rc.keymap
513    elif [ -e "/etc/rc.config" ] ; then
514        echo "Debian-style config detected." >> $LOGFILE
515        keyfile=/etc/rc.config
516    elif [ -e "/etc/console/boottime.kmap.gz" ] ; then
517        echo "Debian-style config detected." >> $LOGFILE
518        echo -en "Adding the following keyboard mapping tables: "
519        mkdir -p $bigdir/tmp
520        echo "keymap-lives-here=/etc/console/boottime.kmap.gz" >> $MINDI_TMP/mondo-restore.cfg
521        KBDEPTH=0
522        mkdir -p $bigdir/etc/console
523        cp /etc/console/boottime.kmap.gz $bigdir/etc/console 2>> $LOGFILE
524        echo -e "$DONE"
525        return 0
526    else
527        echo -en "Searching for rc.config ..."
528        keyfile=`find /etc -name rc.config | head -n1`
529        if [ "$keyfile" = "" ] || [ ! -e "$keyfile" ] ; then
530            LogIt "Unknown config detected. Default keyboard map will be used."
531            return
532        else
533            echo "Found $keyfile" >> $LOGFILE
534        fi
535    fi
536    if [ ! -e "$KEYDIR/keymaps" ] ; then
537        LogIt "Keyboard mapping directory not found. Default keyboard map will be used."
538        return
539    fi
540    echo "keyfile=$keyfile" >> $LOGFILE
541    locale=`grep -F KEYTABLE "$keyfile" | tr -d '"' |cut -d'=' -f2`
542    [ ! "$locale" ] && locale=`grep '.map$' "$keyfile" | sed 's/^.* //'`        # Slackware
543    echo "locale=$locale" >> $LOGFILE
544    #
545    # Process the keymaps dir once for all
546    # AddKeyboardMappingFile will use it recursively
547    #
548    find $KEYDIR/keymaps > $MINDI_TMP/keymaps.find
549    mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep -F "/${locale}." | grep -vx " *#.*"`
550    [ ! "$mp" ] && mp=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
551    # If we have multiple keymaps then log it !!
552    echo "$mp" | grep -q " "
553    if [ $? -eq 0 ]; then
554        echo "WARNING: Multiple keymaps found: $mp" | tee -a $LOGFILE
555        echo "The following one will be used" >> $LOGFILE
556    fi
557    for i in $mp ; do
558        mappath=$i
559        [ -e "$i" ] && [ ! -d "$i" ] && break
560    done
561    if [ ! -e "$mappath" ] || [ -d "$mappath" ] ; then
562       mappath=$(locate */kbd/keymaps/*/$locale)
563    fi
564    echo "mappath = $mappath" >> $LOGFILE
565    if [ ! -e "$mappath" ] || [ -d "$mappath" ] ; then
566        LogIt "Keyboard mapping file not found. Default keyboard map will be used."
567        return
568    fi
569    echo -en "Adding the following keyboard mapping tables: "
570    mkdir -p $bigdir/tmp
571    echo "keymap-lives-here=$mappath" >> $MINDI_TMP/mondo-restore.cfg
572    KBDEPTH=0
573    AddKeyboardMappingFile $mappath
574    echo -e "$DONE"
575    rm -f $MINDI_TMP/keymaps.find
576    return 0
577}
578
579
580FindIsolinuxBinary() {
581    ISOLINUX=/usr/lib/isolinux.bin
582    [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib/syslinux/isolinux.bin
583    [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/syslinux/isolinux.bin
584    [ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib/syslinux/isolinux.bin
585    [ ! -e "$ISOLINUX" ] && ISOLINUX=`locate isolinux.bin | grep -x "/.*/isolinux.bin"`
586    [ ! -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'"
587    echo "Found isolinux.bin at $ISOLINUX" >> $LOGFILE
588}
589
590
591FindLiloBinary() {
592    if which lilo &> /dev/null ; then
593        if which lilo.real > /dev/null 2> /dev/null ; then
594            LILO_EXE=lilo.real
595            LogIt "lilo.real found; will be used instead of lilo (*grumble* *mutter*)"
596        else
597            LILO_EXE=lilo
598        fi
599        $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. :)"
600    else
601        LILO_EXE=`which false`
602    fi
603}
604
605
606FindSensibleBootBFile() {
607    local i out last
608    out=""
609    last=""
610    for i in `find /boot -type f | grep -v chain | grep -v os2 | sort -u` ; do
611    if [ "`strings $i 2> /dev/null | head -n1`" = "LILO" ] ; then
612        out="$out $i"
613        last="$i"
614    fi
615    done
616    echo "$last"
617}
618
619
620FindSpecificModuleInPath() {
621    local modpaths pwd line
622    pwd=`pwd`
623    if [ "$YOUR_KERNEL_SUCKS" ] ; then
624        cd $MINDI_TMP
625    else
626        cd /
627    fi
628    if [ ! -e "$1" ] ; then
629        LogIt "WARNING - cannot search specific path '$1'"
630        return 1
631    fi
632    modpaths=`find $1 -name $2.*o -type f`
633    [ "$?" -ne "0" ] && Die "find $1 -name $2.o -type f --- failed"
634    [ "$modpaths" = "" ] && modpaths=`find $1 -name $2.o.gz -type f`
635    [ "$modpaths" = "" ] && modpaths=`find $1 -name $2.ko.gz -type f`
636    [ "$modpaths" = "" ] && modpaths=`find $1 -name $2 -type f`
637    echo "$modpaths"
638    cd $pwd
639}
640
641
642GenerateGiantDependencyList() {
643    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
644
645    echo -en "Analyzing dependency requirements"
646    outfile=$1
647    tempfile=$MINDI_TMP/$$.txt
648    incoming=`ReadLine`
649
650    > $tempfile
651    progress=0
652    res=0
653    noof_lines=$2
654    while [ "$incoming" != "" ] ; do
655        if echo "$incoming" | grep -x " *#.*" &> /dev/null ; then
656            incoming=`ReadLine`
657            continue
658        fi
659        if [ "$incoming" = "LVMFILES:" ] ; then
660            break
661        fi
662        filelist=`GenerateListForFile "$incoming"`
663        r=$?
664        [ "$r" -ne "0" ] && LogIt "$incoming not found"
665        res=$(($res+$r))
666#       echo "'$incoming' generates filelist '$filelist'" >> $LOGFILE
667        for fname in $filelist ; do
668            [ "$fname" != "" ] && echo "$fname" >> $tempfile
669        done
670        progress=$(($progress+1))
671        echo -en "\r\t\t\t\t\t\t\t\t"
672        i=$(($progress*100))
673        i=$(($i/$noof_lines))
674        echo -en "$i"
675        echo -en "%"
676        modres=$(($progress%4))
677        [ "$modres" -eq "0" ] && echo -en "\t/"
678        [ "$modres" -eq "1" ] && echo -en "\t-"
679        [ "$modres" -eq "2" ] && echo -en "\t\\"
680        [ "$modres" -eq "3" ] && echo -en "\t|"
681        incoming=`ReadLine`
682    done
683    if  [ "$incoming" = "LVMFILES:" ] ; then
684        incoming=`ReadLine`
685        lvmversion=""
686        while [ "$incoming" != "" ] ; do
687            if echo "$incoming" | grep -x " *#.*" &> /dev/null ; then
688                incoming=`ReadLine`
689                continue
690            fi
691            filelist=`GenerateListForFile "$incoming"`
692            for tool in $filelist ; do
693                lvmresolved=`readlink -f $tool`
694                if [ "$tool" == "$lvmresolved" ]; then
695                    echo "$tool" >> $tempfile
696                elif echo "$lvmresolved" | grep "lvmiopversion" &> /dev/null ; then
697                    if [ "$lvmversion" = "" ] ; then
698                        lvmversion=`$lvmresolved`
699                        echo "$lvmresolved" >> $tempfile
700                    fi
701                    toolstripped=`echo $tool | $AWK -F / '{print $NF;}'`
702                    if [ "$lvmversion" == "200" ]; then
703                        # pvdata and lvmcreate_initrd don't exist in LVM2
704                        case "$toolstripped" in
705                        "pvdata")
706                            continue
707                            ;;
708                        "lvmcreate_initrd")
709                            continue
710                            ;;
711                        esac
712                    fi
713                    toolpath="/sbin/lvm-"$lvmversion"/"$toolstripped
714                    if [ -e "$toolpath" ] ; then
715                        echo "$toolpath" >> $tempfile
716                        echo "$tool" >> $tempfile
717                    else
718                        toolpath="/lib/lvm-"$lvmversion"/"$toolstripped
719                    fi
720                    if [ -e "$toolpath" ] ; then
721                        echo "$toolpath" >> $tempfile
722                        echo "$tool" >> $tempfile
723                    else
724                        echo "Where are your LVM-Tools? Couldn't find $tool"
725                    fi
726                else
727                    echo "$tool" >> $tempfile
728                fi
729            done
730            progress=$(($progress+1))
731            echo -en "\r\t\t\t\t\t\t\t\t"
732            i=$(($progress*100))
733            i=$(($i/$noof_lines))
734            echo -en "$i"
735            echo -en "%"
736            modres=$(($progress%4))
737            [ "$modres" -eq "0" ] && echo -en "\t/"
738            [ "$modres" -eq "1" ] && echo -en "\t-"
739            [ "$modres" -eq "2" ] && echo -en "\t\\"
740            [ "$modres" -eq "3" ] && echo -en "\t|"
741            incoming=`ReadLine`
742        done
743    fi
744    echo -en "$DONE\nMaking complete dependency list"
745
746    tr -s '/' '/' < $tempfile | sort -u > $tempfile.new
747    mv -f $tempfile.new $tempfile
748    > $outfile.pre
749    progress=0
750    noof_lines=`cat $tempfile | wc -l`
751    for fname in `cat $tempfile` ; do
752        echo "$fname" >> $outfile.pre
753        LocateDeps $fname >> $outfile.pre
754        progress=$(($progress+1))
755        echo -en "\r\t\t\t\t\t\t\t\t"
756        i=$(($progress*100))
757        i=$(($i/$noof_lines))
758        echo -en "$i"
759        echo -en "%"
760        modres=$(($progress%4))
761        [ "$modres" -eq "0" ] && echo -en "\t/"
762        [ "$modres" -eq "1" ] && echo -en "\t-"
763        [ "$modres" -eq "2" ] && echo -en "\t\\"
764        [ "$modres" -eq "3" ] && echo -en "\t|"
765    done
766    if [ _"$MONDO_SHARE" != _"" ]; then
767        mkdir -p $bigdir/tmp
768        mkdir -p $bigdir/sbin
769        mkdir -p $bigdir/bin
770        if [ -e "$MINDI_TMP/post-nuke.tgz" ] ; then
771            LogIt "\nIncorporating post-nuke tarball"
772            old_pwd=`pwd`
773            cd $bigdir
774            tar -zxf $MINDI_TMP/post-nuke.tgz || LogIt "Error occurred when untarring post-nuke tarball"
775            cd $old_pwd
776        fi
777        if cp -f $MINDI_TMP/mondo*restore $bigdir/usr/bin 2>> $LOGFILE ; then
778            LocateDeps $bigdir/usr/bin/mondo*restore >> $outfile.pre
779        else
780            LogIt "Cannot find mondo*restore in mondo's tempdir, $MINDI_TMP"
781            LogIt "I bet you've got a spare copy of Mondo or Mindi floating around on your system."
782            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."
783            Die "Odd."
784        fi
785    fi
786    tr ' ' '\n' < $outfile.pre | tr -s '/' '/' | grep -Fvx "" | sort -u | grep -Ev "/libX11|/libXext|/libXi|/libgtk|/libgdk" > $outfile
787    rm -f $tempfile $outfile.pre
788    [ "$res" -eq "0" ] && echo -e "\r\t\t\t\t\t\t\t\t$DONE" || echo "\nFailed."
789    return $res
790}
791
792
793GenerateListForFile() {
794    local files_found loc fname incoming i res
795    incoming="$1"
796    files_found=""
797    res=0
798
799    for fname in $incoming ; do
800        files_found="$files_found `LocateFile $fname`"
801    done
802
803    echo "$files_found" | tr ' ' '\n' | sort -u | tr '\n' ' '
804}
805
806
807# Returns all disk devices which are part of a raid array
808GetAllRaidMembers() {
809    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*device/ if(\$2) {print \$2}" < /etc/raidtab
810}
811
812
813GetFileSizeList() {
814    local i
815    for i in `find $1 -type d -o -print` ; do
816        du -sk $i
817    done
818}
819
820
821GetHomeDir() {
822    local res loc
823    loc=`which $1 2>/dev/null`
824    res=`file $loc | $AWK '{print $NF;}'`
825    dirname $res
826}
827
828
829# Check kernel filesystem capabilites for accessing initrd image
830#
831# Interface definition:
832# param #1: absolute path to kernel image
833GetInitrdFilesystemToUse() {
834
835    # interface test: make sure we have one parameter
836    if [ $# -ne 1 ]; then
837        Die "GetInitrdFilesystemToUse(): Expected 1 parameter, got $#."
838    fi
839
840    # interface parameters
841    local lvKernelImage=$1
842
843    # local constants (filesystem magic strings)
844    local lcMagicCramfs="<3>cramfs: wrong magic"
845    local lcMagicExt2fs="<3>EXT2-fs: blocksize too small for device."
846    local lcMagicInitfs="<6>checking if image is initramfs..."
847
848    # local variables
849    local lvOffset
850    local lvScanRes
851    local lvUseFilesystem
852
853    # say where we are.
854    echo "  GetInitrdFilesystemToUse(): called with parameter: $lvKernelImage.\n" >> $LOGFILE
855
856    # verify that file exists
857    [ ! -f $lvKernelImage ] && Die "File $lvKernelImage not found. Terminating."
858
859    # get offet of gzip magic "1f8b0800" in file
860    lvOffset=`od -vA n -t x1 $lvKernelImage | tr -d '[:space:]' | awk '{ print match($0, "1f8b0800")}'`
861    [ $lvOffset -eq 0 ] && Die "gzip magic not found in file $lvKernelImage. Terminating."
862    lvOffset=`expr $lvOffset / 2`
863    echo "  GetInitrdFilesystemToUse(): gzip magic found at lvOffset $lvOffset.\n" >> $LOGFILE
864
865    # scan kernel image for initrd filessystem support
866    lvScanRes=`dd ibs=1 skip=$lvOffset if=$lvKernelImage obs=1M 2>/dev/null | gunzip -c | strings | grep -e "$lcMagicCramfs" -e "$lcMagicExt2fs" -e "$lcMagicInitfs"`
867
868    # determine which filesystem to use for initrd image: ext2fs, gzip'ed cpio (initramfs ) or cramfs
869    if [ `echo $lvScanRes | grep -c "$lcMagicExt2fs"` -eq 1 ]; then
870        lvUseFilesystem="ext2fs"
871    elif [ `echo $lvScanRes | grep -c "$lcMagicInitfs"` -eq 1 ]; then
872        lvUseFilesystem="initramfs"
873    elif [ `echo $lvScanRes | grep -c "$lcMagicCramfs"` -eq 1 ]; then
874        lvUseFilesystem="cramfs"
875    else
876        lvUseFilesystem="UNSUPPORTED"
877    fi
878
879    # say what we are using
880    echo "  GetInitrdFilesystemToUse(): Filesytem to use for initrd is $lvUseFilesystem.\n" >> $LOGFILE
881
882    # return file system to use
883    echo "$lvUseFilesystem"
884
885}
886
887# Searches parent raid device of given disk device
888# $1: disk device (i.e. /dev/hda1)
889GetParentRaidDev() {
890    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {dev=\$2} /^[[:space:]]*device/ {if(\$2==\"$1\") {print dev; exit}}" < /etc/raidtab
891}
892
893
894# Searches members of raid device
895# $1: raid device (/dev/md...)
896GetRaidDevMembers() {
897    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*raiddev/ {if(dev) exit; if(\$2 == \"$1\") dev=\$2} /^[[:space:]]*device/ {if(dev) {print \$2}}" < /etc/raidtab
898}
899
900
901HackPathsToFailsafe() {
902    local incoming newpath kver stub i pwd
903    kver=`uname -r`
904    incoming=`ReadLine`
905    pwd=`pwd`
906    cd $MINDI_TMP
907    while [ "$incoming" != "" ] ; do
908        stub=`basename $incoming`
909        newpath=`FindSpecificModuleInPath lib/modules/$FAILSAFE_KVER $stub`
910        for i in $newpath ; do
911            echo "$i"
912        done
913        read incoming
914    done
915    cd $pwd
916}
917
918
919ListAllPartitions() {
920    local res currline partition all_partitions ap_orig remaining i j
921
922    grep -vx " *#.*" $MY_FSTAB | grep -vx " *none.*" | $AWK '/^\/dev\/[imhs]d||^LABEL\=\/|^UUID=/ && !/fdd|cdr|zip|floppy/ {print $1}'
923    [ -e "/etc/raidtab" ] && $AWK '/^ *device/ {print $2}' /etc/raidtab
924    return
925}
926
927
928ListImagesForUser() {
929    local path fname
930    path=$1
931    echo -en "In the directory '$path' you will find the images:-\n"
932    for fname in `ls $path | grep -F mindi-` ; do
933        printf "%19s " $fname
934    done
935    echo " "
936}
937
938
939ListKernelModulePaths() {
940    local module_list module fname oss r kern
941    oss="/root/oss/modules"
942    module_list="`lsmod | sed -n '2,$s/ .*//'`"
943    # Remove unwanted modules from list
944    for i in $DENY_MODS; do
945        module_list=`echo ${module_list} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
946    done
947###
948### Sq-Modification ... Use kernelname for module search path if specified
949###
950    # kern="`uname -r`"
951    if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
952    then
953        kern=${kernelname}
954    else
955        kern="`uname -r`"
956    fi
957###
958### Sq-Mod End
959###
960    for module in $module_list $EXTRA_MODS ; do
961        r=`find /lib/modules/$kern -type f | grep "/${module}\..*o" | tail -n1`
962        echo "module $module --> $r" >> $LOGFILE
963        [ "$r" ] && echo "$r"
964        [ -f "$oss" ] && find $oss | grep -F $module
965    done
966    find /lib/modules/$kern/modules.* -type f 2> /dev/null
967    [ -f "$oss" ] && find $oss.* 2> /dev/null
968}
969
970
971LocateDeps() {
972    local incoming fname deps
973    incoming="$1"
974    for fname in $incoming ; do
975        if [ ! -e "$fname" ] ; then
976            echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
977            if echo $fname | grep lvm &> /dev/null ; then
978                echo "This warning only affects you if you are using LVM." >> $LOGFILE
979                if lsmod | grep lvm &> /dev/null ; then
980                    echo "I think you are, so please take heed!" >> $LOGFILE
981                else
982                    echo "I don't think you are, so don't worry about it." >> $LOGFILE
983                fi
984            fi
985        elif [ -h "$fname" ] && [ -x "$fname" ] ; then
986            echo "$fname is softlink" >> $LOGFILE
987        else
988            ldd $fname 2> /dev/null | ProcessLDD $fname
989        fi
990    done
991}
992
993
994# Give all symlinks recursively of a full path name
995ReadAllLink() {
996    file="$1"
997
998    if [ ! -h $file ]; then
999        echo "$file"
1000        return 0
1001    fi
1002
1003    link=`readlink -f $file`
1004    d=`dirname $file`
1005    if [ ! -e "$link" -a ! -e "$d/$link" ]; then
1006        echo "Problem with dead link on $file -> $link" >> $LOGFILE
1007    fi
1008    if [ -h "$d" ]; then
1009        echo "$link $d"
1010    else
1011        echo "$link"
1012    fi
1013}
1014
1015
1016LocateFile() {
1017    local i path fname_to_find location output resolved tmp stub cache_id loclist
1018    fname_to_find="$1"
1019    if echo "$fname_to_find" | grep -x "/.*" ; then
1020        output="$fname_to_find"
1021        if [ -h "$output" ] ; then
1022            output="`ReadAllLink $output` $output"
1023        fi
1024        echo "$output"
1025        return 0
1026    fi
1027    output=""
1028    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
1029        [ ! -d "$path" ] && continue
1030        for location in "$path/$fname_to_find" ; do
1031            [ ! -e "$location" ] && continue
1032            output="$location $output"
1033            if [ -h "$location" ] ; then
1034                output="`ReadAllLink $location` $output"
1035            fi
1036        done
1037    done
1038    if [ "$output" = "" ] ; then
1039        return 1
1040    fi
1041    echo "$output"
1042    return 0
1043}
1044
1045
1046LogIt() {
1047    if [ -e /dev/stderr ] ; then
1048        echo -e "$1" >> /dev/stderr
1049    elif [ -e /usr/bin/logger ] ; then
1050        /usr/bin/logger -s $1
1051    fi
1052    echo -e "$1" >> $LOGFILE
1053}
1054
1055
1056MakeModuleLoadingScript() {
1057    local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
1058    tmpmodprobe_flag=$1
1059    outfile=$2
1060    > $outfile || Die "Cannot create empty $outfile"
1061    echo -en "#\041/bin/sh\n\n" >> $outfile
1062    echo "echo -en \"Loading your modules...\"" >> $outfile
1063    if [ "$YOUR_KERNEL_SUCKS" ] ; then
1064        kver=$FAILSAFE_KVER
1065        cd $MINDI_TMP
1066        searchpath=lib/modules/$kver
1067    else
1068###
1069### Sq-Modification ... Use kernelname for module search path if specified
1070###
1071        #kver=`uname -r`
1072        if [ "${kernelname}" != "" ]
1073        then
1074            kver=${kernelname}
1075        else
1076            kver=`uname -r`
1077        fi
1078###
1079### Sq-Modification end
1080###
1081        searchpath=/lib/modules/$kver
1082    fi
1083   
1084    echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
1085    # BERLIOS: That code is duplicated - Should be done once only
1086    list_to_echo="`lsmod | sed -n '2,$s/ .*//'`"
1087    # Remove unwanted modules from list
1088    for i in $DENY_MODS; do
1089        list_to_echo=`echo ${list_to_echo} | tr ' ' '\n' | grep -Ev "^${i}$" | tr '\n' ' '`
1090    done
1091
1092    # Make temporary modprobe.conf file if we are told so
1093    if [ $tmpmodprobe_flag == "Y" ] ; then
1094        infile="$MINDI_TMP/modprobe.conf.mindi"
1095        find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 | xargs -0 cat > $infile
1096    else
1097        infile="/etc/modules.conf"
1098    fi
1099    for module in $list_to_echo $EXTRA_MODS ; do
1100        params=`sed -n "s/^options \\+$module \\+//p" $infile`
1101        modpaths=`FindSpecificModuleInPath $searchpath $module`
1102        for i in $modpaths ; do
1103            echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
1104                | tr '.' '#' \
1105                | sed s/#o#gz/#o/ \
1106                | sed s/#o#gz/#o/ \
1107                | sed s/#ko#gz/#ko/ \
1108                | sed s/#ko#gz/#ko/ \
1109                | tr '#' '.' >> $outfile
1110            echo -en "$i added to module list.\n" >> $LOGFILE
1111        done
1112    done
1113    echo -en "done\n" >> $outfile
1114    echo "echo \"Done.\"" >> $outfile
1115    chmod +x $outfile
1116    cd /
1117    # Remove temporary modprobe.conf file if we have created one
1118    if [ $tmpmodprobe_flag == "Y" ] ; then
1119        rm -f $infile
1120    fi
1121}
1122
1123
1124MakeMountlist() {
1125    local scratchdir mountlist all_partitions current_partition \
1126partition_size partition_format outstring partition_number \
1127partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
1128absolute_partition old_partition_fmt current_lvolume
1129
1130    echo "Your raw fstab file looks like this:" >> $LOGFILE
1131    echo "------------------------------------" >> $LOGFILE
1132    cat $MY_FSTAB >> $LOGFILE
1133    echo "Your mountlist will look like this:" | tee -a $LOGFILE
1134    echo "-----------------------------------" >> $LOGFILE
1135
1136# scratchdir, mountlist(OUT)
1137    scratchdir=$MINDI_TMP
1138    mountlist=$1
1139
1140# NB: partition = device
1141# NB: mountpt = where the device is mounted
1142
1143    [ -e "$MY_FSTAB" ] || Die "Cannot find your fstab file ($MY_FSTAB)"
1144
1145    [ "$mountlist" != "" ] && rm -Rf $mountlist
1146    > $mountlist
1147    echo -en "\rHang on...\r"
1148    all_partitions=""
1149   
1150    if [ $LVM != "false" ]; then
1151        echo -en "\rAnalyzing LVM...\r"
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|5760'`
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.$IA64_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
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    losetup /dev/loop0 > /dev/null 2> /dev/null
1816    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1817    CopyBootBFile $mtpt/boot.b
1818
1819    MakeLiloConfFile $disksize >> bdlilo.conf
1820
1821    chmod 644 bdlilo.conf
1822    MakeMessageFile $disksize > message
1823    lilo -v -C bdlilo.conf -r $mtpt
1824    res=$?
1825
1826    cd $old_pwd
1827    umount $mtpt
1828    mv -f $image $2
1829    rmdir $mtpt
1830
1831    return $res
1832}
1833
1834
1835MakeLiloConfFile() {
1836    local disksize options i ooo
1837    disksize=$1
1838    options=""
1839
1840    if [ "$ARCH" != "ia64" ] ; then
1841        echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1842    fi
1843    if [ "$disksize" -eq "2880" ] ; then
1844        echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
1845    elif [ "$disksize" -gt "2880" ] ; then
1846        /bin/true
1847    else
1848        echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
1849    fi
1850    if [ "$ARCH" != "ia64" ] ; then
1851        echo -en "install=/boot.b\nmap=/boot.map\n"
1852    fi
1853    if [ "$CDRECOVERY" = "yes" ] ; then
1854        echo -en "default=RESTORE\n"
1855    elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ]; then
1856        if [ "$NFS_DEV" != "" ] ; then
1857            echo -en "default=iso\n"
1858        else
1859            echo -en "default=interactive\n"
1860        fi
1861    else
1862        echo -en "default=expert\n"
1863    fi
1864
1865    echo -en "prompt\n"
1866    if [ "$ARCH" != "ia64" ] ; then
1867        echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1868    fi
1869    if [ "$CDRECOVERY" != "yes" ] ; then
1870        echo -en "timeout=300\n"
1871    fi
1872    echo -en "\n"
1873    if [ "$CDRECOVERY" = "yes" ] ; then
1874        options="RESTORE expert"
1875    elif [ "$disksize" -gt "2880" ] ; then
1876        if [ _"$MONDO_SHARE" != _"" ]; then
1877            if [ "$NFS_DEV" != "" ] ; then
1878                options="iso"
1879            else
1880                options="interactive expert compare iso nuke isonuke"
1881# hda hdb hdc hdd"
1882            fi
1883        else
1884            options="expert"
1885        fi
1886    else
1887        options="expert"
1888    fi
1889    for i in $options ; do
1890        ooo=$i
1891        [ "$ooo" = "RESTORE" ] && ooo="nuke"
1892        if [ "$ARCH" = "ia64" ] ; then
1893            rootpart="root=/dev/ram0\n\t"
1894        else
1895            rootpart=""
1896        fi
1897        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"
1898   
1899        outstr=$outstr" $ooo_mode"
1900        outstr=$outstr"\"\n"
1901        if [ "$disksize" = "1440" ] ; then
1902            echo -en "$outstr" | sed s/initrd=.*// | grep -v root=
1903        else
1904            echo -en "$outstr"
1905        fi
1906    done
1907}
1908
1909
1910PrepareBootDiskImage_LILO() {
1911    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1912    imagesdir=$1
1913    disksize=$2
1914    kernelpath=$3
1915    ramdisksize=$4
1916
1917    retval=0
1918    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1919    echo -en "Making "$disksize"KB boot disk..."
1920    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?"
1921    if [ "$ARCH" != "ia64" ] ; then
1922        [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
1923    fi
1924    echo -en "..."
1925    imagefile=$imagesdir/mindi-bootroot.$disksize.img
1926    mountpoint=$MINDI_TMP/mountpoint.$$
1927    mkdir -p $mountpoint
1928    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
1929    if [ "$ARCH" = "ia64" ] ; then
1930        mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1931        t=vfat
1932    else
1933        echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
1934        mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
1935        t=ext2
1936    fi
1937    mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1938    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1939    mkdir -p $mountpoint/etc
1940    if [ "$ARCH" != "ia64" ] ; then
1941        liloconf=$mountpoint/etc/lilo.conf
1942    else
1943        liloconf=$mountpoint/elilo.conf
1944    fi
1945    old_pwd=`pwd`
1946    cd $mountpoint
1947    if [ "$ARCH" != "ia64" ] ; then
1948        tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1949    fi
1950    cd $old_pwd
1951    losetup /dev/loop0 > /dev/null 2> /dev/null
1952    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary."
1953    CopyBootBFile $mountpoint/boot.b
1954
1955    MakeLiloConfFile $disksize > $liloconf
1956
1957    # Copy it so that CD-ROM menu entry is satisfied
1958    if [ "$ARCH" = "ia64" ] ; then
1959        mountefi=0
1960        df -T | grep /boot/efi | grep -q vfat
1961        if [ $? -ne 0 ]; then
1962            mount /boot/efi
1963            if [ $? -ne 0 ]; then
1964                echo "You have to mount your EFI partition when using mindi"
1965                MindiExit -1
1966            fi
1967            mountefi=1
1968        fi
1969        cp /boot/efi/elilo.efi $mountpoint
1970        cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
1971        if [ $mountefi -eq 1 ]; then
1972            umount /boot/efi 2>&1 > /dev/null
1973        fi
1974    fi
1975
1976    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1977    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1978    if [ "$?" -ne "0" ] ; then
1979        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1980        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1981        LogIt "Please unload some of your modules and try again."
1982        rm -f $MINDI_TMP/mtpt.$$
1983        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1984        retval=$(($retval+1))
1985    fi
1986    MakeMessageFile $disksize > $mountpoint/message
1987
1988    mkdir -p $mountpoint/tmp
1989    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1990    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1991        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1992        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1993#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1994    fi
1995
1996    # copy the kernel across
1997    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1998    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1999    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2000    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
2001    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2002        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2003        du -sk $mountpoint/* >> $LOGFILE
2004        echo "--- end of list of files ---" >> $LOGFILE
2005        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2006Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2007        rm -f $mountpoint/vmlinuz
2008        cd $old_pwd
2009        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2010        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2011    #   losetup /dev/loop0 -d
2012        res=0
2013        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2014        res=$(($res+$?))
2015        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2016        res=$(($res+$?))
2017        rm -f $imagefile
2018        if [ "$res" -ne "0" ]; then
2019            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2020            rm -f $imagesdir/mindi-*.1440.img
2021        fi
2022        return $res
2023    fi
2024    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2025    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2026    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2027    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2028# make it bootable
2029    rm -f $mountpoint/zero
2030    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2031    if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
2032        if [ "$ARCH" != "ia64" ] ; then
2033        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2034        else
2035            /bin/true
2036        fi
2037    elif [ ! "$KERN_DISK_MADE" ] ; then
2038# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
2039        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2040    else
2041        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
2042    fi
2043
2044    # BERLIOS  does not test necessarily what it expects
2045    if [ $? -ne "0" ] ; then
2046        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2047            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2048            LogIt "Please reboot your PC as a workaround."
2049            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2050        fi
2051        echo "$LILO_EXE -r $mountpoint ...failed."
2052        echo -en "Press ENTER to continue."; read line
2053        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2054        retval=$(($retval+1))
2055    fi
2056    cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2057    if [ "$ARCH" = "ia64" ] ; then
2058        cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2059    fi
2060    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2061    echo -en "..."
2062    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2063    if [ "$retval" -eq "0" ] ; then
2064        echo -en "...$DONE\r"
2065        if [ "$KERN_DISK_MADE" ] ; then
2066            LogIt "... $disksize KB boot disks were created OK\r"
2067        fi
2068    else
2069        echo -en "...failed\r"
2070        LogIt $disksize"KB boot disk was NOT created\r"
2071        rm -f $imagefile
2072    fi
2073    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2074    return $retval
2075}
2076
2077
2078PrepareBootDiskImage_SYSLINUX() {
2079    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2080    imagesdir=$1
2081    disksize=$2
2082    kernelpath=$3
2083    ramdisksize=$4
2084    do_boot_root_thingy=""
2085    local retval old_pwd
2086    retval=0
2087
2088    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2089    echo -en "Making "$disksize"KB boot disk..."
2090    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?"
2091    [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
2092    echo -en "..."
2093    imagefile=$imagesdir/mindi-bootroot.$disksize.img
2094    mountpoint=$MINDI_TMP/mountpoint.$$
2095    mkdir -p $mountpoint
2096    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2097    echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
2098    mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2099    syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2100
2101    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2102
2103    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2104    old_pwd=`pwd`
2105    MakeSyslinuxMessageFile $mountpoint/message.txt
2106    cd $mountpoint
2107    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2108    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2109    if [ "$NFS_DEV" != "" ] ; then
2110        perl -pi -e 's/interactive/iso/' syslinux.cfg
2111    fi
2112    cd $old_pwd
2113    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2114    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2115    if [ "$?" -ne "0" ] ; then
2116        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2117        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2118        LogIt "Please unload some of your modules and try again."
2119        rm -f $MINDI_TMP/mtpt.$$
2120        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2121        retval=$(($retval+1))
2122    fi
2123
2124    mkdir -p $mountpoint/tmp
2125    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2126
2127    # copy the kernel across
2128    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2129    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2130    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2131    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2132    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2133        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2134        du -sk $mountpoint/* >> $LOGFILE
2135        echo "--- end of list of files ---" >> $LOGFILE
2136        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2137Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2138        rm -f $mountpoint/vmlinuz
2139        cd $old_pwd
2140        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2141        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2142
2143        res=0
2144        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2145        res=$(($res+$?))
2146        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2147        res=$(($res+$?))
2148        rm -f $imagefile
2149        if [ "$res" -ne "0" ]; then
2150            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2151            rm -f $imagesdir/mindi-*.1440.img
2152        fi
2153        return $res
2154    fi
2155    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2156    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2157    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2158    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2159
2160    # make it bootable
2161    rm -f $mountpoint/zero
2162    mkdir -p $mountpoint/etc
2163    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2164    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2165    echo -en "..."
2166    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2167
2168    if [ "$retval" -eq "0" ] ; then
2169        echo -en "...$DONE\r"
2170        if [ "$KERN_DISK_MADE" ] ; then
2171            rm -f $imagefile
2172            LogIt "... $disksize KB boot disks were created OK\r"
2173        fi
2174    else
2175        echo -en "...failed\r"
2176        LogIt $disksize"KB boot disk was NOT created\r"
2177        rm -f $imagefile
2178    fi
2179    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2180    return $retval
2181}
2182
2183
2184PrepareDataDiskImages() {
2185    local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
2186
2187    imagesdir=$1
2188    rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2189    needlist=$MINDI_TMP/what-we-need.txt
2190    bigdir=$MINDI_TMP/bigdir
2191    minidir_root=$MINDI_TMP/minidir
2192    mkdir -p $minidir_root
2193    mkdir -p $bigdir/usr/bin
2194    tardir=$MINDI_TMP/tardir
2195
2196    if [ -e "$DEPLIST_FILE" ]; then
2197        lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
2198    else
2199        lfiles="$DEPLIST_DIR/*"
2200    fi
2201    lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
2202    cat $lfiles | GenerateGiantDependencyList $needlist $lines
2203    res=$?
2204    if [ "$YOUR_KERNEL_SUCKS" ]; then
2205        pwd=`pwd`
2206        cd $MINDI_TMP
2207        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2208            cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2209            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2210                cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2211            else
2212                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2213                BIGNO=$(($BIGNO+1))
2214            fi
2215        done
2216        for i in $EXTRA_MODS ; do
2217            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
2218            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
2219            for k in $j ; do
2220                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2221                    cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2222                else
2223                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2224                    BIGNO=$(($BIGNO+1))
2225                fi
2226                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2227            done
2228        done
2229        cd $pwd
2230    else
2231        ListKernelModulePaths >> $needlist
2232    fi
2233    if [ "$res" -ne "0" ] ; then
2234        Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2235    fi
2236    FindAndAddUserKeyboardMappingFile
2237    mkdir -p $bigdir/tmp
2238    if [ _"$MONDO_SHARE" != _"" ]; then
2239        cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
2240    fi
2241    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2242    DropOptimizedLibraries $needlist $bigdir
2243    echo -en "Assembling dependency files"
2244    CopyDependenciesToDirectory < $needlist $bigdir
2245
2246    # also copy io.sys and msdos.sys, if we can find them
2247    for i in `mount | cut -d' ' -f3` ; do
2248        for j in io.sys msdos.sys ; do
2249            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2250        done
2251    done
2252
2253    # master boot record, too
2254    if [ _"$MONDORESTORECFG" != _"" ]; then
2255        i=`grep bootloader.device $MONDORESTORECFG | cut -d'=' -f2 2> /dev/null`
2256        if [ "$i" ] ; then
2257            LogIt "Backing up $i's MBR"
2258            dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2259            sleep 1
2260            sync
2261            j=$i
2262            [ -h "$j" ] && j=`readlink -f $j`
2263            LogIt "Creating /dev/boot_device ($j)"
2264            mkdir -p $bigdir/dev
2265            cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2266        fi
2267    fi
2268
2269    old_pwd=`pwd`
2270    cd $bigdir
2271
2272    [ -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'."
2273    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2274    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2275        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2276    fi
2277    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2278        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2279        [ "$?" -ne "0" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2280    fi
2281    [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2282    cd $old_pwd
2283    echo -e "$DONE"
2284    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2285    SplitDirectoryIntoMinidirs $bigdir $minidir_root
2286    noof_disks=$?
2287    [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2288    MakeMountlist $MINDI_TMP/mountlist.txt
2289    mkdir -p $minidir_root/$noof_disks/tmp
2290    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"
2291    if [ _"$MONDO_SHARE" != _"" ]; then
2292        cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2293    fi
2294    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2295    cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2296    ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2297    CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2298    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2299    # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2300    rmdir $tardir $bigdir
2301    rm -f $needlist
2302    return $noof_disks
2303}
2304
2305
2306ProcessLDD() {
2307    local main_fname incoming j i fname f newf
2308    main_fname=$1
2309    read incoming
2310    while [ "$incoming" != "" ] ; do
2311        # We take the full path name of the dyn. lib. we want
2312        incoming=`echo "$incoming" | sed '/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*(.*/d ; s/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*\(\/.*\)/\1/ ; s/[[:blank:]]*\(\/.*\)[[:blank:]]*(.*/\1/'`
2313        for f in `echo "$incoming"` ; do
2314            echo "$f `ReadAllLink $f`"
2315        done
2316        read incoming
2317    done
2318}
2319
2320
2321Prompt() {
2322    echo -en "$1"
2323    read line
2324}
2325
2326
2327ReadLine() {
2328    local i incoming
2329    read incoming
2330    i=0
2331    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2332        i=$(($i+1))
2333        read incoming
2334    done
2335    echo "$incoming"
2336}
2337
2338
2339RejigHyperlinks() {
2340    local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2341    minidir_root=$1
2342    noof_disks=$2
2343
2344    old_pwd=`pwd`
2345    diskno=1
2346    while [ "$diskno" -le "$noof_disks" ] ; do
2347        mkdir -p $minidir_root/$diskno
2348        cd $minidir_root/$diskno
2349        for fname in `find -type d -o -print` ; do
2350            [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2351        done
2352        diskno=$(($diskno+1))
2353    done
2354
2355    cd $old_pwd
2356    return
2357}
2358
2359
2360ReplaceIndividualLine() {
2361    local orig_file new_file lino newstring lines_total lines_remaining
2362
2363    orig_file=$1.orig
2364    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2365    new_file=$1
2366    lino=$2
2367    newstring="$3"
2368    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2369        echo "Can't find string" >> $LOGFILE
2370        return 1
2371    fi
2372    lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2373    lines_remaining=$(($lines_total-$lino))
2374    head -n$(($lino-1)) $orig_file > $new_file
2375    echo "$newstring" >> $new_file
2376    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2377    tail -n$lines_remaining $orig_file >> $new_file
2378    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2379    [ -x "$orig_file" ] && chmod +x $new_file
2380    rm -f $orig_file
2381    return 0
2382}
2383
2384
2385ScanCDandTape() {
2386    local i
2387
2388    for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2389        dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2390    done
2391}
2392
2393
2394SizeOfPartition() {
2395    local devpath drive res stub
2396    device=$1
2397    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2398        res=`SizeOfRaidPartition $device`
2399        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2400        echo "$res"
2401        return 0
2402    fi
2403    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2404    res=`$FDISK -s $device 2>> $LOGFILE`
2405    # end patch
2406    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2407    [ "$res" = "" ] && res="-1"
2408    echo $res
2409    return 0
2410}
2411
2412
2413SizeOfRaidPartition() {
2414    local real_dev smallest_size silly tmp
2415
2416    silly=999999999
2417    smallest_size=$silly
2418
2419    for real_dev in `GetRaidDevMembers $1` ; do
2420        tmp=`SizeOfPartition $real_dev`
2421        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2422    done
2423
2424    if [ "$smallest_size" = "$silly" ] ; then
2425        echo "-1"
2426        return 1
2427    else
2428        echo "$smallest_size"
2429        return 0
2430    fi
2431}
2432
2433
2434StripComments()
2435{
2436    local tempfile
2437
2438    tempfile=$MINDI_TMP/$$.strip.txt
2439    cp -f $1 $tempfile 2>> $LOGFILE
2440    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2441    rm -f $tempfile
2442    echo "Stripped comments from $2" >> $LOGFILE
2443}
2444
2445
2446SplitDirectoryIntoMinidirs() {
2447    local bigdir minidir_root i noof_disks old_pwd res
2448
2449    bigdir=$1
2450    minidir_root=$2
2451    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2452
2453    TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2454    noof_disks=$?
2455    if [ "$noof_disks" -eq "0" ] ; then
2456        echo "Failed to fit data into several dirs."
2457        return 0
2458    fi
2459    RejigHyperlinks $minidir_root $noof_disks
2460    [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2461    return $noof_disks
2462}
2463
2464
2465StripExecutable()
2466{
2467    local tmpfile
2468
2469    tmpfile=$MINDI_TMP/stripped.$$.dat
2470    [ -d "$1" ] || [ -h "$1" ] && return
2471    cp -f $1 $tmpfile 2>> $LOGFILE
2472    strip $tmpfile 2> /dev/null
2473    if [ "$?" -eq "0" ] ; then
2474        cp -f $tmpfile $1 2>> $LOGFILE
2475        echo "Stripped binary $2" >> $LOGFILE
2476    fi
2477    rm -f $tmpfile
2478}
2479
2480
2481TemporarilyCompressAllFiles() {
2482    local i orig_fname out_fname out_list
2483
2484    i=0
2485    out_list=$2/compressed/compressed.txt
2486    mkdir -p $2/compressed
2487    > $out_list
2488    for orig_fname in $1 ; do
2489        out_fname=$2/compressed/$orig_fname.gz
2490        mkdir -p $out_fname 2> /dev/null
2491        rmdir $out_fname 2> /dev/null
2492        gzip -c6 $orig_fname > $out_fname 2> /dev/null
2493        i=$(((($i+1))%15))
2494        [ "$i" -eq "0" ] && echo -en "."
2495        du -sk $out_fname >> $out_list
2496    done
2497}
2498
2499
2500TryToFindKernelPath() {
2501    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2502
2503    we_want_version=`uname -r`
2504    possible_kernels=""
2505    duff_kernels=""
2506   
2507    if [ "$ARCH" = "ia64" ] ; then
2508       root="/boot/efi/efi"
2509    else
2510       root="/"
2511    fi
2512    for fname in `find $root -maxdepth 2 -type f | grep -F lin | grep -Ev '^/proc/|^/net/'` ; do
2513        [ ! -e "$fname" ] && continue
2514        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2515        file $fname | grep -q gzip
2516        if [ "$?" -eq "0" ] ; then
2517            # Used by ia64
2518            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2519        else
2520            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2521        fi
2522        [ "$fkern_ver" = "" ] && continue
2523        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2524        [ -f "$fname" ] || continue
2525        [ -h "$fname" ] && continue
2526        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2527        file $fname | grep -q gzip
2528        if [ "$?" -eq "0" ] ; then
2529            # Used by ia64
2530            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2531                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2532                duff_kernels="$fname $duff_kernels"
2533            else
2534                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2535                possible_kernels="$fname $possible_kernels"
2536            fi
2537        else
2538            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2539                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2540                duff_kernels="$fname $duff_kernels"
2541            else
2542                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2543                possible_kernels="$fname $possible_kernels"
2544            fi
2545        fi
2546    done
2547    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2548        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2549    fi
2550    if [ ! "$possible_kernels" ] ; then
2551        LogIt "No kernel matches exactly. Are there any duff kernels?"
2552        possible_kernels="$duff_kernels"
2553        if [ ! "$possible_kernels" ] ; then
2554            LogIt "Sorry, no duff kernels either"
2555        else
2556            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2557            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2558        fi
2559    fi
2560    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2561    noof_kernels=`CountItemsIn "$possible_kernels"`
2562    if [ "$noof_kernels" -eq "0" ] ; then
2563        LogIt "Could not find your kernel."
2564        if [ -e "/boot/vmlinuz" ] ; then
2565            LogIt "Using /boot/vmlinuz as a last resort."
2566            output=/boot/vmlinuz
2567        else
2568            output=""
2569        fi
2570    elif [ "$noof_kernels" -eq "1" ] ; then
2571        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2572        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2573        output="$kernelpath"
2574    else
2575        for i in $possible_kernels ; do
2576            if echo $i | grep "`uname -r`" ; then
2577                LogIt "OK, I used my initiative and found that "
2578                LogIt "$i is probably your kernel. "
2579                output="$i"
2580                return
2581            fi
2582        done
2583        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2584            output=/boot/vmlinuz
2585            echo "Schlomo, this one's for you." >> $LOGFILE
2586        else
2587            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2588            LogIt "boot disks will still work, probably. If one does not work, try another."
2589            LogIt "$possible_kernels"
2590            echo ""
2591        fi
2592    fi
2593    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2594}
2595
2596
2597TryToFitDataIntoSeveralDirs() {
2598    local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2599    local i retval noof_disks total_files list_of_devs
2600
2601    bigdir=$1
2602    minidir_root=$2
2603    BIG_CLUNKY_SIZE_COUNTER=0
2604    retval=0
2605    noof_disks=1
2606
2607    echo -en "\r                                                                            \rDividing data into several groups..."
2608    old_pwd=`pwd`
2609    cd $bigdir
2610    list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2611    progress=0
2612    total_files=`CountItemsIn "$list_of_files"`
2613    if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2614        filesize=1
2615    fi
2616    mkdir -p $minidir_root/$noof_disks
2617    if [ -e "dev" ] ; then
2618        echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2619        cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2620    fi
2621    TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2622    for filename in $list_of_files ; do
2623        AddFileToDir $filename $minidir_root $noof_disks
2624        i=$?
2625        if [ "$i" -gt "$noof_disks" ] ; then
2626            noof_disks=$i
2627            echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2628        fi
2629        if [ "$i" -eq "0" ] ; then
2630            LogIt "Cannot add file $filename to minidir $minidir_root"
2631            retval=$(($retval+1))
2632        fi
2633        progress=$(($progress+1))
2634        echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2635    done
2636    cd $old_pwd
2637    echo -en "\rThe files have been subdivided into $noof_disks directories.                                                            \r"
2638    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2639    if [ "$retval" -gt "0" ] ; then
2640        return 0
2641    else
2642        return $noof_disks
2643    fi
2644}
2645
2646
2647TurnTgzIntoRdz() {
2648    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
2649
2650    tgz_dir_fname=$1
2651    rdz_fname=$2
2652    ramdisksize=$3
2653    disksize=$4
2654    kernelsize=$5
2655    maxsize=$(($disksize-$kernelsize))
2656    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2657    tempfile=$MINDI_TMP/temp.rd
2658    mountpoint=$MINDI_TMP/mnt1
2659    res=0
2660    echo -en "..."
2661    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2662    echo -en "..."
2663    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2664    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE
2665    echo -en "..."
2666    mkdir -p $mountpoint
2667    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."
2668    echo -en "..."
2669    old_pwd=`pwd`
2670    cd $mountpoint
2671    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2672    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2673    cd dev || Die "Can't cd to dev"
2674    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2675    rm -f dev-entries.tgz
2676    cd ..
2677
2678    for w in insmod.static insmod.static.old ; do
2679        s=`which $w 2> /dev/null`
2680        if [ -e "$s" ] ; then
2681            cp --parents -af $s . 2>> $LOGFILE
2682        fi
2683    done
2684
2685    mkdir -p tmp
2686    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2687    for w in cdrom floppy groovy-stuff ; do
2688        mkdir -p mnt/$w
2689    done
2690    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2691        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2692    #fi
2693    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2694        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2695    fi
2696
2697    lsmod > tmp/original-lsmod.txt
2698   
2699    cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2700    cd $old_pwd
2701    echo -en "..."
2702    MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2703    echo -en "..."
2704    old_pwd=`pwd`
2705    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2706        cd $MINDI_TMP
2707        floppy_modules_path=lib/modules/$FAILSAFE_KVER
2708    else
2709        cd /
2710###
2711### Sq-Modification... Use kernel name in module path if specified.
2712###
2713        #floppy_modules_path=lib/modules/`uname -r`
2714        if [ "${kernelname}" != "" ]
2715        then
2716            floppy_modules_path=lib/modules/${kernelname}
2717        else
2718            floppy_modules_path=lib/modules/`uname -r`
2719        fi
2720###
2721### Sq-Modification end
2722###
2723    fi
2724    floppy_modules=""
2725    if [ "$disksize" -lt "2880" ] ; then
2726        list_of_groovy_mods="$FLOPPY_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2727    else
2728        list_of_groovy_mods="$CDROM_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2729    fi
2730    if [ "$NFS_DEV" != "" ] ; then
2731        # For PXE boot
2732        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2733    fi
2734    [ -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."
2735    for i in $list_of_groovy_mods ; do
2736        floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2737    done
2738    for i in $floppy_modules ; do
2739        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2740        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2741        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2742        cp -df $i $mountpoint/ 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2743        [ "`echo "$i" | grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
2744    done
2745    if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2746        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2747        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2748        [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2749        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2750        rm -f $mountpoint/sbin/devfsd
2751    fi
2752    cd $old_pwd
2753    [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2754    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2755    rm -f $mountpoint/zero
2756    mkdir -p $mountpoint/tmp
2757    if [ _"$MONDO_SHARE" != _"" ]; then
2758        cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null || Die "Cannot copy mondo-restore.cfg to ramdisk"
2759        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2760    fi
2761    mkdir -p $mountpoint/proc
2762    echo "$disksize" > $mountpoint/tmp/$disksize.siz
2763    find $mountpoint -name CVS -exec rm -rf '{}' \;
2764    # Determine what filesystem to use for initrd image
2765    echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2766    gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2767    [ -z  gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2768    case "$gvFileSystem" in
2769    "ext2fs")
2770        # say what will be used
2771        echo "Creating an ext2 initrd image..." >> $LOGFILE
2772        # kernel expects linuxrc in ext2 filesystem
2773        ( cd $mountpoint && ln -sf sbin/init linuxrc )
2774        # unmount loop filesystem and create image file using the standard approach
2775        umount $mountpoint || Die "Cannot unmount $tempfile"
2776        dd if=$tempfile bs=1k 2> /dev/null | gzip -v9 > $rdz_fname 2> /dev/null
2777        # log that we are done
2778        echo "...done." >> $LOGFILE
2779    ;;
2780    "initramfs")
2781        # say what will be used
2782        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2783        # make sure that cpio is there
2784        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2785        # go into filesystem
2786        cd $mountpoint
2787        # kernel expects init in cpio filesystem
2788        ln -sf sbin/init init
2789        # create cpio image file and unmount loop filesystem
2790        find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2791        cd $old_pwd
2792        umount $mountpoint || Die "Cannot unmount $tempfile"
2793        # log that we are done
2794        echo "...done." >> $LOGFILE
2795    ;;
2796    *)
2797        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2798    ;;
2799    esac
2800    if [ "$res" -eq "0" ] ; then
2801        echo -en "..."
2802    else
2803        echo -en "\rMade an rdz WITH ERRORS.           \n"
2804    fi
2805    return 0
2806}
2807
2808
2809WhichOfTheseModulesAreLoaded() {
2810    local modname loaded_modules
2811    loaded_modules=" `lsmod | tr -s ' ' '\t' | cut -f1 | grep -Fvx "Modules" | tr '\n' ' '` "
2812    for modname in $1 ; do
2813        [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2814    done
2815}
2816
2817
2818ZipMinidirsIntoTarballs() {
2819    local minidir_root tardir noof_disks diskno old_pwd i
2820    minidir_root=$1
2821    tardir=$2
2822    noof_disks=$3
2823
2824    echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2825    mkdir -p $tardir
2826    mkdir -p $minidir_root/all
2827    old_pwd=`pwd`
2828    diskno=1
2829    while [ "$diskno" -le "$noof_disks" ] ; do
2830        cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2831        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."
2832        diskno=$(($diskno+1))
2833        echo -n "..."
2834        cp -pRdf * $minidir_root/all 2>> $LOGFILE
2835    done
2836    mkdir -p $minidir_root/all/tmp
2837    cd $minidir_root/all
2838    size_of_all_tools=`du -sk . | cut -f1`
2839    if [ _"$MONDO_SHARE" != _"" ]; then
2840        for q in filelist.full.gz biggielist.txt ; do
2841            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2842            cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2843        done
2844        mkdir -p $minidir_root/all/tmp
2845    fi
2846    tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2847    dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2848    [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2849    cd $old_pwd
2850    [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2851    echo -e "$DONE"
2852}
2853
2854
2855##############################################################################
2856#----------------------------------- Main -----------------------------------#
2857##############################################################################
2858
2859# Now we can create what we nedd
2860mkdir -p $MINDI_TMP
2861
2862# Purge from potential old run
2863if [ _"$MINDI_CACHE" = _"" ]; then
2864    Die "MINDI_CACHE undefined"
2865fi
2866rm -rf $MINDI_CACHE 2> /dev/null
2867mkdir -p $MINDI_CACHE
2868
2869
2870if [ "$1" = "--printvar" ] ; then
2871    shift
2872    if [ _"$1" != _"" ] ; then
2873        set | egrep "^$1" | cut -d= -f2
2874    fi
2875    MindiExit 0
2876fi
2877
2878> $LOGFILE
2879echo "mindi v$MINDI_VERSION" >> $LOGFILE
2880echo "$ARCH architecture detected" >> $LOGFILE
2881echo "mindi called with the following arguments:" >> $LOGFILE
2882echo "$@" >> $LOGFILE
2883echo "Start date : `date`" >> $LOGFILE
2884echo "-----------------------------" >> $LOGFILE
2885
2886if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2887    LogIt "WARNING - Ancient distro detected." 1
2888    ln -sf /etc/conf.modules /etc/modules.conf
2889fi
2890[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2891
2892# Log some capital variables
2893[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2894echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2895echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2896echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2897[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2898echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2899if [ -f $MINDI_CONF ]; then
2900    echo "-----------------------------" >> $LOGFILE
2901    echo " Mindi configuration file    " >> $LOGFILE
2902    echo "-----------------------------" >> $LOGFILE
2903    cat $MINDI_CONF >> $LOGFILE
2904    echo "-----------------------------" >> $LOGFILE
2905fi
2906
2907
2908trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2909
2910# Sanity checks
2911which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2912which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2913which 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."
2914which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2915if which awk &> /dev/null ; then
2916    if ! which gawk &> /dev/null ; then
2917        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"
2918    fi
2919fi
2920which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2921[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2922
2923[ "`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"
2924# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2925# may have the modprobe configuration spread out across multiple files in
2926# directory /etc/modprobe.d. If this is the case we concatenate these files into
2927# a temporary file for further processing. Otherwise we continue in the standard
2928# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2929# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2930# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2931if [ -d "/etc/modprobe.d" ] && [ `uname -r | cut -c1-3` == "2.6" ] ; then
2932    TMPMODPROBE_FLAG="Y"
2933else
2934    TMPMODPROBE_FLAG="N"
2935    [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2936    [ ! -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..."
2937fi
2938
2939# Update the PATH variable if incomplete
2940if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2941    PATH=$PATH:/sbin:/usr/sbin
2942    export PATH
2943    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2944    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2945    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2946fi
2947
2948# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2949if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2950    source $MINDI_LIB/FindDistroFailsafe
2951    # Log kernel image
2952    LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2953else
2954    [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2955fi
2956
2957if ! which mkfs.vfat &> /dev/null ; then
2958    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2959fi
2960
2961### BERLIOS
2962### Fix as it's not mandatory on ia64
2963if [ "$ARCH" = "ia64" ] ; then
2964    if which elilo &> /dev/null ; then
2965        LILO_EXE=elilo
2966    else
2967        LILO_EXE=`which false`
2968    fi
2969else
2970    FindIsolinuxBinary
2971    FindLiloBinary
2972fi
2973trap "Aborted" SIGTERM
2974DONE="\r\t\t\t\t\t\t\t\tDone.         "
2975CHOPSIZE=240
2976BIGNO=0
2977MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
2978
2979#
2980# Kernel management: Attempt to locate kernel specific module path
2981# if module path is found then use it other wise use uname -r to set it...
2982#
2983#
2984kernelpath="$mindi_kernel"
2985if [ "$kernelpath" = "NATIVE" ]; then
2986    kernelpath=""
2987fi
2988if [ "$kernelpath" = "" ]; then 
2989    kernelpath=`TryToFindKernelPath`
2990fi
2991kernelname=`echo $kernelpath | cut -d'-' -f2-`
2992echo "kernelname = $kernelname" >> $LOGFILE
2993echo "kernelpath = $kernelpath" >> $LOGFILE
2994if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2995then
2996   echo "Module path for ${kernelpath} not found..." >> $LOGFILE
2997   echo "using running kernel\'s modules." >> $LOGFILE
2998   kernelname=`uname -r`
2999else
3000   echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3001fi
3002
3003if [ -d "/proc/lvm" ]; then
3004    # LVM v1
3005    LVMCMD=""
3006    LVM="v1"
3007elif [ -d "/dev/mapper" ]; then
3008    # LVM v2
3009    LVMCMD="lvm"
3010    LVM="v2"
3011else
3012    LVM="false"
3013fi
3014echo "LVM set to $LVM" >> $LOGFILE
3015echo "----------" >> $LOGFILE
3016echo "df result:" >> $LOGFILE
3017echo "----------" >> $LOGFILE
3018df -T >> $LOGFILE
3019echo "-------------" >> $LOGFILE
3020echo "mount result:" >> $LOGFILE
3021echo "-------------" >> $LOGFILE
3022mount >> $LOGFILE
3023echo "-------------" >> $LOGFILE
3024echo "lsmod result:" >> $LOGFILE
3025echo "-------------" >> $LOGFILE
3026lsmod >> $LOGFILE
3027echo "-------------" >> $LOGFILE
3028echo "Liste of extra modules is:" >> $LOGFILE
3029echo "$EXTRA_MODS" >> $LOGFILE
3030echo "-------------" >> $LOGFILE
3031
3032
3033FLOPPY_WAS_MOUNTED=""
3034for mtpt in /media/floppy /mnt/floppy /floppy ; do
3035    if mount | grep -w $mtpt &> /dev/null ; then
3036        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3037        umount $mtpt
3038    fi
3039done
3040
3041#
3042# If we have a USB device we need to store info
3043# and remove it from the parameters line
3044#
3045if [ "$#" -ne "0" ] ; then
3046    if [ "$1" = "--usb" ] ; then
3047        shift
3048        USBDEVICE=$1
3049        if [ _"$USBDEVICE" = _"" ]; then
3050            Die "No USB device specified"
3051        fi
3052        shift
3053    fi
3054fi
3055
3056#
3057# Default value for parameters coming from mondo potentially
3058#
3059if [ "$ARCH" = "ia64" ] ; then
3060    USE_LILO=yes
3061else
3062    USE_LILO=no
3063fi
3064
3065#
3066# These variables are normaly only significant in a mondo environment
3067# Not enforced yet
3068#
3069CDRECOVERY="no"
3070NOT_BOOT="no"
3071EXCLUDE_DEVS=""
3072IMAGE_DEVS=""
3073NFS_DEV=""
3074
3075#
3076# Deal with parameters
3077#
3078if [ "$#" -ne "0" ] ; then
3079    if [ "$1" = "--findkernel" ] ; then
3080        res=`TryToFindKernelPath`
3081        if [ "$res" = "" ] ; then
3082            MindiExit -1
3083        else
3084            echo "$res"
3085            MindiExit 0
3086        fi
3087    elif [ "$1" = "--makemountlist" ] ; then
3088        [ ! "$2" ] && Die "Please specify the output file"
3089        MakeMountlist $2
3090        MindiExit $?
3091    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3092        echo "Mindi v$MINDI_VERSION"
3093        MindiExit 0
3094    elif [ "$1" = "--custom" ] ; then
3095        if [ _"$MONDO_SHARE" = _"" ]; then
3096            Die "--custom is reserved for mondoarchive calls"
3097        fi
3098        MONDO_TMP=$2
3099        # Change MINDI_TMP for the one provided by mondo
3100        # So that it can get back the built files
3101        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3102        rmdir $MINDI_TMP
3103        MINDI_TMP=$MONDO_TMP
3104        mkdir -p $MINDI_TMP
3105        # This is the scratch dir in mondo
3106        MINDI_CACHE=$3
3107        if [ _"$MINDI_CACHE" != _"" ]; then
3108            mkdir -p $MINDI_CACHE
3109        fi
3110
3111        if [ ! -e "$MONDORESTORECFG" ]; then
3112            Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3113        fi
3114
3115        if [ ! -e "$MONDO_CACHE" ]; then
3116            Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3117        else
3118            #
3119            # Get from mondo our additional configuration
3120            #
3121            echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3122            if [ -f $MONDO_CACHE/mindi.conf ]; then
3123                . $MONDO_CACHE/mindi.conf
3124                echo "-----------------------------" >> $LOGFILE
3125                echo " Mondo configuration file    " >> $LOGFILE
3126                echo "-----------------------------" >> $LOGFILE
3127                cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3128                echo "-----------------------------" >> $LOGFILE
3129            else
3130                Die "No mindi.conf file created by mondo. Aborting"
3131            fi
3132        fi
3133
3134        echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3135        echo "------------------------------------" >> $LOGFILE
3136        cat $MONDORESTORECFG >> $LOGFILE
3137        echo "-----------------------------------" >> $LOGFILE
3138
3139        CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3140        NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3141        USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3142        EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3143        NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3144        VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3145        if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3146            IMAGE_DEVS=""
3147        else
3148            IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3149        fi
3150        [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3151        MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3152        if [ _"$MONDO_ROOT" != _"" ]; then
3153            mkdir -p $MONDO_ROOT
3154        else
3155            Die "MONDO_ROOT is undefined"
3156        fi
3157    else
3158        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3159        MindiExit -1
3160    fi
3161fi
3162#ScanCDandTape
3163[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3164if [ "$CDRECOVERY" = "yes" ] ; then
3165    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3166    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3167else
3168    iso_cfg_file=$MINDI_LIB/isolinux.cfg
3169    sys_cfg_file=$MINDI_LIB/syslinux.cfg
3170fi
3171
3172[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3173if [ _"$MONDO_SHARE" = _"" ]; then
3174    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3175    LogIt "Latest Mindi is available from http://www.mondorescue.org"
3176    LogIt "BusyBox sources are available from http://www.busybox.net"
3177else
3178    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> /var/log/mondo-archive.log
3179fi
3180if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3181    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3182else
3183    LogIt "Unable to find mindi-busybox, please install it"
3184    MindiExit -1
3185fi
3186
3187# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3188insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3189for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3190    insmod $i >> $LOGFILE 2>> $LOGFILE
3191done
3192
3193KERN_DISK_MADE=""
3194
3195if [ "$NOT_BOOT" = "yes" ]; then
3196    LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3197    mkdir -p $MINDI_TMP/small-all/tmp
3198    MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3199    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"
3200    cd $MINDI_TMP/small-all
3201    tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3202    sync
3203    LogIt "Done. Exiting."
3204    MindiExit 0
3205fi
3206
3207if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3208    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3209fi
3210if [ "$kernelpath" = "" ] ; then
3211    if [ _"$MONDO_SHARE" != _"" ]; then
3212        Die "Please use -k <path> to specify kernel."
3213    fi
3214    if [ $INTERACTIVE == "yes" ]; then
3215        echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3216        read ch
3217        if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3218            USE_OWN_KERNEL="yes"
3219        fi
3220    fi
3221    if [ "$USE_OWN_KERNEL" = "yes" ]; then
3222        YOUR_KERNEL_SUCKS=""
3223        kernelpath=`TryToFindKernelPath`
3224        if [ "$kernelpath" = "" ] ; then
3225            echo -n "Please enter kernel path : "
3226            read kernelpath
3227        fi
3228    else
3229        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3230    fi
3231fi
3232if [ _"$MONDO_SHARE" = _"" ] && [ $INTERACTIVE = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3233    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3234    read ch
3235    if [ "$ch" = "y" ] || [ "$ch" = "Y" ] ; then
3236        USE_LILO=yes
3237    fi
3238fi
3239if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3240    # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3241    if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3242        source $MINDI_LIB/FindDistroFailsafe
3243        # Log kernel image
3244        LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3245        kernelpath="$FAILSAFE_KBIN"
3246        LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3247        LogIt "The failsafe kernel is $kernelpath.\n"
3248        LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3249        LogIt "disks then it may still be a result of a problem with your kernel.\n"
3250        pwd=`pwd`
3251        cd $MINDI_TMP
3252        mkdir -p lib/modules
3253        cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3254        cd $pwd
3255    else
3256        kernelpath=$MINDI_LIB/vmlinuz
3257        LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3258        LogIt "However, you are still running your kernel. If Mindi fails to create your"
3259        LogIt "disks then it may still be a result of a problem with your kernel."
3260        pwd=`pwd`
3261        cd $MINDI_TMP
3262        bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3263        cd $pwd
3264    fi
3265    YOUR_KERNEL_SUCKS="Your kernel sucks"
3266fi
3267echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3268[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3269
3270[ "$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."
3271
3272rm -f $MINDI_CACHE/{*img,*gz,*iso}
3273
3274PrepareDataDiskImages $MINDI_CACHE
3275noof_disks=$?
3276ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3277rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3278ramdisk_size=$rds
3279
3280echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3281if [ "$USE_LILO" = "yes" ] ; then
3282    if [ "$ARCH" = "ia64" ] ; then
3283        PrepareBootDiskImage_LILO $MINDI_CACHE $IA64_BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3284    else
3285        if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ;  then
3286            LogIt "WARNING - failed to create 2.88MB floppy disk image."
3287            LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3288            PrepareBootDiskImage_LILO $MINDI_CACHE 5760 $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3289        fi
3290    fi
3291else
3292    if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3293        LogIt "WARNING - failed to create 2.88MB floppy disk image."
3294        LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3295        PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 5760 $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
3296    fi
3297fi
3298
3299[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3300...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3301
3302if [ _"$MONDO_SHARE" = _"" ]; then
3303    ListImagesForUser $MINDI_CACHE
3304    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3305        OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
3306    fi
3307    OfferToMakeBootableISO $MINDI_CACHE
3308    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3309        OfferToMakeBootableUSB $MINDI_CACHE
3310    fi
3311    LogIt "Finished."
3312elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3313    rm -f $MINDI_CACHE/{*img,*gz,*iso}
3314    OfferToMakeBootableISO $MINDI_CACHE
3315    if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3316        cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3317    else
3318        Die "Cannot find all.tar.gz, to be written to tape"
3319    fi
3320elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3321    OfferToMakeBootableUSB $MINDI_CACHE
3322else
3323    OfferToMakeBootableISO $MINDI_CACHE
3324fi
3325# cleanup
3326LogIt "$FRIENDLY_OUTSTRING"
3327for mtpt in $FLOPPY_WAS_MOUNTED ; do
3328    mount $mtpt
3329done
3330MindiExit 0
Note: See TracBrowser for help on using the repository browser.