Difference between pages "Grub-install" and "Boot image"

(Difference between pages)
(I corrected a typo.)
 
(I annotated some more of what is going on.)
 
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.
+
[[Grub]] starts execution with the boot image. The boot image is 512 bytes and can be found in file form at <code>/boot/grub/boot.img</code>. The boot image is 512 bytes because that is how big the [[wikipedia:master boot record|master boot record]] is. On a BIOS-based computer, a disk is booted by reading the first 512 bytes of a disk into memory address 0x7c00 and jumping to that location to begin execution. On an [[wikipedia:x86|x86]] or [[wikipedia:x86-64|x86-64]] system, the source code for that boot image can be found in the grub source code in assembly as <code>grub-core/boot/i386/pc/boot.S</code>. The bootloader is written in 16-bit assembly so it may help to be familiar with the 16-bit instruction set as well as the register set used. It's also useful to know how interrupts work since they get enabled and disabled at various times. Intel makes their manuals specifying these details available at http://www.intel.com/products/processor/manuals.
 
+
<syntaxhighlight lang="asm">
<syntaxhighlight lang="bash">
+
/* -*-Asm-*- */
#! /bin/sh
+
 
</syntaxhighlight>
 
</syntaxhighlight>
This tells the Linux kernel that this script will be executed with <code>/bin/sh</code>.
+
This is just a magic comment that tells certain text editors to treat this as assembly and edit in an appropriate mode.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
 +
/*
 +
*  GRUB  --  GRand Unified Bootloader
 +
*  Copyright (C) 1999,2000,2001,2002,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 is just the license for the code.
 +
<syntaxhighlight lang="asm">
  
# Install GRUB on your drive.
+
#include <grub/symbol.h>
# Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
+
#include <grub/boot.h>
#
+
#include <grub/machine/boot.h>
# 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>
 
</syntaxhighlight>
This section tells that this script falls under the GNU General Public License.
+
These includes include information about offsets and other symbols used in the assembly.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
  
# Initialize some variables.
+
/*
transform="s,x,x,"
+
*  defines for the code go here
 +
*/
  
prefix=/usr
+
/* Print message string */
exec_prefix=${prefix}
+
#define MSG(x) movw $x, %si; call LOCAL(message)
sbindir=/sbin
+
#define ERR(x) movw $x, %si; jmp LOCAL(error_message)
bindir=/bin
+
</syntaxhighlight>
libdir=/lib64
+
These are just some definitions for how to print messages.
PACKAGE_NAME=GRUB
+
<syntaxhighlight lang="asm">
PACKAGE_TARNAME=grub
+
.file "boot.S"
PACKAGE_VERSION=1.98
+
</syntaxhighlight>
target_cpu=i386
+
This tells the assembler that we are starting the <code>boot.S</code> logical file.
platform=pc
+
<syntaxhighlight lang="asm">
host_os=linux-gnu
+
.text
font=/usr/share/grub/ascii.pf2
+
</syntaxhighlight>
pkglibdir=${libdir}/`echo ${PACKAGE_TARNAME}/${target_cpu}-${platform} | sed ${transform}`
+
This tells the assembler that the text portion of the executable format starts here.
 +
<syntaxhighlight lang="asm">
 +
/* Tell GAS to generate 16-bit instructions so that this code works
 +
  in real mode. */
 +
.code16
 
</syntaxhighlight>
 
</syntaxhighlight>
These are some variables set when Grub was configured for the system.
+
This tells the assembler to output 16-bit instructions. This seems to only apply to ARM though according to the documentation.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
  
grub_setup=${sbindir}/`echo grub-setup | sed ${transform}`
+
.globl _start, start;
if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] || [ "${target_cpu}-${platform}" = "mips-yeeloong" ] ; then
+
_start:
    grub_mkimage=${bindir}/`echo grub-mkimage | sed ${transform}`
+
start:
else
+
/*
    grub_mkimage=${bindir}/`echo grub-mkelfimage | sed ${transform}`
+
* _start is loaded at 0x7c00 and is jumped to with CS:IP 0:0x7c00
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=
+
* Beginning of the sector is compatible with the FAT/HPFS BIOS
force_lba=
+
* parameter block.
recheck=no
+
*/
debug=no
+
  
if [ "${target_cpu}-${platform}" = "i386-pc" ] ; then
+
jmp LOCAL(after_BPB)
    disk_module=biosdisk
