Handbuch:X86/Blöcke/Bootloader

From Gentoo Wiki
Jump to:navigation Jump to:search
This page is a translated version of the page Handbook:X86/Blocks/Bootloader and the translation is 100% complete.


Nachdem der Linux Kernel konfiguriert ist, die System Tools installiert sind und die wichtigsten System Konfigurationsdateien angepasst sind, ist es nun an der Zeit, den letzten wichtigen Teil eines Linux-Systems zu installieren: den Bootloader.

Der Bootloader ist beim Booten dafür zuständig, den Linux Kernel zu starten. Ohne ihn würde das System nach dem Druck auf den Power-Knopf nicht wissen, wie es weiter vorgehen soll.

Wir zeigen für die x86 Architektur, wie man entweder GRUB oder LILO für BIOS basierte Systeme, oder GRUB oder efibootmgr für UEFI Systeme konfiguriert.

In diesem Abschnitt des Handbuchs wird unterschieden zwischen dem "Emerge" eines Bootloader-Pakets und dem "Installieren" des Bootloaders auf die System-Festplatte. Der Ausdruck "emerge" wird verwendet, wenn Portage aufgerufen wird, um eine Software auf dem System verfügbar zu machen. Der Ausdruck "installieren" wird verwendet, wenn der Bootloader Dateien in spezielle Bereiche der System-Festplatte kopiert oder dort Daten verändert, um den Bootloader so zu aktivieren, dass er beim nächsten Systemstart gestartet wird.

Standard: GRUB

Die Mehrzahl der Gentoo Linux Systeme verwendet heutzutage GRUB als Bootloader. GRUB (Paket sys-boot/grub) ist der direkte Nachfolger von GRUB Legacy. Ohne weitere Konfiguration unterstützt GRUB ältere BIOS ("pc") Systeme. Mit zusätzlicher Konfiguration unterstützt GRUB mehr als ein halbes Dutzend anderer Plattformen. Details finden Sie in dem Abschnitt Prerequisites section des GRUB Artikels im Gentoo Wiki.

Emerge

Wenn ein älteres BIOS System verwendet wird, das nur MBR Partitions-Tabellen unterstützt, sind keine Konfigurationsarbeiten erforderlich, um GRUB zu "emergen":

root #emerge --ask --verbose sys-boot/grub

Für UEFI Systeme: die Ausführung des obigen Kommandos zeigt vor dem "emerge" die aktivierten GRUB_PLATFORMS Werte an. Wenn UEFI Systeme verwendet werden, müssen Anwender sicherstellen, dass GRUB_PLATFORMS="efi-64" aktiviert ist (was standardmäßig der Fall sein sollte). Wenn es nicht der Fall ist, muss GRUB_PLATFORMS="efi-64" zu der Datei /etc/portage/make.conf hinzugefügt werden, bevor das Emerge-Kommando für GRUB ausgeführt wird. Ansonsten wird GRUB EFI nicht unterstützen.

root #echo 'GRUB_PLATFORMS="efi-64"' >> /etc/portage/make.conf
root #emerge --ask sys-boot/grub
Wenn GRUB installiert wurde ohne dass GRUB_PLATFORMS="efi-64" aktiviert war, kann die Zeile (wie oben gezeigt) zu make.conf hinzugefügt werden. Danach können die Abhängigkeiten für das world package set neu berechnet werden durch Aufruf von emerge mit den Optionen --update --newuse:
root #emerge --ask --update --newuse --verbose sys-boot/grub

Die GRUB Software wurde nun zu dem System hinzugefügt. Sie ist aber noch nicht installiert.

Installation

Als nächstes werden die erforderlichen GRUB Dateien in das /boot/grub/ Verzeichnis installiert. Hierfür kann das grub-install Kommando verwendet werden. Unter der Annahme, dass die erste Festplatte (diejenige von der das System bootet) /dev/sda ist, kann einer der folgenden Befehle verwenden werden:

  • Wenn ein BIOS-System verwendet wird:
root #grub-install /dev/sda

For DOS/Legacy BIOS systems:

