Bevezetés az operációs rendszerekbe

Szia Habr! Szeretném figyelmébe ajánlani egy véleményem szerint érdekes irodalom - az OSTEP - cikk-fordításait. Ez az anyag meglehetősen mélyen tárgyalja a unix-szerű operációs rendszerek munkáját, nevezetesen a folyamatokkal, különféle ütemezőkkel, memóriával és más hasonló összetevőkkel való munkát, amelyek egy modern operációs rendszert alkotnak. Az összes anyag eredetijét itt tekintheti meg itt. Kérem, vegye figyelembe, hogy a fordítás szakszerűtlenül (elég szabadon) készült, de remélem, megtartottam az általános jelentést.

A témában végzett labormunkák itt találhatók:

• eredeti: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• eredeti: github.com/remzi-arpacidusseau/ostep-code
• személyes adaptációm: github.com/bykvaadm/OS/tree/master/ostep

Egyéb alkatrészek:

• 1. rész: Bevezetés

Megnézheted a csatornámat is a címen távirat =)

Nézzük meg a legalapvetőbb absztrakciót, amelyet az operációs rendszer a felhasználóknak nyújt: a folyamatot. A folyamat meghatározása meglehetősen egyszerű – az futó program. Maga a program egy élettelen dolog, amely a lemezen található - ez egy utasításkészlet és esetleg néhány statikus adat, amely elindításra vár. Az operációs rendszer veszi ezeket a bájtokat és futtatja őket, és a programot hasznossá alakítja.
Leggyakrabban a felhasználók egynél több programot szeretnének futtatni egy időben, például böngészőt, játékot, médialejátszót, szövegszerkesztőt és hasonlókat futtathat a laptopján. Valójában egy tipikus rendszer több tíz vagy száz folyamatot futtathat egyszerre. Ez a tény megkönnyíti a rendszer használatát, soha nem kell azon törődni, hogy szabad-e a CPU, csak programokat kell futtatni.

Ez felveti a problémát: hogyan lehet sok CPU illúzióját biztosítani? Hogyan keltheti az operációs rendszer szinte végtelen számú CPU illúzióját, még akkor is, ha csak egy fizikai CPU-ja van?

Az operációs rendszer ezt az illúziót a CPU virtualizációjával hozza létre. Egy folyamat elindításával, majd leállításával, egy másik folyamat elindításával, és így tovább, az operációs rendszer fenntarthatja azt az illúziót, hogy sok virtuális CPU van, pedig valójában egy vagy több fizikai processzor lesz. Ezt a technikát ún a CPU erőforrások idő szerinti felosztása. Ez a technika lehetővé teszi a felhasználók számára, hogy tetszőleges számú párhuzamos folyamatot tudjanak futtatni. Ennek a megoldásnak a költsége a teljesítmény – mivel ha a CPU-t több folyamat osztja meg, akkor az egyes folyamatok feldolgozása lassabban történik.
A CPU-virtualizáció megvalósításához, és különösen ahhoz, hogy jól végezze, az operációs rendszernek alacsony és magas szintű támogatásra is szüksége van. Alacsony szintű támogatást hívnak mechanizmusok alacsony szintű módszerek vagy protokollok, amelyek megvalósítják a funkcionalitás szükséges részét. Ilyen funkció például a környezetváltás, amely lehetővé teszi az operációs rendszer számára, hogy leállítson egy programot, és egy másik programot futtasson a processzoron. Ez az időfelosztás minden modern operációs rendszerben megvalósul.
Ezeken a mechanizmusokon túlmenően az operációs rendszerbe beépített logika „irányelvek” formájában. Politika egy bizonyos döntéshozatali algoritmus az operációs rendszer számára. Az ilyen házirendek például eldöntik, hogy melyik programot kell először elindítani (a parancsok listájából). Így például ezt a problémát az ún ütemező (ütemezési szabályzat) és a megoldás kiválasztásakor olyan adatok vezérlik, mint: indítási előzmények (melyik program indult legtovább az utolsó percekben), milyen terhelést hordoz ez a folyamat (milyen típusú programok indultak), teljesítménymutatók (a rendszer interaktív interakcióra vagy átvitelre van optimalizálva) és így tovább.

