Information Technology | Operating systems » Fábián Zoltán - Operációs rendszerek I.

1. oldal, összesen: 27 Fábián Zoltán - Operációs Rendszerek I. BMF-NIK, 5. félév (2005) 1. Az OR-ek definíciói, típusai, főbb feladatkörei Az OR-ek definíciói • Az OR az a program (programkészlet), amely állandó jelleggel fut a számítógépen, a bekapcsolástól a kikapcsolásig, és lehetővé teszi a számunkra a felhasználói programok hatékony és kényelmes futtatását • A megfelelő OR a felhasználói kör, illetve a megoldandó feladatok függvénye • Az OR olyan program, amely közvetítőként működik a felhasználó és a számítógép hardvere között, illetve lehetővé teszi a felhasználói programok gyors és kényelmes futtatását. Másodlagos feladat, hogy a számítógép hardverjét minél hatékonyabban használja, illetve a szoftverfejlesztési folyamatot megkönnyítse. Így a programozó egy kibővített képességű, egyszerűsített virtuális géppel dolgozhat. (hardver = CPU, I/O, Memória) Fő része a kernel: az a

program, amely feltétlenül szükséges a hardver és szoftver erőforrások közvetlen vezérléséhez. Az OR-eknek lényegében két szintjük van: az egyik a rendszerprogramok szintje (kernel), amely a felhasználó elől rejtve van (hardvervédelem); a másik pedig az alkalmazói programok szintje. Az OR-ek típusai A működés szempontjából • Mikroszámítógépes rendszerek: általában egyfelhasználós személyi számítógépek, a „hagyományos” architektúrával • Mini rendszerek: több, hálózatba kötött gépből áll. Az egyes gépeken ugyanaz az OR fut, s közös perifériák használatára is lehetőség van. Egyidejűleg több program is futtatható, a rendszer erőforrásait több felhasználó is igénybe veheti egy időben. • Párhuzamos rendszerek: olyan multiprocesszoros rendszerek, amelyek közös órajel-generátorral működnek, jó hibatűrő képességgel és lehetővé teszik a beágyazott rendszerek építését. • Osztott rendszerek:

saját processzorral, operatív tárral, adatsínnel rendelkező rendszerekből állnak össze. Előnyei: az erőforrások megosztásának lehetősége, a rendszer rugalmassága, nyíltsága, a konkurens működés (valódi párhuzamosság), a megbízhatóság, a számítógépes kommunikáció biztosítása (groupwork, workflow). Különböző típusú, ORű gépek összehangolt munkáját teszik lehetővé. • VLSI gépek: Az ötödik generációs gépek a mesterséges intelligencia (brain-like computer, fuzzy, neurális hálózatok, genetikus algoritmusok), azaz a soft computing módszereit alkalmazva oldanak meg bonyolult, nagy számításigényű feladatokat. Ezekben a rendszerekben a legnagyobb gond az átjárhatóság (kompatibilitás), amelyet bizonyos szintű szabványosítással oldanak meg Felhasználók szerint • Egyfelhasználós (single user) OR-ek: az első Windows rendszerek és a DOS • Többfelhasználós (multi user) OR-ek: a harmadik generációs gépek korában

vált lehetővé, hogy több felhasználó terminálrendszeren keresztül látszólagos párhuzamban használja a rendszer erőforrásait Taszkok (az egyszerre futtatható feladatok száma) szerint • egyfeladatos (single tasking) • többfeladatos (multitasking) Az OR-ek feladatai, céljai • • • • • • • Az OR olyan program, amely a közvetítő szerepét vállalja a számítógép felhasználója és a számítógép hardvere között. biztosítja a felhasználó számára azt a környezetet, amelyben az a programokat futtathatja. a fejlesztők célja – a számítógép használatát kényelmessé tegyék – a hardver összetevők minél hatékonyabban működjenek A hardvert a CPU, a memóriák és az I/O elemek alkotják, ezek és a szoftverek, fájlok jelentik a számítógép erőforrásait A gépen futtatandó felhasználói programok határozzák meg a megfelelő OR-t A felhasználó lehet ember, de lehet egy másik számítógép is. Programokkal oldja meg

az olyan problámákat, mint a CPU időelosztás, a memóriakezelés, adatszerkezet-tárolás, kimeneti-bemeneti műveletek beosztása, a jogosultságok számbavétele, stb. 2. oldal, összesen: 27 • a felmerülő ellentmondásokat megpróbálja kiküszöbölni, illetve azokról a felhasználónak számot adni. Ezért az ORt tekinthetjük felügyeleti szervnek is, amely a felhasználók által futtatott programokat is figyeli, nem csak a saját rendszerprogramjait. Multiprogramozás, Időosztás Alapelvek • felhasználói- és rendszerfolyamatok indítása, felfüggesztése, egyidejű szinkronizálása • folyamat kommunikáció, holtpontkezelés • amíg az egyik folyamat nem használ egy adott erőforrást, az odaítélhető egy másik folyamatnak, meghatározott időre • A folyamatok végrehajtásának gyors váltakozása a CPU-ban a felhasználó számára a párhuzamosság látszatát kelti. (transzparens mechanizmus, amely a CPU állapotterét menti) • Fizikai-

és virtuális memória (puffer, cache, spooling) • Lemezkezelés (DMA), file-rendszer (fizikai –FAT, INODE- és logikai –ROOT- megvalósítás) • Account rendszer (jogosultságok), hálózatkezelés, védelem (naplózás, rendszer-visszaállítás) 2. Az OR-ek szerkezeti felépítése Az OR működésének alapjai • A számítógép indításakor egy inicializáló program indul el, amely ellenőrzi az erőforrások jelenlétét, azok helyes működését, majd elindítja az OR-t • Az OR a memóriarezidens részét, a kernelt (mag), a memóriába másolja • Az első processzus az init, majd ezután az OR valamilyen eseményre vár. • Az eseményt egy megszakítás (interrupt) jelzi, szoftver vagy hardver jelleggel. A hardver interrupt általában a CPU felé küldött jelet jelent. • Szoftver szinten rendszerhívásnak (system call) nevezzük azt az elemi műveletet, amelyet egy ilyen jel előidéz. • A megszakítást kiválthatja a rendszerben • egy I/O

művelet, • elvégezhetetlen számítási művelet, vagy • az OR valamely művelete iránti igény. • A megszakítások működése architektúránként változó. Általánosan elfogadott, hogy a megszakításokra vonatkozó mutatók, azaz a megszakításvektor a memória alsó tartományában helyezkedjenek el (például az első 100 címen). Ki- és bemeneti felépítés • Egy vezérlő esetlegesen több eszközt is vezérelhet, feladata hogy az általa ellenőrzött perifériáról az adatokat egy köztes tárolóba (puffer-ba) juttassa. A puffer mérete különböző, lemezvezérlő esetében általában egy blokk (512 bájt). • Az I/O művelet akkor veszi kezdetét, amikor a CPU a kívánt periféria vezérlőjének regiszterét betölti, a vezérlő pedig hozzákezd a kért feladatat elvégzéséhez, (olvasás, kihelyezés vagy más). Ha a feladatot befejezte, a vezérlő jelet küld a CPU-nak, és ezáltal az újabb megszakítást indít útjára. • Attól

függően, hogy a vezérlés mikor kerül vissza az I/O folyamattól az őt indító felhasználói processzushoz, beszélhetünk szinkron vagy aszinkron vezérlésről, • Az I/O műveletek közül a lassú perifériákról (perifériákra) történő adatátvitel esetében minden karakter átvitelekor megszakítás lép életbe. A lemezről (lemezre) történő átvitelkor viszont blokkonkénti befejezett adatátvitel után történik megszakítás. A módszer neve DMA (Direct Memory Access), közvetlen memóriahozzáférés (aszinkron) • A megszakításvektorok és a programok általa közösen használt memóriaterületek védelmére is gondolni kell. Ezért minden feladathoz adott regisztercsoport tartozik, amelyet a kezdő-regiszter címe és a határ (limit) határoz meg. Memória-szerkezet • A végrehajtandó programoknak a központi tárban (memóriában) kell elhelyezkednie, hiszen ez az egyetlen olyan tároló, amelyet a processzor közvetlenül elér. • Az itt

működő úgynevezett Neumann-féle architektúra lényege, hogy egy load (indítás) hatására a végrehajtandó utasítás a memóriából az utasításregiszterbe kerül, ott beazonosításra majd végrehajtásra kerül. Az eredmény ugyancsak a központi tár egyik címére kerül ezután, a store hatására. (A regiszter mindenképpen közvetlenül elérhető és címezhető tároló) • Jó lenne, ha a futtatandó program utasításai és adatai mindig a központi tárban lennének, de ez nem lehetséges a méretbeli korlátok miatt 3. oldal, összesen: 27 • • • • • • A megoldás a másodlagos tárolók bevezetése lett, amelyek állandó jelleggel képesek megőrizni nagy mennyiségű adatot. Ide tartoznak a cache-memóriák, lemez-tárolók, a mágnesszalagok és mások Az adatmozgatás, mint már mondtuk, az eszközvezérlőkön keresztül történik. A CPU-ba épített regiszterekhez általában egy gépi óraciklus alatt hozzáfér a processzor, míg

az adatsíneken érkező adatoknak több ciklusra is szükségük lehet, hogy a közvetlen hozzáférésű regisztert feltöltsék. Ezért van szükség a cache-memóriákra, amelyekkel az adatáramlási sebesség és az órajel gyakorisága közötti eltérést enyhíthető. A mágneses lemezek a mai számítógépes rendszerek meghatározó másodlagos tárolói. Hogyan oldhatja meg az OR az adatok logikai és fizikai szerveződését, és hogyan kezeli e kettő között az összefüggéseket, valamint hogyan végzi az adatmozgatást? A tárolókat sorba-rendezhetjük hozzáférési idejük és az áruk szerint. A két dolog fordítottan arányos, tehát a leggyorsabbak a legdrágább tárolók is egyben. Így a sorrend a következő: regiszterek - cache - központi tár - elektronikus lemezek - mágneses lemezek - optikai lemezek - mágnesszalagok. Műszaki okok miatt az első három típusnál kiürül a tár, ha a tápegység leáll, a többi tárolón a pillanatnyi adatok

rögződnek a következő indításig. A számítógép hardvervédelméről • Az ütemezések különböző hibákhoz vezethetnek. Ezért elsődlegesen a hibák jó részét a hardver érzékeli, és további lépésekről az OR gondoskodik. Rögzíti az állapotokat, és megszakítást kezdeményez A programvégrehajtás leáll, jelentés kerül a felhasználóhoz, és a memória-térképet egy fájlban rögzíti az OR, lehetővé téve az esetleges újraindítást A védelem másik eszköze a műveletek végrehajtásánál a duális eljárás (dual-mode). Alapvetően kétféle eljárást különböztetünk meg a felhasználóit és a monitor-eljárást. A hardver egy azonosító bittel bővült, amely az eljárást beazonosítja • A boot monitor eljárás. Amint az OR beindul, már felhasználói eljárásról van szó A megszakítások újra monitor módot eredményeznek, a felhasználói beavatkozásokra történő várakozás felhasználói módot, és így tovább. Eközben

a mode-bit állandóan változik, és így • megóvja a felhasználói programokat egymástól • a kitüntetett gépi utasításokat pedig a felhasználói beavatkozástól • • Az I/O utasítások privilegizáltak, tehát felhasználó közvetlenül nem adhat ki utasítást erre vonatkozóan, csak az OR közvetítésével. Azaz monitor módban megszületik a megszakításvektor, és csak ezután lépünk felhasználói módba. Vannak ezen felül más privilegizált utasítások is, olyanok, mint a halt például. Felhasználói programból, mint tudjuk, soha nem állíthatjuk le a rendszerműködést. A megszakításokat indító utasítások, és a monitor mód felhasználói mód csere utasításai is privilegizáltak. A védelem harmadik összetevője a CPU védelem. Óvnunk kell a CPU-t az olyan felhasználói ballépésektől, amelyek például végtelen ciklusba hajtják. Ezért időkorlátokat (timer) használunk A korlát lehet fix időegység, vagy valamilyen

számláló által elért határ. 3. Az OR-ek fejlődéstörténete, az egyes generációk jellemzői Charles Babbage (1792-1871) első digitális analitikus gépének még nem volt OR-re, sőt szoftvere sem, és maga a gép sem készült el igazán soha, mert mechanikus szerkezet lévén, az alkatrészeket nem tudták megfelelő pontossággal előállítani Első generáció: vákuumcsöves gépek • nem OR koordinálta, hanem egy szakértői csapat • nincs megbízhatatlan a sok elektroncső miatt; programnyelv nem volt, csak gépi kód, kapcsoló-táblák segítségével; ismeretlen volt a végrehajtáshoz szükséges idő (becsülték) • korszakalkotó Neumann János javaslata: adat és utasítás ugyanott tárolható, csak a környezetük alapján különböztethetők meg • EDVAC (1945): Electronic Discrete Variable Calculator). 1500 szorzás / sec, max 12 digit hosszú decimális számokkal bináris formában • UNIVAC I programnyelv a UNIVAC nevű géphez, 1950-ben

lyukkártya • 1952-ben Grace Hopper megalkotta az első hibakeresésre használt programot, az úgynevezett debuggert Második generáció: a tranzisztorok kora • külön légkondicionált termekben felépített számítógépek 4. oldal, összesen: 27 • • • • • • • egy speciális program, amely a szalagról (kártyáról) elindította a beolvasást, tekinthető az ORek elődjének (a programokat először papíron írták, programnyelv is volt már: Fortran) A beolvasást a feldolgozás követte, majd a kimeneti adatokat újra szalagra rögzítették, és azok a nyomtató géphez, egy másik terembe kerültek. (nagy kihasználatlanság) Tipikus programnyelveket használtak, olyat, mint az FMS (Fortran Monitor System). IBSYS: az IBM ORe a korabeli IBM 7094 gépekhez A kihasználatlanság ellenszere a kötegelt feldolgozás (batch) lett: az operátorok összeválogatták a hasonló munkákat, majd ezeket egymás után futtatva több korábbi lépést csak egyszer

