Op een UNIX systeem, zoals onze Ubuntu Linux, zijn er twee grote entiteiten. Enerzijds heb je bestanden. Alle soorten objecten op het systeem, zoals gewone bestanden, mappen, links, speciale bestanden om met randapparatuur te communiceren enzovoorts, worden zoveel mogelijk behandeld onder de algemene noemer “bestand”. Bestanden op zichzelf doen niets, ze staan gewoon op de harde schijf of op een ander opslagmedium. We hebben processen nodig om de bestanden te manipuleren, zodat we een werkbare omgeving krijgen.

Processen zijn altijd uitvoerbare bestanden, die in het geheugen geladen worden en daar instructies doorgeven naar de processor. Neem er nog even hoofdstuk drie uit lespakket 1 bij: uitvoerbare bestanden hebben een “x” in minstens één van de groepen “user”, “group” of “other”. Nemen we als voorbeeld het commando ls:

willy@ubuntu:~$ which ls
/bin/ls
willy@ubuntu:~$ ls -l /bin/ls
-rwxr-xr-x 1 root root	71912 2005-09-05 11:14 /bin/ls

Zolang niemand het ls commando gebruikt om een lijst van bestanden op te vragen, is ls gewoon een bestand. Maar omdat het uitvoerbaar is, kan het instructies beginnen geven aan de processor, wanneer het door de shell opgeroepen wordt. Zolang ls in het geheugen zit en instructies uitdeelt, is het een process.

Sommige commando's starten een enkel proces, zoals ls. Andere commando's starten een hele serie processen. Een voorbeeld van zo'n proces is je web browser. Bovendien kan je meerdere processen tegelijk opstarten: een terminal venster, een browser, een E-mail programma, een tekenprogramma, enzovoort. Dit fenomeen heet multi-tasking, letterlijk: veel taken uitvoeren.

Naast deze eigenschap beschikt Linux, net zoals UNIX, waarvan het afgeleid is, over de mogelijkheid om verschillende gebruikers tegelijk te bedienen. Die gebruikers kunnen lokaal werken via het scherm, het toetsenbord en de muis, of ze kunnen vanop het netwerk verbinden met de computer, of ze kunnen afzonderlijke schermen en toetsenborden hebben, terminals genaamd. Dat is de multi-user funktie van het systeem, letterlijk: veel gebruikers.

	Terminals, is dat niet ouderwets?
	Bijvoorbeeld in de Colruyt, waar elke kassier via een terminal op de hoofdcomputer werkt, worden terminals veel gebruikt.

Het is duidelijk dat er een methode moet zijn om alle processen van alle gebruikers in toom te houden: we willen niet dat één gebruiker alle geheugen van de computer gebruikt, of alle ruimte op de harde schijf, of alle kracht van de processor, want dan kunnen de andere gebruikers niet meer werken. Er moet ook funktionaliteit voorzien worden zodat gebruikers nu eens het ene programma, dan weer het andere kunnen gebruiken, zonder de programma's telkens te moeten afsluiten. Soms moet er ook voor gezorgd worden dat programma's blijven doordraaien, zelfs als de gebruiker zich afmeldt.

In de volgende paragrafen geven we een overzicht van deze funktionaliteit.

Naast interactieve processen, opgestart door de gebruikers van een systeem, zijn er ook automatische of batch processen. Die worden niet opgestart vanuit een terminal venster. Ze wachten eerst op uitvoering in een daartoe bestemde map. Vandaaruit worden ze opgeroepen door een programma dat de wachtrij analyzeert en de programma's systematisch uitvoert. Het programma dat het eerste in de wachtrij terecht kwam, wordt ook eerst uitgevoerd. De naam van dit systeem is “FIFO”, wat staat voor “first in, first out”.

Er zijn twee manieren om automatische processen uit te voeren:

De eerste methode is ook voor gewone gebruikers nuttig en wordt later in dit hoofdstuk besproken. De tweede methode wordt meestal in grotere omgevingen toegepast en is veeleer een werk voor systeembeheerders en zware gebruikers; vandaar valt die methode buiten de scoop van deze cursus.