+
nop /* do I care about this ??? */
elif [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then
+
    disk_module=
+
else
+
    disk_module=ata
+
fi
+
 
</syntaxhighlight>
 
</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.
+
This jumps past the [[wikipedia:BIOS Parameter Block|BIOS Parameter Block]] that takes up the first portion of the sector.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
  
# Usage: usage
+
/*
# Print the usage.
+
* This space is for the BIOS parameter block!!!!  Don't change
usage () {
+
* the first jump, nor start the code anywhere but right after
    cat <<EOF
+
* this area.
Usage: grub-install [OPTION] install_device
+
*/
Install GRUB on your drive.
+
  
  -h, --help              print this message and exit
+
. = _start + GRUB_BOOT_MACHINE_BPB_START
  -v, --version          print the version information and exit
+
. = _start + 4
  --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.
+
/* scratch space */
 +
mode:
 +
.byte 0
 +
disk_address_packet:
 +
sectors:
 +
.long 0
 +
heads:
 +
.long 0
 +
cylinders:
 +
.word 0
 +
sector_start:
 +
.byte 0
 +
head_start:
 +
.byte 0
 +
cylinder_start:
 +
.word 0
 +
/* more space... */
  
grub-install copies GRUB images into /boot/grub (or /grub on NetBSD and
+
. = _start + GRUB_BOOT_MACHINE_BPB_END
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.
+
* End of BIOS parameter block.
 +
*/
 +
</syntaxhighlight>
 +
This reserves space for the BIOS parameter block. The BIOS parameter block is not necessary in the MBR, but Grub uses the same image for a volume boot records as well. A volume boot record may have a BIOS parameter block, so space is made for it.
 +
<syntaxhighlight lang="asm">
  
Report bugs to <bug-grub@gnu.org>.
+
kernel_address:
EOF
+
.word GRUB_BOOT_MACHINE_KERNEL_ADDR
}
+
 
 +
. = _start + GRUB_BOOT_MACHINE_KERNEL_SECTOR
 +
kernel_sector:
 +
.long 1, 0
 +
 
 +
. = _start + GRUB_BOOT_MACHINE_BOOT_DRIVE
 +
boot_drive:
 +
.byte 0xff /* the disk to load kernel from */
 +
/* 0xff means use the boot drive */
 
</syntaxhighlight>
 
</syntaxhighlight>
This sets up the usage message that <code>grub-install</code> prints if it doesn't understand what arguments it was given.
+
Some other magic values are set up.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
# Check the arguments.
+
LOCAL(after_BPB):
for option in "$@"; do
+
 
    case "$option" in
+
/* general setup */
    -h | --help)
+
cli /* we're not safe here! */
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>
 
</syntaxhighlight>
This section parses the command line arguments and sets variables appropriately.
+
This is the first instruction after the jump. The <code>cli</code> instruction clears the interrupts flag so that the processor does not respond to external maskable interrupts.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
 +
        /*
 +
        * This is a workaround for buggy BIOSes which don't pass boot
 +
        * drive correctly. If GRUB is installed into a HDD, check if
 +
        * DL is masked correctly. If not, assume that the BIOS passed
 +
        * a bogus value and set DL to 0x80, since this is the only
 +
        * possible boot drive. If GRUB is installed into a floppy,
 +
        * this does nothing (only jump).
 +
        */
 +
. = _start + GRUB_BOOT_MACHINE_DRIVE_CHECK
 +
boot_drive_check:
 +
        jmp    3f /* grub-setup may overwrite this jump */
 +
        testb  $0x80, %dl
 +
        jz      2f
 +
3:
 +
/* Ignore %dl different from 0-0x0f and 0x80-0x8f.  */
 +
testb  $0x70, %dl
 +
jz      1f
 +
2:
 +
        movb    $0x80, %dl
 +
1:
 +
/*
 +
* ljmp to the next instruction because some bogus BIOSes
 +
* jump to 07C0:0000 instead of 0000:7C00.
 +
*/
 +
ljmp $0, $real_start
 +
</syntaxhighlight>
 +
Part of the BIOS interface is indicating which disk is being booted from. Some BIOSes get this wrong so this uses some heuristics to make a fallback guess if the BIOS did something dumb. The other thing done here is to deal with BIOSes that jump to 07C0:0000 instead of 0000:7C00. This is actually the same physical address, but 0000 is a different segment than 07C0. This can be problematic, so a long jump is made to allow execution to continue with a known segment.
 +
<syntaxhighlight lang="asm">
 +
real_start:
 +
 
 +
/* set up %ds and %ss as offset from 0 */
 +
xorw %ax, %ax
 +
movw %ax, %ds
 +
movw %ax, %ss
  
# for make_system_path_relative_to_its_root()
+
/* set up the REAL stack */
. ${libdir}/grub/grub-mkconfig_lib
+
movw $GRUB_BOOT_MACHINE_STACK_SEG, %sp
  
if test "x$install_device" = x && test "${target_cpu}-${platform}" != "mips-yeeloong"; then
+
sti /* we're safe again */
    echo "install_device not specified." 1>&2
+
    usage
+
    exit 1
+
fi
+
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
The data segment and stack segment registers are zeroed out, and the stack pointer is set up. At this point, interrupts can be re-enabled.
 +
<syntaxhighlight lang="asm">
  
This block ensures that a destination device was specified to <code>grub-install</code> as an argument.
+
/*
 +
*  Check if we have a forced disk reference here
 +
*/
 +
movb  boot_drive, %al
 +
cmpb $0xff, %al
 +
je 1f
 +
movb %al, %dl
 +