kellett elvégezni. Áttértek az off-line perifériás művetekre: a beolvasást, nyomtatást a programok futásától elválasztva intézték. Resident monitor: ha egy program befejeződött, elindította a következőt (az első OR) Periféria-független programozás a rugalmasság érdekében; pufferelés, átlapolt feldolgozás A központi egység gyorsult, a perifériák nem győzték ellátni feladattal; hiányzott a kompatibilitás Harmadik generáció: az IC-k kora • IBM 360: különböző erejű, árú, egymással kompatibilis gépek, a szabványosítás következtében bonyolult OR • az olcsóbb, integrált áramkörökkel és random access memórákkal épített gépek elterjedtek • spooling (simultaneous peripherial operation on-line): a tárakat egyetlen pufferként használja, egyszerre több munkát is lemezre tölt, több munka is átlapolódhat. (jobb kihasználtság) • Honeywell, Univac, később Unisys • A multiprogramozás megoldással szolgált, a

spooling és az időosztás problémájára • Az IBM cégnek köszönhetően a HW és SW termékek elkülönített gyártása valósult meg (szabványosítás) • A korszak jellemző rendszere lett a mini számítógépes rendszer (PDP-11) • Egy ilyen típusú gépen kezdte fejleszteni a UNIX alapú rendszerek ősét a Bell Labs-ban Ken Thompson (1972) Negyedik generáció: LSI (Large Scale Integration) • a magas integráltságú, olcsó hardver, ami mindenki számára elérhetővé vált: egy felhasználó – egy gép (PC – Personal Computer), user friendly OR (DOS, UNIX), a hatékonyság kevésbé fontos • Kialakulhattak a munkaállomások, és az őket kísérő többfelhasználós ORek, hálózatok • Gyors mikroprocesszorok, LAN, elosztott rendszerek 4. A mai OR-ek főbb jellemzői (megszakításrendszer, multiprogramozás, időosztás, hardvervédelem) A megszakításrendszer Eredeti cél: az I/O műveletek és a számítási műveletek szinkronizálása. A

megszakítást egy váratlan esemény váltja ki: aszinkron (reprodukálhatatlan): várható (DMA) vagy nem várható (hardverhiba); szinkron (a program futásakor mindig ugyanott következik be). A megszakítást kiválthatja: egy, a program futása közbeni hiba (overflow, division by zero) vagy valamilyen hardver (portkezelés, billentyűzet-kezelés, adatátvitel) A megszakítások forrásai: Géphibák, I/O források, külső források (másik gép), programozói források (memóriavédelem megsértése, tár-túlcímzés, kivételek, stb.) Lehet még szándékosan, pl rendszerhívásokkal: Az overflow flag jelzi, hogy túlcsordulás lépett fel. Az INTO utasítás segítségével korrekció kérhető A megszakítások kiszolgálásának menete: 1) Az egység aktiválja az INTR bemenetet 2) A CPU elfogadja az INT kérést, ha a) Megszakítható állapotban van b) Megfelelő a bejövő INT prioritása c) A bejövő INT nincs maszkolva (letiltva) d) Ha a fenti három feltétel

teljesül, INT elfogadva 3) A CPU elmenti a verembe az aktuális állapot-információkat (PC, flag) és a megszakított program adatterét (regiszterek) 4) Azonosítja a megszakítást kérő egységet, hiszen egy INT-hez több egység is tartozhat (polling / vektoros) 5) A megszakítás kiszolgálása 6) Az adattér és az állapottér visszaállítása 7) A CPU a kiszolgálás végeztével visszaküld egy nyugtát az egységnek, az pedig deaktiválja az INT-kérő jelet. A megszakítás kiszolgálása után a megszakított program folytatódik vagy nem (reset). Mindegyik INT-hez tartozik egy bit. A CPU ezeket vizsgálja, amikor fogadóképes 5. oldal, összesen: 27 A hardvervédelem Az ütemezések különböző hibákhoz vezethetnek. Ezért a hibák jó részét elsődlegesen a hardver érzékeli, és további lépésekről az OR gondoskodik. Rögzíti az állapotokat, és megszakítást kezdeményez A programvégrehajtás leáll, jelentés kerül a felhasználóhoz, és a

memória-térképet egy fájlban rögzíti az OR, lehetővé téve az esetleges újraindítást. Multiprogramozás A multiprogramozás megjelenése előtt a lassú perifériák korlátozták a CPU kihasználtságát, mert a processzornak várakoznia kellett a lassú perifériás műveletek befejeződésére. A szekvenciális hozzáférésű tárak miatt pedig a munkákat csak érkezési sorrendben lehetett végrehajtani. A véletlen hozzáférésű tárakról az OR tetszőleges sorrendben választhatja ki a következő végrehajtandó munkát, és egy speciális adatszerkezet (nyilvántartás), a „job pool” segítségével úgy ütemezheti, hogy a CPU kihasználtsága kb. 90%-os legyen (a lementés-visszaállítás időbe kerül). A CPU mellett a többi erőforrás felhasználását is koordinálni kell, gondoskodni kell az egyes programok és memóriaterületük védelméről a többiekkel szemben, stb. A legnagyobb problémát az jelentette, hogy továbbra sem volt közvetlen

kapcsolat a programozó és a gép között, vagyis nehéz volt a programokat módosítani, hibát keresni. Az időosztásos rendszerek A time-sharing, multitasking rendszerek interaktív kommunikációt biztosítanak a felhasználó és programja, valamint az OR között. Általában minden felhasználónak külön beviteli eszköze (terminál, konzol) van, melyen keresztül on-line kommunikálhat a rendszerrel. A CPU meg van osztva az egyes felhasználók között, de ezt a felhasználó nem érzékeli közvetlenül. Elvárás, hogy a rendszer válaszideje egy bizonyos határon belül legyen A háttérben általában valamilyen batch-rendszer is fut, hogy az üresjáratokban a rendszer ne maradjon kihasználatlan. Az MiT, a Bell Lab és a GE ilyenirányú fejlesztései nagy hatással voltak a UNIX-ra Az elosztott rendszerek A feldolgozó-képesség elosztottsága (decentralizálás) igen sok előnyös tulajdonságot hordoz: a sebesség növekedése, a funkciók térbeli elosztása

(térben elosztott rendszerstruktúra alakítható ki), jobb megbízhatóság, jobb fejlesztési lehetőségek, adatok és eszközök megosztása, kommunikáció, flexibilitás (terhelésmegosztás, optimalizálás) Felmerülő problémák, hátrányok: a szoftver (az elosztottság és a párhuzamosság miatt új elvre lenne szükség), a hálózat (átviteli sebesség, túlterhelés) és a biztonság (könnyebb az illetéktelen hozzáférés). Típusai: multikomputeres, lazán csatolt rendszerek, illetve multiprocesszoros, szorosan csatolt rendszerek. Az átlátszóság (transparency) hiánya esetén minden gép egy adott feladatot lát el, a felhasználónak tudnia kell, melyikre van szüksége. Átlátszósággal pedig logikailag az egész rendszert egy gépnek látja, a feladatok szétosztását az OR automatikusan végzi. (ehhez kell az új koncepciójú OR) Valósidejű rendszerek Azok a rendszerek, amelyekkel a környezeti, valós időskálához kötött idő-követelményeket

támasztunk. Előírhatjuk, hogy a rendszer egy környezeti eseményre mennyi időn belül reagáljon, vagy milyen időzített akciókat hajtson végre. Ezek az OR-ek többnyire valamilyen célhardveren futnak, s a szenzorok jelzéseire garantáltan a megadott időn belül kell válaszolniuk. Fajtái: hard real-time (a taszkok befejeződnek időben), soft real-time (a taszkok a legmagasabb prioritással futnak) Nyílt rendszerek Az V. generációs számítógépekkel olyan rendszerekre vonatkozó igény merült fel, amelyek fizikaliag is nagy távolságokat hidalnak át, szinte bárhonnan hozzáférhetők. (világ-szabványok) Ennek jegyében az OSI (International Organization for Standardization) ajánlásokat fogalmaz meg a rendszerek egységes működésért. Napjaink rendszerei A IV. generációtól mindegyik rendszerfajta megtalálható; a legelterjedtebbek a multiprogramozott rendszerek A kezelői felületre leginkább az ablakozó technika jellemző, de a parancssori vezérlés

is megmaradt (batchprogramozás, távoli elérés) 6. oldal, összesen: 27 5. Folyamatok, rendszerhívások Alapfogalmak • A processzus vagy folyamat (process, job, task) egy végrehajtás alatt levő program. • Egy időosztásos rendszer processzusát annak címtartománya (memóriatérképe) és processzustáblázatbeli tartalma alkotja • A processzustáblázat olyan, az adott processzushoz kapcsolt vektor vagy láncolat, amely a címtartomány által nem tartalmazott, de a processzussal kapcsolatos egyéb információkat foglalja magában • Egy processzus (a szülőprocesszus) létrehozhat egy vagy több új processzust (gyermekprocesszusokat). Ez a hierarchikus rendszer fastruktúraként ábrázolható • Az elengedhetetlen processzusok közötti kommunikációt általában egy pszeudofájl vagy a csőrendszer (pipe) biztosítja • A parancsértelmező (shell) a számítógép ORének kulcsfontosságú processzusa • Egy többfelhasználós rendszerben a

felhasználó által indított processzus azonosítójához mindenképpen kapcsolódik az őt indító felhasználó azonosítója (user id). Rendszerhívások és szignálok • A processzusok és az OR közötti kapcsolatot a szignálok és a rendszerhívások biztosítják. A szignál a hardvermegszakítások szoftvermegfelelője • Az OR és a felhasználói programok közös érintkezési területe egy kiterjesztett parancsokból álló halmaz, a rendszerhívások (system calls) halmaza. A többfeladatos OR által kezelt rendszerhívásoknak szüksége van az időszerű processzek azonosítójára (process id vagy pid) A rendszerhívások általában a következő osztályokba sorolhatók Pocesszuskezelő rendszerhívások: • end, abort, ad, execute • create process, terminate process, allocate and free memory, Eszközkezelő rendszerhívások: • request device, release device, read, write, reposition • get device attributes, set device attributes, logically attach or

detach devices Fájlkezelő rendszerhívások: • create file, delete file, open, close • read, write, reposition, get file attributes, set file attributes Információkezelő rendszerhívások: • get / set time or date, get / set system data • get / set process, file, or device attributes Kommunikációs rendszerhívások: • create, delete communication connection, send, receive messages • transfer status information, attach or detach remote devices Védelmi rendszerhívások: • A rendszerhívások végrehajtása erősen gépfüggő, és általában assembly nyelvben fogalmazódik meg. • A rendszerhívásokat tartalmazó eljáráskönyvtár több rendszernél lehetővé teszi, hogy C nyelvű programokból rendszerhívásokat hívjunk meg. A rendszerprogramokról • A rendszer-hierarchiában valahol az OR és a felhasználói programok között helyezkednek el, és lényegesen megkönnyítik és leegyszerűsítik más programok végrehajtását és fejlesztését. • A

rendszerhívások csoportjaihoz hasonló csoportokba sorolhatjuk őket: • A felhasználó szempontjából talán a legfontosabb rendszerprogram a parancsértelmező (shell) • Az egyik módszer, hogy a parancsértelmező maga is tartalmazza azt a lépéssort, amelyet végre kell hajtani • A második lehetőség, hogy a parancsértelmező nem értelmezi a parancsot, hanem a kiszolgáláshoz szükséges rutint indítja el Rendszerstruktúra Sok olyan OR létezik, amely kis rendszernek indult, majd a javítások, bővítések következtében lomha dinoszaurusszá lettek. Ilyen például az MS-DOS (egyszerű hardver /8088, nincs hardver-védelem/, felesleges a moduláris OR) Az MS-DOS interfészei és szervezési szintjei nem különülnek el szigorúan egymástól. • az applikációs programok közvetlenül elérhetik az alapvető I/O rutinokat. • A kezdeti UNIX rendszereknek két alaprétege volt. A kernel és a rendszerprogramok A kernel később átszerveződött interfészek

és eszközmeghajtók sorozatává. 7. oldal, összesen: 27 • Ez a felépítés nyújtotta az alapokat a mai OR-ek réteges, illetve moduláris felépítésére. A rétegződés itt olyan, hogy az adott rétegbeli rutinok csak az alatta levő, illetve a saját rétegbeli rutinokat érhetik el közvetlenül. Így megkönnyítették a tesztelést és az esetleges javításokat. (Windows NT) Párhuzamosságok a modern számítógépes rendszerekben • Egy multiprogramozású rendszerben csak látszólagos párhuzamosság van jelen • A valódi párhuzamosság azt jelenti, hogy egy többprocesszoros rendszerben több központi egység osztja ugyanazt a memóriaterületet. • A szekvenciális processzusok modellje megkönnyíti a párhuzamosságok kezelését Processzus modell - egyprocesszoros rendszer • Minden futtatható szoftver a számítógépen (az OR is), szekvenciális processzusok sorozata. A processzus a következő összetevőkből áll: • utasításszámláló

• regiszterek • változóinak értékei. • Minden processzusnak saját virtuális CPU-ja van. A valóságban a CPU kapcsol közöttük • A processzusok nem állandó sebességgel haladnak előre a végrehajtásban, ezért egy esetleges újraindításkor nem ismételhető meg az időosztás. • A processzusokba nem szabad belső időzítéseket beépíteni, de szükség van egy időosztásos (scheduling) algoritmusra, amely a megfelelő időpillanatban felfüggeszti a futó processzust és egy másikat indít, vagy indít újra. Processzushierarchiák • Az egyfelhasználós rendszerekben nincs szükség processzushierarchiák létrehozására • Összetettebb rendszerek esetében a processzusok létrehozásának és megszüntetésének módszereit ki kell dolgozni, ezért az ORek általában tartalmazzák a következő rendszerhívásokat: processzuslétrehozás, memóriába történő betöltés, indítás. 6. Folyamatállapotok, átmenetek Processzusállapotok • Egy

processzus egy adott pillanatban a következő három állapot egyikében lehet – Running (fut): az adott pillanatban éppen használja a CPU-t – Ready (futásra kész): időlegesen leállították, hogy egy másik processzus futhasson – Blocked (blokkolt): bizonyos külső esemény bekövetkezéséig nem futhat Processzusállapotok - ütemezés • A UNIX alapú rendszerek alsó szintje, az ütemező, (scheduler) kezeli a megszakításokat és az ütemezést. Az ORen belül a további processzusszervezés szekvenciális jellegű. Az ütemező egyúttal a megszakításokat és a processzusok közötti kommunikációt is felügyeli. • Példa a processzusállapotokra a UNIX rendszerekből: cat file1 file2 | grep fontos (a grep várhat a cat végére) Processzusok megvalósítása • A processzusmodell lényege, hogy az OR processzusonként egy processzustáblázatot hoz létre és a processzus élettartama alatt azt kezeli • A processzustáblázat tartalma általában utal a

