LinuxKurs/Kernel.md_full

# Linux-Kurs - Kernel

Du konntest dein System erfolgreich auf Slackware -current aktualisieren. Nun ist es an der Zeit, dass wir uns den Kernel etwas genauer anschauen. Doch dazu ist einiges an Vorarbeit notwendig, denn wenn dein Kernel nicht mehr startet, kannst Du nur noch über Umwege auf dein System zugreifen.

**Hinweis**: Sofern nicht anders erwähnt, müssen alle folgenden Kommandos mit Root-Rechten ausgeführt werden.

## -current Synchronisation.

Zunächst möchten wir die Slackware-Paketaktualisierungen nicht mehr wie bisher über einen Internet-Mirror beziehen, sondern über einen lokalen Spiegelserver. Das heisst wir erstellen eine lokale Kopie des vollständigen Slackware -current Paketrepositories für die x86_64 Architektur. Wir werden diesen lokalen Mirror nutzen um Schwierigkeiten beim Upgrade zu vermeiden und weil wir den Kernel von der Aktualisierung mittels slackpkg ausschliessen möchten, um diesen später unabhängig von slackpkg updaten zu können.

Der Slackware Entwickler alienBOB stellt ein Script zur Synchronisation des -current Repositories zur Verfügung. Du kannst es mit Hilfe des **wget** Befehls herunterladen und mittels **chmod** als ausführbar markieren:

```
su -
wget http://slackware.uk/people/alien/tools/mirror-slackware-current.sh -O /usr/local/sbin/mirror-slackware-current.sh
chmod +x /usr/local/sbin/mirror-slackware-current.sh
```

Das Script ermöglicht die Synchronisation des -current Repositories mit Hilfe des **rsync** Kommandos und die Erstellung von ISO-Images. Standardmässig würde die 32bit Version synchronisiert. Um stattdessen die 64bit Variante der Distribution zu synchronisieren, bearbeite das heruntergeladene Script:

`vi /usr/local/sbin/mirror-slackware-current.sh`

Ändere den Inhalt der Variable *ARCH* von *x86* auf *x86_64*:

`ARCH=${ARCH:-"x86_64"}`

![](./slackware_mirror_current_arch.png)

Da wir keine ISO-Images erstellen möchten, kannst Du den Inhalt der Variable *ISO* auf *NONE* setzen:

`ISO=${ISO:-"NONE"}`

![](./slackware_mirror_current_iso.png)

Speichere deine Änderungen ab und verlasse den Editor.

Das Script verwendet als Standard-Speicherort den Pfad */home/ftp/pub/Linux/Slackware/slackware64-current* zur Synchronisation der 64bit-Variante. Da dieser noch nicht existiert musst Du es mit dem **mkdir** Kommando anlegen:

`mkdir -p /home/ftp/pub/Linux/Slackware/slackware64-current/`

Starte die Synchronisation indem Du das Script ausführst. Diese kann initial einige Zeit in Anspruch nehmen, da alle Pakete synchronisiert werden müssen. Wenn Du zu einem späteren Zeitpunkt das Script erneut aufrufst, werden nur noch die Änderungen synchronisiert:

`mirror-slackware-current.sh`

**Hinweis**: sollte die Synchronisation einmal abbrechen, kannst Du das Script erneut unter Angabe des Parameters **-f** aufrufen. Dieser erzwingt eine Synchronisation, auch wenn sich der Changelog nicht geändert hat. Über den zusätzlichen Parameter **-v** erhältst Du eine ausführlichere Ausgabe.

<div style="page-break-after: always;"></div>

### slackpkg Anpassungen

Zur Verwaltung der offiziellen Slackware-Pakete nutzen wir weiterhin den Paketmanager **slackpkg**. In der Datei */etc/slackpkg/mirrors* haben wir bisher einen Internet-Spiegelserver hinterlegt.

Diesen kannst Du auskommentieren und in der gleichen Datei den lokalen Mirror aktivieren.

```
vi /etc/slackpkg/mirrors
```

Suche die Zeile mit dem aktiven Slackware64 *-current* Mirror und füge am Zeilenanfang ein *#*-Zeichen ein.

Zu Beginn der Datei findest Du eine Beispielkonfiguration für einen lokalen Mirror. Diese beginnt mit *file://*. Entferne das *#*-Zeichen vor dem Eintrag und passe den Pfad an, so dass er auf das lokale Verzeichnis zeigt:

`file://home/ftp/pub/Linux/Slackware/slackware64-current/`

