Processen en systeemaanroepen

Een browser, een compiler en een muziekspeler kunnen allemaal voortgang maken op één computer. Elk heeft CPU-tijd, geheugen en toegang tot apparaten nodig. Het besturingssysteem biedt die bronnen via diensten die programma's kunnen gebruiken zonder de hele machine te besturen.

Geef programma's bruikbare bronnen

Virtualisatie zet een fysieke bron om in een handige virtuele bron. CPU-virtualisatie laat veel processen werken alsof elk een eigen processor heeft. Het besturingssysteem voert elk proces een tijdje uit en bewaart zijn toestand tussen de beurten. Geheugenvirtualisatie geeft elk proces zijn eigen adresruimte: de adressen die zijn instructies kunnen gebruiken.

Een abstractie verbergt details achter een bruikbare interface. Een bestand is een abstractie voor opgeslagen bytes. Een programma kan write aanroepen zonder te weten of die bytes naar een SSD of een netwerkschijf gaan. Een systeemaanroep biedt een gecontroleerde manier om een dienst van de kernel aan te vragen. Apparaatspecifiek werk blijft achter de interface.

Deel bronnen en bescherm programma's

Als beheerder van bronnen beslist het besturingssysteem wie CPU-tijd, geheugen en apparaatdiensten krijgt. Het probeert de hardware nuttig te benutten en programma's tegelijk redelijke toegang te geven. Delen vereist ook bescherming: één programma mag het afgeschermde geheugen van een ander niet overschrijven of de timer uitschakelen om de CPU te behouden.

De hardware helpt deze grens af te dwingen. Instructies van toepassingen draaien in de gebruikersmodus met beperkte rechten. Kernelcode draait met de privileges die nodig zijn om de machine te beheren. Een timer kan een programma onderbreken, zelfs als dat programma nooit iets aan het besturingssysteem vraagt.

Volg bij een laptop die een bestand downloadt terwijl hij code compileert drie afzonderlijke taken:

1. Het netwerkapparaat meldt binnenkomende gegevens. De kernel stelt die beschikbaar aan het downloadproces.
2. Het besturingssysteem verdeelt CPU-tijd tussen de browser, de compiler en andere gereedstaande processen.
3. De compiler vraagt bestandsbewerkingen aan om zijn uitvoer op te slaan. Zijn code stuurt de opslagcontroller niet rechtstreeks aan.

Onderscheid de kernel van de interface

De kernel is de geprivilegieerde kern. De shell, de desktop en de meeste systeembibliotheken draaien als gewone programma's, zelfs wanneer ze met het besturingssysteem worden meegeleverd. Een desktopvenster sluiten verwijdert de kernel niet. Een server zonder grafische interface heeft nog steeds procesbeheer, geheugenbescherming en apparaatdiensten nodig.

Op één logische CPU wisselen gebruikerscode en kernelcode elkaar af. Terwijl de compiler gewone gebruikersinstructies uitvoert, wordt de kernel niet ook op die CPU uitgevoerd. Systeemaanroepen, excepties en hardware-interrupts geven de kernel de controle terug.

Kies hoe en kies daarna wie

Een mechanisme biedt een bewerking; beleid bepaalt hoe die wordt gebruikt. De registers van het ene proces opslaan en die van een ander herstellen is een mechanisme. Kiezen welk gereed proces de volgende beurt krijgt is beleid. Door die te scheiden kan het besturingssysteem zijn planningskeuzes veranderen zonder het wisselmechanisme te vervangen.

Bij het ontwerp van een besturingssysteem worden bruikbare abstracties, prestaties, bescherming, betrouwbaarheid, beveiliging en energieverbruik tegen elkaar afgewogen. De extra CPU-tijd en het extra geheugen die aan beheer worden besteed, zijn overhead. In het hele vakgebied keren drie thema's terug: virtualisatie, gelijktijdigheid (activiteiten die tegelijk bezig zijn) en persistentie, waardoor opgeslagen gegevens de levensduur van een programma of een stroomuitval overleven.

Besturingssystemen ontwikkelden zich toen computers van het uitvoeren van afzonderlijke taken overgingen naar het bedienen van veel activiteiten tegelijk. Elke verandering loste een praktisch probleem op: ongebruikte hardware, trage interactie of fouten die zich tussen programma's verspreidden.

Van batches naar overlappend werk

Bij batchverwerking worden ingediende taken achter elkaar uitgevoerd zonder interactie met degene die ze heeft ingediend. Vroege ondersteunende software hielp vooral bij het laden van taken en het uitvoeren van veelvoorkomende I/O-bewerkingen. Als de huidige taak op een apparaat moest wachten, kon de CPU ongebruikt blijven.

Multiprogrammering houdt meerdere taken in het geheugen. Wanneer één taak voor I/O blokkeert, kan een andere rekenen. Stel dat een taak telkens 20 ms rekent en 80 ms op schijf-I/O wacht. Als die alleen draait, is de CPU-bezettingsgraad 20 / 100 = 20%. Met twee van zulke taken en geschikte overlap kunnen nuttige berekeningen 40% van de verstreken tijd vullen. De vertraging van het apparaat is niet korter geworden; CPU-tijd die anders ongebruikt bleef, is benut.

De winst hangt ervan af of er werk gereedstaat. Door taken toe te voegen kan de CPU-bezettingsgraad niet boven 100% komen en taken die op hetzelfde apparaat wachten, kunnen nog steeds een knelpunt tegenkomen. Meerdere taken in het geheugen hebben ook bescherming nodig: de ene mag de andere niet overschrijven of de eigen gegevens van het besturingssysteem beschadigen.

Maak interactie snel

Tijdsverdeling geeft processen korte beurten op de CPU. Een terminal of desktop kan reageren terwijl andere programma's blijven werken. Het zou heel anders aanvoelen als een batchtaak eerst moest eindigen voordat een toetsaanslag van een andere gebruiker werd verwerkt.

Gelijktijdigheid betekent dat meerdere activiteiten in dezelfde periode bezig zijn. Hun instructies kunnen op één logische CPU worden afgewisseld. Parallellisme betekent dat instructies daadwerkelijk gelijktijdig op verschillende verwerkingsbronnen worden uitgevoerd. Multiprogrammering vereist geen parallelle hardware.