Absztrakció: folyamat

Az operációs rendszer által végrehajtott futó program absztrakcióját nevezzük folyamat. Ahogy korábban említettük, a folyamat egyszerűen egy futó program, bármely pillanatnyi időszakban. Olyan program, amellyel összefoglaló információkat szerezhetünk a különböző rendszererőforrásokról, amelyeket ez a program elér vagy befolyásol a végrehajtása során.
A folyamat összetevőinek megértéséhez meg kell érteni a rendszer állapotait: mit tud a program kiolvasni vagy megváltoztatni működése során. Bármikor meg kell érteni, hogy a rendszer mely elemei fontosak a program végrehajtásához.
A rendszer egyik nyilvánvaló eleme, amelyet a folyamat magában foglal, az память. Az utasítások a memóriában találhatók. A program által beolvasott vagy írt adatok szintén a memóriában találhatók. Így a memória, amelyet egy folyamat meg tud címezni (úgynevezett címtér), a folyamat része.
A rendszerállapot részét képezik a regiszterek is. Sok utasítás regiszterek értékének megváltoztatására vagy értékük leolvasására irányul, így a regiszterek is a folyamat működésének fontos részévé válnak.
Megjegyzendő, hogy a gépállapot is néhány speciális regiszterből alakul ki. Például, IP - utasításmutató — egy mutató arra az utasításra, amelyet a program éppen végrehajt. Van még verem mutató és azzal kapcsolatos keretmutató, amelyek a következők kezelésére szolgálnak: függvényparaméterek, helyi változók és visszatérési címek.
Végül a programok gyakran hozzáférnek a ROM-hoz (csak olvasható memória). Ennek az „I/O” (bemenet/kimenet) információnak tartalmaznia kell a folyamat által jelenleg megnyitott fájlok listáját.

Process API

Annak érdekében, hogy jobban megértsük a folyamat működését, nézzünk meg példákat azokra a rendszerhívásokra, amelyeket minden operációs rendszer interfészének tartalmaznia kell. Ezek az API-k ilyen vagy olyan formában elérhetőek bármely operációs rendszeren.

● Teremt (létrehozás): Az operációs rendszernek tartalmaznia kell valamilyen módszert, amely lehetővé teszi új folyamatok létrehozását. Amikor beír egy parancsot a terminálba, vagy elindít egy alkalmazást duplán egy ikonra kattintva, a rendszer egy hívást küld az operációs rendszernek, hogy hozzon létre egy új folyamatot, majd indítsa el a megadott programot.
● Eltávolítás: Mivel létezik egy felület a folyamat létrehozásához, az operációs rendszernek lehetőséget kell biztosítania egy folyamat eltávolításának kényszerítésére is. A legtöbb program futás közben természetesen magától elindul és leáll. Ellenkező esetben a felhasználó szeretné megölni őket, és így hasznos lenne egy interfész a folyamat leállításához.
● Várjon (várakozás): Néha hasznos megvárni egy folyamat befejeződését, ezért vannak olyan interfészek, amelyek lehetővé teszik a várakozást.
● Egyéb vezérlés (különböző vezérlés): Az ölés és a folyamat kivárása mellett más, különféle ellenőrzési módszerek is léteznek. Például a legtöbb operációs rendszer lehetővé teszi egy folyamat leállítását (végrehajtásának leállítását egy bizonyos időszakra), majd folytatását (végrehajtás folytatása).
● Állapot (állapot): Különböző felületek állnak rendelkezésre a folyamat állapotával kapcsolatos információk megszerzésére, például, hogy mennyi ideje fut vagy éppen milyen állapotban van.

Folyamat létrehozása: Részletek

Az egyik érdekesség az, hogy a programok pontosan hogyan alakulnak folyamatokká. Főleg, hogy az operációs rendszer hogyan veszi fel és futtatja a programot. Hogy pontosan hogyan jön létre a folyamat.
Mindenekelőtt az operációs rendszernek be kell töltenie a programkódot és a statikus adatokat a memóriába (a folyamat címterébe). A programok általában lemezen vagy szilárdtestalapú meghajtón találhatók valamilyen végrehajtható formátumban. Így a program és a statikus adatok memóriába való betöltésének folyamata megköveteli, hogy az operációs rendszer képes legyen beolvasni ezeket a bájtokat a lemezről, és el tudja helyezni valahol a memóriában.

