Difference between pages "Grub-install" and "Template:Article"

(Difference between pages)
(I corrected a typo.)
 
 
Line 1: Line 1:
This is an annotation about what grub-install does. This is based on the <code>=sys-boot/grub-1.98-r1</code> version.
+
<includeonly>{{#if:{{{Subtitle|}}}|<div style="margin-left: 15px;">
 +
==={{{Subtitle|}}}===</div>}}
 +
<div class="container" style="margin-top: 20px;"><div class="row"><div class="col-xs-12 col-md-9">
 +
{{#if:{{{Author|}}}|{{#set:Author=User:{{{Author|}}}}}}}{{#set:Gravatar MD5={{#show: User:{{{Author}}} | ?Gravatar MD5}}|Subtitle={{{Subtitle|}}}|Summary={{{Summary|}}}|Icon={{{Icon|}}}|Next in Series={{{Next in Series|}}}|Previous in Series={{{Previous in Series|}}}}}{{#if:{{{Previous in Series|}}}|Previous in series: [[{{{Previous in Series}}}]]}}{{#if:{{{Next in Series|}}}|{{#if:{{{Previous in Series|}}}|<br>}}Next in series: [[{{{Next in Series}}}]]}}
  
<syntaxhighlight lang="bash">
+
{{Tip|[[Support Funtoo]] and help us grow! '''Donate $15 per month and get a free SSD-based [[Funtoo Hosting|Funtoo Virtual Container]].'''}}
#! /bin/sh
+
</includeonly>
</syntaxhighlight>
+
This tells the Linux kernel that this script will be executed with <code>/bin/sh</code>.
+
<syntaxhighlight lang="bash">
+
 
+
# Install GRUB on your drive.
+
# Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+
#
+
# GRUB is free software: you can redistribute it and/or modify
+
# it under the terms of the GNU General Public License as published by
+
# the Free Software Foundation, either version 3 of the License, or
+
# (at your option) any later version.
+
#
+
# GRUB is distributed in the hope that it will be useful,
+
# but WITHOUT ANY WARRANTY; without even the implied warranty of
+
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
# GNU General Public License for more details.
+
#
+
# You should have received a copy of the GNU General Public License
+
# along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+
</syntaxhighlight>
+
This section tells that this script falls under the GNU General Public License.
+
<syntaxhighlight lang="bash">
+
 
+
# Initialize some variables.
+
transform="s,x,x,"
+
 
+
prefix=/usr
+
exec_prefix=${prefix}
+
sbindir=/sbin
+
bindir=/bin
+
libdir=/lib64
+
PACKAGE_NAME=GRUB
+
PACKAGE_TARNAME=grub
+
PACKAGE_VERSION=1.98
+
target_cpu=i386
+
platform=pc
+
host_os=linux-gnu
+
font=/usr/share/grub/ascii.pf2
+
pkglibdir=${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`
+
</syntaxhighlight>
+
These are some variables set when Grub was configured for the system.
+
<syntaxhighlight lang="bash">
+
 
+
grub_setup=${sbindir}/`echo grub-setup | sed ${transform}`
+
if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] || [ "${target_cpu}-${platform}" = "mips-yeeloong" ] ; then
+
    grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}`
+
else
+
    grub_mkimage=${bindir}/`echo grub-mkelfimage | sed ${transform}`
+
fi
+
grub_mkdevicemap=${sbindir}/`echo grub-mkdevicemap | sed ${transform}`
+
grub_probe=${sbindir}/`echo grub-probe | sed ${transform}`
+
grub_editenv=${bindir}/`echo grub-editenv | sed ${transform}`
+
rootdir=
+
grub_prefix=`echo /boot/grub | sed ${transform}`
+
modules=
+
 
+
install_device=
+
no_floppy=
+
force_lba=
+
recheck=no
+
debug=no
+
 
+
if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then
+
    disk_module=biosdisk
+
elif [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then
+
    disk_module=
+
else
+
    disk_module=ata
+
fi
+
</syntaxhighlight>
+
Further variables were initialized some of which were done so in a platform-dependent manner such as <code>disk_module</code> being set to <code>biosdisk</code> on i386-pc systems.
+
<syntaxhighlight lang="bash">
+
 
+
# Usage: usage
+
# Print the usage.
+
usage () {
+
    cat <<EOF
+
Usage: grub-install [OPTION] install_device
+
Install GRUB on your drive.
+
 
+
  -h, --help              print this message and exit
+
  -v, --version          print the version information and exit
+
  --modules=MODULES      pre-load specified modules MODULES
+
  --root-directory=DIR    install GRUB images under the directory DIR
+
                          instead of the root directory
+
  --grub-setup=FILE      use FILE as grub-setup
+
  --grub-mkimage=FILE    use FILE as grub-mkimage
+
  --grub-mkdevicemap=FILE use FILE as grub-mkdevicemap
+
  --grub-probe=FILE      use FILE as grub-probe
+
  --no-floppy            do not probe any floppy drive
+
  --recheck              probe a device map even if it already exists
+
  --force                install even if problems are detected
+
EOF
+
if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then
+
    cat <<EOF
+
  --disk-module=MODULE    disk module to use
+
EOF
+
fi
+
if [ "${target_cpu}-${platform}" = "mips-yeeloong" ] ; then
+
    cat <<EOF
+
  --font=FILE            font file to use
+
EOF
+
fi
+
    cat <<EOF
+
 
+
INSTALL_DEVICE can be a GRUB device name or a system device filename.
+
 
+
grub-install copies GRUB images into /boot/grub (or /grub on NetBSD and
+
OpenBSD), and uses grub-setup to install grub into the boot sector.
+
 
+
If the --root-directory option is used, then grub-install will copy
+
images into the operating system installation rooted at that directory.
+
 
+
Report bugs to <bug-grub@gnu.org>.
+
EOF
+
}
+
</syntaxhighlight>
+
This sets up the usage message that <code>grub-install</code> prints if it doesn't understand what arguments it was given.
+
<syntaxhighlight lang="bash">
+
# Check the arguments.
+
for option in "$@"; do
+
    case "$option" in
+
    -h | --help)
+
usage
+
exit 0 ;;
+
    -v | --version)
+
echo "grub-install (GNU GRUB ${PACKAGE_VERSION})"
+
exit 0 ;;
+
    --modules=*)
+
modules=`echo "$option" | sed 's/--modules=//'` ;;
+
    --font=*)