Daemons, Engels voor “demonen”, zijn serverprocessen die continu draaien. Meestal worden ze opgestart wanneer het systeem opstart, waarna ze in de achtergrond wachten tot hun diensten vereist zijn.

Zelfs als je zelf geen servers draait op je thuis-PC, zijn er daemons aktief. Een voorbeeld is de daemon die nagaat of je wilt inloggen: zelfs als je nog niet aangemeld bent, draait dit proces. Zo is er ook een netwerkdaemon die constant “luistert” of er geen netwerkverbindingen moeten gemaakt worden.

Elk proces heeft een aantal vaste eigenschappen:

Noteer dat de gebruikersnaam bestaat uit een echte gebruikersnaam (real username of RUID) en een effectieve gebruikersnaam (effective username of EUID). De echte gebruiker is diegene die het commando opstartte, de effectieve gebruikersnaam bepaalt de toegangsrechten. Gewoonlijk zijn RUID en EUID hetzelfde, en het proces heeft dezelfde toegangsrechten als de gebruiker. Een voorbeeld om duidelijk te maken wat hiermee bedoeld wordt: de browser firefox:

willy@ubunty:~$ which firefox
/usr/bin/firefox
willy@ubunty:~$ ls -l /usr/bin/firefox
lrwxrwxrwx 1 root root 30 2006-06-06 14:17 /usr/bin/firefox -> ../lib/mozilla-firefox/firefox
willy@ubunty:~$ ls -l /usr/libmozilla-firefox/firefox
-rwxr-xr-x 1 root root 11170 2005-10-10 17:31 /usr/lib/mozilla-firefox/firefox

Wat zien we hier?

	Wie ben ik?
	Gebruik het id commando om na te gaan als welke gebruiker je aan het werken bent.

De systeembeheerder, root, is de baas van het systeem en heeft alle rechten op alle bestanden. Men zou dus op het eerste zicht kunnen denken dat je met firefox meer zou kunnen dan met bijvoorbeeld het cat commando.

Probeer maar eens cat /etc/shadow, dus het bekijken van het bestand waarin de versleutelde wachtwoorden van alle gebruikers van het systeem zitten. Je zal zien dat dit niet lukt. Ook als je in firefox de URL file:///etc/shadow ingeeft, gebeurt er niet veel. Dit komt omdat je de browser opstart met je eigen toegangsrechten, en niet met die van de eigenaar van het commando (kan je nagaan m.b.v. ps -ef). Gelukkig maar, of het hele systeem van toegangsrechten zou op losse schroeven komen te staan.

Hetzelfde geldt voor de toegangsrechten van de groep die eigenaar is van het commando en jouw eigen groepsnaam, waarmee je het commando opstart.

Een van de meest gebruikte commando's voor het opvragen van procesinformatie is ps (afkorting van het Engelse “process”). Zonder opties krijg je enkel de processen te zien die verbonden zijn met de terminal sessie vanwaaruit je ps oproept:

willy@ubunty:~$ ps
  PID TTY		TIME CMD
 7268 pts/0	    00:00:00 bash
 8240 pts/0	    00:00:00 xterm
 8266 pts/0	    00:00:00 xcalc
 9855 pts/0	    00:00:00 ps

Noteer: de commando's die in de vorige oefening werden opgestart, zijn hier nog aktief.

We zien 4 kolommen met informatie:

Normaalgezien draaien er tientallen, honderden of duizenden processen op een systeem. We hebben dus manieren nodig om die processen uit te filteren die voor ons van belang zijn, tesamen met de bijhorende procesinformatie. Dit doen we door opties bij ps te gebruiken en dan de shell te gebruiken om de resultaten te filteren.

Het meest gebruikt is wellicht de constructie

	Voer uit
	Geef dit commando in in een terminal venster. Rol de schuifbalk aan de rechterzijkant van het venster naar boven toe, totdat je ziet waar de output van dit commando begint.

