Linux concept: kernel

1. De basis

De kernel is het centrale programma van het besturingssysteem. Het is de eerste echte software die de machine bij het opstarten laadt, het blijft in het geheugen zolang de computer aanstaat, en het heeft volledige controle over de hardware. Al het andere, van je shell tot je webbrowser tot een databaseserver, is een gewoon programma dat boven op de kernel draait en de kernel om hulp vraagt zodra het iets echts moet doen.

De reden voor dit ontwerp is bescherming. Een moderne CPU kan in twee modi draaien. In kernelmodus mag een programma alles: elk stukje geheugen aanraken, met elk apparaat praten, de processor stilzetten. In gebruikersmodus zit een programma opgesloten: het mag alleen zijn eigen geheugen gebruiken en moet voor al het andere iets vragen. De kernel draait in kernelmodus. Elk ander programma draait in gebruikersmodus. Deze scheiding is wat voorkomt dat een programma met een fout de hele machine laat crashen of de privegegevens van een ander programma leest.

Je begrijpt de kernel daarom het best als een poortwachter en een scheidsrechter. Als je programma een bestand wil lezen, kan het de schijf niet zelf openen; het vraagt het aan de kernel, en de kernel controleert je rechten, leest de juiste blokken, en geeft de data terug. Als twee programma's allebei de CPU willen, bepaalt de kernel wie er draait en hoe lang. Als een programma om geheugen vraagt, zoekt de kernel het en houdt het gescheiden van dat van alle anderen.

Het juiste mentale model: de kernel is het enige programma dat met de hardware mag praten. Elk ander programma op het systeem is een gast die de kernel om alles wat echt is moet vragen, en de kernel beslist ja of nee.

Dit artikel gaat over dat kernprogramma: wat het doet, waar de naam vandaan komt, hoe Linux is ontstaan, hoe je je eigen kernel bekijkt en afstelt, en de verrassende waarheid dat bijna alles wat je computer doet eigenlijk een kort verzoek is dat over de grens de kernel in en weer uit wordt gegeven. De voorbeelden zijn geverifieerd tegen Linux-kernelversie 6.11.

1.1 Zien welke kernel je draait

Je kunt je draaiende kernel zich met een commando laten identificeren: uname (kort voor "unix name"). De handigste vlag is -r (kort voor "release"):

$ uname -r
6.11.0-29-generic

$ cat /proc/version
Linux version 6.11.0-29-generic (buildd@lcy02-amd64-008) (gcc 13.3.0) #29 SMP PREEMPT_DYNAMIC ...

De eerste regel is de kernelversie die je op dit moment draait. De tweede, gelezen uit het speciale bestand /proc/version, voegt toe wie het bouwde, met welke compiler, en wanneer. Merk op dat je de kernel leest door een bestand te openen: die truc komt hieronder keer op keer terug.

1.2 Wat de kernel eigenlijk doet

Het werk van de kernel valt uiteen in een paar grote verantwoordelijkheden. Ze gaan allemaal over het veilig delen van een beperkte resource tussen veel programma's tegelijk:

Geen enkele applicatie kan deze taken voor zichzelf doen zonder elke andere applicatie te kunnen verstoren. Ze centraliseren in een vertrouwd programma is het hele idee van een besturingssysteemkernel.

1.3 Kernelruimte en gebruikersruimte

Je komt twee termen voortdurend tegen: kernelruimte en gebruikersruimte. Ze benoemen de twee werelden die de modusscheiding creeert. Kernelruimte is waar de kernel en zijn stuurprogramma's draaien, met volledige toegang tot de hardware. Gebruikersruimte is waar elk gewoon programma draait, afgeschermd en om hulp vragend. De grens ertussen wordt miljoenen keren per seconde overgestoken, en die oversteken is precies wat een systeemaanroep is:

USER SPACE     your shell, editor, browser, servers   (limited)
                          |
                          |   system call  (a guarded doorway)
                          v
KERNEL SPACE   scheduler, memory, drivers, filesystems (full power)
                          |
                          v