1:
 +
/* save drive reference first thing! */
 +
pushw %dx
  
<syntaxhighlight lang="bash">
+
/* print a notification message on the screen */
 +
MSG(notification_string)
  
# If the debugging feature is enabled, print commands.
+
/* set %si to the disk address packet */
setup_verbose=
+
movw $disk_address_packet, %si
if test $debug = yes; then
+
 
    set -x
+
/* check if LBA is supported */
    setup_verbose="--verbose"
+
movb $0x41, %ah
fi
+
movw $0x55aa, %bx
</syntaxhighlight>
+
int $0x13
  
This block makes <code>grub-install</code> more verbose if grub was built with debugging enabled.
+
/*
 +
*  %dl may have been clobbered by INT 13, AH=41H.
 +
*  This happens, for example, with AST BIOS 1.04.
 +
*/
 +
popw %dx
 +
pushw %dx
  
<syntaxhighlight lang="bash">
+
/* use CHS if fails */
 +
jc LOCAL(chs_mode)
 +
cmpw $0xaa55, %bx
 +
jne LOCAL(chs_mode)
  
# Initialize these directories here, since ROOTDIR was initialized.
+
andw $1, %cx
case "$host_os" in
+
jz LOCAL(chs_mode)
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>
 
</syntaxhighlight>
Set up the location where Grub will be installed.
+
Grub tries to use LBA geometry, but if the BIOS does not support LBA, it falls back to using CHS geometry.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
 +
lba_mode:
 +
xorw %ax, %ax
 +
movw %ax, 4(%si)
  
grubdir=${bootdir}/`echo grub | sed ${transform}`
+
incw %ax
device_map=${grubdir}/device.map
+
/* set the mode to non-zero */
 +
movb %al, -1(%si)
  
grub_probe="${grub_probe} --device-map=${device_map}"
+
/* the blocks */
 +
movw %ax, 2(%si)
  
# Check if GRUB is installed.
+
/* the size and the reserved byte */
if [ "${target_cpu}-${platform}" = "i386-pc" ] || [ "${target_cpu}-${platform}" = "sparc64-ieee1275" ] ; then
+
movw $0x0010, (%si)
    set $grub_setup dummy
+
    if test -f "$1"; then
+
        :
+
    else
+
        echo "$1: Not found." 1>&2
+
        exit 1
+
    fi
+
fi
+
  
set $grub_mkimage dummy
+
/* the absolute address */
if test -f "$1"; then
+
movl kernel_sector, %ebx
    :
+
movl %ebx, 8(%si)
else
+
movl kernel_sector + 4, %ebx
    echo "$1: Not found." 1>&2
+
movl %ebx, 12(%si)
    exit 1
+
fi
+
  
set $grub_mkdevicemap dummy
+
/* the segment of buffer address */
if test -f "$1"; then
+
movw $GRUB_BOOT_MACHINE_BUFFER_SEG, 6(%si)
    :
+
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
+
* BIOS call "INT 0x13 Function 0x42" to read sectors from disk into memory
    rm -f $device_map
+
* Call with %ah = 0x42
fi
+
* %dl = drive number
 +
* %ds:%si = segment:offset of disk address packet
 +
* Return:
 +
* %al = 0x0 on success; err code on failure
 +
*/
  
# Create the device map file if it is not present.
+
movb $0x42, %ah
if test -f "$device_map"; then
+
int $0x13
    :
+
else
+
    # Create a safe temporary file.
+
    test -n "$mklog" && log_file=`$mklog`
+
  
    $grub_mkdevicemap --device-map=$device_map $no_floppy || exit 1
+
/* LBA read is not supported, so fallback to CHS.  */
fi
+
jc LOCAL(chs_mode)
</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.
+
movw $GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
<syntaxhighlight lang="bash">
+
jmp LOCAL(copy_buffer)
 +
 
 +
LOCAL(chs_mode):
 +
/*
 +
*  Determine the hard disk geometry from the BIOS!
 +
*  We do this first, so that LS-120 IDE floppies work correctly.
 +
*/
 +
movb $8, %ah
 +
int $0x13
 +
jnc LOCAL(final_init)
 +
 
 +
/*
 +
*  The call failed, so maybe use the floppy probe instead.
 +
*/
 +
testb $GRUB_BOOT_MACHINE_BIOS_HD_FLAG, %dl
 +
jz LOCAL(floppy_probe)
 +
 
 +
/* Nope, we definitely have a hard disk, and we're screwed. */
 +
ERR(hd_probe_error_string)
 +
 
 +
LOCAL(final_init):
 +
/* set the mode to zero */
 +
movzbl %dh, %eax
 +
movb %ah, -1(%si)
 +
 
 +
/* save number of heads */
 +
incw %ax
 +
movl %eax, 4(%si)
 +
 
 +
movzbw %cl, %dx
 +
shlw $2, %dx
 +
movb %ch, %al
 +
movb %dh, %ah
 +
 
 +
/* save number of cylinders */
 +
incw %ax
 +
