root/morphix/trunk/gengrubmenu2/gengrubmenu2

#! /bin/sh

# this is code initally ported by Mantas Kriauciunas <mantas@akl.lt>
# for the Morphix project. The code came for a large part from the 
# grub-installer (taken from debian-installer) postinst script and
# update-grub script from the grub debian package.
# os-prober tool from debian-installer project is needed for finding
# other operating systems.

set -e
#set -x

newline="
"

if [ -z $5 ]; then
    echo "$0 GRUBDIR BOOTDEV ROOTDEV KERNELARGUMENTS IMAGE [INITRD]"
    echo "where: "
    echo " - GRUBDIR is the /boot/grub directory which"
    echo "  contains device.map and will contain your new menu.lst"
    echo " - BOOTDEV is the device grub will boot Morphix from"
    echo " - ROOTDEV is the root= argument to the kernel"
    echo " - KERNELARGUMENTS is the line of arguments to the kernel"
    echo " - IMAGE is the name of the kernel in the BOOTDEV"
    echo " - INITRD is the name of the initrd in the BOOTDEV"
    exit
fi

TARGET="$1"

log=/var/log/messages

log() {
        logger -t grub-installer "$@"
}

error() {
        log "error: $@"
}

info() {
        log "info: $@"
}

get_serial_console() {
        local defconsole="$(sed -e 's/.*console=/console=/' /proc/cmdline)"
        if echo "${defconsole}" | grep -q console=ttyS; then
                local PORT="$(echo "${defconsole}" | sed -e 's%^console=ttyS%%' -e 's%,.*%%')"
                local SPEED="$(echo "${defconsole}" | sed -e 's%^console=ttyS[0-9]\+,%%' -e 's% .*%%')"
                local SERIAL="${PORT},${SPEED}"
                echo "console=$SERIAL"
        fi
}

serial="$(get_serial_console)"