root #grub-install /dev/sda
  • Wenn ein UEFI-System verwendet wird:
Wichtig
Stellen Sie sicher, dass die EFI System-Partition (ESP) eingehängt wurde, bevor Sie grub-install ausführen. Wenn die EFI System-Partition nicht eingehängt wurde, wird grub-install die Installation trotzdem durchführen. Die GRUB EFI-Datei (grubx64.efi) wird dann in das falsche Verzeichnis installiert. Dabei werden Sie nicht informiert oder gewarnt.

For UEFI systems:

root #grub-install --target=x86_64-efi --efi-directory=/boot

Upon successful installation, the output should match the output of the previous command. If the output does not match exactly, then proceed to Debugging GRUB, otherwise jump to the Configure step.

Optional: Secure Boot

The sys-boot/grub package does not recognize the secureboot USE flag, this is because the GRUB EFI executable is not installed by the package but is instead built and installed by the grub-install command. GRUB must therefore be manually signed after installation to the boot partition. Additionally, GRUB is a modular bootloader but loading modules is prohibited when Secure Boot is enabled. Therefore all necessary modules must be compiled into the GRUB EFI executable, below an example is shown including some basic modules, this may have to be adjusted for more advanced configurations:

root #emerge --noreplace sbsigntools
root #export GRUB_MODULES="all_video boot btrfs cat chain configfile echo efifwsetup efinet ext2 fat font gettext gfxmenu gfxterm gfxterm_background gzio halt help hfsplus iso9660 jpeg keystatus loadenv loopback linux ls lsefi lsefimmap lsefisystab lssal memdisk minicmd normal ntfs part_apple part_msdos part_gpt password_pbkdf2 png probe reboot regexp search search_fs_uuid search_fs_file search_label sleep smbios squash4 test true video xfs zfs zfscrypt zfsinfo"
root #grub-install --target=x86_64-efi --efi-directory=/efi --modules=${GRUB_MODULES} --sbat /usr/share/grub/sbat.csv
root #sbsign /efi/EFI/GRUB/grubx64.efi --key /path/to/kernel_key.pem --cert /path/to/kernel_key.pem --out /efi/EFI/GRUB/grubx64.efi

To successfully boot with secure boot enabled the used certificate must either be accepted by the UEFI firmware, or shim must be used as a pre-loader. Shim is pre-signed with the third-party Microsoft Certificate, accepted by default by most UEFI motherboards.

How to configure the UEFI firmware to accept custom keys depends on the firmware vendor, which is beyond the scope of the handbook. Below is shown how to setup shim instead:

root #emerge sys-boot/shim sys-boot/mokutil sys-boot/efibootmgr
root #cp /usr/share/shim/BOOTX64.EFI /efi/EFI/GRUB/shimx64.efi
root #cp /usr/share/shim/mmx64.efi /efi/EFI/GRUB/mmx64.efi

Shims MOKlist requires keys in the DER format, since the OpenSSL key generated in the example here is in the PEM format, the key must be converted first:

root #openssl x509 -in /path/to/kernel_key.pem -inform PEM -out /path/to/kernel_key.der -outform DER
Hinweis
The path used here must be the path to the pem file containing the certificate belonging to the generated key. In this example both key and certificate are in the same pem file.

Then the converted certificate can be imported into Shims MOKlist:

root #mokutil --import /path/to/kernel_key.der

And finally we register Shim with the UEFI firmware. In the following command, boot-disk and boot-partition-id must be replaced with the disk and partition identifier of the EFI system partition:

root #efibootmgr --create --disk /dev/boot-disk --part boot-partition-id --loader '\EFI\GRUB\shimx64.efi' --label 'shim' --unicode
Debugging GRUB

When debugging GRUB, there are a couple of quick fixes that may result in a bootable installation without having to reboot to a new live image environment.

In the event that "EFI variables are not supported on this system" is displayed somewhere in the output, it is likely the live image was not booted in EFI mode and is presently in Legacy BIOS boot mode. The solution is to try the removable GRUB step mentioned below. This will overwrite the executable EFI file located at /EFI/BOOT/BOOTX64.EFI. Upon rebooting in EFI mode, the motherboard firmware may execute this default boot entry and execute GRUB.

