|
|
|
|
|
|
|
|
|
|
|
De Linux kernel is het eigenlijke besturingssysteem. De kernel regelt de interactie tussen de soft- en hardware. De kernel verdeelt het geheugen en processortijd tussen de programma's. Stuurbestanden (device drivers) in de kernel regelen de toegang tot hardware componenten. Zonder kernel kunt u uw computer hardware niet met uw software besturen.
U kunt onder Linux stuurbestanden in de vorm van kernelmodulen on the fly laden en verwijderen. Via de instelling CONFIG_KMOD regelt de kernel dit zelf: dus als een als module gecompileerd stuurbestand aangeroepen wordt, laadt de kernel het stuurbestand in het geheugen. Als het stuurbestand niet meer gebruikt wordt verdwijnt het uit het geheugen. Oudere kernels maakten gebruik van de kernel daemon (kerneld).
De Linux kernel (kernel.org) wordt via het internet ontwikkeld. Het werk wordt in taakgroepen verricht. Linux is in C geschreven. C is een minder gecompliceerde taal dan C++, wat het compileren versnelt en het debuggen vergemakkelijkt. Verbeteringen van de officiele kernel worden aan Linus Torvalds doorgeven. Als ze goed genoeg zijn komen ze in de volgende stabiele kernel. Geheel nieuwe onderdelen worden aan een development kernel toegevoegd.
Linus Torvalds heeft een soort vetorecht over de officiële kernel. Hij verricht vooral coördinerend werk en wordt hierbij ondersteund door niet minder geniale beroepshackers als de multimedia specialist Alan Cox. Een nieuwe kernel wordt door Linus aangekondigd op www.kernelnotes.org. Linus Torvalds situatie is een beetje te vergelijken met de kernpositie die Bill Gates heeft binnen de firma Microsoft. Het verschil is dat Bill Gates met een leger van advocaten en marketingmensen achter gesloten deuren aan Microsofts marktpositie werkt, terwijl Linus Torvalds met duizenden pro deo programmeurs open en bloot aan een voor iedereen vrij besturingssysteem werkt!
Kernel versies worden aangegeven door een major, minor en patchlevel nummer. Ik gebruik nu kernel versie 2.2.10. Major numbers (de eerste 2) veranderen zelden. Minor versions (2.2, 2.3) veranderen een paar maal per jaar, patchlevels van in ontwikkeling zijnde kernels (development releases) soms dagelijks. Het laatste nummer (de 10 in 2.2.10) is het patchlevel.
sjoerd@visser:~ > uname -a
Linux visser 2.2.10 #2 Sun Nov 28 16:53:55 CET 1999 i686 unknown
Ontwikkelingsversies van de kernel hebben een oneven minor nummer (bijv. 2.3). Stabiele versies hebben een even minor nummer (bijv. 2.2). Beide kerneltypen worden gelijktijdig ontwikkeld. De ontwikkeling van de development kernel (die met de nieuwe features) gaat natuurlijk het rapst: hiervan treft u frequent nieuwe patchlevels aan. Als versie 2.3.nn stabiel genoeg is wordt hij versie 2.4 (een kopie ervan wordt het uitgangspunt van nieuwe ontwikkelingskernel 2.5).
Het voordeel van deze methode is dat degenen die nieuwe kernel eigenschappen ontwikkelen, geen rekening hoeven te houden met degenen die gewoon een stabiel Linux systeem willen hebben.
Wat flitste er over het scherm direct na de Linux boot?
Het zijn de berichten van de kernel. Ze worden onderschept en opgeslagen door klogd, de kernel log daemon. Direct na het booten (en voor de login) zijn ze zichtbaar te maken met Shift-PageUp. Behalve de kernel berichten laat Shift-PageUp u ook de resultaten van de deamonen uit de init scripten zien.
Na de login zijn ze zichtbaar te maken met het commando dmesg:
dmesg > dmesg.txt (naar bestand dmesg.txt in de huidige dir)
Het is zeker de moeite waard om deze teksten eens te bestuderen. Het geeft veel informatie over het besturingssysteem en de hardware die u draait.
Een andere bron van (dynamische) systeeminformatie is te vinden in de (pseudo) directory /proc:
cat /proc/version geeft de Linux kernel versie en de hiervoor gebruikte c compiler weer.
Onder Linux is het vrij gebruikelijk om een zelf kernel aan te maken. Het programmeerwerk is al voor u gedaan. Wat u in feite doet is de samenstelling van de kernel bepalen: de ondersteuning voor hardware, netwerk en bestandssystemen. U stelt dus het menu samen, daarna geeft u de kok (de GNU c compiler) de opdracht het eten te klaar te maken. Of het ook opgediend wordt, of dat alles bij het oude blijft, bepaalt u wederom zelf.
Dat is natuurlijk alleen mogelijk als u precies weet wat u wilt en u uw hardware kent.
Goede redenen om voor uzelf een nieuwe kernel te compileren zijn:
U wilt een hogere kernelversie i.v.m. nieuwe of verbeterde eigenschappen
U wilt een kernel op maat i.p.v. de door uw distributie geleverde standaard kernel.
U wilt eens wat met uw hardware experimenteren.
Een kernel op maat is een aan uw behoeften aangepaste kernel: Onnodige stuurbestanden laat u weg, zelden gebruikte stuurbestanden kunt u als laadbare modulen compileren. Door onnodige stuurbestanden weg te laten bespaart u geheugen en laat u bronnen van potentieel negatieve interacties weg.
Uw hardware en de door u benodigde stuurbestanden bepalen welke opties u in het kernel configuratie menu plaatst: bestandssystemen, netwerkopties, geluidskaart. Alles wat maar door Linux ondersteund wordt kunt u zo instellen.
Met een kernel optimalisatie voor de processor kan bijv. al een behoorlijke snelheidswinst te behalen zijn. Een Pentium II is geen snelle i386. Dit levert altijd voordeel op. Anderzijds zijn er ook experimentele kernelopties. De ondersteuning voor USB bijvoorbeeld (hierboven in kernel 2.2.13) is nog verre van betrouwbaar.
Wat ik moest doen is de belangrijkste opties opties instellen (wat ik niet begreep liet ik op de aanbevolen waarden staan):
Bijv.
dat ik een Pentium i.p.v. een 386 processor gebruik. De
standaard linux kernels zijn voor de 386 gemaakt, maar omdat een
Celeron veel efficiënter met het geheugen om kan gaan dan
een 386, scheelt een voor de Celeron geoptimaliseerde kernel Linux
veel werk. Hierin is al een mathematische co-processor
aanwezig: De voor de zekerheid in de standaard 386 kernel ingebakken
emulatie daarvan is niet nodig. Een Celeron of Pentium II/III is als
Pentium Pro te compileren.
Ook zijn er veel bugfixes voor defecte hardware in de standaardkernel ingebakken. Als u zeker weet dat de bugfix niet nodig heeft, laat u ze er gewoon uit.
Als u geen netwerk gebruikt, kunt de netwerk ondersteuning uit de kernel laten. Als u de computer later op een netwerk aansluit, kunt u alsnog een aan uw netwerk aangepaste kernel compileren, maar nu is het balast.
Vergeet echter nimmer de TCP/IP netwerkondersteuning in te bakken, want die hebt u bijv. nodig om te printen (loopback), voor de X server en voor het internet (en om contact te houden met de andere gebruikers van uw systeem).
De linux kernel is meestal een gezipte kernel (zImage of bzImage). Lilo, de Linux Loader, zorgt ervoor dat hij wordt geladen. U mag er zoveel versies van aanmaken als u wilt. Zo is het gebruikelijk om bij aanmaak van een nieuwe kernel de oude achter de hand te houden, zodat als de nieuwe kernel tegenvalt u met lilo de oude kernel weer kunt laden. Dat laatste kan ook met loadlin vanuit DOS of met een Linux bootdiskette.
De broncode van de Linux kernel is vrij. Hij hoort bij iedere Linux distributie te zitten. De normale plaats ervoor is in /usr/src/linux . In de praktijk is /usr/src/linux een symbolische verwijzing naar de actuele broncode (source, src): /usr/src/linux-2.2.13.SuSE bij mij. Dit is ook de plaats waar u de kernel moet compileren (dit kan bijv. vanuit de Midnight Commander, mc).
U hebt een GNU c compiler nodig (gcc), het make utility en een geschikte c bibliotheek (libc). In principe zullen ze onderdeel uitmaken van uw distributie.
De /usr/src/linux/README en de /usr/src/linux/Documentation/ map geven belangrijke achtergrondinformatie.
Er zijn drie programma's om een nieuwe kernel te configureren. Ze worden door root in /usr/src/linux opgestart:
make config
make menuconfig
make xconfig
Hiervoor start u een terminalvenster op. U logt in als root (su) en gaat naar /usr/src/linux. Dit is een symlink naar de te compileren kernelversie (hier kernelversie 2.2.13). Het kan geen kwaad dit met ls -l nog eens te controleren in /usr/src:
root@visser:/usr/src > ls -l
total 4
lrwxrwxrwx 1 root root 17 Dec 30 22:38 linux -> linux-2.2.13.SuSE
drwxr-xr-x 14 root root 1024 Dec 30 22:27 linux-2.2.10.SuSE
drwxr-xr-x 15 root root 1024 Dec 30 22:27 linux-2.2.13.SuSE
drwxr-xr-x 14 root root 1024 Nov 28 10:03 linux-2.2.5.SuSE
drwxr-xr-x 7 root root 1024 May 12 1999 packages
root@visser:/usr/src > cd linux
In /usr/src/linux typt u make xconfig als u in X zit of make menuconfig zonder X server.
Hieronder ziet u het (tekstmodus) grafische terminalbeeld van make menuconfig:
root@visser:/usr/src/linux >make menuconfig
make xconfig produceert onder het X Window systeem een soortgelijk scherm met instellingen van alle kernelopties. Wat u invoert wordt na "Save and Exit" in het verborgen bestand file:/usr/src/linux/.config opgeslagen.
Met
de optie "Store configuration to File" kunt u een
kernelconfiguratie bibliotheek aanmaken (aanrader, net zo goed als
het verstandig is een backup van oude "config.sys"
bestanden te bewaren). Als u na een minder geslaagde configuratie van
de regen in de drup komt kunt u met "Load configuration from
File" een beproefde kernelconfiguratie als uitgangspunt
nemen.
Op de opties wordt in xmenuconfig verder ingegaan. De kernel source bevat file:/usr/src/linux/Documentation/Configure.help van Axel Boldt, waarin op de opties verder wordt ingegaan.
Ga als root naar /usr/src/linux. Deze directory is een symlink naar de door u te gebruiken broncode van de kernel.
Een opdracht om de kernel en de kernelmodules in een klap te maken en te installeren is:
make dep clean bzImage modules modules_install
Ik ga er echter in stappen op in.
Met het commando make dep clean zImage wordt de gezipte kernel gecompileerd. Het bestaat uit drie afzonderlijke commando's:
make dep
make clean
make zImage
Dit commando maakt een kernel image. De z geeft aan dat het om een gezipte versie gaat.
Krijgt u daarna foutmeldingen, dan kunt u niet verder gaan. De foutmelding "the kernel is too big" betekent dat uw kernel te groot is. U hebt drie opties om de kernel te verkleinen:
Minder features in de kernel inbouwen (met N in plaats van Y).
Minder vaak gebruikte delen als modulen inbouwen (met M in plaats van Y).
Een sterk gecomprimeerde bzImage aanmaken (make bzImage i.p.v. make zImage).
Ik maak van alle drie methoden gebruik.
Maakt dus een sterk gecomprimeerde kernel aan in /usr/src/linux/arch/i386/boot.
Een goede uitslag eindigt als volgt:
Daarna moet u de kernelmodulen maken en installeren.
Als u de kernel modulair (aanbevolen) opbouwt moet u vervolgens de volgende twee opdrachten ook uitvoeren in /usr/src/linux:
make modules
Maakt de kernelmodulen aan.
make modules_install
Dit commando installeert specifieke modules uit /usr/src/drivers/.. in de map /lib/modules/kernel-versie .
U kunt het ook in een regel doen:
make modules modules_install
Deze opdracht eindigt met iets als:
De modulen zijn hier in bovengenoemde subdirectory van /lib/modules geinstalleerd.
Modulen worden via het configuratiebestand voor laadbare kernelmodulen /etc/conf.modules door insmod, modprob en een kernel daemon (kerneld) teruggevonden. Met /etc/conf.modules hebt u overigens alleen maar te maken als u een losse module (object file) handmatig installeert, die geen deel uitmaakt van de officiele kernel. Zie hiervoor de README van het te installeren stuurbestand. Het commando depmod gaat dit bestand voor u na.
Gaat alles goed, dan moet u de locatie van nieuwe kernel in /etc/lilo.conf opgeven en het installatie-programma lilo draaien. Lilo kan alleen de kernel laden als het de fysieke locatie van de kernel op de harde schijf weet (CHS adressering: cylinder, header, sector). Want pas na het laden van de kernel worden de stuurbestanden van het EXT2 bestandssysteem actief! Het vervangen van de een bzImage (en System.map) door de andere (met altijd een andere fysieke locatie op de harde schijf) zal ertoe leiden dat het systeem niet meer boot (te corrigeren door na een boot met loadlin of bootdiskettes alsnog lilo te draaien).
Maar maak eerst een backup van de oude kernel en bijbehorende System.map ! Deze bevinden zich in /boot of in een ander door /etc/lilo.conf in image = aangeven lokatie.
Beter is het nog een backup te maken van de oude kernel en alle (boot)bestanden van /boot in een nieuw aan te maken directory /boot/bootbackup voor het geval u per abuis een bootbestand wist. Dit kan goed met de GNU Midnight Commander (mc).
Kopieer /usr/src/linux/arch/i386/boot/zImage (zImage) of /usr/src/linux/arch/i386/boot/bzImage (bzImage) naar uw /boot/ directory.
Dit is de gecomprimeerde kernel.
Kopieer /usr/src/linux/System.map naar uw /boot/ directory.
Dit bestand bevat informatie over de door de kernel benodigde modulen.
Stel /etc/lilo.conf voor de nieuwe kernel in.
Zie de instructies in Lilo: Bootmanager en Linux loader.
Belangrijk
is altijd een oude kernel (hier vmlinuz) aan te houden, naast de
experimentele kernel (bzImage). Dan kunt u als het misgaat met de
nieuwe kernel, weer naar de oude kernel terug.
Draai daarna het lilo installatie programma lilo:
lilo
Na een reboot zou de een bootmenu met daarin de optie om de nieuwe kernel te laden moeten verschijnen.
Er kan echter veel misgaan: zie Lilo: Bootmanager en Linux loader.