HARDWARE       CPU, RAM, disks, network, devices

Houd dit plaatje in gedachten. Bijna alles in de rest van dit artikel is ofwel iets wat in kernelruimte gebeurt, ofwel een manier voor jou, staand in gebruikersruimte, om over de grens te kijken en te zien wat de kernel doet.

1.4 De twee grote illusies: planning en virtueel geheugen

Twee van de taken van de kernel verdienen bijzondere aandacht, want samen creeren ze de illusie dat elk programma de machine voor zichzelf heeft.

De eerste is planning. Je machine draait veel meer programma's dan het CPU-kernen heeft, en toch gedraagt elk zich alsof het zonder onderbreking draait. De kernel bereikt dit met context switching: het laat een proces een paar milliseconden draaien, bewaart zijn exacte toestand, en geeft de kern door aan de volgende, honderden keren per seconde. Een planner bepaalt de volgorde en weegt eerlijkheid af tegen reactiesnelheid, en je kunt het aandeel van een proces bijsturen met zijn nice-waarde, een prioriteit die loopt van -20 (hebberig) tot 19 (vrijgevig):

$ nice -n 10 ./backup.sh     # start a job at low priority (short for "niceness")
$ renice -n 5 -p 1234        # lower the priority of a process already running

De tweede is virtueel geheugen. Elk proces krijgt zijn eigen prive, aaneengesloten beeld van het geheugen en denkt dat het de hele machine bezit. De kernel koppelt die virtuele adressen aan echt RAM in kleine stukken die pagina's heten, duwt pagina's die het niet nodig heeft naar swap op schijf, en gebruikt alle overgebleven RAM als een pagecache zodat recent gelezen bestanden meteen terugkomen. Dit is waarom vrij geheugen op een gezonde Linux-machine verontrustend laag lijkt: de kernel geeft het bewust uit als cache.

$ grep -E 'Cached|SwapTotal' /proc/meminfo   # page cache and swap size
Cached:         14711040 kB
SwapTotal:       8388604 kB

Geen van beide illusies is iets wat je aanzet; ze draaien allebei altijd, voor elk proces, onderhouden door de kernel miljoenen keren per seconde. De instelling vm.swappiness die je later tegenkomt is een kleine knop op deze tweede illusie.

3. Een korte geschiedenis

De Linux-kernel begon als het bijproject van een student en groeide uit tot de meest ingezette software ter wereld. Dat verhaal kennen verklaart een aantal van zijn ontwerpkeuzes.

De achtergrond is Unix, geschreven bij AT&T's Bell Labs vanaf 1969, met zijn idee van een kleine kernel plus veel kleine gereedschappen. Unix was niet gratis, dus in de jaren tachtig zetten twee initiatieven zich in om een vrije vervanging te bouwen. Richard Stallman startte het GNU-project in 1983 en bouwde een volledige set Unix-gereedschappen, maar de eigen kernel ervan was niet klaar. Los daarvan schreef Andrew Tanenbaum Minix, een klein leer-besturingssysteem, zodat studenten de broncode van een echte kernel konden bestuderen.

In 1991 begon een Finse student, Linus Torvalds, gefrustreerd door de licentie van Minix, voor de lol zijn eigen kernel te schrijven. Zijn aankondiging op 25 augustus 1991 is beroemd om hoe bescheiden die was:

"I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones." De hobby werd de kernel die nu het grootste deel van het internet, alle 500 supercomputers uit de Top 500 en elke Android-telefoon draait.

Torvalds bracht de kernel uit onder de GNU GPL, zodat iedereen hem kon lezen, wijzigen en delen. Samen met de al voltooide GNU-gereedschappen vormde dat een compleet vrij besturingssysteem. Duizenden ontwikkelaars sloten zich aan, en het groeide uit tot het grootste samenwerkingsproject in software ooit.

