GUID Booting Guide

From Funtoo
Jump to navigation Jump to search
   Support Funtoo!
Get an awesome Funtoo container and support Funtoo! See Funtoo Containers for more information.


GPT, which stands for GUID Partition Table, is a disk partitioning scheme that was introduced by Intel for Itanium architecture systems, as part of EFI, the Extensible Firmware Interface. While you are probably not using an Itanium architecture computer, and you are likely using a BIOS-based rather than an EFI-based system, you still may want to use GPT partitioning. Why? Because the standard MBR-based partitioning scheme only supports system disks that are less than 2TiB in size. On modern systems, especially systems with hardware RAID logical volumes, it is very easy to go beyond the 2TiB limit. GUID partition tables support disks that are larger than 2TiB in size.

GPT Technology Overview

This section contains a technical overview of GPT technology.

GUID partition tables support up to 512 partitions. GPT data structures are stored in the first sectors of the drive with a secondary copy stored at the end of the drive. This allows the partitioning scheme of your disk to be recovered in situations where the primary partition table has been corrupted.

For compatibility with legacy partitioning tools, GPT partitioning tools typically rewrite the MBR partition table (generally located in the first sector of the disk) in a way those tools will interpret it like "This disk has only one partition (of an unknown type) covering the whole disk".

It is possible to convert an existing MBR-partitioned disk to GPT format using the gdisk command. Please carefully read the gdisk man page before using this capability, as it is potentially dangerous, particularly if you are performing it on your boot disk.


Funtoo Linux fully supports GPT on x86-32bit and x86-64-bit systems.

Booting GPT

If you decide to use a GPT-based partitioning scheme for your system disk, either out of necessity due to a 2TiB+ disk, or because you want to try GPT out, then the question arises -- how do you get the darn thing to boot? This is where the new GRUB boot loader comes in. The new GRUB (version 2.0, found at sys-boot/grub) is a redesign of the original GRUB (version 0.9x, now called sys-boot/grub-legacy in Funtoo) boot-loader that includes very mature support for booting from GPT-based disks.

Now, let's take a look at how to get GPT-based booting working under Funtoo Linux.

Getting Started

The first thing you'll need to do is to use a LiveCD. I recommend System Rescue CD for this task as it is Gentoo-based and includes all the proper tools. Go ahead and boot the LiveCD, and then get to the point where you are ready to partition your system disk.

At this point, you have two choices as to what partitioning tool to use. You can use either gdisk or parted. gdisk is a very nice fdisk-like partitioning tool that supports GPT partitioning. It is rather new software but seems to work quite well. The other tool you can use, GNU parted, has been around for a while and is more mature, but is harder to use.

We'll take a look at how to create partitions using gdisk. Alternatively, cgdisk, curses-based gdisk for users familiar with cfdisk or sgdisk, command-line tool can be used for creating and managing GPT partitions.

Partitioning Using Gdisk

OK, the first step is using gdisk is to start it up, specifying the disk you want to modify:

root # gdisk /dev/sda

You should find gdisk very familiar to fdisk. Here is the partition table we want to end up with:

Command (? for help): p
Disk /dev/sda: 312581808 sectors, 149.1 GiB
Disk identifier (GUID): 17
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 312581774
Total free space is 0 sectors (0 bytes)

Number  Start (sector)    End (sector)  Size       Code  Name
   1              34          204833   100.0 MiB   0700  Linux/Windows data
   2          204834          270369   512.0 kiB   EF02  BIOS boot partition
   3          270370         1318945   512.0 MiB   8200  Linux swap
   4         1318946       312581774   148.4 GiB   0700  Linux/Windows data

Command (? for help):

Above, you'll see that we have a 100 MiB boot partition, a 512 kiB "BIOS boot partition", 512 MiB of swap, and the remaining disk used by a 148.4 GiB root partition.

The one new thing here is the "BIOS boot partition." What is it? In GRUB-speak, this BIOS boot partition is basically the location of the meat of GRUB's boot loading code - the quivalent of the stage1_5 and stage2 files in legacy GRUB. Since GPT-based partition tables have less "bonus" space than their MBR equivalents, and explicit partition of code EF02 is required to hold the guts of the boot loader.

In all other respects, the partition table is similar to that of an MBR-based disk. We have a boot and root partition with code 0700, and a Linux swap partition with code 8200. One this partition table has been written to disk and appropriate mkfs and mkswap commands are issued, /dev/sda1 will be used to hold /boot, /dev/sda2 will be used by the new GRUB directly, /dev/sda3 will house our swap and /dev/sda4 will hold our root filesystem.

