1 Parent en Child relaties

Het begint allemaal bij de kernel die het allereerste proces op de computer activeert. Dit proces heeft de naam 'init' en heeft altijd het proces ID (PID) 1. Init is ervoor verantwoordelijk dat de andere processen gestart worden. Het proces 'init' doet dat door een techniek die bekend staat als forking: eenvoudig gezegd komt het erop neer dat een proces zichzelf copieert en in de copy van zichzelf een nieuw proces start. Op deze wijze ontstaat een parent-child-relatie waarbij het child proces altijd afhankelijk is van het parent-proces en het de taak is van de parent om het child in de gaten te houden.

Het is mogelijk een ander proces te laten starten met PID 1, maar dat is alleen nuttig voor troubleshooting. In dat geval geeft men op de prompt van de bootloader bijvoorbeeld de optie init=/bin/bash mee; dit zorgt ervoor dat bash gestart wordt met PID 1.

Onder normale omstandigheden zal het child-proces wanneer het klaar is een signaal terugsturen naar het parent-proces. Hierin verteld het child proces op welke wijze het is afgesloten. Als het succesvol was, stuurt het child proces een exit-code 0 naar de parent, was het child proces niet succes vol dan wordt een andere exit-code naar het parent proces gestuurd. Dit kan exit-code 1 zijn, maar ook elke willekeurige andere exit-code. Welke code gebruikt wordt, wordt ingevuld door de programmeur van de betreffende opdracht en staat dus op voorhand niet vast. Als het parent proces de shell was en het child-proces een opdracht die vanuit de shell is uitgevoerd, kan de exit-status van het laatste child-proces worden opgevraagd met de opdracht echo $?

Als beheerder van een systeem is het belangrijk dat men kan achterhalen hoe de relatie tussen parent- en child- processen is opgebouwd. Hiervoor zijn er enkele opties beschikbaar. De meest directe manier is te kijken naar de proces status in het pseudo-filesystem /proc. In deze directory bestaat een subdirectory voor elk actief proces. De naam van deze subdirectory komt overeen met de PID van het process. In deze subdirectory bestaat er een bestand genaamd 'status'. Hierin wordt alle relevante informatie over het proces bijgehouden, zo ook de PPID, ofwel de PID van het parent-proces.

Naast de mogelijkheid om voor elk individueel proces de status uit te lezen, zijn er ook een 2-tal opdrachten waarmee men de hiërarchische relatie tussen parent en child proces kan tonen. Een van de mogelijkheden is gebruik maken van de opdracht pstree, als een alternatief met iets meer mogelijkheden om de uitvoer te filteren is er de opdracht ps met de f (forest), al dan niet in combinatie met andere opties. De opdracht ps afx geeft bijvoorbeeld een lijst van alle processen waarin uitstekend de relaties tussen parent en child processen duidelijk wordt. Met de opdracht ps kan men niet goed duidelijk maken dat alle processen voortkomen uit het init process, hiervoor kan men beter pstree gebruiken. De volgende screen-shot is een uitreksel van een ps afx scherm.

2 Zombie process

Als een child-proces klaar is, is het zijn taak om zich netjes af te melden bij de parent. Meestal gaat dit goed, soms kunnen hier echter problemen ontstaan doordat de parent niet langer beschikbaar is wanneer het child proces afsterft. Het kan bijvoorbeeld voorkomen dat de parent beëindigd is, of de status 'sleeping' heeft en daardoor geen communicatie meer van het child-process kan ontvangen. Op dat moment ontstaat een zombie proces. Als dit het geval is, is het niet langer mogelijk het child-process netjes af te melden. De hiervoor noodzakelijke communicatie tussen parent en child kan immers niet tot stand gebracht worden. Als het parent-proces ineens weer beschikbaar komt, zal het zombie proces vanzelf verdwijnen.

2.1 zelf een zombie process maken

