source: branches/stable/mindi/mindi @ 1350

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

Better log file content in mondoarchive.log from the copy of the mindi log

  • Property svn:keywords set to Rev Id
File size: 113.9 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1350 2007-04-25 16:01:31Z bruno $
4#
5#-----------------------------------------------------------------------------
6# mindi - mini-Linux distro based on the user's filesystem & distribution
7#
8# Mindi can create a multi-floppy boot/root kit. The first floppy is the boot
9# disk: it contains a kernel, a ramdisk etc. The second disk is data disk #1;
10# the third disk is data disk #2; and so it goes.
11#
12# See http://www.mondorescue.org for details.
13#-----------------------------------------------------------------------------
14
15### Which arch are we on (useful for ia64 port)
16ARCH=`/bin/arch`
17
18#RUN_AFTER_INITIAL_BOOT_PHASE="echo \"Who lives in a pineapple under the sea?\" > /tmp/spongebob.squarepants.txt"
19    # after booting from floppy/CD image but before
20    # accessing auxiliary data disks (or the rest of
21    # the CD), the initscript will run the above command.
22
23RUN_AFTER_BOOT_PHASE_COMPLETE="ide-opt"
24    # after the emergency boot process is complete but
25    # before the init script runs mondorestore, it will
26    # run this command.
27
28MINDI_REV=RRR
29MINDI_VER=VVV
30
31MINDI_VERSION=${MINDI_VER}-r$MINDI_REV
32MINDI_PREFIX=XXX
33MINDI_CONF=YYY
34MINDI_SBIN=${MINDI_PREFIX}/sbin
35MINDI_LIB=LLL
36
37MINDI_CONFIG_DIST="$MINDI_CONF/mindi.conf.dist"
38if [ ! -f $MINDI_CONFIG_DIST ]; then
39    echo "Unable to find $MINDI_CONFIG_DIST. Please reinstall mindi"
40    exit -1
41fi
42md5sum --status -c "$MINDI_CONF/mindi.conf.dist.md5"
43if [ $? -ne 0 ]; then
44    echo "$MINDI_CONF/mindi.conf.dist md5 checksum incorrect. Please reinstall mindi"
45    exit -1
46fi
47. $MINDI_CONFIG_DIST
48
49MINDI_CONFIG="$MINDI_CONF/mindi.conf"
50if [ ! -f $MINDI_CONFIG ]  && [ "_$1" = "_" ]; then
51    echo "No $MINDI_CONFIG file found using sensible values from $MINDI_CONFIG_DIST"
52else
53    if [ "_$1" = "_" ]; then
54        echo "Using $MINDI_CONFIG as additional config file to $MINDI_CONFIG_DIST"
55    fi
56    . $MINDI_CONFIG
57fi 
58
59#
60# Manages defaults coming from conf files
61#
62INTERACTIVE="$mindi_interactive"
63
64if [ "$INTERACTIVE" = "yes" ]; then
65    # do you want to be prompted to write
66    # floppy images out to floppy disks?
67    # if 'no', images will not be written to floppies
68    PROMPT_WRITE_BOOT_FLOPPIES="yes"
69
70    # Ask if you want to make a CD Image to be written?
71    # if this is set to 'no', then the image will be created automatically
72    PROMPT_MAKE_CD_IMAGE="yes"
73
74    # Ask if you want to make a USB Image to be written?
75    # if this is set to 'no', then the image will be created automatically
76    PROMPT_MAKE_USB_IMAGE="yes"
77
78    # If set to "no", you will be prompted for whether or not
79    # you want to use your own kernel, or the supplied default.
80    # If "yes" mindi will automatically use your own kernel.
81    USE_OWN_KERNEL="no"
82fi
83
84EXTRA_SPACE=$mindi_extra_space
85BOOT_SIZE=$mindi_boot_size
86DEPLIST_DIR="$MINDI_CONF/deplist.d"
87DEPLIST_FILE="$MINDI_CONF/$mindi_deplist_file"
88WRITE_BOOT_FLOPPIES="$mindi_write_boot_floppy"
89PROMPT_MAKE_CD_IMAGE="$mindi_write_cd"
90PROMPT_MAKE_USB_IMAGE="$mindi_write_usb"
91PROMPT_MAKE_TAPE_IMAGE="$mindi_write_tape"
92USE_OWN_KERNEL="$mindi_use_own_kernel"
93MINDI_CACHE="$mindi_cache_dir"
94FORCE_DUAL_FLOPPIES="$mindi_dual_floppies"
95TMPDIR="$mindi_tmp_dir"
96FDDEVICE="$mindi_fd_device"
97USBDEVICE="$mindi_usb_device"
98TAPEDEV="$mindi_tape_device"
99ADDITIONAL_BOOT_PARAMS="$mindi_boot_params"
100MY_FSTAB="$mindi_etc_fstab"
101LOGFILE="$mindi_log_file"
102FLOPPY_MODS="$mindi_floppy_mods"
103TAPE_MODS="$mindi_tape_mods"
104SCSI_MODS="$mindi_scsi_mods"
105IDE_MODS="$mindi_ide_mods"
106PCMCIA_MODS="$mindi_pcmcia_mods"
107USB_MODS="$mindi_usb_mods"
108CDROM_MODS="$TAPE_MODS $FLOPPY_MODS $IDE_MODS $mindi_cdrom_mods $USB_MODS $PCMCIA_MODS"
109NET_MODS="$mindi_net_mods"
110EXTRA_MODS="$CDROM_MODS $mindi_extra_mods $mindi_additional_mods"
111DENY_MODS="mindi_deny_mods"
112FORCE_MODS="mindi_force_mods"
113
114BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
115FDISK=$MINDI_SBIN/parted2fdisk
116MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
117
118# ----------------------------------------------------------------------------
119
120
121AbortHere() {
122    [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
123    Die "Program is terminating in response to signal received from OS/user"
124}
125
126
127HackSyslinuxFile() {
128    local incoming
129    incoming=`ReadLine`
130    while [ "$incoming" ] ; do
131        echo -en "$incoming" | sed s/24000/$1/
132        if [ "`echo "$incoming" | grep append`" ] ; then
133            echo -en " $ADDITIONAL_BOOT_PARAMS"
134        fi
135        echo -en "\n"
136        incoming=`ReadLine`
137    done
138    if [ -e "$MINDI_LIB/memtest.img" ] ; then
139        echo -en "label memtest\n  kernel memdisk\n  append initrd=memtest.img\n\n"
140    fi
141}
142
143
144Aborted() {
145    trap SIGHUP SIGTERM SIGTRAP SIGINT
146    [ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindi*img $MINDI_CACHE/*gz $MINDI_CACHE/mindi.iso
147    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
148    Die "User abort."
149}
150
151
152AddFileToDir() {
153    local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
154    filename=$1
155    minidir_root=$2
156    noof_disks=$3
157
158    diskno=$noof_disks
159    mkdir -p $minidir_root/$diskno
160    [ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
161    if [ ! -e "$filename" ] ; then
162        if [ -h "$filename" ] ; then
163            cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
164            return $noof_disks
165        else
166            Die "AddFileToDir asked me to add $filename, which does not exist. Oops! Did you run out of disk space or is your Linux distro severely broken?"
167        fi
168    fi
169
170    # move to the disk that has room on it (or end up using the last, if all full)
171    while [ "$diskno" -lt "40" ] ; do
172        mkdir -p $minidir_root/$diskno
173        filesize=`du -sk $filename | cut -f1`
174        cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
175        if [ "$filesize" -le "4" ] ; then
176            siz=$filesize
177        elif [ ! -f "$filename" ] ; then
178            siz=0
179        else
180            siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt | cut -f1`
181            [ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
182            siz=$(($siz-2));# to allow for sectors & the fact that they round up
183        fi
184        [ ! "$siz" ] && siz=4
185        [ "$siz" -lt "0" ] && siz=0
186        LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
187        [ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
188        echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
189        LAST_COMPRESSED_SIZE=0
190        rm -f $minidir_root/$diskno/$filename
191        diskno=$(($diskno+1))
192    done
193    return 0 ; # failed
194}
195
196
197AddKeyboardMappingFile() {
198    local mappath r included_list included_item i res ii sss
199    mappath=$1
200    KBDEPTH=$(($KBDEPTH+1))
201    [ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
202    if [ -e "$bigdir/$mappath" ] ; then
203        echo "$mappath already added" >> $LOGFILE
204        return
205    elif [ -d "$bigdir/$mappath" ] ; then
206        echo "Cannot add $mappath: it's a directory. Sorry."
207        return
208    fi
209    echo "Added kbd map $mappath" >> $LOGFILE
210    if [ ! -e "$mappath" ] ; then
211            mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
212        if [ ! -e "$mappath" ] ; then
213            LogIt "Cannot add $mappath: kbd map file not found"
214            return
215        fi
216    else
217        echo -en "`basename $mappath | tr '.' '#' | sed s/#kmap#gz// | sed s/#inc#gz//` " | tr '#' '.'
218    fi
219
220    mkdir -p $bigdir/etc
221    cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE || LogIt "AKMF -- Could not copy $mappath to $bigdir"
222    if [ "`echo $mappath | grep -F ".gz"`" ] ; then
223        included_list=`gzip -dc $mappath | grep -Fi include | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
224    else
225        included_list=`grep -Fi include $mappath | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
226    fi
227    for included_item in $included_list ; do
228        if [ ! -e "$included_item" ] ; then
229                sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
230            [ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
231            for ii in $sss ; do
232                [ -e "$ii" ] && AddKeyboardMappingFile $ii
233            done
234        else
235            AddKeyboardMappingFile $included_item
236        fi
237    done
238}
239
240
241ChopUpAndCopyFile() {
242    local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
243    filename=$1
244    outdir=$2
245    slicesize=$3
246    biggienumber=$4
247
248    [ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
249    mkdir -p $outdir
250
251    sliceno=0
252    scratchfile=$MINDI_TMP/blah.$$.dat
253    cp -f $filename $scratchfile 2>> $LOGFILE || Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
254    [ "`head $scratchfile -n1 | grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
255    [ "`echo "$filename" | grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
256    if [ "`echo "$filename" | grep -F "lib/modules/" | grep "\.*o\.gz"`" != "" ] ; then
257        mv $scratchfile $scratchfile.gz
258        gunzip -f $scratchfile || LogIt "Cannot gunzip $scratchfile.gz"
259        filename=`echo "$filename" | tr '.' '#' | sed s/#o#gz/#o/ | sed s/#ko#gz/#ko/ | tr '#' '.'`
260    fi
261    filesize=`du -sk $scratchfile | cut -f1`
262    noof_slices=$(($filesize/$slicesize))
263    echo "$filename" > $outdir/slice-$biggienumber.name
264    echo "$filesize" > $outdir/slice-$biggienumber.size
265    [ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
266    while [ "$sliceno" -le "$noof_slices" ] ; do
267        dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
268        sliceno=$(($sliceno+1))
269    done
270    rm -f $scratchfile
271}
272
273
274CopyBootBFile() {
275    local copy_to copy_from possible_locations liloc
276    copy_to=$1
277    copy_from=/boot/boot.b
278    liloc=`which lilo.real 2>/dev/null`
279    [ $liloc ] || liloc=`which lilo 2>/dev/null`
280    if [ $liloc ]; then
281        if ! [ `strings $liloc | grep "boot\.b"` ]; then
282            LogIt "boot.b files built into lilo; I'll create a dummy."
283            > $copy_to
284            return 0
285        fi
286    fi
287    if [ ! -f "$copy_from" ] ; then
288        LogIt "OK, you don't have a /boot/boot.b file, which is odd because\n most _good_ Linux distributions come with one, even if it's only a softlink"
289        copy_from=`grep install= /etc/lilo.conf | grep "\.b" | cut -d'=' -f2`
290        if [ ! -f "$copy_from" ] ; then
291            LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
292            copy_from=`FindSensibleBootBFile`
293            LogIt "I'm going to use '$copy_from'"
294        fi
295    fi
296    cp -f $copy_from $copy_to 2>> $LOGFILE || LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
297}
298
299
300CopyDependenciesToDirectory() {
301    local outdir incoming fname filesize counter
302    outdir=$1
303    mkdir -p $outdir
304    incoming=`ReadLine`
305    counter=0
306    while [ "$incoming" != "" ] ; do
307        if [ -d "$incoming" ] ; then
308            find $incoming/* -maxdepth 0 2> /dev/null | CopyDependenciesToDirectory $outdir
309        elif [ -e "$incoming" ] ; then
310            filesize=`du -sk $incoming | cut -f1`
311            if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
312                ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
313                BIGNO=$(($BIGNO+1))
314            else
315                cp --parents -Rdf $incoming $outdir 2> /dev/null || Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
316                if [ "`echo "$incoming" | grep "lib/modules/.*\..*o\.gz"`" != "" ] ; then
317                    gunzip -f $outdir/$incoming || LogIt "Cannot gunzip $outdir/$incoming"
318                fi
319                [ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
320            fi
321            counter=$(($counter+1))
322            if [ "$counter" -ge "5" ] ; then
323                counter=0
324                echo -en "."
325            fi
326        fi
327        incoming=`ReadLine`
328    done
329}
330
331
332CopyImageToDisk() {
333    local image dev procno res comment
334    image=$1
335    dev=$2
336    comment=$3
337    [ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
338    Prompt "About to write $comment. Please press ENTER."
339    echo -en "Formatting disk..."
340    if which fdformat > /dev/null ; then
341        fdformat -n $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
342    elif which superformat > /dev/null ; then
343        superformat $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
344    else
345        Die "Please install either fdformat or superformat."
346    fi
347    echo -en "\nWriting $comment"
348    if echo $image | grep "mindi-[r|b]oot\.1440" &> /dev/null ; then
349        cat $image > $dev &
350    else
351        dd if=$image of=$dev &> /dev/null &
352    fi
353    procno=$!
354    ps $procno > /dev/null 2> /dev/null
355    while [ "$?" -eq "0" ] ; do
356        sleep 3
357        echo -en "."
358        ps $procno > /dev/null 2> /dev/null
359    done
360    echo -e "$DONE"
361    LogIt "$comment has been written."
362}
363
364
365CountItemsIn() {
366    local r
367    r=0
368    for q in $1 ; do
369        r=$(($r+1))
370    done
371    echo $r
372}
373
374
375CreateDataDiskImagesFromTarballs() {
376    local tardir outdir diskno noof_disks kp
377    tardir=$1
378    outdir=$2
379    noof_disks=$3
380
381    mkdir -p $outdir
382    diskno=1
383    echo -en "Creating data disk "
384    while [ "$diskno" -le "$noof_disks" ] ; do
385        echo -en "#$diskno..."
386        cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE || LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
387        CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
388        diskno=$(($diskno+1))
389    done
390    mv -f $tardir/all.tar.gz $outdir
391    du -sk $outdir/*gz >> $LOGFILE
392    echo -e "$DONE"
393}
394
395
396
397CreateOneDataDiskImage() {
398    local tarball imagefile dev diskno noof_disks mountpoint
399    tarball=$1
400    imagefile=$2
401    diskno=$3
402    noof_disks=$4
403
404    mountpoint=$MINDI_TMP/mountpoint.$$
405    mkdir -p $mountpoint
406    dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null || LogIt "Cannot dd (CODI)"
407    echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
408    mke2fs -N 12 -F $imagefile &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
409    mount -t ext2 -o loop $imagefile $mountpoint || Die "Can't loopmount $imagefile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
410    mv $tarball $mountpoint/
411    if [ "$?" -ne "0" ] ; then
412        umount $mountpoint
413        rmdir $mountpoint
414        Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
415    fi
416    [ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
417    umount $mountpoint || LogIt "Cannot umount (CODI)"
418    rmdir $mountpoint || LogIt "Cannot rmdir (CODI)"
419}
420
421# Last function called before exiting
422# Parameter is exit code value
423MindiExit() {
424    local my_partitions
425
426    echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
427    echo "End date : `date`" >> $LOGFILE
428    if [ _"$MONDO_SHARE" != _"" ] ; then
429        echo "------------- mindi logfile included -------------------------" >> /var/log/mondoarchive.log
430        cat $LOGFILE >> /var/log/mondoarchive.log
431        echo "--------------------------------------------------------------">> /var/log/mondoarchive.log
432    fi
433
434    sync
435    cd /
436
437    # Unmount whtat could remain mounted
438    my_partitions=`mount | grep -F $$ | cut -f1 -d' '`
439    [ "$my_partitions" != "" ] && umount $my_partitions
440    # Clean temporary files only when standalone mindi
441    if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
442        rm -Rf $MINDI_TMP
443    fi
444    exit $1
445}
446
447Die() {
448    local i
449    if [ "$1" = "" ] ; then
450        LogIt "FATAL ERROR"
451    else
452        LogIt "FATAL ERROR. $1"
453    fi
454
455    LogIt "Please e-mail a copy of $LOGFILE 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    all_partitions=""
1148   
1149    if [ $LVM != "false" ]; then
1150        echo -en "Analyzing LVM...\n"
1151        $MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
1152        if [ $? -ne 0 ]; then
1153            LVM="false"
1154        fi
1155        all_partitions=`cat $MINDI_TMP/lvm.res | grep -F ">>>" | cut -d' ' -f2-32`
1156    fi
1157    all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
1158#    echo "all partitions = $all_partitions" > /dev/stderr
1159    for i in $IMAGE_DEVS ; do
1160        mount | grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
1161    done
1162    [ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" | tr ' ' '\n' | sort -u | tr '\n ' ' '`"
1163    printf "        %-15s %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL UUID | tee -a $LOGFILE
1164    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"
1165    for c_p in $all_partitions ; do
1166        [ "`echo "$useless_dev" | grep -F "$c_p"`" != "" ] || [ "`echo "$c_p" | grep ":"`" != "" ] && continue
1167        [ "`echo "$c_p" | grep -x "/dev/cdroms.*"`" ] && continue
1168        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
1169            current_partition=`readlink -f $c_p`
1170            [ "`echo "$current_partition" | grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
1171            [ "`echo "$useless_dev" | grep -F "$current_partition"`" ] && continue
1172        else
1173            current_partition="$c_p"
1174        fi
1175        [ "$c_p" = "none" ] && continue
1176        redhat_label=""
1177        uuid=""
1178        absolute_partition=`readlink -f $c_p`
1179        partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1180
1181        # Detects noauto partitions not mounted and exclude them
1182        partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1183        if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" =  "" ] ; then
1184            continue
1185        fi
1186
1187        # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1188        # current_partition contains only first column of /etc/fstab
1189        if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1190            str_to_find_fmt_with=$current_partition
1191            redhat_label=`echo "$current_partition" | cut -d'=' -f2`
1192            actual_dev=""
1193
1194            # 1st try, findfs - the RHEL way of finding labels and their partitions
1195            if [ -x "/sbin/findfs" ]; then
1196                actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1197            fi
1198   
1199            # 2nd try : blkid, the good way for all LABEL except swap
1200            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1201                actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | cut -d':' -f1`
1202                # For LVM FS it will give a /dev/dm-# which should then be converted
1203                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1204                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1205                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1206                    for dev in `ls /dev/mapper/*`; do
1207                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1208                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1209                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1210                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1211                            break
1212                        fi
1213                    done
1214                fi
1215            fi
1216   
1217            # 3rd try, which works on a standard partition (ext2/3), but not on swap
1218            # For LVM gives a /dev/mapper entry
1219            if [ "x$actual_dev" = "x" ]; then
1220                actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | cut -d' ' -f1`
1221            fi
1222   
1223            # 4th try, with vol_id
1224            # SWAP only
1225            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1226                list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | $AWK '{ print $1 }' `
1227                for dev_swap in $list_swaps ; do
1228                    dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1229                    if [ "x$dev_exists" != "x" ]; then
1230                        actual_dev=$dev_swap
1231                        break;
1232                    fi
1233                done
1234            fi
1235
1236            # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1237            # LABEL=SW-cciss/c0d0p3 (RDP)
1238            # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1239            # SWAP only
1240            if [ "x$actual_dev" = "x" -a  _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1241                    for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1242                    do
1243                        # Location of the swap label for kernel 2.6
1244                        try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
1245                        if [ "x$try_dev_label" = "x$redhat_label" ]; then
1246                            actual_dev=$try_dev
1247                        fi
1248                    done
1249            fi
1250
1251            # Check if one of all those tries has known success
1252            if [ "x$actual_dev" != "x" ]; then
1253                current_partition=$actual_dev
1254            else
1255                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"
1256            fi
1257        # This part tries to retrieve the correct device from a UUID line in /etc/fstab
1258        # current_partition contains only first column of /etc/fstab
1259        elif [ "`echo "$current_partition" | /bin/grep -i "UUID="`" != "" ]; then
1260            str_to_find_fmt_with=$current_partition
1261            uuid=`echo "$current_partition" | cut -d'=' -f2`
1262            actual_dev=""
1263
1264            # 1st try, findfs - the RHEL way of finding labels and their partitions
1265            if [ -x "/sbin/findfs" ]; then
1266                actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
1267            fi
1268   
1269            # 2nd try : blkid, the good way for all LABEL except swap
1270            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1271                actual_dev=`/sbin/blkid | /bin/grep "$uuid" | grep UUID= | cut -d':' -f1`
1272                # For LVM FS it will give a /dev/dm-# which should then be converted
1273                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1274                    major=`/bin/ls -l $actual_dev | $AWK '{print $5}'`
1275                    minor=`/bin/ls -l $actual_dev | $AWK '{print $6}'`
1276                    for dev in `ls /dev/mapper/*`; do
1277                        major1=`/bin/ls -l $dev | $AWK '{print $5}'`
1278                        minor1=`/bin/ls -l $dev | $AWK '{print $6}'`
1279                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1280                            actual_dev=`/bin/ls -l $dev | $AWK '{print $10}'`
1281                            break
1282                        fi
1283                    done
1284                fi
1285            fi
1286   
1287            # 3th try, with vol_id
1288            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1289                list_dev=`mount | /bin/grep -E '^/' | $AWK '{ print $1 }' `
1290                for dev in $list_dev ; do
1291                    dev_exists=`/sbin/vol_id $dev | /bin/grep "$uuid"`
1292                    if [ "x$dev_exists" != "x" ]; then
1293                        actual_dev=$dev
1294                        break;
1295                    fi
1296                done
1297            fi
1298
1299            # Check if one of all those tries has known success
1300            if [ "x$actual_dev" != "x" ]; then
1301                current_partition=$actual_dev
1302            else
1303                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"
1304            fi
1305        else
1306            str_to_find_fmt_with=$current_partition
1307        fi
1308
1309        partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1310        # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1311        # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1312        # the former is then a link to the latter, so we test whether
1313        # $current_partition is actually such a link or not and set
1314        # $current_lvolume accordingly. On Debian you may find more than one answer
1315        # so we remove the one corresponding to /dev/.static
1316        # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1317        # principle is the same and we need to find the link to it as well.
1318        # Note that $current_lvolume may well be an
1319        # ordinary device. It is just to make sure that we feed the right value
1320        # into any of the LVM tools if possible.
1321
1322        current_lvolume="$current_partition"
1323        if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1324            # .static dir are a Debian specificity
1325            current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1326            echo $current_lvolume | grep -q ' '
1327            if [ $? -eq 0 ]; then
1328                echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE 
1329            fi
1330        fi
1331        #
1332        # End of LVM device style variation code (other than $current_lvolume).
1333
1334        if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1335            # Size computed via LVM not directly
1336            partition_size="lvm"
1337        else
1338            partition_size=`SizeOfPartition $current_partition`
1339            [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1340            [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1341            if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1342                partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1343                [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1344                [ "$partition_format" != "swap" ] && partition_format="swap"
1345                if [ "$partition_size" = "" ] ; then
1346                    totalsize=0
1347                    items=0
1348                    for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1349                        totalsize=$(($totalsize+$i))
1350                        items=$(($items+1))
1351                    done
1352                    [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1353                    [ "$partition_size" -lt "125000" ] && partition_size=125000
1354                    echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1355                fi
1356            fi
1357        fi
1358        [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1359        [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1360        if [ "$partition_mountpt" = "" ] ; then
1361            if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1362                if  [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1363                    partition_mountpt="raid"
1364                    partition_format="raid"
1365                else
1366                    partition_mountpt="lvm"
1367                    partition_format="lvm"
1368                fi
1369            fi
1370        fi
1371        psz=$partition_size
1372        echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1373        [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1374        if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1375            partition_mountpt="image"
1376            old_partition_fmt=$partition_format
1377            partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1378            partition_size=$(($partition_size+1)); # just in case
1379            if [ "$partition_format" = "Linux" ] ; then
1380                echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1381                echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1382                partition_format=$old_partition_fmt
1383            fi
1384        fi
1385        if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1386            echo "Excluding $current_partition from mountlist" >> $LOGFILE
1387            continue
1388        fi
1389        if [ ! "$partition_mountpt" ] ; then
1390            echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1391            for qq in "" `find /dev/ida/c*d* ! -name '*p*'` ; do
1392                partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1393                [ "$partition_format" ] && break
1394            done
1395            echo "------- $FDISK log end ------------" >> $LOGFILE
1396            if [ "$partition_format" = "Compaq diagnostics" ] ; then
1397                partition_format="compaq"
1398            elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1399                LogIt "Unable to find mountpoint of $current_partition - ignoring"
1400                continue
1401            fi
1402        fi
1403        partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1404        [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1405        unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid`
1406        if [ "$current_partition" = "" ] ; then
1407            echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1408        elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1409            if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1410                partition_mountpt=raid
1411                partition_format=raid
1412                printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid | tee -a $LOGFILE
1413                printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" $uuid >> $mountlist
1414            else
1415                echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1416            fi
1417        elif [ "$partition_format" = "" ] ; then
1418            echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1419        elif [ "$partition_size" = "" ] ; then
1420            echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1421        elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1422            continue
1423        else
1424            if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1425                echo "Stupid bastard..." >> $LOGFILE
1426                partition_format="vfat"
1427            fi
1428            printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid | tee -a $LOGFILE
1429            printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" $uuid >> $mountlist
1430        fi
1431    done
1432}
1433
1434
1435MakeSureNumberIsInteger() {
1436    res=`echo "$1" | tr -s '\-[0-9]' ' '`
1437    if [ "$res" != " " ] && [ "$res" != "" ] ; then
1438    echo "result = '$res'"
1439        Die "$1 should be an integer"
1440    fi
1441}
1442
1443
1444MakeSyslinuxMessageFile() {
1445    mkdir -p $1
1446    rmdir $1
1447    echo -en "  " > $1
1448    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1449        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
1450    else
1451        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
1452    fi
1453    sed s/%r/"`uname -r`"/ $1.tmp | sed s/%t/"`hostname`"/ > $1
1454    rm -f $1.tmp
1455    if [ "$CDRECOVERY" != "yes" ] ; then
1456        if [ "$NFS_DEV" != "" ] ; then
1457            echo -en "Press <enter> to continue.\n" >> $1
1458        elif [ ! "$MINDI_TMP" ] ; then
1459            echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
1460            if [ -e "$MINDI_LIB/memtest.img" ] ; then
1461                echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
1462            fi
1463        else
1464            echo -en "$BOOT_MEDIA_MESSAGE" >> $1
1465        fi
1466    else
1467        echo -en " \
1468To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1469CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1470    fi
1471}
1472
1473
1474MoveHyperlinkSensibly() {
1475    local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
1476    filename=$1
1477    minidir_root=$2
1478    resides_on_diskno=$3
1479    noof_disks=$4
1480
1481    [ -h "$minidir_root/$resides_on_diskno/$filename" ] || Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
1482
1483    old_diskno=$resides_on_diskno
1484    d=1
1485    while [ "$d" -le "$noof_disks" ] ; do
1486        if [ "$d" -ne "$old_diskno" ] ; then
1487            old_pwd=`pwd`
1488            cd $minidir_root/$old_diskno
1489            cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE || Die "Can't move $filename (sensibly) from $old_diskno to $d"
1490            rm -f $filename
1491            cd $old_pwd
1492        fi
1493# when the softlink is resolvable, our work here is done
1494        [ -e "$minidir_root/$d/$filename" ] && return 0
1495        old_diskno=$d
1496        d=$(($d+1))
1497    done
1498    return 1
1499}
1500
1501
1502OfferToCopyImagesToDisks() {
1503    local imagesdir i imagename dev count boot_dev data_dev
1504    imagesdir=$1
1505    boot_dev=$2
1506    data_dev=$3
1507
1508    echo -en "Would you like to create boot+data floppy disks now (y/[n]) ?"
1509    read i
1510    [ "$i" != "y" ] && [ "$i" != "Y" ] && return
1511    mount | grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
1512    echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
1513    [ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
1514    [ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
1515    find $imagesdir -type f > $MINDI_TMP/imagesdir.files
1516    i=`grep -F "/mindi-root.1" $MINDI_TMP/imagesdir.files 2> /dev/null`
1517    j=`grep -F "/mindi-boot" $MINDI_TMP/imagesdir.files | grep -Ev "2880|$BOOT_SIZE"`
1518    if [ "$i" ] ; then
1519        CopyImageToDisk $j $data_dev "boot disk"
1520        CopyImageToDisk $i $data_dev "root disk"
1521    else
1522        CopyImageToDisk $j $boot_dev "boot/root disk"
1523    fi
1524    count=1
1525    for i in `grep -F mindi-data $MINDI_TMP/imagesdir.files` ; do
1526        CopyImageToDisk $i $data_dev "data disk #$count"
1527        count=$(($count+1))
1528    done
1529    rm -f $MINDI_TMP/imagesdir.files
1530}
1531
1532
1533OfferToMakeBootableISO() {
1534    local i old_pwd
1535    if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1536        echo -en "Shall I make a bootable CD image? (y/[n]) "
1537        read i
1538        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1539    fi
1540    if [ _"$MINDI_TMP" = _"" ]; then
1541        Die "MINDI_TMP undefined"
1542    fi
1543    rm -Rf $MINDI_TMP/iso
1544    mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
1545    cp -f $1/*.img $1/*.gz $MINDI_TMP/iso/images 2>> $LOGFILE || LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
1546    old_pwd=`pwd`
1547    cd $MINDI_TMP/iso
1548    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1549    for i in memdisk memtest.bin memtest.img ; do
1550        j=$MINDI_LIB/$i
1551        k=$MINDI_TMP/iso/isolinux
1552        if [ -e "$j" ] ; then
1553            LogIt "Copying $j to $k"
1554            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1555            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1556            if [ _"$MONDO_SHARE" != _"" ]; then 
1557                cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1558            fi
1559        fi
1560    done
1561    MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
1562    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?"
1563    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
1564    if [ _"$MONDO_SHARE" != _"" ]; then 
1565        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?"
1566        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?"
1567
1568    fi
1569    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1570    cd $MINDI_TMP/iso/isolinux
1571    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?"
1572    if [ "$NFS_DEV" != "" ] ; then
1573        perl -pi -e 's/interactive/iso/' isolinux.cfg
1574    fi
1575    if [ "$ARCH" != "ia64" ] ; then
1576        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?"
1577        cp $ISOLINUX ../ 2>> $LOGFILE
1578    fi
1579    cd $MINDI_TMP/iso
1580    if [ "$ARCH" != "ia64" ] ; then
1581        if [ _"$MONDO_SHARE" != _"" ]; then 
1582            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?"
1583            cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
1584        fi
1585        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
1586    else
1587        mkisofs -J -r -o $MINDI_CACHE/mindi.iso -b images/mindi-bootroot.$BOOT_SIZE.img -c isolinux/boot.cat -no-emul-boot . > /dev/null 2> $MINDI_TMP/mkisofs.log
1588    fi
1589    if [ "$?" -ne "0" ] ; then
1590        echo "----------- mkisofs's errors --------------" >> $LOGFILE
1591        cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1592        echo "mkisofs returned the following errors:-"
1593        cat $MINDI_TMP/mkisofs.log
1594        LogIt "Failed to create ISO image."
1595    else
1596        echo "Created bootable ISO image at $MINDI_CACHE/mindi.iso" >> $LOGFILE
1597    fi
1598    rm -f $MINDI_TMP/mkisofs.log
1599    cd $old_pwd
1600}
1601
1602
1603OfferToMakeBootableUSB() {
1604    local i old_pwd
1605    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ _"$MONDO_SHARE" = _"" ]; then
1606        echo "Shall I make a bootable USB image ?"
1607        echo -en "WARNING: This will erase all content on $USBDEVICE (y/[n]) "
1608        read i
1609        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1610    fi
1611    if [ _"$MINDI_TMP" = _"" ]; then
1612        Die "MINDI_TMP undefined"
1613    fi
1614    rm -Rf $MINDI_TMP/usb
1615    mkdir -p $MINDI_TMP/usb
1616    USBPART="${USBDEVICE}1"
1617
1618    echo -en "Transforming $USBDEVICE in a Bootable device " 
1619    echo -en "."
1620    echo "Transforming $USBDEVICE in a Bootable device"  >> $LOGFILE
1621    echo "Checking $USBDEVICE" >> $LOGFILE
1622    $FDISK -l $USBDEVICE 2>&1 >> $LOGFILE
1623    if [ $? -ne 0 ]; then
1624        echo "Unable to access $USBDEVICE" | tee -a $LOGFILE
1625        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1626        MindiExit -1
1627    fi
1628    echo -en "."
1629    echo "Erasing $USBDEVICE" >> $LOGFILE
1630    $FDISK $USBDEVICE 2>&1 >> $LOGFILE << EOF
1631d
1632d
1633d
1634d
1635n
1636p
16371
1638
1639
1640t
1641b
1642a
16431
1644w
1645EOF
1646    if [ $? -ne 0 ]; then
1647        echo "Unable to create a vfat Filesystem on $USBDEVICE" | tee -a $LOGFILE
1648        echo "Make sure your USB device is pluged in" | tee -a $LOGFILE
1649        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1650        MindiExit -1
1651    fi
1652    echo -en "."
1653    echo "Creating a vfat filesystem on $USBPART" >> $LOGFILE
1654    mkfs -t vfat $USBPART 2>&1 >> $LOGFILE
1655    if [ $? -ne 0 ]; then
1656        echo "Unable to create a vfat filesystem on $USBPART" | tee -a $LOGFILE
1657        echo "Make sure your USB device is pluged in and partitioned ($USBPART must exist on it)" | tee -a $LOGFILE
1658        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1659        MindiExit -1
1660    fi
1661    echo -en "."
1662    echo "Mounting $USBPART on $MINDI_TMP/usb" >> $LOGFILE
1663    mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1664    if [ $? -ne 0 ]; then
1665        echo "Unable to mount $USBPART on $MINDI_TMP/usb" | tee -a $LOGFILE
1666        echo "Make sure your USB device is pluged in, partitioned and formated ($USBPART must exist on it)" | tee -a $LOGFILE
1667        $FDISK -l $USBDEVICE 2>&1 | tee -a $LOGFILE
1668        MindiExit -1
1669    fi
1670    echo -en "."
1671    mkdir -p $MINDI_TMP/usb/{images,archives}
1672    cp -f $1/*.img $1/*.gz $MINDI_TMP/usb/images 2>> $LOGFILE || LogIt "OfferToMakeBootableUSB: Cannot copy $i to $MINDI_TMP/iso/images"
1673    echo -en "."
1674    old_pwd=`pwd`
1675    cd $MINDI_TMP/usb
1676    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1677    for i in memdisk memtest.bin memtest.img ; do
1678        j=$MINDI_LIB/$i
1679        k=$MINDI_TMP/usb
1680        if [ -e "$j" ] ; then
1681            LogIt "Copying $j to $k"
1682            cp -f $j $k 2> /dev/null || Die "Failed to copy $j to $k"
1683            cp -f $j $MINDI_TMP 2> /dev/null || Die "Failed to copy $j to $MINDI_TMP"
1684            if [ _"$MONDO_SHARE" != _"" ]; then
1685                cp -f $j $MONDO_ROOT 2>> $LOGFILE || Die "Failed to copy $j to $MONDO_ROOT"
1686            fi
1687        fi
1688    done
1689    echo -en "."
1690    MakeSyslinuxMessageFile $MINDI_TMP/usb/message.txt
1691    echo -en "."
1692    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?"
1693    echo -en "."
1694    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/usb/initrd.img 2>> $LOGFILE
1695    echo -en "."
1696    if [ _"$MONDO_SHARE" != _"" ]; then
1697        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?"
1698        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?"
1699
1700    fi
1701    echo -en "."
1702    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1703    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?"
1704    echo -en "."
1705    if [ "$NFS_DEV" != "" ] ; then
1706        perl -pi -e 's/interactive/iso/' syslinux.cfg
1707    fi
1708    cd $old_pwd
1709    echo -en "."
1710    if [ "$ARCH" != "ia64" ] ; then
1711        if [ _"$MONDO_SHARE" != _"" ]; then
1712            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?"
1713            cp -f $MONDO_SHARE/autorun $MONDO_ROOT 2>> $LOGFILE
1714        fi
1715        umount $MINDI_TMP/usb
1716        syslinux $USBPART 2>> $MINDI_TMP/syslinux.log
1717    else
1718        echo "No USB boot support for ia64" | tee -a $LOGFILE
1719        umount $MINDI_TMP/usb
1720        MindiExit -1
1721    fi
1722    echo -en "."
1723    if [ "$?" -ne "0" ] ; then
1724        echo "----------- syslinux's errors --------------" |tee -a $LOGFILE
1725        cat $MINDI_TMP/syslinux.log |tee -a $LOGFILE
1726        LogIt "Failed to create USB image."
1727    else
1728        echo -e "$DONE"
1729        echo "Created bootable USB image on $USBDEVICE" >> $LOGFILE
1730    fi
1731    rm -f $MINDI_TMP/syslinux.log
1732    #
1733    # If mondoarchive, then tranfer $MINDI_CACHE content to the USB device
1734    # and mount that device under that mountpoint instead
1735    # Has to be done at the end here.
1736    #
1737    if [ _"$MONDO_SHARE" != _"" ]; then
1738        mount $USBPART $MINDI_TMP/usb 2>> $LOGFILE
1739        mv $MINDI_CACHE/* $MINDI_TMP/usb
1740        umount $MINDI_TMP/usb
1741        mount $USBPART $MINDI_CACHE
1742    fi
1743}
1744
1745
1746PluralOrNot() {
1747    [ "$1" -gt "1" ] && echo -en "s"
1748}
1749
1750
1751MakeMessageFile() {
1752    local disksize
1753    disksize=$1
1754    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1755        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`"/
1756    else
1757        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`/
1758    fi
1759    if [ "$disksize" -gt "2880" ] ; then
1760        if [ _"$MONDO_SHARE" != _"" ]; then
1761            if [ "$CDRECOVERY" != "yes" ] ; then
1762                if [ "$NFS_DEV" != "" ] ; then
1763                    echo -en "Press <enter> to continue.\n"
1764                elif [ ! "$MINDI_TMP" ] ; then
1765                    echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1766                else
1767                    echo -en "$BOOT_MEDIA_MESSAGE"
1768                fi
1769            fi
1770        fi
1771    fi
1772    if [ "$CDRECOVERY" = "yes" ] ; then
1773        echo -en "\
1774To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1775CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1776    fi
1777    echo -en "\n\n\n"
1778}
1779
1780
1781write_full_floppy_of_kernel() {
1782    local mtpt image old_pwd res disksize
1783
1784    res=0
1785    old_pwd=`pwd`
1786    KERN_DISK_MADE=1
1787    disksize=$3
1788    rand1=$RANDOM
1789    rand2=$RANDOM
1790    image=$MINDI_TMP/$rand1.$rand2.img
1791    mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
1792    dd if=/dev/zero of=$image bs=1k count=$disksize &> /dev/null
1793    echo "Creating ext2 filesystem on $image" >> $LOGFILE
1794    mke2fs -N 26 -F $image &> /dev/null || Die "Unable to create an ext2 file system on $image"
1795    mkdir -p $mtpt
1796    mount -o loop $image $mtpt
1797    cd $mtpt
1798    mkdir -p {dev,tmp,boot}
1799    cp -f $1 vmlinuz 2>> $LOGFILE
1800    if [ "$?" -ne "0" ] ; then
1801        LogIt "Failed to copy $1 to ramdisk"
1802        cd $old_pwd
1803        umount $mtpt
1804        rmdir $mtpt
1805        rm $image
1806        return 1
1807    fi
1808
1809    rdev vmlinuz 2,0
1810    rdev -R vmlinuz 0
1811    rdev -r vmlinuz 49152
1812
1813    tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1814    # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
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" != "$BOOT_SIZE" ] && 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 &> /dev/null || Die "Unable to create an ext2 file system on $imagefile"
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    # BERLIOS : Useless and generating errors on CentOS ? (losetup miss a param)
1952    #losetup /dev/loop0 > /dev/null 2> /dev/null
1953    #[ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary."
1954    CopyBootBFile $mountpoint/boot.b
1955
1956    MakeLiloConfFile $disksize > $liloconf
1957
1958    # Copy it so that CD-ROM menu entry is satisfied
1959    if [ "$ARCH" = "ia64" ] ; then
1960        mountefi=0
1961        df -T | grep /boot/efi | grep -q vfat
1962        if [ $? -ne 0 ]; then
1963            mount /boot/efi
1964            if [ $? -ne 0 ]; then
1965                echo "You have to mount your EFI partition when using mindi"
1966                MindiExit -1
1967            fi
1968            mountefi=1
1969        fi
1970        cp /boot/efi/elilo.efi $mountpoint
1971        cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
1972        if [ $mountefi -eq 1 ]; then
1973            umount /boot/efi 2>&1 > /dev/null
1974        fi
1975    fi
1976
1977    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1978    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1979    if [ "$?" -ne "0" ] ; then
1980        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1981        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1982        LogIt "Please unload some of your modules and try again."
1983        rm -f $MINDI_TMP/mtpt.$$
1984        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1985        retval=$(($retval+1))
1986    fi
1987    MakeMessageFile $disksize > $mountpoint/message
1988
1989    mkdir -p $mountpoint/tmp
1990    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1991    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1992        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1993        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1994#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1995    fi
1996
1997    # copy the kernel across
1998    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1999    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2000    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2001    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
2002    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2003        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2004        du -sk $mountpoint/* >> $LOGFILE
2005        echo "--- end of list of files ---" >> $LOGFILE
2006        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2007Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2008        rm -f $mountpoint/vmlinuz
2009        cd $old_pwd
2010        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2011        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2012    #   losetup /dev/loop0 -d
2013        res=0
2014        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2015        res=$(($res+$?))
2016        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2017        res=$(($res+$?))
2018        rm -f $imagefile
2019        if [ "$res" -ne "0" ]; then
2020            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2021            rm -f $imagesdir/mindi-*.1440.img
2022        fi
2023        return $res
2024    fi
2025    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2026    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2027    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2028    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2029# make it bootable
2030    rm -f $mountpoint/zero
2031    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2032    if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
2033        if [ "$ARCH" != "ia64" ] ; then
2034        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2035        else
2036            /bin/true
2037        fi
2038    elif [ ! "$KERN_DISK_MADE" ] ; then
2039# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
2040        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2041    else
2042        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
2043    fi
2044
2045    # BERLIOS  does not test necessarily what it expects
2046    if [ $? -ne "0" ] ; then
2047        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2048            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2049            LogIt "Please reboot your PC as a workaround."
2050            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2051        fi
2052        echo "$LILO_EXE -r $mountpoint ...failed."
2053        echo -en "Press ENTER to continue."; read line
2054        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2055        retval=$(($retval+1))
2056    fi
2057    cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2058    if [ "$ARCH" = "ia64" ] ; then
2059        cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2060    fi
2061    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2062    echo -en "..."
2063    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2064    if [ "$retval" -eq "0" ] ; then
2065        echo -en "...$DONE\n"
2066        if [ "$KERN_DISK_MADE" ] ; then
2067            LogIt "$disksize KB boot disks were created OK\n"
2068        fi
2069    else
2070        echo -en "...failed\n"
2071        LogIt $disksize"KB boot disk was NOT created\n"
2072        rm -f $imagefile
2073    fi
2074    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2075    return $retval
2076}
2077
2078
2079PrepareBootDiskImage_SYSLINUX() {
2080    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2081    imagesdir=$1
2082    disksize=$2
2083    kernelpath=$3
2084    ramdisksize=$4
2085    do_boot_root_thingy=""
2086    local retval old_pwd
2087    retval=0
2088
2089    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2090    echo -en "Making "$disksize"KB boot disk..."
2091    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?"
2092    [ "$disksize" != "2880" ] && [ "$disksize" != "$BOOT_SIZE" ] && Die "PDBI - disksize is $disksize - bad size"
2093    echo -en "..."
2094    imagefile=$imagesdir/mindi-bootroot.$disksize.img
2095    mountpoint=$MINDI_TMP/mountpoint.$$
2096    mkdir -p $mountpoint
2097    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2098    echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
2099    mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2100    syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2101
2102    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2103
2104    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2105    old_pwd=`pwd`
2106    MakeSyslinuxMessageFile $mountpoint/message.txt
2107    cd $mountpoint
2108    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2109    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2110    if [ "$NFS_DEV" != "" ] ; then
2111        perl -pi -e 's/interactive/iso/' syslinux.cfg
2112    fi
2113    cd $old_pwd
2114    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2115    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2116    if [ "$?" -ne "0" ] ; then
2117        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2118        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2119        LogIt "Please unload some of your modules and try again."
2120        rm -f $MINDI_TMP/mtpt.$$
2121        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2122        retval=$(($retval+1))
2123    fi
2124
2125    mkdir -p $mountpoint/tmp
2126    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2127
2128    # copy the kernel across
2129    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2130    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2131    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2132    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2133    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2134        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2135        du -sk $mountpoint/* >> $LOGFILE
2136        echo "--- end of list of files ---" >> $LOGFILE
2137        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2138Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2139        rm -f $mountpoint/vmlinuz
2140        cd $old_pwd
2141        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2142        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2143
2144        res=0
2145        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2146        res=$(($res+$?))
2147        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2148        res=$(($res+$?))
2149        rm -f $imagefile
2150        if [ "$res" -ne "0" ]; then
2151            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2152            rm -f $imagesdir/mindi-*.1440.img
2153        fi
2154        return $res
2155    fi
2156    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2157    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2158    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2159    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2160
2161    # make it bootable
2162    rm -f $mountpoint/zero
2163    mkdir -p $mountpoint/etc
2164    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2165    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2166    echo -en "..."
2167    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2168
2169    if [ "$retval" -eq "0" ] ; then
2170        echo -en "...$DONE\n"
2171        if [ "$KERN_DISK_MADE" ] ; then
2172            rm -f $imagefile
2173            LogIt "$disksize KB boot disks were created OK\n"
2174        fi
2175    else
2176        echo -en "...failed\n"
2177        LogIt $disksize"KB boot disk was NOT created\n"
2178        rm -f $imagefile
2179    fi
2180    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2181    return $retval
2182}
2183
2184
2185PrepareDataDiskImages() {
2186    local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
2187
2188    imagesdir=$1
2189    rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2190    needlist=$MINDI_TMP/what-we-need.txt
2191    bigdir=$MINDI_TMP/bigdir
2192    minidir_root=$MINDI_TMP/minidir
2193    mkdir -p $minidir_root
2194    mkdir -p $bigdir/usr/bin
2195    tardir=$MINDI_TMP/tardir
2196
2197    if [ -e "$DEPLIST_FILE" ]; then
2198        lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
2199    else
2200        lfiles="$DEPLIST_DIR/*"
2201    fi
2202    lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
2203    cat $lfiles | GenerateGiantDependencyList $needlist $lines
2204    res=$?
2205    if [ "$YOUR_KERNEL_SUCKS" ]; then
2206        pwd=`pwd`
2207        cd $MINDI_TMP
2208        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2209            cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2210            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2211                cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2212            else
2213                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2214                BIGNO=$(($BIGNO+1))
2215            fi
2216        done
2217        for i in $EXTRA_MODS ; do
2218            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
2219            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
2220            for k in $j ; do
2221                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2222                    cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2223                else
2224                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2225                    BIGNO=$(($BIGNO+1))
2226                fi
2227                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2228            done
2229        done
2230        cd $pwd
2231    else
2232        ListKernelModulePaths >> $needlist
2233    fi
2234    if [ "$res" -ne "0" ] ; then
2235        Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2236    fi
2237    FindAndAddUserKeyboardMappingFile
2238    mkdir -p $bigdir/tmp
2239    if [ _"$MONDO_SHARE" != _"" ]; then
2240        cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
2241    fi
2242    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2243    DropOptimizedLibraries $needlist $bigdir
2244    echo -en "Assembling dependency files"
2245    CopyDependenciesToDirectory < $needlist $bigdir
2246
2247    # also copy io.sys and msdos.sys, if we can find them
2248    for i in `mount | cut -d' ' -f3` ; do
2249        for j in io.sys msdos.sys ; do
2250            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2251        done
2252    done
2253
2254    # master boot record, too
2255    if [ _"$MONDORESTORECFG" != _"" ]; then
2256        i=`grep bootloader.device $MONDORESTORECFG | cut -d'=' -f2 2> /dev/null`
2257        if [ "$i" ] ; then
2258            LogIt "Backing up $i's MBR"
2259            dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2260            sleep 1
2261            sync
2262            j=$i
2263            [ -h "$j" ] && j=`readlink -f $j`
2264            LogIt "Creating /dev/boot_device ($j)"
2265            mkdir -p $bigdir/dev
2266            cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2267        fi
2268    fi
2269
2270    old_pwd=`pwd`
2271    cd $bigdir
2272
2273    [ -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'."
2274    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2275    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2276        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2277    fi
2278    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2279        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2280        [ "$?" -ne "0" ] && [ _"$MONDO_SHARE" != _"" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2281    fi
2282    [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2283    cd $old_pwd
2284    echo -e "$DONE"
2285    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2286    SplitDirectoryIntoMinidirs $bigdir $minidir_root
2287    noof_disks=$?
2288    [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2289    MakeMountlist $MINDI_TMP/mountlist.txt
2290    mkdir -p $minidir_root/$noof_disks/tmp
2291    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"
2292    if [ _"$MONDO_SHARE" != _"" ]; then
2293        cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2294    fi
2295    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2296    cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2297    ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2298    CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2299    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2300    # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2301    rmdir $tardir $bigdir
2302    rm -f $needlist
2303    return $noof_disks
2304}
2305
2306
2307ProcessLDD() {
2308    local main_fname incoming j i fname f newf
2309    main_fname=$1
2310    read incoming
2311    while [ "$incoming" != "" ] ; do
2312        # We take the full path name of the dyn. lib. we want
2313        incoming=`echo "$incoming" | sed '/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*(.*/d ; s/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*\(\/.*\)/\1/ ; s/[[:blank:]]*\(\/.*\)[[:blank:]]*(.*/\1/'`
2314        for f in `echo "$incoming"` ; do
2315            echo "$f `ReadAllLink $f`"
2316        done
2317        read incoming
2318    done
2319}
2320
2321
2322Prompt() {
2323    echo -en "$1"
2324    read line
2325}
2326
2327
2328ReadLine() {
2329    local i incoming
2330    read incoming
2331    i=0
2332    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2333        i=$(($i+1))
2334        read incoming
2335    done
2336    echo "$incoming"
2337}
2338
2339
2340RejigHyperlinks() {
2341    local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2342    minidir_root=$1
2343    noof_disks=$2
2344
2345    old_pwd=`pwd`
2346    diskno=1
2347    while [ "$diskno" -le "$noof_disks" ] ; do
2348        mkdir -p $minidir_root/$diskno
2349        cd $minidir_root/$diskno
2350        for fname in `find -type d -o -print` ; do
2351            [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2352        done
2353        diskno=$(($diskno+1))
2354    done
2355
2356    cd $old_pwd
2357    return
2358}
2359
2360
2361ReplaceIndividualLine() {
2362    local orig_file new_file lino newstring lines_total lines_remaining
2363
2364    orig_file=$1.orig
2365    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2366    new_file=$1
2367    lino=$2
2368    newstring="$3"
2369    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2370        echo "Can't find string" >> $LOGFILE
2371        return 1
2372    fi
2373    lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2374    lines_remaining=$(($lines_total-$lino))
2375    head -n$(($lino-1)) $orig_file > $new_file
2376    echo "$newstring" >> $new_file
2377    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2378    tail -n$lines_remaining $orig_file >> $new_file
2379    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2380    [ -x "$orig_file" ] && chmod +x $new_file
2381    rm -f $orig_file
2382    return 0
2383}
2384
2385
2386ScanCDandTape() {
2387    local i
2388
2389    for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2390        dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2391    done
2392}
2393
2394
2395SizeOfPartition() {
2396    local devpath drive res stub
2397    device=$1
2398    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2399        res=`SizeOfRaidPartition $device`
2400        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2401        echo "$res"
2402        return 0
2403    fi
2404    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2405    res=`$FDISK -s $device 2>> $LOGFILE`
2406    # end patch
2407    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2408    [ "$res" = "" ] && res="-1"
2409    echo $res
2410    return 0
2411}
2412
2413
2414SizeOfRaidPartition() {
2415    local real_dev smallest_size silly tmp
2416
2417    silly=999999999
2418    smallest_size=$silly
2419
2420    for real_dev in `GetRaidDevMembers $1` ; do
2421        tmp=`SizeOfPartition $real_dev`
2422        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2423    done
2424
2425    if [ "$smallest_size" = "$silly" ] ; then
2426        echo "-1"
2427        return 1
2428    else
2429        echo "$smallest_size"
2430        return 0
2431    fi
2432}
2433
2434
2435StripComments()
2436{
2437    local tempfile
2438
2439    tempfile=$MINDI_TMP/$$.strip.txt
2440    cp -f $1 $tempfile 2>> $LOGFILE
2441    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2442    rm -f $tempfile
2443    echo "Stripped comments from $2" >> $LOGFILE
2444}
2445
2446
2447SplitDirectoryIntoMinidirs() {
2448    local bigdir minidir_root i noof_disks old_pwd res
2449
2450    bigdir=$1
2451    minidir_root=$2
2452    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2453
2454    TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2455    noof_disks=$?
2456    if [ "$noof_disks" -eq "0" ] ; then
2457        echo "Failed to fit data into several dirs."
2458        return 0
2459    fi
2460    RejigHyperlinks $minidir_root $noof_disks
2461    [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2462    return $noof_disks
2463}
2464
2465
2466StripExecutable()
2467{
2468    local tmpfile
2469
2470    tmpfile=$MINDI_TMP/stripped.$$.dat
2471    [ -d "$1" ] || [ -h "$1" ] && return
2472    cp -f $1 $tmpfile 2>> $LOGFILE
2473    strip $tmpfile 2> /dev/null
2474    if [ "$?" -eq "0" ] ; then
2475        cp -f $tmpfile $1 2>> $LOGFILE
2476        echo "Stripped binary $2" >> $LOGFILE
2477    fi
2478    rm -f $tmpfile
2479}
2480
2481
2482TemporarilyCompressAllFiles() {
2483    local i orig_fname out_fname out_list
2484
2485    i=0
2486    out_list=$2/compressed/compressed.txt
2487    mkdir -p $2/compressed
2488    > $out_list
2489    for orig_fname in $1 ; do
2490        out_fname=$2/compressed/$orig_fname.gz
2491        mkdir -p $out_fname 2> /dev/null
2492        rmdir $out_fname 2> /dev/null
2493        gzip -c6 $orig_fname > $out_fname 2> /dev/null
2494        i=$(((($i+1))%15))
2495        [ "$i" -eq "0" ] && echo -en "."
2496        du -sk $out_fname >> $out_list
2497    done
2498}
2499
2500
2501TryToFindKernelPath() {
2502    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2503
2504    we_want_version=`uname -r`
2505    possible_kernels=""
2506    duff_kernels=""
2507   
2508    if [ "$ARCH" = "ia64" ] ; then
2509       root="/boot/efi/efi"
2510    else
2511       root="/"
2512    fi
2513    for fname in `find $root -maxdepth 2 -type f | grep -F lin | grep -Ev '^/proc/|^/net/'` ; do
2514        [ ! -e "$fname" ] && continue
2515        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2516        file $fname | grep -q gzip
2517        if [ "$?" -eq "0" ] ; then
2518            # Used by ia64
2519            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2520        else
2521            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2522        fi
2523        [ "$fkern_ver" = "" ] && continue
2524        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2525        [ -f "$fname" ] || continue
2526        [ -h "$fname" ] && continue
2527        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2528        file $fname | grep -q gzip
2529        if [ "$?" -eq "0" ] ; then
2530            # Used by ia64
2531            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2532                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2533                duff_kernels="$fname $duff_kernels"
2534            else
2535                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2536                possible_kernels="$fname $possible_kernels"
2537            fi
2538        else
2539            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2540                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2541                duff_kernels="$fname $duff_kernels"
2542            else
2543                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2544                possible_kernels="$fname $possible_kernels"
2545            fi
2546        fi
2547    done
2548    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2549        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2550    fi
2551    if [ ! "$possible_kernels" ] ; then
2552        LogIt "No kernel matches exactly. Are there any duff kernels?"
2553        possible_kernels="$duff_kernels"
2554        if [ ! "$possible_kernels" ] ; then
2555            LogIt "Sorry, no duff kernels either"
2556        else
2557            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2558            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2559        fi
2560    fi
2561    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2562    noof_kernels=`CountItemsIn "$possible_kernels"`
2563    if [ "$noof_kernels" -eq "0" ] ; then
2564        LogIt "Could not find your kernel."
2565        if [ -e "/boot/vmlinuz" ] ; then
2566            LogIt "Using /boot/vmlinuz as a last resort."
2567            output=/boot/vmlinuz
2568        else
2569            output=""
2570        fi
2571    elif [ "$noof_kernels" -eq "1" ] ; then
2572        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2573        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2574        output="$kernelpath"
2575    else
2576        for i in $possible_kernels ; do
2577            if echo $i | grep "`uname -r`" ; then
2578                LogIt "OK, I used my initiative and found that "
2579                LogIt "$i is probably your kernel. "
2580                output="$i"
2581                return
2582            fi
2583        done
2584        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2585            output=/boot/vmlinuz
2586            echo "Schlomo, this one's for you." >> $LOGFILE
2587        else
2588            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2589            LogIt "boot disks will still work, probably. If one does not work, try another."
2590            LogIt "$possible_kernels"
2591            echo ""
2592        fi
2593    fi
2594    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2595}
2596
2597
2598TryToFitDataIntoSeveralDirs() {
2599    local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2600    local i retval noof_disks total_files list_of_devs
2601
2602    bigdir=$1
2603    minidir_root=$2
2604    BIG_CLUNKY_SIZE_COUNTER=0
2605    retval=0
2606    noof_disks=1
2607
2608    echo -en "\r                                                                            \rDividing data into several groups..."
2609    old_pwd=`pwd`
2610    cd $bigdir
2611    list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2612    progress=0
2613    total_files=`CountItemsIn "$list_of_files"`
2614    if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2615        filesize=1
2616    fi
2617    mkdir -p $minidir_root/$noof_disks
2618    if [ -e "dev" ] ; then
2619        echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2620        cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2621    fi
2622    TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2623    for filename in $list_of_files ; do
2624        AddFileToDir $filename $minidir_root $noof_disks
2625        i=$?
2626        if [ "$i" -gt "$noof_disks" ] ; then
2627            noof_disks=$i
2628            echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2629        fi
2630        if [ "$i" -eq "0" ] ; then
2631            LogIt "Cannot add file $filename to minidir $minidir_root"
2632            retval=$(($retval+1))
2633        fi
2634        progress=$(($progress+1))
2635        echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2636    done
2637    cd $old_pwd
2638    echo -en "\rThe files have been subdivided into $noof_disks directories.                                                            \r"
2639    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2640    if [ "$retval" -gt "0" ] ; then
2641        return 0
2642    else
2643        return $noof_disks
2644    fi
2645}
2646
2647
2648TurnTgzIntoRdz() {
2649    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
2650
2651    tgz_dir_fname=$1
2652    rdz_fname=$2
2653    ramdisksize=$3
2654    disksize=$4
2655    kernelsize=$5
2656    maxsize=$(($disksize-$kernelsize))
2657    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2658    tempfile=$MINDI_TMP/temp.rd
2659    mountpoint=$MINDI_TMP/mnt1
2660    res=0
2661    echo -en "..."
2662    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2663    echo -en "..."
2664    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2665    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile &> /dev/null || Die "Unable to create an ext2 file system on $tempfile"
2666    echo -en "..."
2667    mkdir -p $mountpoint
2668    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."
2669    echo -en "..."
2670    old_pwd=`pwd`
2671    cd $mountpoint
2672    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2673    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2674    cd dev || Die "Can't cd to dev"
2675    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2676    rm -f dev-entries.tgz
2677    cd ..
2678
2679    for w in insmod.static insmod.static.old ; do
2680        s=`which $w 2> /dev/null`
2681        if [ -e "$s" ] ; then
2682            cp --parents -af $s . 2>> $LOGFILE
2683        fi
2684    done
2685
2686    mkdir -p tmp
2687    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2688    for w in cdrom floppy groovy-stuff ; do
2689        mkdir -p mnt/$w
2690    done
2691    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2692        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2693    #fi
2694    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2695        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2696    fi
2697
2698    lsmod > tmp/original-lsmod.txt
2699   
2700    cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2701    cd $old_pwd
2702    echo -en "..."
2703    MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2704    echo -en "..."
2705    old_pwd=`pwd`
2706    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2707        cd $MINDI_TMP
2708        floppy_modules_path=lib/modules/$FAILSAFE_KVER
2709    else
2710        cd /
2711###
2712### Sq-Modification... Use kernel name in module path if specified.
2713###
2714        #floppy_modules_path=lib/modules/`uname -r`
2715        if [ "${kernelname}" != "" ]
2716        then
2717            floppy_modules_path=lib/modules/${kernelname}
2718        else
2719            floppy_modules_path=lib/modules/`uname -r`
2720        fi
2721###
2722### Sq-Modification end
2723###
2724    fi
2725    floppy_modules=""
2726    if [ "$disksize" -lt "2880" ] ; then
2727        list_of_groovy_mods="$FLOPPY_MODS $FORCE_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2728    else
2729        list_of_groovy_mods="$CDROM_MODS $FORCE_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2730    fi
2731    if [ "$NFS_DEV" != "" ] ; then
2732        # For PXE boot
2733        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2734    fi
2735    [ -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."
2736    for i in $list_of_groovy_mods ; do
2737        floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2738    done
2739    for i in $floppy_modules ; do
2740        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2741        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2742        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2743        cp -df $i $mountpoint/ 2>/dev/null || LogIt "Unable to copy $i to $mountpoint"
2744        [ "`echo "$i" | grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
2745    done
2746    if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2747        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2748        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2749        [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2750        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2751        rm -f $mountpoint/sbin/devfsd
2752    fi
2753    cd $old_pwd
2754    [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2755    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2756    rm -f $mountpoint/zero
2757    mkdir -p $mountpoint/tmp
2758    if [ _"$MONDO_SHARE" != _"" ]; then
2759        cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null || Die "Cannot copy mondo-restore.cfg to ramdisk"
2760        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null || Die "Cannot copy mountlist to ramdisk"
2761    fi
2762    mkdir -p $mountpoint/proc
2763    echo "$disksize" > $mountpoint/tmp/$disksize.siz
2764    find $mountpoint -name CVS -exec rm -rf '{}' \;
2765    # Determine what filesystem to use for initrd image
2766    echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
2767    gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
2768    [ -z  gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
2769    case "$gvFileSystem" in
2770    "ext2fs")
2771        # say what will be used
2772        echo "Creating an ext2 initrd image..." >> $LOGFILE
2773        # kernel expects linuxrc in ext2 filesystem
2774        ( cd $mountpoint && ln -sf sbin/init linuxrc )
2775        # unmount loop filesystem and create image file using the standard approach
2776        umount $mountpoint || Die "Cannot unmount $tempfile"
2777        dd if=$tempfile bs=1k 2> /dev/null > ${rdz_fname}.tmp 2> /dev/null
2778        bs=`tune2fs -l ${rdz_fname}.tmp | grep -E '^Block size:' | cut -d: -f2`
2779        ADDITIONAL_BOOT_PARAMS="$ADDITIONAL_BOOT_PARAMS ramdisk_blocksize=$bs"
2780        gzip -v9 ${rdz_fname}.tmp > $rdz_fname 2> /dev/null
2781        rm -f ${rdz_fname}.tmp
2782        # log that we are done
2783        echo "...done." >> $LOGFILE
2784    ;;
2785    "initramfs")
2786        # say what will be used
2787        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2788        # make sure that cpio is there
2789        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2790        # go into filesystem
2791        cd $mountpoint
2792        # kernel expects init in cpio filesystem
2793        ln -sf sbin/init init
2794        # create cpio image file and unmount loop filesystem
2795        find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2796        cd $old_pwd
2797        umount $mountpoint || Die "Cannot unmount $tempfile"
2798        # log that we are done
2799        echo "...done." >> $LOGFILE
2800    ;;
2801    *)
2802        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2803    ;;
2804    esac
2805    if [ "$res" -eq "0" ] ; then
2806        echo -en "..."
2807    else
2808        echo -en "\rMade an rdz WITH ERRORS.           \n"
2809    fi
2810    return 0
2811}
2812
2813
2814WhichOfTheseModulesAreLoaded() {
2815    local modname loaded_modules
2816    loaded_modules=" `lsmod | tr -s ' ' '\t' | cut -f1 | grep -Fvx "Modules" | tr '\n' ' '` "
2817    for modname in $1 ; do
2818        [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2819    done
2820}
2821
2822
2823ZipMinidirsIntoTarballs() {
2824    local minidir_root tardir noof_disks diskno old_pwd i
2825    minidir_root=$1
2826    tardir=$2
2827    noof_disks=$3
2828
2829    echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2830    mkdir -p $tardir
2831    mkdir -p $minidir_root/all
2832    old_pwd=`pwd`
2833    diskno=1
2834    while [ "$diskno" -le "$noof_disks" ] ; do
2835        cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2836        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."
2837        diskno=$(($diskno+1))
2838        echo -n "..."
2839        cp -pRdf * $minidir_root/all 2>> $LOGFILE
2840    done
2841    mkdir -p $minidir_root/all/tmp
2842    cd $minidir_root/all
2843    size_of_all_tools=`du -sk . | cut -f1`
2844    if [ _"$MONDO_SHARE" != _"" ]; then
2845        for q in filelist.full.gz biggielist.txt ; do
2846            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2847            cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2848        done
2849        mkdir -p $minidir_root/all/tmp
2850    fi
2851    tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2852    dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2853    [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2854    cd $old_pwd
2855    [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2856    echo -e "$DONE"
2857}
2858
2859
2860##############################################################################
2861#----------------------------------- Main -----------------------------------#
2862##############################################################################
2863
2864# Now we can create what we nedd
2865mkdir -p $MINDI_TMP
2866
2867# Purge from potential old run
2868if [ _"$MINDI_CACHE" = _"" ]; then
2869    Die "MINDI_CACHE undefined"
2870fi
2871rm -rf $MINDI_CACHE 2> /dev/null
2872mkdir -p $MINDI_CACHE
2873
2874
2875if [ "$1" = "--printvar" ] ; then
2876    shift
2877    if [ _"$1" != _"" ] ; then
2878        set | egrep "^$1" | cut -d= -f2
2879    fi
2880    MindiExit 0
2881fi
2882
2883> $LOGFILE
2884echo "mindi v$MINDI_VERSION" >> $LOGFILE
2885echo "$ARCH architecture detected" >> $LOGFILE
2886echo "mindi called with the following arguments:" >> $LOGFILE
2887echo "$@" >> $LOGFILE
2888echo "Start date : `date`" >> $LOGFILE
2889echo "-----------------------------" >> $LOGFILE
2890
2891if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2892    LogIt "WARNING - Ancient distro detected." 1
2893    ln -sf /etc/conf.modules /etc/modules.conf
2894fi
2895[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2896
2897# Log some capital variables
2898[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2899echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2900echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2901echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2902[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2903echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2904if [ -f $MINDI_CONF ]; then
2905    echo "-----------------------------" >> $LOGFILE
2906    echo " Mindi configuration file    " >> $LOGFILE
2907    echo "-----------------------------" >> $LOGFILE
2908    cat $MINDI_CONF >> $LOGFILE
2909    echo "-----------------------------" >> $LOGFILE
2910fi
2911
2912
2913trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2914
2915# Sanity checks
2916which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2917which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2918which 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."
2919which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2920if which awk &> /dev/null ; then
2921    if ! which gawk &> /dev/null ; then
2922        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"
2923    fi
2924fi
2925which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2926[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2927
2928[ "`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"
2929# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2930# may have the modprobe configuration spread out across multiple files in
2931# directory /etc/modprobe.d. If this is the case we concatenate these files into
2932# a temporary file for further processing. Otherwise we continue in the standard
2933# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2934# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2935# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2936if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
2937    TMPMODPROBE_FLAG="Y"
2938else
2939    TMPMODPROBE_FLAG="N"
2940    [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2941    [ ! -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..."
2942fi
2943
2944# Update the PATH variable if incomplete
2945if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2946    PATH=$PATH:/sbin:/usr/sbin
2947    export PATH
2948    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2949    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2950    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2951fi
2952
2953# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2954if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2955    source $MINDI_LIB/FindDistroFailsafe
2956    # Log kernel image
2957    LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2958else
2959    [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2960fi
2961
2962if ! which mkfs.vfat &> /dev/null ; then
2963    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2964fi
2965
2966### BERLIOS
2967### Fix as it's not mandatory on ia64
2968if [ "$ARCH" = "ia64" ] ; then
2969    if which elilo &> /dev/null ; then
2970        LILO_EXE=elilo
2971    else
2972        LILO_EXE=`which false`
2973    fi
2974else
2975    FindIsolinuxBinary
2976    FindLiloBinary
2977fi
2978trap "Aborted" SIGTERM
2979DONE="\r\t\t\t\t\t\t\t\tDone.         "
2980CHOPSIZE=240
2981BIGNO=0
2982MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
2983
2984#
2985# Kernel management: Attempt to locate kernel specific module path
2986# if module path is found then use it other wise use uname -r to set it...
2987#
2988#
2989kernelpath="$mindi_kernel"
2990if [ "$kernelpath" = "NATIVE" ]; then
2991    kernelpath=""
2992fi
2993if [ "$kernelpath" = "" ]; then 
2994    kernelpath=`TryToFindKernelPath`
2995fi
2996kernelname=`echo $kernelpath | cut -d'-' -f2-`
2997echo "kernelname = $kernelname" >> $LOGFILE
2998echo "kernelpath = $kernelpath" >> $LOGFILE
2999if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3000then
3001   echo "Module path for ${kernelpath} not found..." >> $LOGFILE
3002   echo "using running kernel\'s modules." >> $LOGFILE
3003   kernelname=`uname -r`
3004else
3005   echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3006fi
3007
3008if [ -d "/proc/lvm" ]; then
3009    # LVM v1
3010    LVMCMD=""
3011    LVM="v1"
3012elif [ -d "/dev/mapper" ]; then
3013    # LVM v2
3014    LVMCMD="lvm"
3015    LVM="v2"
3016else
3017    LVM="false"
3018fi
3019echo "LVM set to $LVM" >> $LOGFILE
3020echo "----------" >> $LOGFILE
3021echo "df result:" >> $LOGFILE
3022echo "----------" >> $LOGFILE
3023df -T >> $LOGFILE
3024echo "-------------" >> $LOGFILE
3025echo "mount result:" >> $LOGFILE
3026echo "-------------" >> $LOGFILE
3027mount >> $LOGFILE
3028echo "-------------" >> $LOGFILE
3029if [ -e /etc/raidtab ]; then
3030    echo "-------------" >> $LOGFILE
3031    echo "/etc/raidtab content:" >> $LOGFILE
3032    echo "-------------" >> $LOGFILE
3033    cat /etc/raidtab >> $LOGFILE
3034fi
3035echo "-------------" >> $LOGFILE
3036echo "lsmod result:" >> $LOGFILE
3037echo "-------------" >> $LOGFILE
3038lsmod >> $LOGFILE
3039echo "-------------" >> $LOGFILE
3040echo "Liste of extra modules is:" >> $LOGFILE
3041echo "$EXTRA_MODS" >> $LOGFILE
3042echo "-------------" >> $LOGFILE
3043
3044
3045FLOPPY_WAS_MOUNTED=""
3046for mtpt in /media/floppy /mnt/floppy /floppy ; do
3047    if mount | grep -w $mtpt &> /dev/null ; then
3048        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3049        umount $mtpt
3050    fi
3051done
3052
3053#
3054# If we have a USB device we need to store info
3055# and remove it from the parameters line
3056#
3057if [ "$#" -ne "0" ] ; then
3058    if [ "$1" = "--usb" ] ; then
3059        shift
3060        USBDEVICE=$1
3061        if [ _"$USBDEVICE" = _"" ]; then
3062            Die "No USB device specified"
3063        fi
3064        shift
3065    fi
3066fi
3067
3068#
3069# Default value for parameters coming from mondo potentially
3070#
3071if [ "$ARCH" = "ia64" ] ; then
3072    USE_LILO=yes
3073else
3074    USE_LILO=no
3075fi
3076
3077#
3078# These variables are normaly only significant in a mondo environment
3079# Not enforced yet
3080#
3081CDRECOVERY="no"
3082NOT_BOOT="no"
3083EXCLUDE_DEVS=""
3084IMAGE_DEVS=""
3085NFS_DEV=""
3086
3087#
3088# Deal with parameters
3089#
3090if [ "$#" -ne "0" ] ; then
3091    if [ "$1" = "--findkernel" ] ; then
3092        res=`TryToFindKernelPath`
3093        # Avoids logfile content for mondo
3094        export MONDO_SHARE=""
3095        if [ "$res" = "" ] ; then
3096            MindiExit -1
3097        else
3098            echo "$res"
3099            MindiExit 0
3100        fi
3101    elif [ "$1" = "--makemountlist" ] ; then
3102        [ ! "$2" ] && Die "Please specify the output file"
3103        MakeMountlist $2
3104        # Avoids logfile content for mondo
3105        export MONDO_SHARE=""
3106        MindiExit $?
3107    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3108        echo "Mindi v$MINDI_VERSION"
3109        # Avoids logfile content for mondo
3110        export MONDO_SHARE=""
3111        MindiExit 0
3112    elif [ "$1" = "--custom" ] ; then
3113        if [ _"$MONDO_SHARE" = _"" ]; then
3114            Die "--custom is reserved for mondoarchive calls"
3115        fi
3116        MONDO_TMP=$2
3117        # Change MINDI_TMP for the one provided by mondo
3118        # So that it can get back the built files
3119        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3120        rmdir $MINDI_TMP
3121        MINDI_TMP=$MONDO_TMP
3122        mkdir -p $MINDI_TMP
3123        # This is the scratch dir in mondo
3124        MINDI_CACHE=$3
3125        if [ _"$MINDI_CACHE" != _"" ]; then
3126            mkdir -p $MINDI_CACHE
3127        fi
3128
3129        if [ ! -e "$MONDORESTORECFG" ]; then
3130            Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3131        fi
3132
3133        if [ ! -e "$MONDO_CACHE" ]; then
3134            Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3135        else
3136            #
3137            # Get from mondo our additional configuration
3138            #
3139            echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3140            if [ -f $MONDO_CACHE/mindi.conf ]; then
3141                . $MONDO_CACHE/mindi.conf
3142                echo "-----------------------------" >> $LOGFILE
3143                echo " Mondo configuration file    " >> $LOGFILE
3144                echo "-----------------------------" >> $LOGFILE
3145                cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3146                echo "-----------------------------" >> $LOGFILE
3147            else
3148                Die "No mindi.conf file created by mondo. Aborting"
3149            fi
3150        fi
3151
3152        echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3153        echo "------------------------------------" >> $LOGFILE
3154        cat $MONDORESTORECFG >> $LOGFILE
3155        echo "-----------------------------------" >> $LOGFILE
3156
3157        CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3158        NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3159        USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3160        EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3161        NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3162        VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3163        if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3164            IMAGE_DEVS=""
3165        else
3166            IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3167        fi
3168        [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3169        MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3170        if [ _"$MONDO_ROOT" != _"" ]; then
3171            mkdir -p $MONDO_ROOT
3172        else
3173            Die "MONDO_ROOT is undefined"
3174        fi
3175    else
3176        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3177        MindiExit -1
3178    fi
3179fi
3180#ScanCDandTape
3181[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3182if [ "$CDRECOVERY" = "yes" ] ; then
3183    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3184    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3185else
3186    iso_cfg_file=$MINDI_LIB/isolinux.cfg
3187    sys_cfg_file=$MINDI_LIB/syslinux.cfg
3188fi
3189
3190[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3191if [ _"$MONDO_SHARE" = _"" ]; then
3192    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3193    LogIt "Latest Mindi is available from http://www.mondorescue.org"
3194    LogIt "BusyBox sources are available from http://www.busybox.net"
3195else
3196    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3197fi
3198if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3199    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3200else
3201    LogIt "Unable to find mindi-busybox, please install it"
3202    MindiExit -1
3203fi
3204
3205# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3206insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3207for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3208    insmod $i >> $LOGFILE 2>> $LOGFILE
3209done
3210
3211KERN_DISK_MADE=""
3212
3213if [ "$NOT_BOOT" = "yes" ]; then
3214    LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3215    mkdir -p $MINDI_TMP/small-all/tmp
3216    MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3217    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"
3218    cd $MINDI_TMP/small-all
3219    tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3220    sync
3221    LogIt "Done. Exiting."
3222    MindiExit 0
3223fi
3224
3225if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3226    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3227fi
3228if [ "$kernelpath" = "" ] ; then
3229    if [ _"$MONDO_SHARE" != _"" ]; then
3230        Die "Please use -k <path> to specify kernel."
3231    fi
3232    if [ "$INTERACTIVE" = "yes" ]; then
3233        echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3234        read ch
3235        if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3236            USE_OWN_KERNEL="yes"
3237        fi
3238    fi
3239    if [ "$USE_OWN_KERNEL" = "yes" ]; then
3240        YOUR_KERNEL_SUCKS=""
3241        kernelpath=`TryToFindKernelPath`
3242        if [ "$kernelpath" = "" ] ; then
3243            echo -n "Please enter kernel path : "
3244            read kernelpath
3245        fi
3246    else
3247        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3248    fi
3249fi
3250if [ _"$MONDO_SHARE" = _"" ] && [ "$INTERACTIVE" = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3251    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3252    read ch
3253    if [ "$ch" = "y" ] || [ "$ch" = "Y" ] ; then
3254        USE_LILO=yes
3255    fi
3256fi
3257if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3258    # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3259    if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3260        source $MINDI_LIB/FindDistroFailsafe
3261        # Log kernel image
3262        LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3263        kernelpath="$FAILSAFE_KBIN"
3264        LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3265        LogIt "The failsafe kernel is $kernelpath.\n"
3266        LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3267        LogIt "disks then it may still be a result of a problem with your kernel.\n"
3268        pwd=`pwd`
3269        cd $MINDI_TMP
3270        mkdir -p lib/modules
3271        cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3272        cd $pwd
3273    else
3274        kernelpath=$MINDI_LIB/vmlinuz
3275        LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3276        LogIt "However, you are still running your kernel. If Mindi fails to create your"
3277        LogIt "disks then it may still be a result of a problem with your kernel."
3278        pwd=`pwd`
3279        cd $MINDI_TMP
3280        bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3281        cd $pwd
3282    fi
3283    YOUR_KERNEL_SUCKS="Your kernel sucks"
3284fi
3285echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3286[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3287
3288[ "$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."
3289
3290rm -f $MINDI_CACHE/{*img,*gz,*iso}
3291
3292PrepareDataDiskImages $MINDI_CACHE
3293noof_disks=$?
3294ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3295rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3296ramdisk_size=$rds
3297
3298echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3299if [ "$USE_LILO" = "yes" ] ; then
3300    if [ "$ARCH" = "ia64" ] ; then
3301        PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3302    else
3303        if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ;  then
3304            LogIt "WARNING - failed to create 2.88MB floppy disk image."
3305            LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3306            PrepareBootDiskImage_LILO $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3307        fi
3308    fi
3309else
3310    if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3311        LogIt "WARNING - failed to create 2.88MB floppy disk image."
3312        LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3313        PrepareBootDiskImage_SYSLINUX $MINDI_CACHE $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
3314    fi
3315fi
3316
3317[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3318...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3319
3320if [ _"$MONDO_SHARE" = _"" ]; then
3321    ListImagesForUser $MINDI_CACHE
3322    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3323        OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
3324    fi
3325    OfferToMakeBootableISO $MINDI_CACHE
3326    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3327        OfferToMakeBootableUSB $MINDI_CACHE
3328    fi
3329    LogIt "Finished."
3330elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3331    rm -f $MINDI_CACHE/{*img,*gz,*iso}
3332    OfferToMakeBootableISO $MINDI_CACHE
3333    if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3334        cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3335    else
3336        Die "Cannot find all.tar.gz, to be written to tape"
3337    fi
3338elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3339    OfferToMakeBootableUSB $MINDI_CACHE
3340else
3341    OfferToMakeBootableISO $MINDI_CACHE
3342fi
3343# cleanup
3344LogIt "$FRIENDLY_OUTSTRING"
3345for mtpt in $FLOPPY_WAS_MOUNTED ; do
3346    mount $mtpt
3347done
3348MindiExit 0
Note: See TracBrowser for help on using the repository browser.