# This is copied from update-grub. We've requested that it be moved
# to a utility or shell library.
# Comment by mantas:
# device.map should be created before convert function is created
# Maybe add check in convert function ?
# device.map can be created with this command:
#grub --batch --no-floppy --no-config-file --device-map=/mnt/target/boot/grub/device.map
# End of comment by mantas
device_map=$TARGET/device.map
# Usage: convert os_device
# Convert an OS device to the corresponding GRUB drive.
# This part is OS-specific.
convert () {
#    # First, check if the device file exists.
#    if test -e "$1"; then
#               :
#    else
#               echo "$1: Not found or not a block device." 1>&2
#               exit 1
#    fi

        host_os=`uname -s | tr '[A-Z]' '[a-z]'`

    # Break the device name into the disk part and the partition part.
    case "$host_os" in
    linux*)
                tmp_disk=`echo "$1" | sed -e 's%\([sh]d[a-z]\)[0-9]*$%\1%' \
                                  -e 's%\(fd[0-9]*\)$%\1%' \
                                  -e 's%/part[0-9]*$%/disc%' \
                                  -e 's%\(c[0-7]d[0-9]*\).*$%\1%'`
                tmp_part=`echo "$1" | sed -e 's%.*/[sh]d[a-z]\([0-9]*\)$%\1%' \
                                  -e 's%.*/fd[0-9]*$%%' \
                                  -e 's%.*/floppy/[0-9]*$%%' \
                                  -e 's%.*/\(disc\|part\([0-9]*\)\)$%\2%' \
                                  -e 's%.*c[0-7]d[0-9]*p*%%'`
        ;;
    gnu*)
                tmp_disk=`echo "$1" | sed 's%\([sh]d[0-9]*\).*%\1%'`
                tmp_part=`echo "$1" | sed "s%$tmp_disk%%"` ;;
    freebsd*)
                tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([saw]d[0-9]*\).*$%r\1%' \
                            | sed 's%r\{0,1\}\(da[0-9]*\).*$%r\1%'`
                tmp_part=`echo "$1" \
                        | sed "s%.*/r\{0,1\}[saw]d[0-9]\(s[0-9]*[a-h]\)%\1%" \
                | sed "s%.*/r\{0,1\}da[0-9]\(s[0-9]*[a-h]\)%\1%"`
        ;;
    netbsd*)
                tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([sw]d[0-9]*\).*$%r\1d%' \
                        | sed 's%r\{0,1\}\(fd[0-9]*\).*$%r\1a%'`
                tmp_part=`echo "$1" \
                        | sed "s%.*/r\{0,1\}[sw]d[0-9]\([abe-p]\)%\1%"`
        ;;
    *)
                echo "update-grub does not support your OS yet." 1>&2
                exit 1 ;;
    esac

    # Get the drive name.
    tmp_drive=`grep -v '^#' $device_map | grep "$tmp_disk *$" \
                        | sed 's%.*\(([hf]d[0-9][a-g0-9,]*)\).*%\1%'`

    # If not found, print an error message and exit.
    if test "x$tmp_drive" = x; then
                echo "$1 does not have any corresponding BIOS drive." 1>&2
                exit 1
    fi

    if test "x$tmp_part" != x; then
                # If a partition is specified, we need to translate it into the
                # GRUB's syntax.
                case "$host_os" in
                linux*)
                echo "$tmp_drive" | sed "s%)$%,`expr $tmp_part - 1`)%" ;;
                gnu*)
                if echo $tmp_part | grep "^s" >/dev/null; then
                                tmp_pc_slice=`echo $tmp_part \
                                | sed "s%s\([0-9]*\)[a-g]*$%\1%"`
                                tmp_drive=`echo "$tmp_drive" \
                                | sed "s%)%,\`expr "$tmp_pc_slice" - 1\`)%"`
                fi
                if echo $tmp_part | grep "[a-g]$" >/dev/null; then
                                tmp_bsd_partition=`echo "$tmp_part" \
                                | sed "s%[^a-g]*\([a-g]\)$%\1%"`
                                tmp_drive=`echo "$tmp_drive" \
                                | sed "s%)%,$tmp_bsd_partition)%"`
                fi
                echo "$tmp_drive" ;;
                freebsd*)
                if echo $tmp_part | grep "^s" >/dev/null; then
                                tmp_pc_slice=`echo $tmp_part \
                                | sed "s%s\([0-9]*\)[a-h]*$%\1%"`
                                tmp_drive=`echo "$tmp_drive" \
                                | sed "s%)%,\`expr "$tmp_pc_slice" - 1\`)%"`
                fi
                if echo $tmp_part | grep "[a-h]$" >/dev/null; then
                                tmp_bsd_partition=`echo "$tmp_part" \
                                | sed "s%s\{0,1\}[0-9]*\([a-h]\)$%\1%"`
                                tmp_drive=`echo "$tmp_drive" \
                                | sed "s%)%,$tmp_bsd_partition)%"`
                fi
                echo "$tmp_drive" ;;
                netbsd*)
                if echo $tmp_part | grep "^[abe-p]$" >/dev/null; then
                                tmp_bsd_partition=`echo "$tmp_part" \
                                | sed "s%\([a-p]\)$%\1%"`
                                tmp_drive=`echo "$tmp_drive" \
                                | sed "s%)%,$tmp_bsd_partition)%"`
                fi
                echo "$tmp_drive" ;;
                esac
    else
                # If no partition is specified, just print the drive name.
                echo "$tmp_drive"
    fi
}

# Convert a linux non-devfs disk device name into the hurd's syntax.
hurd_convert () {
        dr_type=$(expr "$1" : '.*\([hs]d\)[a-h][0-9]*')
        dr_letter=$(expr "$1" : '.*d\([a-h]\)[0-9]*')
        dr_part=$(expr "$1" : '.*d[a-h]\([0-9]*\)')
        case "$dr_letter" in
        a) dr_num=0 ;;
        b) dr_num=1 ;;
        c) dr_num=2 ;;
        d) dr_num=3 ;;
        e) dr_num=4 ;;
        f) dr_num=5 ;;
        g) dr_num=6 ;;
        h) dr_num=7 ;;
        esac
        echo "$dr_type${dr_num}s$dr_part"
}

#The start'

boot=$(convert "$2")
root="$3"
user_params="$4"
image="$5"
initrd="$6"

if test "x$initrd" != x; then
    initrd="initrd $initrd"
fi

#If boot is device, then boot=root in menu.lst
if echo $boot | grep -v "," >/dev/null; then
    boot=$(convert "$3")
fi 

# Mantas-> I don't know what IFS is, but after this newlines are written ;)
IFS="$OLDIFS"

BC_GRUBTEMPLATE1="# See www.gnu.org/software/grub for details
# By default, boot the first entry
default 0
# Boot automatically after 5 seconds
timeout 5

title Morphix GNU/Linux
# kernel path-to-kernel root=rootdevice kernelarguments
root $boot
kernel $image root=$root $user_params
$initrd

title Morphix GNU/Linux (recovery mode)
# kernel path-to-kernel root=rootdevice kernelarguments
root $boot
kernel $image root=$root $user_params single
$initrd
"