processzus: • állapotára • utasításszámlálójára • veremmutatójára • memóriatérképére • megnyitott fájljainak állapotára • elszámolási és ütemezési információira • egyéb olyan információkra, Processzuskezelő mezők a processzustáblázatban Az OR a processzusokat, memóriát és fájlokat elkülönítve kezeli, ezért a processzustáblázat mezői is e három csoportba tagolódnak. A processzustáblázat memóriakezelő mezői általában a következő információkat tartalmazzák • regiszterek, utasításszámláló • programállapot szó, veremmutató • processzusállapot, processzus indítási ideje 8. oldal, összesen: 27 • felhasznált CPU idő, gyermek CPU ideje • következő ébresztés ideje, mutató az üzenetsorra • függő jelző bitek, processzusazonosító, különböző jelző bitek Megszakítások • egy központi egységgel és több ki- és bemeneti egységgel rendelkező rendszer ütemezőjének működése:

• Minden egyes B/K eszközosztály kapcsolatban áll a memória alsó részében elhelyezkedő megszakításvektorral. Ez a vektor tartalmazza a megszakítást kiszolgáló eljárás címét. A következő sorrend mutatja, hogyan cselekszik az OR alsó szintje, az ütemező, amikor megszakítás következik be: • A hardver verembe teszi az utasításszámlálót és más információkat • A hardver a megszakításvektorból betölti az új utasításszámlálót • Az assembly eljárás elmenti a regiszterek tartalmát, majd beállítja az új vermet • A C megszakítás-kezelő bemenő adatokat olvas és tárol • Az ütemező a várakozó processzust futásra kész állapotba helyezi • Az ütemező a futásra kész várakozók közül kijelöl egyet futásra • A C eljárás visszatér assembly kódba és elindítja az új aktuális processzust Processzusállapotok közötti átmenetek 1. A processzus input miatt blokkolt 2. Az ütemező másik processzust választott 3.

Az ütemező ezt a processzust választotta 4. A bemenet elérhető lett 7. Folyamatok, versenyhelyzetek, kritikus szekciók, folyamatok kommunikációja Processzusok kommunikációja • A többfeladatos rendszerek alapkövetelménye, hogy egy megszakítások nélküli, jól strukturált módszert biztosítson a processzusok közötti kommunikációhoz, azaz az IPC (InterProcess Communication) feladatkörhöz. • Az OReket építő szakembereknek a következő feladatokat kell megoldaniuk – hogyan továbbíthat egyik processzus információt egy másiknak – két vagy több processzus ne keresztezze egymás útját, ha kritikus tevékenységbe kezdenek – ha a processzusok munkája között függőség áll fenn, akkor a sorrendiségre figyelni kell Sleep és Wakeup • Léteznek olyan processzusok közötti kommunikációt szolgáló primitívek, amelyek anélkül blokkolnak, hogy elvesztegetnék a CPU időt, miközben a processzus a kritikus szekcióba történő belépésre

vár • Ilyen egyszerű primitív-pár a SLEEP és WAKEUP. • A SLEEP rendszerhívás, amely a hívót blokkolja (felfüggeszti), amíg egy másik processzus őt fel nem ébreszti • A WAKEUP rendszerhívás egyetlen paramétere az a processzus, amelyet fel kell ébresztenie. • Lehetőség van arra is, hogy a SLEEP és WAKEUP is rendelkezzen egy-egy paraméterrel, és ezek megfelelő összepárosításának elvén működjön a két rendszerhívás A gyártó-fogyasztó probléma • A következő, gyártó-fogyasztó (összekötött tároló) probléma a SLEPP-WAKEUP pár alkalmazásának jó példája: két processzus osztozik egy közös, rögzített méretű tárolón. A gyártó adatokat helyez el benne, a fogyasztó kiveszi azokat. A gyártó új adatot akar elhelyezni a már telítődött tárolóba Ez nem sikerülhet, ezért a gyártó aludni megy, amíg a fogyasztó egy vagy több elemet ki nem vesz, és a gyártót felébreszthetik. Ha a tároló üres, akkor a

fogyasztó megy aludni az ébresztésig, amikor is a gyártó már elemekkel töltötte fel a tárolót. Probléma: A fogyasztó a count-ban nullát talál. Az ütemező ebben a pillanatban felfüggeszti, a gyártót indítja, aki elemet tesz a tárolóba (count=1), a count előző nulla értéke miatt wakeup-pal ébreszti a fogyasztót. Az ébresztőjel elveszik, mert a fogyasztó logikailag nem alszik. A gyártó eközben feltölti a tárolót Megoldási lehetőség • Hogy az ébresztőjel ne veszhessen el, vezessünk be az ébresztőt váró bitet. (ez csak kíséri az ébresztő jelet) • A megoldás a szemaforok bevezetése, amelyekkel számolhatók a függőben maradt ébresztések Szemaforok 9. oldal, összesen: 27 • • • • • 1965-ben Dijkstra javasolta a szemafor változótípus bevezetését, amely típus nulla, ha nincs elmentett ébresztés, illetve pozitív egész, utalva az elmentett ébresztések számára. A SLEEP és WAKEUP hívások általánosításai

a DOWN és UP műveletek. A DOWN művelet például csökkenti a szemafor értékét, ha az pozitív, tehát végrehajt egy tárolt ébresztést. Ha a szemafor 0, akkor a processzust altatja a DOWN meghívása nélkül. Az értékellenőrzés, az értékcsere, az altatás elemi műveletek, tehát a szemafort egyszerre nem érhetik el, és nem változtathatják (fontos szinkronizálási újítás) Az UP művelet hasonló módon működik (Az alvók közül általában véletlenszerűen választják ki az ébresztendőt) Szemaforok alkalmazása a gyártó-fogyasztó probléma esetében • Az UP és DOWN olyan rendszerhívásokként működik, amelyekben az OR tilt minden megszakítást, amíg a szemafor értékét vizsgálja. • A példa három szemafort használ – a full a teli rekeszeket számlálja – az empty az üres rekeszeket számlálja – a mutex biztosítja, hogy a gyártó és fogyasztó ne érje el egy időben a tárolót • Bináris szemaforoknak nevezzük azokat,

amelyek kezdőértéke 1, és azt biztosítják, hogy kettő vagy több processzus egyidejűleg ne lépjen kritikus szekcióba (jól szervezett szemaforokkal a kölcsönös kizárás biztosított) • • • A szemaforok jól használhatók tehát – a kölcsönös kizárás elérésére, a mutex segítségével, – szinkronizációra, a full és empty segítségével. Ezek a szemaforok biztosítják, hogy bizonyos eseménysorozatok bekövetkezzenek, és hogy bizonyosak ne. A szemaforok széles körben elterjedtek, és ma is fejlesztik a velük kapcsolatos algoritmusokat A szemaforok alkalmazásának buktatói: – végtelenségig blokkolt állapotban maradhat mindegyik processzus - ezt nevezzük holtpontnak – versenyhelyzetek és reprodukálhatatlan események következhetnek be Monitorok • A szemaforok hiányosságait javítandó, magasabb szintű primitíveket vezettek be, és ezeket monitoroknak nevezték (Hoare, 1974-ben, Hansen, 1975-ben). • A monitor eljárások,

változók, adatszerkezetek együttese, amelyeket egy speciális modulba gyűjtenek egybe • A monitorok forrásnyelvi konstrukciók, a fordítóprogram pedig tudja, hogy a monitor eljárásait másképp kell kezelni, mint az egyszerű eljárásokat A monitorok tulajdonságai: • A processzusok bármikor hívhatják a monitorban levő eljárásokat, de nem érhetik el közvetlenül a monitor belső adatszekezeteit a monitoron kivül deklarált eljárásokból • Minden időpillanatban csak egy processzus lehet aktív egy monitorban, és ez lehetővé teszi a kölcsönös kizárást • A monitorok belépési pontjánál általában bináris szemaforok biztosítják a kölcsönös kizárást adó felfüggesztéseket. • A blokkolásokat továbbá állapotváltozók biztosítják, valamint az őket kezelő WAIT és SIGNAL műveletek. Ezek hasonlítanak a SLEEP és WAKEUP műveletekhez, de velük nem fordul elő hogy az egyik processzus egy másik, aludni készülőt akar

felébreszteni. Versenyhelyzetek • Ha 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, versenyhelyzet áll elő. Kritikus szekciók • A versenyhelyzetek megelőzésére szükségünk van a kölcsönös kizárásra, azaz arra, hogy bizonyos processzusokat egy ideig távol tartsunk a közös erőforrásoktól • A programnak azt a részét, amelyben megosztott memóriát használ, kritikus szekciónak nevezzük. Ha megszervezhető, hogy két vagy több processzus ne legyen egyidejűleg kritikus szekcióban, akkor ezzel elkerülhető lesz a versenyhelyzet is. Párhuzamosan futó processzusok akkor oszthatják korrekten és hatékonyan a közös adatterületeket, ha: 1. két processzus nem lehet egyidejűleg a saját kritikus szekciójában, 2. nem szabunk előfeltételeket a sebességekkel és a CPU-k számával kapcsolatban, 3. egy, a saját kritikus szekcióján kívül futó processzus sem blokkolhat

más processzusokat, 4. egy processzusnak sem kell örökké várnia, hogy belépjen a saját kritikus szekciójába 10. oldal, összesen: 27 8. IPC (InterProcess Communication) problémák Az étkező filozófusok probléma • Dijkstra (1965-ben) vetette fel a problémát, és ma is gyakran tesztelik az új szinkronizációs primitíveket ezzel a feladattal • A probléma: – öt filozófus, öt tányér spagetti, öt villa – enni csak két villával lehet egyszerre – a filozófusok ‘kétállapotúak’: gondolkodnak vagy esznek – Ha egyikük megéhezik, egyenként megpróbálja felvenni a két villát és eszik, majd leteszi a villákat és újra gondolkodik • • • • Ha mind az öt filozófus egyszerre veszi kézbe mondjuk a bal oldali villáját - a másikat nem tudja megszerezni. Holtpont alakul ki. Ha csak a jobb oldali villa elérhető, tegye azt le és várjon, amíg a bal oldali is szabad lesz. Előfordulhat, hogy ezt az algoritmust mindegyik filozófus

egyszerre hajtja végre, cselekszik, kivár. Mindig történik valami, de nincs előrehaladás. Az ilyen programproblémát éheztetésnek nevezzük Ha nem azonos időközönként próbálkoznak a filozófusok, akkor sem valószínű, hogy sokáig fenntartható az, hogy mindig egyen valaki. Gyakorlati hiba, hogy nem hatékony a módszer: egyszerre csak egy filozófus eszik (hiszen akár kettő is megtehetné ezt). Az olvasók és írók • Az étkező filozófusok problémakör, és a megoldások jól hasznosíthatók, ha korlátozott számú erőforrás miatt alakul ki versenyhelyzet • Az író-olvasó probléma nem más, mint az adatbázisok hozzáférési problémáit modellező feladat (például repülőjegy-foglalás) • Elfogadható, hogy több olvasó legyen a bázisban egyidejűleg, de az írónak kizárólagos jogot kell adni a hozzáféréshez • Ha az olvasó mindig új olvasókat enged maga mellé, akkor hatékony egyidejűséget kapunk. Ugyanakkor a bázis előtt

akár a végtelenségig is várakozhat egy író, hogy az olvasók elfogyjanak, és egyedül maradjon a bázisban. • Ezt elkerülendő, ha író várakozik, és újabb olvasó érkezik, azt az író maga mögé parancsolja. Csak azt kell megvárnia, hogy a bázisban tartózkodó olvasók elfogyjanak. Ez a módszer kevésbé hatékony, mert nem támogatja az egyidejű olvasást oly mértékben, mint az előző. Az alvó borbély probléma • egy processzus (a borbély) kiszolgál más processzusokat (vendégek) • Reggel kinyit, ha nincs vendég, aludni megy • Az első érkező vendég ébreszti • Csak meghatározott számú (a székek száma szerinti) vendég tartózkodhat az üzletben. Ha nincs benn ülőhely, a vendég várakozni kényszerül az ajtó előtt • A hajvágás egy eljárás. Amíg tart, az üzletben levő többi vendégek nem kerülnek sorra (nem léphetnek kritikus szekcióba - mutex szemafor), • Ha a hajvágásnak vége, a vendég elhagyja az üzletet, és

a borbély megnézi várakozik-e valaki a székeken. Ha igen, új eljárást kezd, egy szék kiürül, új vendég jöhet be várakozni a sorára. • Az író-olvasó probléma és az alvó borbély probléma esetében nem történik valódi adatátvitel, de IPC témakörbe tartoznak a szinkronizációs problémák miatt. 9. Folyamatok ütemezése Ha több processzus kerül egyidejűleg futásra kész állapotba, akkor az OR döntést hoz a futás sorrendjéről, ütemez A jó ütemezési algoritmus néhány feltétele • Pártatlanság, Hatékonyság • A válaszidő minimalizálása az interaktív felhasználóknál • Az áthaladási idő minimalizálása a kötegelt felhasználóknál • Jó áteresztőképesség (az egy időegység alatt elvégzett munkák száma) • A processzusok futása egyedi, és nem jósolható előre, a CPU-idő viszont véges • Hogy a processzusok csak behatárolt időintervallumon belül futhassanak, a rendszer rendszeres megszakításokat

küld 11. oldal, összesen: 27 • • Ha egy futásra kész processzus felfüggeszthető, akkor megszakító ütemezésről beszélünk. Az esetleges versenyhelyzeteket szemaforok, monitorok, üzenetek alkalmazásával kerülhetjük el. Round robin ütemezés • Minden processzusnak ki van osztva egy adott időszelet, amíg futhat • Ha az időszelet végén a processzus még fut, akkor felfüggesztik, és a CPU a következő kijelölttel folytatja. Ha az időszelet közben végez, a CPU új processzust választ. Feltételezzük, hogy a processzusok azonos prioritásúak • A legkomolyabb gond az időszelet hosszának meghatározása. • Az átkapcsolás maga is időbe telik (minél kisebb kell, hogy legyen az időszelethez képest) • A túl hosszú időszelet nem hatékony (elsősorban az interaktív felhasználóknál szembetűnő) Prioritásos ütemezés • Ha az ütemezéskor külső tényezőket is figyelembe veszünk, akkor prioritásos ütemezési algoritmust kell

