transform="@program_transform_name@"

prefix="@prefix@"

exec_prefix="@exec_prefix@"

sbindir="@sbindir@"

bindir="@bindir@"

libdir="@libdir@"

sysconfdir="@sysconfdir@"

PACKAGE_NAME=@PACKAGE_NAME@

PACKAGE_TARNAME=@PACKAGE_TARNAME@

PACKAGE_VERSION=@PACKAGE_VERSION@

target_cpu=@target_cpu@

platform=@platform@

host_os=@host_os@

datarootdir=@datarootdir@

pkglibdir="${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`"

localedir="@datadir@/locale"

self="`basename $0`"

grub_setup="${sbindir}/`echo grub-setup | sed ${transform}`"

grub_mkimage="${bindir}/`echo grub-mkimage | sed ${transform}`"

grub_mkdevicemap="${sbindir}/`echo grub-mkdevicemap | sed ${transform}`"

grub_probe="${sbindir}/`echo grub-probe | sed ${transform}`"

grub_editenv="${bindir}/`echo grub-editenv | sed ${transform}`"

grub_mkrelpath="${bindir}/`echo grub-mkrelpath | sed ${transform}`"

grub_version_check="${bindir}/`echo grub-version-check | sed ${transform}`"

rootdir=

bootdir=

grubdir="`echo "/@bootdirname@/@grubdirname@" | sed 's,//*,/,g'`"

modules=

install_device=

install_dir=

no_floppy=

force_lba=

recheck=no

debug=no

debug_image=

update_nvram=yes

copy_version_lst=no

do_version_check=yes

do_embed_versioning=yes

removable=no

efi_quiet=

if test -f "${sysconfdir}/default/grub" ; then

. "${sysconfdir}/default/grub"

bootloader_id="$(echo "$GRUB_DISTRIBUTOR" | tr 'A-Z' 'a-z' | cut -d' ' -f1)"

if test -z "$bootloader_id"; then

bootloader_id=grub

if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then

disk_module=biosdisk

elif [ "${platform}" = "ieee1275" ] || [ "${platform}" = "efi" ] ; then

disk_module=

disk_module=native

usage () {

argument () {

allow_floppy=""

while test $# -gt 0

option=$1

shift

case "$option" in

-h | --help)

usage

exit 0 ;;

-v | --version)

echo "$self (${PACKAGE_NAME}) ${PACKAGE_VERSION}"

exit 0 ;;

--modules)

modules=`argument $option "$@"`; shift;;

--modules=*)

modules=`echo "$option" | sed 's/--modules=//'` ;;

--font)

shift;;

--font=*)

;;

--root-directory)

rootdir="`argument $option "$@"`"; shift;;

--root-directory=*)

rootdir="`echo "$option" | sed 's/--root-directory=//'`" ;;

--boot-directory)

bootdir="`argument $option "$@"`"; shift;;

--boot-directory=*)

bootdir="`echo "$option" | sed 's/--boot-directory=//'`" ;;

--grub-directory)

grubdir_override="`argument $option "$@"`"; shift;;

--grub-directory=*)

grubdir_override="`echo "$option" | sed 's/--grub-directory=//'`" ;;

--grub-setup)

grub_setup="`argument "$option" "$@"`"; shift;;

--grub-setup=*)

grub_setup="`echo "$option" | sed 's/--grub-setup=//'`" ;;

--bootloader-id)

bootloader_id="`argument $option "$@"`"; shift;;

--bootloader-id=*)

bootloader_id="`echo "$option" | sed 's/--bootloader-id=//'`" ;;

--grub-mkimage)

grub_mkimage="`argument $option "$@"`"; shift;;

--grub-mkimage=*)

grub_mkimage="`echo "$option" | sed 's/--grub-mkimage=//'`" ;;

--grub-mkrelpath)

grub_mkrelpath="`argument "$option" "$@"`"; shift;;

--grub-mkrelpath=*)

grub_mkrelpath="`echo "$option" | sed 's/--grub-mkrelpath=//'`" ;;

--grub-mkdevicemap)

grub_mkdevicemap="`argument "$option" "$@"`"; shift;;

--grub-mkdevicemap=*)

grub_mkdevicemap="`echo "$option" | sed 's/--grub-mkdevicemap=//'`" ;;

--grub-probe)

grub_probe="`argument "$option" "$@"`"; shift;;

--grub-probe=*)

grub_probe="`echo "$option" | sed 's/--grub-probe=//'`" ;;

--no-floppy)