movw %ax, 8(%si)
 +
 
 +
movzbw %dl, %ax
 +
shrb $2, %al
 +
 
 +
/* save number of sectors */
 +
movl %eax, (%si)
 +
 
 +
setup_sectors:
 +
/* load logical sector start (top half) */
 +
movl kernel_sector + 4, %eax
 +
 
 +
orl %eax, %eax
 +
jnz LOCAL(geometry_error)
 +
 
 +
/* load logical sector start (bottom half) */
 +
movl kernel_sector, %eax
 +
 
 +
/* zero %edx */
 +
xorl %edx, %edx
 +
 
 +
/* divide by number of sectors */
 +
divl (%si)
 +
 
 +
/* save sector start */
 +
movb %dl, %cl
 +
 
 +
xorw %dx, %dx /* zero %edx */
 +
divl 4(%si) /* divide by number of heads */
 +
 
 +
/* do we need too many cylinders? */
 +
cmpw 8(%si), %ax
 +
jge LOCAL(geometry_error)
 +
 
 +
/* normalize sector start (1-based) */
 +
incb %cl
 +
 
 +
/* low bits of cylinder start */
 +
movb %al, %ch
 +
 
 +
/* high bits of cylinder start */
 +
xorb %al, %al
 +
shrw $2, %ax
 +
orb %al, %cl
 +
 
 +
/* save head start */
 +
movb %dl, %al
 +
 
 +
/* restore %dl */
 +
popw %dx
 +
 
 +
/* head start */
 +
movb %al, %dh
 +
 
 +
/*
 +
* BIOS call "INT 0x13 Function 0x2" to read sectors from disk into memory
 +
* Call with %ah = 0x2
 +
* %al = number of sectors
 +
* %ch = cylinder
 +
* %cl = sector (bits 6-7 are high bits of "cylinder")
 +
* %dh = head
 +
* %dl = drive (0x80 for hard disk, 0x0 for floppy disk)
 +
* %es:%bx = segment:offset of buffer
 +
* Return:
 +
* %al = 0x0 on success; err code on failure
 +
*/
 +
 
 +
movw $GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
 +
movw %bx, %es /* load %es segment with disk buffer */
 +
 
 +
xorw %bx, %bx /* %bx = 0, put it at 0 in the segment */
 +
movw $0x0201, %ax /* function 2 */
 +
int $0x13
 +
 
 +
jc LOCAL(read_error)
 +
 
 +
movw %es, %bx
 +
 
 +
LOCAL(copy_buffer):
 +
/*
 +
* We need to save %cx and %si because the startup code in
 +
* kernel uses them without initializing them.
 +
*/
 +
pusha
 +
pushw %ds
 +
 
 +
movw $0x100, %cx
 +
movw %bx, %ds
 +
xorw %si, %si
 +
movw $GRUB_BOOT_MACHINE_KERNEL_ADDR, %di
 +
movw %si, %es
 +
 
 +
cld
 +
 
 +
rep
 +
movsw
 +
 
 +
popw %ds
 +
popa
 +
 
 +
/* boot kernel */
 +
jmp *(kernel_address)
 +
 
 +
/* END OF MAIN LOOP */
  
# 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>
 
</syntaxhighlight>
This does some sanity checks on the device map file in case it has been manually corrected in an erroneous way.
+
<syntaxhighlight lang="asm">
<syntaxhighlight lang="bash">
+
/*
 +
* BIOS Geometry translation error (past the end of the disk geometry!).
 +
*/
 +
LOCAL(geometry_error):
 +
ERR(geometry_error_string)
 +
</syntaxhighlight lang="asm">
 +
This is where Grub prints the error message when there is an issue with the disk geometry.
 +
<syntaxhighlight lang="asm">
  
# Copy the GRUB images to the GRUB directory.
+
/*
for file in ${grubdir}/*.mod ${grubdir}/*.lst ${grubdir}/*.img ${grubdir}/efiemu??.o; do
+
* Read error on the disk.
    if test -f $file && [ "`basename $file`" != menu.lst ]; then
+
*/
rm -f $file || exit 1
+
LOCAL(read_error):
    fi
+
movw $read_error_string, %si
done
+
LOCAL(error_message):
for file in ${pkglibdir}/*.mod ${pkglibdir}/*.lst; do
+
call LOCAL(message)
    cp -f $file ${grubdir} || exit 1
+
LOCAL(general_error):
done
+
MSG(general_error_string)
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
+
/* go here when you need to stop the machine hard after an error condition */
mkdir -p ${grubdir}/locale/
+
        /* tell the BIOS a boot failure, which may result in no effect */