használnunk (a legmagasabb prioritású fut először) • Hogy a magas prioritású ne futhasson a végtelenségig – futás közben csökkenthető a prioritása vagy – kiszabható a maximális időszelete • A prioritásokat tehát a processzusokhoz rendelhetjük – statikusan, a külső tényezők alapján, előre megadottan – dinamikusan, (például, hogy B/K processzusok ne várjanak, hiszen ha időben indulnak, más processzus is CPU-hoz juthat a B/K futása mellett) – prioritási osztályokat létrehozva Ütemezési algoritmus négy prioritási osztállyal • • először a 4-es prioritású osztály elemei futnak, amíg van belőlük; a maguk időszeleteiben, Round Robin módon ha a magasabb osztályból az elemek elfogynak, az alacsonyabb szintűek kerülnek sorra Többszörös sorok • A különböző osztályban levő processzusok különböző számú időszeletig futnak (a magasabb osztálybeliek több időszeletet vehetnek igénybe közvetlen egymás

után) • Ha a processzus elhasználja a számára így előlátott időszeleteket egyszer, akkor ezután eggyel alacsonyabb prioritású osztályba kerülve várja az aktualizálást • Az eredetileg hosszú futási időt igénylő processzusoknak ez a módszer gyakran hátrányos A legrövidebb feladatot először • Olyan kötegelt rendszereknél használják, ahol a futási idő előre ismert • A sok egyformán fontos bemenő feladat közül az ütemező a legrövidebbet először hajtja végre • Nehéz előre eldönteni, hogy az interaktív processzusok közül melyik lesz a legrövidebb Sorsjáték- ütemezés (1994) • A processzusok között másodpercenként adott számú sorsjegyet (CPU időegységet) oszt ki az ütemező • A magasabb prioritású processzusok több sorsjegyet kapnak • Együttműködő processzusok átadhatják egymásnak a sorsjegyeiket, növelve ezzel a hatékonyságot (pl. kliensek nélküli szervernek nem kell sorsjegy) • Különösen jól

alkalmazható videó-szervereknél (a képlebontásnak megfelelő számú sorsjegyet adunk a képkezelő processzusnak) Valós idejű ütemezés • A valós idejű rendszerekben az idő nagyon fontos tényező. (A bitekből zenét produkálni) • A programokat rövid, megjósolható időtartamú processzusokra osztjuk • A valós idejű rendszerek programozható eseményei lehetnek periodikusak illetve aperiodikusak. • A valós idejű ütemező algoritmusok is lehetnek – statikusak (a rendszerindítás előtt adjuk meg) 12. oldal, összesen: 27 • – dinamikusak (futás közben változtathatóak) Ismert valós idejű algoritmusok: – állandó arány algoritmus – legkorábbi határidő először – lazaságon (processzus felesleges időmennyiségén) alapuló algoritmus. Kétszintű ütemezés • Ha a futtatandó processzusoknak nem elegendő a főmemória, hanem lemezkapacitást is igényelnek, akkor a hatékonyság érdekében kétszintű ütemezést kell

alkalmaznunk • A processzusok egy része betöltődik a főmemóriába, az ütemező ezekkel fogalakozik. A többi lemezen marad, majd idővel ezek kerülnek a főmemóriába, egy magasabb szintű ütemező hatására. • Az alacsonyabb szintű ütemező a főmemóriabeli processzusokat kezeli, a magasabb szintű ütemező pedig a lemez és a főmemória között ingázik. • Az ütemezők használhatják a round robin, a prioritásos, vagy más ütemezési módszert, de nem kötelezően ugyanazt használniuk Az ábra három különböző (a), (b), (c) időpillanatot mutat be. • Az ütemező a következő kritériumok alapján dönthet: • Mennyi idő telt el a processzusok kicserélése óta? • Mennyi CPU időt használt fel a processzus ez idáig, és mennyit utoljára? • Milyen nagy a processzus (a kicsik nem zavaróak a főmemóriában sem) • Milyen magas a processzus prioritása? • Bevezethetünk ütemezési célokat, ami azt jelenti, hogy az ütemezési

algoritmust paraméterezzük, a paraméterek megadását más processzusokra bízzuk. 10. Holtpontok és kezelésük Mi a holtpont? • Az együttműködő folyamatok szinkronizációs és kommunikációs problémáiból eredő leállás • Például egy H folyamathalmaz holtponton van, ha egy H-beli folyamat által előidézett eseményre vár Jellemzők • Nem csak erőforrás miatt • Lehetnek holtpontos és futó folyamatok is • Nem alakul ki mindig – alattomos • Csökken a teljesítőképesség A versengő rendszerek jellemzői • Véges számú erőforrás • Egypéldányos, többpéldányos • Megosztható és kizárólagos használatú • Lépések: – Igénylés – Használat – felszabadítás A holtpontok kialakulásának feltételei: • Kölcsönös kizárással, kizárólagos joggal használt erőforrások • Foglalva várakozás • Nincs erőszakos erőforrás-elvétel • Körkörös várakozás • Erőforrás gráf: erőforrás, folyamat, kérés

él, foglal él Problémamegoldás • Strucc algoritmus (ha fájdalommentes) • Detektálás és feloldás • Védekezés (hatékonyságromlás) – Kizárjuk a szükséges feltételek egyikét, – elkerülés • Felhasználói folyamatok: új holtpont-lehetőség! 13. oldal, összesen: 27 • • Észlelés: lassulás esetén egy program kilövi Feloldás: veszteséggel járhat, visszaállítható legyen Megelőzés • Kölcsönös kizárás – osztatlan műveletek (PL. nyomtató sor) • Foglalva várakozás (egyetlen rendszerhívással történő kérés) • Erőszakos erőforrás-elvétel (csak menthető állapotú erőforrásoknál) • Körkörös várakozás (viselkedési szabály) Kommunikációs holtpont • Ügyfele és szolgáltatók folyamatai • A szerepek nem különülnek el • Egymásra várnak körkörösen Konzervatív holtpont-kezelés • egyszerre egy folyamat fogja az erőforrásokat • Hogyan szolgálja ki a rendszer az előbbi problémát? •

hátrány: – Az erőforrások nagy része kihasználatlan – Hosszú várakozási sor – Jelentkezhetnek kiéheztetett folyamatok 11. Szálkezelés Folyamatok megvalósítása: szálak • A hagyományos processzusszervezésben egy vezérlési szál és egy utasításszámláló volt • A modern ORek támogatják a processzuson belüli többszörös vezérlési szálak kiszolgálását. Ezeket a szálakat nevezzük könnyűsúlyú processzusoknak vagy egyszerűen szálaknak Példák • Fájlszerver processzus. A szerver az aktuális fájlba történő íráskor/olvasáskor hatékonyságnövelés céljából gyorsítótárat (cache) használ. Ha az OR blokkolja is processzust, több szálon fogadhat továbbra is kéréseket a fájllal kapcsolatban. Egyszálas rendszernél ez nem lehetséges, mert különböző processzek különálló szálai nem osztozhatnak ugyanazon a gyorsítótár-tartományon. • A WEB oldalak több kis összetett képből állnak. Ezek letöltése

különálló kapcsolatteremtést jelent, és különálló szálakon futó kapcsolatként lényegesen növelhető a letöltés teljesítménye. • Ha ugyanazon címtartományt több szál használja, akkor néhány processzkezelő mező szálanként értendő, és a különálló száltáblázat tartalmaz önálló • utasításszámlálót (mert a szálak felfüggeszthetők és újraindíthatók), • regisztereket (amelyeket szál-felfüggesztéskor ugyancsak elmentünk), • állapotjelzőt (mert a szálak is lehetnek fuót, futáskész és blokkolt állapotban). Szálak kezelése • Ha az OR nem vesz tudomást a szálak létezéséről, akkor azok felhasználói hatáskörben vannak (azaz például egy blokkolásra készülő szál maga jelöli ki az utódját). Ilyen feléhasználói szintű szálkezelő csomag például a POSIX P-szálak csomagja. • Ha az OR kezeli a szálakat, akkor a kezelés a kernel feladata, amely a szálak ütemezését a processzustáblázathoz

hasonló, minden futó szálra vonatkozó száltáblázat segítségével végzi. • A szálak közötti átkapcsolás a felhasználói szintű szálkezelésnél gyorsabb, viszont egy szál blokkolása ennél a módszernél a teljes processzus blokkolásához vezet. Ezért mindkét módszert (a felhasználói- és a kernel-kezelést is) alkalmazzák, illetve azok hibrid változataival kisérleteznek. • Az olyan hibajelzéseket, amelyeket a processzus egyik szála globális változóba ír (pl. UNIX-ban), felülírhatja ugyanazon processzus másik szála. • A szignálok között vannak szálspecifikusak. Ha például a többszálas rendszer kernelje a processzus valamely száljától ALARM hivást kap, tudnia kell az eredményszignált a megfelelő szálon átadni. A felhasználói szintű szálkezelésnél viszont az a probléma áll elő, hogy a rendszer processzusonként csak egy riasztást képes kezelni, ugyanakkor a processzus több száljának akár egyidőben is szüsége

lehet a riasztásra. • Többszálas processzus szálankénti vermelést igényel. Verem-túlcsordulásnál a kernelnek érzkelnie kellene melyik szál verméről van szó, és csak azt autómatikusan növelnie. Ez nehezen oldható meg 14. oldal, összesen: 27 A szálak alkalmazásakor felmerülő nyitott kérdések közül néhány: • Milyen hatása van a többszálas szülőprocesszusban kiadott, gyermekprocesszust létrehozó rendszerhívásnak? A gyermekpocesszus megörökli a szálakat is? • Ha a szülő- ás a gyermekprocesszus is többszálas, és egy B/K rendszerhívás blokkolja a szálat, csak a szülő-szál blokkolódik? Csak a gyermekszál, vagy mindkettő? • Ha több szál osztozik ugyanazon adatstruktúrán, természetesen ugyanazon a processzuson belül, akkor előfordulhat hogy egyik szál lezár egy fájlt, egy másik szál pedig még olvas belőle? • Ha egyazon processzus két különböző szála majdnem egy időben igényel újabb memóriaterületet,

mindkettő külön-külön kap új területeket? (Nem többszálas rendszereknél gyakran összeomlik az OR, ha még kielégítetlen igénylés alatt újabb érkezik) 12. Fájlkezelés, fizikai és logikai fájlszerkezet A fájl az őt létrehozó felhasználó szempontjából összetartozó adatok gyűjteménye. A fájlokat programok hozzák létre és dolgozzák fel, perifériákon tárolódnak, és ezért tartalmuk, a központi tárban tárolt változókkal és adatokkal szemben, megmaradnak a munka végeztével. Az OR az állományokat a hozzájuk rendelt azonosítóról, névről ismeri fel A felhasználó szempontjából a fájl egy logikai absztrakció, hiszen elrejti a tárló eszközt, a perifériákról és perifériákra történő fájlmozgatás lényegét, és a tárolókon történő valódi elrendezést. Ha az állományt tároló eszközre hivatkozunk, akkor azt egyes OReknél logikai eszköznévvel tesszük (MS-DOS, pl. a:, b:, c:,), vagy, mint a UNIX-nál, az

egységes állományrendszer keretein belül a perifériákat is fájlként látjuk (itt ugyanis minden fájl). Az állományokat a felhasználók, vagy maga az OR, feladatbeli hovatartozásuk szerint könyvtárakba (folder, katalógus) csoportosítja. Az OR feladatai a fájlkezeléssel kapcsolatban, a megvalósításbeli eltérésektől függetlenül a következők: - műveleteket hajt végre az állományokon és a könyvtárakon (létrehozás, törlés, másolás, módosítás környezetének biztosítása) - biztosítja az információátvitelt az állományok és az őket használó folyamatok között, - az egyidejűleg több folyamat által használt állományok kezelését, - szabályozza a fájlok hozzáférési jogosultságait, - biztosítja a tárolt fájlok védelmét jogosulatlan olvasástól, írástól, törléstől, módosítástól, - eszközöket biztosít az archiváláshoz Fájlszerkezetek Az OR számára a fájl bájtok sorozata. Maga a felhasználó az, aki

ezeket az elemi információegységeket nagyobb egységekbe szervezi. Így alakul ki a: - mező, amely egy egyszerű számadatot tartalmazhat - a rekord, amely általában összetartozó mezők csoportja. A fájl, ha ilyen rekordokból épül fel, akkor általában azonos szerkezetű rekordok sorozata. Bizonyos OR-ek az állományokat csak bájtsorozatnak tekintik, és csak az erre hivatott állománykezelő programok azonosítják be a fájl belső szerkezetét (ilyen a UNIX). A másik lehetőség, hogy az ORnek közvetlen eszközei vannak a rekordonkénti hozzáféréshez, tehát új mezőtípusok létrehozására. Ez azt is jelenthetné, hogy minden egyes új rekord, vagy mezőtípus létrehozásáról az OR-nek tudnia kell, ám ez szinte lehetetlen. Így ez a megoldási lehetőség inkább elvi Az állományok fizikai tárolása Az OR által a fájlkezeléssel kapcsolatos legkisebb kezelt információegység egy blokk (tipikusan 512 bájt). Egy blokknyi adat néhány szektor

tartalmát öleli fel. Egy blokknyi adatot kér le az OR, egy blokknyit képes felszabadítani és így tovább. A szabad, blokknyi területek számontartására szolgáló módszerek nagyban befolyásolják a rendszer sebességét és hatékonyságát. A nyilvántartás végezhető: - Bittérkép segítségével, amelyben minden blokkot egy bit ábrázol, 1, ha foglalt, 0 ha szabad. A szabad, illetve összefüggő szabad helyek jól felismerhetők, de a bittérkép jól védett, állandóan elérhető helyen kell, hogy legyen. - Láncolt blokklista estében a szabad blokk tartalmazza a következő szabad blokk hivatkozását, és a rendszer csak az első szabad blokkot jegyzi. Az összefüggő szabad helyek nem beláthatók, ezért lényegesen több lemezmozgatásra van szükség. A módszert némileg javítja, ha a szabad blokk végén nem egy, hanem több szabad blokk-hivatkozást helyeznek el. - Az egybefüggő szabad területek nyilvántartása a fenti módszerek egyesítése,