Go ahead and create filesystems on these partitions, and then mount the root and boot filesystems to /mnt/gentoo and /mnt/gentoo/boot respectively. Now go ahead and unpack a stage3 tarball to /mnt/gentoo and chroot in as you normally do.

Configuring The Kernel

Your kernel will need a couple of extra GPT-related options enabled in order for it to make sense of your GPT partitions and find your filesystems.

Under Enable the block layer-->Partition Types:

[*] Advanced Partition Selection (PARTITION_ADVANCED)
[*] EFI GUID Partition Support (EFI_PARTITION)

If you are using a non-Funtoo distribution then you may need to append a proper rootfstype= option to your kernel boot options to allow Linux to properly mount the root filesystem when Advanced Partition Selection is enabled. Boot-Update does this for you automatically.

Now just go ahead and compile and install your kernel, and copy it to /boot/bzImage.

Booting The System

To get the system booted, you will want to first edit /etc/fstab inside the chroot so that it reflects the partitions and filesystems you just created. For Funtoo Linux systems, this is done by emerging boot-update, which is the universal boot loader configurator for Funtoo Linux.

root # emerge boot-update

Boot-Update is a front-end for the GRUB 1.9x boot loader and provides a necessary simplified configuration interface. boot-update is used to generate boot loader configuration files. But before we get to boot-update, we first need to install GRUB to your hard disk. This is done as follows:

root # grub-install /dev/sda

grub-install will detect and use /dev/sda2 and use it to store its boot loader logic.

Now it's time to create an /etc/boot.conf file. For more information on all available options, consult the Boot-Update guide -- I'll show you a sample configuration for the sample GPT partition scheme above:

boot {
        generate grub
        default bzImage

"Funtoo Linux" {
        kernel bzImage

Once /etc/boot.conf has been created, then type:

root # boot-update

This will auto-generate a /boot/grub/grub.cfg file for you, and you will now be able to reboot into Funtoo Linux using a GPT partitioning scheme.

For more information on all the options available for /etc/boot.conf, please consult the Boot-Update guide.


Browse all our available articles below. Use the search field to search for topics and keywords in real-time.

Article Subtitle
Article Subtitle
Awk by Example, Part 1 An intro to the great language with the strange name
Awk by Example, Part 2 Records, loops, and arrays
Awk by Example, Part 3 String functions and ... checkbooks?
Bash by Example, Part 1 Fundamental programming in the Bourne again shell (bash)
Bash by Example, Part 2 More bash programming fundamentals
Bash by Example, Part 3 Exploring the ebuild system
Funtoo Filesystem Guide, Part 1 Journaling and ReiserFS
Funtoo Filesystem Guide, Part 2 Using ReiserFS and Linux
Funtoo Filesystem Guide, Part 3 Tmpfs and Bind Mounts
Funtoo Filesystem Guide, Part 4 Introducing Ext3
Funtoo Filesystem Guide, Part 5 Ext3 in Action
GUID Booting Guide
Learning Linux LVM, Part 1 Storage management magic with Logical Volume Management
Learning Linux LVM, Part 2 The upgrade
Linux Fundamentals, Part 1
Linux Fundamentals, Part 2
Linux Fundamentals, Part 3
Linux Fundamentals, Part 4
Making the Distribution, Part 1
Making the Distribution, Part 2
Making the Distribution, Part 3
Maximum Swappage Getting the most out of swap
On screen annotation Write on top of apps on your screen
OpenSSH Key Management, Part 1 Understanding RSA/DSA Authentication
OpenSSH Key Management, Part 2 Introducing ssh-agent and keychain
OpenSSH Key Management, Part 3 Agent Forwarding
Partition Planning Tips Keeping things organized on disk
Partitioning in Action, Part 1 Moving /home
Partitioning in Action, Part 2 Consolidating data
POSIX Threads Explained, Part 1 A simple and nimble tool for memory sharing
POSIX Threads Explained, Part 2
POSIX Threads Explained, Part 3 Improve efficiency with condition variables
Sed by Example, Part 1
Sed by Example, Part 2
Sed by Example, Part 3
Successful booting with UUID Guide to use UUID for consistent booting.
The Redesign, Part 1 A site reborn
The Redesign, Part 2 The Documentation System
The Redesign, Part 3 The New Main Pages
The Redesign, Part 4 The Final Touch of XML
Traffic Control
Windows 10 Virtualization with KVM