1 Operációs rendszerek helye — számítógépes rendszer hardver

1. Operációs rendszerek helye - számítógépes rendszer (hardver, szoftver, hálózat) + felhasználók = Egységes Tervezési Egység (a felhasználók is fontos részei a tervezésnek) - szoftver: rendszerprogramok (alapszoftver) és felhasználói programok - az OS a legalapvetőbb rendszerprogram, kernel módban fut - egyéb rendszerprogramok: nem az OS részei, lehetnek hardver közeliek, hálózat közeliek, segédprogramok (pl. : fordítók, szövegszerkesztők), felhasználói módban futnak - felhasználói programok - általános applikációk (web böngészők, táblázatkezelők, stb. ) - célrendszerek (banki alkalmazások, ETR, stb. )

2. OS alapvető feladatai 1. kiterjesztett, virtuális gép – „felülről lefelé nézőpont” - megvédi a felhasználót a hardver kezelésétől - állományorientált kapcsolatot biztosít - elrejt sok alacsony szintű tulajdonságot, pl. megszakítások, időzítések, memóriaszervezés, stb. ► a felhasználónak egyenértékű, egyszerűbben kezelhető virtuális gépet nyújt 2. erőforrás-kezelő – „alulról felfelé nézőpont” - nyilvántartja az erőforrásokat (hardver és szoftver erőforrások) - kielégíti az erőforrás-kéréseket - maximalizálja a rendszer hatékonyságát, teljesítményét ► az OS az a hely, ahol az összetett rendszer minden egyes részét kezelik

3. OS alapvető tulajdonságai 1. processzusok (folyamatok) az alapvető aktív alkotóelemek - processzus: egy végrehajtás alatt lévő program, ami létrejön (programbetöltés vagy végrehajtás indítása során), létezik (fut), majd megszűnik 2. egyidejűleg több processzus létezik - a CPU-t fel kell osztani az aktuális futó processzusok között, ezt nevezzük time sharing-nek 3. erőforrások centralizált kezelése - a processzusok kérés esetén kapják meg az erőforrásokat az operációs rendszertől 4. eseményvezérelt - esemény megszakítás esemény feldolgozása esemény kiszolgálása visszatérés a megszakítás helyére

4. OS generációi – 1 -2. generáció 1. generáció (1945 -55) - nem léteztek operációs rendszerek - hatalmas, vákuumcsöves, 1 felhasználós gépek - gépi nyelvű programozás - gépek vezérlése kapcsolótáblával, később lyukkártyákkal - külön csapat tervezte, programozta, kezelte, stb. a gépeket 2. generáció (1955 -65) - tranzisztorok megjelenése → megbízhatóbb gépek → gyárthatóak, eladhatóak (több millió dolláros ár) - fortran és assembly programozás - az OS állandó a memóriában (pl. FMS, IBSYS) - elkülönültek a tervezők, gyártók, kezelők, programozók, karbantartók - kötegelt rendszerek → az elvesztegetett idő csökken - megjelent az eszközvezérlők, a verem-memória, a hívható OS eljárások, a relatív címezhetőség

5. OS generációi – 3. generáció - kis méretű integrált áramkörök (IC-k) alkalmazása, csökken az ár/teljesítmény hányados - IBM bevezeti a System/360 rendszert, egymással kompatibilis gépek családja → megszűnik a két független gyártósor - a sorozat minden gépén OS/360 operációs rendszer - multiprogramozás: CPU és I/O átfedően képes dolgozni, az OS a CPU üresjárati idejét tölti ki több belső memóriában tárolt processzus egyidejű futtatásával - memória szeletelés: az OS a memóriát szeletekre particionálja, minden partícióban egy-egy független job fut, ezeket speciális hardver védi meg más feladatok beavatkozásától - háttértárolás: az OS a feladatokat közvetlenül lemezről tudta olvasni, egy futó program befejezésekor egy új feladatot töltött a lemezről az immár üres partícióba, és elindította azt → a szalagok alkalmazásainak többsége megszűnt - COBOL, ADA, PASCAL nyelvű programozás

6. Időosztás – time slicing - a multiprogramozás egy variációja - minden felhasználónak saját on-line terminálja van - a felhasználó processzusai egy adott maximális időtartamig birtokolhatták a CPU-t → a processzus-ütemező alrendszer átadta a CPU használatának jogát egy másik processzusnak - így a kiszolgálást igénylő feladatokhoz rendelhető a CPU → nagyszámú felhasználót képes gyorsan, interaktív módon kiszolgálni a számítógép - az első időosztásos rendszer a CTSS volt, az M. I. T. fejlesztette ki egy speciálisan átalakított IBM 7094 -esen

7. Átmeneti tárolás – spooling - a 3. generációs operációs rendszereknél jelent meg - SPOOL = Simultaneous Peripheral Operation On Line - az OS a feladatokat a számítógépteremben való megjelenésükkor lemezre (disk-spool terület) tudta olvasni, valahányszor egy futó program befejeződött, az OS egy új feladatot tudott a lemezről az immár üres partícióba tölteni és elindítani, a processzus is innen kapja és ide írja adatait - ezt a technikát háttértárolásnak is hívják, és a kimentre is alkalmazták - segítségével a szalagok alkalmazásainak többsége megszűnt

8. Memória-partíciók - az OS a memóriát szeletekre particionálta, és minden partícióhoz egy-egy független job rendelődött - a multiprogramozást tette lehetővé - partíciók fajtái: - statikus: az operációs rendszer indulásakor fix darabszámú és fix méretű partíció képződött, egy feladat végrehajtásához az OS keresett egy szabad és elegendő méretű partíciót, amelyben a programnak megkezdhette a végrehajtását - dinamikus: az OS egy program végrehajtásához a szabad memóriaterületből készített egy elegendő méretű partíciót, így a partíciók száma változó

9. OS generációi – 4+ generáció - LSI (Large Scale Integration) áramkörök megjelenése → PC-k, munkaállomások (üzleti életben, hivatalokban használt nagy teljesítményű, hálózatba kötött nagyobb PC-k) - PC, Workstation operációs rendszerek: - egy felhasználós, több feladatos operációs rendszerek - felhasználóbarátok - pl. : MS-DOS, Windows verziók, stb. - hálózati operációs rendszerek: - több felhasználós, több feladatos operációs rendszerek - lényegében nem különböznek az egyprocesszoros OS-ektől - pl. : UNIX, Linux, Windows NT, stb. - osztott operációs rendszerek: - egy feladatot egy időben több processzor is végezhet - az állományok tárolását automatikusan az OS végzi - a párhuzamosításhoz bonyolult processzorütemező algoritmus szükséges

10. OS felületei - az OS-nek lehet felhasználói felülete és program felülete - felhasználói felület: - felhasználó – OS kapcsolati alrendszer - ezek egy parancsértelmezőn (command interface, shell), vagy egy grafikus felületen keresztül kommunikálnak egymással - a felhasználó parancsait értelmezi - program felület: - processzus – OS kapcsolati alrendszer - ezek rendszerhívások, könyvtári eljárások, ill. egyéb OS szolgáltatások útján kommunikálnak egymással

11. Rendszerhívások – system calls - rendszerhívások (kiterjesztett utasítások) készlete: - OS – felhasználói programok közötti kapcsolatot alkotják - meghatározzák az OS tényleges tevékenységét - interpretáció kérdése, mi alkot rendszerhívást, pl. a POSIX szabvány csak a biztosítandó eljárásokat sorolja fel - a MINIX 53 rendszerhívásának 6 kategóriája: - processzusok létrehozása és megszüntetése - szignálok kezelése - fájlok írása és olvasása - katalóguskezelés - adatvédelem - időkezelés - ezeken kívül létezhetnek további kategóriák: - eseménykezelés - memóriakezelés - üzenetkezelés

12. OS szerkezete – rétegelt 1. - az operációs rendszer rétegek hierarchiája, minden réteg az alatta lévőre épül, - minden réteg egy „virtuális gép”, a rétegbeli függvények által nyújtott funkciók összessége - az első ilyen rendszer a E. W. Dijkstra által tervezett THE volt, az alábbi 6 réteggel rendelkezett: 5. rendszert kezelő processzus 4. felhasználói programok 3. bemenet/kimenet 2. processzus kommunikáció, gépkezelő konzol 1. memóriakezelés 0. processzor-hozzárendelés, multiprogramozás - eljárások, függvények rétegekbe csoportosulnak → felügyelt eljáráshívások valósíthatóak meg - bármely n. rétegbeli eljárás csak a közvetlenül alatta lévő n-1. réteg eljárásait hívhatja → áttekinthető eljárásrendszer

12. OS szerkezete – rétegelt 2. - minden réteg saját adatterülettel rendelkezhet → áttekinthető adatáramlás - program-végrehajtási szinteket különböztetünk meg: - normál mód: - felhasználói programok - OS eljárásainak meghatározott részhalmaza - kitüntetett mód: - speciális OS eljárások ill. rendszerprogramok is - a rétegelt szerkezet könnyen konfigurálható, például az eszközvezérlők egy rétegbe csoportosíthatóak

13. OS szerkezete – kliens/szerver 1. - A korszerű operációs rendszerek egyre több programot helyeznek magasabb rétegekbe, azok kikerülnek az OS-ből → egy minimális kernel marad - egymással kommunikáló processzusok rendszere – üzenetek adása ill. vétele értendő kommunikáció alatt - az OS feladata az üzenetek közvetítése a processzusok között - szolgáltatást kérünk az OS-től → a kliensprocesszus kérést küld a szerverprocesszusnak → ez elvégzi a munkát és választ küld - az üzenet felépítése: - fejléc (header), az üzenet továbbításához szükséges információkat tartalmazza (pl. címzett, feladó, hossz, kódolás. . . ) - tartalom (body), a címzett állítja össze, a feladó értelmezi, szerkezete a kommunikációs protokoll által definiált - a kliens- és szerverprocesszus felhasználói módban fut - a kernel felügyelt módban fut, a kliens és a szerver közötti kommunikációt kell kezelnie

13. OS szerkezete – kliens/szerver 2. - az operációs rendszer felhasználói módban nem végrehajtható funkcióinak kezelése: - speciális, kernel módban futó szerverprocesszusokkal - a kernelbe beépített minimális kezelőkészlettel - a kliens/szerver struktúra előnyei: - újabb szerverprocesszusokkal az operációs rendszer szolgáltatásai bármikor bővíthetők - a szerverprocesszusok egymástól teljesen függetlenül programozhatóak - hálózatok esetén is alkalmazható, ekkor a szerver- és kliensprocesszus külön OS-en fut, és ezek a hálózaton keresztül cserélnek üzeneteket

14. Kliens/szerver programozás - két ill. három rétegű alkalmazás-szerkezeten alapul - a kliens számítógépen futó kliens processzus a szükséges szolgáltatásokat a hálózaton üzenetek formájában kéri a szerver gépen futó szerver alkalmazástól - a kliens gép feladatai: - a képernyő kezelése - a felhasználó akcióinak megfelelő kérések összegyűjtése és továbbítása - a válaszok fogadása