Een vroege discussie bepaalde hoe mensen over de kernel denken. In 1992 noemde Tanenbaum het monolithische ontwerp van Linux publiekelijk verouderd en pleitte in plaats daarvan voor een microkernel. In een monolithische kernel draaien stuurprogramma's en bestandssystemen allemaal samen in kernelruimte; in een microkernel draaien de meeste ervan als losse programma's in gebruikersruimte. Linux bleef monolithisch, voor snelheid en eenvoud, maar voegde laadbare modules toe zodat het geen star blok hoefde te zijn. Die keuze, "monolithisch maar modulair", is vandaag nog steeds het ontwerp.

De versienummers verdienen een kanttekening, want ze verrassen mensen. Sinds de sprong naar 3.0 betekent het eerste getal geen grote herschrijving; Torvalds verhoogt het vooral wanneer het tweede getal ongemakkelijk groot wordt. Een nieuwe stabiele kernel komt nu ongeveer elke negen of tien weken uit. De versie die je draait, zoals 6.11, is gewoon een punt op een gestage, doorlopende lijn.

Niet elke uitgave is bedoeld om te houden, en het verschil is belangrijk als je een kernel kiest. De meeste versies zijn stabiele uitgaven, die maar een paar maanden worden onderhouden. Een paar zijn gemarkeerd als Long-Term Support (LTS) en krijgen jarenlang beveiligingsfixes; op die kernels bouwen distributies voort en die draait bijna elke productieserver. Daarboven zit de mainline, waar Torvalds nieuwe ontwikkeling samenvoegt. In de praktijk jaag je bijna nooit op de nieuwste mainline-kernel: je draait de geteste LTS-kernel die je distributie levert en laat die je de beveiligingspatches aanreiken.

5. Gemiddelde gebruiksgevallen

Zodra je de kernel kunt lezen, is de volgende stap hem aan het werk zien en de onderdelen bekijken die hij op verzoek laadt. Niets hiervan wijzigt iets; het is allemaal inspectie, en het meeste heeft geen speciale rechten nodig.

5.1 Kernelmodules: de onderdelen die op verzoek laden

Een module is een stuk kernelcode, meestal een apparaatstuurprogramma, dat in de draaiende kernel geladen en weer verwijderd kan worden zonder herstart. Zo ondersteunt een klein kernelbestand duizenden verschillende apparaten: het laadt alleen de stuurprogramma's die je hardware echt nodig heeft. Toon de geladen modules met lsmod ("list modules"):

$ lsmod | head -4
Module                  Size  Used by
tls                   155648  0
inet_diag              28672  2 tcp_diag,udp_diag
udp_diag               12288  0

Elke regel is een stuurprogramma of functie die op dit moment in je kernel leeft. Om te weten wat er een is, vraag je het modinfo:

$ modinfo tls
filename:       /lib/modules/6.11.0-29-generic/kernel/net/tls/tls.ko.zst
license:        Dual BSD/GPL
description:    Transport Layer Security Support

De .ko in de bestandsnaam staat voor "kernel object", de vorm die een module op schijf heeft. Op moderne systemen is die gecomprimeerd, vandaar de extra .zst. Modules laden en verwijderen vereist root en gaat met modprobe, dat ook alle modules meeneemt waarvan degene die je vraagt afhankelijk is:

$ sudo modprobe -r tls     # remove a module (short for "remove")
$ sudo modprobe tls        # load it again, with its dependencies

5.2 De kernel lezen via /proc en /sys

Je las hierboven al /proc/version. Dat bestand staat niet echt op een schijf: het maakt deel uit van procfs, een virtueel bestandssysteem dat de kernel in het geheugen verzint om zijn eigen toestand als gewone bestanden te tonen. Zijn tegenhanger, sysfs op /sys, doet hetzelfde voor apparaten en kernelobjecten. Samen zijn ze de reden dat zoveel van Linux wordt geinspecteerd door simpelweg een bestand te lezen:

$ cat /proc/cpuinfo        # every CPU core the kernel sees
$ cat /proc/meminfo        # memory totals, straight from the kernel
$ cat /proc/uptime         # seconds since the kernel started
$ ls /sys/class/net        # network interfaces the kernel knows about