mert a teljes bittérkép helyett csak az összefüggő szabad blokkhalmazok közül csak az elsőre találunk hivatkozást, a szabad terület nagyságával kibővítve. 15. oldal, összesen: 27 Állománykezelés általában és a UNIX alapú rendszerekben Az állományok tartalma lehet: - programállomány (forrás-, tárgy-, bináris-, stb. programok) vagy - adatállomány (numerikus, alfabetkus, alfanumerikus). Ettől függetlenül szerkezetileg az állomány lehet bájtok, szövegsorok, vagy rekordok sorozata, de legfőbb jellemzői a: - név, hossz - típus, tulajdonos - létrehozás, változás dátuma - hozzáférési jogkörök Az OR általában adott típusokat megnyitás, kezelés, elmentés, nyilvántartás, védelem szempontjából különbözőképpen kezel. A UNIX elegáns – minden állomány bájtok sorozata, azaz fájl A UNIX alapú rendszerek esetében az OR is állomány. A ROM–ba kerül a betöltőprogram és a rendszermag fix része. A RAM egy része is

állandó tartalommal rendelkezik, ez a rezidens része az OR-nek A memória tranzisztens része a szolgáltatóké. A UNIX mint minta - minden információ a rendszeren belül állomány - fa-szerkezetű katalógusrendszer épül a root-ból kiindulva, benne általában a bin (bináris rendszerprogramok), dev (perifériák kezelése) katalógusokkal. - minden felhasználó báziskatalógust kap, bejelentkezéskor pedig aktuális katalógust, ami módosulhat munka közben, - az állományokra a gyökértől induló úttal hivatkozunk, - linkelt hozzáférést biztosít, - az állományvédelem tulajdonosra, csoportra vagy egyéb felhasználóra vonatkozik (egymástól független paraméterekkel) - az állományok általános kezelését (másolás, listázás) egyszerű programkönyvtárak végzik. Hozzáférési jogosultságok (permission) - Létkérdés a többfelhasználós rendszereknél. - Alapazonosítók a uid és a gid (tulajdonos és csoporttagok, illetve egyéb) -

Alaptevékenységek: olvasás, írás, végrehajtás (illetve keresés) 13. Tárkezelés, tárleosztás, lapozás A számítógépes rendszerek tárolói, ár és hozzáférés, valamint kapacitás szerint, hierarchikus módon is sorbarakhatók. Alsó szinten a processzor fizikai regiszterei helyezkednek el, majd a tárkapacitás és hozzáférési idő növekedésével jutunk el az operatív táron, és a háttértárolókon keresztül a másodlagos és harmadlagos tárolókig. A szintek közötti adatmozgatás az OR egyik fő feladata. A legnagyobb gondot az jelenti, hogy a futtatandó programnak és a vele kapcsolatos adatoknak állandó jelleggel a memóriában kellene lenniük, ám ezek időnként már a cache memóriák beiktatásával sem férnek el a processzor közelében. Gyorsítótárak A szintek közötti adatmozgatást segítik elő. Az I/O rendszer először rákérdez, hogy az adat a cache-ben van-e már, és ha igen, akkor továbbítja az alacsonyabb szintre (ezt

találatnak nevezzük). Ha nem, akkor bekéri azt a magasabb szintről. A gyorsítótárak jellegzetes képviselői a következők: - Regiszterek, virtuális memóriák - a buffer-cache, amely fájlok tárolását teszi lehetővé a memória erre kijelölt részén A szintek közötti adatmozgatás általában a felhasználó számára rejtettek. Hatékony algoritmusokkal elérhető, hogy egyszerre nagyobb adatmennyiség is mozogjon, hiszen az egy feladatra vonatkozó programrészek és adatok általában egymáshoz közel eső tárrészekről találhatók. A találatok aránya így elérheti a 90%-ot is Maga az OR közvetlenül a központi tárra és a háttértárak és másodlagos és harmadlagos tárolók fájlrendszerére felügyel, valamint a virtuális memória és buffer-cache tartozik a hatáskörébe. Memóriakezelés Az optimális leosztásra törekedve a következő elveket szokás figyelembe venni: - csökkenteni kell a program által egyidejűleg igényelt

memóriaterület nagyságát, mégpedig úgy hogy 16. oldal, összesen: 27 csak a futó programrészek töltődnek a tárba a programból (fontos a programon belüli modularitás) egy program futásán belül a címtartományt többszörösen kihasználják (overlay programszerkezettel, illetve algoritmusokkal) - a több program által használt eljárások fizikailag csak egyszer tárolódnak a memóriát hézagmentesen kellene kitölteni úgy, hogy a programrészek helyeit felcseréljük vagy még jobban elaprózzuk az adatblokkokat hatékonyan vonjuk be a munkába a háttértárakat. - - A fizikai tárigény csökkentésére egyrészt a programozók által írt, dinamikus betöltésre szolgáló rutinok szolgálnak, másrészt azok a rutinok, amelyek az úgynevezett könyvtári eljárásokat kezelik. Ezek az eljárások azok, amelyek egyszer töltődnek a memóriába, és onnan több processz is használhatja őket. Az átfedő programrészek technikája is segít a

tárigény csökkentésében. Ilyenkor a modulokra bontott program programrészei közül a leghosszabb foglal címtartományt, és ezen a területen cserélődnek mindig a futó programrészek. Ennél a módszernél az OR közreműködése nem szükséges, elegendő a jó moduláris felosztást megszerkeszteni. Tártervezési módok Az egypartíciós rendszerben a kötött, például megszákításvektorok vagy periféria címtartományok feletti memóriatartományokat csak egyetlen folyamat használja. Az első szabad címtől töltődik a program, és csak ennek a címnek a megőrzése elegendő a biztonságos leosztáshoz, illetve futás közbeni cserékhez. A többpartíciós rendszer a multiprogramozású rendszerek következménye. Az OR az általa lekötött címtartományokat fix vagy változó hosszúságú partíciókra osztja a folyamatok között. A szabad területek nyilvántartása az OR feladata. Ha túl sok a rés, léteznek a foglalt regiszterek tartalmát a memória

egyik végébe tömörítő rutinok Mindez dinamikus memóriabetöltést biztosít. A dinamikus memóriabetöltés néhány ismertebb algoritmusa a következő: - a legjobban illeszkedő módszer, amelynél a legkisebb elegendő méretű térrészt foglalja el a betöltött program, - az első megfelelő módszere, a sorbarendezett szabad tartományok közül az első megfelelő hosszúságút választja - a legkevésbé illeszkedő, ahol a legnagyobb szabad memóriarészbe másolódik be a program teljes egészében. A többpartíciós rendszer a biztonság érdekében a futó processz által lefoglalt tartomány kezdeti és végső címét tárolja. A tárcsere (swapping) módszere azt jelenti, hogy a fizikai tárat időben osztjuk meg a folyamatok között. Ha például egy folyamat hosszabb várakozásra kényszerül, akkor a vele kapcsolatos adatok a háttértárolóra másolódnak, átadva a helyet a soron következő folyamatnak. Folytatáskor visszatöltődnek az adatok A

régebbi kis méretű tárak esetében ez a módszer elterjedt volt, mára már csak akkor folyamodnak hozzá az ORek, ha valóban hosszú várakozásról vagy torlódásról van szó. A lapszervezés alkalmával mind a fizikai, mind a logikai címtartományokat azonos, rögzített hosszúságú lapokra osztják (binárisan kerek hosszúságúra). A logikai és fizikai lapszerkezet közötti kapcsolatot minden pillanatban egy laptábla rögzíti, így a logikai lapok bármely elhelyezkedésben rákerülhetnek a fizikai lapok helyére, csak a lapon belüli elrendezés marad fix. Különböző folyamatoknak saját laptáblája van A módszer gyorsítható, ha a lapokon belüli hozzáférést csak egyszerű eltolásokkal oldják meg. Előnye, hogy jó a kihasználtsága, viszont a laphossz nem mindig igazodik a külső adatszervezéshez. Szegmensszervezés esetében a fix hosszúságú lapoktól eltérően, változó hosszúságú szegmensekre tördelik az adatokat. Ugyancsak

memóriaképben tárolódik a logikai és fizikai címtartományok közötti kapcsolat A szegmensek igazodhatnak az adatszerkezetekhez. Egy szegmens tartalma lehet például pontosan egy folyamat memóriaképe vagy egy blokknyi adat. A logikai címek változtatáskor megmaradnak, csak a szegmens igazodik a futtatáshoz, növelve ezzel a hatékonyságot. A lapszervezés és a szegmensszervezés lehetővé teszi, hogy több folyamat közös tárterületet használjon. A közös területek konfliktus nélküli használatáról az OR gondoskodik. A mai modern rendszerekben ez utóbbi két módszert gyakran együtt is alkalmazzák. Virtuális memória A lap- és szegmensszervezés lehetővé teszi, hogy az OR közreműködésével a folyamatok szinte korlátlan terjedelmű logikai címtárat használjanak, hiszen a háttértárolók elbírják a laponként vagy szegmensenként cserélődő éppen aktuális adatmennyiséget. A címtartományok a rendszerlemezre képződnek le, a memória

csak gyorsítótárként működik. A folyamatok tehát egy virtuális memóriát látnak, a központi tárban csak a pillanatnyilag futó lap található Azokat a tapasztalatokat tükrözik a lapcserék és más módszerek, amelyek szerint például - a program úgysem használja egyidejűleg a teljes parancskészletét - bizonyos programrészek, például a hibakezelők, nem is biztos, hogy futni fognak - a programrészek időben elkülönülten (gyakran) szekvenciálisan hajtódnak végre - a programmodulok az erőforrásokat eltérő intenzitással használják - ha több folyamat lapjai elérhetőek egyszerre, akkor egyszerűbb az erőforrások ütemezése 17. oldal, összesen: 27 A lapkiválasztás történhet - igény szerint (demand paging), azaz csak a laphibánál észlelt lapot hozzuk be a memóriába - előretekintő lapozás, ahol az OR valamilyen algoritmus alapján betölt olyan további lapokat, amelyre várhatóan hamarosan szükség lesz. A lapcserék jellemző

módszerei a következők: - legrégebbi lap (FIFO), ahol a legrégebben betöltött lap cserélődik ki egy újra - optimális algoritmus, amely csak akkor igazán optimális, ha előrelátható, mely lapokra lesz a közeljövőben szükség. Ez multiprogramozott rendszerben nem jósolható meg biztosan, mégis használható - legrégebben nem használt (Last Recently Used, LRU) lapok módszere azt a lapot helyezi ki, amelyre a legrégebben hivatkoztak. Ez jó módszernek bizonyult, de nehézkes a megvalósítása - Újabb esély (Second Chance): a lap használatát is számontartó FIFO módszer. A lapcserék hatékonyságát az is növelheti, ha a betöltést mindig elvégezzük, de a lecserélt lapokat csak akkor mentjük újra a háttértárolókra, ha azokban változás állt be. Az OR, ha van szabad kapacitás, a módosított lapokat akkor is menti, ha nincsenek még cserére ítélve. Ha a lapozó folyamat csak a maga lapjait cserélgeti, akkor lokális, ha más folyamat lapjai

közül is bekér, globális memóriagazdálkodásról beszélünk. A többfeladatos rendszereknél a virtuális tárban egy feladathoz egyre kevesebb aktív lap tartozik, és a lapozásban résztvevő folyamatok számával növekedhet a laphiba-gyakoriság. Ez elaprózódáshoz, lassuláshoz, végül pedig vergődéshez (thrashing) vezet. Ezért meg kell találni az egyensúlyt a lapozó feladatok száma és az úgynevezett működő lapkészlet számossága között. Sajnos különböző feladatoknak, különböző futtatási szakaszban különböző a lapszámigénye, és ez bonyolítja az általános algoritmusok kidolgozását. A dinamikus lokális memóriagazdálkodás olyan lokális gazdálkodási rendszer, amely figyelve a folyamatokat, esetlegesen áttérhet a globális gazdálkodásra is. 14. Lemezkezelés, olvasási és kihelyezési algoritmusok Olvasási algoritmusok A fájlkezelő modelleket alapvetően a hozzáférési módszerek határozzák meg. A soros (vagy

szekvenciális) hozzáférési mód a mágnesszalag korából való, ahol az azonos hosszúságú rekordokat csak szigorú egymásutánban lehetett elérni. Ma már elsősorban a fájl-pointer tábla hozzáférési modelljeként alkalmazzuk A közvetlen (direkt) hozzáférés az elemi információegységek (bájt, mező, rekord) közvetlen elérését sorszám alapján biztosítja. Az indexelt, illetve index-szekvenciális hozzáférés (Index sequential access method, ISAM) egy kulcstáblán keresztül jut el a fizikailag tárolt rekordhoz. A kulcs szerint rendezett indextábla lehetővé teszi a gyors elérést a valódi adattáblában. Az állománykezelő programoknak gondoskodniuk kell adatmódosítás esetén az indextábla-módosításról is Kihelyezési algoritmusok Ha már a szabad területek térképe valamilyen módon a rendelkezésünkre áll, akkor beszélhetünk a fájlok kihelyezésének módjáról (allokációs módszerről) is A folytonos terület módszerével az

összetartozó információkat, egymást követő szabad blokkokban igyekszik elhelyezni az OR. Sajnos előre sohasem tudjuk, hány blokkot foglal majd le a betöltendő információ, és az elhelyezés esetlegesen maga után vonhat újabb tördeléseket is. A módszer előnye viszont, hogy akár szekvenciális módon is visszakereshetjük a blokkok tartalmát. A láncolt tárolás esetében a következő szabad blokk töltődik fel, ám annak utolsó helye szabadon marad, mert ott található utalás a következő szabad blokkra, ahol az írás majd folytatódik. Így viszont az adatok csak sorba-járással nyerhetők vissza, maga a tárolási mód pedig a láncszemek miatt sérülékeny. Az előny az, hogy mindaddig, amíg van szabad blokkra történő utalás, a rendszer nem szorítja keretek közé a tárolandó információt, mint az előző módszernél. Ezért utólagos tördelés sem várható. Az MS-DOS OR által használt módszer a fájl-allokációs tábla alkalmazása

(File Allocation Table - FAT). Ez a módszer a láncolt tárolás egy változata, amikor is az összes láncelemet egy kitüntetett helyen tároljuk a lemezen. A foglalt lemezblokknak megfelelő helyen ebben a táblában a következő szabad blokkra utalást találunk. A mágneses lemez fizikai szerkezete • A lemezek mindkét oldalát sávok (track), azon belül szektorok alkotják. A több, egymás fölé fűzött sávok alkotnak egy cilindert. • A szektor a legkisebb kezelhető egység az információátvitel szempontjából, és benne már csak bitsorozatként értelmezhető az információ. Hozzáférési idő • Amit a hardver szempontjából figyelembe kell venni még az, hogy: – mennyi idő alatt áll a fej rá a kiválasztott sávra (lassú) – a kiválasztott szektorra, és hogy – mennyi idő alatt kerül tovább az egy szektornyi információ. 18. oldal, összesen: 27 Jellemző algoritmusok • A sorrendi kiszolgálás (First Come First Served, FCFS)