15. OS alrendszerek - az operációs rendszerekben egy-egy összetartozó funkciócsoport egy alrendszert alkothat, ilyen alrendszerek lehetnek: - processzuskezelő – process handling pl. gondoskodik a CPU időosztásáról - erőforrás-kezelő – resource handling pl. kölcsönös kizárás, szinkronizáció, stb. - memóriakezelő – memory management - bevitel/kiviteli – input/output - fájlkezelő – file, directory and file system management - időkezelő – time management pl. maximális végrehajtási idő meghatározása - védelmi, biztonsági – protection, security - jelkezelő – signal handling - eseménykezelő – event handling - felhasználói felületet kezelő pl. a parancsértelmező (shell)

16. Processzusok, fonalak 1. - processzus: - végrehajtás alatt lévő program - tartozik hozzá egy saját címtartomány, a memória egy szelete, amelyen belül az olvashat és írhat - címtartományának tartalmát memóriatérképnek nevezik, ez a program szövegéből, adataiból és verméből áll - a memóriatérképen kívüli információit az OS processzustáblázata tárolja (regiszterkészlet: utasításszámláló, veremmutató, egyéb hardver regiszterek, futáshoz szükséges egyéb információk) - állapota lehet futó, futáskész vagy blokkolt - egy processzus létrehozhat egy vagy több gyermekprocesszust, ezek újra sajátjaikat → fastruktúra jön létre - közös feladat végrehajtásában együttműködő processzusok kommunikálhatnak is egymással - erőforrásokat kizárólagosan ill. osztottan használhatnak

16. Processzusok, fonalak 2. - több processzus között is megoszthatjuk a processzort egy processzusütemezési algoritmussal, mellyel meghatározzuk, hogy mikor fejezzük be a munkát az egyik processzuson és szolgáljunk ki egy másikat - fonal: - szekvenciálisan végrehajtódó program - a processzus hozza létre - osztozik a létrehozó erőforrásain, címtartományán, jogosultságain - saját állapota és verme van - kezelése jelentős részben a programozó felelőssége

17. Kontextus csere - egy modern számítógép több dolgot képes egy időben elvégezni - multiprogramozható rendszerben a CPU váltakozva hajtja végre a processzusok programjait, futtatva azokat néhány 10 vagy 100 ezredmásodpercig - a processzor minden időpillanatban csak egy programot futtat, de a párhuzamosság illúzióját kelti → látszatpárhuzamosság ↨ többprocesszoros rendszerekben hardver-párhuzamosság - kontextus csere – context switching: - a CPU át akar váltani a P 1 processzusról a P 2 processzusra - a P 1 állapotát kimenti a CPU a hardver regisztereiből az erre a célra fenntartott memóriaterületre - a P 2 korábban memóriába mentett állapotát helyreállítja a CPU a regisztereiben

18. Memóriatérkép - minden processzushoz tartozik egy saját címtartomány, azaz a memória egy minimális és maximális című helye közötti szelet, amelyen belül az olvashat és írhat - a címtartomány tartalmát memóriatérképnek nevezzük, amely a következőkből áll: - szövegszegmens – a program kódja - adatszegmens – konstansokat és változókat tartalmazhat - veremszegmens – adatot (pl. lokális változók), információkat (pl. Last-In-First-Out kezelés, Push/Pop utasítások, stb. ) tartalmazhat - dinamikus változók (pl. heap)

19. Processzus állapotai, állapotátmenetek 1. - bár minden processzus önálló egység saját utasításszámlálóval és belső állapottal, gyakran szükségük van arra, hogy más processzusokkal kölcsönhatásba lépjenek ↓ ha az egyik processzus végrehajt egy kommunikációs lépést, akkor megváltozhat a másik processzus állapota - egy processzus egy adott pillanatban 3 -féle állapotban lehet: - futó – az adott pillanatban használja a CPU-t - futáskész – készen áll a futásra, de ideiglenesen leállította a processzorütemező, és átadta a CPU használati jogát egy másik processzusnak, hogy az futhasson - blokkolt – bizonyos külső esemény bekövetkezéséig logikailag nem képes futni, tipikusan azért, mert olyan bemenetre vár, mely még nem elérhető - segédállapotok – iniciális, terminális

19. Processzus állapotai, állapotátmenetek 2. - léteznek átmenetek is az állapotok között: - futó→blokkolt: - automatikus - futó→futáskész: - a processzusütemező feladata - futáskész→futó: - a processzusütemező feladata - blokkolt→futáskész: - akkor fordul elő, ha a processzus által várt külső esemény bekövetkezik - ha egy processzus sem fut az adott pillanatban, akkor a processzus egyből futó állapotba megy át, ellenkező esetben várakoznia kell, míg a CPU elérhető nem lesz.

20. Processzus leírása 1. - a processzusok nyilvántartására, tulajdonságainak leírására szolgáló memóriaterület a Process Table, illetve a Process Control Block (PCB) - minden processzus leírása a következőket tartalmazza: - processzus azonosító – process ID: egyértelmű hivatkozási sorszám, a processzus létrejöttekor kapja meg - létrehozó processzus azonosító: a szülő processzus azonosítója - memóriatérkép: a processzus címtartományának tartalma, idővel változik - processzus állapota: futó, futáskész, blokkolt - jogosultságok: read, write, execute – létrehozó állítja be - birtokolt erőforrások: kizárólagosan ill. osztottan használt erőforrások nyilvántartása - meg nem kapott erőforrások: a processzus által kért, de meg nem kapott erőforrások

20. Processzus leírása 2. - CPU-állapot mentési terület: kontextus cseréhez; utasításszámláló, verempointerek, regiszterek tárolására - egyéb számlázási, statisztikai információk - egyidejűleg létező processzusok leírásai láncra vannak fűzve - processzus létrejön → leírására szolgáló memóriaterület (PCB) hozzá csatolódik a lánchoz - processzus megszűnik → a PCB láncszem törlődik a láncról - a processzusleírások láncán műveleteket is végre lehet hajtani, ilyenek lehetnek például a következők: - processzus gyermekeinek keresése – pl. szülőprocesszus megszűnésekor, - futáskész processzusok keresése – pl. CPU kiosztásakor, - erőforrást igénylő processzusok keresése – pl. erőforrás odaítélésekor, stb.

21. Processzus létrehozása - egy processzus létrehozásának lépései az alábbiak: 1. memóriaterület foglalása a processzus PCB számára 2. a PCB feltöltése iniciális adatokkal: - memóriatérkép kezdeti adatai - kizárólagosan birtokolt erőforrások - a processzor állapota - indítási cím ► utasításszámláló - létrehozó jogosultságai ► jogosultságok 3. memória foglalása a program szövege, adatai és verme számára, és ezek betöltése, a legtöbb OS-ben ez a létrehozó feladata 4. a processzus PCB hozzáfűzése a processzusleírások láncára 5. a processzus állapotának futáskészre állítása

22. Processzus megszüntetése - egy processzus megszüntetésének lépései az alábbiak: 1. gyermekprocesszusok megszüntetése rekurzívan, vagy más szülőprocesszushoz csatolása 2. processzus állapotának terminálisra történő állítása 3. processzus PCB lecsatolása a processzusleírások láncáról, a processzus ezután már nem osztozik a CPU-n 4. a processzus birtokában lévő erőforrások felszabadítása 5. a memóriatérképnek megfelelő memóriaterületek felszabadítása 6. processzus PCB memóriaterületének felszabadítása - egy processzus a következő módokon szűnhet meg: - önmagát megszüntetheti az exit() paranccsal → jelet küld a létrehozó processzusnak a megszüntetés sikerességéről - a létrehozója vagy annak ősei megszüntethetik - a „kill” szignál megszüntetheti, ha az nincsen lekezelve

23. Processzus ütemezés feladata, céljai - amikor egyidejűleg több futáskész állapotú processzus létezik, az OS-nek el kell döntenie, hogy melyik fusson először → ütemezője hozza meg ezt a döntést, ütemezési algoritmus - az ütemező által elérni próbált célok: - pártatlanság – egy adott processzus indokolatlanul a többi processzus kárára ne részesüljön előnyben - hatékonyság – a CPU kihasználtsága 100% legyen - válaszidő – csökkenteni az interaktív felhasználók válaszidejét - átfutási idő – egy processzus létrejöttétől a megszűnéséig tartó időtartam minél rövidebb legyen - áteresztőképesség – egységnyi idő alatt végrehajtott processzusok száma minél nagyobb legyen - erőforrás-kihasználtság minél jobb legyen - költség alacsony legyen, az algoritmus nem lehet túl bonyolult - megbízhatóság – az átfutási idő nem függhet az egyidejűleg létező processzusoktól

24. Processzus ütemezés paraméterei 1. Az ütemezési algoritmus ezek alapján dolgozik; a processzusok azon tulajdonságai, melyeket figyelembe vesz az ütemező: - processzus létrejöttekor besorolódhat processzus osztályokba: - batch – a processzus futtatása „ráér” - interaktív – a shell-ben kiadott parancs hatására jön létre a processzus, mely a felhasználókkal is kommunikálhat - real-time – időre érzékeny processzusok, ezek eseményeket szolgálnak ki - processzus rendelkezhet prioritással, mely lehet: - rögzített – létrehozás után nem változik - változó – az ütemező változtatja az algoritmusától függően - processzusnak lehet típusa is: - CPU-intenzív - erőforrás-igényes

24. Processzus ütemezés paraméterei 2. - real-time (eseményeket kiszolgáló) rendszerekben feltételek tartozhatnak egy processzushoz - dinamikus információk, ezeket az ütemező gyűjti: - eddig használt összes CPU idő, - maximális memória, - erőforráskérések gyakorisága, - adott processzus „elhanyagoltsága”, stb.

25. Processzus ütemező algoritmusok – round robin, tiszta prioritásos 1. - round robin ütemezés: - egyik legrégebbi, legegyszerűbb, legszélesebb körben használt - minden processzusnak ki van osztva egy időszelet, amely alatt engedélyezett a futása - időszelet végen a processzus fut → előjegyzett processzus kapja meg a CPU használati jogát - időszelet vége előtt véget ér a processzus → a CPUátkapcsolás a processzus blokkolásakor megtörténik - az ütemező egy listát tart nyilván a futtatandó processzusokról, ha a processzus felhasználta a saját időszeletét, a végére kerül - az átkapcsolás folyamata bizonyos adminisztrációs időt igényel, ezt a folyamatot nevezik processzusátkapcsolásnak ↓ - ha az időszelet túl kicsi, az csökkenti a CPU hatékonyságát, ha túl nagy, akkor az interaktív kérdésekre lassú a válaszadás

25. Processzus ütemező algoritmusok – round robin, tiszta prioritásos 2. - tiszta prioritásos ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzusnak engedjük meg, hogy fusson - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére a következő módszerek alkalmazhatók: - minden óraütemben csökkentjük a futó processzus prioritását - minden processzushoz hozzárendelünk egy max. időszeletet - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

26. Processzus ütemező algoritmusok – aging, feedback 1. - aging – növekvő prioritásos – ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzusnak engedjük meg, hogy fusson - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére minden óraütemben csökkentjük a futó processzus prioritását - ha egy processzus nem választódik ki, akkor nő a prioritása - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

26. Processzus ütemező algoritmusok – aging, feedback 2. - feedback – visszacsatolási prioritásos – ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzus futhat - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére minden processzushoz hozzárendelünk egy maximális időszeletet - ha a processzus időszeletének lejárta miatt veszti el a CPU használati jogát, akkor csökken a prioritása, ha erőforráskérés miatt, akkor marad → a CPU-intenzív és erőforrás-igényes processzusok kiegyenlítődnek - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