for file in ${grubdir}/locale/*.mo ${pkglibdir}/locale/*.mo; do
+
        int $0x18
    if test -f "$file"; then
+
LOCAL(stop):
        cp -f "$file" ${grubdir}/locale/
+
jmp LOCAL(stop)
    fi
+
 
done
+
</syntaxhighlight>
 +
<syntaxhighlight lang="asm">
 +
notification_string: .asciz "GRUB "
 +
geometry_error_string: .asciz "Geom"
 +
hd_probe_error_string: .asciz "Hard Disk"
 +
read_error_string: .asciz "Read"
 +
general_error_string: .asciz " Error\r\n"
 
</syntaxhighlight>
 
</syntaxhighlight>
This copies grub components and its localization files to the [[The_Root_Filesystem#.2Fboot_:_Static_files_of_the_boot_loader|boot]] directory.
+
Several null-terminated ASCII strings are set up.
<syntaxhighlight lang="bash">
+
<syntaxhighlight lang="asm">
  
# Write device to a variable so we don't have to traverse /dev every time.
+
/*
grub_device=`$grub_probe --target=device ${grubdir}`
+
* message: write the string pointed to by %si
 +
*
 +
*  WARNING: trashes %si, %ax, and %bx
 +
*/
  
if ! test -f ${grubdir}/grubenv; then
+
/*
    $grub_editenv ${grubdir}/grubenv create
+
* Use BIOS "int 10H Function 0Eh" to write character in teletype mode
fi
+
* %ah = 0xe %al = character
 +
* %bh = page %bl = foreground color (graphics modes)
 +
*/
 +
1:
 +
movw $0x0001, %bx
 +
movb $0xe, %ah
 +
int $0x10 /* display a byte */
 +
LOCAL(message):
 +
lodsb
 +
cmpb $0, %al
 +
jne 1b /* if not end of string, jmp to display */
 +
ret
  
# Create the core image. First, auto-detect the filesystem module.
+
/*
fs_module=`$grub_probe --target=fs --device ${grub_device}`
+
*  Windows NT breaks compatibility by embedding a magic
if test "x$fs_module" = x -a "x$modules" = x; then
+
*  number here.
    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,
+
. = _start + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC
# this command is allowed to fail (--target=fs already grants us that the
+
nt_magic:
# filesystem will be accessible).
+
.long 0
partmap_module=`$grub_probe --target=partmap --device ${grub_device} 2> /dev/null`
+
.word 0
  
# Device abstraction module, if any (lvm, raid).
+
/*
devabstraction_module=`$grub_probe --target=abstraction --device ${grub_device}`
+
*  This is where an MBR would go if on a hard disk. The code
 +
*  here isn't even referenced unless we're on a floppy.  Kinda
 +
*  sneaky, huh?
 +
*/
  
# The order in this list is critical. Be careful when modifying it.
+
. = _start + GRUB_BOOT_MACHINE_PART_START
modules="$modules $disk_module"
+
part_start:
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
+
probe_values:
if [ "x${relative_grubdir}" = "x" ] ; then
+
.byte 36, 18, 15, 9, 0
    relative_grubdir=/
+
fi
+
  
prefix_drive=
+
LOCAL(floppy_probe):
config_opt=
+
/*
 +
*  Perform floppy probe.
 +
*/
  
if [ "x${devabstraction_module}" = "x" ] ; then
+
movw $probe_values - 1, %si
    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
+
LOCAL(probe_loop):
    grub_drive="`echo ${grub_drive} | sed -e s/,[0-9]*[a-z]*//g`"
+
/* reset floppy controller INT 13h AH=0 */
    if [ "$disk_module" = ata ] ; then
+
xorw %ax, %ax
        # generic method (used on coreboot and ata mod)
+
int $0x13
        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
+
incw %si
    $grub_mkimage ${config_opt} --output=${grubdir}/core.img --prefix=${prefix_drive}${relative_grubdir} $modules || exit 1
+
movb (%si), %cl
  
    # Now perform the installation.
+
/* if number of sectors is 0, display error and die */
    $grub_setup ${setup_verbose} ${setup_force} --directory=${grubdir} --device-map=${device_map} \
+
cmpb $0, %cl
        ${install_device} || exit 1
+
jne 1f
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."
+
/*
 +
* Floppy disk probe failure.
 +
*/
 +
MSG(fd_probe_error_string)
 +
jmp LOCAL(general_error)
  
# Bye.
+
/* "Floppy" */
exit 0
+
fd_probe_error_string: .asciz "Floppy"
 +
 
 +
1:
 +
/* perform read */
 +
movw $GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
 +
movw $0x201, %ax
 +
movb $0, %ch
 +
movb $0, %dh
 +
int $0x13
 +
 
 +
/* if error, jump to "LOCAL(probe_loop)" */
 +
jc LOCAL(probe_loop)
 +
 
 +
/* %cl is already the correct value! */
 +
movb $1, %dh
 +
movb $79, %ch
 +
 
 +
jmp LOCAL(final_init)
 +
 
 +
. = _start + GRUB_BOOT_MACHINE_PART_END
 +
 
 +
</syntaxhighlight>
 +
<syntaxhighlight lang="asm">
 +
/* the last 2 bytes in the sector 0 contain the signature */
 +
.word GRUB_BOOT_MACHINE_SIGNATURE
 
</syntaxhighlight>
 