no_floppy="--no-floppy" ;;

--recheck)

recheck=yes ;;

--removable)

removable=yes ;;

--allow-floppy)

allow_floppy="--allow-floppy" ;;

--disk-module)

if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then

disk_module="`argument "$option" "$@"`"; shift;

fi ;;

--disk-module=*)

if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then

disk_module="`echo "$option" | sed 's/--disk-module=//'`"

fi ;;

--no-nvram)

update_nvram=no ;;

# Solaris-specific arguments:

--pkglibdir)

pkglibdir="`argument "$option" "$@"`"; shift ;;

--pkglibdir=*)

pkglibdir="`echo "$option" | sed 's/--pkglibdir=//'`" ;;

--no-embed-versioning)

do_embed_versioning=no ;;

--no-check-versioning)

do_version_check=no ;;

--force-mbr)

force_mbr="--force-mbr" ;;

# This is an undocumented feature...

--debug)

debug=yes ;;

--debug-image)

debug_image="`argument "$option" "$@"`"; shift;;

--debug-image=*)

debug_image="`echo "$option" | sed 's/--debug-image=//'`" ;;

-f | --force)

setup_force="--force" ;;

-*)

echo "Unrecognized option \`$option'" 1>&2

usage

exit 1

;;

*)

if [ "${target_cpu}-${platform}" = "x86_64-efi" ] \

|| [ "${target_cpu}-${platform}" = "i386-efi" ]; then

if test "x$install_dir" != x; then

echo "More than one install_directory?" 1>&2

usage

exit 1

fi

install_dir="${option}"

else

if test "x$install_device" != x; then

echo "More than one install_devices?" 1>&2

usage

exit 1

fi

install_device="${option}"

fi

;;

esac

versiondir="${pkglibdir}"

. ${libdir}/@PACKAGE@/grub-mkconfig_lib

if test "x$install_device" = x && ([ "${target_cpu}-${platform}" = "i386-pc" ] \

|| [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ]); then

echo "install_device not specified." 1>&2

usage

exit 1

elif test "x$install_dir" = x && ([ "${target_cpu}-${platform}" = "x86_64-efi" ] \

|| [ "${target_cpu}-${platform}" = "i386-efi" ]); then

echo "install_directory not specified." 1>&2

usage

exit 1

if ! ([ "${target_cpu}-${platform}" = "i386-pc" ] \

|| [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ]); then

install_device=

if ! ([ "${target_cpu}-${platform}" = "x86_64-efi" ] \

|| [ "${target_cpu}-${platform}" = "i386-efi" ]); then

install_dir=

setup_verbose=

if test x"$debug" = xyes; then

set -x

setup_verbose="--verbose"

efi_quiet=-q

if [ -z "$bootdir" ]; then

# Default bootdir if bootdir not initialized.

bootdir="/@bootdirname@"

if [ -n "$rootdir" ] ; then

# Initialize bootdir if rootdir was initialized.

bootdir="${rootdir}/@bootdirname@"

fi

grubdir="${bootdir}/@grubdirname@"

if ! test x"$grubdir_override" = x; then

if ! test -d "$grubdir_override"; then

echo grub-directory "$grubdir_override" does not exist

exit 1

fi

grubdir="$grubdir_override"

grubdir="`echo "$grubdir" | sed 's,//*,/,g'`"

device_map="${grubdir}/device.map"

if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then

set $grub_setup dummy

if test -f "$1"; then

:

else

echo "$1: Not found." 1>&2

exit 1

fi

set "$grub_mkimage" dummy

if test -f "$1"; then

:

echo "$1: Not found." 1>&2

exit 1

set "$grub_mkdevicemap" dummy

if test -f "$1"; then

:

echo "$1: Not found." 1>&2

exit 1

if [ x"$platform" = xefi ]; then

# Find the EFI System Partition.

efidir=

if test -n "${install_dir}"; then

efidir="${install_dir}"

mkdir -p "$efidir" || exit 1

elif test -d "${bootdir}/efi"; then

install_device="`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${bootdir}/efi"`"

# Is it a mount point?

if test "x$install_device" != "x`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${bootdir}"`"; then

efidir="${bootdir}/efi"

fi

elif test -d "${bootdir}/EFI"; then

install_device="`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${bootdir}/EFI"`"

# Is it a mount point?

if test "x$install_device" != "x`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${bootdir}"`"; then

efidir="${bootdir}/EFI"

fi

elif test -n "$rootdir" && test "x$rootdir" != "x/"; then

