Inleiding tot besturingssystemen
Hé Habr! Ik zou graag een reeks artikelen onder uw aandacht willen brengen - vertalingen van een interessante literatuur naar mijn mening - OSTEP. Dit materiaal bespreekt vrij diepgaand het werk van Unix-achtige besturingssystemen, namelijk het werken met processen, verschillende planners, geheugen en andere soortgelijke componenten waaruit een modern besturingssysteem bestaat. U kunt het origineel van alle materialen hier bekijken . Houd er rekening mee dat de vertaling onprofessioneel (vrij vrij) is gemaakt, maar ik hoop dat ik de algemene betekenis heb behouden.
Labwerk over dit onderwerp is hier te vinden:
Andere delen:
Je kunt ook kijken op mijn kanaal op =)
Alarm! Er is een lab voor deze lezing! Kijk
Proces-API
Laten we eens kijken naar een voorbeeld van het maken van een proces in een UNIX-systeem. Het gebeurt via twee systeemoproepen vork() и exec ().
Oproepvork()
Beschouw een programma dat een fork()-aanroep doet. Het resultaat van de uitvoering ervan zal als volgt zijn.
Allereerst voeren we de functie main() in en drukken de string op het scherm af. De regel bevat de procesidentificatie die in het origineel wordt aangeroepen PID of procesidentificatie. Deze identificatie wordt in UNIX gebruikt om naar een proces te verwijzen. Het volgende commando roept fork() aan. Op dit punt wordt een vrijwel exacte kopie van het proces gemaakt. Voor het besturingssysteem lijkt het erop dat er twee exemplaren van hetzelfde programma op het systeem draaien, die op hun beurt de functie fork() verlaten. Het nieuw gemaakte onderliggende proces (in relatie tot het ouderproces dat het heeft gemaakt) zal niet langer worden uitgevoerd, te beginnen met de functie main(). We moeten niet vergeten dat een kindproces geen exacte kopie is van het ouderproces; het heeft in het bijzonder zijn eigen adresruimte, zijn eigen registers, zijn eigen verwijzing naar uitvoerbare instructies en dergelijke. De waarde die wordt geretourneerd naar de aanroeper van de functie fork() zal dus anders zijn. In het bijzonder zal het ouderproces de PID-waarde van het onderliggende proces als retour ontvangen, en het onderliggende proces zal een waarde gelijk aan 2 ontvangen. Met behulp van deze retourcodes kunt u vervolgens processen scheiden en elk proces dwingen zijn eigen werk te doen. . De uitvoering van dit programma is echter niet strikt gedefinieerd. Nadat het besturingssysteem in twee processen is verdeeld, begint het deze te monitoren en hun werk te plannen. Als het wordt uitgevoerd op een single-coreprocessor, blijft een van de processen, in dit geval het ouderproces, werken en krijgt het onderliggende proces de controle. Bij het opnieuw opstarten kan de situatie anders zijn.
Oproep wacht()
Beschouw het volgende programma. In dit programma vanwege de aanwezigheid van een oproep wacht() Het bovenliggende proces wacht altijd totdat het onderliggende proces is voltooid. In dit geval krijgen we een strikt gedefinieerde tekstuitvoer op het scherm
exec() aanroepen
Denk eens aan de uitdaging exec (). Deze systeemaanroep is handig als we een heel ander programma willen draaien. Hier zullen we bellen execvp() om het wc-programma uit te voeren, een woordtelprogramma. Wat gebeurt er als exec() wordt aangeroepen? Bij deze aanroep worden de naam van het uitvoerbare bestand en enkele parameters als argumenten doorgegeven. Waarna de code en statische gegevens uit dit uitvoerbare bestand worden geladen en het eigen segment met de code wordt overschreven. De resterende geheugengebieden, zoals de stapel en de heap, worden opnieuw geïnitialiseerd. Waarna het besturingssysteem het programma eenvoudigweg uitvoert en een reeks argumenten doorgeeft. We hebben dus geen nieuw proces gemaakt, we hebben eenvoudigweg het huidige actieve programma getransformeerd in een ander actief programma. Na het uitvoeren van de exec()-aanroep in de afstammeling lijkt het alsof het oorspronkelijke programma helemaal niet is uitgevoerd.
Deze opstartcomplicatie is volkomen normaal voor een Unix-shell en zorgt ervoor dat die shell code kan uitvoeren na het aanroepen vork(), maar vóór het gesprek exec (). Een voorbeeld van dergelijke code is het aanpassen van de shell-omgeving aan de behoeften van het programma dat wordt gestart, voordat het wordt gestart.
Shell - gewoon een gebruikersprogramma. Ze laat je de uitnodigingsregel zien en wacht tot je er iets in schrijft. Als u daar de naam van een programma schrijft, zal de shell in de meeste gevallen de locatie ervan vinden, de methode fork() aanroepen en vervolgens een type exec() aanroepen om een nieuw proces te maken en wachten tot het is voltooid met behulp van een wacht() oproep. Wanneer het onderliggende proces wordt afgesloten, keert de shell terug van de wait()-aanroep, drukt de prompt opnieuw af en wacht tot de volgende opdracht wordt ingevoerd.
Met de fork() & exec() splitsing kan de shell bijvoorbeeld de volgende dingen doen:
wc-bestand > nieuw_bestand.
In dit voorbeeld wordt de uitvoer van het wc-programma omgeleid naar een bestand. De manier waarop de shell dit bereikt is vrij eenvoudig: door een onderliggend proces te maken voordat het wordt aangeroepen exec (), sluit de shell de standaarduitvoer en opent het bestand nieuw bestand, dus alle uitvoer van het verder lopende programma wc wordt doorgestuurd naar een bestand in plaats van naar een scherm.
Unix pijp worden op een vergelijkbare manier geïmplementeerd, met het verschil dat ze een pipe()-aanroep gebruiken. In dit geval zal de uitvoerstroom van het proces worden verbonden met een pipe-wachtrij in de kernel, waarmee de invoerstroom van een ander proces zal worden verbonden.
Bron: www.habr.com