Een kernel bouwen.pdf - GM Club

Een kernel bouwen
Waarom is het nuttig om zelf een kernel te bouwen ?
Hoewel iedereen begrijpt waar je het over hebt als je PC zegt, is het niet zo dat elke PC gelijk is aan elke
andere PC. Integendeel, er zijn vele leveranciers van moederborden, processoren, harde schijven,
videokaarten, enzovoort, en al die leveranciers hebben in de loop van de tijd al vele verschillende varianten
van hun produkten uitgebracht. Met andere woorden: als je nauwkeurig kijkt naar alle onderdelen, is elke PC
anders dan alle andere PC's.
Elke type produkt van elke leverancier werkt op zijn eigen manier, en het kernel moet dus weten hoe het moet
communiceren met al die onderdelen.
Uitgevers van Linux CD-ROMs hebben het probleem dat ze een CD willen maken die op elke PC te
gebruiken is, maar ze kunnen niet alle mogelijke varianten van het Linux kernel maken, want dat zou niet op
een CD-ROM passen (waarschijnlijk niet eens op enkele tientallen CD-ROMs). Wat ze doen is een klein
aantal kernels op de CD-ROM zetten met `typische' PC-configuraties. Elke PC-gebruiker pakt het kernel wat
het best bij zijn computer past, en gebruikt dat om Linux mee te draaien.
Het probleem van deze aanpak is dat het kernel wat op de CD-ROM staat weliswaar wel werkt, maar ook veel
meer kan dan wat er in de computer zit (en dus nodig is). Een voorbeeld is het kernel `net' van Slackware. Dit
kernel kent alle netwerkkaarten, en tenzij de hele computer vol zit met die dingen, heb je aan genoeg aan een
kernel die alleen het type kaart kent wat ook echt in de computer zit.
Alle programmatuur die in het kernel zit om onderdelen aan te sturen die niet in de computer zitten vormt
alleen maar ballast, en houdt een stuk geheugen vast wat nuttiger ergens anders voor gebruikt kan worden. In
sommige (extreme) gevallen zijn ze zelfs oorzaak van het niet goed werken van het kernel.
De oplossing voor dit alles is het maken van een kernel specifiek voor de eigen computer. Op die manier
wordt gezorgd dat Linux optimaal functioneert.
Hoe bouw je een kernel ?
Het bouwen van een kernel bestaat uit vijf stappen:
1. Zorg dat de broncode van een recente versie van het kernel beschikbaar is op het systeem.
2. Configureer het kernel.
3. Maak een executeerbare kernelimage.
4. Installeer de kernelimage zodanig dat de computer ermee opstart als de computer wordt aangezet.
5. Start de machine opnieuw, zodat het nieuwe geladen wordt (en daarmee in gebruik wordt genomen).
Het lijkt de eerste keer allemaal erg veel en erg moeilijk, maar met wat geduld, wat nadenken, en het nemen
van wat veiligheidsmaatregelen kan er weinig misgaan.
De broncode van een recent kernel
Versienummers van kernels
Omdat Linux (en het Linux kernel) constant in ontwikkeling is, en het testen door een grote groep
vrijwilligers gedaan wordt over de hele wereld, komen er constant nieuwe versies uit. Om wat orde te houden
in alle versies bestaat er een nummerings-systeem om elke versie een uniek nummer te geven.