+
font=`echo "$option" | sed 's/--font=//'` ;;
+
    --root-directory=*)
+
rootdir=`echo "$option" | sed 's/--root-directory=//'` ;;
+
    --grub-setup=*)
+
grub_setup=`echo "$option" | sed 's/--grub-setup=//'` ;;
+
    --grub-mkimage=*)
+
grub_mkimage=`echo "$option" | sed 's/--grub-mkimage=//'` ;;
+
    --grub-mkdevicemap=*)
+
grub_mkdevicemap=`echo "$option" | sed 's/--grub-mkdevicemap=//'` ;;
+
    --grub-probe=*)
+
grub_probe=`echo "$option" | sed 's/--grub-probe=//'` ;;
+
    --no-floppy)
+
no_floppy="--no-floppy" ;;
+
    --recheck)
+
recheck=yes ;;
+
    --disk-module=*)
+
if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then
+
          disk_module=`echo "$option" | sed 's/--disk-module=//'`
+
        fi ;;
+
    # This is an undocumented feature...
+
    --debug)
+
debug=yes ;;
+
    -f | --force)
+
        setup_force="--force" ;;
+
    -*)
+
echo "Unrecognized option \`$option'" 1>&2
+
usage
+
exit 1
+
;;
+
    *)
+
if test "x$install_device" != x; then
+
    echo "More than one install_devices?" 1>&2
+
    usage
+
    exit 1
+
fi
+
install_device="${option}" ;;
+
    esac
+
done
+
</syntaxhighlight>
+
This section parses the command line arguments and sets variables appropriately.
+
<syntaxhighlight lang="bash">
+
 
+
# for make_system_path_relative_to_its_root()
+
. ${libdir}/grub/grub-mkconfig_lib
+
 
+
if test "x$install_device" = x && test "${target_cpu}-${platform}" != "mips-yeeloong"; then
+
    echo "install_device not specified." 1>&2
+
    usage
+
    exit 1
+
fi
+
</syntaxhighlight>
+
 
+
This block ensures that a destination device was specified to <code>grub-install</code> as an argument.
+
 
+
<syntaxhighlight lang="bash">
+
 
+
# If the debugging feature is enabled, print commands.
+
setup_verbose=
+
if test $debug = yes; then
+
    set -x
+
    setup_verbose="--verbose"
+
fi
+
</syntaxhighlight>
+
 
+
This block makes <code>grub-install</code> more verbose if grub was built with debugging enabled.
+
 
+
<syntaxhighlight lang="bash">
+
 
+
# Initialize these directories here, since ROOTDIR was initialized.
+
case "$host_os" in
+
netbsd* | openbsd*)
+
    # Because /boot is used for the boot block in NetBSD and OpenBSD, use /grub
+
    # instead of /boot/grub.