algoritmusa a beérkezés sorrendjében szolgálja ki a lemez-I/O igényeket. A fejmozgatás természetesen így nem optimális, viszont a válaszidők kiegyensúlyozottak • A legrövidebb fejmozgatási idő (Shortest Seek Time, SSTF) algoritmus azt a kérést szolgálja ki elsőként a várakozók közül, amely a legkisebb fejmozgatást igényli. Így nagy a várakozási idő szórása, sőt a kiéheztetés veszélye is fennáll, azaz egyes igényeket az algoritmus mindaddig nem vesz figyelembe, amíg közelebbi cilinderen talál magának feladatot. • A pásztázó (SCAN) algoritmus a pillanatnyi fejelmozdulás irányában veszi sorra az igényeket, majd ha azok egyik irányban, egy időpillanatban elfogynak, akkor a másik irányba fordul. A középső cilinderek így mindig gyakrabban kerülhetnek sorra. (ritka lemezműveletek esetén hatékony) • Az N lépéses pásztázó (N-SCAN) az egyik irányba történő pásztázás indításakor pontosan N darab igényt vesz

figyelembe az adott irányban, majd amikor ezeket kielégíti, a következő N igényt a másik irányból veszi sorra. A SCAN módszer várakozási idejével összehasonlítva kisebb szórást mutat ez a módszer, és nem részesít előnyben egy adott cilindercsoportot sem. • Az egyirányú, körforgó pásztázó (C-SCAN) algoritmusa mindig egyik irányban haladva szolgálja ki sorban az igényeket, majd, ha végez, visszaugrik a kezdetre, és a közben beérkezett igényeket számba véve újra elindul pásztázni. Így mindenképpen azonos eséllyel indulnak a külső és belső sávok (gyakori lemezműveletek esetén hatékony) Kisegítő módszerek • Jó eredmény érhető el a lemezterület tömörítésével, azaz az összetartozó adatblokkok fizikailag is összefüggő blokkokba, szektorokba helyezésével. Sajnos a multiprogramozású rendszereknél, az időosztás miatt az összetartozó adatblokkok kezelése sem folyamatos, hiszen mindenkit ki kell szolgálni, így a

tömörítés időnként jelentéktelen eredményt mutat. • Kódolási módszerekkel az adatokat tárolhatjuk "pakolt", azaz tömörített formában, és beolvasáskor segédprogram "kicsomagolva" továbbítja a memóriába, miközben a felhasználónak erről mit sem kell tudnia. • • • • • • 15. Az I/O rendszer kezelése A számítógépen zajló feladatok megoldásának sebessége jórészt azon múlik, hogy milyen jól szervezett az adatmozgatás a rendszeren belül Az adatmozgatás az eszközöktől függően történhet bájtonként, például a billentyű és képernyő esetében. Ilyenkor az adatmozgatás iránya is gyakran egyértelműen meghatározható, tehát például a képernyő irányába csak a kiírás műveletéről kell gondoskodni. A blokkonkénti adatátvitel például a lemez kezelésekor jellemző. egyes vezérlők csak egy-egy eszközt felügyelnek, mások a sínrendszeren keresztül több eszközt koordinálnak. Az olyan

vezérlők, mint a grafikus vezérlő, vagy a lemezekhez csatlakozó SCSI sin, önálló processzorral (és mikrokóddal) rendelkeznek. A portok a legegyszerűbb csatlakozók: sínillesztő áramköröket és néhány regisztert tartalmaznak. A processzor többféleképpen is elindíthat egy IO átvitelt. • Az alapelv az, hogy az adott memória-címekre bizonyos időközönként, egy jelzőbit állása alapján, a várakozó IO vezérlők meghatározott regiszterei betöltődnek, illetve ezekről a memóriaterületekről a vezérlők regisztereibe kerülnek vissza. Állapotjelzők • Ha a vezérlők állapotjelzőit programozottan ellenőrzi a rendszer, akkor polling módszerről beszélünk. • Lehet ugyanakkor a processzor és a vezérlők közötti kapcsolat megteremtője egy ciklikusan ismétlődő algoritmus, amelyben megszakítások biztosítják azt, hogy a processzor felismerje az IO igényeket. Device, interface, driver • A legtöbb szabványosított device (eszköz)

interfészt az operációs rendszerek eleve felismerik, mert beépítik őket a fejlesztők, legfeljebb néhány paramétert kell megadni a telepítéskor. • Ha teljesen ismeretlen eszköz telepítéséről van szó, akkor az OR úgynevezett device driver (eszközmeghajtó) segédprogram-csomagjával meg lehet írni a beillesztést. 19. oldal, összesen: 27 Az adatmozgatás jellemzői rétegenként • Az alkalmazói felület szintjén az adatblokkok a memória és valamelyik eszköz között mozognak. Minden esetben ismert a forrás, a célállomás és a mozgó adat mennyisége. A forrás és a cél természetesen vagy a memória vagy az eszköz lehet, az adatmennyiséget pedig bájtokban szokás megmutatni. • Az kért I/O lépésre utaló szabványosított adatstruktúra ilyenkor tartalmazza a: • parancsot (olvasás vagy írás) • egy állapotjelzőt, amely az adatmozgatás sikerességét igazolja • a memóriacímet illetve eszközcímet • a mennyiségre vagy más

jellemzőre vonatkozó paramétert (például lemezre történő íráskor a blokkcímet). A terminálrendszer • A terminál, amely elengedhetetlen része egy többfelhasználós rendszernek, egy karakteres I/O egység. • A billentyűzeten és a képernyőn kívül adatátviteli vonal is tartozik hozzá, amely biztosítja a host-tal való kapcsolatot. Az adatátvitelt meghatározza például az, hogy a – terminálbevitel sor- vagy képernyőorientált, – milyen billentyűzetszabványt alkalmaz a rendszer, – milyen transzparens adatokkal bővül még az egyszerű adatblokk. A hálózati ki- és bemenetek kezelése • Az általunk ismert és használt UNIX alapú rendszerek és a WINDOWS NT is a hálózati I/O feladatokat csatlakozók (socket) segítségével oldja meg. A kernel I/O rendszere • Az alacsonyabb szinteket érintő I/O műveletek közül a kernelt érintők az elsők. Ezeknek kell ellátni a – perifériák ütemezését – az általános átmeneti tárolás

(pufferolás) és a gyorsítótárak kezelését – a hibakezelést • Az ütemezés és az összehangolt adatmozgatás fontos eszköze a pufferolás. Elengedhetetlen ennek alkalmazása, ha két eltérő sebességgel előrehaladó folyamat adatait kell kapcsolatba hozni. • Ha az I/O művelettel mozgatott adatblokkon változtatás esedékes, akkor az eredeti és módosított változatok biztonságos elkülönítése puffer nélkül elképzelhetetlen. Az egyik módszer a spool (puffer) bevezetése: gyűlnek szekvenciálisan az adategységek, hogy amikor a teljes kép összeáll, ugyancsak egymásutánban, átkerüljenek a kérdéses eszközre (például a nyomtatóra). Hibakezelés a kernellel • A kernel I/O rendszerének feladata a hibaüzenetek beazonosítása és esetleges továbbítása. (A hibák egy részét maga a futtatott kezelőprogram is észlelheti) • Ha a hiba tranzisztens jellegű, azaz kiküszöbölhető, akkor hibát jelző részfolyamat ismétlésével

megkísérelhető a javítás. Ha az OR nem képes a javítást elvégezni, akkor hibajelentést kell továbbítani • A hibakód általában csak 1 bit, a további elemzést és jelentést a hibás parancs és az I/O művelet paraméterei segítségével már tárolt programok készítik el. I/O műveletek a biztonságos tárolás érdekében • Mindenképpen említésre méltóak a naplófájlok, amelyek rögzítik a rendszerműveleteket és állapotokat akár ciklikusan, akár valamilyen más ritmusban. Ezek a naplók (logfile) általában rejtettek, és nem zavarják a felhasználót, de hozzáértők, hiba esetén, reprodukálni képesek ezek alapján a történteket, és visszaállítani az esetleges előző állapotokat. • A naplófájloknak különösen nagy jelentősége van az olyan osztott rendszereknél, ahol gyakori a tranzakciókezelés. 16. Védelem, védelmi mátrix A védelem A védelem azt jelenti, hogy olyan módszereket kell a fejlesztőknek kidolgozni, amelyek

biztosítják, hogy a multiprogramozott, osztott rendszerekben a számítógép erőforrásait a felhasználói- és rendszerfolyamatok konfliktusmentesen használják egyidejűleg. A biztonság fogalma pedig azt jelenti, hogy a rendszerben a tárolt adatok, és maga a rendszerműködés, is sérthetetlen. Védelmi rendszer Az OR védelmi rendszere tehát egyrészt gondoskodik arról, hogy o a folyamatok a számítógép osztott erőforrásait egymás zavarása nélkül használják o a rendszer általános megbízhatósága növekedjen 20. oldal, összesen: 27 a folyamatok bizonyos erőforrásokat az előre megszabott feltételek mellett használjanak A UNIX módszere például az, hogy minden elérhető erőforrás a rendszeren belül jogosultságokhoz kötött. Azt, hogy kinek, hogyan és milyen jogosultságok járhatnak, és azokat hogyan osztják ki, már a szabályrendszer írja elő. Az első számú szabály például az, hogy a root (rendszergazda) felhasználó

mindenféle jogosultsággal rendelkezik. o o Védelmi tartományok o minden számítógépes rendszerbeli erőforrást objektumnak tekintünk, amelynek van neve, rajta értelmezett művelethalmaza, és ezekhez tartozó jogosultsága o A rendszer akkor lesz védett, és a működése biztonságos, ha a folyamatok nem zavarják egymást, tehát egy adott időpillanatban egy folyamat csak az éppen abban a pillanatban igénybe vett objektum, éppen általa kért műveletéhez kap jogosultságot. o A need to know módszer lényege az, hogy minden folyamat egy adott védelmi tartományon belül működik, amelyen belül szabályozva van, mely erőforrásokhoz milyen művelettel férhet hozzá. Így például egy T tartományhoz hozzárendelhetünk olyan (objektum-név; műveleti jogosultság(-ok)) párosokat, amelyekkel meghatározzuk, hogy a T tartományon belül működő processz a fájl1 állományt írhatja és olvashatja, de nem végezhet rajta semmilyen más műveletet. o A

tartományok nem függetleníthetők, hiszen egy-egy objektumhoz több tartománynak ugyanaz a jogosultság járhat. o A folyamatok és tartományok közötti kapcsolat lehet statikus vagy dinamikus. A statikus kapcsolat azt jelenti, hogy egy adott folyamathoz kapcsolódó erőforrás-halmaz előre meghatározott. Ha ez a leosztás változtatható, akkor dinamikus módszerről beszélünk, amely újabb feladatokat hárít az operációs rendszerre: a tartományváltások megoldását. Dinamikus módszer o Példa:. A p folyamat két, jól elkülöníthető fázisban játszódik le, az elsőben például csak olvassa az o objektumot, a másodikban csak írja Védelmi tartomány-váltás és elérési mátrix o A védelmi tartományok leosztását szimbolikusan általában egy elérési mátrixban ábrázolják, amelyből leolvashatók a tartománybeli objektum-jogosultság párosok o Első példaként az ábrán egy statikus védelmi tartományrendszert ábrázoló elérési mátrix

látható. ta tb td o o o Objektumok adatfájl szovegfájl Archivprog nyomtató olvasás olvasás nyomtatás tc írás Végrehajtás olvasás, A dinamikus védelmi tartományrendszert ábrázoló elérési mátrix kibővül azokkal az oszlopokkal, amelyek megmutatják, hogy mely tartományból melyik másik tartományba történhet váltás. A mátrixból leolvasható, hogy például a ta tartományból a tb tartományba léptethet a rendszer, a td folyamat viszont nem léptethető át más tartományba (nyilvánvalóan, amíg a végrehajtás be nem fejeződik) az elérési jogosultságok másolhatóak, azaz például egy folyamat, az általa használt tartományon belüli, a folyamatnak ott rendelkezésére álló jogosultságokat átadhatja más tartományoknak (így újabb objektumtartomány-jogosultság hármas születik). Ezt a módszert ezért elérési jogosultság másolásnak nevezzük (copy módszernek). az előző módszert úgy lehet általánosítani, hogy egyes,

esetlegesen kitüntetett védelmi tartományoknak megengedjük, hogy tulajdonosi jogokkal rendelkezzenek egy adott objektum felett, tehát a velük kapcsolt objektumok jogosultságait átadhatják más tartománynak (owner módszer) Az elérési Mátrix tárolása A túlméretezettség kezelése a legnagyobb gond. Lássunk néhány optimális tárolásra törekvő módszert: o Mint láttuk a példaként bemutatott táblázatban, a cellák jó részében nincs bejegyzés. Ezért az ilyen mátrixokat mindig megkísérlik optimális módon tárolni. Hasonló, úgynevezett bittérképes ritka mátrixokat használnak egyes adatbáziskezelő renszerek az adatkapcsolatok rögzítésére. o Globális tábla: egy egyszerű, kevésbé hatékony elérést biztosító módszer. A rendszer egy hosszú listába szerkeszti az objektum-tartomány-jogosultság hármasokat, és ez a lista gyakran kerül ki a háttértárolókra a mérete miatt. 21. oldal, összesen: 27 o o o Objektum-elérési

listák: az általunk is használt mátrix-formátumot oszlopai mentén feldaraboljuk, így a listában minden objektum a teljes tartománykészleten végigfut, majd a következő objektum lista-része következik, és így tovább. A hátrány az, hogy így az összes objektumot számba kell venni Tartományok szerinti lista: ha a mátrixot a sorai mentén szabdaljuk szét. Ekkor az első tartományra bejegyződik az összes objektum-jogosultság páros, majd a következő tartományra az összes objektum-jogosultság páros, és így tovább. Zár-kulcs (lock-key) módszer: arról kapta a nevét, hogy a tartományokhoz is és az objektumokhoz is bitminták illeszkednek, és ha ezek a bitminták illeszthetőek egymáshoz (mint a kulcs a zárba), akkor az adott helyzetben a védelmi tartományt birtokló folyamat használhatja az illesztő kulcs által meghatározott jogosultságot az érintett objektumon. Az elérés így egyszerűbb és hatékonyabb Rugalmas lesz a rendszer, hiszen