</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>.
+
The MBR has some magic bytes that let the BIOS recognize it instead of being random data.
 
[[Category:Grub]]
 
[[Category:Grub]]

Latest revision as of 20:09, 4 December 2010

Grub starts execution with the boot image. The boot image is 512 bytes and can be found in file form at /boot/grub/boot.img. The boot image is 512 bytes because that is how big the master boot record is. On a BIOS-based computer, a disk is booted by reading the first 512 bytes of a disk into memory address 0x7c00 and jumping to that location to begin execution. On an x86 or x86-64 system, the source code for that boot image can be found in the grub source code in assembly as grub-core/boot/i386/pc/boot.S. The bootloader is written in 16-bit assembly so it may help to be familiar with the 16-bit instruction set as well as the register set used. It's also useful to know how interrupts work since they get enabled and disabled at various times. Intel makes their manuals specifying these details available at http://www.intel.com/products/processor/manuals.

/* -*-Asm-*- */

This is just a magic comment that tells certain text editors to treat this as assembly and edit in an appropriate mode.

/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 1999,2000,2001,2002,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/>.
 */

This is just the license for the code.

#include <grub/symbol.h>
#include <grub/boot.h>
#include <grub/machine/boot.h>

These includes include information about offsets and other symbols used in the assembly.

/*
 *  defines for the code go here
 */
 
	/* Print message string */
#define MSG(x)	movw $x, %si; call LOCAL(message)
#define ERR(x)	movw $x, %si; jmp LOCAL(error_message)

These are just some definitions for how to print messages.

	.file	"boot.S"

This tells the assembler that we are starting the boot.S logical file.

	.text

This tells the assembler that the text portion of the executable format starts here.

	/* Tell GAS to generate 16-bit instructions so that this code works
	   in real mode. */
	.code16

This tells the assembler to output 16-bit instructions. This seems to only apply to ARM though according to the documentation.

.globl _start, start;
_start:
start:
	/*
	 * _start is loaded at 0x7c00 and is jumped to with CS:IP 0:0x7c00
	 */
 
	/*
	 * Beginning of the sector is compatible with the FAT/HPFS BIOS
	 * parameter block.
	 */
 
	jmp	LOCAL(after_BPB)
	nop	/* do I care about this ??? */

This jumps past the BIOS Parameter Block that takes up the first portion of the sector.

	/*
	 * This space is for the BIOS parameter block!!!!  Don't change
	 * the first jump, nor start the code anywhere but right after
	 * this area.
	 */
 
	. = _start + GRUB_BOOT_MACHINE_BPB_START
	. = _start + 4
 
	/* scratch space */
mode:
	.byte	0
disk_address_packet:
sectors:
	.long	0
heads:
	.long	0
cylinders:
	.word	0
sector_start:
	.byte	0
head_start:
	.byte	0
cylinder_start:
	.word	0
	/* more space... */
 
	. = _start + GRUB_BOOT_MACHINE_BPB_END
 
	/*
	 * End of BIOS parameter block.
	 */

This reserves space for the BIOS parameter block. The BIOS parameter block is not necessary in the MBR, but Grub uses the same image for a volume boot records as well. A volume boot record may have a BIOS parameter block, so space is made for it.

kernel_address:
	.word	GRUB_BOOT_MACHINE_KERNEL_ADDR
 
	. = _start + GRUB_BOOT_MACHINE_KERNEL_SECTOR
kernel_sector:
	.long	1, 0
 
	. = _start + GRUB_BOOT_MACHINE_BOOT_DRIVE
boot_drive:
	.byte 0xff	/* the disk to load kernel from */
			/* 0xff means use the boot drive */

Some other magic values are set up.

LOCAL(after_BPB):
 
/* general setup */
	cli		/* we're not safe here! */

This is the first instruction after the jump. The cli instruction clears the interrupts flag so that the processor does not respond to external maskable interrupts.

        /*
         * This is a workaround for buggy BIOSes which don't pass boot
         * drive correctly. If GRUB is installed into a HDD, check if
         * DL is masked correctly. If not, assume that the BIOS passed
         * a bogus value and set DL to 0x80, since this is the only
         * possible boot drive. If GRUB is installed into a floppy,
         * this does nothing (only jump).
         */
	. = _start + GRUB_BOOT_MACHINE_DRIVE_CHECK
boot_drive_check:
        jmp     3f	/* grub-setup may overwrite this jump */
        testb   $0x80, %dl
        jz      2f
3:
	/* Ignore %dl different from 0-0x0f and 0x80-0x8f.  */
	testb   $0x70, %dl
	jz      1f
2:	
        movb    $0x80, %dl
1:
	/*
	 * ljmp to the next instruction because some bogus BIOSes
	 * jump to 07C0:0000 instead of 0000:7C00.
	 */
	ljmp	$0, $real_start