A korai operációs rendszerekben a betöltési folyamat nagy lelkesedéssel zajlott, ami azt jelenti, hogy a program indítása előtt a teljes kód betöltődött a memóriába. A modern operációs rendszerek ezt lustán teszik, vagyis csak akkor töltenek be kód- vagy adatdarabokat, amikor a program ezt megköveteli a végrehajtása során.

Miután a kód és a statikus adatok betöltődnek az operációs rendszer memóriájába, még néhány dolgot el kell végezni a folyamat futtatása előtt. Bizonyos mennyiségű memóriát le kell foglalni a verem számára. A programok a veremet használják a helyi változókhoz, függvényparaméterekhez és visszatérési címekhez. Az operációs rendszer lefoglalja ezt a memóriát, és átadja a folyamatnak. A verem bizonyos argumentumokkal is lefoglalható, konkrétan a main() függvény paramétereit tölti ki, például argc és argv tömbjével.

Az operációs rendszer bizonyos memóriát is lefoglalhat a programhalomhoz. A kupacot a programok arra használják, hogy kifejezetten dinamikusan lefoglalt adatokat kérjenek. A programok ezt a helyet a függvény meghívásával kérik malloc () és kifejezetten törli a függvény meghívásával ingyenes(). A kupac olyan adatstruktúrákhoz szükséges, mint a csatolt lapok, hash táblák, fák és mások. Eleinte kis mennyiségű memóriát foglalnak le a kupac számára, de idővel, ahogy a program fut, a kupac több memóriát kérhet a könyvtár API malloc() hívásán keresztül. Az operációs rendszer részt vesz a több memória lefoglalásában, hogy segítsen kielégíteni ezeket a hívásokat.

Az operációs rendszer inicializálási feladatokat is végrehajt, különösen az I/O-val kapcsolatosakat. Például UNIX rendszereken alapértelmezés szerint minden folyamathoz 3 nyitott fájlleíró tartozik a szabványos bemenethez, kimenethez és hibához. Ezek a fogantyúk lehetővé teszik a programok számára, hogy beolvassák a terminálról érkező bemeneteket, valamint információkat jelenítsenek meg a képernyőn.

Így a kód és a statikus adatok memóriába való betöltésével, a verem létrehozásával és inicializálásával, valamint az I/O-feladatok végrehajtásával kapcsolatos egyéb munkák elvégzésével az operációs rendszer előkészíti a szakaszt a folyamat végrehajtására. Végül még egy utolsó feladat maradt: a program futtatása a belépési ponton, a main() függvényen keresztül. A main() függvény végrehajtásával az operációs rendszer átadja a CPU vezérlését az újonnan létrehozott folyamatnak, így a program elindul.

Folyamat állapota

Most, hogy megértjük, mi a folyamat és hogyan jön létre, soroljuk fel azokat a folyamatállapotokat, amelyekben előfordulhat. A legegyszerűbb formájában egy folyamat az alábbi állapotok egyikében lehet:
● futás. Futás közben a folyamat a processzoron fut. Ez azt jelenti, hogy az utasítások végrehajtásra kerülnek.
● Kész. Kész állapotban a folyamat készen áll a futtatásra, de az operációs rendszer valamilyen oknál fogva nem hajtja végre a megadott időpontban.
● Zárolt. Blokkolt állapotban a folyamat végrehajt bizonyos műveleteket, amelyek megakadályozzák, hogy készen álljon a végrehajtásra, amíg valamilyen esemény bekövetkezik. Az egyik gyakori példa az, hogy amikor egy folyamat IO-műveletet kezdeményez, az blokkolódik, így egy másik folyamat használhatja a processzort.