27. Processzus ütemező algoritmusok – fair share - a CPU-t a processzusok között „igazságosan elosztó” ütemezés - a processzusok osztályokba sorolódnak - az osztályok meghatározott arányban részesülnek az összes CPU-időből - az ütemező méri az egyes osztályokbeli processzusokra fordított összes CPU-időt - ha egy osztály elmarad az őt megillető aránytól, akkor abból az osztályból választ az ütemező processzust - osztályon belül a választás más szempont alapján történik

28. Processzus ütemező algoritmusok – előrelátó algoritmusok - a „legrövidebb feladatot először” algoritmus - olyan rendszerekben alkalmazzák, melyek speciálisan kötegelt feladatok feldolgozására alkalmasak, és ezen feladatok futási ideje előre ismert - mindig a legkisebb összes CPU-időt igénylő processzus kapja meg a processzor használati jogát - az algoritmus bizonyíthatóan optimális, legyen 4 feladatunk: a, b, c és d futásidőkkel, ekkor az első befejezi a időpontban, a második a+b időpontban, stb. → az átlagos áthaladási idő: (4 a+3 b+2 c+d)/4, tehát a többszörösen járult hozzá az átlaghoz → neki kell a legrövidebb feladatnak lennie

29. Processzus ütemezés elmélete - az ütemezéshez létezik egy szelekciós függvény: int f (p, w, e, s), ahol - p: a processzus prioritása - w: a processzus eddig rendszerben eltöltött összideje - e: a processzus által eddig használt összes CPU-idő - s: a processzus által igényelt összes CPU-idő - a függvény által visszaadott f értékét minden aktív processzusra kiszámoljuk, és az érték szerint döntünk - f ~ max(w) → FIFO algoritmus - f ~ állandó → round robin, prioritásos, stb. - f ~ min(s) → „legrövidebb feladatot először” algoritmus - normalizált átfutási időnek a w/s hányadost nevezzük, 1 ≤ w/s = 1/(1 -r), ahol 0≤r<1 ► az ütemezési algoritmus hatékonyságát r jellemzi, minél ez az érték, annál jobb az algoritmus

30. Processzus ütemezés szimulációja - a processzus ütemező algoritmust mesterséges körülmények között szimulálhatjuk, hogy elemezni tudjuk a hatékonyságát - a szimulációhoz szükséges paraméterek: - l: egységnyi (1) idő alatt átlagosan létrejövő processzusok száma - s: egy processzus átlagos össz CPU időszükséglete (s • l ≤ 1) - minden létrehozott processzushoz hozzárendelődnek a szimulálandó ütemezési algoritmusban használt paraméterek (pl. prioritás) - futtatjuk a szimulált algoritmust a fenti paraméterekkel véletlenszerűen létrehozott processzusokra, mérjük a normalizált átfutási időket - hisztogramot rajzolunk az s szerint csoportosított átlagos normalizált átfutási időknek megfelelő r értékekből, és ezt értelmezzük

31. Kölcsönös kizárás - az együtt dolgozó processzusok közös tárolóterületen (memória, fájl) osztozhatnak, amelyből mindegyik olvashat és írhat - versenyhelyzet: kettő vagy több processzus olvas vagy ír megosztott adatokat, és a végeredmény attól függ, hogy ki és pontosan mikor fut - a kölcsönös kizárás valamilyen módszer, mely biztosítja, hogy ha egy processzus használ megosztott változót, fájlt, stb. , akkor a többi processzus tartózkodjon ettől a tevékenységtől - kritikus szekció: a processzus programjának az a része, mely megosztott memóriához vagy fájlokhoz nyúl, vagy más kritikus tevékenységet végez, mely versenyhelyzetekhez vezethet - a megfelelő kölcsönös kizárás szabályai: - legfeljebb egy processzus lehet a kritikus szekciójában - véges időn belül bármely proc. beléphessen a krit. szekciójába - krit. sz. kívüli proc. nem befolyásolhatja más krit. sz. -ba lépését - nem lehet feltétel a CPU-k száma vagy a proc. -ok lefutási ideje

32. Entry – Exit módszerek struktúrája a kölcsönös kizárásra - a kölcsönös kizárás szabályainak megfelelő Entry-Exit módszerek struktúrája a következő: - a processzus az entry eljárással belép a kritikus szekciójába - itt már használhatja a processzus a megosztott fájlokat, memóriát, stb. - a processzus az exit eljárással kilép a kritikus szekciójából - ezután a következő processzus beléphet saját kritikus szekciójába

33. Entry – Exit módszerek – hardver módszerek 1. - megszakítások tiltása: - a legegyszerűbb megoldás, mihelyt egy processzus belép saját kritikus szekciójába letiltja az összes megszakítást, és újraengedélyezi, mielőtt elhagyja azt - problémák ezzel a módszerrel: - ütemező-, esemény-kiszolgáló processzusok nem jutnak CPU-hoz → veszélyes - többprocesszoros rendszerben a tiltás csak egy adott CPU-ra vonatkozik - nem megfelelő a felhasználói processzusok számára - a TSL (Test and Set Lock) utasítás - beolvassa a memóriaszó tartalmát egy regiszterbe, és ezután egy nemnulla értéket ír erre a memóriacímre - az utasítás végrehajtásával a CPU zárolja a memóriabuszt, a művelet befejezéséig megtiltva ezzel más CPU-knak a memória elérését

33. Entry – Exit módszerek – hardver módszerek 2. - ha a lock megosztott változó értéke 0, bármelyik processzus beállíthatja 1 -re a TSL használatával, és ezután olvashatja, írhatja a megosztott memóriát - miután ezt megtette, visszaállítja lock értékét 0 -ra - tevékeny várakozást követel meg enter_region; TSL register, lock CMP register, #0 JNE enter_region RET leave_region; MOVE lock, #0 RET

34. Entry – Exit módszerek – Peterson „udvariassági” módszer 1. #define FALSE 0 #define TRUE 1 #define N 2 int turn; interested[N]; void enter_region (int process) { int other; other = 1 - process; interested[process] = TRUE; turn = process; while (turn == process && interested[other] == TRUE { } }

34. Entry – Exit módszerek – Peterson „udvariassági” módszer 2. void leave_region (int process) { interested[process] = FALSE; } - csak két processzusra működik - mielőtt a kritikus szekcióba lép, minden processzus meghívja az enter_region-t, paraméterként átadva a saját processzus sorszámát, 0 -t vagy 1 -et - ha szükséges várakozik a biztonságos belépésig - miután végzett meghívja a leave_region-t, hogy ezt jelezze, és megengedje egy másik processzusnak a belépést - tevékeny várakozást követel meg

35. Entry – Exit módszerek – Lamport „sorszám” módszer int N; // sorszám-tömb int My. Noi = 0; // saját sorszám-változó Entryi: My. Noi = N++; //pi egyedi belépési sorszámot kap wait while(My. Noi != minj(My. Noj, My. Noj != 0)); ki: … Exiti: My. Noi = 0; // pi kilépett - ez a módszer akárhány processzusra működik - mindegyik processzus olvassa a többi processzus sorszámváltozóját - tevékeny várakozást követel meg → elpazarolt CPU-idő

36. Entry – Exit módszerek – Dijkstra féle bináris szemafor int S = N; // globális szemafor változó (itt nem bináris) Entry: // i-től független! DOWN(S): wait while (S == 0); S = S - 1; ki: … Exit: // i-től független! UP(S): S = S + 1; // pi kilépett - E. W. Dijkstra javasolta, hogy egy új, globális, egész változótípus létrehozását, melyet minden processzus lát → szemafor - két művelet van, a DOWN és az UP, ezek rendszerhívásokként vannak megvalósítva → az OS tilt bennük minden megszakítást - a DOWN művelet megvizsgálja, hogy a szemafor értéke nagyobb-e, mint nulla, ha igen, akkor csökkenti az értékét - az UP a megadott szemafor értékét növeli, végrehajtását semmilyen processzus nem blokkolhatja

37. Hoare monitor a kölcsönös kizárásra 1. - Hoare és Brinch Hansen egy magasabb szintű szinkronizációs primitívet javasoltak, amit monitornak neveztek el - a monitor több processzusból hívható, közös állapot- és globális változókkal rendelkező eljárások, változók és adatszerkezetek együttese, és mindezek egy speciális csomagba vannak összegyűjtve - a processzusok bármikor hívhatják monitorban lévő eljárásokat, de nem érhetik el közvetlenül a monitor belső adatszerkezeteit a monitoron kívül deklarált eljárásokból - minden időpillanatban csak egy processzus lehet aktív egy monitorban - processzus meghív egy monitoreljárást → az eljárás ellenőrzi, hogy más aktív-e a monitoron belül, ha igen, akkor a hívó felfüggesztődik, ha nem, akkor a hívó processzus beléphet - minden kritikus szekciót monitoreljárássá alakítva soha lesz két processzus egy időben a saját kritikus szekciójában

37. Hoare monitor a kölcsönös kizárásra 2. - szükség van egy módszerre, mellyel blokkolhatunk egy processzust, ha az nem tud tovább haladni → állapotváltozók, és műveleteik (WAIT, SIGNAL) bevezetése monitor example int i; // globális minden eljárásra condition c; // állapot-változó procedure producer(x) {. . . WAIT(c); … // a monitoreljárás nem tudja folytatni, blokkolja a } // hívót, más processzus beléphet a monitorba procedure consumer(x) {. . . SIGNAL(c); // a processzus felébreszti alvó „partnerét” azon } // az állapotváltozón, amelyre az éppen vár end monitor;

38. Szinkronizáció alapproblémái - legyenek p 1, p 2, … , pn processzusok és a 1, a 2, … , am akciók - ha a pi processzus csak feltételhez szabva hajthatja végre az aj akciót (pl. az a feltétel, hogy egyetlen másik processzus sem hajthatja végre az adott akciót = kölcsönös kizárás), akkor a feltétel bekövetkeztéig a pi processzus blokkolt állapotban lesz - a szinkronizációs probléma tulajdonképpen általánosítása a kölcsönös kizárás problémájának (pl. legyen v globális változó, amíg p 1 ír v-be, p 2 nem írhatja/olvashatja v-t) - holtpont (deadlock) : processzusok egy csoportja blokkolt és egyetlen csoportbeli processzus sem képes futáskésszé válni, „örökre” blokkoltak maradnak - éheztetés (starvation): olyan helyzet, melyben minden program korlátlan ideig folytatja a futást, de nem tesz semmit a fejlődés érdekében

39. Étkező filozófusok szinkronizációs probléma 1. - E. W. Dijkstra vetette fel és oldotta meg - 5 filozófus ül egy kerek asztal körül, mindegyik előtt van egy tányér spagetti, és az egymás melletti tányérok között van 1 villa - a filozófusok élete evésből és gondolkodásból áll - a filozófusoknak két villára van szükségük, hogy ehessenek - ha egyikük éhes lesz, megpróbálja megszerezni a bal és jobb oldalán lévő villát – egyszerre egyet – tetszőleges sorrendben - ha ez sikerült, akkor eszik egy ideig, majd leteszi a villákat és gondolkodással folytatja - a feladat az, hogy úgy szinkronizáljuk a filozófusokat, hogy véges időn belül mindegyikük kapjon 2 villát és ne haljon éhen egyikük sem - a megoldás lépései a következők: 1. a filozófusok gondolkodnak egy ideig, majd megpróbálják megszerezni mindkét villát egyszerre. 2. mindegyikük az állapotát éhesre állítja