Niets hiervan is een echt bestand dat op een schijf wacht. Elke lezing is een live vraag aan de kernel, ter plekke beantwoord. Gereedschappen als free, top en lscpu zijn, onder de motorkap, gewoon vriendelijke lezers van diezelfde virtuele bestanden.

5.3 Het eigen logboek van de kernel: dmesg

De kernel houdt een doorlopend logboek van zijn eigen meldingen bij in een geheugengebied dat de ring buffer heet: hardware die het detecteerde, stuurprogramma's die het laadde, fouten die het tegenkwam. Je leest het met dmesg ("display message"):

$ dmesg | head            # earliest boot messages: CPU, memory, devices
$ sudo dmesg -w           # follow new kernel messages live (short for "wait")
$ sudo dmesg -T           # show human-readable timestamps

Dit is de eerste plek om te kijken als hardware zich misdraagt. Sluit een USB-stick aan en draai dmesg, en je ziet de kernel het apparaat opmerken, een stuurprogramma laden, en de nieuwe schijf benoemen. Op veel distributies heeft dmesg lezen nu sudo nodig, omdat het logboek details kan onthullen die nuttig zijn voor een aanvaller.

5.4 Een interface voor elk bestandssysteem: het VFS

Linux leest een ext4-schijf, een XFS-schijf, een Btrfs-volume, een FAT-USB-stick en een netwerkschijf over NFS met exact dezelfde commando's. Dat is geen geluk. De kernel heeft een laag die het Virtual File System (VFS) heet en die een gemeenschappelijke interface presenteert, zodat cd, ls, cp en de systeemaanroepen open en read zich identiek gedragen ongeacht welk echt bestandssysteem eronder zit. Elk type bestandssysteem klikt gewoon in het VFS. Je kunt elk type dat je kernel op dit moment begrijpt in nog een virtueel bestand opsommen:

$ cat /proc/filesystems     # filesystem types this kernel supports
nodev   sysfs
nodev   proc
        ext4
        xfs
        btrfs

De markering nodev betekent dat het type geen onderliggend apparaat heeft, zoals het virtuele proc-bestandssysteem; de andere zijn echte formaten op schijf. Het VFS is waarom een Linux-gebruiker zelden hoeft na te denken over welk bestandssysteem hij gebruikt: de kernel verbergt de verschillen achter een uniforme set bestanden, mappen en rechten.

7. Wat de meeste gebruikers niet weten

7.1 De hele kernel is een klein bestand

Het is makkelijk om je de kernel als iets enorms en uitgestrekts voor te stellen. Het is een enkel bestand van ongeveer vijftien megabyte in /boot, met de naam vmlinuz. De naam zelf vertelt een verhaal: vm omdat het virtueel geheugen ondersteunt, linu voor Linux, en een afsluitende z omdat het bestand gecomprimeerd is. Bij het opstarten pakt de kernel zichzelf uit in het geheugen, en vanaf dan heeft dat ene bescheiden bestand volledige zeggenschap over een machine met gigabytes RAM en tientallen apparaten. Al het andere op schijf is gewoon programma's en data die dit ene bestand wil draaien.

7.2 Bijna alles wat je doet is een systeemaanroep

Het strace-voorbeeld was een glimp van een diepere waarheid: programma's in gebruikersruimte kunnen niets echts uit zichzelf doen. Tekst afdrukken, een bestand aanmaken, een netwerkverbinding openen, een ander programma starten, de klok lezen, dit zijn allemaal systeemaanroepen, verzoeken aan de kernel. Er zijn er maar een paar honderd, en die korte lijst is het volledige vocabulaire waarin elk programma op het systeem om wat dan ook vraagt. Als je begrijpt dat een programma gewoon een reeks berekeningen is, onderbroken door syscalls, is de hele machine niet langer mysterieus.

7.3 De kernel "draait" niet zoals een programma

