GRUB kompiliert aus dem Quellcode unter Linux

GRUB ist die Abkürzung für GNU GRand Unified Bootloader: Es ist der Bootloader, der in praktisch allen Linux-Distributionen verwendet wird. Zu Beginn der Bootphase wird der Bootloader von der Firmware des Rechners geladen, entweder BIOS oder UEFI (GRUB unterstützt beide), und er lädt einen der verfügbaren Kernel. Da es sich um eine unverzichtbare Software handelt, ist grub standardmäßig installiert und in den offiziellen Repositories der Distribution, die wir verwenden, verfügbar. Manchmal möchten wir GRUB jedoch aus dem Quellcode kompilieren, entweder um eine bestimmte Version davon zu erhalten oder um die Änderung zu umgehen, die die Distributionen am Vanilla-Code hätten vornehmen können. In diesem Tutorial sehen wir, wie man einen solchen Vorgang durchführt.

In diesem Tutorial lernen Sie Folgendes:

• Installieren Sie die Software, die zum Erstellen von grub erforderlich ist
• Abrufen des Grub-Quellcodes
• Kompilieren Sie GRUB und führen Sie die Grub-Installation auf EFI- und BIOS-Plattformen durch.

Verwendete Softwareanforderungen und Konventionen

Installieren von GRUB-Kompilierungsabhängigkeiten

Bevor wir Grub auf unserem System erstellen können, müssen wir einige Software-Abhängigkeiten installieren. Der Befehl, der benötigt wird, um die Pakete zu installieren, die diese Software enthalten, variiert je nach der Distribution, die wir verwenden. Wenn wir beispielsweise Fedora verwenden, können wir den dnf-Paketmanager verwenden und Folgendes ausführen:

sudo dnf install \
  make \
  binutils \
  bison \
  gcc \
  gettext-devel \
  flex

Unter Debian können wir den folgenden Befehl ausgeben:

sudo apt-get update && sudo apt-get install \
  make \
  binutils \
  bison \
  gcc \
  gettext \
  flex

Unter Archlinux installieren wir Pakete mit dem Pacman:

sudo pacman -Sy \
  make \
  diffutils \
  python \
  binutils \
  bison \
  gcc \
  gettext \
  flex

Abrufen des GRUB-Quellcodes

Um den Grub-Quellcode zu erhalten, können wir mit unserem Browser zu der Seite navigieren, auf der die Quellcode-Tarballs gehostet werden, oder ein Befehlszeilentool wie Curl oder wget verwenden, um die Version herunterzuladen, die wir kompilieren möchten, ohne unseren Terminal-Emulator zu verlassen. Zum Zeitpunkt des Schreibens ist die neueste Version von grub 2.06. Tarballs sind sowohl mit der Erweiterung .xz als auch mit der .gz verfügbar: Der Quellcode, den sie enthalten, ist derselbe, aber sie werden mit unterschiedlichen Algorithmen komprimiert. Für dieses Beispiel werden wir letzteres mit curl herunterladen:

curl -O ftp.gnu.org/gnu/grub/grub-2.06.tar.gz

Wir möchten auch die zugehörige .sig herunterladen, um die Tarball-Signatur zu überprüfen:

curl -O ftp.gnu.org/gnu/grub/grub-2.06.tar.gz.sig

Um die Tarball-Signatur mit gpg zu überprüfen, müssen wir den öffentlichen Schlüssel importieren, der zum Signieren des Pakets verwendet wurde:

gpg --keyserver keyserver.ubuntu.com --receive-keys BE5C23209ACDDACEB20DB0A28C8189F1988C2166

Sobald der Schlüssel zu unserem Schlüsselbund hinzugefügt wurde, können wir die Tarball-Signatur überprüfen, indem wir den folgenden Befehl ausführen:

gpg --verify grub-2.06.tar.gz.sig

Wir sollten eine Botschaft der guten Unterschrift wie die folgende erhalten:

gpg: assuming signed data in 'grub-2.06.tar.gz'
gpg: Signature made Tue 08 Jun 2021 05:11:03 PM CEST
gpg:                using RSA key BE5C23209ACDDACEB20DB0A28C8189F1988C2166
gpg: Good signature from "Daniel Kiper <dkiper@net-space.pl>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: BE5C 2320 9ACD DACE B20D  B0A2 8C81 89F1 988C 2166

Kompilieren von GRUB-Code

Wir haben die Signatur des Grub-Tarballs heruntergeladen und überprüft, jetzt müssen wir um den Quellcode zu kompilieren, als erstes den Inhalt extrahieren:

tar -xvzf grub-2.06.tar.gz

Der obige Befehl extrahiert den Tarball-Inhalt und erstellt ein neues Verzeichnis mit dem Namen grub-2.06. An dieser Stelle wollen wir es eintragen:

cd grub-2.06