39. Étkező filozófusok szinkronizációs probléma 2. 3. ha a filozófusnak sikerül megszereznie mindkét villát, akkor eszik, közben kizárja a többi filozófust 4. amennyiben a filozófus nem tudja megszerezni a villákat, akkor blokkolódik 5. az evés befejező filozófusok állapotukat gondolkodóra állítják, majd megnézik a bal és a jobb szomszédjukat, hogy ők így már tudnak-e enni – az állapotuk éhes kell legyen és blokkolva kell lenniük 6. ha igen, akkor felébresztik őket, hogy ők is tudjanak enni - holtpont nem alakulhat ki - ez olyan processzusok modellezésére hasznos, amelyek korlátozott számú erőforrások (pl. I/O eszközök) kizárólagos eléréséért versenyeznek

40. Gyártók – Fogyasztók szinkronizációs probléma 1. - két processzus osztozik egy közös, rögzített méretű tárolón - az gyártó adatokat helyez el benne, a fogyasztó kiveszi azokat - a megoldás szemaforok felhasználásával: #define N 100 int mutex = 1; int empty = N; int full = 0; void producer() { int item; while (TRUE) { produce_item(&item); down(&empty); down(&mutex); enter_item(item);

40. Gyártók – Fogyasztók szinkronizációs probléma 2. up(&mutex); up(&full); } } void consumer(void) { int item; while (TRUE) { down(&full); down(&mutex); remove_item(item); up(&mutex); up(&empty); } }

41. Olvasók – Írók szinkronizációs probléma - Courtois és mások vetették fel - adatbázis elérését modellezi (pl. egy légitársaság helyfoglalási rendszere sok versengő processzussal, melyek mind olvasni vagy írni szeretnének - több processzus egyidejű olvasása elfogadható ↔ ha egy proc. írja az adatbázist, akkor más processzusoknak nem szabad azt elérniük - amíg legalább egy olvasó aktív, további olvasók jöhetnek - mivel az írónak kizárólagos hozzáférésre van szüksége, mindaddig fel lesz függesztve, amíg van olvasó - másik megoldás: ha egy író már vár, akkor az utána jövő olvasók fel lesznek függesztve, így az írónak csak azt kell megvárnia, hogy az érkezése előtti aktív olvasók befejezzék ► kevesebb egyidejűséget valósít meg, a hatékonyság csökken

42. Petri séma 1. - processzusok szinkronizációjának leírási, ábrázolási módja - akció: szekvenciálisan végrehajtódó programrészletek bemenetekkel és kimenetekkel - az akciók csak bizonyos feltételekkel hajtódnak végre, ezt a bemenetek határozzák meg - Petri-féle szinkronizációs séma: akciók bemeneteiken és kimeneteiken keresztül összekötött hálózata, vagy gráfja; olyan programot ábrázoló diagram, melynek több processzussal történő végrehajtására is van lehetőség - indítási feltétel: legalább egy feltételpont az akció bemenetén - egy akció végrehajtható, ha minden bemenetén van pont - akció végrehajtása: minden bemenetéről 1 pont levonódik, és minden kimenetéhez 1 pont hozzáadódik - kezdőállapot – a sémában a be- és kimeneteken a kezdő-pontok el vannak helyezve

42. Petri séma 2. - végállapot – a sémában nincs végrehajtható akció - végrehajtás – az akciók lehetséges végrehajtásaival kapott sémasorozat a kezdőállapottól a végállapotig

43. Processzusok kommunikációja Processzusok együttműködéséhez szükséges azok közötti kommunikáció, ennek módszerei a következők: - adatok cseréje csővezetéken keresztül – konfliktushelyzet itt is előállhat, ha a csőben nincs adat, akkor a pipe-ból olvasó processzus blokkolódik → olyan módszer, mint a versenyző processzusok esetében - üzenetek adás-vétele: két processzus vagy egy operációs rendszeren belül, vagy hálózaton keresztül két külön operációs rendszeren beszélget egymással - közös adatterület – osztott memória: a UNIX-ban, Linux-ban lehet definiálni osztott memóriaterületet - kliens/szerver modell segítségével

44. Csővezeték – pipe 1. #define STD_IN 0 / * standard bemenet fájlleírója* / #define STD_OUT 1 /* standard kimenet fájlleírója*/ pipeline(char *process 1, char *process 2) { int fd[2]; pipe(&fd[0]); / * pipe létrehozása * / if (fork() != 0) { / * ezeket a szülőprocesszus hajtja végre * / close(fd[0]); / * a pipe-ból nem kell olvasnia * / close(STD_OUT ); / * új standard kimenet előkészítése * / dup(fd[1]); / * standard kimenetet az fd[1]-hez rendeljük * / close(fd[1]); / * ez a fájlleíró már nem kell * / execl(process 1, 0); } else { / * ezeket a gyermekprocesszus hajtja végre * / close(fd[1]); / * a pipe-ba nem kell írnia * / close(STD_IN ); / * új standard bemenet előkészítése * /

44. Csővezeték – pipe 2. dup(fd[0]); / * standard bemenetet az fd[0]-hoz rendeljük * / close(fd[0]); / * ez a fájlleíró már nem kell * / execl(process 2, 0); } }

45. Üzenetportok 1. - a Unix-ban, Windows NT-ben, egyéb hálózatokban alkalmazzák a processzusok kommunikációjára - két processzus üzeneteket cserél egy porton keresztül - az üzenetporton az üzenetek egy láncra vannak felfűzve - a lánc feje – üzenetport: typedef struct { Message *head; // első üzenetre mutató pointer int type; // a port típusa char *name; // üzenetport neve Msg. Port *reply_port; // esetleg a válasz-port címe } Msg. Port; - a láncszem – üzenet: typedef struct { Message *next; // a láncon következő üzenet címe int lenght; // az üzenet (teljes) hossza char message_text[1]; // az üzenet (tényleges) szövege

45. Üzenetportok 2. } Message; - az üzenetportokkal kapcsolatos műveletek: Msg. Port *Create. Port (char *name, int type = 0, Msg. Port *reply_port = 0); Msg. Port *Find. Port (char *name); void Send. Message (Msg. Port *p, Message *m); Message * Receive. Message (Msg. Port *p); // blokkol, ha p üres int Test. Port (Msg. Port *p); // nullát ad vissza, ha p-n nincs üzenet - az üzenetportnak és magának az üzenetnek is memóriát kell foglalni, az üzenet számára általában az adó foglalja le, a vevő szabadítja fel a memóriaterületet

46. Ciklikus üzenetbufferek - processzusok kommunikációjának egy megvalósítási módszere - egy FIFO módszerrel működő vektorként képzelhető el - a B buffer n darab, azonos méretű cellára van osztva, melyekben egy üzenet fér el - a c 1, c 2, … , cn-1 cellák lehetnek foglaltak vagy szabadok üzenet tárolására - végrehajtható műveletek: - send(B, m): az m üzenetet a legkisebb indexű üres cellába helyezi, ez foglalt lesz – ezt végrehajtó processzus blokkolódik, ha nincs üres cella - m = receive(B): a legelőször lefoglalt cellából az üzenetet kiadja, az adott cella szabad lesz – ezt végrehajtó processzus blokkolódik, ha nincs foglalt cella - például a csővezeték implementálható ciklikus üzenetbufferel

47. Processzusok kommunikációja: Windows NT LPC 1. - a Windows NT üzenetváltásos és üzenetportokat alkalmazó processzus-kommunikációra is képes - az NT subsystem egy szerverprocesszusként működik, mely feladata a kliens processzusok közötti üzenetközvetítés - felhasználói programok → kliensprocesszusok - az LPC (Local Procedure Call Facility) kliens-szerver közvetítő, portokon keresztül valósítja meg az üzenetek továbbítását - kétféle port létezik: - kapcsoló – connection – port - kommunikációs – communication – port - két kliens processzus kommunikációja: - kliens kér egy hozzáférést – handle – a subsystem kapcsoló portjához → ezt jelöljük hc-vel - kliens a hc segítségével kapcsolódási kérést küld a szerverprocesszusnak

47. Processzusok kommunikációja: Windows NT LPC 2. - a szerverprocesszus két privát kommunikációs portot hoz létre a hk és hs hozzáférésekkel, hk → kliensé, hs → szerveré - a kliens a hk, a szerver a hs segítségével küld a másiknak üzeneteket, ill. kér a másiktól üzeneteket - az NT subsystem üzenetkezelési módjai: 1. a rövid üzenetek a port üzenetláncára kerülnek 2. a klienstől jövő üzenetek egy osztott memóriába kerülnek 3. a szerver fonalat hoz létre a kliensek üzeneteinek kezelésére - grafikus felületű applikációk esetén: - egy esemény (command) bekövetkezését az NT kezeli le - az eseményből üzenet készül - az üzenet a szerver portjára kerül - a szerver meghívja az esemény kezelésére kijelölt felhasználói eljárásokat (nevezik callback eljárásoknak is)

48. Processzusok kommunikációja: Unix IPC 1. - processzusok kommunikációja (Interprocess Communication) háromféleképpen valósulhat meg: - osztott memória segítségével: két processzus az OS-től közös memóriát kér - csővezeték segítségével: C-ben, shell-ben lehet programozni - csatolópont – socket – segítségével: ezen a ponton keresztül kommunikál a két processzus, ez mindig egy tartományon (domain) belül érvényes - tartományok lehetnek a következők: - Unix tartomány: az egy OS alatt futó processzusok közötti kommunikációra alkalmas, a csatolópont ekkor egy elérési úttal megjelölt fájl vagy könyvtár - Internet tartomány: a külön OS-en futó processzusok közötti kommunikációra alkalmas, a csatolópont egy 32 bites IP-cím

48. Processzusok kommunikációja: Unix IPC 2. - kommunikáció módja háromféle lehet: - stream – bájt sorozat - packet – csomag sorozat - datagram – üzenetek küldése történik, melyek sorrendje helyreállítható, minden helyesen megkapott üzenet után a vevőnek nyugtát kell küldenie - protokoll: a szerver- és kliensprocesszus közötti üzenetek formájának szabványa - kliens C eljárások IPC megvalósítására: - int socket (int domain, int type, int protocol); // csatolópont // létrehozására, - bind (int socket_id, char *adress, …); // hozzácsatolásra, - connect (int socket_id, …); // kapcsolat élővé tételére, - listen (int socket_id, …); // üzenetre várására, - accept (int socket_id, …); // üzenetet nyugtázására, stb.

49. Erőforrás osztályok 1. - sorosan osztott erőforrások: olyan erőforrások, melyeket egyidejűleg csak egy processzus használat - osztott erőforrások kérésének folyamata: - a processzus az OS erőforrás-kezelő alrendszerétől kéri az erőforrást - ha az biztosítja neki, akkor használja azt - véges időn belül felszabadítja az erőforrást, értesítve erről az OS erőforrás-kezelő alrendszerét - Request-Release pár formailag olyan, mint az Entry-Exit - megszakítható erőforrás: több processzus használhatja, de egyidejűleg csak egy, használatát kérni kell az OS-től - megszakíthatatlan erőforrás: a processzus létezése során végig annak rendelkezésére áll - hardver erőforrás – memória, I/O eszközök, stb. - szoftver erőforrás – közös változók, fájlok, stb.