Part of the BIOS interface is indicating which disk is being booted from. Some BIOSes get this wrong so this uses some heuristics to make a fallback guess if the BIOS did something dumb. The other thing done here is to deal with BIOSes that jump to 07C0:0000 instead of 0000:7C00. This is actually the same physical address, but 0000 is a different segment than 07C0. This can be problematic, so a long jump is made to allow execution to continue with a known segment.

real_start:
 
	/* set up %ds and %ss as offset from 0 */
	xorw	%ax, %ax
	movw	%ax, %ds
	movw	%ax, %ss
 
	/* set up the REAL stack */
	movw	$GRUB_BOOT_MACHINE_STACK_SEG, %sp
 
	sti		/* we're safe again */

The data segment and stack segment registers are zeroed out, and the stack pointer is set up. At this point, interrupts can be re-enabled.

	/*
	 *  Check if we have a forced disk reference here
	 */
	movb   boot_drive, %al
	cmpb	$0xff, %al
	je	1f
	movb	%al, %dl
1:
	/* save drive reference first thing! */
	pushw	%dx
 
	/* print a notification message on the screen */
	MSG(notification_string)
 
	/* set %si to the disk address packet */
	movw	$disk_address_packet, %si
 
	/* check if LBA is supported */
	movb	$0x41, %ah
	movw	$0x55aa, %bx
	int	$0x13
 
	/*
	 *  %dl may have been clobbered by INT 13, AH=41H.
	 *  This happens, for example, with AST BIOS 1.04.
	 */
	popw	%dx
	pushw	%dx
 
	/* use CHS if fails */
	jc	LOCAL(chs_mode)
	cmpw	$0xaa55, %bx
	jne	LOCAL(chs_mode)
 
	andw	$1, %cx
	jz	LOCAL(chs_mode)

Grub tries to use LBA geometry, but if the BIOS does not support LBA, it falls back to using CHS geometry.

lba_mode:
	xorw	%ax, %ax
	movw	%ax, 4(%si)
 
	incw	%ax
	/* set the mode to non-zero */
	movb	%al, -1(%si)
 
	/* the blocks */
	movw	%ax, 2(%si)
 
	/* the size and the reserved byte */
	movw	$0x0010, (%si)
 
	/* the absolute address */
	movl	kernel_sector, %ebx
	movl	%ebx, 8(%si)
	movl	kernel_sector + 4, %ebx
	movl	%ebx, 12(%si)
 
	/* the segment of buffer address */
	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, 6(%si)
 
/*
 * BIOS call "INT 0x13 Function 0x42" to read sectors from disk into memory
 *	Call with	%ah = 0x42
 *			%dl = drive number
 *			%ds:%si = segment:offset of disk address packet
 *	Return:
 *			%al = 0x0 on success; err code on failure
 */
 
	movb	$0x42, %ah
	int	$0x13
 
	/* LBA read is not supported, so fallback to CHS.  */
	jc	LOCAL(chs_mode)
 
	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
	jmp	LOCAL(copy_buffer)
 
LOCAL(chs_mode):
	/*
	 *  Determine the hard disk geometry from the BIOS!
	 *  We do this first, so that LS-120 IDE floppies work correctly.
	 */
	movb	$8, %ah
	int	$0x13
	jnc	LOCAL(final_init)
 
	/*
	 *  The call failed, so maybe use the floppy probe instead.
	 */
	testb	$GRUB_BOOT_MACHINE_BIOS_HD_FLAG, %dl
	jz	LOCAL(floppy_probe)
 
	/* Nope, we definitely have a hard disk, and we're screwed. */
	ERR(hd_probe_error_string)
 
LOCAL(final_init):
	/* set the mode to zero */
	movzbl	%dh, %eax
	movb	%ah, -1(%si)
 
	/* save number of heads */
	incw	%ax
	movl	%eax, 4(%si)
 
	movzbw	%cl, %dx
	shlw	$2, %dx
	movb	%ch, %al
	movb	%dh, %ah
 
	/* save number of cylinders */
	incw	%ax
	movw	%ax, 8(%si)
 
	movzbw	%dl, %ax
	shrb	$2, %al
 
	/* save number of sectors */
	movl	%eax, (%si)
 
setup_sectors:
	/* load logical sector start (top half) */
	movl	kernel_sector + 4, %eax
 
	orl	%eax, %eax
	jnz	LOCAL(geometry_error)
 
	/* load logical sector start (bottom half) */
	movl	kernel_sector, %eax
 
	/* zero %edx */
	xorl	%edx, %edx
 
	/* divide by number of sectors */
	divl	(%si)
 
	/* save sector start */
	movb	%dl, %cl
 
	xorw	%dx, %dx	/* zero %edx */
	divl	4(%si)		/* divide by number of heads */
 
	/* do we need too many cylinders? */
	cmpw	8(%si), %ax
	jge	LOCAL(geometry_error)
 
	/* normalize sector start (1-based) */
	incb	%cl
 
	/* low bits of cylinder start */
	movb	%al, %ch
 
	/* high bits of cylinder start */
	xorb	%al, %al
	shrw	$2, %ax
	orb	%al, %cl
 
	/* save head start */
	movb	%dl, %al
 
	/* restore %dl */
	popw	%dx
 
	/* head start */
	movb	%al, %dh
 