Met een eenvoudig c-programma is het mogelijk zelf een zombie-proces te maken. De onderstaande c-code geeft weer hoe dit moet gebeuren.

Dit programma begint met het afdrukken van de tekst "hallo", vervolgens treedt een fork op. Als dit succesvol is wordt het proces inactief voor 60 seconden. Het child-proces kan dus niet langer communiceren met het parent proces. Weergave van de proces activiteit met de opdracht top laat vervolgens zien dat er een zombie is. Als na 60 seconden het parent-proces weer actief wordt (het hoeft immers maar 60 seconden te slapen), verdwijnt het zombie-proces ook weer automatisch. Om bovenstaande code uit te voeren, maakt men een tekstbestand met de naam zombie.c. Vervolgens wordt dit bestand met de opdracht gcc -o zombie zombie.c. Dit leverd een werkend programma met de naam zombie. Hiervoor moet wel de c-compiler gcc op de computer geinstalleerd zijn.

3 Signalen

Voor de communicatie tussen processen wordt gebruikt gemaakt van signalen. Signalen maken het mogelijk dat een parent-proces bijvoorbeeld een child-proces beëindigd als er iets mis gaat. Ook kan de beheerder van een systeem door middel van signalen ervoor zorgen dat een specifieke actie uitgevoerd wordt. De volgende tabel bevat een lijst van alle mogelijke signalen, de meeste daarvan worden gebruikt tussen processen onderling. Elk signaal heeft een naam en een nummer, daarnaast is er een standaard actie voor ieder signaal.
De volgende acties zijn beschikbaar:

• Term, het proces wordt afgesloten
• Ign, het signaal wordt genegeerd
• Core, het proces wordt afgesloten en er wordt een core-dump gemaakt
• Stop, het proces wordt gestopt. Een proces dat gestopt is kan ook weer gestart worden, zonder dat de status van het proces verloren gaat.

Signalen gebruikt op het INTEL platform.
Hou er rekening mee dat op andere platforms soms andere signaal nummers gebruikt worden.
zie ook man 7 signal

Signaal	Waarde	Actie	Commentaar
SIGHUP	1	Term	Het proces wordt geforceerd zijn configuratie opnieuw in te lezen. De eindgebruiker merkt niets van een tijdelijke onderbreking
SIGINT	2	Term	Het proces wordt vanaf het toetsenbord onderbroken
SIGQUIT	3	Core	Het proces wordt vanaf het toetsenbord onderbroken
SIGILL	4	Core	Er heeft een illegale instructie plaatsgevonden
SIGTRAP	5	Core	Een beheer signaal is naar het proces gestuurd
SIGABRT	6	Core	Een ander proces heeft door middel van Abort en abort-signaal verstuurd. Dit wordt toegepast om een programma abnormaal te laten be-eindigen
SIGBUS	7	Core	Treedt op wanneer geheugen over de bus op verkeerde wijze wordt benaderd
SIGFPE	8	Core	Wordt veroorzaakt door een floating point error
SIGKILL	9	Term	Kan door een beheerder gebruikt worden om een proces af te breken Hierbij wordt het proces niet netjes afgemeld en gaan eventuele nog openstaande gegevens verloren.
SIGUSR1	10	Term	Dit signaal kan door een programmeur gebruikt worden om signalen te versturen
SIGSEGV	11	Core	Segmentation fault: er wordt op een ongeldige wijze naar werkgeheugen verwezen
SIGUSR2	12	Term	Signaal dat door de gebruiker gedefinieerd kan worden
SIGPIPE	13	Term	Verbroken pipe: er wordt verwezen naar een pipe die niet bestaat
SIGALRM	14	Term	Het alarmsignaal. Dit wordt gebruikt om na verstrijken van een bepaalde periode een alarmsignaal naar een proces te sturen
SIGTERM	15	Term	Signaal dat door de beheerder gebruikt wordt om een proces netjes af te sluiten
SIGTERM	17	Ign	Geeft aan een parent proces door dat een child proces gestopt is
SIGCONT	18	nvt	Hervat een proces dat gestopt is. Dit is bijvoorbeeld wat de opdracht 'fg' doet om een proces te hervatten dat met ctrl-Z gestopt is.
SIGSTOP	19	Stop	Stopt een proces
SIGTSTOP	20	Stop	Stopt een proces vanaf een TTY. Dit is wat er gebeurt als de toets combinatie ctrl-z gebruikt wordt op een interactief proces
SIGTTIN	21	Stop	Invoer vanaf een TTY die bestand is voor een achtergrond proces
SIGTTOU	22	Stop	TTY uitvoer voor een achtergrond proces
SIGURG	23	Ign	Urgente situatie op een verbinding
SIGXCPU	24	Core	Tijdslimiet op de CPU is overschreden
SIGXFSZ	25	Core	Bestands grootte is overschreden
SIGVTALRM	26	Term	Virtueel alarm
SIGPROF	27	Term	De profiling timer is verlopen