49. Erőforrás osztályok 2. - erőforrás osztály: hasonló tulajdonságú, hasonlóan kezelendő erőforrások együttese - készlet: erőforrás osztály elemei és az elemek leírásai - várakozó sor: blokkolt állapotú processzusok sora, melyek erőforrást kértek, de még nem kapták meg - allokátor: erőforrás osztálybeli erőforrás kérést/felszabadítást végző OS eljárások - erőforrás osztályra jó példa a memóriaszeletek osztálya

50. Erőforrás osztályok leírása - erőforrás osztály azonosító – resource id - erőforrás osztályt is egy processzus hozza létre, ennek a processzus azonosítója – process id - készlet listája (lánc vagy vektor): - egyes láncszemek (erőforrások) leírása, pl. memóriaszeletek esetén a kezdőcím és a hossz - szabad vagy foglalt, mely processzus számára foglalt - készlet-elem beléptető ill. törlő eljárás - várakozó lista - a listán lévő processzusok azonosítója - erőforrás-kérés paraméterei, pl. a kért memóriaszelet hossza - belépési időpont, stb. - allokátor eljárások: Request-Release eljárások

51. Erőforrás kérés/felszabadítás 1. - allokátor működése erőforrás kérés esetén: - az utasítás a Request (res_id, e-specification, &e-id) vagyis meg kell mondani, melyik erőforrás osztályból kérünk erőforrást, milyen tulajdonsággal rendelkező erőforrást kérünk, majd a harmadik paraméteren megkapjuk a kért erőforrás címét - a kérő processzust blokkolt állapotba hozza - a kérő processzust várakozó listába helyezi - a várakozó listát végig vizsgálja, és ha egy korábbi processzus kérése teljesíthető, akkor: - válaszváltozóba behelyezi az erőforrás azonosítóját - a kiadott erőforrást foglaltnak jegyzi be a készletben - a processzust futáskész állapotba hozza - a processzust kitörli a várakozó listából - a vezérlést átadja a processzus-ütemezőnek

51. Erőforrás kérés/felszabadítás 2. - allokátor működése erőforrás felszabadítás esetén: - az utasítás a Release (res_id, e-id), vagyis meg kell mondani, hogy melyik erőforrás osztályból szabadítunk fel erőforrást, majd a második paraméteren megadjuk az erőforrás címét - az erőforrást szabadnak jegyzi be a készletben - végigmegy a várokozó listán, és megpróbálja a kielégítetlen kéréseket teljesíteni - a hívó processzusnak visszaadja a vezérlést - speciális erőforrások: - hardver erőforrások: memória, bemeneti/kimeneti erőforrások (pl. I/O eszközök, fájlok, könyvtárak) - szoftver erőforrások: adatok (közös adatok, üzenetek), eljáráscsoportok (OS eljárások, stb. )

52. Holtpont kialakulás feltételei - holtpont: processzusok egy halmaza az egymás birtokában lévő erőforrásokra várakozik örökké, vagyis egymást akadályozzák abban, hogy futáskésszé váljanak - holtpont kialakulásának feltételei: 1. sorosan osztott erőforrások léteznek az OS-ben 2. csak a birtokló processzus szabadíthatja fel a birtokában lévő erőforrásokat 3. Hold and Wait: legalább egy processzus birtokol erőforrást és blokkolt, vagyis erőforrás kérése van 4. cirkuláris Wait: létezik processzusok egy

sorozata, amelyre igaz, hogy minden pi blokkolt és a pi+1 birtokában lévő erőforrást kéri, ez egy elegendő feltétel - az 1. és 2. feltétel a legtöbb OS-ben teljesül, a 3. speciális esete a 4. -nek → holtpont kialakulását a 3. vagy 4. feltétel létrejöttének megakadályozásával érhetjük el

53. Holtpont kezelés módszerei - feltételezzük, hogy nem alakul ki ilyen szituáció (strucc politika) → ekkor a rendszergazda feladata a „gyanúsan öreg” processzusok megszüntetése, Unix-ban alkalmazzák - feltámasztás – recovery: az OS észreveszi és megszünteti, erre „durva” módszerek vannak: - erőforrás elvétele erőszakkal, majd átadása egy másiknak → csökken eggyel a holtpontban lévő processzusok száma - processzus megszüntetése - megelőzés – prevention: megakadályozzuk a holtpont létrejöttét, korlátozzuk a processzusok erőforráshoz jutását → erőforrás kihasználtság romlik, a processzusok átfutási ideje romlik, stb.

54. Holtpont megelőzése – prevention - Hold and Wait megakadályozásával jár, a triviális szabály az, hogy egy processzus nem kérhet erőforrást, ha már birtokol erőforrást (memóriára nem, de I/O egységekre pl. értelmezhető) - a szabály enyhítése az, hogy egyszerre több erőforrást kérhet egy Request utasítással egy processzus → bonyolult allokátor, éheztetés, rossz erőforrás kihasználtság - cirkularitás megakadályozása (elegendő feltétel, ez is korlátozás a processzusok erőforrás használatára) – erőforrások sorba rendezésének módszere: - az erőforrás osztály készletének ismert sora - szabály: ha pi az ej-t kéri, nem birtokolhatja ek-t (k>j) - szabály: ha pi az ej-ről lemond, nem birtokolhatja ek-t (k>j) - előrelátó algoritmusok (nem kérhet minden proc. minden ef-t): - bankár algoritmus egy homogén erőforrásosztályra - erőforrás pályagörbék - pre-allokációs gráf

55. Holtpont megelőzése – bankár algoritmus - egy kisvárosi bankár tevékenységét utánozza - a bankár rendelkezik bizonyos hitelkerettel (erőforrások) az ügyfelek (proceszusok) pedig kölcsönt kérnek - az ügyfelek összes kérése nagyobb lehet a bankár hitelkereténél - biztonságosnak nevezünk egy állapotot, ha van elegendő erőforrás ahhoz, hogy a bankár eleget tegyen annak az ügyfélnek, aki legközelebb van a maximumához - az algoritmus minden kérésre megnézi, hogy ha azt engedélyezi, akkor biztonságos állapot keletkezik-e - ha igen, teljesíti a kérést, egyébként a későbbre halasztja - ha ez megtörténik, akkor a feltevés szerint ez a kölcsön visszafizetődik és újra következhet az ügyfél vizsgálata - ha végül minden kölcsön visszafizetődik, akkor a kezdeti kéréseket ki lehetett elégíteni - egy erőforrás osztály erőforrásaira alkalmazható, de van több erőforrás osztályt kezelő változata is

56. Holtpont megelőzése – pre-allokációs gráf - minden állapothoz egy gráfot rendel, ezt az allokátor tárolja - a gráfban jelzések szolgálnak arra, hogy egy processzus kéri az erőforrást (szaggatott vonal), ill. birtokolja azt (folytonos vonal) - egy gráf akkor biztonságos, ha nincs benne kör, ebből az állapotból ugyanis nem jöhet létre holpont - ha egy processzus olyan erőforrást kér, mely hozzárendelésével a pre-allokációs gráfban kör alakulna ki, akkor a processzus nem kapja meg az erőforrást, blokkolódik → romlik az erőforráskihasználtság

57. Memóriakezelés feladatai 1. - a processzus memóriája két részből áll: - szöveg – változatlan: program, konstansok - adat – változó: statikus változók, verem, heap - a memóriakezelés feladatai: - szabad/foglalt területek nyilvántartása - memória-igények kielégítése (dinamikus memória) - csere (swap): memória – háttértár közötti csere (a UNIX operációs rendszerek alap memóriakezelő tevékenysége) - memória-védelem (csak 1 processzus kezeljen egy memóriaterületet, kivéve osztott memória esetén) - a memóriakezelés többszintű is lehet, többféle memória állhat rendelkezésre, ezek hierarchikusan szerveződnek: - cache memória: a memória és a CPU közti adatcsere gyorsítására, létezik adat ill. program cache - RAM központi memória - állandó lemezes tároló

57. Memóriakezelés feladatai 2. - processzus létrehozásakor: - induló fizikai memória biztosítása, a 3. generációs OS-eknél maximálisan elegendő memóriaterület biztosítása (dinamikus partíció esetén is) ↔ UNIX memória foglalása nem így történik - relokáció: a betöltési címnek megfelelően át kell címezni a program utasításainak a címrészeit - bázis-relatív címzés esetén nincs átcímzés, a processzus létrehozásakor kell meghatározni a kezdőcímet ahova a program betöltődik - processzus futása közben: - logikai → fizikai cím transzformáció, sikertelen esetben lép közbe a memóriakezelő - dinamikus memóriakérések/felszabadítások elvégzése - csere végrehajtása - védelem (pl. nem létező memóriacímre hivatkozás tiltása)

57. Memóriakezelés feladatai 3. - a memóriaszervezést meg lehet valósítani rögzített méretű partíciókkal, ennek két fajtája is van: - rögzített memóriaszeletek külön-külön várakozási sorral - rögzített memóriaszeletek egyetlen várakozási sorral - másik fajtája a memóriaszervezésnek a dinamikusan változó partíciók módszere

58. Memória allokáció – alapfeladatok és módszerek 1. - futás közben nyilván kell tartani a memória szabad ill. foglalt memória-szeleteit - a szeletek lehetnek fix vagy változó hosszúságúak - memória-kérés eljárása: void *requmem (int size) - memória-felszabadítás eljárása: void freemem (void *base) - dinamikus memóriafoglalás esetén két módszer van a memóriahasználat nyilvántartására: - fix memóriaszeletekre osztás, és bitsorozat használata a foglaltság ellenőrzésére: 0 – szabad, 1 – foglalt - a szeletek egy láncstruktúrán vannak láncszemekként: - szabad szeletek lánca: {(hi, ki) | hi kezdőcím, ki hossz} - foglalt szeletek lánca: {(gj, lj) | gj kezdőcím, lj hossz} - void *c = requmem(s) – kiad egy legalább s hosszúságú szabad szelet kezdőcímet, a szeletet átrakja a foglalt szeletek láncra – blokkol, ha nincs ilyen szabad szelet

58. Memória allokáció – alapfeladatok és módszerek 2. - freemem(c) – a c kezdőcímű foglalt szeletet átrakja a szabad szeletek láncára, egyes allokátorok ellenőrzik, hogy jogos-e a kérés - példák memória allokációra egyes programozási nyelvekben: - C: allok/free - C++: new/delete - Pascal: new/dispose - szemétgyűjtés – garbage collection: a szomszédos szabad szeletek egyesítése, ez egy időigényes folyamat