Een versienummer van een kernel is niet één getal, maar bestaat uit 3 getallen, gescheiden door een punt.
Opvragen van dit nummer kan gedaan worden met het commando `uname -a'. Mijn computer meldt:
Linux rataplan 2.0.27 #6 Fri Mar 8 00:31:26 MET 1996 i586
`Linux' is de naam van het besturingssysteem (dit zou bij iedereen hetzelfde moeten zijn), `rataplan' is de
naam van mijn computer, `2.0.27' is de versie van het kernel wat ik gebruik, `#6 Fri Mar 8 00:31:26 MET
1996' is het tijdstip waarop ik mijn kernel heb gemaakt, en `i586' is het type van de processor wat in mijn
computer zit.
Het eerste nummer (nummer `2') is het hoofdversie nummer. De eerste (test)kernels hadden nummer 0 (deze
kernels waren overigens vaak stabieler dan Windows 3.11), bij de vrijgave van de eerste `stabiele' versie in
Maart 1994 is versie 1 uitgekomen, en ondertussen zijn we overgegaan op versie 2 met de integratie van
modules in het kernel (modules worden verderop nog uitgelegd).
Het tweede nummer in het kernelnummer heeft een dubbele functie. Het fungeert als een subversie nummer
(dus kernels die beginnen met 1.2 zijn nieuwer dan kernels die beginnen met nummer 1.0), maar ook om
onderscheid te maken tussen stabiele en experimentele kernels. De regel is dat even nummers gebruikt
worden voor de stabiele kernels, en oneven nummers voor de experimentele. Op dit moment bestaan er dus
naast 2.0 kernels ook 2.1 kernels. Als de 2.1 versie uitontwikkeld is (wat in de toekomst wel eens zal
gebeuren), gaat die versie over naar 2.2 (of 3.0), en vanaf dat moment worden nieuwe ontwikkelingen gedaan
in kernel versies 2.3 (of 3.1).
Het laatste nummer is een volgnummer (nummer `27') binnen de serie 2.0 kernels. Deze nummers worden
gewoon steeds één opgehoogd met elke nieuwe release. Volgnummers in de ene serie hebben geen betekenis
in de andere serie (dus kernel 2.0.27 heeft geen speciale binding met kernel 2.1.27).
Welk kernel handig is om te gebruiken is moeilijk te beantwoorden in zijn algemeenheid. Het hangt af van
waar de computer gebruikt voor gebruikt wordt, en hoe heet-van-de-naald het kernel moet zijn. Het voordeel
van stabiele kernels is dat ze stabiel zijn, er zitten geen experimentele stukken code waar nog aan gesleuteld
wordt. Aan de andere kant, dat betekent wel vaak dat ze niet het nieuwste van het nieuwste bevatten.
Bij het maken van een kernel voor de eerste keer is het handig om een stabiel kernel te nemen. Als er dan
problemen optreden weet je in ieder geval zeker dat het niet aan de onstabiele code in het kernel ligt. Als dat
allemaal goed gaat, en je krijgt wat vertrouwen in het proces, dan kun je daarna altijd nog een experimentele
versie proberen (ontwikkeling van het Linux kernel zal waarschijnlijk wel door blijven gaan, zolang er
computers zijn).
Bij het schrijven van deze tekst is het laatste stabiele kernel nummer 2.0.29, maar alle kernels vanaf versie
2.0.0 zijn bruikbaar.
Plaats van de broncode van het kernel in het Linux systeem
De broncode van het huidige kernel staat altjd in /usr/src/linux. Het lijkt logisch om de oude versie van
weg te gooien, en dan de nieuwe versie er neer te zetten. Op zich mag dat (en kan dat ook), maar daarmee
maak je het wel onmogelijk om terug te gaan naar een oudere versie, in het geval dat er iets ernstig mis gaat.
Een veiligere oplossing is om de oude broncode te bewaren naast de nieuwe.
Verhaal over het maken van een softlink met de naam `linux' in /usr/src naar verschillende kernel versies.
Configureren van het kernel
make menuconfig, en uitleggen wat al die opties doen.

Maak een kernelimage
Dit klinkt erg ingewikkeld, maar is erg eenvoudig. Een kernelimage maak je met drie commando's:
1. make dep
Met dit commando berekent de computer in welke volgorde alle files gecompileerd moeten worden.
2. make clean
Dit commando zorgt ervoor dat alle oude files verdwijnen, waardoor echt alle files opnieuw
aangemaakt worden.
Bij het compileren voor de eerste keer is het niet echt nodig, maar uitvoeren van het commando duurt
niet lang, en het commando doen terwijl het niet nodig is kan geen kwaad.
3. make zImage
Dit commando zorgt ervoor dat alle files één voor één gecompileerd worden, en dat ze allemaal aan
elkaar gekoppeld worden. Afhankelijk van de hoeveel geheugen, kan dit kort of lang duren (op een
oude machine met 4MB heeft het bij mij wel eens ruim 2 uur geduurd, en op een Pentium met 32MB
duurt het ongeveer 10 minuten).
Na de laatste stap moet er een kernelimage gemaakt zijn. Deze staat in de directory
/usr/src/linux/arch/i386/boot, en heet zImage.
Installeer het nieuwe kernelimage
Installeren van het nieuwe kernel komt ruwweg neer op het overschrijven het oude kernel (waarmee de
machine op dit moment draait). Dat is echter een niet zo slimme oplossing, omdat er dan geen weg terug is als
het nieuwe kernel niet blijkt te werken (het oude kernel is weg, en je kunt niet bij de broncode om een nieuw
(beter) kernel te maken, omdat de machine niet opstart met het nieuwe kernel).
Een veiligere oplossing is om het nieuwe kernel naast het oude te zetten, en dan bij het opstarten van de
machine expliciet te kiezen voor het nieuwe kernel. Als het niet werkt, dan kun je door een reset weer booten
met het oude (werkende) kernel (en een nieuwe poging wagen met een andere configuratie van het kernel).
Werkt het wel, dan kun je dan het oude kernel weggooien, of het nieuwe als standaard kernel om mee op te
starten aanwijzen (waarbij het oude kernel als terugval mogelijkheid aanwezig blijft).
Start de computer opnieuw