Plaats diensten binnen of buiten de kernel

Linux is monolithisch en kan kernelmodules laden. MINIX 3, QNX en seL4 zijn voorbeelden van microkernelontwerpen. Windows NT en XNU van Apple worden doorgaans beschreven als hybride ontwerpen. Een stuurprogramma in de gebruikersmodus kan na een crash vaak opnieuw worden gestart, terwijl een geprivilegieerd stuurprogramma toegang heeft waardoor een fout het hele systeem kan treffen.

Vroege systemen voor personal computers zoals MS-DOS en het klassieke Mac OS misten de procesgeheugenbescherming die tegenwoordig wordt verwacht. Moderne systemen combineren regels van het besturingssysteem met handhaving door de hardware. Korte CPU-beurten alleen zouden niet voorkomen dat een programma het geheugen van een ander programma verandert; delen en bescherming lossen verschillende delen van het probleem op.

Een uitvoerbaar bestand op schijf kan herhaaldelijk worden gestart. Elke start vereist een eigen veranderlijke toestand, zodat één instantie onafhankelijk kan pauzeren, hervatten of mislukken. Die actieve instantie is een proces.

Herken de draaiende instantie

Een programma bestaat uit opgeslagen instructies en statische gegevens. Een proces combineert een programma met zijn huidige geheugen, CPU-registers en I/O-toestand. Drie shells kunnen hetzelfde uitvoerbare bestand draaien en tegelijk verschillende variabelen, huidige directory's en geschiedenissen bijhouden.

De programmateller (PC) duidt de volgende instructie aan. De stackpointer geeft de locatie van de actieve stack aan. Algemene registers bevatten tussenwaarden. Wanneer een proces stopt met draaien, moet voldoende toestand worden bewaard om het bij de juiste instructie met de juiste waarden te laten doorgaan.

Lees de indeling van de adresruimte

De adresruimte van een proces is het geheugen dat zijn instructies kunnen adresseren. Een veelgebruikte indeling in leermateriaal plaatst code en statische gegevens bij lagere adressen, een heap daarboven en een stack bij hogere adressen. De heap ondersteunt dynamisch toegewezen objecten; de stack ondersteunt functieaanroepen en lokale toestand. In deze indeling groeit de heap naar hogere adressen en de stack naar lagere adressen. De werkelijke indeling hangt af van het systeem en implementaties van malloc kunnen op meer dan één manier geheugen verkrijgen.

Twee processen kunnen voor een variabele hetzelfde virtuele adres afdrukken en daar toch verschillende waarden bevatten. Virtuele adressen horen bij de geheugenweergave van een proces. Gelijke adresnummers betekenen niet dat schrijfbare opslag wordt gedeeld.

Start een programma

Om een nieuw programmabeeld te starten, richt het besturingssysteem deze onderdelen in:

1. De uitvoerbare code en gegevens, waarvan delen op moderne systemen worden geladen wanneer ze nodig zijn.
2. Een initiële gebruikersstack en opstartinformatie, waaronder de argumentstrings en argumentvector die de runtime gebruikt om main aan te roepen.
3. Geheugen voor dynamische toewijzing en de initiële registertoestand.
4. Een I/O-omgeving, inclusief geërfde bestandsdescriptoren.
5. Een ingangspunt waar de opstartcode van het programma begint.

Op Unix zijn bestandsdescriptoren kleine gehele getallen die open I/O-bronnen aanduiden. Volgens de shellconventie is 0 standaardinvoer, 1 standaarduitvoer en 2 standaardfoutuitvoer. Ze zijn vaak met een terminal verbonden. Een proces kan extra descriptoren erven; de drie bekende nummers zijn geen limiet en geen garantie dat elk proces ze altijd open heeft.

Bekijk de gegevens van de kernel

Het procesbesturingsblok (PCB) bevat informatie die de kernel nodig heeft om één proces te beheren: PID, toestand, opgeslagen uitvoeringscontext, geheugengegevens, open descriptoren, ouderproces, eigenaar, huidige directory en gebruiksgegevens. Linux gebruikt task_struct; xv6 gebruikt struct proc. Een processentabel of processenlijst ordent deze gegevens.

Terwijl een proces draait, staan zijn actuele registers in de CPU. Bij binnenkomst in de kernel worden zijn gebruikersregisters op zijn kernelstack opgeslagen; een contextwisseling bewaart ook de uitvoeringscontext van de kernel. Het PCB is geen voortdurend bijgewerkte afspiegeling van elk gebruikersregister.

Een Linux-uitvoer van ps kan bijvoorbeeld 8240 8200 S bash en 8291 8240 R ps bevatten. Het tweede proces heeft PID 8291 en ouder-PID 8240, dus het is een kindproces van de shell. R omvat zowel processen in uitvoering als gereedstaande processen. Een PID identificeert een actief proces binnen zijn PID-naamruimte, maar na het opruimen kan dat nummer opnieuw worden gebruikt.

Een proces kan bestaan zonder op dit moment een instructie uit te voeren. Zijn toestand vertelt het besturingssysteem of het een CPU kan gebruiken of eerst op iets anders moet wachten. Dit onderscheid verklaart waarom een drukke computer veel processen kan hebben waarvan er op een bepaald moment maar enkele worden uitgevoerd.

Bepaal wat het proces nodig heeft

Een geblokkeerd proces verbruikt geen CPU-tijd zolang het geblokkeerd is. Het apparaat of de gebeurtenis kan nog wel voortgang maken. Een gereed proces heeft al wat het nodig heeft, behalve een CPU.

De basisovergangen zijn gereed → in uitvoering wanneer het proces wordt gekozen, in uitvoering → gereed wanneer het van de CPU wordt gehaald, in uitvoering → geblokkeerd wanneer het moet wachten en geblokkeerd → gereed wanneer de gebeurtenis plaatsvindt. Door voltooiing van de gebeurtenis komt een proces in aanmerking voor uitvoering; het krijgt niet onmiddellijk de CPU. Kiezen tussen processen die in aanmerking komen is de taak van de scheduler.

Volg overlappend werk

