Nieuws
Nieuwe distributie
Onlangs zijn we overgestapt op een nieuwe Linux-distributie, nl. Pardus Linux
Dit lijkt ons een prima distributie, zowel voor beginners als experts.
|
|
20. De Linux kernel
De kernel is het hart van een Linux systeem. Het is het deel van Linux, dat bij het opstarten van de computer als
eerste geladen wordt en als een spin in een web de touwtjes in handen heeft. Maar wat doet die kernel en hoe werkt
het? Daar probeert dit artikel wat duidelijkheid over te geven.
De Linux kernel heeft heel wat taken. Deze taken zijn samen te vatten met de algemene omschrijving, dat de kernel
ervoor zorgt, dat de hardware doet, wat door de software gevraagd wordt.
Of, iets uitgebreider: de kernel verzorgt de toegang tot de computerbronnen: processor, geheugen, schijven,
netwerkkaart, grafische kaart, toetsenbord, muis, enz. De kernel stelt die bronnen beschikbaar aan
gebruikersprogramma's (bv. VI of de Gimp) en zorgt ervoor, dat die programma's elkaar niet in de weg zitten (bv.
niet tegelijk naar de harde schijf schrijven of in hetzelfde deel van het geheugen). Gebruikersprogramma's hebben
dus geen rechtstreekse toegang tot die bronnen: alles loopt via de kernel.
De belangrijkste deeltaken zijn (onder meer) procesbeheer, geheugenbeheer, hardware-aansturing, beheer van
bestandssystemen en netwerkbeheer. Deze deeltaken zullen we hieronder stuk voor stuk summier doornemen.
Procesbeheer
Een proces kun je zien als een draaiend programma. Als je in een (X-) console de opdracht
ps aux
geeft, krijg je een opsomming te zien, van alle processen, die op dat moment op je computer draaien; en dat kunnen
er flink wat zijn.
Het zou, in theorie, makkelijk zijn, als je computer over vele processors beschikte: dan kon iedere processor
één proces afhandelen. De meeste computers hebben echter maar één processor, en die
kan steeds maar één instructie tegelijk uitvoeren. Dat het toch lijkt of er meerdere processen
tegelijkertijd lopen, komt doordat de kernel snel van taak tot taak (van proces tot proces) doorschakelt. Ieder
actief proces krijgt gemiddeld zo'n 10msec (om maar even een orde van grootte aan te geven) processortijd voordat
het volgende proces aan de beurt is.
Dat omschakelen van proces naar proces lijkt op het eerste gezicht eenvoudig, maar er komt veel bij kijken: voordat
de uitvoering een proces gestopt kan worden, om processortijd aan een volgend proces te gunnen, moet de huidige stand
van dat eerste proces wel eerst opgeslagen worden; anders weet de kernel, als hij de volgende keer weer wat
processortijd aan dat proces wil geven, niet waar hij was gebleven. En met "huidige stand" wordt niet alleen bedoeld
met welke instructie dat proces bezig was, maar ook de inhoud van allerlei (tijdelijke) registers en stacks,
geheugenadressen, variabelen, enz. Al die gegevens worden opgeslagen, en daarna wordt de "stand" van het volgende
proces opgehaald, zodat aan dàt proces verder gewerkt kan worden. Daarmee wordt ook duidelijk, dat het
schakelen tussen processen ook processortijd kost, die ten koste gaat van de tijd, die daadwerkelijk voor de "echte"
processen beschikbaar is.
En dit is nog maar een erg simpele voorstelling van zaken; in werkelijkheid komt er nog veel meer kijken bij het
proces-beheer. Zo houdt de kernel bij welke processen actief zijn, en welke wel even kunnen wachten (omdat ze
bijvoorbeeld wachten op input van het toetsenbord) en zorgt hij ervoor, dat sommige processen voorrang krijgen boven
andere (bijvoorbeeld bij het binnenkomen van data via het netwerk of modem), enz.. Ook zorgt de kernel ervoor, dat
processen met elkaar kunnen communiceren.
Geheugenbeheer
De afdeling geheugenbeheer van de kernel zorgt er o.a. voor, dat ieder proces kan beschikken over een eigen
gedeelte van het geheugen. Het geheugen wordt daartoe (simpel gezegd) opgedeeld in "bladzijden" (pages), en ieder
proces kan, naar behoefte, beschikken over één of meer van die bladzijden. De kernel moet dus
bijhouden, welk geheugendeel hoort bij welk proces.
Als een programma even niets te doen heeft, is het zonde om dat programma zoveel kostbare en soms schaarse RAM te
laten gebruiken. En zelfs als dat programma wèl actief is, zijn er wellicht programma-delen, die niets te
doen hebben. De kernel kan de geheugen-pagina's van dat programma dan vrij maken uit het RAM en de informatie
verplaatsen naar het swap-geheugen op de harde schijf, zodat andere processen, die het RAM-geheugen wèl
hard nodig hebben, er gebruik van kunnen maken.
Dit illustreert al, dat het toewijzen van geheugen-pagina's aan processen een dynamisch geheel is, waarbij de kernel
voortdurend "een vinger aan de pols" houdt om het geheugen zo effectief mogelijk te gebruiken.
En dan hebben we het nog niet gehad over verschillende "soorten" geheugen: geheugen, waar het programma is
opgeslagen, geheugen voor de programma-gegevens (data), buffers, fifo's, enz.
Ook het geheugen-beheer is, al met al, veel complexer, dan in het kader van dit artikel omschreven kan worden.
Hardware-aansturing
Een belangrijke taak van de kernel is het beschikbaar stellen van hardware-bronnen aan programma's, die daar
om vragen. Veelal doet de kernel dit, door de hardware-bron aan het programma te presenteren als een zgn.
device-bestand. Deze device-bestanden vormen een zgn. virtueel bestandssysteem: het zijn geen echte bestanden (kijk
maar eens naar de grootte van deze bestanden in de direcory /dev...), maar een manier om programma's,
via de kernel, te laten communiceren met de hardware.
Er bestaat nòg een virtueel bestandssysteem, nl. het /proc bestandssysteem. In de directory-structuur van
Linux vind je in de /proc directory allerlei systeem-informatie terug, die daar "weggeschreven" wordt
door de kernel. Ook dit zijn dus geen echte bestanden.
Nu bestaat er voor de Intel-achtige pc's een zeer uitgebreide variatie aan hardware (denk alleen maar eens aan de
verschillende types netwerk- en geluidskaarten), en het zou niet handig zijn om de drivers voor al die zaken in de
kernel in te bouwen: de kernel zou er wel erg groot door worden, terwijl het merendeel van de drivers ongebruikt
zou blijven. Daarom bestaat de mogelijkheid om die drivers, als ze nodig zijn, apart te laden en zo aan de kernel
te koppelen. Die apart te laden kernel-delen worden bij Linux "modules" genoemd. Uniek is, dat het laden van die
drivers bij Linux (in tegenstelling tot bij Windows) kan zonder dat de computer opnieuw opgestart hoeft te worden.
De grote distributies leveren meestal een kernel, waar alleen het hoogst noodzakelijke is ingebouwd, met daarnaast een flink aantal modules, die, afhankelijk van de aanwezige hardware, zo nodig geladen kunnen worden. Als je zèlf
een kernel zou compileren, zou je er ook voor kunnen kiezen alle drivers voor jouw specifieke hardware direct in te
bouwen in die kernel. Maar goed: het zelf configureren en compileren van een kernel valt buiten het bestek van dit
artikel.
De kernel zorgt er voor, dat alle vragen om contact met de hardware netjes afgehandeld worden, zonder dat die contacten
met elkaar conflicteren.
Het kan echter ook gebeuren, dat de hardware vraagt om contact met een programma. Dat gebeurt bv. als er iets
ingetypt wordt op het toetsenbord. Er wordt dan een zgn. "Interrupt Request" (IRQ), vrij vertaald:
"onderbrekings-verzoek", verstuurd naar de processor. De kernel zorgt er dan voor, dat de afhandeling van dat
verzoek met voorrang behandeld wordt, door het bijbehorende proces aan te roepen.
Beheer van bestandssystemen
Linux (of eigenlijk: de kernel) kan omgaan met vele verschillende bestandssystemen. Om er een paar te noemen:
ext2, ext3, dos, vfat, Reiserfs, minix, xfs, iso9660, enz.. De verschillen tussen die bestandssystemen zit hem
hoofdzakelijk in de wijze, waarop bestanden worden weggeschreven op de drive of partitie en hoe dat geadministreerd
wordt. Dit staat dus los van de hardware (ide of scsi) driver.
Bijzonder in Linux is ook, dat verschillende drives, partities e.d. niet allemaal een eigen drive-letter of -naam
hebben (zoals bij Windows), maar altijd in de directory-structuur zijn of worden opgenomen.
Als data in een bestand op bv. de harde schijf moet worden opgeslagen, zal de kernel die data "vertalen" naar het
juiste bestandssysteem en de bijbehorende administratie bijwerken. Bovendien wordt die data niet direct naar de
hardware weggeschreven, maar eerst in een buffer geplaatst. Dit, omdat het daadwerkelijk wegschrijven nogal wat
tijd kost (harde schijven e.d. zijn erg traag in vergelijking met RAM). Binnen de kernel draait een progammaatje
(een daemon), dat die buffers in de gaten houdt en, als die buffers vol raken, of als er een bepaalde tijd verstreken
is sinds de laatste verandering in die buffers, het sein geeft die data daadwerkelijk weg te schrijven. Die daemon
heet bdflush, en is als proces terug te vinden met de opdracht
ps aux | grep flush.
Voor wie er meer over wil weten:
man bdflush
Trouwens even nog een wetenswaardigheidje: in het resultaat van de opdracht
ps aux
kun je een aantal processen zien, waarvan de naam tussen vierkante haken staat (bv: [bdflush]).
Dat zijn allemaal kernel-processen.
Netwerkbeheer
Linux is netwerk-georiënteerd. Netwerk-functionaliteit is dus erg belangrijk. Ook de kernel heeft hierin
de nodige taken. Het zou te ver voeren om hier diep in te gaan op deze taken, o.a. omdat enige kennis van
netwerk-theorie (o.a. Het ISO OSI model) hierbij onontbeerlijk zou zijn.
Wèl kunnen we enkele zaken noemen, waarin de kernel een belangrijk aandeel heeft:
Zo zijn daar natuurlijk de hardware-drivers, bij de moderne distributies meestal in de vorm van modules. Zonder
deze drivers zouden we niets kunnen met de netwerkkaart, modem, enz. in onze computer.
Verder heeft de kernel een aantal taken in het omgaan met de verschillende netwerk-protocollen. Zo verzorgt de
kernel een deel van bv. het TCP/IP-protocol. Een gebruikersprogramma, dat van dit protocol gebruik wil maken, zal
dus niet communiceren met de hardware-driver, maar met de kernel.
Ook belangrijk is, dat de kernel de mogelijkheid biedt om netwerk-pakketten te filteren (Netfilter). Van deze
mogelijkheid wordt dankbaar gebruik gemaakt bij het maken van firewalls: scripts die de kernel vertellen, wat er
met welke netwerk-pakketten moet gebeuren.
En dan is er nog het zgn. loopback-device, oftewel het dummy-netwerk; ook dit wordt verzorgd door de kernel.
En dan hebben we nòg niet alles benoemd m.b.t. het netwerkbeheer. Denk daarbij maar eens aan ondersteuning
voor NFS (Network File System), enz.
Stabiliteit
Iets waar we het nog niet over gehad hebben is de rol van de kernel bij de stabiliteit van het systeem. Het feit,
dat Linux zo stabiel is wordt onder meer veroorzaakt, doordat de kernel de verschillende lopende programma's
(processen) zo goed beheert. Want Linux mag dan wel stabiel zijn, niet alle software, die onder Linux draait, is
dat ook (zeker niet als je graag experimenteert met alpha en beta-releases....). Loopt er eens een programma vast,
dan zorgt de kernel ervoor, dat de andere processen daar geen last van hebben. De gebruikers-programma's draaien in
de zgn. user-mode. Ze kunnen alleen invloed op elkaar uitoefenen via de kernel. Ook de toegang tot de hardware-bronnen
wordt door de kernel netjes geregeld, zodat gebruikersprogramma's elkaar ook hierbij niet in de weg kunnen zitten.
We kunnen wel stellen, dat de stabiliteit van Linux voor het overgrote deel te danken is aan de kernel.
Tenslotte
De taken en werking van de Linux kernel zijn niet goed in een eenvoudig artikel te beschrijven. We hopen je er
echter een kleine indruk van te hebben gegeven. Voor diepgravender informatie kun je heel goed terecht op het
internet. Twee links (voor de echte die-hards) willen we daarbij speciaal aanbevelen:
Laatst herzien op 18-12-2006
|
Printbaar