Je ziet de kernel nooit in een lijst met processen, want het is geen proces. Het heeft geen plek in de ps-uitvoer zoals een dienst dat heeft. In plaats daarvan zit de kernel stil tot iets hem aanroept: een programma doet een systeemaanroep, of een apparaat werpt een interrupt op, en de CPU schakelt naar kernelmodus, draait de relevante kernelcode, en schakelt terug. De kernel is minder een programma dat draait en meer een lichaam van code dat wordt betreden, zijn werk doet, en weer wordt verlaten, miljoenen keren per seconde. Daarom kan het alles beheren zonder ooit als een draaiende taak te verschijnen.

7.4 Modules zijn kernelcode die laadt terwijl je werkt

Als je een webcam aansluit en die gewoon werkt, heeft de kernel zojuist een stuurprogramma in zichzelf geladen, live, zonder herstart. Dat laadbare stuurprogramma is een module, en het draait met dezelfde volledige macht als de rest van de kernel; er is geen veiligheidshek tussen een module en de kern zodra die is geladen. Dit is de opbrengst van het "monolithisch maar modulair"-ontwerp uit de geschiedenissectie: de kernel blijft klein op schijf door de duizenden stuurprogramma's die het nodig zou kunnen hebben als losse modulebestanden te bewaren, en alleen die binnen te halen waar je feitelijke hardware om vraagt.

7.5 Je hebt vrijwel zeker meerdere kernels klaarstaan

Elke kernelupdate laat de vorige kernel geinstalleerd. Na verloop van tijd verzamel je er een klein stapeltje van in /boot en /lib/modules, en het opstartmenu biedt ze stilletjes allemaal aan. Dit is een bewust vangnet, geen rommel: als een nieuwe kernel niet opstart of een stuurprogramma breekt, herstart je, kies je de vorige uit het menu, en werk je binnen enkele seconden weer. Het is veruit de beste reden dat kernelupgrades op Linux zo weinig risico hebben, en het is waarom je oude kernels voorzichtig moet opruimen, met minstens een bekende, werkende terugval.

7.6 "Linux" is alleen de kernel

Het ding dat dit hele artikel beschrijft, de kernel, is het enige deel dat strikt Linux heet. De shell waar je in typt, de commando's ls en cat en grep, de compiler, de C-bibliotheek: niets daarvan is Linux. Ze komen grotendeels van GNU en andere projecten, en ze zijn hetzelfde op veel besturingssystemen. Linux is de kern waar ze allemaal op rusten. Daarom is de zorgvuldige naam voor het hele systeem GNU/Linux, en daarom antwoordt je kernel, gevraagd naar zijn besturingssysteem met uname -o, met precies dat namenpaar.

9. Veelgemaakte fouten

9.1 Mythe versus werkelijkheid

9.2 Andere valkuilen om te vermijden

• Alle oude kernels verwijderen om ruimte vrij te maken. Verwijder oude versies voorzichtig en houd altijd minstens een vorige kernel, anders kan een mislukte upgrade je zonder manier om op te starten achterlaten.
• Een sysctl-wijziging maken en verwachten dat die een herstart overleeft. Een live wijziging met -w is tijdelijk. Schrijf hem in /etc/sysctl.d/ om hem blijvend te maken.
• Kernelversie verwarren met distributieversie. Ubuntu 24.04 en de kernel 6.11 zijn twee verschillende dingen. uname -r geeft de kernel; /etc/os-release geeft de distributie.
• Een eigen kernel compileren zonder terugval. Laat de werkende distributiekernel altijd geinstalleerd en in het opstartmenu, zodat een kapotte eigen build geen dode machine is.
• Aannemen dat de kernel alleen naar /var/log logt. De eigen live buffer van de kernel is dmesg. Tekstlogboeken worden er achteraf uit weggeschreven; de buffer is de bron.
• Een module laden die voor een andere kernel is gebouwd. Modules zijn gebonden aan de exacte kernelversie waarvoor ze zijn gebouwd, en daarom heeft elke kernel zijn eigen /lib/modules-map.