Wichtig
Wenn grub-install einen Fehler wie Could not prepare Boot variable: Read-only file system meldet, ist es möglicherweise erforderlich, einen Mount-Parameter des efivars-Dateisystems auf "read-write" zu ändern:
root #mount -o remount,rw,nosuid,nodev,noexec --types efivarfs efivarfs /sys/firmware/efi/efivars
root #mount -o remount,rw,nosuid,nodev,noexec --types efivarfs efivarfs /sys/firmware/efi/efivars

This is caused by certain non-official Gentoo environments not mounting the special EFI filesystem by default. If the previous command does not run, then reboot using an official Gentoo live image environment in EFI mode.

Einige Hersteller von Mainboards scheinen nur das Verzeichnis /efi/boot/ für die .EFI-Datei in der EFI System Partition (ESP) zu unterstützen. Der GRUB Installer unterstützt diese Arbeitsweise mit der Option --removable. Stellen Sie sicher, dass die ESP eingehängt wurde, bevor Sie die folgenden Kommandos ausführen. Vorausgesetzt, dass die ESP eingehängt ist unter /boot (wie früher vorgeschlagen), können Sie folgende Kommandos ausführen:
root #grub-install --target=x86_64-efi --efi-directory=/boot --removable
Dies erzeugt das von der UEFI Spezifikation definierte Standard-Verzeichnis und kopiert dann die grubx64.efi-Datei zu dem "Standard"-Ort der EFI-Datei, der in der gleichen Spezifikation definiert wurde.

Konfiguration

Im nächsten Schritt erzeugen wir auf Grundlage der Benutzereinstellungen, die in der Datei /etc/default/grub und den Skripten im Verzeichnis /etc/grub.d angegeben sind, die GRUB Konfiguration. In den meisten Fällen ist keine Konfiguration durch den Benutzer erforderlich, weil GRUB automatisch erkennen wird, welcher Kernel zu booten ist (den höchsten verfügbaren in /boot/) und was das Root Dateisystem ist. Mit Hilfe der GRUB_CMDLINE_LINUX Variable ist auch möglich, Kernel-Parameter in /etc/default/grub zu definieren.

Zum Generieren der endgültigen GRUB Konfiguration führen Sie den Befehl grub-mkconfig aus:

root #grub-mkconfig -o /boot/grub/grub.cfg
Generating grub.cfg ...
Found linux image: /boot/vmlinuz-5.15.52-gentoo
Found initrd image: /boot/initramfs-genkernel-x86-5.15.52-gentoo
done

Die Ausgabe des Befehls muss erwähnen, dass mindestens ein Linux Image gefunden wurde, da dieses zum Booten des Systems erforderlich sind. Wenn ein initramfs verwendet wird, oder der Kernel mit Hilfe von genkernel erzeugt wurde, sollte das korrekte initrd Image ebenfalls erkannt werden. Falls dies nicht der Fall ist, überprüfen Sie das Verzeichnis /boot/ mit dem Befehl ls auf dessen Inhalt. Wenn die Dateien in der Tat fehlen sollten, gehen Sie zurück zur Kernel-Konfiguration und der dortigen Installationsanleitung.

Tipp
Die os-prober Utility kann in Verbindung mit GRUB verwendet werden, um andere Betriebssysteme auf angeschlossenen Festplatten zu erkennen. Windows 7, 8.1, 10 und andere Linux Distributionen werden erkannt. Diejenigen, die ein Dual-Boot System wünschen, sollten das sys-boot/os-prober Paket "emergen" und dann das grub-mkconfig Kommando erneut ausführen (wie oben beschrieben). Falls Erkennungsprobleme auftreten, lesen Sie bitte den GRUB Artikel vollständig, bevor Sie die Gentoo Community um Hilfe bitten.

Alternative 1: LILO

Emerge

