Introduktion till operativsystem

Hej, Habr! Jag vill presentera för er en serie översättningsartiklar av en intressant litteratur — OSTEP. I detta material behandlas djupgående hur unix-liknande operativsystem fungerar, nämligen arbetet med processer, olika schemaläggare, minne och andra liknande komponenter som utgör ett modernt OS. Originalet av allt material kan du se här ). Ett typiskt exempel på användning:. Observera att översättningen är utförd oprofessionellt (relativt fritt), men jag hoppas att jag har bevarat den övergripande meningen.

Laborationsarbeten för detta ämne kan hittas här:

• original: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• original: github.com/remzi-arpacidusseau/ostep-code
• min personliga anpassning: github.com/bykvaadm/OS/tree/master/ostep

Andra delar:

• Del 1: Intro

Och du kan också kolla in min kanal på telegram =)

Låt oss titta på den mest grundläggande abstraktionen som OS erbjuder användare: processen. Definitionen av en process är ganska enkel — det är ett körande program. Ett program i sig är en livlös sak, belägen på disken – det är en uppsättning instruktioner och möjligen några statiska data, som väntar på att bli startade. Det är operativsystemet som tar dessa byte och kör dem, vilket förvandlar programmet till något nyttigt.
Oftast vill användare köra mer än ett program samtidigt, till exempel kan du köra en webbläsare, ett spel, en mediaplayer, en textredigerare och så vidare på din laptop. Faktiskt kan ett typiskt system köra tiotals och hundratals processer samtidigt. Denna fakta gör systemet enklare att använda, du behöver aldrig oroas för om CPU:n är ledig, du startar bara programmen.

Härav uppstår problemet: hur ska man skapa illusionen av flera CPU:er? Hur kan operativsystemet skapa illusionen av praktiskt taget ett oändligt antal CPU:er, även om du bara har en fysisk CPU?

Operativsystemet skapar denna illusion genom CPU-virtualisering. Genom att köra en process, sedan stanna den, köra en annan process och så vidare, kan OS upprätthålla illusionen av att det finns många virtuella CPU:er, även om det i själva verket bara handlar om en eller flera fysiska processorer. Denna teknik kallas CPU-resurser tidsdelning. Denna teknik gör det möjligt för användare att köra så många samtidiga processer som de önskar. Priset för denna lösning är prestanda – eftersom om CPU:n delas av flera processer kommer varje process att bearbetas långsammare.
För att möjliggöra CPU-virtualisering, och särskilt för att göra det bra, kräver operativsystemet både låg- och hög-nivå stöd. Låg-nivå stöd kallas mekanismer – det är låg-nivå metoder eller protokoll som implementerar den nödvändiga funktionaliteten. Ett exempel på sådan funktionalitet är kontextväxling, som ger operativsystemet möjlighet att stoppa ett program och starta ett annat program på processorn. Denna tidsdelning är implementerad i alla moderna operativsystem.
Ovanför dessa mekanismer finns viss logik inbyggd i operativsystemet, i form av "policys". Policy – är en specifik algoritm för beslutsfattande i operativsystemet. Sådana policies avgör till exempel vilket program som ska köras (från kommandolistan) först. Således kommer en policy, som kallas schemaläggare (scheduling policy) att vägledas av information som: starthistorik (vilket program har kört längst under den senaste minuten), vilken belastning varje process har (vilka typer av program som har körts), prestandametrik (är systemet optimerat för interaktivt samspel eller för genomströmning) och så vidare.

Abstraktion: process

Abstraktionen av ett körande program, utfört av operativsystemet, är vad vi kallar process. Som redan nämnts är en process helt enkelt ett körande program vid en viss tidpunkt. Programmet med vilket vi kan få sammanfattande information från olika systemresurser, och som programmet får tillgång till eller påverkar under sin körning.
För att förstå komponenterna i en process måste vi förstå systemtillstånd: vad programmet kan läsa eller ändra under sin körning. Vid varje given tidpunkt måste vi förstå vilka systemelement som är viktiga för programmets genomförande.
Ett av de uppenbara elementen i systemets tillstånd som processen inkluderar är minnet. Instruktionerna lagras i minnet. Data som programmet läser eller skriver lagras också i minnet. Därför är det minne som processen kan adressera (det så kallade adressutrymmet) en del av processen.
En annan del av systemets tillstånd är registren. Många instruktioner syftar till att ändra värdet av registren eller läsa deras värde, vilket gör att registren också blir en viktig del av processens funktion.
Det bör noteras att maskinens tillstånd också består av vissa specialregister. Till exempel, IP — instruction pointer — pekaren till den instruktion som programmet för närvarande exekverar. Det finns också stack pointer och den relaterade frame pointer, som används för att hantera: funktionsparametrar, lokala variabler och återvändsadresser.
Slutligen hänvisar program ofta till ROM (läsminne). Den information om 'I/O' (ingång/utgång) bör innehålla en lista över filer som processen har öppnat för tillfället.