# The EFI System Partition may have been given directly using

# --root-directory.

install_device="`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${rootdir}"`"

# Is it a mount point?

if test "x$install_device" != "x`"$grub_mkdevicemap" --device-map=/dev/stdout | "$grub_probe" --target=device --device-map=/dev/stdin "${rootdir}/.."`"; then

efidir="${rootdir}"

fi

fi

if test -n "$efidir"; then

efi_fs=`"$grub_probe" --target=fs "--device-map=${device_map}" "${efidir}"`

if test "x$efi_fs" = xfat; then :; else

echo "${efidir} doesn't look like an EFI partition." 1>&2

efidir=

fi

fi

if test -n "$efidir"; then

# The EFI specification requires that an EFI System Partition must

# contain an "EFI" subdirectory, and that OS loaders are stored in

# subdirectories below EFI. Vendors are expected to pick names that do

# not collide with other vendors. To minimise collisions, we use the

# name of our distributor if possible.

efi_distributor="$bootloader_id"

if test $removable = yes; then

# The specification makes stricter requirements of removable

# devices, in order that only one image can be automatically loaded

# from them. The image must always reside under /EFI/BOOT, and it

# must have a specific file name depending on the architecture.

efi_distributor=BOOT

case "$target_cpu" in

i386)

efi_file=BOOTIA32.EFI ;;

x86_64)

efi_file=BOOTX64.EFI ;;

# GRUB does not yet support these architectures, but they're defined

# by the specification so we include them here to ease future

# expansion.

ia64)

efi_file=BOOTIA64.EFI ;;

esac

else

# It is convenient for each architecture to have a different

# efi_file, so that different versions can be installed in parallel.

case "$target_cpu" in

i386)

efi_file=grubia32.efi ;;

x86_64)

efi_file=grubx64.efi ;;

# GRUB does not yet support these architectures, but they're defined

# by the specification so we include them here to ease future

# expansion.

ia64)

efi_file=grubia64.efi ;;

*)

efi_file=grub.efi ;;

esac

# TODO: We should also use efibootmgr, if available, to add a Boot

# entry for ourselves.

fi

if ! test -n "$install_dir"; then

# If the install_dir was specified, USE THAT DIR, not a derivation.

efidir="$efidir/EFI/$efi_distributor"

mkdir -p "$efidir" || exit 1

fi

else

# We don't know what's going on. Fall back to traditional

# (non-specification-compliant) behaviour.

efidir="$grubdir"

efi_distributor=

efi_file=grub.efi

fi

mkdir -p "$grubdir" || exit 1

if test $recheck = yes; then

rm -f "$device_map"

if test -f "$device_map"; then

# Make sure that there is no duplicated entry.

tmp=`sed -n '/^([fh]d[0-9]*)/s/\(^(.*)\).*/\1/p' "$device_map" \

if test -n "$tmp"; then

echo "The drive $tmp is defined multiple times in the device map $device_map" 1>&2

exit 1

fi

device_map=

if ! test -f "${versiondir}"/version.lst; then

if test x"$do_embed_versioning" = xyes; then

if test x"$do_version_check" = xno; then

# Only emit a message if another one won't be emitted later on.

echo "WARNING: Versioning information not found in $versiondir"

echo " grub-install will not embed versioning information."

fi

do_embed_versioning=no

fi

version_lst_present=no

if test x"$do_version_check" = xno; then

do_embed_versioning=no

else # Check currently installed version.

# If the about to be installed GRUB2 version file is missing, that's an error.

if test x"$version_lst_present" = xno; then

echo "FATAL: Versioning information could not be found in ${versiondir}"

echo "Disable versioning or ensure that ${versiondir}/version.lst is"

echo "present."

exit 1

fi

# If the currently installed GRUB2 version file is missing, proceed with

# the installation.

if test -f "${grubdir}"/version.lst; then

# Both files are available, compare the two versions.

copy_version_lst="`"${grub_version_check}" --source="${versiondir}"/version.lst --dest="${grubdir}"/version.lst -t solaris_grub_version`"

if test x"$copy_version_lst" != xyes; then

echo "The version of GRUB2 installed at ${grubdir} is the same as or newer than the version currently available in ${versiondir}" 1>&2

exit 0

fi

fi

mod_compat="`"${grub_version_check}" -t module_interface_version --dest="${versiondir}"/version.lst`"

if ! test "x$mod_compat" = xyes; then

echo This version of grub-install is not compatible with modules in "${pkglibdir}".