Beachte bitte den abschliessenden */* in der Pfadangabe. Zusammengefasst sollte die Konfiguration wie folgt aussehen:

![](./slackware_slackpkg_mirror_current.png)

Du kannst natürlich die weiteren auskommentierten Mirrors in der Datei beibehalten. Es darf allerdings nur ein Mirror aktiv konfiguriert sein.

<div style="page-break-after: always;"></div>

Zusätzlich möchten wir gerne den Kernel von der Aktualisierung mittels slackpkg ausnehmen, da andernfalls die bisherige Kernelversion durch ein Update überschrieben würde. Sollte es mit der neueren Kernelversion zu Schwierigkeiten kommen, könntest Du nur noch über ein Rettungsmedium auf dein Linux-System zugreifen.

Füge dazu folgende Einträge zur Datei */etc/slackpkg/blacklist* hinzu:

```
kernel-generic
kernel-generic-smp
kernel-headers
kernel-huge
kernel-huge-smp
kernel-modules
kernel-modules-smp
kernel-source
```

![](./slackware_slackpkg_blacklist_ponce_wsr_kernel.png)

### System aktualisieren

Die Aktualisierung deines Systems erfolgt wie gewohnt, mit dem Zusatz, dass Du nun zuvor das *mirror-slackware-current.sh* ausführen musst.

```
mirror-slackware-current.sh
slackpkg update
slackpkg install-new
slackpkg upgrade-all
slackpkg clean-system
```

Optional erfolgt die Aktualisierung der 3rd-Party-Repositories, falls Du diese konfiguriert hast:

`slackpkg install ktown`

und/oder:

`slackpkg install multilib`

## Kernel aktualisieren

Da wir nun den Kernel in der slackpkg Blacklist-Konfiguration von der Aktualisierung ausgenommen haben, wird dieser bei einem *slackpkg upgrade-all* nicht mehr geupdated. Ein Scriptes des Slackware Benutzers *luvr* ermöglicht die Aktualisierung des Kernels unter Beibehalten der bisherigen lauffähigen Version. So hast Du im Bedarfsfall immer die Möglichkeit dein System mit der vorherigen Kernel-Version zu starten.

Lade das Script herunter und markiere es mit Hilfe des **chmod** Befehls als ausführbar:

```
wget 'https://www.linuxquestions.org/questions/attachment.php?attachmentid=31763&d=1572878978' -O /usr/local/sbin/upgrade-kernel.sh
chmod +x /usr/local/sbin/upgrade-kernel.sh
```

**Hinweis**: die Anführungszeichen um die Download-URL sind in diesem Falle notwendig, da der Link ein `&`-Zeichen enthält, welches andernfalls von der BASH interpretiert würden. Alternativ könntest Du statt der einfachen Anführungszeichen um den Link auch das Sonderzeichen mit Hilfe von `\` *escapen* um es von der Interpretation durch die BASH auszuschliessen: `../questions/attachment.php?attachmentid=30786\&..`

Führe das Script zur Aktualisierung des Kernels aus:

`/usr/local/sbin/upgrade-kernel.sh`

<div style="page-break-after: always;"></div>

Es begrüsst dich mit einer TUI-Oberfläche und bietet dir an die neue Kernelversion herunterzuladen und zu installieren, sowie vorhandene Kernelversionen zu entfernen. Eine mögliche Ausgabe sieht wie folgt aus:

![](./slackware_upgrade_kernel.png)

Die Installation erfolgt dabei parallel zur vorhandenen Kernel-Version. Es werden entsprechende Symlinks im Verzeichnis */boot* generiert auf welche Du in lilo referenzieren kannst.

Sollte keine Kernel-Aktualisierung vorliegen, kannst Du die TUI verlassen. Dann ist es an der Zeit abzuwarten bis das nächste Kernel-Update im -current Zweig erfolgt, bevor Du weiter fortfährst. Zur Kontrolle hilft ein regelmässiger Blick in den Changelog:

ftp://ftp.osuosl.org/pub/slackware/slackware64-current/ChangeLog.txt

Wenn sich dort Veränderungen ergeben haben, kannst Du deinen lokalen Mirror mit Hilfe des *mirror-slackware-current.sh* Scriptes aktualisieren und die zuvor erwähnten Schritte ausführen. Falls die Änderungen eine aktuellere Kernel-Version beinhalten, kannst Du nun das *upgrade-kernel.sh* Script ausführen.

### Bootloader anpassen

Sobald das erste Kernel-Update mit Hilfe des *upgrade-kernel-sh* Scriptes installiert worden ist, werden symbolische Links auf die jeweils neue und die vorherige Kernelversion erstellt. Diese werden bei fortlaufenden Kernel-Aktualisierungen entsprechend angepasst.

Um die vom *upgrade-kernel.sh* Script erstellten symbolischen Links beim Systemstart auswählen zu können, muss die Datei */etc/lilo.conf* angepasst werden:

`vi /etc/lilo.conf`

Ersetze den bisherigen Abschnitt am Ende der Datei durch:

```
image = /boot/vmlinuz-huge
  root = /dev/sda2
  label = Huge
  read-only