Process API

För att förbättra förståelsen av processens funktion ska vi studera exempel på systemanrop som måste ingå i varje operativsystems gränssnitt. Dessa API är på ett eller annat sätt tillgängliga på varje operativsystem.

● Skapa (skapande): Operativsystemet måste ha någon metod som gör det möjligt att skapa nya processer. När du skriver ett kommando i terminalen eller startar en applikation genom att dubbelklicka på ikonen, skickas en begäran till operativsystemet för att skapa en ny process och sedan starta det angivna programmet.
● Ta bort: Eftersom det finns ett gränssnitt för att skapa en process, måste operativsystemet också erbjuda möjlighet till tvingad borttagning av processen. De flesta program kommer naturligtvis att startas och avslutas av sig själva i takt med att de körs. I annat fall skulle användaren vilja kunna avsluta dem, och ett gränssnitt för att stoppa processen skulle därför vara användbart.
● Vänta (väntande): Ibland är det användbart att vänta på att processen ska slutföras, så vissa gränssnitt tillhandahålls för att möjliggöra detta.
● Övrig kontroll (olika styrningar): Förutom att döda och vänta på processer finns det också olika kontrollmetoder. Till exempel ger de flesta operativsystem möjligheten att frysa en process (stoppa dess körning under en viss tid) och att sedan återuppta den (fortsätta exekveringen).
● Status (status): Det finns olika gränssnitt för att få information om en process, såsom hur länge den har körts eller vilket tillstånd den befinner sig i.

Skapande av process: detaljer

En intressant aspekt är hur program faktiskt omvandlas till processer. Särskilt hur operativsystemet laddar och startar ett program. Hur en process skapas konkret.
Först måste operativsystemet ladda programmets kod och statiska data till minnet (i processens adressutrymme). Program ligger vanligtvis på disken eller en solid-state-enhet i något körbart format. Därför kräver processen att ladda program och statiska data till minnet att operativsystemet kan läsa dessa byte från disken och placera dem någonstans i minnet.

I tidiga operativsystem utfördes laddningsprocessen ivrigt (eagerly), vilket betyder att koden laddades helt till minnet innan programmet startades. Moderna operativsystem gör detta lat (lazily), genom att ladda bitar av kod eller data bara när de behövs av programmet under dess körning.

Efter att koden och de statiska data har laddats in i minnet måste operativsystemet utföra ytterligare några steg innan processen kan startas. Ett visst minnesutrymme måste avsättas för stacken. Program använder stacken för lokala variabler, funktionsparametrar och returadresser.. Operativsystemet avsätter detta minne och ger det till processen. Stacken kan också avsättas med vissa argument, specifikt fyller den funktionsparametrarna för main(), som till exempel en array av argc och argv.

Operativsystemet kan också avsätta ett visst minnesutrymme för programmets heap. Heapen används av program för explicit begärd dynamiskt allokerad data.. Program begär detta utrymme genom att anropa funktionen malloc() och frigör det explicit genom att anropa funktionen free()Högen behövs för datatyper som: länkade listor, hash-tabeller, träd och andra. I början reserveras en liten mängd minne för högen, men med tiden kan högens minnesbegärningar öka genom biblioteks-API-anropet malloc(). Operativsystemet är involverat i att tilldela mer minne för att hjälpa till att uppfylla dessa begärningar.

Operativsystemet kommer också att utföra initialiseringsuppgifter, särskilt de som rör in- och utmatning. Till exempel har varje process i UNIX-system som standard 3 öppna filbeskrivare för standard inmatnings-, utmatnings- och felström. Dessa beskrivare gör det möjligt för program att läsa in data från terminalen samt att skriva ut information på skärmen.

Genom att ladda kod och statiska data i minnet, skapa och initiera stacken och även utföra annat relaterat till in- och utmatningsuppgifter förbereder operativsystemet plattformen för processens utförande. Till slut finns det en sista uppgift: att köra programmet via dess ingångspunkt, kallad funktionen main(). När kontrollen övergår till funktionen main() överlämnar operativsystemet kontrollen till den nyligen skapade processen, vilket gör att programmet börjar köras.