Gebruik één logische CPU en negeer wisseloverhead. Proces A rekent 2 ms, wacht 3 ms op schijf-I/O en rekent daarna 1 ms. Proces B heeft 4 ms CPU-tijd nodig. A begint eerst.

Op 2 ms start A de I/O en blokkeert. B rekent terwijl de schijf werkt. Op 5 ms is de I/O van A voltooid, maar het besturingssysteem laat B zijn vierde CPU-milliseconde afmaken voordat het A uitvoert. Dit is een beleidskeuze, geen extra toestandsovergang rechtstreeks van geblokkeerd naar in uitvoering.

Het totale CPU-werk is 2 + 1 + 4 = 7 ms en beide zijn na 7 ms klaar. Als A volledig zou draaien voordat B begon, zou de verstreken tijd 2 + 3 + 1 + 4 = 10 ms zijn. De CPU-bezettingsgraad zou 7 / 10 = 70% zijn, omdat geen ander werk de I/O-wachttijd vulde.

Lees toestanden op een echt systeem

Linux ps combineert in uitvoering en gereed als R. Het toont onderbreekbare slaap als S, niet-onderbreekbare slaap, vaak voor I/O, als D, een gestopt proces als T en een beëindigd proces waarvan de status nog niet is opgehaald als Z. Een gestopt proces wacht niet simpelweg op de voltooiing van een gewone I/O-bewerking. Een zombieproces is klaar met uitvoeren en behoudt alleen de gegevens die nodig zijn om zijn resultaat te melden.

Een nieuw proces doorloopt ook de aanmaakfase voordat het gereed is. Op een systeem met vier logische CPU's kunnen hoogstens vier processen met één thread tegelijk worden uitgevoerd. Gereedwachtrijen ordenen werk dat voor uitvoering in aanmerking komt; lijsten met geblokkeerde processen houden bij welke gebeurtenissen die processen nodig hebben. Een contextwisseling bewaart de uitvoeringstoestand van het ene proces en herstelt die van een ander wanneer het besturingssysteem verandert welk proces draait.

fork() maakt vanuit het aanroepende ouderproces een kindproces aan. Beide gaan direct na de aanroep verder, zodat één pad in de broncode twee uitvoeringen wordt. De retourwaarde vertelt elk proces welke rol het heeft.

Handel alle drie de resultaten af

pid_t rc = fork();
if (rc < 0) {
    perror("fork");
    exit(1);
} else if (rc == 0) {
    printf("child %ld\n", (long) getpid());
} else {
    printf("parent of %ld\n", (long) rc);
}

Gebruik <unistd.h> voor fork en getpid, <stdio.h> voor afdrukken en <stdlib.h> voor exit. Bij succes ontvangt het ouderproces de positieve PID van het kindproces; het kindproces ontvangt 0. Bij een fout ontvangt de aanroeper -1, geeft errno de fout aan en bestaat er geen kindproces.

Als het ouderproces PID 5000 heeft en het kindproces 5001, drukt het ouderproces “parent of 5001” af en het kindproces “child 5001”. Het is niet gegarandeerd welk proces eerst draait. getpid() geeft de eigen PID van de aanroeper terug; getppid() geeft de PID van zijn ouderproces terug. Het kindproces begint main niet opnieuw en herhaalt geen instructies van vóór de fork.

Volg afgeschermd geheugen en gedeelde I/O

Ouderproces en kindproces beginnen met dezelfde gewone geheugeninhoud in afzonderlijke adresruimten. Als x vóór de aanroep 10 is en het kindproces zijn kopie op 20 zet, blijft de kopie van het ouderproces 10. Zelfs het afgedrukte adres van x kan gelijk zijn: die gelijke virtuele adressen horen bij verschillende procesadresruimten.

Kopiëren bij schrijven voorkomt dat elke geheugenpagina direct wordt gekopieerd. Ouderproces en kindproces delen aanvankelijk fysieke pagina's die tegen schrijven zijn beschermd. Wanneer een van beide naar een afgeschermde pagina schrijft, zorgt de kernel voor een eigen kopie voordat hij de schrijfbewerking toestaat. Zo blijft het gedrag van gescheiden geheugen behouden, terwijl de kosten lager zijn als een kindproces snel daarna exec aanroept.

Bestandsdescriptoren gedragen zich anders. Hun gekopieerde vermeldingen verwijzen naar dezelfde onderliggende beschrijving van een geopend bestand (open file description), die de huidige bestandspositie bevat. Opeenvolgende leesbewerkingen via een geërfde descriptor verschuiven die gedeelde positie. De descriptortabel wordt gekopieerd, maar de onderliggende toestand van het geopende bestand in de kernel kan gedeeld blijven.

Tel alleen forks die een proces bereikt

Als elke aanroep slaagt, laat fork(); fork(); vier processen over: beide processen die door de eerste aanroep ontstaan, voeren de tweede uit. Een lus met drie iteraties die door alle processen wordt bereikt, laat $2^3=8$ processen over, inclusief het oorspronkelijke proces. Een fork in een tak die alleen het ouderproces uitvoert, wordt door minder processen bereikt, zodat herhaalde verdubbeling niet langer het hele programma beschrijft.

Leeg gebufferde tekst bewust

printf kan tekst in een buffer in de gebruikersruimte achterlaten. fork kopieert die buffer samen met de rest van het geheugen. Als uitvoer wordt omgeleid naar een volledig gebufferde stroom, kan tekst die vóór de fork is afgedrukt door beide processen bij normale beëindiging worden weggeschreven.

Bij printf("start\n"); fork(); schrijft een gebruikelijke regelgebufferde terminal de regel met het regelafbrekingsteken vóór de fork weg. Bij omleiding naar een bestand kan de tekst in de buffer blijven staan en tweemaal worden weggeschreven. fflush(stdout) vóór fork() schrijft de wachtende tekst eenmaal weg. De dubbele uitvoer komt door gekopieerde gebufferde gegevens, niet doordat de eerdere printf tweemaal wordt uitgevoerd.

Een proces kan zijn identiteit behouden terwijl het van programma verandert. De exec-familie voert die vervanging uit. Door die met fork te combineren kan een ouderproces zijn werk voortzetten terwijl een kindproces een ander programma gaat uitvoeren.