image = /boot/vmlinuz-huge-prev
  root = /dev/sda2
  label = Huge-prev
  read-only
```

Nach der Anpassung muss der Bootloader neu geschrieben werden:

`lilo`

Dies Aktualisierung des Bootloaders muss zwingend nach jeder Kernel-Aktualisierung ausgeführt werden.

### Funktion überprüfen

Sobald die erste Kernelaktualisierung erfolgt ist, was unter Slackware -current sehr häufig der Fall sein kann, prüfe bitte ob Du den neuen Kernel mit der Bezeichnung *Linux* sowie den vorherigen Kernel mit der Bezeichnung *Linux-prev* erfolgreich starten kannst. Die aktive Kernelversion kannst Du dir mit Hilfe des `uname` Befehls ausgeben lassen:

`uname -a`

## initrd

Sollte alles soweit funktioniert haben, können wir die erste Änderung an der Kernelkonfiguration vornehmen. Bisher verwenden wir den monolithischen *huge* Kernel. Dabei handelt es sich um eine grosse Datei, die alle wichtigen Kernelmodule bereits enthält. Eine Alternative ist die Nutzung des sogenannten *generic* Kernels. Dieser enthält im Kernel-Image nur einen Bruchteil der Module. Um das System dennoch erfolgreich starten zu können, benötigst Du zusätzlich eine sogenannte *initrd*, was für *initial ramdisk* steht.

Diese initrd ist dynamisch und wird auf dein System angepasst. Beim Startvorgang lädt der Kernel die initrd nach und fährt dann mit dem init Prozess fort.

Slackware enthält ein Script mit dem Namen *mkinitrd_command_generator.sh* welches dich bei der Erstellung der initrd unterstützt. Es überprüft welche Module auf deinem System benötigt werden und gibt dir einen Befehl aus der zur Erstellung der Ramdisk ausgeführt werden kann:

`/usr/share/mkinitrd/mkinitrd_command_generator.sh`

![](./slackware_mkinitrd.png)

Ohne weitere Parameter bezieht sich das Script auf den aktuell laufenden Kernel. Es wird standardmässig keine Ramdisk erstellt sondern nur der Befehl ausgegeben, mit dem diese generiert werden kann.

Das *upgrade-kernel.sh* Script ruft den *mkinitrd_command_generator.sh* automatisch bei einer Kernel-Aktualisierung auf. Es ist daher nicht notwendig die Ramdisk manuell zu erstellen. Schaue dir das *upgrade-kernel.sh* Script einmal mit dem `view` Befehl an:

`view /usr/local/sbin/upgrade-kernel.sh`

Suche dort im Befehlsmodus mit Hilfe von `/mkinitrd` nach dem Aufruf des *mkinitrd_command_generator.sh* Scriptes:

![](./slackware_upgrade_kernel_mkinitrd.png)

`$(/usr/share/mkinitrd/mkinitrd_command_generator.sh -a '-o '"${INITRD}" --run "${KERNEL}")`

Hier wird das Script zur Erstellung der Ramdisk unter Angabe des gewünschten Namens und der Kernelversion aufgerufen.

Um den Kernel mit der initrd zu starten, müssen entsprechende Einträge in der Bootloader-Konfiguration hinterlegt werden. Füge dazu folgende Zeilen am Ende der */etc/lilo.conf* vor dem Hinweis *# Linux bootable partition config ends* hinzu:

```
image = /boot/vmlinuz-generic
  initrd = /boot/initrd-generic
  root = /dev/sda2
  label = Generic
  read-only

image = /boot/vmlinuz-generic-prev
  initrd = /boot/initrd-generic-prev
  root = /dev/sda2
  label = Generic-Prev
  read-only