LILO, der LInuxLOader, ist das erprobte und wahre Arbeitstier unter den Linux Bootloadern. Allerdings fehlen ihm gegenüber GRUB einige Funktionen. LILO wird auch heute noch verwendet, weil GRUB auf einigen Systemen nicht funktioniert, aber LILO schon. Natürlich wird er ebenfalls verwendet, weil ihn einige Leute kennen und bei LILO bleiben wollen. So oder so, Gentoo unterstützt beide Bootloader.

Das "Emergen" von LILO ist ein Kinderspiel.

root #emerge --ask sys-boot/lilo

Konfiguration

Um LILO zu konfigurieren, erstellen Sie zunächst die Datei /etc/lilo.conf:

root #nano -w /etc/lilo.conf

In der Konfigurationstatei werden Abschnitte verwendet, um die bootfähigen Kernel zu referenzieren. Stellen Sie sicher, dass die Kernel-Dateien (mit Kernelversion) und die initramfs Dateien bekannt sind, da auf sie in dieser Konfigurationsdatei Bezug genommen werden muss.

Hinweis
Wenn als Root-Dateisystem JFS verwendet wird, fügen Sie bitte eine append="ro" Zeile nach jedem Booteintrag hinzu, weil JFS sein Log erst auslesen muss, bevor es ein Einhängen im Lese- und Schreibmodus erlaubt.
DATEI /etc/lilo.confLILO Beispiel-Konfiguration
boot=/dev/sda             # Install LILO in the MBR
prompt                    # Give the user the chance to select another section
timeout=50                # Wait 5 (five) seconds before booting the default section
default=gentoo            # When the timeout has passed, boot the "gentoo" section
compact                   # This drastically reduces load time and keeps the map file smaller; may fail on some systems
  
image=/boot/vmlinuz-5.15.52-gentoo
  label=gentoo            # Name we give to this section
  read-only               # Start with a read-only root. Do not alter!
  root=/dev/sda3          # Location of the root filesystem
  
image=/boot/vmlinuz-5.15.52-gentoo
  label=gentoo.rescue     # Name we give to this section
  read-only               # Start with a read-only root. Do not alter!
  root=/dev/sda3          # Location of the root filesystem
  append="init=/bin/bb"   # Launch the Gentoo static rescue shell
  
# The next two lines are for dual booting with a Windows system.
# In this example, Windows is hosted on /dev/sda6.
other=/dev/sda6
  label=windows
Hinweis
Wenn Sie ein anderes Partitionierungs-Schema und/oder Kernel-Abbild verwenden, passen Sie die Datei bitte entsprechend an.

Wenn ein initramfs notwendig ist, dann ändern Sie die Konfiguration, indem sie auf die initramfs Datei verweisen und dieser mitteilen, an welcher Stelle sich das echte Root-Device befindet:

DATEI /etc/lilo.confBoot-Eintrag mit initramfs Informationen
image=/boot/vmlinuz-5.15.52-gentoo
  label=gentoo
  read-only
  append="root=/dev/sda3"
  initrd=/boot/initramfs-genkernel-x86-5.15.52-gentoo

Wenn zusätzliche Optionen an den Kernel übergeben werden müssen, verwenden Sie die append Anweisung. Um beispielsweise die video Anweisung zur Aktivierung des Framebuffers hinzuzufügen:

DATEI /etc/lilo.confBoot-Optionen mit Video-Parametern
image=/boot/vmlinuz-5.15.52-gentoo
  label=gentoo
  read-only
  root=/dev/sda3
  append="video=uvesafb:mtrr,ywrap,1024x768-32@85"

Benutzer, die genkernel verwenden, sollten wissen, dass ihr Kernel die gleichen Bootoptionen verwendet, wie die Installations-CD. Wenn Sie beispielsweise SCSI Support benötigen, fügen sie doscsi als Kernel-Option hinzu.

Speichern Sie nun die Datei und beenden Sie den Editor.

Installation

Zum Abschluss führen Sie bitte das Programm /sbin/lilo aus, damit LILO die Einstellungen aus /etc/lilo.conf auf das System anwenden kann (das heißt: sich selbst auf die Festplatte installieren kann). Beachten Sie, dass /sbin/lilo jedes Mal erneut ausgeführt werden muss, wenn ein Kernel installiert, oder eine Veränderung an lilo.conf vorgenommen wurde.