Op een systeem zoals hetgeen waarmee je nu werkt, valt de lijst van processen nog mee. Je krijgt een lijst met 8 kolommen te zien, waarvan deze het meest relevant zijn:

De man pagina van ps bevat veel voorbeelden van het gebruik van de andere opties. Je vindt er ook meer uitleg over de informatie in de andere kolommen. In het volgende hoofdstuk gaan we verder in op het filteren van de output, zodat er meer relevante informatie getoond wordt. We willen namelijk niet elke keer gaan zoeken in deze lijst naar het specifieke proces dat we onder de loupe willen nemen.

Het top commando geeft min of meer dezelfde informatie als ps -ef, maar hier wordt de informatie om de vijf seconden opgefrist. Bovendien hebben we hier al automatisch een zeker vorm van sorteren: de zwaarste processen, dat wil zeggen de processen die het meeste processortijd verbruiken, worden bovenaan in de lijst getoond. We krijgen ook niet alle processen te zien. Al naargelang de grootte van je terminal venster wordt de lijst ingekort. We krijgen dus een “top” van de processen te zien.

	Meedoen
	Geef het top commando in, zonder opties, gevolgd door Enter. We bespreken hieronder verder de output.

Naast de info over de processen, onder de zwarte balk, zien we bovenaan nog een aantal andere gegevens over het systeem:

	Documentatie
	Lees man top en man ps voor meer informatie. Blijf niet te lang hangen als je iets niet verstaat, en ook niet als het te moeilijk wordt. Lees gewoon verder in de cursus, en neem er later, telkens je het commando gebruikt, de man pagina weer bij. We kunnen niet alles tegelijk vertellen, de gaten zullen later langzamerhand opgevuld worden.

We hebben het al enkele keren over parent processes gehad. Waar komen onze processen vandaan? Gebruik het pstree commando om de processtructuur te tonen.

De meeste processen stammen af van init, het initiële proces waarmee het systeem gestart wordt. Meer hierover in de paragraaf “Hoe je computer opstart en afsluit”.

	Waar is pstree?
	Voer het pstree commando in in een terminal venster, gevolgd door Enter. Waar zit het pstree commando zelf in deze boomstructuur? Welk proces is de ouder (het parent process) van pstree?

Een nieuw proces wordt aangemaakt doordat een bestaand proces een exacte kopie van zichzelf maakt. Dit child process (letterlijk: het kind van het ouderproces) is eigenlijk net hetzelfde als het ouderproces, enkel het procesidentificatienummer verschilt. Deze procedure heet men een fork (letterlijk: een vork of splitsing).

Na de fork wordt de geheugenruimte van het kindproces overschreven met de nieuwe procesdata: het commando dat gevraagd werd, wordt in het geheugen geladen. Dit noemt men een exec.

Het geheel van kopiëren en overschrijven heet dan fork-and-exec. Alle processen worden op deze manier gemaakt. Zelfs init, het eerste proces met PID 1, werd zo gecreëerd door de kernel.

Onderstaand schema geeft weer hoe bijvoorbeeld een ls proces afstamt van je shell, bash:

Figuur 5.1. Het fork-and-exec mechanisme

De fork wordt hier met een horizontale pijl voorgesteld. Bemerk dat enkel het procesidentificatienummer verandert.

De vertikale pijlen stellen de exec voor. Hier blijft het procesidentificatienummer gelijk, maar de geheugeninhoud wordt verwisseld.

Zoals we reeds konden zien aan de output van het pstree commando, hebben veel processen init als ouderproces, terwijl dat helemaal niet mogelijk is. Nemen we bijvoorbeeld ons systeem dat in grafische mode draait: er moeten allerlei programma's opgestart worden om het grafische loginscherm te tonen, daarna moet de desktop gestart worden door middel van een desktopmanager, dan volgt de venstermanager (windowmanager), dan start je een terminal venster en daarin draait een shell waarmee je commando's kan ingeven. Wat gebeurt hier dan?