```

Auch hier werden die passenden symbolischen Links für den neuen sowie den vorherigen Kernel vom *upgrade-kernel.sh* Script erzeugt.

Führe `lilo` aus und versuche die Kernel-Versionen mit der Ramdisk zu starten. Der Startvorgang sollte ein wenig schneller gehen als mit dem *huge* Kernel.

## Eigenen Kernel erstellen

Bisher haben wir die Kernel Varianten *huge* und *generic* der Distribution genutzt. Es kann allerdings vorkommen, dass eine neuere Kernelversion benötigt wird. Grund dafür kann zum Beispiel fehlende Hardwareunterstützung in der Distributions-Version sein.

Wir gehen davon aus das Du den *generic* Kernel gestartet hast. Sollte dies nicht der Fall sein, starte dein System neu und wähle im lilo Bootmenü den Punkt: *Generic*.

Um einen eigenen Kernel compilieren zu können, benötigen wir die entsprechenden Quellen. Die offiziellen Kernel-Quellen findest du auf: https://www.kernel.org

Kopiere dir beispielsweise im Firefox den Link auf die aktuelle stabile Kernelversion indem du mit der rechten Maustaste auf *[tarball]* klickst und **Link-Adresse kopieren** wählst. Öffne daraufhin ein Terminal und wechsle in das Verzeichnis */usr/src* in dem sich üblicherweise die Kernel-Quellen befinden:

`cd /usr/src`

Mit Hilfe des **wget** Befehls kannst Du das Kernel-Archiv herunterladen. Gebe dazu `wget` gefolgt von einem Leerzeichen ein und füge den zuvor kopierten Link mit `Ctrl + Shift + V` ein.

Zum Beispiel:

`wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.3.7.tar.xz`

Entpacken kannst Du das Archiv mit folgendem Kommando:

`tar -xvpf linux-*.tar.xz`

Wechsle daraufhin in den neu erstellten Pfad, in unserem Beispiel mit Hilfe von:

`cd linux-5.3.7`

Als Basis für den neuen Kernel kannst Du die Konfiguration deines bisherigen Kernels verwenden. Mit folgendem Befehl kannst Du die bisherige Konfiguration übernehmen:

`zcat /proc/config.gz > .config`

Der Befehl `zcat` verhält sich ähnlich wie der bereits bekannte `cat` Befehl, ermöglicht aber auch das Anzeigen von gzip-komprimierten Dateien. Das `>` Zeichen leitet die Ausgabe um, in diesem Falle in die Datei *.config* im aktuellen Verzeichnis.

Mit Hilfe von `make olddefconfig` kann daraufhin die alte Konfiguration adaptiert werden:

`make olddefconfig`

Nun ist es möglich Anpassungen an der Kernelkonfiguration vorzunehmen. Dabei hilft dir der Befehl `make menuconfig`. Alternativ gibt es eine grafische Konfigurationsoberfläche die Du mit `make xconfig` aufrufen kannst.

Anpassungen am Kernel sind optional. Als Beispiel möchten wir die Unterstützung für das Sicherheitsframework AppArmor aktivieren. Dieses bietet zusätzlichen Schutz auch vor noch nicht öffentlich bekannten Sicherheitslücken, sogenannten Zero-Day-Exploits.

Starte im Verzeichnis in dem sich die Kernel-Sourcen befinden den folgenden Befehl:

`make menuconfig`

Es begrüsst dich eine TUI-Oberfläche in der Du wie gewohnt navigieren kannst. Wenn Du ein Untermenü öffnest, kannst Du über den **Exit** Befehl eine Ebene zurückspringen. 

**Hinweis:** Im Hauptmenü beendet **Exit** die Anwendung.

Navigiere mit den Cursortasten oder durch Aufruf des Kurzbefehls zum Punkt *Security Options* und öffne das Untermenü durch Eingabe von Enter, sofern der Punkt **Select** aktiviert ist.

![](./slackware_kernel_security_options.png)

Scrolle in der sich öffnenden Parameterliste bis zu den Punkt AppArmor Support und aktiviere diesen mit der Space-Taste.

![](./slackware_kernel_apparmor.png)

Du kannst bei Bedarf weiter Änderungen vornehmen. Speichere deine Änderungen ab, indem Du mit der Tab-Taste den Punkt **Save** anwählst und mit Enter bestätigst.

Du wirst nach einem Dateinamen für die Kernel-Konfigurationsdatei gefragt. Standardmässig lautet dieser *.config*. Wir gehen davon aus, dass Du die Einstellung unverändert beibehältst.

Als nächstes kannst Du die Anwendung mit Hilfe des **Exit** Befehls beenden. Du musst ihn möglicherweise mehrmals anwählen, falls Du dich in einem Untermenü befindest.

Mit folgendem Befehl startest Du den Compiliervorgang:

`make bzImage modules`

Es werden das Kernel-Image (*bzImage*) sowie die Kernelmodule (*modules*) compiliert. Dieser Vorgang kann einige Zeit in Anspruch nehmen.

Die compilierten Kernelmodule müssen daraufhin in den entsprechenden Pfad kopiert werden. Standardmässig wäre dies */lib/modules/* gefolgt von der Kernelversion. Dabei hilft dir das folgende Kommando:

`make modules_install`

Der Befehl kopiert nicht nur die Kernelmodule an den richtigen Ort sondern führt abschliessend auch das `depmod` Kommando aus. Einige Kernelmodule haben Abhängigkeiten, die mit Hilfe von **depmod** aufgelöst und in der Datei */lib/modules/KERNELVERSION/modules.dep* hinterlegt werden.

Das eigentliche Kernel-Image muss nun in den */boot* Pfad kopiert werden:

`cp arch/x86/boot/bzImage /boot/vmlinuz-5.3.7`

Ersetze die Kernel-Version (in diesem Beispiel *5.3.7*) durch diejenige des Kernels den Du compiliert hast.

Es ist sinnvoll auch die *System.map* sowie die Kernel-Konfiguration in den */boot* Pfad zu kopieren:

```
cp System.map /boot/System.map-5.3.7
cp .config /boot/config-5.3.7
```

Auch hier muss der Dateiname entsprechend angepasst werden, so dass er der compilierten Kernelversion entspricht. Die *System.map* wird im Fehlerfalle zum Debugging genutzt. Ausführliche Informationen dazu findest du auf folgender Webseite: https://rlworkman.net/system.map/

### Ramdisk

Da wir den neuen Kernel auf der Basis des *generic* Kernels erstellt haben, ist eine Ramdisk zwingend notwendig. Zur Erstellung kannst Du das *mkinitrd_command_generator.sh* Script zur Hilfe nehmen.

`$(/usr/share/mkinitrd/mkinitrd_command_generator.sh -k 5.3.7 -a "-o /boot/initrd-5.3.7.gz" --run)`

Ersetze hierbei die Kernelversion durch die deines Kernels. Der Parameter *--run* gibt nur das Kommando zur Erstellung der initrd ohne weitere Bemerkungen aus. Da wir die gesamte Zeichenkette in *$()* stellen, wird diese von der BASH als Befehl interpretiert, also direkt ausgeführt und die initrd erzeugt. 

Das *upgrade-kernel.sh* Script kümmert sich nicht um die Erstellung der Ramdisk für deinen persönlichen Kernel. Jedes Mal wenn Du einen neuen Kernel compilierst und verwenden möchtest musst Du initrd erneut erzeugen.


### Bootloader

Abschliessend wird der Bootloader angepasst, so dass Du in der Lage bist deinen neuen Kernel zu starten.

Füge dazu einen entsprechenden Eintrag vor dem Hinweis *# Linux bootable partition config ends* zu der */etc/lilo.conf* Konfigurationsdatei hinzu:

```
image = /boot/vmlinuz-5.3.7
  initrd = /boot/initrd-5.3.7.gz
  root = /dev/sda2
  label = Linux-5.3.7
  read-only
```


Wobei die Versionsnummer entsprechend angepasst werden muss, so dass sie deinem Kernel entspricht.

Führe `lilo` aus und versuche deine erste selbstcompilierte Kernel-Versionen zu starten.

...


Würdest Du neben den Standardmodulen die automatisch vom *mkinitrd_command_generator.sh* Script integriert werden weitere Module oder Parameter angeben wollen, könntest Du diese Zeile entsprechend anpassen.

Ein Beispiel zur Verwendung des Schweizerdeutschen Tastaturlayouts zum Entsperren von verschlüsselten Partitionen könnte wie folgt aussehen:

`$(/usr/share/mkinitrd/mkinitrd_command_generator.sh -a -l sg-latin1 -h /dev/cryptvg/swap '-o '"${INITRD}" --run "${KERNEL}")`

Hier wird ausserdem der Parameter `-h /dev/cryptvg/swap` verwendet, welcher besagt, dass bei einem Hibernate-Vorgang die verschlüsselte Swap Partition zur Sicherung des Systemstands verwendet werden soll.

Da Du bisher auf deinem Linux-System keine Festplattenverschlüsselung