root #/sbin/lilo

Alternative 2: efibootmgr

Auf UEFI basierten Systemen kann die UEFI Firmware auf dem System selbst (mit anderen Worten: der primäre Bootloader) dazu gebracht werden, dass sie selbst nach UEFI Boot-Einträgen sucht. Solche Systeme benötigen keine (sekundären) Bootloader wie GRUB, um das System zu booten. Auf solchen Systemen werden Bootloader wie GRUB genutzt, weil sie erweiterte Funktionalität bieten. efibootmgr ist für diejenigen gedacht, die ihr System auf direktem (und evtl. rigidem) Weg booten wollen. GRUB ist einfacher für die Mehrzahl der Anwender, weil es beim Booten von UEFI Systemen mehr Flexibilität bietet.

System administrators who desire to take a minimalist, although more rigid, approach to booting the system can avoid secondary bootloaders and boot the Linux kernel as an EFI stub.

Vergessen Sie nicht, dass die sys-boot/efibootmgr Anwendung kein Bootloader ist, sondern ein Werkzeug, um mit der UEFI-Firmware zu interagieren und deren Einstellungen zu aktualisieren. Auf diese Weise kann ein Kernel, der früher installiert wurde, mit zusätzlichen Optionen gebootet werden (falls nötig). Des Weiteren lassen sich dadurch mehrere Booteinträge realisieren. Diese Interaktion erfolgt durch EFI Variablen (daher die Notwendigkeit für die Kernel-Unterstützung für EFI Variablen).

Bitte lesen Sie den EFI stub kernel Artikel, bevor Sie fortfahren. Im Linux Kernel müssen bestimmte Optionen aktiviert sein, damit er direkt von der UEFI Firmware gebootet werden kann. Es kann notwendig sein, den Kernel erneut zu kompilieren. Es könnte auch hilfreich sein, den efibootmgr Artikel zu lesen.

It is also a good idea to take a look at the efibootmgr article for additional information.

Hinweis
Zur Wiederholung: efibootmgr ist keine Voraussetzung, um ein UEFI System zu booten. Der Linux-Kernel selbst kann direkt gebootet werden. Zusätzliche Kernel Bootparameter können in den Linux-Kernel einkompiliert werden (es gibt eine Kernel-Konfigurations-Option namens CONFIG_CMDLINE, mit der Benutzer Bootparameter spezifizieren können). Sogar ein initramfs kann in den Kernels einkompiliert werden.

Diejenigen, die diesen Weg gehen wollen, müssen zuerst die Software installieren:

root #emerge --ask sys-boot/efibootmgr

Erzeugen Sie das Verzeichnis /boot/efi/boot/ und kopieren Sie den Kernel dorthin. Ändern Sie dabei seinen Namen nach bootx64.efi.

root #mkdir -p /boot/efi/boot
root #cp /boot/vmlinuz-* /boot/efi/boot/bootx64.efi
Hinweis
Die Verwendung von \ als Verzeichnistrenner ist in UEFI Definitionen Pflicht.

Als Nächstes sagen Sie der UEFI Firmware, dass ein Booteintrag mit dem Namen "Gentoo" zu erstellen ist, der den frisch kompilierten EFI stub Kernel bootet:

root #efibootmgr --create --disk /dev/sda --part 2 --label "Gentoo" --loader "\efi\boot\bootx64.efi"

Falls ein Ausgangsdateisystem im Arbeitsspeicher (Initial RAM Filesystem = initramfs) verwendet wird, fügen Sie die passenden Bootoptionen hinzu:

root #efibootmgr -c -d /dev/sda -p 2 -L "Gentoo" -l "\efi\boot\bootx64.efi" initrd='\initramfs-genkernel-x86-5.15.52-gentoo'

Note that the above command presumes an initramfs file was copied into the ESP inside the same directory as the bootx64.efi file.

Nach diesen Änderungen wird bei einem Neustart das Systems ein Booteintrag mit der Bezeichnung "Gentoo" verfügbar sein.

