source: branches/stable/mindi/mindi @ 1167

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

Better messages for mindi on initramfs/initrd detection

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