/*
 * BIOS call "INT 0x13 Function 0x2" to read sectors from disk into memory
 *	Call with	%ah = 0x2
 *			%al = number of sectors
 *			%ch = cylinder
 *			%cl = sector (bits 6-7 are high bits of "cylinder")
 *			%dh = head
 *			%dl = drive (0x80 for hard disk, 0x0 for floppy disk)
 *			%es:%bx = segment:offset of buffer
 *	Return:
 *			%al = 0x0 on success; err code on failure
 */
 
	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
	movw	%bx, %es	/* load %es segment with disk buffer */
 
	xorw	%bx, %bx	/* %bx = 0, put it at 0 in the segment */
	movw	$0x0201, %ax	/* function 2 */
	int	$0x13
 
	jc	LOCAL(read_error)
 
	movw	%es, %bx
 
LOCAL(copy_buffer):
	/*
	 * We need to save %cx and %si because the startup code in
	 * kernel uses them without initializing them.
	 */
	pusha
	pushw	%ds
 
	movw	$0x100, %cx
	movw	%bx, %ds
	xorw	%si, %si
	movw	$GRUB_BOOT_MACHINE_KERNEL_ADDR, %di
	movw	%si, %es
 
	cld
 
	rep
	movsw
 
	popw	%ds
	popa
 
	/* boot kernel */
	jmp	*(kernel_address)
 
/* END OF MAIN LOOP */
/*
 * BIOS Geometry translation error (past the end of the disk geometry!).
 */
LOCAL(geometry_error):
	ERR(geometry_error_string)
</syntaxhighlight lang="asm">
This is where Grub prints the error message when there is an issue with the disk geometry.
<syntaxhighlight lang="asm">
 
/*
 * Read error on the disk.
 */
LOCAL(read_error):
	movw	$read_error_string, %si
LOCAL(error_message):
	call	LOCAL(message)
LOCAL(general_error):
	MSG(general_error_string)
 
/* go here when you need to stop the machine hard after an error condition */
        /* tell the BIOS a boot failure, which may result in no effect */
        int	$0x18
LOCAL(stop):
	jmp	LOCAL(stop)
notification_string:	.asciz "GRUB "
geometry_error_string:	.asciz "Geom"
hd_probe_error_string:	.asciz "Hard Disk"
read_error_string:	.asciz "Read"
general_error_string:	.asciz " Error\r\n"

Several null-terminated ASCII strings are set up.

/*
 * message: write the string pointed to by %si
 *
 *   WARNING: trashes %si, %ax, and %bx
 */
 
	/*
	 * Use BIOS "int 10H Function 0Eh" to write character in teletype mode
	 *	%ah = 0xe	%al = character
	 *	%bh = page	%bl = foreground color (graphics modes)
	 */
1:
	movw	$0x0001, %bx
	movb	$0xe, %ah
	int	$0x10		/* display a byte */
LOCAL(message):
	lodsb
	cmpb	$0, %al
	jne	1b	/* if not end of string, jmp to display */
	ret
 
	/*
	 *  Windows NT breaks compatibility by embedding a magic
	 *  number here.
	 */
 
	. = _start + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC
nt_magic:
	.long 0
	.word 0
 
	/*
	 *  This is where an MBR would go if on a hard disk.  The code
	 *  here isn't even referenced unless we're on a floppy.  Kinda
	 *  sneaky, huh?
	 */
 
	. = _start + GRUB_BOOT_MACHINE_PART_START
part_start:
 
probe_values:
	.byte	36, 18, 15, 9, 0
 
LOCAL(floppy_probe):
/*
 *  Perform floppy probe.
 */
 
	movw	$probe_values - 1, %si
 
LOCAL(probe_loop):
	/* reset floppy controller INT 13h AH=0 */
	xorw	%ax, %ax
	int	$0x13
 
	incw	%si
	movb	(%si), %cl
 
	/* if number of sectors is 0, display error and die */
	cmpb	$0, %cl
	jne	1f
 
/*
 * Floppy disk probe failure.
 */
	MSG(fd_probe_error_string)
	jmp	LOCAL(general_error)
 
/* "Floppy" */
fd_probe_error_string:	.asciz "Floppy"
 
1:
	/* perform read */
	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
	movw	$0x201, %ax
	movb	$0, %ch
	movb	$0, %dh
	int	$0x13
 
	/* if error, jump to "LOCAL(probe_loop)" */
	jc	LOCAL(probe_loop)
 
	/* %cl is already the correct value! */
	movb	$1, %dh
	movb	$79, %ch
 
	jmp	LOCAL(final_init)
 
	. = _start + GRUB_BOOT_MACHINE_PART_END
/* the last 2 bytes in the sector 0 contain the signature */
	.word	GRUB_BOOT_MACHINE_SIGNATURE

The MBR has some magic bytes that let the BIOS recognize it instead of being random data.