Unified Kernel Image

If installkernel was configured to build and install unified kernel images. The unified kernel image should already be installed to the EFI/Linux directory on the EFI system partition, if this is not the case ensure the directory exists and then run the kernel installation again as described earlier in the handbook.

To add a direct boot entry for the installed unified kernel image:

root #efibootmgr --create --disk /dev/sda --part 1 --label "gentoo" --loader /efi/EFI/Linux/gentoo-x.y.z.efi

Alternative 3: Syslinux

Syslinux ist eine weitere Bootloader-Alternative für die x86 Architektur. Syslinux unterstützt MBR und - seit Version 6.0.0 - auch EFI. Weiterhin werden PXE (netboot) und weitere, weniger bekannte Optionen unterstützt. Obwohl Syslinux bei vielen Anwendern beliebt ist, wird es nicht in diesem Handbuch beschrieben. Es gibt jedoch einen Syslinux Artikel im Gentoo Wiki, in dem die Installation beschrieben wird.

Alternative 4: systemd-boot

Another option is systemd-boot, which works on both OpenRC and systemd machines. It is a thin chainloader and works well with secure boot.

To install systemd-boot:

root #bootctl install
Wichtig
Make sure the EFI system partition has been mounted before running bootctl install.

When using this bootloader, before rebooting, verify that a new bootable entry exists using:

root #bootctl list

If no new entry exists, ensure the sys-kernel/installkernel package has been installed with the systemd-boot USE flag enabled, and re-run the kernel installation.

For the distribution kernels:

root #emerge --ask --config sys-kernel/gentoo-kernel

For a manually configured and compiled kernel:

root #make install
Wichtig
When installing kernels for systemd-boot, no root= kernel command line argument is added by default. On systemd systems that are using an initramfs users may rely instead on systemd-gpt-auto-generator to automatically find the root partition at boot. Otherwise users should manually specify the location of the root partition by setting root= in /etc/kernel/cmdline as well as any other kernel command line arguments that should be used. And then reinstalling the kernel as described above.

Optional: Secure Boot

When the secureboot USE flag is enabled, the systemd-boot EFI executable will be signed automatically. bootctl install will automatically install the signed version.

To successfully boot with secure boot enabled the used certificate must either be accepted by the UEFI firmware, or shim must be used as a pre-loader. Shim is pre-signed with the third-party Microsoft Certificate, accepted by default by most UEFI motherboards.

How to configure the UEFI firmware to accept custom keys depends on the firmware vendor, which is beyond the scope of the handbook. A postinst hook to automatically update systemd-boot and set it up with shim instead is provided on the systemd-boot wiki page. However the first time this should be done manually by following the steps below:

root #emerge --ask sys-boot/shim sys-boot/mokutil sys-boot/efibootmgr
root #cp /usr/share/shim/BOOTX64.EFI /efi/EFI/BOOT/BOOTX64.EFI
root #cp /usr/share/shim/mmx64.efi /efi/EFI/BOOT/mmx64.efi
root #cp /efi/EFI/systemd/systemd-bootx64.efi /efi/EFI/BOOT/grubx64.efi
Hinweis
Shim is hardcoded to load grubx64.efi. As such the systemd-boot bootloader must be named as if it were GRUB.

Shims MOKlist requires keys in the DER format, since the OpenSSL key generated in the example here is in the PEM format, the key must be converted first:

root #openssl x509 -in /path/to/kernel_key.pem -inform PEM -out /path/to/kernel_key.der -outform DER
Hinweis
The path used here must be the path to the pem file containing the certificate belonging to the generated key. In this example both key and certificate are in the same pem file.

Then the converted certificate can be imported into Shims MOKlist:

root #mokutil --import /path/to/kernel_key.der

And finally we register Shim with the UEFI firmware. In the following command, boot-disk and boot-partition-id must be replaced with the disk and partition identifier of the EFI system partition:

root #efibootmgr --create --disk /dev/boot-disk --part boot-partition-id --loader '\EFI\BOOT\BOOTX64.EFI' --label 'shim' --unicode