nem kell nagy adatmennyiséget tárolni és mozgatni. UNIX példa o A legegyszerűbb példával, a védelmi tartományok módszerével kapcsolatban, az operációs rendszer duális módban történő futása szolgál. o Minden felhasználóhoz egy tartomány tartozik, és azt a felhasználó azonosítója határozza meg. Tartományváltás úgy történik, hogy időlegesen megváltozik a felhasználói azonosító. Ez az azonosítóváltás a fájlrendszerhez kapcsolódik. (setuid – set user ID – bitnek) 17. Biztonsági kérdések, megoldások Biztonság o Biztonságos rendszerről akkor beszélünk, ha biztosítható, hogy a rendszer, valamint a rendszerben tárolt információ külső behatolás esetén nem sérülhet meg. o A külső biztonság érdekében többek között fizikailag meg kell védenünk a rendszert attól, hogy illetéktelenek, vagy hozzá nem értők hozzáférjenek. Például nem engedhető meg, hogy a háttértárak elvihetők legyenek, vagy hogy bárki

leülhessen „kísérletezni″, ha ráadásul még a beléptetést is elleste. Root jelszavakat nem szabad másokkal megosztani, legfeljebb egy-két operátorral (ezt viszont meg kell tenni, mert egy ember nem lehet mindig jelen egy a rendszer közelében). Fontos a biztonságos zár, biztonságos áramellátó, állandó biztonságosan őrzött másolat az adatokról, és így tovább. o Alkalmazzunk olyan kész programrészeket, amelyek megakadályozzák, hogy a rendszerben tárolta adatokat illetéktelenül olvassák, módosítsák vagy töröljék. o Az OR által alkalmazott módszerek sajnos sohasem képesek teljes biztonságot nyújtani, hiszen a rendszer feltörése elvileg mindig csak idő és türelem kérdése a bejutó számára. Ugyanakkor el lehet érni azt, hogy a behatolónak nagyobbak legyenek a költségei és ráfordításai, mint az a nyereség, amihez az esetlegesen megszerzett információkkal hozzájutna. Ez egyébként a mai titkosítási módszerek fő

célkitűzése is egyben, mert tökéletesen megszerkesztett, feltörhetetlen biztonsági kód nincs, csak olyan amelynek feltörése aránytalanul sok időbe vagy pénzbe kerülne. o A biztonsági intézkedések mértékének ugyanakkor arányban kell lennie a tárolt információ értékével A felhasználó azonosítása o A felhasználók azonosításának leggyakoribb módja az, ha valamilyen, csak a felhasználó által ismert információ segítségével azonosítjuk őt a beléptetéskor. Ez az információ lehet a felhasználó neve (szimbolikus), valamilyen jelszó, algoritmus, vagy ezek kombinált használata. A jelszavakkal történő azonosításkor általában a felhasználónak létezik o egy felhasználói neve (user name, userid), ez lehet nyilvános is, és o egy, csak általa ismert, általa megválasztott jelszava (password). o Ha a jelszó nem felel meg a bejelentkezni kívánó felhasználói nevéhez, akkor a rendszer általában még néhányszor felkínálja a

lehetőséget, hogy javítsanak rajta. Gyakori megoldás az, hogy három-négyszeri sikertelen próbálkozás után a rendszer egyszerűen letiltja az illető felhasználói nevet, és a felhasználót arra kéri, jelentkezzen a rendszergazdánál, ha be akar lépni a rendszerbe. o A mai rendszerekben általában még a root sem tudja elolvasni a jelszót a megfelelő állományból, a többszörösen kódolt tárolási mód miatt, ezért az egyetlen megoldás az új jelszó megadása (root jogosultság). o A rendszer tekintetében fontos, hogy a jelszavakat tartalmazó állomány jól védett legyen a rendszeren belül. A behatoló először a módszerre próbál rájönni, hogy a visszafejtést megkezdje. o A mai rendszerek jó belső védelme mellett gyenge pont sajnos a hálózat. Itt a legegyszerűbb „elcsípni” a jelszót Ezért igazán fontos rendszereknél jól kell védeni a csatornákat, vagy modern titkosítási rendszereket kell használni. Ilyen például az, amikor a

jelszavak nem kerülnek a hálóra, csak a felhasználó és a rendszer által generált kulcsok haladnák át a csatornán, és a rendszeren belül, az ott tárolt jelszóval egyetemben engedélyezik a beléptetést. o Példaképpen említsük meg a UNIX alapú rendszereket. Itt a jelszavakat tároló fájl publikus, de a többszintű kódolás miatt a leolvasható kódok távol állnak a valódiaktól. 22. oldal, összesen: 27 o A felhasználó-azonosításnak vannak modernebb változatai is, olyan, mint például az ujjlenyomat- , kézerezetvagy retinavizsgálat, aláírás-ellenőrzés. A rendszer biztonságát biztosító további módszerekről o A monitoring módszer, azt jelenti, hogy a rendszer bizonyos megfigyelhető, hardver és szoftver módszerekkel ellenőrizhető pontjait, bizonyos időközönként lekérdezik. Ezzel fény derülhet az esetleges illetéktelen próbálkozásokra. Például: o a felhasználót tájékoztatja az OR mikor lépett be legutóbb a

rendszerbe, o a sikertelen próbálkozások után lassítja a válaszidőt az újabb próbálkozások alkalmával, vagy ahogy már említettük, akár le is tilthatja a beléptetést o Ha rendszernek jó a naplózási mechanizmusa, akkor az illetéktelen próbálkozások nem merülnek feledésbe, és a további próbálkozások a későbbiekben kivédhetőek. Az elektronikus aláírás ma már elengedhetetlen 18. Osztott rendszerek (jellemzői, folyamatkezelése, időkezelése) Jellemzők o Erőforrás-megosztás (eszközök, tárolók, adatbázisok) o Nyitottság (rugalmasság, bővíthetőség) o Konkurencia (az egyidejű hozzáférések szabályozása, prioritások, párhuzamosság) o Skálázhatóság (méretnöveléskor, bővítéskor nincs szükség az architektúra módosítására) o Hibatűrés (hardver-redundancia, a kritikus szerverek tükrözhetők) o Átlátszóság (a fizikai tagoltság elrejtése) Felmerülő problémák, hátrányok: a szoftver (az elosztottság és a

párhuzamosság miatt új elvre lenne szükség), a hálózat (átviteli sebesség, túlterhelés) és a biztonság (könnyebb az illetéktelen hozzáférés). Felépítés, működés Egy nyílt, elosztott rendszerben az OR mikrokernelek és szolgáltatások halmazából épül fel. A meghatározott hálózati topológiáknak megfelelően felépülő rendszer közötti kommunikáció valamilyen szabványosított protokoll (pl. TCP/IP) zajlik. Kliens-szerver modell és RPC Az elosztott rendszerek kialakítását leggyakrabban a kliens-szerver modellel, és az RPC protokollal kötik össze. A rendszerben bizonyos kitüntetett feladatokat egy-egy adott szerver végez el: például egy állományhoz való hozzáférést egy fájlszerver, egy nyomtatóhoz történő hozzáférést pedig nyomtató-szerver biztosítja számunkra. Ebben a modellben a kliensek nem kommunikálnak egymással, hanem közvetlenül a kiszolgálókat érik el. A szervereken daemon processzek felelnek azért, hogy az

egyes portokon érkező kérésekre megfelelő választ lehessen adni. Egy elosztott számítási modellben –a hagyományos hálózatitól eltérően– a szerverek eléréshez nem kell ismerni annak pontos címét, hanem csak az általa nyújtott, igénybeveendő szolgáltatásokat. A kapcsolat kiépítésért már egy külön kommunikációs közbülső réteg (middleware) gondoskodik. A kötés (binding) az a folyamat, ami során a kliens megtalálja a kívánt szolgáltatást nyújtó szervert, s kettejük között kialakul a kommunikációs kapcsolat. (http, ftp) A proxy egy olyan szervert takar, amely valamilyen más szerveren tárolt információt helyben tárol a kliensek számára. A proxy általában nem közvetlenül a szervertől kérdezi le az adatokat, hanem egy másik, közelebbi proxytól. Ily módon a proxyk hierarchikus rendszerében egy kliens-kérés addig továbbítódik az adatot eredetileg tároló szerver felé, míg egy proxy átmeneti tárában meg nem

találja a szükséges adatot. A kommunikáció legelterjedtebb formája az RPC (Remote Procedure Call). Ez a rendszer egy protokoll-leírást és egy programozói interfészt tartalmaz. Alapvetően egy kliens számára lehetővé teszi egy kiválasztott szervergépen található eljárás lefuttatását. A bemenő paraméterek, illetve visszatérési értékek kezeléséről is az RPC-alrendszer gondoskodik Általában UDP felett implementálják; a kapcsolatban álló felek azonosítását is tartalmazza. A szálak alkalmazásának előnyei A szálak alkalmazásával párhuzamosíthatjuk a kliensek és a szerverek működését az RPC kommunikáció alatt. A szerverek minden beérkező kérésre külön szálat indítanak el, adott maximumig. A kliens a távoli eljárást szintén egy szálban indítja, így amíg annak eredménye megérkezik, mást is csinálhat. Egy távoli eljárás meghívása során a kliens és szerver programokban lévő szálakat logikailag egy szállá

foghatjuk össze: ez az RPC-szál. Ez a kliens oldalon keletkezik, majd kiterjesztődik a hálózaton keresztül a szerverre, ahol szerver szállá válik, amin belül végrehajtódik a távoli eljárás. Ezután visszatér a klienshez, és ismét kliens szálként szolgáltatja a függvény visszatérési értékeit. A szálak okozta konkurens hozzáférés azonban az alkalmazás készítőjére hárítja a kölcsönös kizárás elvének betartását. E nélkül a többszálú rendszer adatai könnyen inkonzisztens állapotba kerülhetnek. 23. oldal, összesen: 27 Időkezelés Ismerni kell a valós időt (naplózás, számlázás), illetve a rendszerben keletkezett események sorrendiségét (event ordering). Koordinált Univerzális idő (KUI) A legpontosabb időmérő eszköz ma az atomóra (10-13 sec/sec). Azonban az emberiség az időt a csillagászati időhöz viszonyítja, így bevezették a KUI (Coordinated Universal Time) fogalmát, aminél meghatározott időközönként

szökőmásodperceket kell beiktatni, vagy törölni. (a műholdakról sugárzott idő terjedési idővel növelve) A valós, fizikai idő kezelése Elosztott rendszerben minden egyes csomópont saját fizikai órát tartalmaz. A belső szinkronizációnak köszönhetően az egyes órák elfogadható mértékben térnek el egymástól. A külsőnek szinkronizációnak köszönhetően pedig a KUI-hoz képest sem csúsznak. Elosztott rendszerekben alkalmazott óra rendszerek o Pontos központi órával rendelkező rendszerek • Egy központi óra, a többi csak akkor kell, ha ez meghibásodik • A módszer pontos, de drága, mert a CPU-ba integrált hardvert igényel • A kommunikációs költség alacsony (pl. GPS – 4 szatelit, kb ns-os pontosság) o Központilag felügyelt órákkal rendelkező rendszerek (master-slave) • A pontosnak elfogadott master óra lekérdezi a slave-eket • Csúszásokat mér, korrekciókat küld • Ha a master elromlik, valamilyen algoritmus szerint

újat kell választani • Az átviteli időt becsülik o Elosztott órás rendszerek • Minden hely azonos algoritmust futtat • Minden hely a többi üzenet alapján becsüli saját pontosságát, és frissíti magát • A csomópontok észreveszik, ha valamelyikük meghibásodott, és ezután nem veszik figyelembe • Nagy kommunikációs költség 19. Titkosítás, vírusvédelem Védelem a külső behatolások ellen A lehallgatás egyik formája, amikor a csatornára rácsatlakozik a lehallgató, és a csatornán áthaladó jeleket leszedi. Egy másik lehallgatási forma, amikor a lehallgatás során nem csak az adatokat hallgatják le, hanem a lehallgatás során az adatokat módosítják is. Ezt azért tehetik meg, mert az átviteli csatorna nem biztonságos. Információ forrás (ATM) Információ forrás (ATM) Lehallgató Hálózat Információ nyelő (BANK) Információ nyelő (BANK) Beavatkozás A Titkosítás lépései Információ (Érthető szöveg) Hálózat

Titkosítási módszer Titkosított szöveg Megfejtési módszer Nem biztonságos csatorna Titkosítási kulcs Információ (Érthető szöveg) Megfejtési kulcs Julius Caesar titkosítási módszere A leveleket úgy írta, hogy felírta az abc betűit egymás után, majd a betűket körbe forgatta 3 hellyel. Az így kapott táblázat alapján minden karakternek volt egy megfelelője. A kódolás Magyarországon könnyen megfejthető lenne, mivel a az egyik leggyakoribb magánhangzónk az e betű, és ha a kódolt szövegben például sok x-et látunk, akkor nagy valószínűséggel behelyettesíthető az e betűre, innentől kezdve a visszafejtés már könnyű feladat. Ezt a módszert egyébként helyettesítéses rejtjelezésnek nevezzük. Felismeréses titkosító algoritmusok Az eljárás során valamilyen algoritmus szerint felcserélik a karaktereket. Ennek egyik formája, amikor egy adott oszlopból álló rácsba írják be az üzenetet, majd a kódolást úgy

valósítják meg, hogy az oszlopokat felcserélik. A mai hardverek teljesítménye már elég nagy ahhoz, hogy ezeket a kódolásokat pár perc alatt megfejtse. 24. oldal, összesen: 27 Kódolás digitális feldolgozás esetén Az ötlet, hogy az adatokat bitsorozattá alakítjuk. Az így kialakult bitsort a XOR (kizáró-vagy) művelettel és ez K kulccsal kódoljuk le. A kulcs bitsorozat nélkül nem dekódolható az eredeti adat Kódolás Dekódolás Bitsor XOR kulcs 1 0 1 1 0 Titkosított bitsor 0 1 1 0 0 1 1 0 1 0 Titkosított bitsor XOR kulcs 0 1 1 0 0 Eredeti bitsor 1 0 1 1 0 1 1 0 1 0 A bitsor kódolásánál a kulcs ismétlődése a megfejtést, feltörés lehetőségét növeli. A cél a folyamatos titkosítás, és a nagy mennyiségű adat gyors kódolása. Az RSA titkosítás A digitális aláíráshoz az RSA kétkulcsú titkosítási eljárást használják. Ennek a módszernek a segítségével végzik mind a bekódolást és kikódolást. Az RSA