#Maybe there should be check if menu.lst already exist ?
echo $BC_GRUBTEMPLATE1 > $TARGET/menu.lst

os-prober > /tmp/os-probed || true

# Generation menu.lst addition for other OSes.
tmpfile=/tmp/menu.lst.extras
OLDIFS="$IFS"
IFS="$newline"
for os in $(cat /tmp/os-probed); do
        IFS="$OLDIFS"
        title=$(echo "$os" | cut -d: -f2)
        type=$(echo "$os" | cut -d: -f4)
        case "$type" in
                chain)
                        partition=$(echo "$os" | cut -d: -f1)
                        grubdrive=$(convert "$partition") || true
                        if [ -n "$grubdrive" ]; then
                                cat >> $tmpfile <<EOF

# This entry automatically added by the Debian installer for a non-linux OS
# on $partition
title           $title
root            $grubdrive
savedefault
EOF
                                # Only set makeactive if grub is installed
                                # in the mbr.
                                if [ "$bootdev" = "(hd0)" ]; then
                                        cat >> $tmpfile <<EOF
makeactive
EOF
                                fi
                                cat >> $tmpfile <<EOF
chainloader     +1

EOF
                        fi
                ;;
                linux)
                        partition=$(echo "$os" | cut -d: -f1)
                        mappedpartition=$partition
                        IFS="$newline"
                        for entry in $(linux-boot-prober "$partition"); do
                                IFS="$OLDIFS"
                                bootpart=$(echo "$entry" | cut -d: -f2)
                                mappedbootpart=$bootpart || true
                                if [ -z "$mappedbootpart" ]; then
                                        mappedbootpart="$bootpart"
                                fi
                                label=$(echo "$entry" | cut -d : -f3)
                                if [ -z "$label" ]; then
                                        label="$title"
                                fi
                                kernel=$(echo "$entry" | cut -d : -f4)
                                initrd=$(echo "$entry" | cut -d : -f5)
                                if echo "$kernel" | grep -q '^/boot/' && \
                                   [ "$mappedbootpart" != "$mappedpartition" ]; then
                                        # separate /boot partition
                                        kernel=$(echo "$kernel" | sed 's!^/boot!!')
                                        initrd=$(echo "$initrd" | sed 's!^/boot!!')
                                        grubdrive=$(convert "$mappedbootpart") || true
                                else
                                        grubdrive=$(convert "$mappedpartition") || true
                                fi
                                params="$(echo "$entry" | cut -d : -f6-) $serial"
                                cat >> $tmpfile <<EOF

# This entry automatically added by the Debian installer for an existing
# linux installation on $mappedpartition.
title           $label (on $mappedpartition)
root            $grubdrive
kernel          $kernel $params
EOF
                                if [ -n "$initrd" ]; then
                                        cat >> $tmpfile <<EOF
initrd          $initrd
EOF
                                fi
                                cat >> $tmpfile <<EOF
savedefault
boot

EOF
                                IFS="$newline"
                        done
                        IFS="$OLDIFS"
                ;;
                hurd)
                        partition=$(echo "$os" | cut -d: -f1)
                        grubdrive=$(convert "$partition") || true
                        hurddrive=$(hurd_convert "$partition") || true
                        # Use the standard hurd boilerplate to boot it.
                        cat >> $tmpfile <<EOF

# This entry automatically added by the Debian installer for an existing
# hurd installation on $partition.
title           $title (on $partition)
root            $grubdrive
kernel          /boot/gnumach.gz root=device:$hurddrive
module          /hurd/ext2fs.static --readonly \\
                        --multiboot-command-line=\${kernel-command-line} \\
                        --host-priv-port=\${host-port} \\
                        --device-master-port=\${device-port} \\
                        --exec-server-task=\${exec-task} -T typed \${root} \\
                        \$(task-create) \$(task-resume)
module          /lib/ld.so.1 /hurd/exec \$(exec-task=task-create)
savedefault
boot

EOF
                ;;
                *)
                        info "unhandled: $os"
                ;;
        esac
        IFS="$newline"
done
IFS="$OLDIFS"
rm -f /tmp/os-probed

if [ -s $tmpfile ]; then
        if [ -s $TARGET/menu.lst ]; then
            cat >> $TARGET/menu.lst << EOF

# This is a divider, added to separate the menu items below from the Debian
# ones.
title           Other operating systems:
root

EOF
        fi
        cat $tmpfile >> $TARGET/menu.lst
        rm -f $tmpfile
fi