Elképzelheti ezeket az állapotokat gráf formájában. Amint a képen is láthatjuk, a folyamat állapota az operációs rendszer belátása szerint változhat RUNNING és READY között. Ha egy folyamat állapota KÉSZ állapotról FUTTATÁSRA változik, az azt jelenti, hogy a folyamat ütemezve van. Az ellenkező irányba - eltávolítva az elrendezésből. Abban a pillanatban, amikor egy folyamat BLOKKOLVA válik, például elindítok egy IO-műveletet, az operációs rendszer ebben az állapotban tartja, amíg valamilyen esemény bekövetkezik, például az IO befejezéséig. ebben a pillanatban az átmenet a READY állapotba, és lehetőleg azonnal a RUNNING állapotba, ha az operációs rendszer úgy dönt.
Nézzünk egy példát arra, hogy két folyamat hogyan halad át ezeken az állapotokon. Először képzeljük el, hogy mindkét folyamat fut, és mindegyik csak a CPU-t használja. Ebben az esetben az állapotuk így fog kinézni.

A következő példában az első folyamat egy idő után lekéri az IO-t, és BLOKKOLVA állapotba lép, lehetővé téve egy másik folyamat futtatását (1.4. ÁBRA). Az operációs rendszer látja, hogy a 0. folyamat nem használja a CPU-t, és elindítja az 1. folyamatot. Amíg az 1. folyamat fut, az IO befejeződik, és a 0. folyamat állapota READY-re változik. Végül az 1. folyamat befejeződött, és a befejezést követően a 0. folyamat elindul, végrehajtja és befejezi a munkáját.

Adatstruktúra

Maga az operációs rendszer egy program, és csakúgy, mint bármely más program, rendelkezik néhány kulcsfontosságú adatszerkezettel, amelyek nyomon követik a különféle releváns információkat. Az egyes folyamatok állapotának nyomon követéséhez az operációs rendszer támogat néhányat folyamatlista az összes READY állapotú folyamathoz, valamint néhány további információ az éppen futó folyamatok nyomon követéséhez. Ezenkívül az operációs rendszernek figyelnie kell a blokkolt folyamatokat. Az IO befejezése után az operációs rendszernek felébresztenie kell a szükséges folyamatot, és futásra kész állapotba kell helyeznie.

Például az operációs rendszernek meg kell őriznie a processzorregiszterek állapotát. Abban a pillanatban, amikor a folyamat leáll, a regiszterek állapota a folyamat címterében tárolódik, működésének folytatása pillanatában pedig a regiszterek értékei visszaállnak, és így folytatódik a folyamat végrehajtása.

A kész, blokkolt, futó állapotokon kívül van néhány más állapot is. Előfordulhat, hogy a létrehozáskor egy folyamat INIT állapotban van. Végül egy folyamatot akkor lehet VÉGLEGES állapotba helyezni, amikor már befejeződött, de az információit még nem törölték. UNIX rendszereken ezt az állapotot hívják zombi folyamat. Ez az állapot olyan esetekben hasznos, amikor egy szülőfolyamat meg akarja tudni egy gyermek visszatérési kódját, például általában a 0 sikert, az 1 pedig hibát jelez, de a programozók további kimeneti kódokat adhatnak ki különböző problémák jelzésére. Amikor a szülőfolyamat leáll, egy utolsó rendszerhívást hajt végre, például a wait(), hogy megvárja, amíg az utódfolyamat befejeződik, és jelezze az operációs rendszernek, hogy törölni tudja a befejezett folyamathoz kapcsolódó adatokat.

Az előadás legfontosabb pontjai:

● folyamat — az operációs rendszerben futó program fő absztrakciója. Egy folyamat bármely adott időpontban leírható állapotával: a memória tartalma a címterében, a processzorregiszterek tartalma, beleértve az utasításmutatót és a veremmutatót, valamint az IO információk, például a nyitott fájlok olvasása vagy írása.
● Process API olyan hívásokból áll, amelyeket a programok a folyamatokhoz indíthatnak. Általában ezek létrehozási, törlési vagy egyéb hívások.
● A folyamat a számos állapot egyikében van, beleértve a futó, kész, blokkolt állapotot. A különféle események, például az ütemezés, az ütemezés alóli kivételek vagy a várakozások megváltoztathatják a folyamat állapotát.
● Folyamatlista információkat tartalmaz a rendszer összes folyamatáról. Minden egyes bejegyzést folyamatvezérlő blokknak nevezünk, ami a valóságban egy olyan struktúra, amely minden szükséges információt tartalmaz egy adott folyamatról. 

Forrás: will.com