echo Refusing to grub-install with incompatible modules.

exit 5

for file in "${grubdir}"/*.mod "${grubdir}"/*.lst "${grubdir}"/*.img "${grubdir}"/efiemu??.o; do

if test -f "$file" && [ "`basename $file`" != menu.lst ]; then

rm -f "$file" || exit 1

fi

for file in "${pkglibdir}"/*.mod "${pkglibdir}"/*.lst; do

cp -f "$file" "${grubdir}" || exit 1

if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then

for file in "${pkglibdir}"/*.img "${pkglibdir}"/efiemu??.o; do

if test -f "$file"; then

cp -f "$file" "${grubdir}" || exit 1

fi

done

mkdir -p "${grubdir}"/locale/

for dir in "${localedir}"/*; do

if test -f "$dir/LC_MESSAGES/grub.mo"; then

cp -f "$dir/LC_MESSAGES/grub.mo" "${grubdir}/locale/${dir##*/}.mo"

fi

is_path_readable_by_grub "${grubdir}" || (echo "${grubdir}" not readable 1>&2 ; exit 1)

grub_device="`"$grub_probe" --device-map="${device_map}" --target=device "${grubdir}"`" || exit 1

if ! test -f "${grubdir}"/grubenv; then

"$grub_editenv" "${grubdir}"/grubenv create

fs_module="`"$grub_probe" --device-map="${device_map}" --target=fs --device "${grub_device}"`"

if test "x$fs_module" = x ; then

echo "Auto-detection of a filesystem of ${grub_device} failed." 1>&2

echo "Try with --recheck." 1>&2

echo "If the problem persists please report this together with the output of \"$grub_probe --device-map=\"${device_map}\" --target=fs -v ${grubdir}\" to <bug-grub@gnu.org>" 1>&2

exit 1

partmap_module=

for x in `"$grub_probe" --device-map="${device_map}" --target=partmap --device "${grub_device}" 2> /dev/null`; do

case "$x" in

netbsd | openbsd)

partmap_module="$partmap_module part_bsd";;

"") ;;

*)

partmap_module="$partmap_module part_$x";;

esac

devabstraction_module="`"$grub_probe" --device-map="${device_map}" --target=abstraction --device "${grub_device}"`"

if [ "x$disk_module" = xata ]; then

disk_module=pata

if [ "x$disk_module" = xnative ]; then

disk_module="pata ahci ohci"

if [ "x$target_cpu" = "xi386" ] || [ "x$target_cpu" = "xx86_64" ]; then

disk_module="$disk_module uhci"

fi

disk_module="$disk_module usbms"

modules="$modules $disk_module"

modules="$modules $fs_module $partmap_module $devabstraction_module"

relative_grubdir="`"$grub_mkrelpath" "${grubdir}"`" || exit 1

if [ "x${relative_grubdir}" = "x" ] ; then

relative_grubdir=/

prefix_drive=

config_opt=

rm -f "${grubdir}/load.cfg"

if [ "x${debug_image}" != x ]; then

echo "set debug='${debug_image}'" >> "${grubdir}/load.cfg"

config_opt="-c ${grubdir}/load.cfg "

if [ "x${devabstraction_module}" = "x" ] ; then

if [ x"${install_device}" != x ]; then

if echo "${install_device}" | grep -q '^(.*)$' ; then

install_drive="${install_device}"

else

install_drive="`"$grub_probe" --device-map="${device_map}" --target=drive --device "${install_device}"`" || exit 1

fi

install_drive="`echo "${install_drive}" | sed -e 's/^(\(\([^,\\\\]\|\\\\\\\\\|\\\\,\)*\)\(\(,[a-zA-Z0-9]*\)*\))$/\1/'`"

fi

grub_drive="`"$grub_probe" --device-map="${device_map}" --target=drive --device "${grub_device}"`" || exit 1

# Strip partition number

grub_partition="`echo "${grub_drive}" | sed -e 's/^(\(\([^,\\\\]\|\\\\\\\\\|\\\\,\)*\)\(\(,[a-zA-Z0-9]*\)*\))$/\3/'`"

grub_drive="`echo "${grub_drive}" | sed -e 's/^(\(\([^,\\\\]\|\\\\\\\\\|\\\\,\)*\)\(\(,[a-zA-Z0-9]*\)*\))$/\1/'`"

if [ "x$fs_module" == xzfs ] || ([ "x$disk_module" != x ] && [ "x$disk_module" != xbiosdisk ]) || [ "x${grub_drive}" != "x${install_drive}" ] || ([ "x$platform" != xefi ] && [ "x$platform" != xpc ] && [ x"${platform}" != x"ieee1275" ]); then