Processens tillstånd

Nu när vi har en viss förståelse av vad en process är och hur den skapas, låt oss lista de tillstånd som en process kan befinna sig i. I sin enklaste form kan processen befinna sig i ett av dessa tillstånd:
● Running. I körande tillstånd körs processen på processorn. Det innebär att instruktionerna utförs.
● Redo. I klart tillstånd är processen redo att starta, men av någon anledning utför operativsystemet den inte vid den aktuella tidpunkten.
● Blockerad. I blockerat tillstånd utför processen operationer som gör att den inte är redo att köras förrän en viss händelse inträffar. Ett vanligt exempel är när processen initierar en IO-operation, blir den blockerad och på så sätt kan en annan process använda processorn.

Tänk dig dessa tillstånd som ett graf. Som vi kan se på bilden kan processens tillstånd växla mellan RUNNING och READY efter operativsystemets (OS) beslut. När processens tillstånd förändras från READY till RUNNING betyder det att processen har schemalagts. I motsatt riktning — avbruten från schemaläggning. I det ögonblick processen blir BLOCKED, till exempel under en IO-operation, kommer OS att hålla den i detta tillstånd tills en viss händelse inträffar, som exempelvis avslutandet av IO. I det ögonblicket övergår den till tillståndet READY och kan omedelbart gå till tillståndet RUNNING, om OS så beslutar.
Låt oss titta på ett exempel på hur två processer går igenom dessa tillstånd. Först föreställer vi oss att båda processerna är aktiva och vardera använder endast CPU. I sådana fall kommer deras tillstånd att se ut på följande sätt.

I nästa exempel begär den första processen IO efter en tid av arbete och övergår till tillståndet BLOCKED, vilket ger den andra processen möjlighet att starta (FIG 1.4). OS ser att process 0 inte använder CPU och startar process 1. Under tiden som process 1 körs avslutas IO och status för process 0 ändras till READY. Slutligen avslutas process 1, och när den är klar startas process 0, körs och avslutar sin uppgift.

Databasstruktur

Operativsystemet själv är ett program och precis som alla andra program har den vissa nyckeldata strukturer som spårar olika relevanta informationsbitar. För att spåra tillståndet för varje process kommer OS att underhålla en viss processlista för alla processer i tillståndet READY och viss ytterligare information för att spåra de processer som för närvarande körs. Dessutom måste OS spåra och blockera processer. Efter att IO avslutats är OS skyldig att väcka den nödvändiga processen och återföra den till ett tillstånd av beredskap för start.

Så, till exempel, måste OS spara tillståndet för processorns register. Vid stopp av processen sparas registertillståndet i processens adressutrymme, och vid fortsättning av dess arbete återställs registervärdena och processen fortsätter därmed sin utförande.

Förutom tillstånden ready, blocked, running finns det även vissa andra tillstånd. Ibland kan en process vid skapandet ha tillståndet INIT. Slutligen kan processen sättas i tillståndet FINAL när den redan har avslutats, men informationen om den har ännu inte rensats. I UNIX-system kallas detta tillstånd zombiprocess. Detta tillstånd är användbart när föräldraprocessen vill veta återvändande kod från barnprocessen, till exempel signalerar vanligtvis 0 en framgångsrik avslutning, medan 1 indikerar ett fel, men programmerare kan skapa ytterligare utgångskoder som signalerar olika problem. Vid avslutning gör föräldraprocessen det sista systemanropet, till exempel wait(), för att vänta på att barnprocessen ska avslutas och signalera OS att det är okej att rensa bort data relaterade till den avslutade processen.

Centrykt punkter i föreläsningen:

● Process är den huvudsakliga abstraktionen av ett körande program i OS. Vid varje given tidpunkt kan en process beskrivas utifrån dess tillstånd: minnesinnehållet i dess adressutrymme, innehållet i processorns register, inklusive instruction pointer och stack pointer samt information om IO, såsom öppna filer som läses eller skrivs.
● Process API består av anrop som program kan göra angående processer. Vanligtvis handlar det om anrop för skapande, borttagning eller andra.
● Processen befinner sig i ett av många tillstånd, inklusive running, ready, blocked. Olika händelser, såsom schemaläggning, uteslutning från schemaläggning eller väntan kan omvandla en process från ett tillstånd till ett annat.
● Processlistan innehåller information om alla processer i systemet. Varje post i den kallas process control block, vilket faktiskt är en struktur som innehåller all nödvändig information om en specifik process. 

Källa: habr.com