Sobald wir uns im grub-2.06-Verzeichnis befinden, können wir das configure-Skript starten und starten, das unter anderem dazu dient, zu überprüfen, ob die Build-Abhängigkeiten erfüllt sind. Das configure-Skript akzeptiert eine Reihe von Optionen, die die Kompilierung des Programms beeinflussen: Mit der Option --prefix können wir beispielsweise festlegen, wo die architekturunabhängigen Dateien installiert werden sollen. Der Standardwert für diese Option ist normalerweise /usr/local (dieses Verzeichnis wird als Installationsbasis verwendet, um Konflikte mit Software zu vermeiden, die mit dem Distributionspaket-Manager installiert wurde). Manchmal möchten wir diesen Wert ändern, z.B. wenn wir stow verwenden, um das vom Quellcode installierte Programm zu verwalten.

Unabhängig davon, welches Präfix wir setzen, wird ein Grub-Verzeichnis erstellt, wenn wir den Befehl make install ausführen. Es werden die erstellten Binärdateien und Bibliotheken gehostet.

Konfigurieren der GRUB-Kompilierung für eine bestimmte Plattform

Eine weitere wichtige Option, die wir verwenden können, ist --with-platform. Diese Option wird benötigt, um anzugeben, für welche Plattform der Quellcode kompiliert werden soll. Der Standardwert wird erraten. Um grub explizit für efi zu kompilieren, würden wir zum Beispiel schreiben:

./configure --with-platform=efi

Es gibt viele andere Optionen, die verwendet werden können, um Grub-Funktionen zu aktivieren oder zu deaktivieren (das Aktivieren weiterer Funktionen kann die Installation zusätzlicher Build-Abhängigkeiten erfordern). Für eine detaillierte Beschreibung können wir Folgendes ausführen:

./configure -h

Für dieses Tutorial werden wir grub mit den Standardoptionen kompilieren, daher führen wir einfach das configure-Skript aus, ohne etwas anzugeben:

./configure

Wenn alles wie erwartet verläuft, wird nach Beendigung der Arbeit des Skripts eine Zusammenfassung der Art und Weise, wie Grub kompiliert wird, auf dem Bildschirm gedruckt. In diesem Fall:

GRUB2 will be compiled with following components:
Platform: i386-pc
With devmapper support: No (need libdevmapper header)
With memory debugging: No
With disk cache statistics: No
With boot time statistics: No
efiemu runtime: Yes
grub-mkfont: No (need freetype2 library)
grub-mount: No (need FUSE library)
starfield theme: No (No build-time grub-mkfont)
With libzfs support: No (need zfs library)
Build-time grub-mkfont: No (need freetype2 library)
Without unifont (no build-time grub-mkfont)
Without liblzma (no support for XZ-compressed mips images) (need lzma library)
With stack smashing protector: No

Um den Code tatsächlich zu kompilieren, müssen wir nun make verwenden. Optional können wir es mit der Option -j (kurz für --jobs) aufrufen, um festzulegen, wie viele Befehle gleichzeitig ausgeführt werden sollen. Der Wert, der normalerweise an diese Option übergeben wird, ist die Anzahl der verfügbaren Verarbeitungseinheiten (wir können diesen Wert mit dem Befehl nproc erhalten). Wenn die Option -j ohne Argument angegeben wird, werden keine Einschränkungen auferlegt:

make -j$(nproc)

Sobald wir den obigen Befehl ausführen, wird die Kompilierung gestartet. Sobald der Vorgang abgeschlossen ist, können wir mit der Installation fortfahren. Da, wie wir gesehen haben, das Standardpräfix /usr/local ist, müssen wir den Befehl make install mit Root-Rechten starten. In diesem Fall verwenden wir sudo, um sie zu erhalten:

sudo make install

Bereinigen des Quellcode-Verzeichnisses nach der GRUB-Kompilierung

Nachdem wir den Code kompiliert haben, möchten wir möglicherweise das Quellcodeverzeichnis von den Resten früherer Konfigurationen bereinigen, nur für den Fall, dass wir den Vorgang wiederholen möchten. Um diese Aufgabe zu erfüllen, können wir zwei make-Ziele verwenden:

• sauber
• Reinigen

Was ist der Unterschied zwischen den beiden? Das erste Ziel bewirkt, dass die Binärdateien und Objekte des Programms entfernt werden. Letzteres macht dasselbe, entfernt aber zusätzlich auch Dateien, die mit dem Skript "configure" erzeugt wurden.

Schlüsse

In diesem Tutorial haben wir gelernt, wie man den Grub-Bootloader aus dem Quellcode erstellt. Wir haben gesehen, wie man den Tarball mit dem Quellcode herunterlädt und wie man ihn überprüft, wie man die Dateien extrahiert, wie man die benötigten Abhängigkeiten auf einigen der am häufigsten verwendeten Linux-Distributionen installiert und schließlich die Befehle, die zum Kompilieren und Installieren der Software benötigt werden.