Processen

Start Omhoog Computersystemen Besturingssystemen Processen Threads Gelijktijdigheid: Wederzijdse uitsluiting Gelijktijdigheid: deadlock en utisterving Geheugenbeheer Virtueel geheugen Uniprocessor planning Multiprocessor en real-time planning Bestandsbeheer I/O beheer en schijfplanning Bash Powershell Begrippen

Alle meervoudig programmeerbare besturingssystemen, van ťťn-gebruiker systemen, zoals Windows voor eindgebruikers, tot mainframe systemen, zoals IBM's mainframe besturingssysteem z/OS, welke duizenden gebruikers ondersteund zijn gebouwd rond het concept van het proces.

  • Het besturingssysteem moet de executie van meerdere processen tussenvoegen om het processorgebruik te maximaliseren terwijl het redelijke reactietijden kan leveren.
  • Het besturingssysteem moet bronnen toekennen schikkende naar een specifiek beleid (bv. bepaalde functies of applicaties hebben een hogere prioriteit) terwijl op hetzelfde moment een deadlock moet worden vermeden.
  • Van het OS mag worden verwacht om inter-proces communicatie en de creatie gebruikers-processen worden ondersteund. Beide op een manier om structurering van applicaties vergemakkelijkt.
  • 3.1. Wat is een proces?

    3.1.1. Achtergrond

    Voordat we de term proces definiŽren is het handig om enkele concepten uit hoofdstuk 1 en 2 samen te vatten:

    1. Een computer bestaat uit een verzameling hardware bronnen, zoals processor, hoofdgeheugen, I/O modules, timers, disk drives enz.
    2. Computertoepassingen zijn ontworpen voor specifieke taken.
    3. Het is inefficiŽnt om toepassingen te ontwikkelen voor specifieke hardware. De voornaamste redenen zijn:
       
      1. Talloze applicaties kunnen worden ontwikkeld voor hetzelfde platform en het daarom aangewezen om algemene routines te ontwikkelen voor de toegang tot de computerbronnen.
      2. De processor zelf levert enkel beperkte support voor multiprogrammering. Software is nodig om voor het beheer van het delen van de processor en andere bronnen door meerdere applicaties op hetzelfde moment.
      3. Als meerdere applicaties actief zijn op hetzelfde moment is nodig om de data, I/O gebruikt en andere brongebruik te beveiligen tussen de applicaties onderling.
    4. Het besturingssysteem was ontworpen om applicaties te voorzien van gemakkelijke, vol met functies, betrouwbare, veilige en consistente interface.
    5. Het besturingssysteem biedt een uniforme en abstractie voorstelling van bronnen die opvraagbaar en toegankelijk zijn voor applicaties.

    Nu we de concepten van applicaties, systeem software en bronnen hebben, kunnen bespreken hoe het besturingssysteem op een georganiseerde en gecontroleerde manier de applicaties zo kan uitvoeren dat:

  • Bronnen beschikbaar worden gemaakt voor meerdere applicaties.
  • De fysische processor wordt geschakeld tussen meerdere applicaties zodat het lijkt dat alle vooruitgaan.
  • De processor en I/O apparaten efficiŽnt kunnen worden gebruikt.
  • De door alle moderne besturingssystemen toegepaste methode is het steunen op het model waarvan de uitvoer van een applicatie correspondeert met het bestaan van ťťn of meerdere processen.

    3.1.2. Processen en proces controle blokken

    In hoofdstuk 2 hebben we enkele definities besproken voor de term proces, zoals:

  • Een programma in uitvoering
  • Een instantie van een programma in uitvoering op een computer
  • Een entiteit dat kan worden toegewezen en worden uitgevoerd op een processor
  • Een eenheid van activiteit door de uitvoer van een sequentie instructies, een huidige status en een bijbehorende set van systeembronnen
  • We kunnen een proces ook beschrijven als een entiteit dat bestaat uit een aantal delen. Twee essentiŽle delen van een proces zijn de programma code (welke gedeeld kunnen worden met andere processen dat hetzelfde programma zijn aan het uitvoeren) en een dataset behorende tot die code. Laten we veronderstellen dat de processor start met het uitvoeren van de programmacode en we refereren naar deze uitvoerende entiteit als een proces. Op een gegeven moment, terwijl het programma in uitvoering is, kan dit proces gekenmerkt worden door een aantal elementen:

  • Identificatie: Een unique identifier behorende bij dit proces, om zich te onderscheiden van andere processen.
  • Status: Als het proces in uitvoering is, is het in running state.
  • Prioriteit: priority level relatief in verhouding tot andere processen.
  • Programmateller: Het adres van de volgende instructie om uitgevoerd te worden in het programma.
  • Geheugen pointers: Bevat pointers (variabelen) naar de programmacode en data geassocieerd met dit proces plus elk geheugenblok dat gedeeld wordt met andere processen.
  • Context data: De gegevens aanwezig in de registers van de processor terwijl het proces uitvoerende is.
  • I/O status informatie: Inclusief openstaande I/O aanvragen, I/O apparaten (bv. disk drives) toegewezen aan dit proces, een lijst bestanden in gebruik door het proces enz.
  • Statistische informatie: Kan het processorgebruik bevatten en gebruikte kloktijden, tijdlimieten, enz.
  • De informatie in de voorgaande lijst is opgeslagen in een datastructuur, typisch een proces control block genoemd, dat wordt gecreŽerd en beheerd door het besturingssysteem. Het belangrijke van het process control block is dat het genoeg informatie bevat zodat het mogelijk is om een lopend proces te onderbreken en nadien verder te laten gaan alsof de onderbreking niet had voorgedaan. Het procescontroleblok is het sleutelhulpmiddel om een besturingssysteem meerdere processen te laten ondersteunen en om te voorzien in meervoudige verwerking (multiprocessing). Als een proces wordt onderbroken worden de huidige waarden van de programmateller (context date) bewaard in de toegewezen velden van het corresponderen procescontroleblok en de status van het proces wordt veranderd naar een andere niveau zoals blocked of ready. Het besturingssysteem kan nu klaar een ander proces in running state zetten. De programmateller en context data behorende tot dit proces worden geladen in de processor registers en het proces begint met uitvoeren.

    We kunnen dus zeggen dat een proces bestaat uit programmacode en bijbehorende data plus een procescontroleblok. Voor een single-processor computer kan er op ieder moment maar ťťn proces in uitvoering zijn en dat proces is in running state.

    3.2. Proces toestanden

    Vanuit het oogpunt van de processor worden instructies in een bepaalde volgorde uitgevoerd van zijn repertoire door de waarden te veranderen in het register van de programmateller. Op een bepaald moment kan de programmateller refereren naar code in verschillende programma's die deel uitmaken van verschillende processen.

    We kunnen het gedrag van een individueel proces schetsen door een sequentie van instructies op te stellen die worden uitgevoerd voor dat proces. Zulk een lijst wordt verwezen als een trace van het proces. Het gedrag van de processor kunnen we schetsen door te tonen hoe de traces van verschillende processen worden tussengevoegd.

    Bovenstaand voorbeeld toont een geheugen lay-out van drie processen. Om het te vereenvoudigen nemen we aan dat er geen gebruik wordt gemaakt van virtueel geheugen; dus alle drie processen worden voorgesteld door programma's dat volledig geladen zijn in het hoofdgeheugen. Als toevoeging is er een klein dispatcher programma welke de processor laat schakelen tussen de processen onderling. Onderstaande tabel laat traces van ieder proces gedurende het eerste gedeelte van hun uitvoering zien. De eerste 12 instructies van de uitvoering van proces A en C worden getoond. Proces B voert 4 instructies uit en we nemen aan dat de vierde instructie een I/O operatie aanroept waardoor het proces moet wachten.

    Laten we nu deze traces bekijken vanuit de processors optiek. Onderstaande tabel laat de tussengevoegde traces zien van de eerste 52 instructiecyclussen. De geschakeerde gebieden betreft de code welke wordt uitgevoerd door de dispatcher. De zelfde sequentie van instructies worden door de dispatcher in elke instantie uitgevoerd, omdat de dezelfde functionaliteit van de dispatcher wordt uitgevoerd. We nemen aan dat het besturingssysteem een maximum van zes instructies laat uitvoeren, waarna het wordt onderbroken; dit verhinderd dat een enkel proces monopolistisch beslag kan leggen op het processorgebruik.

    3.2.1. Het twee toestanden proces model

    De hoofdzakelijke verantwoordelijkheid van een besturingssysteem is de controle op de uitvoer van processen; dit houdt in het bepalen van het tussenvoegingspatroon voor de uitvoering en toewijzing van bronnen aan processen. De eerste stap in het ontwerp van een besturingssysteem in het besturen van processen is het gedrag beschrijven wat we verwachten dat een proces vertoont.

    Het meest eenvoudige model dat we kunnen construeren, gezien op eender moment, is dat een proces wordt uitgevoerd door een processor of niet. In dit model, een proces kan in twee toestanden begeven: Running or Not Running. Als het besturingssysteem een nieuw proces creŽert, creŽert het ook een proces control block en zet het proces in het systeem in de Not Running status. Het proces bestaat, is gekend door het besturingssysteem en is wachtende op een mogelijkheid om uitgevoerd te worden. Van tijd tot tijd, zal het huidige proces onderbroken worden en de dispatcher gedeelte van het besturingssysteem zal een ander proces selecteren om uit te voeren. Het eerdere proces veranderd van Running state naar Not Running state en het een van de andere processen verandert naar Running state.

    Vanuit dit eenvoudig model kunnen we sommige van de ontwerpelementen van het besturingssysteem beginnen te verkiezen. Ieder proces moet op een manier worden voorgesteld zodat het besturingssysteem het kan blijven volgen. Dat wil zeggen er moet enige informatie, relatief tot ieder proces zijn, inclusief huidige staat en plaats in het geheugen; dit is het process control block. Processen die niet in uitvoering zijn moeten bewaard worden in een of andere vorm van wachtrij, op hun beurt wachtend om uitgevoerd te worden. Er is een enkele wachtrij waarin ieder ingangspunt een pointer naar het process control block van een specifiek proces is. De wachtrij kan ook bestaan uit een gelinkte lijst van datablokken, waarin ieder blok voorgesteld wordt als ťťn proces.

    Het gedrag van dispatcher kunnen we omschrijving als termen van dit wachtrij diagram. Een proces dat onderbroken is, wordt verplaatst naar de wachtrij van wachtende processen. Optioneel wordt het proces verwijderd als het voltooid of afgebroken is. In ieder geval zal de dispatcher een ander proces van de wachtrij nemen en beginnen uit te voeren.

    3.2.2. De creatie en beŽindiging van processen

    Voordat we ons twee-toestanden model beginnen te verfijnen, is het nuttig om praten over creatie en beŽindiging van processen; uiteindelijk, en losstaand van het model van procesgedrag dat wordt gebruikt, het leven van een proces is gebonden door de creatie en beŽindiging.

    3.2.2.1. Procescreatie

    Als een nieuw proces wordt toegevoegd aan de reeds beheerde lijst, zal het besturingssysteem de datastructuren bouwen die worden gebruikt om het proces te beheren en zal deze voor het proces geheugenruimte in het hoofdgeheugen toewijzen. Deze acties vormen samen de creatie van een nieuw proces.

    Zoals vermeld in onderstaande tabel zullen vier gemeenschappelijke gebeurtenissen leiden tot de creatie van een proces. In een batch omgeving wordt een proces gecreŽerd in reactie op de overgave van een job. In een interactieve omgeving, wordt een proces gecreŽerd als een nieuwe gebruiker probeert in te loggen. In beide gevallen is het besturingssysteem verantwoordelijk voor de aanmaak van een nieuw proces. Het besturingssysteem kan ook een proces aanmaken ten behoeve van een applicatie. Bijvoorbeeld, als een gebruiker een bestand wil afdrukken kan het besturingssysteem een proces instantiŽren dat de printopdracht beheert. Het sturend proces kan dus onafhankelijke verdergaan voor de benodigde tijd om de printopdracht te voltooien.

    Traditioneel was het besturingssysteem dat alle processen op een transparante manier aanmaakte voor de gebruiker of applicatieprogramma, en dit is nog steeds gebruikelijk in vele eigentijdse besturingssystemen. Nochtans kan het handig zijn om processen toe te staan andere processen te creŽren. Bijvoorbeeld, een applicatie kan een ander proces aanmaken om gegevens van de applicatie te ontvangen en deze gegevens te verwerken op een manier zodat deze later te gebruiken is voor analyse. Het nieuwe proces loopt parallel met het origineel proces en wordt van tijd tot tijd geactiveerd zodra er nieuwe gegevens beschikbaar zijn. Dit geheel kan zeer bruikbaar zijn om structuur in de applicatie te brengen. Als een ander voorbeeld, een server proces (bv. print server, file server), kan nieuwe processen opstarten voor elk aanvraag dat het behandeld. Als een besturingssysteem een proces instantieert op expliciete vraag van een ander proces, wordt dit process spawning genoemd.

    Als een proces een ander proces opstart, wordt de eerste gerefereerd als parent process en het geÔnstantieerd proces gerefereerd als child process. Kenmerkend is dat gerelateerde processen onderling moeten communiceren en samenwerken. Het samenwerken tussen processen is een moeilijke taak voor de programmeur.

    3.2.2.2. ProcesbeŽindiging

    Ieder computersysteem moet voor een proces een reden van voltooiing voorzien. Een batch opdracht moet een Halt-instructie of een door het besturingssysteem geleverde beŽindigingsroutine voorzien. In het eerstgenoemde zal de Halt-instructie een interrupt genereren om het besturingssysteem te informeren dat een proces voltooid is. Voor een interactieve applicatie zal de handeling van de gebruiker aangeven wanneer het proces voltooid is. In een timesharing systeem bijvoorbeeld, zal het proces voor een specifieke gebruiker beŽindigd worden als de gebruiker uitlogt of zijn terminal uitschakelt. Op een personal computer of werkstation, sluit de gebruiker een applicatie (bv. tekstverwerker of rekenblad). Uiteindelijk zullen deze acties leiden tot een service request aan het besturingssysteem om het vragend proces te beŽindigen.

    Bovendien zal een aantal error- en fout-condities ook leiden tot beŽindiging van een proces. Onderstaand tabel somt de veelvoorkomende erkende condities.

    Uiteindelijke zal in sommige besturingssystemen een proces beŽindigd worden door het proces dat het gecreŽerd heeft of wanneer het parent proces zelf beŽindigd wordt.

    3.2.3. Het vijf toestanden proces model

    Als alle processen op ieder moment klaar waren om uitgevoerd te worden, dan zou het wachtrijmechanisme uit onderstaande figuur doeltreffend zijn. De wachtrij is een FIFO (first in first out) lijst en de processor verwerkt de beschikbare processen op een round-robin manier (ieder proces in wachtrij wordt een bepaalde tijd toegewezen om uitgevoerd te worden en wordt daarna terug in de wachtrij geplaatst tenzij het geblokkeerd is). Hoewel zelfs met het meest eenvoudig voorbeeld is deze implementatie inefficiŽnt: Sommige processen in de Not-Running toestand zijn klaar om uitgevoerd te worden, terwijl andere blocked zijn, wachtend op een I/O operatie. Dus bij gebruikmaking van een enkelvoudige wachtrij kan de dispatcher niet enkel de oudste op het einde van de wachtrij selecteren. Integendeel, de dispatcher moet de lijst scannen, kijkend naar het proces dat niet geblokkeerd is en het langst in de wachtrij zit.

    Een meer praktischere manier om deze situatie aan te pakken is om de toestand van Not Running op te splitsen in twee toestanden: Ready en Blocked. Dit wordt geÔllustreerd door onderstaande afbeelding. Om het af te maken hebben we twee extra toestanden toegevoegd. De vijf toestanden in dit nieuwe diagram zijn:

  • Running: Het proces dat momenteel wordt uitgevoerd. Voor dit hoofdstuk gaan we uit van een computer met een enkele processor, zodat ten hoogste ťťn proces per moment in deze toestand kan zijn.
  • Ready: Een proces dat klaar is om uitgevoerd te worden als het moment daar is.
  • Blocked/Waiting: Een proces dat niet uitgevoerd kan worden totdat een ťťn of andere gebeurtenis optreedt, zoals de voltooiing van een I/O operatie.
  • New: Een oroces dat pas gecreŽerd, maar nog niet door het besturingssysteem toegelaten tot de pool van uitvoerbare processen. Typerend is dat een nieuw proces nog niet geladen is in het hoofdgeheugen, ondanks dat het proces control block reeds is aangemaakt.
  • Exit: Een proces dat door de het besturingssysteem uit de pool van uitvoerbare processen wordt gehaald, is ofwel halted of omdat het afgebroken voor ťťn of andere reden.
  • De New en Exit toestanden zijn handige constructors voor procesbeheer. De New status correspondeert met een proces dat juist gedefinieerd is. Eerst zal het besturingssysteem die nodige interne administratie uitvoeren. Een identifier zal geassocieerd worden met het proces. Iedere tabel die nodig is om het proces te beheren zal toegewezen en aangemaakt worden. Op dit punt is het proces in de New toestand. Dit betekend dat het besturingssysteem de benodigde acties heeft uitgevoerd om het proces te creŽren, maar nog niet over is gegaan tot executie van het proces. Het kan bijvoorbeeld nodig zijn dat het besturingssysteem het aantal processen in het systeem moet limiteren vanwege prestatie- of geheugenbeperkingen. Zolang het proces in de New toestand is, zal alle relevante informatie in control tabellen in het hoofdgeheugen beheerd worden, alhoewel het proces zelf niet in het hoofdgeheugen bevind en nog er nog geen plaats in het hoofdgeheugen is toegewezen voor de bijbehorende data van dat programma. Zolang het proces in de New status staat zal het programma in het secundair geheugen blijven, normaal gesproken disk opslag.

    Op een gelijkwaardige manier zal een proces het systeem in twee fases verlaten. Eerst wordt een proces beŽindigd worden als het een punt van voltooiing bereikt, afgebroken wordt door een niet herstelbare fout of wanneer een ander proces met geschikte autoriteit er voor zorgt dat het proces wordt afgebroken. De beŽindiging zal het proces verder laten gaan naar de Exit status. Vanaf dit moment kan het proces niet meer worden uitgevoerd. De tabellen en andere bijbehorende informatie van de Job zullen tijdelijke door het besturingssysteem worden bewaard zodat er tijd wordt voorzien om aanvullende programma's de tijd te geven om de benodigde informatie op te halen. Zodra deze programma's de benodigde informatie hebben opgehaald, hoeft het besturingssysteem niet langer meer enige gegevens te onderhouden met betrekking tot het proces en het proces zal verwijderd worden van het systeem.

    Bovenstaande figuur geeft de mogelijke gebeurtenissen die leiden naar iedere toestand verandering van een proces: de mogelijke transities zijn als volgt:

  • Null -> New: Een nieuw proces is aangemaakt om een programma uit te voeren. Deze gebeurtenis gebeurt voor iedere reden uit tabel 3.1.

  • New -> Ready: Het besturingssysteem kan het proces verplaatsen van de New status naar de Ready status als het voorbereid is om een extra proces aan te nemen. De meeste systemen zetten een limiet op het maximum aantal beschikbare processen of de hoeveelheid virtueel geheugen toegewezen tot bestaande processen. Deze limiet zorgt ervoor dat de prestatie niet verminderd door een teveel aan actieve processen.
  • Ready -> Running: Zodra het tijd is om een proces te selecteren om uitgevoerd te worden zal het besturingssysteem een kiezen uit de lijst van processen met de Ready status. Dit is de taak van de planner (scheduler) of dispatcher.
  • Running -> Exit: Het huidig lopend proces is beŽindigd door het besturingssysteem als het proces aangeeft dat het klaar is, of afgebroken is. Zie tabel 3.2.
  • Running -> Ready: De meest voorkomende overgangsredenen zijn dat het lopend proces het maximum aantal toegestane tijd van ononderbroken uitvoering heeft bereikt: praktisch alle meervoudig programmeerbare besturingssystemen hanteren deze manier van tijddiscipline. Er zijn verschillende andere oorzaken voor deze overgang, welke niet geÔmplementeerd zijn in alle besturingssystemen. Specifieke gewichtigheid is het geval waarin besturingssystemen verschillende prioriteiten niveaus toepast op verschillende processen. Laten we uitgaan van het volgende voorbeeld dat een Proces A uitvoerende is met een gegeven prioriteitsniveau, en dat proces B op een hoger niveau geblokkeerd staat. Als het besturingssysteem leert dat de gebeurtenis waarop Proces B wachtende is gebeurd, B verplaatsen naar de Ready status, dan kan het Proces B onderbreken en dispatch Proces B. We zeggen dan dat het besturingssysteem beslag heeft gelegd (preemted) op Proces A. Uiteindelijk kan een proces vrijwillig controle van de processor vrijmaken. Een voorbeeld is een achtergrond proces dat periodiek een of andere vorm van administratie of onderhoud uitvoert.
  • Running -> Blocked: Een proces wordt in de Blocked status gezet als iets opvraagt waarop gewacht moet worden. Een aanvraag naar het besturingssysteem is meestal in de vorm van een system service call; dat is een oproep van het lopend programma naar een procedure dat deel is van de besturingssysteemcode. Als processen onderling communiceren, kan een proces geblokkeerd raken als het op een ander proces aan het wachten is die data moet sturen.
  • Blocked -> Ready: Een proces in de Blocked status wordt verplaatst naar de Ready status als de gebeurtenis waarop het wachtende was gebeurd.
  • Ready -> Exit: Voor de duidelijkheid, deze overgang wordt niet getoond op het status diagram. In sommige systemen kan een parent op ieder moment een child proces beŽindigen. Ook, als de parent wordt beŽindigd, worden alle met de parent geassocieerde child-processen ook beŽindigd.
  • Blocked -> Exit: Dezelfde opmerkingen uit voorgaand item geld hier ook.
  • Terugkerend naar ons eenvoudig voorbeeld, onderstaande figuur toont de overgang van ieder proces tussen de verschillende toestanden. Figuur 3.8a suggereert de manier waarop de wachtrij discipline met twee wachtrijen geÔmplementeerd kan worden: Een Ready wachtrij en een Blocked wachtrij. Als ieder proces naar het systeem doorgestuurd is, wordt het geplaatst in de Ready wachtrij. Op het moment dat het tijd is voor het besturingssysteem een ander proces te kiezen om uit te voeren, zal het ťťn kiezen uit de Ready wachtrij. Bij afwezigheid van een prioriteitenschema zal dit een eenvoudige FIFO (first-in-first-out) wachrij worden. Als het lopend proces van de uitvoering wordt verwijderd, wordt het beŽindigd ofwel in de Ready of Blocked wachrij geplaatst. Uiteindelijk als een gebeurtenis voorvalt, zal ieder proces in de Blocked wachtrij dat op die gebeurtenis aan het wachten was verplaatst worden naar de Ready wachtrij.

    Deze laatgenoemde regeling betekend dat wanneer een gebeurtenis voorvalt, het besturingssysteem de volledige geblokkeerde wachtrij moet scannen om die processen te vinden die aan het wachten zijn op die gebeurtenis. In een groot besturingssysteem kunnen dat honderden of zelfs duizenden processen in die wachtrij zijn. Daarom zou het veel efficiŽnter zijn als er meerdere wachtrijen voor iedere gebeurtenis zouden zijn. Als een bepaalde gebeurtenis voorvalt, kan de volledige lijst van processen in die wachtrij in de Ready status worden gezet. (Figuur 3.8b).

    Een laatste verfijning: Als de dispatching van processen geregeld wordt door een prioriteitenschema, dan zou het gemakkelijk zijn om een aantal Ready wachtrijen te hebben, elk voor ieder prioriteitsniveau. Het besturingssysteem kan dan vlot bepalen welke de Ready proces met de hoogste prioriteit het langst aan het wachten is.

     

    3.2.4. Opschorting van processen

    3.2.4.1. De noodzaak van wisselen

    De drie zojuist beschreven hoofdzakelijke toestanden (Ready, Running, Blocked) voorzien op een systematische manier het gedrag van processen en stuurt de implementatie van het besturingssysteem. Sommige besturingssystemen zijn zo geconstrueerd om enkel gebruik te maken van deze drie toestanden.

    Alhoewel, het is gegrond om andere toestanden toe te voegen aan het model. Om het nut aan te tonen van deze nieuwe toestanden beschouw dan een systeem dat geen virtueel geheugen hanteert. Ieder proces dat uitgevoerd moet worden moet in het hoofdgeheugen bevinden.

    Herinner dat de reden voor dit uitgebreide systeem voortkomt doordat I/O activiteiten veel trager zijn dan uitvoering en daarom in een enkelvoudig programmeerbare omgeving de processor de meeste tijd onbenut blijft.

    Het hoofdgeheugen zou uitgebreid kunnen worden om plaats te bieden aan meer processen, maar dit impliceert een extra kostprijs van het hoofdgeheugen en grotere geheugens staan inherent aan grotere processen.

    Een andere oplossing is swapping (wisselen), wat betekend dat je, delen van, of het complete proces verplaatst van hoofdgeheugen naar disk. Als geen van de processen in het hoofdgeheugen zich in de Ready status bevinden zal het besturingssysteem ťťn van de geblokkeerde processen naar de disk wisselen en in de opgeschorte wachtrij plaatsen. Dit is een wachtrij van bestaande processen die tijdelijk uit het hoofdgeheugen zijn gezet. Het besturingssysteem haalt een ander proces van de opgeschorte wachtrij of het zal een nieuw proces inwilligen. Uitvoering zal dan verder gaan met het nieuw of opgehaald proces.

    Wisseling is een I/O operatie en is kan daarom het probleem potentieel groter maken. Doordat disk I/O over het algemeen de snelste I/O operatie is vergeleken tot tape of printer I/O, zal wisseling toch een significante prestatiewinst opleveren.

    Door het gebruik van wisseling als zojuist beschreven zal een ander toestand moeten worden toegevoegd aan ons proces gedrag model. (Figuur 3.9a): de Suspend status. Als alle processen in het hoofdgeheugen zich in de Blocked status bevinden, dan kan het besturingssysteem ťťn proces opschorten door het in de Suspend status te zetten en dit te verplaatsen naar disk. De geheugenruimte die vrijkomt, kan dan voor een ander proces worden aangewend.

    Als het besturingssysteem de wisseling-uit het hoofdgeheugen heeft uitgevoerd, heeft het twee keuzes om een proces te kiezen om terug in het hoofdgeheugen te brengen: Het kan toelaten een nieuw proces aan te maken of het kan een opgeschort proces terug in het hoofdgeheugen plaatsen. Het zou lijken dat de voorkeur uitgaat naar het terug inbrengen van een eerder opgeschort proces om te voorzien in service in plaats van de totale last van het systeem verder te verhogen.

    Maar deze benadering zorgt voor een moeilijkheid. Alle processen die opgeschort zijn waren in de Blocked status op het moment van opschorting. Het zou duidelijk niet goed doen om een geblokkeerd proces terug in het hoofgeheugen te plaatsen als het nog steeds niet klaar is voor uitvoering. Weet dat ieder proces in de Suspend status oorspronkelijk geblokkeerd was door een specifieke gebeurtenis. Als deze gebeurtenis plaatsvindt dan is proces niet meer geblokkeerd en zal potentieel beschikbaar zijn voor uitvoering.

    Daarvoor moeten we het ontwerpaspect heroverwegen. Er zijn hier twee onafhankelijk concepten: ofwel is een proces aan het wachten op een gebeurtenis (geblokkeerd of niet) ofwel dat een proces uitgewisseld is naar disk (opgeschort of niet). Om deze 2 x 2 combinatie te huisvesten, zijn er vier toestanden benodigd:

  • Ready: Het proces is in het hoofdgeheugen en beschikbaar voor uitvoering.
  • Blocked: Het proces is in het hoofdgeheugen en is wachtend op een gebeurtenis.
  • Blocked/Suspend: Het proces bevindt zich in het secundair geheugen en is wachtend op een gebeurtenis.
  • Ready/Suspend: Het proces bevindt zich in het secundair geheugen maar is beschikbaar voor uitvoering zodra het ingeladen is in het hoofdgeheugen.
  • Voordat we verder kijken naar het toestanden transitie diagram dat beide nieuwe onderbroken toestanden bevatten, moet een ander punt worden vermeld. Tot nu toe werd er vanuit gegaan dat er geen virtueel geheugen in gebruik was en dat een proces ofwel in het geheel in het hoofdgeheugen bevindt of helemaal niet in het hoofdgeheugen bevindt. Met een virtueel geheugen schema is het mogelijk om een proces uit voeren dat maar zich deels in het hoofgeheugen bevindt. Als een referentie wordt gemaakt naar een procesadres dat zich niet in het hoofdgeheugen bevindt zal het deel wat van toepassing is terug opgehaald worden. Het gebruik van virtueel geheugen zou laten blijken dat het expliciete wisselen niet meer nodig is, omdat eender welk gewenst proces verplaatst kan worden van en naar het hoofgeheugen door de geheugenbeheer hardware van de processor. In hoofdstuk 8 zullen we zien dat de prestatie van een virtueel geheugen systeem instort als er genoeg grote actieve processen zijn welke allemaal gedeeltelijk in het hoofdgeheugen zitten. Daarom is het zelfs met een virtueel geheugen systeem nodig dat het besturingssysteem processen uitwisselt en van tijd tot tijd volledig.

    Laat ons nu naar figuur 3.9b kijken naar het toestand transitie model dat we hebben ontwikkeld. (De gestreepte lijnen in de figuur tonen mogelijke maar niet noodzakelijke overgangen.) Belangrijke nieuwe overgangen zijn:

  • Blocked -> Blocked/Suspend: Als er geen klaarstaande processen zijn dan zal op zijn minst ťťn geblokkeerd proces uitgewisseld worden om plaats te maken voor een ander proces dat niet geblokkeerd staat. Deze overgang kan zelfs gemaakt worden als er klaarstaande processen beschikbaar zijn of een klaarstaand proces, dat het graag uitgeeft dat het meer hoofdgeheugen nodig heeft om een adequatere prestatie te onderhouden.
  • Blocked/Suspend -> Ready Suspend: Een proces in geblokkeerde toestand wordt verplaatst naar de Ready/Suspend toestand als de gebeurtenis waarop het aan het wachten is gebeurd. Merk op dat dit vereist dat de status informatie betreffende opgeschorte processen beschikbaar moeten zijn voor het besturingssysteem.
  • Ready/Suspend -> Ready: Als er geen gereedstaande processen in het hoofdgeheugen zitten, dan moet het besturingssysteem ťťn ophalen om de uitvoer verder te zetten. Als toevoeging kan het geval zijn dat een proces in de Ready/Suspend toestand een hogere prioriteit heeft dan een proces in de Ready toestand. In dat geval moet de besturingssysteem ontwikkelaar bepalen wat van groter belang is. Het hoger prioriteitsproces of om het wisselen te minimaliseren.
  • Ready -> Ready/Suspend: Normaal gesproken zal het besturingssysteem verkiezen om een geblokkeerd proces op te schorten in plaats van een gereedstaand proces, omdat een gereedstaand proces nu uitgevoerd kan worden, waartegen het geblokkeerd proces meer plaats inneemt in de hoofdgeheugenruimte en niet uitgevoerd kan worden. Het kan toch nodig zijn om een gereedstaand proces op te schorten als dit de enige manier is om ruimte te maken voor een voldoende groot blok in het hoofgeheugen. Ook kan het besturingssysteem kiezen om een lager prioriteiten klaarstaand proces op te schorten in plaats van een hoger prioriteiten geblokkeerd proces als het denkt dat het geblokkeerd binnen korte tijd klaarstaat.
  • Diverse andere overgangen zijn het overwegen waard zoals volgende:

  • New -> Ready/Suspend en New -> Ready: Als een nieuw proces aangemaakt wordt kan het ofwel toegevoegd worden aan de Ready wachtrij ofwel Ready/Suspend wachtrij. In beide gevallen moet het besturingssysteem een proces control block aanmaken en geheugenruimte aan het proces toewijzen. Het verkiest de voorkeur om deze administratieve taken zo vroeg mogelijk te doen, zodat het een grote pool van niet geblokkeerde processen kan onderhouden. Met deze aanpak zou er vaak niet voldoende plaats meer zijn in het hoofdgeheugen voor nieuwe processen en daarom het gebruik van (New -> Ready/Suspend) overgang. Aan de andere kant kunnen we beargumenteren dat een just-in-time filosofie om processen zo laat mogelijk te creŽren de overheid van het besturingssysteem verminderd en toelaat dat het besturingssysteem de proces creatie taken uitvoert wanneer het systeem belemmerd raakt met geblokkeerde processen.
  • Blocked/Suspend -> Blocked: Het insluiten van deze overgang wordt gezien een slecht ontwerp. Wat is het nut om een proces dat niet klaar om uitgevoerd te worden en nog niet in het hoofdgeheugen zit naar hoofdgeheugen te verplaatsen. Maar beschouw het volgende: Een proces wordt beŽindigd en het maakt hoofdgeheugen vrij. Er is een proces in de Blocked/Suspend wachtrij met een hogere prioriteit dan enige van de processen in de Ready/Suspend wachtrij en het besturingssysteem heeft een reden om aan te namen dat de geblokkeerde gebeurtenis snel zal voorvallen. Onder deze omstandigheden lijkt het redelijk om een geblokkeerd proces in het hoofdgeheugen te zetten in plaats van een klaarstaand proces.
  • Running -> Ready/Suspend: Normaal gesproken zal een uitvoerend proces verplaatst worden naar de Ready status als zijn Tijdtoewijzing vervalt. Als het besturingssysteem beslag legt op proces omdat een hoger prioriteiten proces in de Blocked/Suspend wachtrij juist ontgrendeld raakt, dan kan het besturingssysteem het lopend proces direct verplaatsen naar de Ready/Suspend wachtrij verplaatsen en plaats vrijmaken in het hoofdgeheugen.
  • Iedere toestand -> Exit: Normaal gesproken zal een proces beŽindigen terwijl het uitvoerende is, ofwel omdat het voltooid is of omdat een of andere fout conditie is opgetreden. Hoewel in sommige besturingssystemen een proces beŽindigd kan worden door het proces dat het gecreŽerd heeft of wanneer het parent proces zelf beŽindigd is. Als dit toegestaan wordt dan kan een proces in eender welke toestand verplaatst worden naar de Exit toestand.
  • 3.2.4.2. Ander nut van opschorting

    Tot zo ver hebben we het concept van opgeschorte processen vergeleken met dat van een proces dat niet in het hoofdgeheugen zit. Een proces dat niet in het hoofdgeheugen zit is niet direct beschikbaar voor uitvoering of het wel of aan het wachten is op een gebeurtenis.

    We kunnen het concept van opgeschorte processen verder vorm geven. Laten we een opgeschort proces met de volgende eigenschappen definiŽren:

    1. Het proces is niet onmiddellijk beschikbaar voor uitvoering.
    2. Het proces kan maar hoeft niet wachtende te zijn op een gebeurtenis. Als het wachtend is, is deze geblokkeerde conditie onafhankelijk van de opgeschorte conditie en het voorval van de geblokkeerde gebeurtenis zal dat het proces niet onmiddellijk mogelijk maken op uitgevoerd te worden.
    3. Het proces was in een opgeschorte toestand geplaatst door een agent ofwel door zichzelf, een parent proces, het besturingssysteem met als doel om uitvoering te voorkomen.
    4. Het proces mag niet verwijderd worden uit deze toestand totdat de agent uitdrukkelijk order geeft om het te verwijderen.

    Onderstaande tabel somt een aantal redenen op voor opschorting van een proces. Een reden dat we besproken hebben is om geheugenruimte te voorzien door Ready/Suspended proces op te halen of om het geheugen te vergroten toegewezen aan andere Ready processen. Het besturingssysteem kan andere redenen hebben om een proces op te schorten. Bijvoorbeeld een audit- of traceerproces kan gebruikt worden om de activiteit van het systeem te monitoren; het proces kan gebruikt worden om de gebruik van diverse bronnen te meten (processor, geheugen, kanalen) en de snelheid van de vooruitgang van een gebruikersproces in het systeem. Het besturingssysteem, onder gebruikerscontrole, kan van tijd tot tijd dit proces in- en uitschakelen. Als het besturingssysteem een probleem vermoedt of detecteert kan het een proces opschorten. Een voorbeeld hiervan is een deadlock dat in latere hoofdstukken wordt behandeld. Een ander voorbeeld is een probleem op een communicatielijn en de gebruiker heeft het besturingssysteem het proces, die de lijn aan het gebruiken was, laten opschorten om enkele testen uit te voeren.

    Een andere aantal redenen heeft betrekking tot de acties van een individuele gebruiker. Bijvoorbeeld als een gebruiker een bug vermoed in een programma zou de gebruiker het programma willen debuggen door het programma op te schorten, het te onderzoeken en het programma of data aan te passen en weer verder te laten gaan met uitvoering.

    Timing overwegingen kunnen ook leiden tot discussie om een proces te wisselen. Bijvoorbeeld al een proces periodiek geactiveerd moet worden maar de meeste tijd inactief is dan zou het tussen de gebruiken uitgewisseld (swapped-out) moeten worden. Een programma dat het gebruik van de activiteit van een gebruiker controleert is een voorbeeld.

    Als laatste zou een parent proces wensen dat een onderliggend proces opgeschort wordt. Bijvoorbeeld, proces A creŽert proces B om een bestand te lezen. Vervolgens, proces B komt een probleem tegen met het lezen van dat bestand en rapporteert dat aan proces A. Proces A onderbreekt proces B om de oorzaak te onderzoeken.

    In al deze gevallen is de activatie van een opgeschort proces gevraagd door de agent die oorspronkelijk de opschorting heeft gevraagd.

    3.3. Beschrijving van een proces

    Het besturingssysteem stuurt de gebeurtenissen binnen het computer systeem. Het plant en dispatcht processen voor uitvoering door de processor, wijst bronnen toe aan processen en reageert op aanvragen van gebruikersprocessen voor basis diensten. Principieel kunnen we het besturingssysteem zien als een entiteit dat het door processen gebruik van systeembronnen beheert.

    Dit concept wordt geÔllustreerd aan de hand van onderstaande figuur. In een meervoudig programmeerbare omgeving zijn er tal van processen (P1 ... Pn) die gecreŽerd zijn en bestaan in het virtueel geheugen. Ieder proces, gedurende de duur van zijn uitvoering, heeft toegang nodig tot bepaalde systeembronnen, inclusief de processor, I/O apparaten en het hoofdgeheugen. In de figuur is proces P1 in uitvoering; op zijn minst een deel zit in het hoofdgeheugen en heeft controle over twee I/O apparaten. Proces P2 zit ook in het hoofdgeheugen, maar is geblokkeerd omdat het wachtend is op een door P1 toegewezen I/O apparaat. Proces Pn is uitgewisseld is daarom opgeschort.

    We verkennen de details van het beheer van deze bronnen door het besturingssysteem in later hoofdstukken. Nu zijn we geÔnteresseerd in een meer fundamentelere vraag: Welke informatie heeft het besturingssysteem nodig om de processen te besturen en om bronnen hiervoor te beheren.

    3.3.1. Besturingssysteem controle structuren

    Als het besturingssysteem het beheer moet doen van processen en bronnen, dan moet informatie hebben van huidige status van ieder proces en bron. De algemene aanpak om deze informatie te voorzien is simpel en duidelijk. Het besturingssysteem construeert en onderhoudt informatie in tabellen van iedere entiteit dat het beheert. Een algemene aanpak binnen het bereik van deze verrichting wordt geÔllustreerd in onderstaande afbeelding, welke de vier verschillende types van de door het besturingssysteem onderhouden tabellen toont. Hoewel de details tussen de besturingssystemen kunnen verschillen hanteren fundamenteel gezien alle besturingssystemen informatie uit deze vier categorieŽn.

    Geheugentabellen worden gebruikt om bij te houden van zowel hoofd- (echt) en secundair (virtueel) geheugen. Een gedeelte van het hoofdgeheugen is gereserveerd voor het gebruik door het besturingssysteem zelf en de rest is beschikbaar voor de processen. Processen worden onderhouden in het secundair geheugen gebruikmakend van een of andere manier van virtueel geheugen of eenvoudigweg door een wisselmechanisme (swapping). De geheugentabellen moeten de volgende informatie bevatten:

  • De toewijzing van hoofdgeheugen aan de processen
  • De toewijzing van secundair geheugen aan processen
  • Elke beveiligingsattribuut van hoofd- of virtuele geheugenblokken, zoals in welke processen toegang kunnen krijgen tot bepaalde gedeelde geheugengebieden
  • Iedere informatie benodigd voor het beheer van virtueel geheugen
  • I/O Tabellen worden door het besturingssysteem gebruikt om I/O apparaten en kanalen van het computersysteem te beheren. Op een gegeven moment kan een I/O apparaat beschikbaar of toegewezen worden aan een specifiek proces. Als een I/O operatie vooruitgaat, moet het besturingssysteem de status en plaats in het geheugen als bron of bestemming hiervan weten.

    Bestandstabellen kunnen ook door het besturingssysteem worden geregeld. Deze tabellen voorzien in informatie over het bestaan van bestanden, hun locatie in het secundair geheugen, hun actuele status en andere attributen. De meeste, zo niet alle informatie kan onderhouden en gebruikt worden door het bestandsbeheersysteem, waarin het besturingssysteem geen of nauwelijks kennis van bestanden heeft. In andere besturingssystemen wordt het meeste van het bestandsbeheer gedaan door het besturingssysteem zelf.

    Procestabellen worden door de besturingssystemen onderhouden om processen te beheren. Het resterende van deze sectie wordt besteed aan het onderzoeken van de noodzakelijke procestabellen. Voordat we verder gaan moeten twee extra punten worden duidelijk gemaakt.

    Ten eerste, ondanks dat onderstaande figuur vier afzonderlijke groepen van tabellen laat zien moet het duidelijk zijn dat deze tabellen op een af andere manier verbonden of verwezen moeten worden. Geheugen, I/O en bestanden worden beheerd ten behoeve van processen. In de procestabellen moet er dus enige referentie zijn naar deze bronnen, direct of indirect. De bestanden waarnaar verwezen wordt in de bestandstabellen zijn toegankelijk via een I/O apparaat en zal op sommige momenten in het hoofd- of secundair geheugen zitten. De tabellen zelf moeten voor het besturingssysteem zelf toegankelijk zijn en daardoor onderworpen zijn aan het geheugenbeheer.

    Ten tweede, hoe kan het besturingssysteem in de eerste plaats weten om de tabellen aan te maken? Het is duidelijk dat het besturingssysteem enige kennis moet hebben van de basis omgeving, zoals hoeveel hoofdgeheugen er is, wat de I/O apparaten zijn en wat hun identificatie is en zo verder. Dit is een zaak van configuratie. Dat wil zeggen, dat wanneer een besturingssysteem wordt geÔnitialiseerd, toegang moet hebben tot sommige configuratiedata dat de basisomgeving definieert en deze data moet buiten het besturingssysteem gecreŽerd zijn met behulp van menselijke tussenkomst of een vorm van autoconfiguratie software.

    3.3.2. Proces controle structuren

    Beschouw wat een besturingssysteem moet weten om een proces te beheren en te sturen. Het proces moet eerst weten waar het zich bevind en ten tweede moet het de attributen van het proces kennen die nodig zijn voor zijn beheer (bv. process ID en proces toestand).

    3.3.2.1. Proceslocatie

    Voordat we de vragen kunnen behandelen van waar een proces zich bevindt moeten we een meer fundamentelere vraag stellen: Wat is de fysieke uiting van een proces? Op zijn minst moet een proces een programma een stel programma's bevatten die uitgevoerd moeten worden. Bij deze programma's hoort een set van data locaties voor lokale en globale variabelen en eender welke gedefinieerde constanten. Dus een proces bestaat op zijn minst uit voldoende geheugen om het programma en de data van dat proces te bevatten. Bovendien brengt de uitvoer van een programma een stack met zich mee dat gebruikt wordt om procedure oproepen en doorgifte van parameters tussen procedures te volgen. Uiteindelijk heeft ieder proces zich verenigd met een aantal attributen dat gebruikt zijn door het besturingssysteem voor procesbeheer. Typisch zijn wordt de collectie van attributen gerefereerd als een proces control block. We kunnen naar deze collectie van programma's, data, stack en attributen refereren als de process image (Tabel 3.4).

    De locatie van het proces beeld zal bepaald worden door het geheugenbeheerschema dat wordt gebruikt. In het eenvoudigst geval, het proces beeld wordt beheerd als een opeenvolgend of ononderbroken geheugenblok. Dit blok wordt onderhouden in het secundair geheugen, meestal disk. Zodat het besturingssysteem het proces kan beheren, op zijn minst een klein deel van zijn beeld moet in het hoofdgeheugen worden beheerd. Om het proces uit te voeren moet het volledige proces beeld geladen worden in het hoofdgeheugen of op zijn minst het virtueel geheugen. Dus het besturingssysteem moet de locatie van ieder proces op disk weten en voor ieder proces dat in het hoofdgeheugen zit. Een besturingssysteem moet dus bijhouden welke delen van het beeld van elk proces nog in het hoofdgeheugen zit.

    Figuur 3.11 toont de structuur van locatie informatie op de volgende manier. Er is een primaire procestabel met ťťn ingang voor ieder proces. Iedere ingang bevat op zijn minst een pointer naar een proces beeld. Als het proces beeld meerdere blokken bevat zal deze informatie direct in de primaire proces tabel zitten of via kruisverwijzingen naar ingangen in geheugentabellen. Natuurlijk is dit een veralgemeende schets; een specifiek besturingssysteem zal zijn eigen manier van locatie informatie beheer hebben.

    3.3.2.2. Procesattributen

    Een gesofisticeerd meervoudig programmeerbaar systeem vergt veel informatie van ieder proces. Zoals uitgelegd was, kan beschouwd worden dat deze informatie bevat zit in een process control block. Verschillende systemen zullen deze informatie op elk hun eigen manier organiseren en een aantal zal je later in dit en het volgende hoofdstuk tegenkomen. Nu zullen we enkel het type informatie behandelen dat gebruikt kan worden door een besturingssysteem zonder in detail na te denken hoe die informatie tot stand komt.

    Tabel 4.5 somt de typerende categorieŽn van informatie op die het besturingssysteem nodig heeft voor ieder proces. Men kan enigszins verbaasd zijn met de hoeveelheid benodigde informatie. Als men steeds meer en meer bewust wordt van de verantwoordelijkheden van een besturingssysteem zal de deze lijst steeds redelijker blijken.

    We kunnen de process control block informatie in drie algemene categorieŽn groeperen:

  • Proces identificatie
  • Processor status informatie
  • Proces controle informatie.
  • Met respect tot proces identificatie, in vrijwel alle besturingssystemen is iedere toegewezen aan een unieke numerieke identificatie, welk eenvoudigweg een index kan zijn in de primaire proces tabel (Figuur 3.11); anders moet er een toewijzing (mapping) zijn dat het besturingssysteem toestaat om de op de proces-identificatie gebaseerde bijbehorende tabellen op te zoeken. Deze identificatie is op verschillende manieren bruikbaar. Veel van de andere door het besturingssysteem gecontroleerde tabellen kunnen proces-identificaties gebruiken om naar procestabellen te verwijzen. Bijvoorbeeld, de geheugentabellen kunnen zo georganiseerd zijn om een map van het hoofdgeheugen te leveren met een identicatie van welk aan ieder regio, het proces is toegewezen. Gelijkaardige referenties zullen er ook zijn in I/O en bestandstabellen. Als processen met elkaar communiceren, informeert de proces-identificatie het besturingssysteem met de bestemming van een specifieke communicatie. Als processen zijn toegestaan om andere processen te creŽren, wijzen de identificaties naar de ouder en afstammelingen van ieder proces.

    Bovenop deze proces-identificaties kan een proces aan een gebruikers-identificatie worden toegewezen die de gebruikersverantwoordelijkheid aangeeft voor de job.

    Processor status informatie bestaat uit de inhoud van de processor registers. Terwijl een proces in uitvoering zit deze informatie natuurlijk in de registers. Als een proces wordt onderbroken moet al deze informatie in de registers bewaard worden, zodat deze hersteld kunnen worden als het proces verder gaat met uitvoering. Het type en aantal betrokken registers hangt af van het ontwerp van de processor. Gebruikelijk zal de register set de gebruikerszichtbare-, controle-, statusregisters en stack pointers bevatten. Deze zijn allemaal in hoofdstuk 1 beschreven.

    Opmerkelijk is dat alle processorontwerpen een register of een set van registers bevatten gekend als het programmastatuswoord (PSW), dat de toestand informatie bevat. Het PSW bevat de conditiecodes plus andere status informatie. Een goed voorbeeld van een processor status woord is dat van een Intel x86 processor, gerefereerd door het EFLAGS register (zie afbeelding 3.12 en tabel 3.6). Deze structuur wordt gebruikt eender welk besturingssysteem lopend op een x86 processor (inclusief UNIX en Windows).

    De derde belangrijkste informatiecategorie van informatie in het procescontroleblok kan beter de process control information genoemd worden. Dit is extra door het besturingssysteem benodigde informatie om diverse actieve processen te besturen en coŲrdineren. Het laatste stuk van tabel 3.5 geeft dit deel van informatie weer. Als we de details van de functionaliteit van een besturingssysteem uit voorgaande hoofdstukken in detail bekijken wordt het nut van de diverse items op deze lijst duidelijk.

    Figuur 3.13 suggereert de structuur van procesbeelden in het virtueel geheugen. Ieder procesbeeld bevat een procescontroleblok, een gebruikersstack, de privťadresruimte van het proces en ieder ander geheugengebied dat het proces met andere processen deelt. In de afbeelding wordt ieder proces getoond als een opeenvolgend bereik van adressen. In een werkelijke implementatie hoeft dit niet noodzakelijkerwijs het geval te zijn en zal dat afhangen van het geheugenbeheerschema en de manier waarop controlestructuren door het besturingssysteem wordt georganiseerd.

    Zoals aangetoond in tabel 4.5 kan het procescontroleblok structuurinformatie bevatten, inclusief pointers die het schakelen van procescontroleblokken toestaat. De wachtrijen die in de voorgaande sectie is beschreven kan worden geÔmplementeerd als een geschakelde lijst van procescontroleblokken. Bijvoorbeeld de structuur van de wachtrij uit afbeelding 3.8a kan geÔmplementeerd worden als voorgesteld in figuur 3.14.

    3.3.2.3. Rol van het procescontroleblok

    Het procescontroleblok is de meest belangrijke datastructuur van een besturingssysteem. Ieder procescontroleblok bevat alle informatie van een proces dat benodigd is door een besturingssysteem. De blokken worden door nagenoeg iedere module van het besturingssysteem gelezen en/of aangepast, ook deze betrokken met planning, brontoewijzing, interruptverwerking, controle en analyse van de prestatie. Men kan zeggen dat de set procescontroleblokken de status van het besturingssysteem bepaald.

    Dit brengt een belangrijke ontwerpkwestie naar voren. Een aantal routines binnen het besturingssysteem hebben toegang nodig tot informatie in de procescontroleblokken. De voorziening van directe toegang tot deze tabellen is niet moeilijk. Ieder proces wordt uitgerust met een unieke ID en deze kan gebruikt worden als een index binnen tabel van pointers naar de procescontroleblokken. De moeilijkheid is niet de toegang, maar de beveiliging. Twee problemen manifesteren van zichzelf:

  • Een fout in een enkele routine, zoals een interrupt handler kan het procescontroleblok beschadigen welke de mogelijkheid van het systeem om de aangetaste processen te beheren aantast.
  • Een ontwerpverandering in de structuur of semantiek van het procescontroleblok kan een aantal modules in het besturingssysteem aantasten.
  • Deze problemen kunnen worden aangepakt door alle benodigde routines van het besturingssysteem door een handler routine te laten gaan, welke de enkele taak heeft om procescontroleblokken te beschermen en welk de enige autoriteit is om deze blokken te lezen en te schrijven. De afweging van zulks een routine is de prestatiekwestie en de mate waarin de rest van de systeemsoftware kan vertrouwd juist te zijn.

    3.4. Procesbeheer

    3.4.1. Modus van uitvoering

    Voordat we verder gaan met hoe een besturingssysteem processen beheert, moeten we een onderscheiding maken tussen de uitvoermodus die normaal behoort tot het besturingssysteem en die normaal behoort tot gebruikersprogramma's. De meeste processors ondersteunen op zijn minst twee uitvoermodi. Bepaalde instructies kunnen enkel uitgevoerd worden in de meer bevoorrechte modi. Deze zou het lezen of bewerken van een control register, zoals het programmastatuswoord; primitieve I/O instructies; en gerelateerde geheugenbeheer instructies kunnen bevatten. Bepaalde geheugengebieden kunnen enkel benaderd worden in de verhoogde bevoorrechte modus.

    De minder bevoorrechte modus heeft vaak betrekking op de system mode, control mode of kernel mode. De laatste term heeft betrekking op de kern van het besturingssysteem, dat deel van het besturingssysteem dat de meest belangrijke systeemfuncties bevat. Tabel 3.7 lijst de functies op die typisch in de kern van een besturingssysteem zitten.

    De reden om twee modi te gebruiken is duidelijk. Het is nodig om het besturingssysteem en hoofdbesturingssysteemtabellen zoals procescontroleblokken te beschermen tegen interferentie van gebruikersprogramma's. In de kernel mode heeft de software volledige controle over de processor en alle instructies, registers en geheugen. Dit niveau van controle is niet noodzakelijk en voor de veiligheid is dit niet gewenst voor gebruikersprogramma's.

    Twee vragen komen boven: Hoe kan de processor weten in welke modus hij aan het uitvoeren is en hoe de modus veranderd is? Kijkend naar de eerste vraag zit er normaal een bit in het programmastatuswoord (PSW) dat de modus van uitvoering aangeeft. Deze bit wordt gewijzigd aan de hand van bepaalde gebeurtenissen. Meestal wanneer een gebruiker een oproep doet aan een service van het besturingssysteem of wanneer een interrupt de uitvoer van besturingssysteemroutine activeert, wordt de modus op kernel modus gezet en bij het terugkeren van de service naar het gebruikersproces wordt de modus weer op gebruikersmodus gezet.

    3.4.2. Aanmaak van een proces

    In sectie 3.2 hebben we de gebeurtenissen besproken die leiden tot aanmaak van een nieuw proces. We hebben de tot een proces behorende datastructuren besproken en we gaan nu kort de stappen beschrijven die betrokken zijn in de aanmaak van het proces.

    Eens het besturingssysteem bepaalt voor welke reden (tabel 3.1) een nieuw proces wordt aangemaakt kan het voortgaan als volgt:

    1. Wijs een unieke proces identificatie toe aan een nieuw proces. Op dit moment is een nieuwe ingang toegevoegd aan de primaire procestabel, welk ťťn ingang per proces bevat.
    2. Wijs plaats toe aan het proces. Dit bevat alle elementen van het procesbeeld. Het besturingssysteem moet weten hoeveel plaats benodigd is voor privť gebruikers-adresruimte (programma's en data) en de gebruikersstack. Deze waarden van kunnen standaard op het type of proces toegewezen worden of ze kunnen gemaakt worden op basis van de aanvraag van een gebruiker tijdens het moment dat de job aangemaakt wordt. Als een proces door een ander proces geÔnitieerd is kan het ouder proces de benodigde waarden doorgeven aan het besturingssysteem als deel van de proces-aanmaak aanvraag. Als een of andere adresruimte gedeeld moet worden door dit nieuwe proces moeten de bijbehorende schakels opgezet worden. Uiteindelijk moet de ruimte voor procescontroleblok toegewezen worden.
    3. Initialiseer het procescontroleblok. Het proces identificatie gedeelte bevat de het ID van dit proces plus andere bijbehorende Id's zoals dat van het parent proces. De processorstatus informatie wordt typisch geÔnitialiseerd met de meeste ingangen op nul behalve voor de programmateller (gezet op het programma-ingangspunt) en systeem stack pointers (gezet om de proces stack grenzen te bepalen). Het procescontrole informatie gedeelte is geÔnitialiseerd op basis van standaard waarden plus attributen die gevraagd zijn voor dit proces. Bijvoorbeeld, de processtatus wordt typisch geÔnitialiseerd naar Ready of Ready/Suspend. De prioriteit kan standaard gezet worden naar de laagste prioriteit tenzij een expliciete vraag is gemaakt voor een hogere prioriteit. Initieel mag het proces geen bronnen bezitten tenzij er een expliciete vraag is voor deze of tenzij ze overgeŽrfd zijn van de parent.
    4. Stel de geschikte koppelingen in. Bijvoorbeeld al het besturingssysteem iedere planningswachtrij onderhoud als een gekoppelde lijst, dat moet het nieuw proces in de Ready of Ready/Suspend lijst geplaatst worden.
    5. CreŽer of breit bestaande datastructuren uit. Bijvoorbeeld, het besturingssysteem kan een boekhoudkundig onderhouden over ieder proces dat vervolgens gebruikt wordt voor facturering en/of prestatie inschattingsdoeleinden.

    3.4.3. Processchakeling

    Op het eerste zicht zou de functie van processchakeling rechttoe rechtaan lijken. Op een gegeven moment wordt is een proces onderbroken en wijst het besturingssysteem een ander proces toe aan de Running status en geeft het controle door naar dat proces. Hoewel verschillende ontwerpkwesties zijn gerezen. Eerst, welke gebeurtenis initieert een proceswisseling? Een andere zaak is dat we het onderscheid moeten kennen tussen modi-wisseling en proces-wisseling. En wat moet het besturingssysteem als laatste doen met de diverse datastructuren onder zijn beheer om een proceswisseling te initiŽren?

    3.4.3.1. Wanneer van proces verwisselen

    Een proceswisseling kan op ieder moment gebeuren wanneer het besturingssysteem controle heeft gekregen van huidig uitvoerend proces. Tabel 3.8 wijst op de mogelijke gebeurtenissen dat controle kan overdragen naar het besturingssysteem.

    Laten we eerst de systeem interrupties bekijken. We kunnen, zoals veel systemen doen, twee vormen van systeem interrupties onderscheiden, ťťn die eenvoudigweg gezien kan worden als een interruptie en de ander als een val (trap). De eerste is het gevolg van een of andere gebeurtenis extern en onafhankelijk van het huidig uitvoerend proces, zoals de voltooiing van een I/O bewerking. De tweede is het gevolg van een fout of uitzonderingsconditie die binnen het huidig uitvoerend proces wordt gegenereerd, zoals een poging tot een ongeldige bestandstoegang. Met een gewone interruptie wordt eerst de controle overgedragen naar de interrupt handler, welk enkele huishoudtaken uitvoert en dan aftakt naar een besturingssysteemroutine dat verwikkeld is met deze specifieke interruptie die is gebeurd.

    Klok interrupt: Het besturingssysteem bepaald of het huidig uitvoerend proces voor de maximaal toegestane tijd uitgevoerd is geweest, bepaald als een time slice. Een time slice is de maximum tijd dat een proces kan uitvoeren voordat het wordt onderbroken. Het proces moet geschakeld worden naar de Ready status en een ander proces moet opgevoerd worden.

    I/O interrupt: Het besturingssysteem bepaald welke I/O actie is gebeurd. Als de I/O actie een gebeurtenis bevat voor welk ťťn of meer processen aan het wachten zijn dan zal het besturingssysteem alle corresponderende geblokkeerde processen verplaatsen naar de Ready toestand (en Blocked/Suspend processen naar de Ready/Suspend toestand). Het besturingssysteem moet beslissen of het verder zal gaan met uitvoering met het huidig proces in de Running toestand of beslag legt op een hoger-prioriteiten Ready proces.

    Geheugenfout: De processor komt een referentie tegen van een virtueel geheugenadres voor een woord dat zich niet in het hoofdgeheugen bevindt. Het besturingssysteem moet dit blok (pagina of segment) van geheugen ophalen die de referentie bevat van het secundair geheugen naar hoofdgeheugen. Nadat de I/O bewerking uitgegeven is om het geheugenblok over te brengen, wordt het proces met de geheugenfout in de Blocked toestand geplaatst; het besturingssysteem voert een proceswissel uit om verder te gaan met de uitvoer van een ander proces. Nadat het gewenste blok in het hoofdgeheugen is geplaatst zal dat proces in de Ready toestand worden gezet.

    Met een val (trap) zal het besturingssysteem bepalen of de fout of uitzonderingsconditie fataal is. Zo ja, dan zal het huidig uitvoerend proces verplaatst worden naar de Exit toestand en een proceswissel zal gebeuren. Zo niet, dan zal de actie van het besturingssysteem afhangen van de aard van de fout en het ontwerp van het besturingssysteem. Het kan sommige herstelprocedures proberen of eenvoudigweg de gebruiker informeren. Het kan een proceswissel doen of verder gaan met het huidig uitvoerend proces.

    Als laatste kan vanuit een uitvoerend programma een besturingssysteem geactiveerd worden door een supervisor oproep. Bijvoorbeeld, een gebruikersproces is uitvoerende en een instructie is uitgevoerd een I/O aanvraagt, zoals om een bestand te openen. Deze oproep kan resulteren in een overdracht naar een routine dat deel uitmaakt van de besturingssysteemcode. Het gebruik van een systeemoproep kan er voor zorgen dat een proces in de Blocked toestand wordt geplaatst.

    3.4.3.2. Moduswissel

    In hoofdstuk 1 hebben de insluiting van een interruptie besproken als deel van de instructiecyclus. Herinner dat in de interruptiefase de processor controleert of er interrupties hangende zijn door middel van de aanwezigheid van een interrupt signaal. Als er geen interrupties hangende zijn zal de processor verder gaan met naar de fetch stage en de volgende instructie van het huidig programma van het huidig proces ophalen. Als er een interruptie hangend is zal de processor het volgende doen:

    1. Het zet de programmateller op het startadres van de interrupt handler programma.
    2. Het schakelt over van gebruikersmodus naar kernelmodus zodat de interrupt-verwerkende code ook bevoorrechte code kan bevatten.

    De processor zal nu verder gaan naar de fetch stage en zal de eerste instructie van de interrupt handler ophalen welke de interruptie bedient. Op dit punt wordt de context van het proces dat onderbroken is bewaard in de procescontroleblok van het onderbroken programma.

    Een vraag zou kunnen opkomen is: wat de context bevat dat bewaard is? Het antwoord is dat het elke informatie moet bevatten dat veranderd kan worden door de uitvoering van de interrupt handler en dat benodigd is om verder te gaan met het programma dat onderbroken is. Een deel van het procescontroleblok waar gerefereerd was als processorstatusinformatie moet worden opgeslagen. Dit moet de programmateller, andere processorregisters en stack informatie bevatten.

    Moet er nog iets anders worden gedaan? Dat hangt af van wat er vervolgens gebeurd. De interrupt handler is een typisch kort programma dat een paar aan het interrupt gerelateerde basistaken uitvoert. Bijvoorbeeld stelt het de markering of indicator terug in dat de aanwezigheid van de interrupt signaleert. Het kan ook bevestiging naar de entiteit zenden die de interrupt heeft geÔnitieerd, zoals een I/O module. En het kan ook enkel basis huishoudtaken met betrekking tot de aard van interrupt uitvoeren. Bijvoorbeeld als de interrupt betrekking heeft op een I/O gebeurtenis, zal de interrupt handler kijken naar een fout conditie. Als er een fout gebeurd kan de interrupt handler een signaal naar het proces sturen die deze I/O operatie oorspronkelijk heeft aangevraagd. Als de interrupt gekomen door de klok dan zal de handler de controle overgeven aan de dispatcher, welke de controle wil overgeven aan een ander proces omdat de time slice tot het huidig toegewezen uitvoerend proces is verstreken.

    Wat met de andere informatie in het procescontroleblok? Als deze interrupt gevolgd wordt door een wissel naar een ander proces dan moet er enig werk gebeuren. Alhoewel in de meeste besturingssystemen niet noodzakelijkerwijs betekend dat een interruptie betekent dat er van proces moet worden gewisseld. Het is mogelijk nadat de interrupt handler uitgevoerd is het huidig uitvoerend proces verder gaan met uitvoering. In dat geval alles wat nodig was om de processorstatusinformatie te bewaren op het moment dat de interruptie plaats vond en die informatie hersteld wordt als de controle terug overgedragen wordt aan het programma dat in uitvoering was. Normaal gesproken zal de opslag en herstel op hardware niveau gebeuren.

    3.4.3.3. Verandering van de procestoestand

    Het is duidelijk dat de moduswisssel een verschillend concept is dan dat van een proceswissel. Een moduswissel kan gebeuren zonder de status van het proces te veranderen dat op dat momenteel in de Running toestand staat. In dat geval, de context opslag en opeenvolgend herstel gaat gepaard met een kleine overhead. Echter als het huidig uitvoerend proces veranderd moet worden naar een andere toestand (Ready, Blocked, etc.) dan zal het besturingssysteem aanmerkelijke veranderingen moet maken aan zijn omgeving. De stappen met betrekking tot een volledig proces zijn als volgt:

    1. Bewaar de context van de processor, inclusief programmateller en andere registers.
    2. Werk het procescontroleblok bij van het proces dat momenteel in de Running toestand bevindt. Dit bevat ook het veranderen van de toestand van het proces naar een van de andere toestanden (Ready; Blocked; Ready/Suspend; of Exit). Andere relevante velden moeten ook worden bijgewerkt inclusief de reden van het verlaten van de Running toestand en boekhoudkundige informatie.
    3. Verplaats het procescontroleblok van dit proces naar de geschikte wachtrij (Ready; Blocked door gebeurtenis i; Ready/Suspend).
    4. Kies een volgende proces voor uitvoering.
    5. Werk het procescontroleblok bij van het geselecteerde proces. Dit inclusief het veranderen van de toestand van het proces naar Running.
    6. Werk de geheugenbeheer datastructuren bij. Dit kan vereist zijn, afhankelijk van hoe de adresvertaling beheerd wordt.
    7. Herstel de context van de processor naar datgene welk bestond op het moment dat het geselecteerde proces uitgewisseld was van de Running toestand, door de voorgaande waarden van de programmateller en andere registers te laden.

    Een proceswissel gaat dat gepaard gaat met een toestandsverandering vereist dus meer moeite dan een moduswissel.

    3.5. Uitvoering van het besturingssysteem

    In hoofdstuk 2 hebben we gewezen op twee boeiende feiten van besturingssystemen:

    Het besturingssysteem functioneert op precies dezelfde manier als een normaal computerprogramma met die zin dat het besturingssysteem een set van programma's is dat uitgevoerd wordt door de processor.

    Het besturingssysteem doet regelmatig afstand van controle en hangt af van de processor om de controle terug over te dragen aan het besturingssysteem.

    Als het besturingssysteem een collectie van programma's is en net als ieder ander programma uitgevoerd wordt door de processor is het besturingssysteem dan niet een proces? En als het zo is, hoe wordt het dan bestuurt? Deze interessante vragen hebben een gezorgd voor een aantal benaderingen van het ontwerp. Figuur 3.15 laat een reeks aanpakken zien die in hedendaagse besturingssystemen zijn gevonden.

    3.5.1. Niet-proces kernel

    Een traditionele aanpak, gevonden in veel oudere besturingssystemen is om de kern van het besturingssysteem buiten de processen uit te voeren (Afbeelding 3.15a). Met deze aanpak, wanneer het huidig uitvoerend proces wordt onderbroken of een supervisor oproep uitgeeft, de modus context van dit proces wordt bewaard en controle wordt overgedragen aan de kern van het besturingssysteem. Het besturingssysteem heeft zijn eigen geheugengebied en zijn eigen systeem stack om procedure oproepen en terugkeer te regelen. Het besturingssysteem kan iedere gewenste functie uitvoeren en de context van het onderbroken proces herstellen, welk resulteert in de hervatting van het onderbroken gebruikersproces. Als alternatief kan het besturingssysteem de functie voltooien door de omgeving van het proces te bewaren en verder gaan met plannen en een ander proces uitzenden. Of dit gebeurd hangt af van de reden van interruptie en de omstandigheden op dat moment.

    In elk geval, het punt dat hier wordt gemaakt is dat het concept van verwerking is beschouwd enkel van toepassing te zijn op gebruikersprogramma's. De besturingssysteemcode is uitgevoerd als een aparte entiteit dat werkt in bevoorrechte modus.

    3.5.2. Uitvoering binnen gebruikersproces

    Een alternatief dat gebruikelijker is in besturingssystemen op kleinere computers (PC's, werkstations) is om vrijwel alle besturingssysteem software uit te voeren in de context van een gebruikersproces. Het standpunt is dat het besturingssysteem hoofdzakelijk een collectie van routines is dat de gebruiker oproept om diverse functies uit te voeren binnen de omgeving van het gebruikersproces. Dit wordt getoond in afbeelding 3.15b. Op een gegeven moment is het besturingssysteem n procesbeelden aan het beheren. Ieder beeld bevat niet alleen de gebieden geÔllustreerd in afbeelding 3.13 maar ook programma-, data- en stackgebieden voor kernprogramma's.

    Afbeelding 3.16 geeft een typische structuur voor een procesbeeld weer voor deze strategie. Een aparte kernel stack wordt gebruikt voor het beheer van oproepen en wederkeringen terwijl het proces in kern modus zit.

    Besturingssysteemcode en data zitten in de gedeelde adresruimte en zijn gedeeld door alle gebruikersprocessen.

    Als een interruptie, val(trap) of supervisor oproep gebeurd wordt de processor in kernel modus geplaatst en de controle overgedragen aan het besturingssysteem. Om de controle over te dragen van een gebruikersprogramma naar het besturingssysteem wordt de context bewaard en een moduswissel neemt plaats naar een besturingssysteemroutine. Echter uitvoering gaat verder binnen het gebruikersproces. Er gebeurt dus geen proceswissel enkel een moduswissel binnen hetzelfde proces.

    Als het besturingssysteem bij voltooiing van zijn werk bepaalt dat het huidig proces verder zou moeten gaan met uitvoering dan zal een moduswissel het onderbroken programma verder zetten binnen het huidig proces. Dit is een van de belangrijkste voordelen van deze aanpak: Een gebruikersprogramma dat onderbroken wordt om een of andere besturingssysteemroutine uit te laten voeren, en dan verder zal gaan en al dit gebeurd zonder het nadeel van twee proceswissels. Als het echter bepaald is dat een proceswissel moet gebeuren in plaats van verder te gaan met het vorig programma in uitvoering dan zal de besturing doorgegeven worden aan een proceswissel routine. Deze routine kan of kan niet in het huidig proces uitgevoerd worden afhankelijk voor het gekozen systeemontwerp. Echter op een gegeven moment zal het huidig proces in een niet-uitvoerende toestand moeten worden gezet en een ander proces aangewezen moeten worden als het uitvoerend proces. Tijdens deze fase is het meest logisch gezien het meest gemakkelijk om de uitvoering te zien om plaats te nemen buiten alle processen.

    In een bepaalde manier is deze manier van het besturingssysteem opmerkelijk. Simpelweg gezegd, op bepaalde punten in tijd zal een proces zijn status informatie opslaan een ander proces kiezen om uit te voeren vanuit diegene die klaarstaan en besturing overdragen aan dat proces. De reden dat dit niet een willekeurige en inderdaad chaotische situatie is dat tijdens de kritische tijd, de code die uitgevoerd wordt in het gebruikersproces gedeeld is met besturingssysteemcode en niet gebruikerscode. Door dit concept van gebruikersmodus en kernelmodus kan de gebruiker niet interfereren of onrechtmatig de besturingssysteemroutines wijzigen, zelfs al als ze uitgevoerd worden binnen de gebruikersprocesomgeving. Dit zal ons verder laten herinneren dat er een verschil is tussen het concept van proces en het concept van programma en dat de relatie tussen beide niet ťťn-op-ťťn is. Binnen een proces kan zowel een gebruikersprogramma en besturingssysteemprogramma's worden uitgevoerd en het besturingssysteemprogramma dat uitgevoerd wordt in verschillende gebruikersprocessen zijn identiek.

    3.5.3. Proces gebaseerd besturingssysteem

    Een ander alternatief, geÔllustreerd in afbeelding 3.15c, is om het besturingssysteem te implementeren als een collectie van systeemprocessen. Als in de andere opties, de software dat deel is van de kernel wordt uitgevoerd in de kernel modus. Echter in dit geval zijn de belangrijkste kernel functies als afzonderlijke processen georganiseerd. Alweer kunnen er een klein aantal proceswisselcode worden uitgevoerd buiten ťťn of ander proces.

    Deze aanpak heeft een aantal voordelen. Het legt een programma ontwerpdiscipline op dat het gebruik van een modulair besturingssysteem aanmoedigt met minimale, zuivere interfaces tussen de modules. Enkele niet kritieke functies van het besturingssysteem zullen voor het gemak geÔmplementeerd worden als aparte processen. Bijvoorbeeld, we hebben al eerder een monitor programma vermeld dat het gebruik opneemt van diverse bronnen (processor, memory, kanalen) en de schatting van de voorruitgang van het gebruikersproces in het systeem. Omdat dit programma niet voorziet in een specifieke dienst tot een of ander proces kan het enkel aangeroepen worden door het besturingssysteem. Als proces kan de functie uitgevoerd worden met een toegewezen prioriteitsniveau en tussengeschoven worden met andere processen onder de dispatcher controle. Uiteindelijk het besturingssysteem implementeren als een set van processen is handig in een multiprocessor of Multi computer omgeving, waarin sommige besturingssysteem services uitgezonden kan worden naar toegewezen processoren om de prestaties te verbeteren.

    3.6. Beveiligingskwesties

    Een besturingssysteem koppelt een set van privileges aan ieder proces. Deze privileges bepalen tot welke systeembronnen (inclusief geheugengebieden, bestanden, bevoorrechte systeeminstructies) het proces toegang krijgt en zo verder. Een proces dat uitgevoerd wordt namens een gebruiker met de privileges dat het besturingssysteem herkend als die voor een gebruiker. Een systeem- of een hulpproces kan privileges hebben die toegewezen zijn op het moment van configuratie.

    Op een typisch systeem, is het hoogste niveau van privilege verwezen naar die van administrator, supervisor of root toegang. Root toegang voorziet toegang tot alle functies en diensten van het besturingssysteem. Met root toegang heeft een proces volledige controle over het systeem en kan het programma en bestanden toevoegen en wijzigen, andere processen bewaken, netwerkverkeer afluisteren of verzenden en privileges veranderen.

    Een sleutel ontwerp in de veiligheid van het ontwerp van een besturingssysteem is om te voorkomen of op zijn minst te ontdekken als een gebruiker of stuk kwaadaardige software (malware) probeert om niet geautoriseerde privileges te krijgen tot het systeem en in het bijzonder root toegang. In deze sectie sommen we kort dreigingen en tegenmaatregelen op met betrekking tot deze veiligheidskwestie.

    3.6.1. Dreigingen van systeemtoegang

    Dreigingen met betrekking tot systeemtoegang kunnen worden ondergebracht in twee categorieŽn: indringers en kwaadaardige software.

    3.6.1.1. Indringers

    Een van de meest algemeen voorkomende dreigingen in beveiliging is de indringer (de ander zijn de virussen), vaak bedoeld als een hacker of cracker. In een vroegere belangrijke studie van indringing zijn er drie klassen van indringing geÔdentificeerd:

  • Vermommer: Een individu die niet geautoriseerd is de computer te gebruiken en die de systeem toegangscontrole binnendringt door misbruik te maken van een legitieme gebruikersaccount.
  • Uitbuiter: Een legitieme gebruiker die toegang heeft tot data, programma's of bronnen waarvoor het geen autorisatie heeft of wie geautoriseerd is voor zulke toegang maar zijn of haar privileges misbruikt.
  • Geheime gebruiker: Een individueel die supervisor toegang tot het systeem verkrijgt en deze controle gebruikt om toegangscontrole te ontwijken of om controle te onderdrukken.
  • De vermommer is waarschijnlijk een buitenstaander; de uitbuiter in het algemeen een insider; en de geheime gebruiker kan zowel een buitenstaander als insider zijn.

    Indringingsaanvallen kunnen gaan van goedaardig tot kwaadaardig. De minst erge zijn diegene die het internet willen verkennen en kijken wat mogelijk is. De ergere zijn diegene die proberen bestanden met een hogere privilege te lezen, niet-geautoriseerde aanpassingen te doen aan data en om het systeem te ontregelen.

    Het doel van de indringer is om toegang te verschaffen tot het systeem of om bereik van toegankelijke privileges te verhogen op het systeem. De meeste initiŽle aanvallen gebruiken systeem of software kwetsbaarheden dat een gebruiker toestaat code te laten uitvoeren dat een achterdeur in het systeem opent. Indringers kunnen dergelijke toegang krijgen tot het systeem door het uitbuiten van aanvallen als buffer overflow attacks.

    In de plaats van kan een indringer ook proberen informatie te vergaren dat beveiligd had moeten zijn. In sommige gevallen zit deze informatie in de vorm van een gebruikerswachtwoord. Met de kennis van iemand zijn wachtwoord kan een indringer in het systeem inloggen en alle privileges behorende tot deze gebruiker te benutten.

    3.6.1.2. Kwaadaardige software

    Wellicht zijn de meest gesofisticeerde typen van dreigingen in computersystemen gepresenteerd door programma's dat deze kwetsbaarheden in computersystemen uitbuit. Zulke dreigingen hebben betrekking tot kwaadaardige software of malware. In deze context zijn we bezorgd met dreigingen tot applicatieprogramma's als hulpprogramma's zoals editors, compilers en kernel-level programma's.

    Kwaadaardige software kan in twee categorieŽn worden onderverdeeld: diegene die een host programma nodig hebben en diegene die onafhankelijk zijn. De eerste, ook wel parasitair genoemd, zijn eigenlijk delen van programma's die niet afzonderlijk kunnen bestaan zonder applicatie, hulp of systeemprogramma. Virussen, logische bommen en achterdeuren zijn hiervan voorbeelden. De laatste zijn zelf bestuurde programma's die gepland en uitgevoerd kunnen worden door het besturingssysteem. Wormen en bots zijn hiervan voorbeelden.

    We kunnen ook onderscheid maken tussen software dreigingen die zichzelf niet repliceren en diegene die dat wel doen. De eerste zijn programma's of fragmenten van programma's die geactiveerd worden door een trigger. Voorbeelden hiervan zijn logische bommen, achterdeuren en bots. De laatste bevatten of een programma fragment of een onafhankelijk programma dat, wanneer uitgevoerd, ťťn of meer kopieŽn van zichzelf maakt om later op hetzelfde, of een ander systeem geactiveerd te worden. Virussen en wormen zijn voorbeelden hiervan.

    Kwaadaardige software kan relatief onschuldig zijn of het kan ťťn of meer schadelijke acties veroorzaken, zoals het vernietigen van bestanden en date in het hoofdgeheugen, controles te omzeilen om bevoorrechte toegang te verkrijgen en een betekenis voorzien voor indringers om de toegangscontroles te omzeilen.

    3.6.2. Tegenmaatregelen

    3.6.2.1. Indringingsdetectie

    RFC 2828 (Internet Security Glossary) definieert indringingsdetectie als volgt: Een beveiligingsservice dat de systeem gebeurtenissen bewaakt en analyseert met als doel het vinden, en voorzien in real-time of bijna real-time waarschuwingen van pogingen om toegang tot systeembronnen te verkrijgen in een ongeoorloofde manier.

    Indringingdetectiesystemen (IDS) kunnen als volgt worden geclassificeerd:

  • Host-gebaseerd IDS: Bewaakt de karakteristieken van een enkele host en de gebeurtenissen die zich voordoen binnen die host voor verdachte activiteit.

  • Netwerk-gebaseerde IDS: Bewaakt netwerk verkeer voor specifieke netwerksegmenten of apparaten en analyseert netwerk, transport en applicatie protocollen om verdacht gedrag te herkennen.

  • Een IDS bestaat uit drie logische componenten:

  • Sensoren: Sensoren zijn verantwoordelijk voor het vergaren van data. De input voor een sensor kan eender welk deel van het systeem zijn dat bewijs van een indringing bevat. Types van invoer naar een sensor bevat netwerk pakketten, log bestanden en systeem oproep traceringen. Sensors verzamelen en sturen deze informatie door naar de analysator.
  • Analysators: Analysators ontvangen input van ťťn of meer sensoren of van andere analysators. De analysator is verantwoordelijk om te bepalen of een indringing zich heeft voorgedaan. De uitvoer van deze component is een indicatie dat een indringing heeft plaatsgevonden. De uitvoer kan het bewijs bevatten ondersteund met de conclusie dat een indringing heeft plaatsgevonden. De analysator kan richtlijnen voorzien over welke maatregelen te nemen als resultaat van die indringing.
  • Gebruikersinterface: De gebruikersinterface naar een IDS maakt het voor een gebruiker mogelijk om de output van het systeem of het gedrag van het systeem te controleren. In sommige systemen kan de gebruikersinterface gelijkgesteld worden aan een manager, directeur of console component.
  • Indringingsdetectie systemen zijn typisch ontworpen om menselijk intrusiegedrag te detecteren alsook kwaadaardig softwaregedrag.

    3.6.2.2. Authenticatie

    In de meeste computer beveiligingscontexten is de gebruikersauthenticatie de fundamentele constructie en de eerste lijn van verdediging. Gebruikersauthenticatie is de basis voor de meeste types van toegangscontrole en voor gebruikersverantwoording. RFC 2828 definieert gebruikersauthenticatie als volgt:

    Het proces van het verifiŽren van een identiteit die geclaimd is voor een systeem entiteit. Een authenticatie proces bevat twee stappen:

  • Identificatie stap: Het presenteren van een indentificator aan een beveiligingssysteem. (Identificators zouden zorgzaam toegewezen moeten zijn, omdat de geauthentiseerde identiteiten de basis vormen voor andere beveiligingsdiensten, zoals toegangscontrolediensten.)
  • Verificatie stap: Het presenteren of genereren van authenticatie informatie die de binding tussen de entiteit en de identificator erkent.
  • In essentie is identificatie de reden waarbij een gebruiker een geclaimde identiteit voorziet aan het systeem; gebruikersauthenticatie is de reden om de geldigheid van de claim tot stand te brengen.

    Er zijn vier algemene redenen om een gebruikersidentiteit te authentiseren, welke alleen of in combinatie kan worden gebruikt:

  • Iets wat een individueel weet: Voorbeelden hiervan zijn een wachtwoord, een persoonlijke identificatie nummer of antwoorden op een vooraf gearrangeerde set van vragen.
  • Iets wat de individueel bezit: Voorbeelden hiervan elektronische keycards, smart cards en fysieke sleutels. Dit type van identificator wordt ook wel gerefereerd naar als token.
  • Iets wat de individueel is (statische biometrie): Voorbeelden hiervan zijn vingerafdruk-, oog- en gezichtsherkenning.
  • Iets wat de individueel doet (dynamische biometrie): Voorbeelden hiervan zijn herkenning door middel van een stempatroon, handschriftkarakteristieken en typeritme.
  • Als deze methodes, correct geÔmplementeerd en gebruikt, kunnen leiden tot een veilige gebruikersauthenticatie. Echter iedere methode heeft zijn problemen. Een tegenstander kan in staat zijn om het paswoord te raden of te stelen. Gelijkaardig kan een tegenstander proberen de token na te maken of te stelen. Een gebruiker kan een wachtwoord vergeten of een token verliezen. Bovendien is er een significante administratieve overhead op het systeem voor het paswoordbeheer en token informatiesysteem en het beveiligen van zulke informatie op systemen. Met respect tot biometrische authenticatie zijn er verschillende problemen zoals om te gaan met false positives en false negatives, gebruikersacceptatie, kostprijs en gemak.

    3.6.2.3. Toegangscontrole

    Toegangscontrole implementeert een veiligheidsbeleid dat specifieert wie of wat (bv. in het geval van een proces) toegang mag hebben tot een specifiek systeembron en het type van toegang dat toegestaan is in iedere instantie.

    Een toegangscontrole mechanisme bemiddeld tussen een gebruiker (of een proces die namens een gebruiker uitvoert) en systeembronnen, zoals applicaties, besturingssystemen, firewalls, routers, bestanden en databases. Het systeem moet eerst een gebruiker die toegang zoekt authentiseren. De authenticatie functie bepaald of de gebruiker toegang krijgt tot het systeem. Dan moet de toegangscontrolefunctie bepalen of de gevraagde toegang toegestaan is voor die gebruiker. Een beveiligingsbeheerder onderhoud een autorisatie database dat specifieert welk type van toegang tot welke bron toegestaan is voor deze gebruiker. De toegangscontrolefunctie raadpleegt deze database om te bepalen of het toegang moet verlenen. Een controlefunctie houdt toezicht en houdt een record van gebruikerstoegangen tot systeembronnen bij.

    3.6.2.4. Firewalls

    Firewalls kan een effectieve middel zin om lokaal systeem of netwerk te beveiligen tegen netwerk gebaseerde veiligheidsdreigingen terwijl op hetzelfde moment toegang tot de buitenwereld via wide area netwerken en het Internet is geoorloofd.

    Een firewall is een toegewezen computer dat het koppelpunt is met computers buiten het netwerk en heeft speciale ingebouwde veiligheidsvoorzorgsmaatregelen om gevoelige bestanden op computer binnen het netwerk te beschermen. Persoonlijke firewalls die geÔmplementeerd zitten in hardware of software en geassocieerd zijn met een enkel werkstation of PC zijn ook gebruikelijk.

    De ontwerpdoelen van een firewall zijn:

    1. Alle verkeer van intern naar extern, en omgekeerd, moet langs de firewall passeren. Dit wordt verkregen door alle toegang tot het lokale netwerk fysiek te blokkeren, behalve via de firewall.
    2. Enkel toegelaten verkeer, zoals bepaald door het lokaal veiligheidsbeleid wordt doorgelaten.
    3. De firewall zelf is immuun voor indringers. Dit impliceert het gebruik van een gehard systeem met beveiligd besturingssysteem. Vertrouwde computersystemen zijn geschikt om een firewall te hosten en vaak vereist in overheidsapplicaties.

    Herhalingsvragen

    1. Wat is een instructiespoor?
       
      Een instructiespoor voor een programma is de volgorde waarin instructies voor dat proces worden uitgevoerd.
       
    2. Welke algemene gebeurtenissen geven aanleiding tot het creŽren van een proces?

      Nieuwe batch job; interactieve logon; aangemaakt door OS om een dienst te verlenen; voortgebracht door het bestaande proces. Zie tabel 3.1 voor meer informatie.
       
    3. Geef een korte definitie van iedere toestand in het procesmodel van figuur 3.6.
       
      Running: Het proces dat momenteel wordt uitgevoerd.
      Ready: Een proces dat klaargemaakt wordt om uitgevoerd te worden wanneer de mogelijkheid zich voortdoet.
      Blocked: Een proces dat niet kan uitvoeren totdat een bepaalde gebeurtenis zich voordoet, zoals het voltooien van een I/O-bewerking.
      New: Een proces dat net is aangegemaakt, maar nog niet is toegelaten tot de pool van uitvoerbare processen door het besturingssysteem.
      Exit: Een proces dat door het besturingssysteem is losgelaten uit de pool van uitvoerbare processen, hetzij omdat het is gestopt of omdat het om wat voor reden is afgebroken.

       
    4. Wat wordt bedoeld met het preŽmptief onderbreken van een proces?

      Proces
      preŽmptie ontstaat wanneer een proces in uitvoering wordt onderbroken door de processor zodat een ander proces kan worden uitgevoerd.
       
    5. Wat betekent het begrip swappen en wat is het doel ervan?

      Swapping heeft betrekking met het verplaatsen van een deel of alle processen van hoofdgeheugen naar schijf. Wanneer geen van de processen in het hoofdgeheugen in de Ready toestand bevindt, verwisselt het besturingssysteem ťťn van de geblokkeerde processen uit op schijf in een Suspend wachtrij, zodat een ander proces in het hoofdgeheugen kan worden gebracht om uit te voeren.
       
    6. Waarom bevat figuur 3-9b twee geblokkeerde toestanden?

      Er zijn twee onafhankelijke concepten: of een taak op een gebeurtenis (Blocked of niet) staat te wachten, en of er een proces uit het hoofdgeheugen is verwisseld (Suspended of niet). Om deze 2 2 combinatie te huisvesten, hebben we twee Ready toestanden en twee geblokkeerde toestanden nodig.
       
    7. Geef vier kenmerken van een opgeschort proces.

      1. Het proces is niet onmiddellijk beschikbaar voor uitvoering.
      2. Het proces hoeft al dan niet te wachten op een gebeurtenis. Als het wacht, is deze geblokkeerde toestand onafhankelijk van de opgeschorte conditie, en het optreden van de blokkerende gebeurtenis zal het proces niet in staat stellen om uit te voeren.
      3. Het proces werd door een agent in een opgeschorte toestand geplaatst; hetzij zelf, een ouderproces of het besturingssysteem, met het oog op het voorkomen van de uitvoering.
      4. Het proces kan niet worden verwijderd uit deze toestand tot de agent expliciet opdracht geeft tot verwijdering.

       
    8. Voor welke soorten entiteiten houdt het besturingssysteem informatietabellen bij vanuit beheersoverwegingen?

      Het besturingssysteem onderhoudt tabellen voor entiteiten in verband met het geheugen, I/O, bestanden en processen. Zie tabel 3.10 voor meer informatie.
       
    9. Geef drie algemene informatiecategorieŽn in een procesbesturingsbiok.

      Proces identificatie, processor toestand informatie en proces controle-informatie.
       
    10. Waarom zijn twee verwerkingsmodi (gebruiker en kernel) nodig?

      De gebruikersmodus heeft beperkingen op de instructies die kunnen worden uitgevoerd en de geheugengebieden die toegankelijk zijn. Dit om het besturingssysteem te beschermen tegen schade of verandering. In kernel mode, heeft het besturingssysteem deze beperkingen niet, zodat het besturingssysteem de taken kan uitvoeren.
       
    11. Welke stappen voert het besturingssysteem uit bij het creŽren van een nieuw proces?

      1. Wijs een unieke proces identifier toe aan het nieuwe proces.
      2. Wijs ruimte toe voor het proces.
      3. Initialiseer het procescontroleblok.
      4. Stel de juiste koppelingen in.
      5. Maak of breid andere datastructuren uit.

       
    12. Wat is het verschil tussen een interrupt en een val (trap)?

      Een interrupt is te wijten aan een soort gebeurtenis die extern en onafhankelijk is van het huidig uitvoerend proces, zoals het voltooien van een I/O-bewerking.
      Een val heeft betrekking op een fout of uitzonderingsconditie die gegenereerd wordt binnen het momenteel lopend proces, zoals een poging tot een illegale bestandstoegang.

       
    13. Geef drie voorbeelden van een interrupt.

      Klok interrupt, I/O-interrupt, geheugen fout.
       
    14. Wat is het verschil tussen een moduswisseling en een proceswisseling?

      Een moduswissel kan optreden zonder dat de toestand van het proces dat momenteel in de Running toestand bevind wordt veranderd. Een proces-wissel gaat gepaard door het huidig uitvoerend proces uit de Running toestand te nemen ten gunste van een ander proces. De proceswissel houdt in het opslaan van meer toestandsinformatie.

    Probleemvraagstukken

    1. The following state transition table is a simplified model of process management. with the labels representing transitions between states of READY, RUN, BLOCKED, and NONRESIDENT.



      Give an example of an event that can cause each of the above transitions. Draw a diagram if that helps.
    2. Assume that at time 5 no system resources are being used except for the processor and memory. Now consider the following events:
          At time 5: PI executes a command to read from disk unit 3.
          At time 15: P5's time slice expires.
          At time 18: P7 executes a command to write to disk unit 3.
          At time 20: P3 executes a command to read from disk unit 2.
          At time 24: PS executes a command to write to disk unit 3.
          At time 28: PS is swapped out
          At time 33:An interrupt occurs from disk unit 2: P3's read is complete.
          At time 36: An interrupt occurs from disk unit 3: P1's read is complete.
          At time 38: P8 terminates.
          At time 40: An interrupt from disk unit 3: P5's write is complete.
          At time 44: PS is swapped hack in.
          At time 48: An interrupt occurs from disk unit 3: PTS write is complete.
      For each time 22, 37, and 47, identify which state each process is in. If a is blocked, further identify the event on which is it blocked.
       
    3. Figure 3.9b contains seven states. In principle, one could draw a transition between any two states, for a total of 42 different transitions.
      1. List all of the possible transitions and give an example of what could cause each
        transition.

        New → Ready or Ready/Suspend: covered in text
        Ready → Running or Ready/Suspend: covered in text
        Ready/Suspend → Ready: covered in text
        Blocked → Ready or Blocked/Suspend: covered in text
        Blocked/Suspend → Ready /Suspend or Blocked: covered in text
        Running → Ready, Ready/Suspend, or Blocked: covered in text
        Any State → Exit: covered in text
      2. List all of the impossible transitions and explain why.

        New → Blocked, Blocked/Suspend, or Running: A newly created process remains in the new state until the processor is ready to take on an additional process, at which time it goes to one of the Ready states.
        Ready → Blocked or Blocked/Suspend: Typically, a process that is ready cannot subsequently be blocked until it has run. Some systems may allow the OS to block a process that is currently ready, perhaps to free up resources committed to the ready process.
        Ready/Suspend → Blocked or Blocked/Suspend: Same reasoning as preceding entry.
        Ready/Suspend → Running: The OS first brings the process into memory, which puts it into the Ready state.
        Blocked → Ready /Suspend: this transition would be done in 2 stages. A blocked process cannot at the same time be made ready and suspended, because these transitions are triggered by two different causes.
        Blocked → Running: When a process is unblocked, it is put into the Ready state. The dispatcher will only choose a process from the Ready state to run
        Blocked/Suspend → Ready: same reasoning as Blocked → Ready /Suspend
        Blocked/Suspend → Running: same reasoning as Blocked → Running
        Running → Blocked/Suspend: this transition would be done in 2 stages
        Exit → Any State: Can't turn back the clock
         
    4. Teken een wachtrjdiagram dat vergelijkbaar is met figuur 3.9b voor het procesmodel met zeven toestanden uit figuur 3.8b.

      Figure 9.3 in Chapter 9 shows the result for a single blocked queue. The figurereadily generalizes to multiple blocked queues.
       
    5. Beschouw het overgangsdiagram van procestoestanden in figuur 3.9b. Veronderstel dat het moment is aangebroken dat het besturingssysteem een proces moet toedelen, dat er zich processen in zowel de toestand Gereed als in de toestand Gereed-opgeschort bevinden en dat ten minste ťťn proces in de toestand Gereed-opgeschort een hogere schedulingprioriteit heeft dan alle processen in de toestand Gereed. Er zijn twee extreme benaderingen voor toedeling mogelijk: (1) kies altijd een proces in de toestand Gereed, om het wisselen te minimaliseren, en (2) geef altijd de voorkeur aan het proces met de hoogste prioriteit, zelfs als dat kan leiden tot wisselen wanneer wisselen niet noodzakelijk is. Formuleer een tussenliggende benadering die een balans probeert te vinden tussen prioriteit en prestatie.

      Penalize the Ready, suspend processes by some fixed amount, such as one or two priority levels, so that a Ready, suspend process is chosen next only if it has a higher priority than the highest-priority Ready process by several levels of priority.
       
    6. Tabel 3.13 toont de procestoestanden in het besturingssysteem VAX/VMS.
      1. Kunt u een reden noemen voor het bestaan van zoveel verschillende wachttoestanden?

        A separate queue is associated with each wait state. The differentiation of waiting processes into queues reduces the work needed to locate a waiting process when an event occurs that affects it. For example, when a page fault completes, the scheduler know that the waiting process can be found on the Page Fault Wait queue.
         
      2. Waarom hebben de volgende toestanden geen residente en naar schijf geswapte versies: page fault, wait, collided page wait, common event wait, free page wait en resource wait?

        In each case, it would be less efficient to allow the process to be swapped out while in this state. For example, on a page fault wait, it makes no sense to swap out a process when we are waiting to bring in another page so that it can execute.
         
      3. Teken het diagram met de overgang van toestanden en geef daarbij de actie of gebeurtenis aan die elke overgang veroorzaakt.

         
         

        Next State

        Current State Currently Executing Computable (resident) Computable (outswapped) Variety of wait stated (resident) Variety of wait states (outswapped)
        Currently Executing   Rescheduled   Wait  
        Computable (resident) Scheduled   Outswap    
        Computable (outswapped)   Inswap      
        Variety of wait states (resident)   Event satisfied Outswap    
        Variety of wait states (outswapped)     Event satisfied    

         

    7. Het besturingssysteem VAXIVMS gebruikt vier toegangsmodi van de processor voor het beschermen van systeembronnen en het delen van bronnen door processen. De toegangsmodus bepaalt:
    8. privileges voor de uitvoering van instructies: de instructies die de processor mag uitvoeren;
    9. privileges voor de geheugentoegang: de locaties in het virtuele geheugen waartoe de huidige instructie toegang mag hebben. De vier modi zijn:
      1. Kernel: voert de kernel van het besturingssysteem VMS uit, zoals voor geheugenbeheer, interruptaffiandeling en 1/0-bewerkingen.
      2. Executive: voert veel van de aanroepen van diensten van het besturingssysteem uit, onder andere beheerroutines voor bestanden en records (op schijf en op magneetband).
      3. Supervisor: voert andere diensten van het besturingssysteem uit, zoals het beantwoorden van opdrachten van de gebruiker.
      4. User: voert gebruikersprogrammaís uit plus hulpprogrammaís zoals compilers, editors, linkers en debuggers.
    10. Een proces dat wordt uitgevoerd in een minder geprivilegieerde modus moet vaak een procedure aanroepen die wordt uitgevoerd in een meer geprivilegieerde modus; een voorbeeld is een gebruikersprogramma dat een dienst van het besturingssysteem nodig heeft. Deze aanroep wordt uitgevoerd met een instructie change mode (CHM), die leidt tot een interrupt die de besturing overdraagt aan een routine met de nieuwe toegangsmodus. Een return wordt gemaakt door het uitvoeren van de instructie REl (return from exception or interrupt).
       

      1. Bepaalde besturingssystemen hebben twee modi: kernel en user. Wat zijn de voordelen en nadelen van het gebruik van vier modi in plaats van twee?

        The advantage of four modes is that there is more flexibility to control access to memory, allowing finer tuning of memory protection. The disadvantage is complexity and processing overhead. For example, procedures running at each of the access modes require separate stacks with appropriate accessibility.
         
      2. Kunt u een reden geven voor het gebruik van zelfs meer dan vier modi?

        In principle, the more modes, the more flexibility, but it seems difficult to justify going beyond four.


       

    11. De beveiligingsstructuur van VMS, zoals besproken in de vorige opgave, wordt vaak een ringbescherming (ring protection) genoemd, zoals is weergegeven in figuur 3.18.
      Het eenvoudige kernel-gebruikersysteem, dat werd beschreven in paragraaf 3.3, is op vergelijkbare wijze een structuur met twee ringen. [SILB98I wijzen op een tekortkoming van deze benadering:
      ďHet grootste nadeel van de (hiŽrarchische) ringstructuur is dat deze ons niet de mogelijkheid biedt het Ďneed to knowí-principe toe te passen. Om precies te zijn: moet een object toegankelijk zijn in domein maar mag het niet toegankelijk zijn in domein D, dan moeten we j < i hebben. Dit betekent echter dat elk segment dat toegankelijk is in D, ook toegankelijk is in D1.Ē
      1. Leg duidelijk uit wat het probleem is waarnaar in dit citaat wordt verwezen.

        With j < i, a process running in Di is prevented from accessing objects in Dj. Thus, if Dj contains information that is more privileged or is to be kept more secure than information in Di, this restriction is appropriate. However, this security policy can be circumvented in the following way. A process running in Dj could read data in Dj and then copy that data into Di. Subsequently, a process running in Di could access the information.
         
      2. Noem een manier waarop een besturingssysteem met een ringbescherming dit probleem kan affiandelen.

        An approach to dealing with this problem, known as a trusted system, is discussed in Chapter 16.


       

    12. Figuur 3.8b suggereert dat een proces zich maar in ťťn wachtrij voor een gebeurtenis tegelijk kan bevinden.
      1. Zou u een proces willen toestaan te wachten op meer dan ťťn gebeurtenis tegelijk? Geef een voorbeeld.

        A application may be processing data received from another process and storing the results on disk. If there is data waiting to be taken from the other process, the application may proceed to get that data and process it. If a previous disk write has completed and there is processed data to write out, the application may proceed to write to disk. There may be a point where the process is waiting both for additional data from the input process and for disk
         
      2. Zo ja: hoe zou u de wachtrijstructuur in de figuur aanpassen om deze nieuwe mogelijkheid te ondersteunen?

        There are several ways that could be handled. A special type of either/or queue could be used. Or the process could be put in two separate queues. In either case, the operating system would have to handle the details of alerting the process to the occurrence of both events, one after the other.
         
    13. Bij enkele oudere computers leidde een interrupt tot het opslaan van de registerwaarden in vaste locaties die waren geassocieerd met het desbetreffende interruptsignaal. Onder welke omstandigheden is dit een zinvolle techniek? Leg ook uit waarom deze techniek in het algemeen onpraktisch is.

      This technique is based on the assumption that an interrupted process A will continue to run after the response to an interrupt. But, in general, an interrupt may ause the basic monitor to preempt a process A in favor of another process B. It is now necessary to copy the execution state of process A from the location associated with the interrupt to the process description associated with A. The machine might as well have stored them there in the first place. Source: [BRIN73].
       
    14. In paragraaf 3.4 werd gesteld dat UNIX niet geschikt is voor realtime-toepassingen, omdat een proces dat wordt uitgevoerd in de kernelmodus niet preŽmptief kan worden verwerkt. Licht deze stelling toe.

      Because there are circumstances under which a process may not be preempted (i.e., it is executing in kernel mode), it is impossible for the operating system to respond rapidly to real-time requirements.
       
    15. You have executed the following C program:

      main ()
      { int pid;
      pid = fork ();
      printf ("%d \n", pid);
      }


      What are the possible outputs, assuming the fork succeeded?