eljárásban az üzenetet (itt például a digitális pénz) hatványra emelik a megfelelő kulccsal. A hatványra emelés után az eredmény modulusát vesszük Ez a modulus megfelelően nagy (általában legalább 150 bit hosszúságú) Amikor a rendszer elindul, a bank generál magának két nagy prímszámot, p-t és q-t. A számok szorzata lesz a használandó modulus pq. Az RSA rendszer lényege azon a számelméleti tételen alapszik, hogy x^(p-1)(q-1) = 1 (mod pq) Az így keletkező x ezután nem osztható sem p-vel, sem q-val. A következő lépésben a kulcskészítő választ magának két kulcsot, e-t és d-t. e lesz a publikus kulcs, és d a privát kulcs ed = 1 (mod (p-1)(q-1)) Ezek után egy szöveg lekódolva az egyik kulccsal, csak a másik kulccsal nyitható ki (x^d)^e = x (mod pq) A kulcskészítő ezután reklámozhatja e-t minden felhasználó felé, együtt a modulussal, hiszen ebből senki sem tudja kideríteni se p-t, se q-t, se d-t. A DES (Data Encyption

Standard) titkosítás A számítógépek megjelenésével az a hagyományos módszerek (helyettesítés és felcserélés) tovább élnek, de a hangsúly máshová került. Mivel régen emberek voltak a titkosítók, ezért a készítik egyszerű, emberek által jól megtanulható algoritmusokat és hosszú kulcsokat használtak. Bitcsoport felcserélése és helyettesítése A számítógépek megjelenésével felmerült az igény olyan titkosítási algoritmusok iránt, amelyek olyan komplikáltak, hogy még egy számítógép se tudja megfejteni. Manapság a titkosítási algoritmus a nagyon bonyolult (hiszen a számítógép végzi), és a megfejtő még sok titkosított szöveg birtokában sem tudja megfejteni. A DES módszer lényegében egy 64 bites nyílt szöveget 64 bites titkosított szöveggé alakít egy 56 bites titkosítási kulcs segítségével. Bináris elemek esetén a felcserélések és helyettesítések egyszerű áramkörök segítségével valósítható meg.

A felcseréléseket a P doboz, a helyettesítéseket az S doboz végzi. A P doboz nem más, mint egy 8 bemenetű és 8 kimenetű áramkör, egy bemenő paraméter által meghatározott össze-vissza kötött ki- és bemenetekkel, azaz a bemeneti 8 bit felcserélésével állítja elő a 8 bites kimenetet. A helyettesítést az S doboz végzi, ez a doboz a bemenetére adott 3 bit nyílt szöveget alakítja át 3 bit titkos szöveggé. A titkosítás első lépésben egy kulcstól független felcserélés történik, az utolsóban, pedig ennek az inverze. Az utolsó lépésben egyszerűen az első 32 bitet felcserélik az utolsó 32 bittel. A közbülső 16 fokozat ugyanúgy működik, de a kulcs más-más része határozza meg az alkalmazott P és S dobozok konkrét felépítését. Ez természetesen logikai függvényekkel is leírható, és ez alapján titkosító program is készíthető. 25. oldal, összesen: 27 Vírusok A DOS-korszak vírusai • A command.com megfertőzése,

majd í vírus csatolása minden lefuttatott alkalmazáshoz Terjedésük eleinte a floppy-lemezeken, BBS-eken • A boot-vírusok aktiválódásuk után átveszik a hatalmat, és azonnal támadásba lendülnek. • Később aztán finomodtak a módszerek: az azonnali, erőteljes károkozás helyett inkább a lopakodó taktika és a feltűnésmentes terjedés jött divatba. (Péntek 13, Michelangelo) • A legfejlettebb fájl- és bootvírusok arra is képesek, hogy megváltoztassák a saját kódjukat (polimorfak) A makrovírusok Rájöttek, hogy az MS Office programcsomag (pl. WinWord, Excel) automatikusan betöltődő és elinduló makrói kiváló lehetőséget adnak platformfüggetlen vírusok írására (ezek futtatásához csupán a WinWord vagy az Excel program szükséges, az operációs rendszer lehet bármely Windows változat, de akár MacOS is). A makrovírusok kezdetben csak a dokumentumokban tettek kárt (pl. töröltek sorokat, beszúrtak szövegeket, nem engedték

elmenteni a dokumentumot stb.), de később a teljes fájlrendszert veszélyeztették E-mail-ben terjedő vírusok és férgek Az internet terjedésével párhuzamosan növekedett a böngésző- és levelezőprogramok biztonsági réseit (no meg a felhasználók figyelmetlenségét) kihasználó vírusok száma. Megnőtt a felesleges hálózati adatforgalom A férgek (worm) általában önmagukban terjednek, nem használnak hordozót, és a gépen belüli szaporodás helyett inkább az Internetre telepítik „utódaikat”. A trójai falónak becézett programok viszont jól álcázva belopakodnak gépünkre, majd egy portot nyitnak. A script vírusok a böngészők (és a felhasználók) túlzott engedékenységét (meg persze a programfejlesztők tévedéseit, hibáit) használják ki. Milyen károkozásra képes egy vírus? • A munka lassítása, apróbb bosszúságok, újrabootolás, Adatok továbbítása az Interneten böngészési szokásainkról, kedvenc oldalainkról,

Fájlok (adatok, programok) tartalmának megváltozása, törlése , Bizalmas dokumentumok szétszórása az Interneten (lásd Sircam), Hardveres meghibásodás okozása További kérdések: • Védelem, Felismerés, Irtás, stb. 20. Windows-jellemzők A Windows NT 4.0 struktúrája Az 1.10 ábrán jól látható az NT moduláris felépítése Jól észrevehető a mikrokernel architektúra A HAL modul tulajdonképpen csatoló a hardver és a mikrokernel között, célja a hardverkülönbözőségeket (processzorok architektúrája, processzorok száma, elrendezése) elrejteni a magasabb rétegek elől. Bár az OR része, szokás szerint a hardvergyártók készítik és szállítják a géppel együtt. A HAL-nak köszönhető, hogy az NT sok platformon (pl Intel, DEC Alpha stb.) használható A mikrokernel látja el az alapvető rendszerfunkciókat: a megszakításkezelést, a szálak ütemezését, szinkronizálásokat. Az Executive szolgáltatások moduljait használhatják az

alkalmazások (és az ún. környezeti rendszerek Az Objektum menedzser egységes szabályrendszer segítségével vezérli az objektumok létrehozását, elnevezését, biztonsági tényezőit. A Folyamat menedzser hozza létre és törli a taszkokat, a szálakat (fonalakat), szorosan együttműködve a memória menedzserrel és a biztonsági rendszerrel. A Helyi eljáráshívás alrendszer (hasonlít az RPC-hez) kezeli az alkalmazások hívásait, melyekkel a környezeti alrendszeren (vagy kiszolgáló alrendszer, nem látszik az ábrán!) át szolgáltatásokat igényel. Az I/O alrendszer biztosítja a fájlrendszereket (FAT, NTFS, CDFS), a cache buffer (átmenti gyorsító tároló a központi memória és a háttértárak között) funkciókat, az eszköz drivereket. A Virtuális memóriamenedzser értelemszerűen a memória-gazdálkodást segíti. A megjelenítő rendszerből a konzol rendszer nem a kernel része (az felhasználói módban fut). A Kernel komponens viszont a

Win32K ablakmenedzser: kezeli az ablakokat, a képernyőt, eljuttatja az inputokat az alkalmazásokhoz. A GDI (Graphics Device Interface) grafikus eszköz csatoló pedig képernyő-rajzoló primitívek gyűjteménye. Végül, a megjelenítő alrendszerhez tartoznak a grafikus eszközmeghajtók (driver) is 1.10 ábra A Windows NT 40 kernel szerkezete 26. oldal, összesen: 27 A Windows NT memóriamenedzselése Létezik egy kisméretű asszociatív tár, egy tábla (TLB), a következő bejegyzésekkel: virtuális lapcím, valid bit, módosítás bit, védelmi maszk (rw bitek), lapkeret cím. Láthatólag ezek ugyanazok az információk, amelyek egy szokásos laptáblában is rögzítettek szoktak lenni. Valóban azok, de most egy asszociatív tárbeli bejegyzésben, mely tárra jellemző a tartalom szerinti - a bejegyzéseiben párhuzamos - keresés. Az NT taszkok (többfonalas processzek) 32 bit szélességen 4GB lineáris címtartományt látnak. Ennek felső 2GB-ja

rendszer-címtartomány (kernel módban elérhető), alsó 2 GB-ja a felhasználói módú címtartomány. A címtarományt 4 KB-os lapokra osztják: ez 12 bit szélességű offset értékkel lefedhető. A 4 GB címtartományt persze nem használja teljesen: vannak "lefoglalt" címtartomány szakaszok, melyeket a Virtual Address Descriptorok tartanak nyilván. Memória allokáció során éppen új címtartomány szakaszt vesz fel egy-egy taszk: új deszkriptor bejegyzéssel (kezdő-vég-címmel), és csak amikor ténylegesen használnánk is ezt az új címtartományt (comitting), akkor inicializálják a laptábla bejegyzéseket (kétszintű memória-allokáció). Különleges memória-allokáció a "leképzett fájl" (Mapped File) objektum. Az objektumot beillesztik a létrehozó taszk virtuális címtartományába (ez a nézet: view), ezután a taszk úgy látja fájlt, mintha teljes egészében a memóriában lenne, betöltéséről és a módosítások lemezre

írásáról a memóriamenedzser gondoskodik. Egy taszk több nézetet is létesíthet ugyanahhoz az objektumhoz, több taszk is készíthet saját nézetet megosztott objektumhoz. A "klasszikus" közös memória pedig felfogható a leképzett fájl speciális esetének: az objektum mögött a lapozófájl van. Most jegyezzük meg a következőket is: a dinamikus címleképzés során először éppen a deszkriptorok segítségével az ellenőrződik, hogy cím lefoglalt memóriaterületre esik-e, vagy sem. Ha nem, azonnal keletkezik az érvénytelen címre hivatkozás kivételes esemény, nem kell végignézni a TLB-t a címleképzéshez. Egyéb dolgok: objektumorientáltság, dll-ek szerepe, rendszerfolyamatok, feladatkezelő, NTFS. 21. UNIX-jellemzők 27. oldal, összesen: 27 A Unix kernel funkcionális felépitése A Unix kernel implementációjához legalább két futási mód kell: a felhasználói mód és a kernel mód. Az ábrán a futási szinteket (User level,

Kernel level) tüntettünk fel, amik értelemszerűen megfelelnek a futási módoknak. Természetesen nincs akadálya annak, hogy több futási móddal rendelkező CPU-ra Unixot valósítsunk meg; vannak is ilyenek, pl. a VAX architektúrára implementált BSD Unixok. Az ábrán két, futási módú hardverre implementálható Unix kernel legalapvetőbb struktúrája látható. Megfigyelhető az itt is önálló I/O alrendszer, látható, hogy a memória menedzsment, a scheduler és a folyamatközi kommunikáció szolgáltatás a folyamatvezérlő alrendszer (Process Control Subsystem) részeként feltüntetett. Az alrendszerek funkcióit itt nem részletezzük, ezek hasonlóak a VMS funkciókkal. Az ábrán néhol látszik a réteges felépítés Az viszont nem látszik az ábrán, hogy vannak kernel szintű adatbázisok, adattáblák is. A VMS-hez hasonlóan, a kernel itt is szolgáltatásokat biztosít a felhasználói folyamatok számára. Gyakorló feladatként elemezzünk egy

read (fp, buffer, size) rendszerhívási forgatókönyvet. Bizonyos szolgáltatások itt is eljárás jellegű rutinok (call jelleggel hívhatók), itt is vannak eseménykezelő rutinok (esemény bekövetkezésre, akár aszinkron jeleggel hívódnak), és itt is vannak önálló folyamatként megvalósított szolgáltatások (pl. a swapper és a pagedaemon) Bármelyen is az implementáció, a felhasználói folyamatból a szolgáltatás ún. rendszerhívással (system call) igényelhető A kernelbe való belépés, kilépés Tulajdonképpen háromféle módon juthat a vezérlés a kernelbe: 1. A felhasználó processzekből rendszerhívással (system call) Valójában ez egy futásidejű könyvtári függvény hívása, aminek a paraméterei a felhasználói címtartományban vannak. A hívó folyamatra nézve szinkron Implicit trap (futási módváltás) van benne. 2. Megszakítás (Interrupt) generálásával a hardverből Aszinkron, és ritkán kapcsolatos az éppen futó

processzel, a processz "nincs is tudatában", hogy mi okozza a problémát. 3. Kivételes esemény (Exeption Condition), hiba (error) előállása esetén a hardverből Szintén váratlan, de általában az éppen futó processzel kapcsolatos. Szinkron olyan értelemben, hogy a processz "tudatában van" a felmerült problémának Bizonyos irodalom ezt a belépési módot egyszerűen trap-nek nevezi. A kernelbe való belépés eseményei ·A hardver átkapcsol kernel módba. A memóriaelérés kernel privilégiummal történik, a verem mutató átáll a kernel szintű veremre, minden privilegizált instrukció végrehajtása engedélyezett. ·A PC és a PSW (programszámláló és program státus szó regiszterek) a processz kernel szintű veremére töltődnek (push). Ez hardveres letöltés. ·A rendszerhívás/trap kódja (system call száma/signal kódja) is rátöltődik a veremre. ·Egy assembly rutin lementi az általános célú regisztereket is. Ezek után

már magas szintű nyelven írt rutinok is hívhatók Így is történik, C-ben írt rutin hívódik, a belépés fajtájától függően. Egyebek: a többi tétel nagyrészt a UNIX oldaláról volt megközelítve. Ütemezés, rendszerhívások, csővezetékek, root, dev, terminálkezelés, időosztás. Felhasznált irodalom • SZIF – Számítógép Hálózatok I. jegyzet [http://soktetelfwhu] • NetAcademia DES, RSA titkosítás [http://soktetel.fwhu] • Operációs rendszerek kidolgozott tételek (2003, 160 oldal) [http://soktetel.fwhu] • DES, RSA cikkek [www.mimihu/informatika] • Takács Márta iszonyatosan színvonaltalan, egyúttal alig használható előadás-fóliái [http://www.bankihu/jegyzetek] UFO http://soktetel.fwhu Budapest 2005. január