# generic method (used on coreboot and ata mod)

uuid="`"$grub_probe" --device-map="${device_map}" --target=fs_uuid --device "${grub_device}"`"

if [ "x${uuid}" = "x" ] ; then

if [ "x$platform" != xefi ] && [ "x$platform" != xpc ] && [ x"${platform}" != x"ieee1275" ]; then

echo "UUID needed with $platform, but the filesystem containing ${grubdir} does not support UUIDs." 1>&2

elif [ "$disk_module" = ata ]; then

echo "UUID needed with ata mod, but the filesystem containing ${grubdir} does not support UUIDs." 1>&2

else

echo "UUID needed with cross-disk installs, but the filesystem containing ${grubdir} does not support UUIDs." 1>&2

fi

exit 1

fi

if [ x"$disk_module" != x ] && [ x"$disk_module" != xbiosdisk ]; then

hints="`"$grub_probe" --device-map="${device_map}" --target=baremetal_hints --device "${grub_device}"`"

elif [ x"$platform" = xpc ]; then

hints="`"$grub_probe" --device-map="${device_map}" --target=bios_hints --device "${grub_device}"`"

elif [ x"$platform" = xefi ]; then

hints="`"$grub_probe" --device-map="${device_map}" --target=efi_hints --device "${grub_device}"`"

elif [ x"$platform" = xieee1275 ]; then

hints="`"$grub_probe" --device-map="${device_map}" --target=ieee1275_hints --device "${grub_device}"`"

elif [ x"$platform" = xloongson ] || [ x"$platform" = xqemu ] || [ x"$platform" = xcoreboot ] || [ x"$platform" = xmultiboot ] || [ x"$platform" = xqemu-mips ]; then

hints="`"$grub_probe" --device-map="${device_map}" --target=baremetal_hints --device "${grub_device}"`"

else

echo "No hints available for your platform. Expect reduced performance"

hints=

fi

echo "search.fs_uuid ${uuid} root $hints " >> "${grubdir}/load.cfg"

echo 'set prefix=($root)'"${relative_grubdir}" >> "${grubdir}/load.cfg"

config_opt="-c ${grubdir}/load.cfg "

modules="$modules search_fs_uuid"

else

# we need to hardcode the partition number in the core image's prefix.

if [ x"$grub_partition" = x ]; then

prefix_drive="()"

else

# Comma is already there

prefix_drive="($grub_partition)"

fi

fi

if [ x$GRUB_CRYPTODISK_ENABLE = xy ]; then

for uuid in "`"${grub_probe}" --device "${grub_device}" --target=cryptodisk_uuid`"; do

echo "cryptomount -u $uuid" >> "${grubdir}/load.cfg"

done

config_opt="-c ${grubdir}/load.cfg "

fi

prefix_drive=`"$grub_probe" --device-map="${device_map}" --target=drive --device "${grub_device}"` || exit 1

case "${target_cpu}-${platform}" in

sparc64-ieee1275) mkimage_target=sparc64-ieee1275-raw ;;

mipsel-loongson) mkimage_target=mipsel-loongson-elf ;;

*) mkimage_target="${target_cpu}-${platform}" ;;

case "${target_cpu}-${platform}" in

i386-efi | x86_64-efi) imgext=efi ;;

mipsel-loongson | i386-coreboot | i386-multiboot | i386-ieee1275 \

| powerpc-ieee1275) imgext=elf ;;

*) imgext=img ;;

"$grub_mkimage" ${config_opt} -d "${pkglibdir}" -O ${mkimage_target} --output="${grubdir}/core.${imgext}" --prefix="${prefix_drive}${relative_grubdir}" $modules || exit 1

if [ "${target_cpu}-${platform}" = "mipsel-loongson" ]; then

cp "${grubdir}/core.${imgext}" "${bootdir}"/grub.elf

elif [ "${target_cpu}-${platform}" = "i386-ieee1275" ] || [ "${target_cpu}-${platform}" = "powerpc-ieee1275" ]; then

cp "${grubdir}/core.${imgext}" "${grubdir}/grub"

elif [ "${target_cpu}-${platform}" = "i386-efi" ] || [ "${target_cpu}-${platform}" = "x86_64-efi" ]; then

"$grub_mkimage" ${config_opt} -d "${pkglibdir}" -O ${mkimage_target} --output="${grubdir}/grub.efi" --prefix="" $modules || exit 1