59. Memória allokáció – illesztési algoritmusok - első illesztés: a legkisebb indexű láncszem megkeresése, amely elegendő hosszú a kérés kielégítésére → gyors módszer, de elaprózza a memóriát - legjobb illesztés: megkeresi a láncon azt a szeletet, melynek hossza a legkevésbé tér el a kért hossztól → lassú, mert a teljes láncon végig kell futni, de nem apróz el - legrosszabb illesztés: megkeresi a láncon azt a leghosszabb szeletet, melyen az s hosszúságú kérés kielégíthető → lassú, és még el is aprózza a memóriát - kerekített illesztés: kettő-hatvány hosszúságú szeletekből áll a foglalt és a szabad szeletek lánca, az allokátor ezekből a szeletekből valahányat ad ki → gyors, és nem is apróz el - Fibonacci illesztés: ki = ki -1 + ki -2, k 1 = k 2 = 1, a Fibonacci számok szerinti hosszt vesznek fel a szeletek, ekkor az első illesztés = legjobb illesztés

60. Virtuális memória 1. - a programok túl nagyok és nem férnek bele a rendelkezésre álló memóriába → virtuális memória alkalmazása, az OS csak a program éppen használt részét tartja a memóriában, a többit a lemezen tárolja - logikai címek (utasítás-címrészek) transzformálása fizikai (memória) címekre A: logikai címtartomány; pl. 0 – N M: fizikai címtartomány f: A → M leképezés futás közben - a CPU minden utasítás végrehajtása közben annak címét átküldi a memóriakezelő alegységbe, amely érvényesíti az f leképezést, vagyis átváltja a logikai címet fizikai címmé, majd ráküldi a címbuszra - logikai címzések, ezek mind hardverfüggők: - báziscímzés: a logikai címek 0 -tól N-ig állnak rendelkezésre, a fizikai cím meghatározásához hozzáadjuk a B báziscímet,

60. Virtuális memória 2. hardverben egy bázisregiszter segítségével valósítják meg - lapcímzés – egyszintű (a memória lapokra van osztva): - a logikai cím lapsorszámból és lapon belüli címből áll, az f függvény ezt a két paramétert kapja meg → az Lp lap fizikai címéhez hozzáadja a lapon belüli címet - laptáblát kell létrehozni ennek megvalósításához - ha Lp nem definiált → a memóriakezelő keres egy szabad fizikai lapot, és a laptábla p. sorát kitölti annak címével - szegmenscímzés – többszintű (szegmensekre és lapokra): - a logikai címek szegmens- és lapsorszámból valamint a lapon belüli címből állnak - minden egyes szegmenshez egy laptábla rendelődik hozzá, a z. laptábla p. elemének tartalmát az Lzp + d jelöli - ha Lzp nem definiált → új laptábla és új fizikai lap foglalandó a processzusnak

61. Lapcsere algoritmusok – swap 1. - ha egy logikai laphoz még fizikai lap nincsen hozzárendelve, akkor a következő lépéseket kell végrehajtani: - keresünk egy szabad fizikai lapot, vagy felszabadítunk egy foglaltat, ekkor elmentjük annak tartalmát - új laptartalom betöltése - a laptábla (Lp) címének kitöltése - a nem definiált címet adó utasítás újrakezdése - a probléma igazából a felszabadítandó lap kiválasztása, erre a „legkésőbb fogunk rá hivatkozni” módszer is alkalmazható - ha a laptáblába bejegyzi, hogy történt-e írás/olvasás egy lapra egy időintervallumra vizsgálva, akkor optimális kiválasztási sorrend valósítható meg, ez a következő: - nem írt, nem olvasott - nem írt, olvasott - írt, olvasott

61. Lapcsere algoritmusok – swap 2. - létezik a FIFO (First-In-First-Out) módszer, a legrégebben behozott lap kiválasztása - választhatunk a nem olvasottak közül a FIFO módszerrel is - másik megoldás a hivatkozások számlálása egy adott lapra - problémák a lapcserékkel kapcsolatban: - vergődés – állandó lapcsere - programozási technikák az OS segítésére: - a processzus szöveg mentése szükségtelen - összefogott változó-kezelés - intenzív veremhasználat

62. Bevitel/Kivitel – megvalósítási lehetőségek 1. - kétféle beviteli/kiviteli eszközt szokás megkülönböztetni: - blokkos eszközök - minden adatcsoport címmel rendelkezik, ez lehet sorszám vagy összetett cím is - a bevitel/kivitel blokkonként történik, méretük meghatározott - ilyen eszközök a floppy, winchester, DAT, stb. - karakteres eszközök - ilyen eszközökön nincs cím („soron következőtől elv”) - az átvitel egy bájtonként vagy soronként történik - ilyen eszközök a terminál, nyomtató, stb. - I/O egységek összetevői: - eszköz (device) – mechanikus, valamilyen elv alapján tárolja az adatokat - eszközvezérlő (adapter, device controller) – részben szoftver, az OS külsőbb rétegeivel képes kommunikálni - a mai I/O eszközök közvetlen memória-elérésűek

62. Bevitel/Kivitel – megvalósítási lehetőségek 2. - a klasszikus eszközvezérlők a I/O csatornák (channel): az eszközök egy csatornán vannak, melyen megy az adatáramlás, a csatorna lehet: blokk multiplex ill. byte multiplex (bájtonként keverhetők az egyes bementi és kimeneti tevékenységek) - a PC-k, workstation-ök esetén a legalsó I/O eszköz a sín (bus), jellemző a memória-leképezett (memory mapped) I/O, amikor az eszközt úgy kezeljük, mintha memória egy adott címtartományába be lenne építve - kapcsoló (switch) technológia, a 4+ generációs szervereknél jelent meg, az eszközök közötti adatcsere kapcsolón keresztül történik, a kapcsoló adatátviteli sebessége nagyobb a sínnél (virtuális sínek létrehozása történik)

63. Bevitel/Kivitel – közvetlen memóriaelérés (DMA) - a DMA csökkenti az elpazarolt CPU időt - a CPU-nak csak az adatátvitel kezdeményezése a feladata, a következő paramétereket adja át az eszközvezérlőnek: - adatátvitel iránya (be/ki) - adatok memóriabeli kezdőcíme - átviteli adatmennyiség (bájtszám) - az eszközvezérlő a feladata, hogy a megkapott feladatot végrehajtsa, a CPU-tól függetlenül az adatátvitelt megvalósítsa - ha a programnak információra van szüksége az adatátvitelről → az adatátvitel során/végén az átviteli állapot lekérdezhető - hiba vagy befejezés esetén megszakítás történik, ekkor lehet állapotinformációkat közölni a kezdeményező processzussal

64. Bevitel/Kivitel – memória-leképezett I/O - az eszközvezérlőnek úgy adunk át paramétereket, mintha egy memóriacímre írnánk, és úgy kapunk információkat, mintha egy adott memóriacímről olvasnánk - ha párosul a DMA-val, akkor általában paraméterek átadására használatos, nem az adatokra vonatkozik (blokkos eszközök) - eszközvezérlési információk átadása memóriacímekre való írással (cím-bus, adat-bus), állapotinformációk lekérdezése memóriacímekről való olvasással - eszközvezérlők fix címkiosztására egy példa: clock 040 – 043 keyboard 060 – 063 hard disk 1 F 0 – 1 F 7 secondary RS-232 2 F 8 – 2 FF printer 378 – 37 F floppy disk 3 F 0 – 3 F 7

65. Bevitel/Kivitel – kapcsoló rendszer - egy viszonylag új, modern technológia - a CPU, a memória és az eszközvezérlők egy kapcsolón keresztül kapcsolódnak egymáshoz - ha a memóriától DMA módon az eszközvezérlő adatot kér, akkor létrejön egy virtuális sín a memória csatlakozási pontja és az eszközvezérlő között, amelyen keresztül valósul meg a kérésnek megfelelő adatáramlás – ugyanígy történik a CPU és a memória esetén is - a switch hozza létre ezt a virtuális kapcsolást - ütközések lehetségesek, a memóriától függ (nem a síntől), hogy képes-e az eszközök egyidejű kiszolgálására

66. Bevitel/Kivitel – végrehajtási szintek 1. - az I/O szoftverek céljai: - egységes felhasználói programozási felület biztosítása: a felhasználó ne függjön a a szektorok számától, a blokkmérettől, stb. - az eszközökre való hivatkozás egyszerű legyen → a UNIX-ban, LINUX-ban már nincs eszközfüggőség - blokkmérettől, fizikai felépítéstől, pufferezéstől való függetlenség - egységes hibakezelés, C-ben az error változó lekérdezése - osztott használat adminisztrációjától való függetlenség biztosítása, ezeket osztottan használható erőforrás osztályokként kezeli - az I/O szintekre való felosztása: - felhasználói szint - eszközfüggetlen programozási felület szint - eszközvezérlő szint

66. Bevitel/Kivitel – végrehajtási szintek 2. - megszakítási rendszer szint - hardver szint (ami végrehajtja a feladatot) - egy felhasználói processzus I/O kérést küld → ezt egy eszközfüggetlen szoftver dolgozza fel → ez átadja a részfeladatokat az eszközvezérlőnek → az eszközvezérlő a utasítja a hardvert a kérés végrehajtására → a hardver egy megszakítást produkál → a megszakítás értesíti az eszközvezérlőt a kérés állapotáról → ez az eszközfüggetlen szoftvernek továbbítja az információkat → majd megkapja a felhasználói processzus az I/O választ

67. Bevitel/Kivitel – lemez egységek - a lemez egység egy blokkos eszköz, a címet három rész adja: - henger (cilinder): egymás alatt elhelyezkedő lapok sorozata - pálya (track): egy lap egy köre - szektor (sector): egy pálya egy negyed, nyolcad, stb. része → ez tartalmaz egy fizikai adatblokkot - az adatátviteli idő három részből áll: - keresési (seek) idő: cilinderek és pályák közötti mozgás ideje - fordulási (rotation) idő: szektorok közötti fordulás ideje - átviteli (transfer) idő: adatírási/olvasási idő - a lemez egység hatékony kihasználása az OS célja, itt ez az adatátvitel optimalizálása - a fordulási és átviteli idők adottak - átlapolt keresés: több keresés folytatása egyidejűleg - a keresési idő viszont befolyásolható az átviteli kérések kiszolgálási sorrendjének meghatározásával ► olvasófej ütemezési stratégia

68. Lemez olvasófej ütemezés - olvasófej ütemezési stratégiák: - FCFS (First-Come-First-Served) módszer: érkezési sorrendben teljesítjük az I/O kéréseket → nincs optimalizálás - SSF (Shortest Seek First) – „legközelebbi kérés először” módszer: annak az I/O kérésnek a végrehajtása, amely az előzőleg végrehajtott kéréshez legközelebbi cilinderre esik - liftes algoritmus módszere: az író/olvasó fejek befelé és kifelé mozognak váltakozva, az útba eső kérések elégítik ki - pályánkénti pufferolás módszere: az adott pályára író vagy olvasó fej megvár egy teljes körbefordulást, és mindent leolvas az adott pályavonalról → gyorsítótárban raktározza - amennyiben az adatok nem fizikailag egymást követő szektorokban helyezkednek el, akkor nem sokat ér - ha van egy processzus, mely olvas/módosít rekordokat, akkor azok a rekordok a pufferen lehetnek annak telítődéséig, a fizikai írás/olvasás addig ráér → módosítottak elveszhetnek