Voor de beheerder zijn er een aantal signalen de moeite waard:

• SIGHUP
  het proces wordt gedwongen zijn configuratie bestanden opnieuw in te lezen. Gebruik hiervoor de opdracht kill -1 PID
• SIGTERM
  afsluiten van een process, gebruik hiervoor : kill -15 PID
  het proces wordt netjes afgesloten
• SIGKILL afsluiten van een process, gebruik hiervoor : kill PID het proces wordt onvoorwaardelijk afgesloten (eventueel gaan er gegevens verloren)
• SIGTSTOP process wordt gestopt , geactiveerd met de toets combinatie ctrl-z proces kan opnieuw geactiveerd worden met kill -18 PID (of zie ook 'fg','bg' opdrachten)

4 Typen Processen

Voor het beheer van processen is het belangrijk te weten dat er drie verschillende soorten processen bestaan:

• interactieve processen
  Dit zijn processen die vanuit de shell gestart worden en die beheerd kunnen worden door er een signaal naartoe te sturen dat afkomstig is van een toets combinatie. Zo kan men een actief proces afbreken met de toets combinatie ctrl-c.
• batch processen
  Deze worden in de regel automatisch op de achtergrond gestart door middel van at of cron. Als beheerder kan men deze processen niet beinvloeden met een toetscombinatie. Wel kan men met behulp van ps het PID van dit proces opvragen en het vervolgens afsluiten.
• daemon processen
  Dit zijn achtergrond processen die gestart worden door het run-level en meestal actief blijven, ze zorgen ervoor dat de geinstalleerd services geleverd worden. Vaak neemt de activiteit van deze processen een sleeping status in, de daemon slaapt en wacht op invoer. Daemon processen kunnen ook beheerd worden via hun PID.

5 Geheugen allocatie

Als een proces gestart wordt heeft het resources nodig Om een goede werking te garanderen, doet elk proces aan over-allocation: dit betekent dat het proces meer resources reserveert dan dat het daadwerkelijk nodig heeft. Op basis van deze resources maakt elk proces zijn eigen address-space. Dit is een gedeelte van het werk geheugen dat gereserveerd is door het proces en waar alleen dit proces in mag schrijven. Probeert het toch geheugen buiten de gereserveerde address-space te gebruiken, dan is er sprake van een page-fault en dat wordt in de meeste gevallen direct afgestraft.

Het aardige van de wijze waarop processen onder Linux functioneren, is dat er een zeer strikt onderscheid is tussen de kernel- en de user-space. Kernel-space is dat deel van het geheugen dat door de kernel gereserveerd is. Een normaal proces mag hier nooit rechtstreeks in schrijven; dit is voorbehouden voor de kernel zelf en de bijbehorende drivers. Elk normaal proces wordt standaard geladen in user-space. Door deze strikte scheiding ontstaat een uitermate stabiel operating systeem. Processen zitten de kernel nooit in de weg en kunnen daardoor de linux-kernel nooit laten crashen. Dit is dan ook de reden dat een kernel-panic (een abnormale terminering van de kernel) onder linux zelden voorkomt. Het enige dat kan gebeuren is dat een proces zelf abnormaal wordt be-eindigd. Als dat het geval is kan de beheerder ingrijpen door er een signaal naartoe te sturen waardoor de resources die door het proces in gebruik waren weer netjes teruggegeven worden aan de kernel. Het optreden van een page-fault is onder Linux dus geen kritische situatie.