if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then

if [ "${target_cpu}-${platform}" = "i386-pc" ] && test x"$do_embed_versioning" = xyes; then

version_string="`"${grub_version_check}" --source="${versiondir}"/version.lst -p -t solaris_grub_version`"

if [ -n "$version_string" ]; then

version_arg=--version-string="$version_string"

else

echo "Requested to embed version, but no version info is available. exiting" 1>&2

exit 1

fi

fi

# Now perform the installation.

"$grub_setup" ${force_mbr} ${version_arg} ${allow_floppy} ${setup_verbose} \

${setup_force} --directory="${grubdir}" --device-map="${device_map}" \

"${install_device}" || exit 1

elif [ "${target_cpu}-${platform}" = "i386-ieee1275" ] || [ "${target_cpu}-${platform}" = "powerpc-ieee1275" ]; then

if [ x"$update_nvram" = xyes ]; then

ofpathname="`which ofpathname`"

nvsetenv="`which nvsetenv`"

set "$ofpathname" dummy

if test -f "$1"; then

:

else

echo "$1: Not found." 1>&2

exit 1

fi

set "$nvsetenv" dummy

if test -f "$1"; then

:

else

echo "$1: Not found." 1>&2

exit 1

fi

# Get the Open Firmware device tree path translation.

dev="`echo $grub_device | sed -e 's/\/dev\///' -e 's/[0-9]\+//'`"

partno="`echo $grub_device | sed -e 's/.*[^0-9]\([0-9]\+\)$/\1/'`"

ofpath="`$ofpathname $dev`" || {

# Point boot-device at the new grub install

boot_device="$ofpath:$partno,"`"$grub_mkrelpath" "${grubdir}/core.${imgext}" | sed 's,/,\\\\,g'`

"$nvsetenv" boot-device "$boot_device" || {

fi

elif [ x"${target_cpu}-${platform}" = xmips-arc ]; then

dvhtool -d "${install_device}" --unix-to-vh "{grubdir}/core.${imgext}" grub

echo "You will have to set SystemPartition and OSLoader manually."

elif [ x"$platform" = xefi ]; then

cp "${grubdir}/core.${imgext}" "${efidir}/${efi_file}" || exit 1

# For old macs. Suggested by Peter Jones.

if [ x$target_cpu = xi386 ]; then

cp "${grubdir}/core.${imgext}" "${efidir}/boot.efi"

fi

# Try to make this image bootable using the EFI Boot Manager, if available.

case "$host_os" in

solaris*)

efibootmgr=

;;

*)

efibootmgr="`which efibootmgr`"

;;

esac

if test "$removable" = no && test -n "$efi_distributor" && \

test -n "$efibootmgr"; then

# On Linux, we need the efivars kernel modules.

case "$host_os" in

linux*)

modprobe -q efivars 2>/dev/null || true ;;

esac

# Delete old entries from the same distributor.

for bootnum in `efibootmgr | grep '^Boot[0-9]' | \

fgrep -i " $efi_distributor" | cut -b5-8`; do

efibootmgr $efi_quiet -b "$bootnum" -B

done

# Add a new entry for the image we just created. efibootmgr needs to be

# given the disk device and partition number separately, so we have to

# fiddle about with grub-probe to get hold of this reasonably reliably.

# Use fresh device map text to avoid any problems with stale data, since

# all we need here is a one-to-one mapping.

clean_devmap="$($grub_mkdevicemap --device-map=/dev/stdout)"

efidir_drive="$(echo "$clean_devmap" | "$grub_probe" --device-map="${device_map}" --target=drive --device-map=/dev/stdin "$efidir")"

if test -z "$efidir_drive"; then

echo "Can't find GRUB drive for $efidir; unable to create EFI Boot Manager entry." >&2

else

efidir_disk="$(echo "$clean_devmap" | grep "^$(echo "$efidir_drive" | sed 's/,[^)]*//')" | cut -f2)"

efidir_part="$(echo "$efidir_drive" | sed 's/^([^,]*,[^0-9]*//; s/[^0-9].*//')"

efibootmgr $efi_quiet -c -d "$efidir_disk" -p "$efidir_part" -w \

-L "$bootloader_id" -l "\\EFI\\$efi_distributor\\$efi_file"

fi

fi

if test x"$copy_version_lst" = xyes; then

cp -f "${versiondir}"/version.lst "${grubdir}"/

echo "Installation finished. No error reported."

exit 0