69. Intervallum-timer 1. - olyan szolgáltatás, mely szükség esetén biztosítja egy adott eljárás végrehajtódását meghatározott időnként - processzuskezelő alrendszer időszeletelésére, real-time (időfüggő) feladatoknál, közönséges applikációk esetén is (pl. időigényes számolásokat végző program esetén felhasználói akciók figyelésére, stb. ) alkalmazzák - példa C program-struktúra, Unix-ban használható: #include struct itimerval itv; // időt tartalmazó struktúra void itimer_catcher (…); // a végrehajtandó eljárás sigset (SIGALRM, itimer_catcher); // az eljárás közlése sighold (SIGALRM); // óra megszakítás felfüggesztése // időintervallum beállítása itv. it_interval. tv_sec = 4; // 4 szekundum i. Itv. it_interval. tv_usec = 0; // 0 mikroszekundum itv. it_value = itv. it_interval;

69. Intervallum-timer 2. setitimer(ITIMER_REAL, &itv); // óra indul (valós idővel) sigrelse(SIGALRM); // óra megszakítás engedélyezve … sighold(SIGALRM); // óra megszakítás felfüggesztve … // a 4 szekundumonként végrehajtódó eljárás void itimer_catcher(…) { … }

70. Terminálok 1. - karakteres és grafikus terminálokat szoktunk megkülönböztetni - a karakteres terminálok 8 ill. 16 bites kódokkal dolgoznak, vagyis a bemeneti és a kimeneti egység ekkora - a grafikus terminálok feladata digitálisan megfogalmazott grafikus alakzatok megjelenítése - szinkron ill. aszinkron átvitel történhet - szinkron átvitel: az adó bizonyos ideig tartja vehetőként az adatot a vevő számára, az adó és a vevő szinkronban van - aszinkron átvitel: az adó a vevőtől teljesen függetlenül adja az adatokat és a vevőnek bizonyos időintervallumra van szüksége az adatok átvételére (többnyire pufferolással jár) - terminálok fajtái: - memory-mapped interface (ezen belül karakter és bit orientált) - RS-232 interface (szinkron átviteli módú, karaktersorozatok adása/vétele) - network interface (az X termináloknak van ilyen)

70. Terminálok 2. - egy sínre kapcsolódik a CPU, a memória és a videó RAM - a CPU a megjeleníteni kívánt karaktereket a videó RAM-ba küldi át a sínen keresztül - ezeket a jeleket analóggá alakítják, ezeket jeleníti meg a monitor - a terminál egy klaviatúra és egy monitor együttese, előbbi az utóbbitól teljesen függetlenül csatlakozik a rendszerhez

71. Karakter-átvitel 1. - a karakterbevitelnek többféle módja lehetséges: - nyers (raw) mód: egy billentyűt leütve az annak megfelelő kód fut át a kérő processzushoz, feldolgozás nélküli átvitel (az eszköz és az eszközvezérlő szint között) - sor mód (kanonikus mód): soronkénti átvitel, soron belüli javításokra van lehetőség, ezeknek megfelelő műveleteket az eszközvezérlő végzi el (az eszközvezérlő szint és az eszközfüggetlen szint között van ilyen átvitel) - termios eljárások a UNIX operációs rendszerekben: sor módú átvitelt valósítanak meg, de látszólagosan megengedik a sorok közti mozgást (C szabvány, pl. menü jeleníthető meg) - a karakterkivitel estén megemlíthetők az ESC szekvenciák, a nem látható karaktereket ezekkel valósítják meg a szoftverek - karakterkonverzió: sor mód esetén az eszközvezérlő és a billentyűzet között (az eszközvezérlő intézi)

71. Karakter-átvitel 2. - pufferezés: sor módú átvitel esetén kell, az eszközvezérlőbe van beépítve - grafikus terminálok legtipikusabb módja az X-terminál - Windows terminál-szerver szisztémája: a terminál-szerver processzus egy grafikus szerverprocesszus, amely a terminálon futó kliensprocesszusnak egy grafikus felületet biztosít

72. X terminálok 1. - M. I. T. szabvány grafikus terminálkezelésre - lokálisan és hálózaton keresztül is kliens/szerver modellel van megvalósítva - a display a szerver, a program – amelyik a display szervert használja – a kliens - a szerver X protokoll szerinti üzeneteket fogad, a parancsok tartalma szerint grafikus objektumokat megjelenít ill. kezel, ezek lehetnek: screen, window, color, font, stb. - a kliens X protokoll szerinti üzeneteket küld, a displaytől eseményekre készült üzeneteket fogad - a display része a window manager, ennek feladatai: - főablakok létrehozása - window hierarchia kezelése: méret, átfedés, ikonizálás, stb. - erőforrások (itt képességeket jelent) adatbázis kezelése: font-készlet, color-készlet, stb. - események (event) kezelése (üzenetek formájában átküldi)

72. X terminálok 2. - grafika: az M. I. T. szabványtól teljesen független szoftverileg is (2 D és 3 D grafikus szoftverek) - ezek egy display által adott erőforráson, egy fehér ablakon dolgoznak - grafikus objektumok: - image, bitmap, … - point, line, box, vector, … - text, font, …

73. Fájlrendszerek - az OS fájlkezelő alrendszerének céljai: - olyan nagyméretű adathalmazok tárolása, melyek várhatóan nem férnek be a memóriába - hosszútávon szükséges, processzusokat „túlélő” adatok tárolása, egyszerű elérhetősége - több processzus „egyidejű” hozzáférhetősége az adatokhoz - fájlrendszerek szerkezetük szerint kétfélék lehetnek: - a fájl egy bájtsorozat: az adatátvitel során mindig van egy aktuális pozíció, melytől kezdődően hajtódik végre az írás és olvasás, bájtonként és bájtcsoportonként is lehet írni/olvasni (általában egy meghatározott határoló jelig) - a fájl egy rekordsorozat: a rekordoknak vannak mezői, kulcsmezői, fájlrendszerben egy rekord írását/olvasását kérjük - a tartalmuk szerint a fájlok csoportosítása: - adatokat tartalmazó fájlok - programok – forrásnyelvi, lefordított és betölthető programok

74. Fájlattribútumok - típus → a fájlkiterjesztésben – suffix (Windows-ban) - létrehozó, tulajdonos neve - a tulajdonosra / csoportra / egyébre vonatkozó jogok, ilyenek az írási / olvasási / láthatósági / végrehajthatási jogok - utolsó létesítés / hozzáfordulás / módosítás időpontja - tartalom: bináris, szöveg vagy végrehajtható program - méret, rekordszám és rekordméret is tárolható - rendszer-, rejtett-, esetleg archív fájl - zároltság: ez egy dinamikus tulajdonság, ha több processzus férhet hozzá a fájlhoz, akkor a hozzáféréseket koordinálni kell, (C nyelvben a sys/locking. h header-ben vannak erre struktúrák) a zárolt intervallum kezdetét és végét is meg kell adni - C fájlkezelés – stdio. h: egy pointert kapunk, és minden olvasási és írási eljárásnak egyik paramétere ez a pointer - C fájlkezelés – fcntl. h: egy integert kapunk, és minden olvasási és írási eljárás hívásakor ezt az integert kell megadni

75. Fájlműveletek 1. - itt felsorolt fájlműveletek C szintű műveletek: - létrehozás: kétféle szisztéma van erre, a pointerrel hivatkozásos – fopen (…, „w…”) utasítás, írásra nyitjuk meg – és az integerrel hivatkozásos – create (…) utasítás (UNIX-ra ez jellemző), ideiglenes (processzus létéhez kötött) fájl létrehozása pedig a FILE *tmpfile() művelettel történik - törlés: mindkét szisztémában a remove (…) utasítással - megnyitás: írásra, olvasásra, folytatásra, az előbbi szisztémában FILE *fopen (…) utasítással, másikban pedig az int open (…) utasítással - lezárás: fclose (…) ill. a close (…) műveletekkel, pufferelés esetén, ha írás történt, akkor az adatok beíródnak, egyébként csak olvasáskor a puffer kiürül - írás: az fprintf (…) – formázott karaktersorozat, fputs (…) – egyszerű karaktersorozat, és a write (…) – egyszerű karaktersorozat műveletekkel történhet

75. Fájlműveletek 2. - olvasás: fscanf (…) – formázott bemenet, fread (…) – egyszerű olvasás, read (…) – egyszerű olvasás műveletekkel - pozicionálás: megmondhatjuk, hogy a fájl hányadik bájtjára álljon a „fej”, és az ez utáni műveletek mind innen történnek, az fseek (…) és seek (…) műveletek szolgálnak erre, a rewind (…) művelettel pedig visszaállhatunk a fájl elejére - hibakezelés: C-ben is állandóan ellenőrizni kell a műveletek sikerességét, az ferror (…) művelettel le tudjuk kérdezni a hiba eseményeket - állapot / tulajdonság lekérdezése: léteznek bonyolultabb, részletesebb függvények, az fstat (…) ill. a stat (…) a másik szisztémabeli művelet, ezekkel sokféle tulajdonságot lekérdezhetünk (pl. összesített hossz, keletkezés ideje, módosítás ideje, stb. ) - rengeteg további fájlművelet létezik még, ilyenek lehetnek pl. az átnevezés, hozzátoldás, attribútum-beállítás, stb.

76. Fájlrendszerek megvalósítása 1. - fájlok megvalósításai – fizikai blokkokat rendelünk hozzá a fájl adatainak egyes részeihez – a következők lehetnek: - folytonos blokksorozat: a fájl tárolása fizikailag összefüggő lemezterületen, folytonos blokksorozattal történik - láncolt blokksorozat: a fájl kezdő adatai egy adott fizikai blokkon vannak elhelyezve, ez pedig mutatja, hogy hol van az adott fájl következő blokkja, ilyen esetben szükség van a fájl első blokkjára mutató pointerre - i-csomópont – i-node: a UNIX alkalmazza, egy ilyen csomópont vagy egy könyvtárra, vagy egy fájl részblokkjára vonatkozó információt tartalmaz, a logikai adatblokkjaink láncszerűen vannak felfűzve a fizikai blokkokra - a fájlrendszerek hatékonyságát befolyásoló tényezők: - blokkméret: nagyon apró blokkok esetén az OS feladata ezek összepakolása a pufferben, a fizikai átvitel így a fizikai blokkok méretét megközelítő méretű darabokban történhet,

76. Fájlrendszerek megvalósítása 2. nagyon hosszú blokkok esetén pedig az I/O alrendszernek az a dolga, hogy szétszedje ezeket, és ezek már megfelelnek a fizikai blokkok méreteinek az átvitel szempontjából - szabad/foglalt blokkok nyilvántartása: bittérképes módszer és a szabad/foglalt blokkok láncának módszere létezik - pufferolás: ezzel lehet a hatékonyságot növelni - a fájlrendszerek megbízhatóságát befolyásoló tényezők: - magunk gondoskodhatunk erről időnkénti mentésekkel - tükrözés: fontos adatok esetén menetközben több példányban tároljuk az adatainkat, és ha az egyik helyen elveszik adat, akkor azt helyre lehet állítani – RAID szisztéma - konzisztencia-ellenőrzés elvégzése akkor szükséges, ha nem állítottuk le megfelelően a rendszert – ekkor pl. a szabad/foglalt bejegyzések, adattartalom hitelesség, stb. ellenőrzése kell, hogy megtörténjen - tranzakció-naplózással növelhető a megbízhatóság, minden