Vervang het beeld, behoud het proces

Een geslaagde exec vervangt de oude code, statische gegevens, heap en stack. De kernel bereidt de argumenten en begintoestand van het nieuwe programma voor en begint daarna met de opstartcode. De oude aanroepplek bestaat niet meer, dus een geslaagde exec keert daar nooit naar terug.

De PID, de relatie met het ouderproces en de huidige directory blijven behouden. Open descriptoren blijven behouden, behalve die welke zijn gemarkeerd om bij exec te sluiten. Signalen waarvoor een afhandelaar was ingesteld, krijgen weer hun standaardactie; genegeerde signalen blijven doorgaans genegeerd. De gebruikers- en groepsidentiteit blijft meestal gelijk, maar de set-user-ID- of set-group-ID-rechten van een uitvoerbaar bestand kunnen de effectieve identiteit veranderen als het systeem dat toestaat.

Bouw een geldige argumentvector

Om wc -l notes.txt uit te voeren kan het kindproces dit gebruiken:

char *args[] = {"wc", "-l", "notes.txt", NULL};
execvp(args[0], args);
perror("execvp");
_exit(127);

De strings zijn afzonderlijke argumenten, geen gecombineerde opdrachtregel. Volgens afspraak geeft args[0] het programma aan. De afsluitende NULL is een pointer die het einde van de array markeert; het is niet de string “NULL”. Zonder geldige afsluiting kan de aanroep voorbij de array lezen.

De regels na execvp handelen een fout af. Als het programma niet kan worden gevonden, geeft exec -1 terug en stelt errno in, bijvoorbeeld op ENOENT. _exit beëindigt het kindproces dan zonder geërfde uitvoerbuffers van C te legen. Na een fout terugkeren naar de shelllus zou onbedoeld een extra uitvoeringspad van de shell creëren.

Lees de naam van de variant

De v in execv betekent dat argumenten als vector binnenkomen; l-varianten ontvangen een lijst. Een p-variant zoekt in PATH naar een programmanaam. Een e-variant geeft een expliciete omgeving door. De onderliggende systeemaanroep van Linux is execve; de bibliotheek biedt de handige varianten.

execvp("wc", args) zoekt in PATH. execv("wc", args) behandelt “wc” als een relatieve padnaam in de huidige directory. Een absolute padnaam zoals /usr/bin/wc kan worden gebruikt waar dat uitvoerbare bestand is geïnstalleerd. Exec ontleedt geen shellsyntaxis: een string > in args is gewoon een argument, tenzij een programma die zelf interpreteert.

Gebruik de tijd vóór vervanging

In het voorbeeld met ouderproces PID 6000 en kindproces PID 6001 gaat het kindproces wc uitvoeren, maar behoudt het PID 6001. Zijn ouderproces kan op die PID wachten. Vóór exec kan het kindproces descriptoren omleiden, een pipe aansluiten of van directory veranderen; het vervangende programma erft de voorbereide omgeving.

Deze scheiding staat centraal in de Unix-shell. Windows CreateProcess combineert het aanmaken van een proces en het laden van een programma en gebruikt parameters om het nieuwe proces te configureren. POSIX biedt ook posix_spawn voor een gecombineerde bewerking.

Een ouderproces moet weten of een kindproces klaar is en hoe het is geëindigd. Procesbeëindiging en het ophalen van het resultaat zijn afzonderlijke stappen: het kindproces eindigt en daarna haalt het ouderproces de resterende gegevens bij de kernel op.

Beëindig een proces

Terugkeren uit main of exit(status) aanroepen beëindigt de uitvoering normaal. exit leegt C-uitvoerbuffers en voert geregistreerde beëindigingsafhandelaars uit. _exit(status) beëindigt zonder die opruimactie van de bibliotheek, wat nuttig is na een mislukte exec in een met fork aangemaakt kindproces. Volgens afspraak betekent 0 succes en een waarde anders dan nul een fout.

Een signaal kan een proces ook beëindigen. SIGTERM vraagt om beëindiging en kan worden afgehandeld; SIGKILL kan niet worden opgevangen of genegeerd. SIGSTOP stopt de uitvoering en kan ook niet worden opgevangen of genegeerd; SIGCONT hervat een gestopt proces. Een terminal stuurt normaal SIGINT bij Ctrl-C en SIGTSTP bij Ctrl-Z naar de taak op de voorgrond. Een signaal is een softwaremelding aan een proces, geen hardware-interrupt.

Wacht op één resultaat

wait(&status) wacht op één kindproces en geeft zijn PID terug. waitpid(pid, &status, 0) selecteert een bepaalde positieve PID van een kindproces. De status van een geëindigd kindproces die nog niet is opgehaald, kan direct worden opgehaald. Anders onderbreekt een gewone blokkerende wachtbewerking het ouderproces totdat een passend resultaat beschikbaar is.

Met WNOHANG geeft waitpid 0 terug wanneer passende kindprocessen bestaan, maar geen daarvan een resultaat klaar heeft. Een positief resultaat geeft aan welk kindproces is opgehaald. Een resultaat van -1 is een fout: ECHILD betekent dat er geen passend kindproces meer is; EINTR betekent dat een signaalafhandelaar het wachten heeft onderbroken.

Decodeer de status vóór gebruik