+
    grub_prefix=`echo /grub | sed ${transform}`
+
    bootdir=${rootdir}
+
    ;;
+
*)
+
    # Use /boot/grub by default.
+
    bootdir=${rootdir}/boot
+
    ;;
+
esac
+
</syntaxhighlight>
+
Set up the location where Grub will be installed.
+
<syntaxhighlight lang="bash">
+
 
+
grubdir=${bootdir}/`echo grub | sed ${transform}`
+
device_map=${grubdir}/device.map
+
 
+
grub_probe="${grub_probe} --device-map=${device_map}"
+
 
+
# Check if GRUB is installed.
+
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
+
fi
+
 
+
set $grub_mkimage dummy
+
if test -f "$1"; then
+
    :
+
else
+
    echo "$1: Not found." 1>&2
+
    exit 1
+
fi
+
 
+
set $grub_mkdevicemap dummy
+
if test -f "$1"; then
+
    :
+
else
+
    echo "$1: Not found." 1>&2
+
    exit 1
+
fi
+
</syntaxhighlight>
+
These blocks ensure that grub components are installed.
+
<syntaxhighlight lang="bash">
+
# Create the GRUB directory if it is not present.
+
test -d "$bootdir" || mkdir "$bootdir" || exit 1
+
test -d "$grubdir" || mkdir "$grubdir" || exit 1
+
 
+
# If --recheck is specified, remove the device map, if present.
+
if test $recheck = yes; then
+
    rm -f $device_map
+
fi
+
 
+
# Create the device map file if it is not present.
+
if test -f "$device_map"; then
+
    :
+
else
+
    # Create a safe temporary file.
+
    test -n "$mklog" && log_file=`$mklog`
+
 
+
    $grub_mkdevicemap --device-map=$device_map $no_floppy || exit 1
+
fi
+
</syntaxhighlight>
+
This creates the device map by calling <code>grub-mkdevicemap</code>. That program will create a mapping from the Grub device names to the Linux device nodes.
+
<syntaxhighlight lang="bash">
+
 
+
# Make sure that there is no duplicated entry.
+
tmp=`sed -n '/^([fh]d[0-9]*)/s/\(^(.*)\).*/\1/p' $device_map \
+
    | sort | uniq -d | sed -n 1p`
+
if test -n "$tmp"; then
+
    echo "The drive $tmp is defined multiple times in the device map $device_map" 1>&2
+
    exit 1
+
fi
+
</syntaxhighlight>
+
This does some sanity checks on the device map file in case it has been manually corrected in an erroneous way.
+
<syntaxhighlight lang="bash">
+
 
+
# Copy the GRUB images to the GRUB directory.
+
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
+
done
+
for file in ${pkglibdir}/*.mod ${pkglibdir}/*.lst; do
+
    cp -f $file ${grubdir} || exit 1
+
done
+
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
+
fi
+
 
+
# Copy gettext files
+
mkdir -p ${grubdir}/locale/
+
for file in ${grubdir}/locale/*.mo ${pkglibdir}/locale/*.mo; do
+
    if test -f "$file"; then
+
        cp -f "$file" ${grubdir}/locale/
+
    fi
+
done
+
</syntaxhighlight>
+
This copies grub components and its localization files to the [[The_Root_Filesystem#.2Fboot_:_Static_files_of_the_boot_loader|boot]] directory.
+
<syntaxhighlight lang="bash">
+
 
+
# Write device to a variable so we don't have to traverse /dev every time.
+
grub_device=`$grub_probe --target=device ${grubdir}`
+
 
+
if ! test -f ${grubdir}/grubenv; then
+
    $grub_editenv ${grubdir}/grubenv create
+
fi
+
 
+
# Create the core image. First, auto-detect the filesystem module.
+
fs_module=`$grub_probe --target=fs --device ${grub_device}`
+
if test "x$fs_module" = x -a "x$modules" = x; then
+
    echo "Auto-detection of a filesystem module failed." 1>&2
+
    echo "Please specify the module with the option \`--modules' explicitly." 1>&2
+
    exit 1
+
fi
+
 
+
# Then the partition map module.  In order to support partition-less media,
+
# this command is allowed to fail (--target=fs already grants us that the
+
# filesystem will be accessible).
+
partmap_module=`$grub_probe --target=partmap --device ${grub_device} 2> /dev/null`
+
 
+
# Device abstraction module, if any (lvm, raid).
+
devabstraction_module=`$grub_probe --target=abstraction --device ${grub_device}`
+
 
+
# The order in this list is critical.  Be careful when modifying it.
+
modules="$modules $disk_module"
+
modules="$modules $fs_module $partmap_module $devabstraction_module"
+
</syntaxhighlight>
+
Since Grub is modular, it needs the modules that allow it to recognize the boot directory. Consequently, it uses the <code>grub-probe</code> command to determine the modules necessary and adds them to the modules list in an appropriate order. Once it can recognize the boot directory, Grub can dynamically load modules as necessary and read its configuration file.
+
<syntaxhighlight lang="bash">
+
 
+
relative_grubdir=`make_system_path_relative_to_its_root ${grubdir}` || exit 1
+
if [ "x${relative_grubdir}" = "x" ] ; then
+
    relative_grubdir=/
+
fi
+
 
+
prefix_drive=
+
config_opt=
+
 
+
if [ "x${devabstraction_module}" = "x" ] ; then
+
    if [ x"${install_device}" != x ]; then
+
      if echo "${install_device}" | grep -qx "(.*)" ; then
+
        install_drive="${install_device}"
+
      else
+
        install_drive="`$grub_probe --target=drive --device ${install_device}`"
+
      fi
+
      install_drive="`echo ${install_drive} | sed -e s/,[0-9]*[a-z]*//g`"
+
    fi
+
    grub_drive="`$grub_probe --target=drive --device ${grub_device}`"
+
 
+
    # Strip partition number
+
    grub_drive="`echo ${grub_drive} | sed -e s/,[0-9]*[a-z]*//g`"