Bij het laden van een proces, kan onderscheid gemaakt worden in de verschillende soorten resources die het proces claimt.

• code memory
  dit is het geheugen dat het proces nodig heeft om de programma onderdelen te kunnen laden. Over het algemeen neemt dit niet veel ruimte in beslag.
• data-memory
  in dit geheugen laadt het proces zijn gegevens, het is voornamelijk hier dat de overallocatie plaast vindt. elk proces claimt namelijk meer werk-geheugen dan het daadwerkelijk nodig heeft
• shared-memory
  dit geheugen wordt gebruikt om programma onderdelen in op te slaan die komen uit de zogenaamde shared-library's. Andere processen maken eveneens gebruik van dit geheugen. Meestal neemt ook dit type geheugen niet veel ruimte in beslag.

Met behulp van opdrachten zoals 'top' en 'free' verkrijgt men een overzicht van het geheugen.

Om zijn werk te kunnen doen, bestaat de mogelijkheid dat alles wat het proces aan werkgeheugen nodig heeft, geladen wordt in het werkgeheugen dat fysiek in de vorm van RAM in de computer aanwezig is. Alle memory pages (geheugen blokken) die in het fysieke geheugen gealloceerd zijn, worden aangeduid als resident memory. Naast het residente geheugen maakt Linux ook nog gebruik van swap geheugen. Dit is RAM geheugen dat geemuleerd wordt op de harde schijf van de computer. SWAP geheugen wordt alleen gebruikt als het normale geheugen volledig in gebruik is en er geen ruimte meer in aanwezig is. De verzameling van geheugen blokken die zowel in SWAP als in resident geheugen aanwezig is wordt het virtuele geheugen genoemd. Men kan de wijze waarop processen gebruik maken van het geheugen tonen met een opdracht zoals 'top'.

6 Processen, de sheduler en prioriteit

Wanneer een proces gestart wordt, heeft het over het algemeen processortijd nodig. Omdat het proces in kwestie waarschijnlijk niet het enige proces is waarvoor dat geldt, komt het in de queue terecht. Hierin staan alle processen die processortijd nodig hebben en iedereen komt daar aan de beurt. In princiepe wordt daarvoor het LIFO princiepe gebruikt (LAST IN FIRST OUT). Het proces dat het langst aan het wachten is wordt als eerste afgehandeld. De scheduler maakt hiervoor gebruik van het prioriteis mechanisme: hoe langer een proces in de queue staat, hoe hoger de prioriteir van het proces wordt.

Nu is doorgaans niet elk proces even belangrijk. Daarom is het goed te weten dat de prioriteit van een proces kan aangepast worden. Hiervoor wordt gebruik gemaakt van de opdrachten 'nice' en 'renice'. Hoe hoger de nice-waarde van een proces, hoe aardiger het voor andere processen is en dus hoe minder prioriteit het proces nodig heeft. Heeft een proces echter een negatieve nice-waarde dan neemt de prioriteit van dat proces ten opzichte van de andere processen toe. Het resultaat is dat het proces in kwestie steeds op een vrij hoge positie in de queue zal terecht komen en daarbij andere processen passeert zodat het eerder aan de beurt zal zijn. De nice waarde van een proces kan bij het opstarten worden meegegeven door gebruik te maken van de opdracht nice. Ook is het mogelijk om de nice waarde van een proces achteraf aan te passen met de opdracht renice. Een andere mogelijkheid is vanuit het top programma de optie r toe te passen.