De verklaring is tamelijk eenvoudig: veel programma's “demoniseren” hun kindprocessen, zodanig dat die kunnen blijven draaien als de ouder stopt (zie de paragraaf “Daemons”). Het init proces neemt de rol van peetvader van zulke processen: als de ouder sterft, vallen ze onder de verantwoordelijkheid van init.

	Voorbeeld van demoniseren
	Start de web browser firefox vanuit een terminal venster. Indien je dat nog niet gedaan had, bevries het proces en laat het verderdraaien in de achtergrond. Gebruik pstree om na te gaan welk proces het ouderproces van firefox is. Sluit het terminal venster. firefox blijft draaien. Neem een nieuw terminal venster. Gebruik het pstree commando om na te gaan wat er met firefox gebeurd is.

Heel af en toe wil het nog wel eens mislopen met de “adoptie” van processen. Een proces dat geen ouderproces heeft, noemt men een zombie. Je kon deze term ook zien in de output van het top commando. Het systeem heeft geen vat meer op zo'n zombieproces, het blijft in het geheugen hangen tot je de computer herstart. Meestal duidt het voorkomen van zombieprocessen op slecht geprogrammeerde applicaties.

Wanneer een proces normaal eindigt, geeft het een code, de exit status, door aan de ouder. Als alles goed verlopen is, is de exit status nul. Men mag ervan uitgaan dat er iets foutliep als de exit status niet nul is. De mogelijke waarden van de exit status worden gedocumenteerd in de man pages en de systeembibliotheken. Ze zijn voor elk commando verschillend en worden bijvoorbeeld in scripts gebruikt om na te gaan of een opdracht al dan niet gelukt is. Ook programmeurs maken veelvuldig gebruik van de exit status van commando's.

De waarde van de exit status van shell commando's wordt opgeslagen in een speciale variabele, aangeduid met $?. Met het echo commando kan je de inhoud van deze variabele bekijken.

Hieronder een voorbeeld met grep. Een exit status van 0 betekent dat de zoekstring gevonden werd in het opgegeven bestand:

willy@ubuntu:~$ grep willy /etc/passwd
willy:x:1000:1000:Willy,,,:/home/willy:/bin/bash
willy@ubuntu:~$ echo $?
0

/etc/passwd?

Het /etc/passwd bestand bevat een lijst van alle gebruikersnamen die op je systeem gekend zijn. De informatie is gerangschikt in kolommen die gescheiden worden door dubbele punten. We zien hier over gebruiker willy het volgende: gebruikersnaam; een “x” die het wachtwoord verbergt - de wachtwoorden zitten in /etc/shadow; het identificatienummer van de gebruiker; het identificatienummer van de groep waarvan de gebruiker deel uitmaakt; omschrijving of naam van de gebruiker; het pad naar de home map van de gebruiker; de shell voor deze gebruiker;

Een exit status van 1 betekent dat de zoekstring niet gevonden werd, maar niet noodzakelijk dat de shell een foutmelding geeft:

willy@ubuntu:~$ grep blah /etc/passwd
willy@ubuntu:~$ echo $?
1

Een exit status van 2 lokt wel een foutmelding uit, bijvoorbeeld wanneer de optie niet herkend wordt of het opgegeven bestand niet gevonden wordt:

willy@ubuntu:~$ grep blah /etc/blabla
grep: /etc/blabla: Onbekend bestand of map
willy@ubuntu:~$ echo $?
2
willy@ubuntu:~$ grep --blah bleble /etc/passwd
grep: optie niet herkend `--blah'
Gebruik: grep [OPTIE]... PATROON [BESTAND]...
Probeer `grep --help' voor meer informatie.
willy@ubuntu:~$ echo $?
2

Deze methode om een gecodeerd resultaat terug te geven stamt van de C programmeertaal. Vandaar dat de code ook wel eens return code genoemd wordt.