+
    if [ "$disk_module" = ata ] ; then
+
        # generic method (used on coreboot and ata mod)
+
        uuid="`$grub_probe --target=fs_uuid --device ${grub_device}`"
+
        if [ "x${uuid}" = "x" ] ; then
+
          echo "UUID needed with ata mod, but the filesystem containing ${grubdir} does not support UUIDs." 1>&2
+
          exit 1
+
        fi
+
        echo "search.fs_uuid ${uuid} root " > ${grubdir}/load.cfg
+
echo 'set prefix=($root)'"${relative_grubdir}" >> ${grubdir}/load.cfg
+
config_opt="-c ${grubdir}/load.cfg "
+
        modules="$modules search_fs_uuid"
+
    elif [ "x${grub_drive}" != "x${install_drive}" ] ; then
+
        uuid="`$grub_probe --target=fs_uuid --device ${grub_device}`"
+
        if [ "x${uuid}" = "x" ] ; then
+
          echo "You attempted a cross-disk install, but the filesystem containing ${grubdir} does not support UUIDs." 1>&2
+
          exit 1
+
        fi
+
        echo "search.fs_uuid ${uuid} root " > ${grubdir}/load.cfg
+
echo 'set prefix=($root)'"${relative_grubdir}" >> ${grubdir}/load.cfg
+
config_opt="-c ${grubdir}/load.cfg "
+
        modules="$modules search_fs_uuid"
+
    fi
+
else
+
    prefix_drive=`$grub_probe --target=drive --device ${grub_device}`
+
fi
+
</syntaxhighlight>
+
Partitions can be moved around or initialized in a different order, so Grub wants to identify filesystems by their UUIDs. It also can load from a drive different from where it is installed. It does further probing to determine if the UUID module will be needed and includes it with the other modules.
+
<syntaxhighlight lang="bash">
+
 
+
if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then
+
    $grub_mkimage ${config_opt} --output=${grubdir}/core.img --prefix=${prefix_drive}${relative_grubdir} $modules || exit 1
+
 
+
    # Now perform the installation.
+
    $grub_setup ${setup_verbose} ${setup_force} --directory=${grubdir} --device-map=${device_map} \
+
        ${install_device} || exit 1
+
elif [ "${target_cpu}-${platform}" = "mips-yeeloong" ] ; then
+
    $grub_mkimage ${config_opt} -f ${font} -d ${pkglibdir} -O elf --output=/boot/grub.elf --prefix=${prefix_drive}${relative_grubdir} $modules || exit 1
+
else
+
    $grub_mkimage ${config_opt} -d ${pkglibdir} --output=/boot/multiboot.img --prefix=${prefix_drive}${relative_grubdir} $modules || exit 1
+
fi
+
 
+
echo "Installation finished. No error reported."
+
 
+
# Bye.
+
exit 0
+
</syntaxhighlight>
+
Grub finally uses the information about needed modules to create an image using <code>grub-mkimage</code>. The initial <code>boot.img</code> file is then modified to point to the <code>core.img</code> file that was just generated. That image is then installed to the desired installation device with <code>grub-setup</code>.
+
[[Category:Grub]]
+

Revision as of 01:16, January 2, 2015