int status;
pid_t r;
do {
    r = waitpid(child, &status, 0);
} while (r == -1 && errno == EINTR);
if (r == -1) {
    perror("waitpid");
} else if (WIFEXITED(status)) {
    printf("exit %d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
    printf("signal %d\n", WTERMSIG(status));
}

Dit gebruikt <sys/wait.h>, <errno.h> en <stdio.h>. De opgeslagen status codeert zowel de manier van beëindigen als een resultaat. WEXITSTATUS is zinvol nadat WIFEXITED waar is gebleken; WTERMSIG volgt op WIFSIGNALED.

Alleen de laagste acht bits van een normale afsluitwaarde zijn beschikbaar. exit(300) levert daarom 44 op, terwijl exit(-1) 255 oplevert. Op Linux levert exit(3) doorgaans de ruwe wachtstatus 768 op; dat ruwe gehele getal afdrukken is niet hetzelfde als de afsluitcode decoderen.

Haal zombieprocessen op en herken weesprocessen

Een zombieproces is beëindigd, maar behoudt zijn PID en resultaat totdat een wachtbewerking die ophaalt. Het voert geen code uit, dus SIGKILL sturen kan het niet verwijderen. Een langlopend ouderproces moet de beëindigingsstatus van elk kindproces ophalen. Om alle kindprocessen op te halen blijf je na elke positieve PID wachten, probeer je opnieuw bij EINTR en stop je bij ECHILD; andere fouten meld je.

Een weesproces heeft zijn ouderproces verloren en kan nog draaien. Linux geeft het een passend subreaperproces of het initproces van de naamruimte als nieuw ouderproces, dat later zijn resultaat kan ophalen. Gewone rechten om signalen te sturen hangen af van gebruikersidentiteiten en privileges. Als root draaien geeft rechten, maar betekent niet dat de uitvoering in de kernelmodus plaatsvindt.

Een shell zet commandotekst om in het aanmaken van processen, het instellen van descriptoren en het ophalen van resultaten. Het is een gewoon gebruikersprogramma dat dezelfde beschermde diensten van het besturingssysteem gebruikt als andere programma's.

Start een extern commando

Voor wc -l notes.txt bouwt de shell de argumentvector en start hij het commando. De ontlede woorden vormen een met een nullpointer afgesloten argumentvector, args:

pid_t child = fork();
if (child == -1) {
    perror("fork");
} else if (child == 0) {
    execvp(args[0], args);
    perror("execvp");
    _exit(127);
} else {
    int status;
    pid_t result;
    do {
        result = waitpid(child, &status, 0);
    } while (result == -1 && errno == EINTR);
    if (result == -1) perror("waitpid");
    else if (WIFEXITED(status)) {
        printf("exit %d\n", WEXITSTATUS(status));
    } else if (WIFSIGNALED(status)) {
        printf("signal %d\n", WTERMSIG(status));
    }
}

Dit gebruikt <unistd.h>, <sys/wait.h>, <errno.h> en <stdio.h>. De omringende shell leest en ontleedt elk commando, voert dit startpad uit en toont daarna de volgende prompt.

Alleen het kindproces vervangt zijn programma; de shell kan het crashen van een commando als beëindigingsresultaat ophalen. Ingebouwde commando's zoals cd moeten de eigen toestand van de shell veranderen: als een kindproces van directory verandert, blijft de directory van de oudershell ongewijzigd.

Leid een descriptor om vóór exec

Voor ls -l > out.txt opent het kindproces de bestemming om te schrijven en maakt het bestand aan of wijzigt de lengte ervan naar nul. Daarna laat het standaarduitvoer naar dat bestand verwijzen:

int fd = open("out.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1) { perror("open"); _exit(1); }
if (dup2(fd, STDOUT_FILENO) == -1) {
    perror("dup2"); _exit(1);
}
if (fd != STDOUT_FILENO && close(fd) == -1) {
    perror("close"); _exit(1);
}

open heeft <fcntl.h> nodig; descriptoraanroepen en _exit gebruiken <unistd.h>. De rechten voor het aanmaken worden gefilterd door het bestandsaanmaakmasker van het proces. De controle fd != STDOUT_FILENO houdt descriptor 1 open, ook als open zelf 1 teruggaf. Na een geslaagde instelling behoudt exec descriptor 1 en schrijft ls normaal zonder iets van de omleiding te weten.

Een oudere aanpak sluit descriptor 1 voordat het bestand wordt geopend: open geeft de laagste ongebruikte descriptor terug. dup2 geeft de bestemming expliciet aan. Invoeromleiding verbindt op dezelfde manier een leesbaar bestand met descriptor 0.

Verbind twee commando's

Voor ls | wc -l maakt pipe(fds) een leeskant fds[0] en een schrijfkant fds[1]. Het producerende kindproces verbindt de schrijfkant met descriptor 1. Het consumerende kindproces verbindt de leeskant met descriptor 0. Na het dupliceren sluit elk proces de oorspronkelijke pipedescriptoren die het niet nodig heeft. Het ouderproces sluit zijn kopieën en wacht op beide kindprocessen.

Maak beide kindprocessen aan voordat je op een ervan wacht. Een producent kan de pipe vullen en blokkeren; de lezer moet bestaan om de pipe leeg te maken. De lezer bereikt het bestandseinde pas wanneer alle schrijfdescriptoren zijn gesloten en de gebufferde pipegegevens zijn verbruikt. Een ongebruikte schrijfkant die het ouderproces openhoudt, kan wc voor altijd laten wachten.

Houd de prompt beschikbaar

Voor sleep 60 & start de shell het kindproces en toont hij de volgende prompt zonder direct te wachten. Later gebruikt hij niet-blokkerende wachtbewerkingen of reageert hij op SIGCHLD om de status van beëindigde kindprocessen op te halen.

De afsluitstatus bepaalt ook commandocombinaties. make && ./app start het tweede commando alleen na succes; make || echo failed start het tweede alleen na een fout. Deze beslissingen gebruiken het gedecodeerde resultaat, niet de ruwe gecodeerde wachtstatus.

De kernel moet programma's snel laten rekenen en tegelijk bewerkingen tegenhouden waarmee de controle over de machine kan worden overgenomen. De privilegemodus van de CPU is de hardwaregrens die beide mogelijk maakt.

Scheid berekeningen van geprivilegieerde besturing

In de gebruikersmodus kunnen instructies toegang krijgen tot toegestaan procesgeheugen en gewone berekeningen uitvoeren. Ze kunnen de hardwareconfiguratie die andere programma's beschermt niet vrij veranderen. In de kernelmodus, ook supervisormodus of geprivilegieerde modus genoemd, kan het besturingssysteem de beschermde bewerkingen uitvoeren die nodig zijn om de machine te beheren.

Geprivilegieerde bewerkingen zijn onder meer de timer programmeren, interrupts uitschakelen, interruptafhandelaars instellen, besturingsregisters voor geheugenvertaling veranderen, beschermde apparaten rechtstreeks aansturen en de CPU stilzetten. Als elke toepassing de timer kon uitschakelen, zouden korte CPU-beurten afhangen van de medewerking van die toepassing.

AArch64 biedt ook EL2 voor hypervisors en EL3 voor beveiligde firmware. Deze namen duiden privilegeniveaus van de hardware aan, geen verschillende soorten gebruikersaccounts.

Ga binnen op een gecontroleerd adres

Gebruikerscode kan haar eigen privileges niet verhogen en niet zomaar een kerneladres kiezen om code uit te voeren. De overgang vindt plaats via een systeemaanroep, een door een instructie veroorzaakte exceptie of een hardware-interrupt. De CPU draagt de controle over aan een ingangspunt dat door het besturingssysteem is ingesteld. De terugkeercode van de kernel herstelt de opgeslagen gebruikerstoestand en verlaagt het privilegeniveau om de toepassingscode te hervatten.

De kernel beschermt zijn gegevens ook met geheugentoegangsrechten. Een proces kan kerneladressen in zijn virtuele indeling hebben en toch geen rechten hebben om die in de gebruikersmodus te benaderen. Een adres kennen geeft geen toegang tot de bytes op dat adres.

Neem een x86-64 Linux-toepassing die hlt uitvoert, een instructie die is bedoeld om een CPU tot een gebeurtenis stil te zetten. In de gebruikersmodus veroorzaakt de instructie een exceptie. Linux stuurt normaal SIGSEGV, waarvan de standaardactie dat proces beëindigt. De toepassing zet niet de hele computer stil; de beschermingsgrens verandert de poging tot een geprivilegieerde bewerking in een gebeurtenis die de kernel afhandelt.

Houd identiteit en modus gescheiden

Een root- of beheerdersproces is nog steeds een programma in de gebruikersmodus terwijl zijn eigen instructies draaien. Zijn gebruikersidentiteit geeft het ruimere rechten om diensten aan te vragen. Het gaat nog steeds via gecontroleerde paden de kernel binnen en de kernel controleert het verzoek.

Een geprivilegieerd onderhoudsprogramma mag bijvoorbeeld een beschermd bestand openen. Het programma vraagt dat via een systeemaanroep; het wordt geen kernelcode alleen omdat het verzoek is toegestaan. Omgekeerd wordt kernelcode die een read van een gewone gebruiker afhandelt in de kernelmodus uitgevoerd, ook al heeft de aanroeper geen beheerdersidentiteit.

Op één logische CPU is dit een volgorde: gebruikersinstructies, toegang tot de kernel, kernelwerk, terugkeer naar gebruikersinstructies. Het is geen gelijktijdige uitvoering van een programma en een tweede taak van het besturingssysteem op dezelfde CPU. Afzonderlijke logische CPU's kunnen op hetzelfde moment verschillende modi uitvoeren.

Een C-programma lijkt vaak een gewone functie aan te roepen wanneer het een dienst van het besturingssysteem nodig heeft. Onder de wrapperfunctie van een systeemaanroep zorgt een gecontroleerde CPU-overgang ervoor dat kernelcode dat verzoek kan controleren en uitvoeren.

Onderscheid een bibliotheekaanroep van een kernelverzoek

De C-bibliotheek implementeert strlen in de gebruikersruimte zonder systeemaanroep. printf maakt gegevens op en kan die bufferen; een latere write draagt bytes via de kernel over. Een dunne wrapperfunctie voor read zet argumenten klaar volgens de systeemaanroepconventie van het platform en voert de toegangsinstructie uit.

POSIX beschrijft interfaces voor Unix-achtige systemen. Linux implementeert veel diensten die grofweg zijn ingedeeld in procesbesturing, bestands- en apparaatbewerkingen, informatie, communicatie en bescherming. Een systeemaanroepnummer selecteert een dienst uit de dispatchtabel van de kernel. Nummers zijn platformspecifiek: Linux x86-64 gebruikt 1 voor write en 39 voor getpid; AArch64 gebruikt 64 voor write.

Volg één schrijfverzoek

Volg voor write(1, "hi\n", 3) op Linux x86-64 het verzoek in volgorde:

1. De wrapperfunctie plaatst dienstnummer 1 in rax, descriptor 1 in rdi, het bufferadres in rsi en het aantal 3 in rdx.
2. syscall bewaart het retouradres en de vlaggen in registers, gaat naar de kernelmodus en springt naar het ingestelde ingangspunt. De instructie wisselt niet automatisch van stack.
3. Ingangscode van de kernel richt de kernelstack van het proces in en slaat de resterende gebruikerstoestand op.
4. De kernel kiest via zijn dispatchtabel write; de implementatie controleert de descriptor, de toegang tot de gebruikersbuffer en het verzoek voordat ze bytes doorgeeft aan de uitvoerbron.
5. Bij een volledig geslaagde schrijfbewerking is het resultaat 3 bytes. Terugkeercode van de kernel herstelt de gebruikerstoestand en hervat de wrapperfunctie, die terugkeert naar de aanroeper.

Descriptor 1 kan een terminal, bestand of pipe aanduiden. Het nummer alleen geeft niet aan welk uitvoerapparaat wordt gebruikt. Een schrijfbewerking kan ook met succes een kleiner aantal bytes teruggeven; aanroepers die elke byte moeten overdragen houden bij hoeveel daadwerkelijk is geschreven.

Controleer fouten bij de interface

De kernel behandelt gebruikerspointers en andere argumenten als onbetrouwbaar. Een verzoek om uit een ontoegankelijke buffer te kopiëren kan mislukken met EFAULT; gecontroleerd kopiëren voorkomt dat de aanroeper toegang krijgt tot kernelgeheugen.

Op Linux is een kernelfout een negatieve foutcode. De gebruikelijke C-wrapperfunctie rapporteert -1 en stelt errno in. Als open("missing.txt", O_RDONLY) bijvoorbeeld mislukt omdat het bestand niet bestaat, is errno ENOENT. perror("missing.txt") kan “missing.txt: No such file or directory” tonen. Bekijk errno na een gemelde fout, niet als primaire test voor succes: een geslaagde aanroep hoeft een eerdere fout niet te wissen.

Houd rekening met tijd in de kernel

Een aanroep die meteen kan worden voltooid, kan naar hetzelfde proces terugkeren. Een blokkerende leesbewerking van de terminal kan dat proces daarentegen in de geblokkeerde toestand brengen en een ander laten draaien. De invoergebeurtenis maakt de lezer gereed; zodra die wordt ingepland, voltooit hij het terugkeerpad.

Toegang tot de kernel kost meer werk dan een normale functieaanroep: toestand opslaan, privileges veranderen, argumenten controleren en de uitvoering herstellen. Buffering in de bibliotheek kan kleine uitvoerstukken combineren tot minder schrijfbewerkingen. Op Linux voert strace ls het commando ls uit en rapporteert daarbij de systeemaanroepen, argumenten en resultaten.

Toegang tot de kernel kan een dienstverzoek, een instructieprobleem of een apparaatgebeurtenis betekenen. Door de oorzaak in te delen kun je voorspellen wat het besturingssysteem zal doen en of dezelfde instructie opnieuw moet worden uitgevoerd.

Vraag wat de gebeurtenis veroorzaakte

Synchroon betekent gekoppeld aan de instructie die wordt uitgevoerd. Het betekent niet dat dezelfde invoer bij elke uitvoering precies dezelfde fouten veroorzaakt. Een laadinstructie kan een fout veroorzaken wanneer de pagina ontbreekt en later slagen wanneer die pagina in het geheugen staat. Asynchroon betekent dat de oorzaak van de gebeurtenis onafhankelijk is van de huidige instructie, zoals een schijf die eerder werk voltooit.

CPU-handleidingen gebruiken deze termen op verschillende manieren. Let op de oorzaak: een bewust dienstverzoek, een door een instructie veroorzaakte gebeurtenis of een hardwaremelding.

Verwijs door naar de juiste afhandelaar

Bij het opstarten installeert het besturingssysteem beschermde adressen van afhandelaars. Een trap- of interrupttabel koppelt soorten gebeurtenissen aan kernelroutines. Op x86-64 dient de interruptdescriptortabel (IDT) voor interrupts en excepties; syscall gebruikt een ingangsadres in een speciaal processorregister. Alleen geprivilegieerde code kan deze bestemmingen instellen.

Bij een interrupt vanuit de gebruikersmodus slaat x86-64-hardware een terugkeerframe op een kernelstack op. Ingangscode slaat extra registers op voordat de afhandeling begint. Het syscall-pad bewaart de initiële terugkeertoestand in registers en vertrouwt op ingangscode om de kernelstack in te richten. Als je alle toegangspaden als identieke hardwareacties behandelt, verberg je een belangrijk verschil in implementatie.

Kies de uitkomst

Een geldige pagina die niet in het geheugen staat, kan worden geladen, waarna de instructie die de fout veroorzaakte opnieuw wordt geprobeerd. Toegang tot geheugen dat het proces niet mag gebruiken, leidt er normaal toe dat Linux SIGSEGV stuurt. Een exceptie is dus niet altijd fataal en ook niet altijd een verzoek om de huidige instructie over te slaan.

Bij een daadwerkelijke x86-64-instructie idiv voor deling van gehele getallen met deler nul veroorzaakt de CPU een deelfoutexceptie. Linux levert normaal SIGFPE af; de bekende melding noemt drijvendekommagetallen, ook bij deze instructie voor gehele getallen. De instructie voor deling van gehele getallen op AArch64 geeft daarentegen nul bij een deler nul. Deling door nul in C is ongedefinieerd gedrag, dus overdraagbare C-code kan niet op een van beide machine-uitkomsten vertrouwen.

Wanneer een leesbewerking van de schijf eindigt, legt de interruptafhandelaar de voltooiing vast en maakt het wachtende proces gereed. Dat proces kan later draaien. Een timerinterrupt geeft het besturingssysteem de kans opnieuw te bepalen welk proces de CPU gebruikt, maar de afhandelaar kan ook naar hetzelfde proces terugkeren.

Onderscheid een signaal van een interrupt

Een hardware-interrupt stelt de CPU op de hoogte; een signaal stelt via het besturingssysteem een proces op de hoogte. Een exceptie kan ertoe leiden dat de kernel een signaal stuurt en één proces kan via kill om een signaal voor een ander proces vragen. Normale voltooiingen van apparaatbewerkingen zijn interrupts en betekenen niet dat er programmafouten zijn.

Kernelcode moet ook gedeelde gegevens beschermen terwijl gebeurtenissen optreden. De kernel kan interrupts op een CPU kort uitschakelen en waar nodig vergrendelingen gebruiken. Lange perioden met uitgeschakelde interrupts vertragen de afhandeling van apparaten; alleen lokale interrupts uitschakelen voorkomt niet dat een andere CPU toegang krijgt tot gedeelde gegevens.

Elke instructie van een toepassing in een softwaresimulator uitvoeren zou het delen van de CPU duur maken. Een toepassing onbeperkte controle over de machine geven zou delen onveilig maken. Beperkte directe uitvoering (LDE) gebruikt gewone uitvoering op de hardware met een beschermd pad terug naar het besturingssysteem.

Los twee verschillende besturingsproblemen op

Directe uitvoering betekent dat de gewone instructies van een proces op de CPU zelf worden uitgevoerd. Het besturingssysteem onderzoekt en keurt niet elke rekeninstructie goed. Twee problemen blijven over: bewerkingen beperken die de machine kunnen beschadigen en de controle terugkrijgen wanneer een programma niet vrijwillig stopt.

De gebruikersmodus lost het beperkingsprobleem op. Via systeemaanroeptraps kan een programma diensten aanvragen zonder willekeurige geprivilegieerde code te kiezen. Een hardwaretimer lost het besturingsprobleem op: die kan een toepassing onderbreken die helemaal geen aanroepen doet. Samen ondersteunen deze mechanismen CPU-virtualisatie met weinig overhead.

Bereid de uitvoering van toepassingen voor

Bij het opstarten stelt de kernel gebeurtenisafhandelaars in en initialiseert hij de timer. Deze instelbewerkingen zijn geprivilegieerd. Latere gebruikersprogramma's kunnen de afhandelaars niet omleiden of de timer uitschakelen om te voorkomen dat hun beurt eindigt.

Om een proces te starten maakt het besturingssysteem zijn beheervermelding en geheugenbeeld aan, bereidt het opstartargumenten en een gebruikersstack voor en stelt het initiële registerwaarden in. Het zorgt voor een initiële opgeslagen context zodat de normale terugweg van kernel naar gebruiker het programma kan starten. Conceptueel begint het proces door terug te keren uit een trap die het nooit heeft veroorzaakt.

De gedetailleerde indeling van het opgeslagen frame hangt af van de CPU en het besturingssysteem. Het bruikbare ontwerpidee is hergebruik: dezelfde herstelmechanismen kunnen een onderbroken proces hervatten of een nieuw voorbereid proces starten.

Keer vrijwillig terug naar de kernel

Tijdens een systeemaanroep bewaart de hardware de initiële terugkeertoestand en draagt de controle over. Ingangscode van de kernel slaat de extra registers op de kernelstack van het proces op. Na voltooiing van een niet-blokkerend verzoek herstelt de kernel het proces en keert terug naar de gebruikersmodus. Als het verzoek blokkeert, kan eerst een ander gereed proces draaien.

Wanneer main terugkeert, vraagt de beëindigingsverwerking van de runtime uiteindelijk aan de kernel om het proces te beëindigen. Het geheugen kan worden vrijgegeven terwijl de beëindigingsgegevens bewaard blijven totdat een ouderproces die ophaalt.

Keer terug zonder medewerking

Een coöperatief systeem is afhankelijk van programma's die aanroepen doen, de CPU-beurt afstaan of excepties veroorzaken. Een eindeloze lus die geen van die dingen doet, kan een CPU monopoliseren. Het klassieke Mac OS illustreert deze zwakte.

Een niet-coöperatief ontwerp gebruikt een timerinterrupt om toegang tot de kernel af te dwingen. Neem een leermodel met één logische CPU en een periodieke timer die om de 4 ms afgaat. De timer produceert 1.000 / 4 = 250 tikken per seconde. Een gebruikersproces dat vastzit in while (1) { } wordt bij de volgende tik onderbroken. De kernel kan dan een ander gereed proces uitvoeren; de lus hoeft niet eerst een systeemaanroep te bereiken.

De tik is een kans om te handelen, geen verplichting om van proces te wisselen. De scheduler kan het onderbroken proces laten doorgaan. Timerafhandeling en herstel van de opgeslagen toestand zijn mechanismen; de keuze van de scheduler is beleid. De werkelijke responstijd hangt ook af van kernelwerk en van wanneer interrupts kunnen worden afgehandeld, dus een timerperiode op zichzelf garandeert geen responstijd van een toepassing.

Naar de kernelmodus gaan verandert niet noodzakelijk het draaiende proces. Een contextwisseling vindt plaats wanneer de kernel de uitvoeringstoestand van het ene proces bewaart en die van een ander hervat. Dit vereist zowel het bewaren van de gebruikerstoestand als een verandering in de eigen uitvoeringscontext van de kernel.

Volg hoe A wordt onderbroken en B wordt hervat

Volg voor een wisseling op x86-64 door de timer de lagen:

1. A voert gebruikersinstructies uit. De timer onderbreekt A.
2. De hardware gaat naar de kernelmodus en slaat het interruptterugkeerframe van A op de kernelstack van A op. Ingangscode slaat daar de overige gebruikersregisters van A op.
3. De scheduler kiest B. De wisselroutine slaat de uitvoeringscontext van de kernel voor A op en herstelt de opgeslagen kernelcontext van B, inclusief zijn kernelstackpointer.
4. De kernel schakelt waar nodig naar de adresruimtecontext van B. De kernel draait nu namens B met de kernelstack van B.
5. De afsluitcode van de kernel herstelt de gebruikersregisters van B. De terugkeerinstructie herstelt de terugkeertoestand van B en gaat naar de gebruikersmodus. B gaat verder waar het eerder stopte.

De eerste opslag bewaart de onderbroken gebruikersuitvoering van A. De tweede bewaart waar de kernel was tijdens de afhandeling voor A. Het zijn geen twee identieke volledige kopieën van dezelfde registerverzameling. Een PCB of bijbehorende contextstructuur en de kernelstack per proces werken samen om de toestand te bewaren.

Herken de gebeurtenis en de beslissing

Een blokkerende aanroep, procesbeëindiging of een beslissing bij een timerinterrupt kan tot een wisseling leiden. Een apparaatinterrupt kan een ander proces gereed maken, waarna de scheduler dat kan kiezen. Alle wisselmechanismen draaien in de kernel; een toepassing slaat haar eigen registers niet op om zich voor onderbreking beschikbaar te stellen.

Een contextwisseling bewaart de uitvoeringstoestand die nodig is om door te gaan. De tijd verstrijkt en de buitenwereld kan veranderen: gedeelde bestandsposities en externe invoer worden niet bevroren terwijl een proces is onderbroken.

Houd rekening met directe en indirecte kosten

Direct werk omvat het uitvoeren van de scheduler, het opslaan en herstellen van registers en het selecteren van een adresruimte. Vertaalcaches moeten mogelijk worden aangepast; vertalingen met labels kunnen voorkomen dat alle oude vermeldingen worden weggegooid. Indirecte kosten volgen wanneer B CPU-caches of gecachte adresvertalingen opnieuw moet vullen die door A zijn verdrongen. De kosten hangen af van hardware en werklast, dus gebruik gemeten of gegeven waarden wanneer je overhead berekent.

Stel dat een wisseling, inclusief de relevante effecten, 5 µs kost en nuttige CPU-beurten 10 ms duren. Zet 10 ms om naar 10.000 µs. Het wisselaandeel is 5 / (10.000 + 5), ongeveer 0,05%. Voor nuttige beurten van 1 ms is dat 5 / 1005, ongeveer 0,50%; bij 0,1 ms is dat 5 / 105, ongeveer 4,8%.

De noemer bevat nuttig werk plus wisseltijd voor één herhaalde cyclus. Een kortere beurt kan meer kansen bieden voor interactief werk, maar besteedt een groter aandeel aan herhaald wisselen. De timer en wisselcode maken korte beurten mogelijk; het planningsbeleid moet die kosten afwegen tegen de reactiesnelheid.