76. Fájlrendszerek megvalósítása 3. módosítást naplózunk, hibás adatok esetén egy biztos ponttól kezdve a tranzakciókat újra végre tudjuk hajtani → így újra naprakész állapotba kerülhetnek az adataink

77. Könyvtárak - a könyvtárak egy gyökérből elágazó fastruktúrába vannak szervezve, egy könyvtár fájlokat és újabb könyvtárakat is tartalmazhat - ezt a fastruktúrát sértik a UNIX operációs rendszerben létező linkek, a link egy másik könyvtárban lévő állományra ill. könyvtárra egy mutató (hard és soft linkek vannak) - megfelelő ez a struktúra arra, hogy logikailag szortírozzuk az adatainkat - minden egyes alkönyvtárnak útvonala (path) van, a gyökér könyvtártól (root) kezdődő könyvtársorozat az abszolút útvonal, létezik a munkakönyvtárból vezető relatív útvonal is - olyan fájlműveletek esetén, ahol szükséges a fájlnév megadása, elegendő megadni a munkakönyvtárból kiinduló fát - műveletek könyvtárakkal: mkdir, rmdir, rename, link, unlink, …

78. Könyvtárak nyilvántartása - a Windows rendszerekben létezik korlátozás az egy könyvtárban tartható állományok és könyvtárak számára → fix struktúrájú rekord tartozik minden egyes fájlhoz illetve alkönyvtárhoz, és ezek számára egy formázáskor meghatározott terület van fenntartva a merevlemezen ► egy fájlra ill. alkönyvtárra mutató rekordban bizonyos mezők mutatják bizonyos tulajdonságait az adott állománynak - i-csomópont módszer a UNIX-ban: egy könyvtárhoz tartozó rekord (bejegyzés) tartalmazza az alábbiakat: - a könyvtár nevét - a benne található fájlok, ill. alkönyvtárak i-csomópontjainak sorszámát ► az i-csomópontok tartalmaznak minden információt (típus, méret, tulajdonos, stb. ), ez a szisztéma homogén a fájlokra, könyvtárakra ill. alkönyvtárakra vonatkozóan

79. Osztott fájlrendszerek 1. - fájlok lehetnek helyi (local) és távoli (remote) fájlok, utóbbiakat valamilyen módon el lehet érni az adott OS alól - osztott fájlrendszerek azok az adott OS alatt létező fájlrendszerek, melyek más operációs rendszer alól is elérhetők (lehetnek egy távoli, hálózaton elérhető gépen, vagy pl. az adott gép merevlemezének egy részén) - követelmények a távolról elérhető fájlrendszerekre: - a fájlok kezelése legyen azonos a lokális fájlok kezelésével (pl. írás/olvasás ugyanazokkal az eljárásokkal történjen) → ez UNIX-ban megvalósul a mount módszer segítségével - hatékonyság – az OS kezelje a remote fájlokat is olyan hatékonyan, mint a lokális fájlokat (bizonyos korlátok között) - áttetszőség (transparency): - helyfüggetlenség a hivatkozásban – ne kelljen tudni, hogy a távoli fájlrendszeren hol található a fájl - fizikai tárolás-függetlenség – legyen mindegy, hogy milyen

79. Osztott fájlrendszerek 2. fizikailag a távoli fájlrendszer - helyváltozástól való függetlenség – egy távoli fájl elérhetősége a helyváltoztatástól legyen független - többszörös hozzáférhetőség legyen egy fájlhoz → az adatok konzisztenciájának védelmére szükség van valamilyen szisztémára, pl. automatikus lock/unlock - távoli fájlrendszerek elérési módszerei: - hoszt (hálózati pont) és egy hoszton létező útvonal megadásával érjük el a fájlt (az áttetszőség helyfüggetlenségét nem biztosítja) - NFS (Network File System), a SUN UNIX operációs rendszerekre – mount szisztémával be lehet ágyazni a távoli fájlrendszert a lokális fájlrendszerbe - RPC (Remote Procedure Call), az I/O tevékenység processzusok közötti kommunikációra redukálódik (ez a módszer az áttetszőségből semmit nem teljesít)

79. Osztott fájlrendszerek 3. - cache biztosíthatja a hatékonyságot – nem csak az adott adatcsoportot olvassuk be, hanem a környékén lévő adatokat is egy lokális tárolóba → probléma az, hogy a cache tartalma nem biztosan hiteles - kétféle módon használhatunk egy távoli fájlt: - állapotfüggő – megnyitáskor leolvassuk a fájl-információkat, és ezeket tároljuk a lokális OS-en → veszélyes módszer - állapotfüggetlen – minden hozzáféréskor lekérdezzük az aktuális állapotot a távoli OS-től → megbízható módszer - fájl replikáció: nagyobb osztott adatmennyiség esetén, hogy ne legyen túlterhelt a hálózat, a lokális OS másolatokat kap a távoli fájlrendszer egy részéről, és egy ideig ezzel dolgozik, majd a a módosításokat visszaküldi a hálózaton keresztül → az adatok több helyen tárolódnak, nem lehet biztosítani, hogy mindkét helyen ugyanaz a tartalom legyen, szükség van frissítésre, melynek gyakorisága viszont kicsi

80. OS védelem, biztonság 1. - az OS védelmének (protection) ill. biztonságának (security) megvalósítása valójában nem alrendszerrel történik → az OS minden komponensébe be kell épülnie, alkalmazási feladatok esetén is biztosítani egy fajta biztonságot, védelmet - biztonsági követelmények: - titkosság: személyi, üzleti adatok bizalmas kezelése, emberi jogok, verseny jogok igénye miatti titkosság magvalósítása - integritás: - konzisztencia – megbízható, kompatíbilis adathalmazok biztosítása - módosítások csak jogosultság szerint történjenek - jogosultak számára rendelkezésre állás - az OS részei, ahol ezeknek a feltételeknek teljesülniük kell: - hardver - szoftver - adat

80. OS védelem, biztonság 2. - hálózat - OS védelem és biztonság tervezési elvei: - minimális jogokat adjunk a felhasználóknak a feladat elvégzéséhez - gazdaságos legyen a megvalósítás – vagyis – beépített, ne kelljen a biztonsági rendszert utólag ráépíteni - a felhasználó számára elfogadható legyen, ne legyen túl sok többletmunkája a felhasználónak a biztonság betartása miatt - teljesnek kell lennie, az OS minden biztonsági pontjára, hozzáférésre terjedjen ki - nyíltnak kell lennie, nem lehet arra számítani, hogy a beépített biztonsági védelmet nem derítik majd fel

81. Védelmi, biztonsági sérülések titkosság integritás rendelkezésre állás ellopás, leállítás programmódosítás, vírus támadás fájl módosítása, új fájl létrehozása programtörlés, loginmódosítás fájl törlése, elérésének lehetetlenítése hardver tűzfalon átjutás, routing választás szoftver másolás adat hálózat illegális olvasás forgalom figyelés, hamis üzenetek üzenet-leolvasás küldése, rombolás, üzenet-módosítás struktúra átalakítása

82. Felhasználó-orientált védelem 1. - felhasználói védelem: a felhasználóval követtetünk el olyan cselekedeteket, amelyekből nyilvánvalóvá válik, hogy ő az, aki a megfelelő jogokkal bír - felhasználói védelem megvalósításai: - jelszó (password) módszer: - nagy számú lehetőséget kell biztosítani jelszóként - a belépéseket naplózni lehet, le kell tiltani valahány sikertelen (illegális) próbálkozás után a felhasználót - aszimmetrikus kódolás alkalmazása, a jelszó kódoltan tárolódik az OS-en, a dekódoló algoritmus nem tárolt → dekódolás lehetetlenné tétele - speciális jelszó módszerek: - egyszer használatos jelszavak használata (pl. jelszósorozat – mindegyikkel egyszeri bejelentkezés) - lejárati időintervallumok beállítása a jelszavakra

82. Felhasználó-orientált védelem 2. - azonosító kártya módszer, az OS beolvassa a kártyát, majd a felhasználót ez alapján azonosítja - legmodernebb módszerek: gépelési minta, hang, írisz alapján történő azonosítás

83. Adat-orientált védelem - komolyabb védelmi módszer, mint a felhasználói-orientált - objektumok (pl. memória, fájl, stb. ) → ezeket kell védeni - szubjektumok (pl. felhasználók, eljárások, stb. ) → akciókat hajtanak végre - az objektumokon hajtunk végre bizonyos akciókat, ekkor kell a jogosultságokat vizsgálni - létezik egy elérési (access) mátrix: - a szubjektumokat ebben tartományokba soroljuk be - minden szubjektumtartomány rendelkezik jogosultságokkal - oszlopai az objektumok - sorai a tartományok - elemei az adott sor tartományának jogosultságai az adott oszlop objektumára nézve - egy ilyen védelmi rendszer egy adott akció végrehajtási kérése esetén megnézi az milyen objektumra vonatkozik, a szubjektum milyen tartományba tartozik, és ellenőrzi a jogosultságot

84. Hálózat-orientált védelem 1. - legegyszerűbb módja az üzenetek kódolása ill. dekódolása - a kódolás történhet az üzenet fejére (header): - az üzenet fejével a hálózati elemek is foglalkoznak - minden hálózatra lépéskor kódolódik, kilépéskor dekódolódik - a vonali utakat rögzítik a hálózati elemek, mindegyik ráteszi a saját bélyegzőjét a fejre - még szigorúbb az ellenőrzés, ha egy megérkezett üzenet esetén visszakérdez a vevő a feladóra - a kódolás történhet az üzenet tartalmára (body): - csak az adó és a vevő foglalkozik vele, ezek megegyeznek a kódolási szisztémában - az adó kódolja, a vevő dekódolja - az üzenetek kódolásához kódolási kulcsra van szükség, a vevőnek ismernie kell ezt a kulcsot a dekódoláshoz

84. Hálózat-orientált védelem 2. - A és B processzusok üzenetváltása → kulcs szükséges hozzá: - lehet úgy, hogy A választ, majd elküldi B-nek - egy C központi processzus választ, és elküldi A-nak és B-nek - a kulcs sem lehet kódolatlan → egy korábbi kulccsal kell kódolni és dekódolni - a kulcsok megkülönböztetése: - állandó kulcs (permanent key) – több kapcsolatfelvétel (session) idejére érvényes - egy ülésre szóló kulcs (session key) – egy kapcsolatfelvétel (session) idejére érvényes - forgalom-fenntartás (traffic pending): sűrű üzenetküldés, üres üzenetekkel 100%-os sávszélesség-kihasználás két hoszt között → a „kémek” figyelmét felkeltik és elterelik ezzel

85. Program-orientált védelem - program-orientált védelemre klasszikus példa a vírusvédelem - vírusok → megváltoztatják a program funkcionalitását, pótcselekvéseket építenek be a programba, az eredeti feladatra képtelenné teszik azt - trójai faló: becsempészve a processzusunk olyan melléktevékenységeket végez, mint pl. jogok osztása illegális felhasználóknak, bizonyos védelmek megszüntetése, stb. - magába a programba is lehet kódolni az egyes részekre vonatkozó jogosultsági információkat → az ellenőrzés ilyenkor is az OS feladata futás közben - dinamikus jogosultságok: olyan jogosultságok, melyek nem állandóak az időben, ezeket kérés estén osztják ki (pl. a fájlok zárolása – az adatok konzisztenciáját szolgálja elsősorban)