Projektlabor – Párhuzamos és elosztott rendszerek operációs rendszerei

(1)

Írta: Rövid András

PROJEKTLABOR – PÁRHUZAMOS ÉS ELOSZTOTT RENDSZEREK

OPERÁCIÓS RENDSZEREI

PÁRHUZAMOS SZÁMÍTÁSTECHNIKA MODUL

Lektorálta: oktatói munkaközösség

(2)

COPYRIGHT:

2011-2016, Rövid András, Óbudai Egyetem, Neumann János Informatikai Kar LEKTORÁLTA: oktatói munkaközösség

Creative Commons NonCommercial-NoDerivs 3.0 (CC BY-NC-ND 3.0)

A szerző nevének feltüntetése mellett nem kereskedelmi céllal szabadon másolható, terjeszthető, megjelentethető és előadható, de nem módosítható.

TÁMOGATÁS:

Készült a TÁMOP-4.1.2-08/2/A/KMR-2009-0053 számú, “Proaktív informatikai modulfejlesztés (PRIM1): IT Szolgáltatásmenedzsment modul és Többszálas processzorok és programozásuk modul” című pályázat keretében

KÉSZÜLT: a Typotex Kiadó gondozásában FELELŐS VEZETŐ: Votisky Zsuzsa

ISBN 978-963-279-562-1

2

(3)

KULCSSZAVAK:

Operációs rendszerek, párhuzamos környezet, mechanizmusok, ütemezés, szinkronizálás, kontextus, kernelmód, felhasználói mód, rendszerhívás, késleltetett eljáráshívás, aszinkron eljáráshívás, megszakítás, I/O menedzsment, memóriamenedzsment

ÖSSZEFOGLALÓ:

A tananyag az operációs rendszerek belső működésének megismerését segíti, különös tekintettel a többmagos, illetve elosztott környezetben működő operációs rendszerekre. A tananyag egy rövid hardveráttekintéssel indul, amely rávilágít a modern architektúrák sajátosságaira. Ezt követően a párhuzamos és elosztott környezetet támogató operációs rendszerek felépítésének, valamint azok mechanizmusainak hatékony megvalósítása kerül részletezésre többprocesszoros szorosan csatolt (SMP) architektúrákra fókuszálva. Ide sorolható pl. a többprocesszoros környezetben való megszakításkezelés, szinkronizálás és kivételkezelés, prioritáskezelés. A tananyag további fontos részét képezik a kernel és felhasználói móddal, valamint a rendszerhívásokkal kapcsolatos tudnivalók, az erőforrások reprezentációja, a szálak és processzorok ütemezésének algoritmusai és nem utolsó sorban a memória- és I/O menedzsment. Az említett témák megértését sok esetben illusztratív példák is segítik. A tananyag az operációs rendszerekkel kapcsolatos alapvető ismeretekre épít, célja az általános (az operációs rendszerek mindegyikét felölelő) ismeretek mélyítése a szervermegoldások témakörére fókuszálva.

(4)

www.tankonyvtar.hu

Párhuzamos és elosztott rendszerek operációs rendszerei

Rövid András

4

(5)

Hallgatói tájékoztató

A jelen bemutatóban található adatok, tudnivalók és információk a számonkérendő anyag vázlatát képezik. Ismeretük szükséges, de nem elégséges feltétele a sikeres zárthelyinek, illetve vizsgának.

Sikeres zárthelyihez, illetve vizsgához a jelen bemutató tartalmán felül a kötelező irodalomként megjelölt anyag, a gyakorlatokon szóban, illetve a táblán átadott tudnivalók ismerete, valamint a gyakorlatokon megoldott példák és az otthoni feldolgozás céljából kiadott feladatok önálló megoldásának képessége is szükséges.

(6)

Tartalom

• Hardveráttekintés

• Az operációs rendszer szerepe

• OS struktúrák

• OS típusok multiprocesszoros esetben

• Windows 2008 Server architektúrája

• A rendszer mechanizmusai

• Objektumok szerepe és kezelése

• Hozzáférések szinkronizálása

• Folyamatok és szálak

• A Windows 2008 Server ütemezési stratégiája

• Memóriamenedzsment

• I/O kezelés

www.tankonyvtar.hu

(7)

Hardveráttekintés (CPU)

A processzorciklus

– A következő instrukció betöltése a memóriából (FETCH).

– Dekódolás (pl. a 10110010… bináris érték milyen instrukciót takar?) – (DECODE).

– Futtatás (EXECUTE).

– „Write-back”.

(8)

Hardveráttekintés (CPU)

• Minden CPU-nak saját instrukciókészlete van

– Pl. Pentium CPU-ra írt program nem futtatható SPARC CPU-n.

• Regiszterkészlet

– Általános és speciális felhasználású regiszterek.

www.tankonyvtar.hu

(9)

Hardveráttekintés (CPU)

Cím Érték

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA MOV R1, #10

MOV R2, #20 MOV R3, #2 MUL R4, R2, R3 ADD R5, R1, R4 BREAK

include<stdio.h>

int main( ) {

int a=10;

int b=20;

int c;

c=a+b*2;

return 0;

}

(10)

Hardveráttekintés (CPU)

www.tankonyvtar.hu

110A

DECODE 0001 opcode MOV 0001 register

0110 data1 0100 data2 PC = 1000

MEMORY CPU Cím Érték

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

10

(11)

Hardveráttekintés (CPU)

Regiszter Érték

R0

R1 00001010 R2

R3 R4 R5 R6 R7

1 1 0 A

10 decimális 0001

R1 0001

MOV Cím Érték

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA

Dekódolás

Végrehajtás

(12)

Hardveráttekintés (CPU)

www.tankonyvtar.hu

R0

R1 00001010 R2 00010100 R3

R4 R5 R6 R7

1 2 1 4

20 decimális 0010

R2 0001

MOV

Dekódolás

Végrehajtás Cím Érték

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA

PC = 1002

12

(13)

Hardveráttekintés (CPU)

R0

R1 00001010 R2 00010100 R3 00000010 R4

R5 R6 R7

1 3 0 2

2 decimális 0011

R3 0001

MOV

Dekódolás

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA

(14)

Hardveráttekintés (CPU)

www.tankonyvtar.hu

R0

R1 00001010 R2 00010100 R3 00000010 R4 00101000 R5

R6 R7

3 4 2 3

0100 R4 0011

MUL

Dekódolás

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA

0010 0011 R2 R3

MUL

ALU

PC = 1006

14

(15)

Hardveráttekintés (CPU)

R0

R1 00001010 R2 00010100 R3 00000010 R4 00101000 R5 00110010 R6

R7

3 5 2 3

0101 R5 0010

ADD

Dekódolás

==============

1000 110A 1002 1214 1004 1302 1006 3423 1008 2514 100A 0000

MEMÓRIA

0001 0100 R1 R4

ADD

ALU

(16)

Hardveráttekintés (Szuperskalár CPU)

• Szuperskalár

– A szuperskalár felépítésnél a processzor egyszerre több utasítást is képes végrehajtani a csővezeték elv (pipeline) segítségével.

www.tankonyvtar.hu

Fetch unit

Execute unit

Puffer

Decode unit

IF ID EX WB

idő

instrukció

16

(17)

Hardveráttekintés (CPU) – MultiCore

Core 1 Core 2

Core 3 Core 4 L2 cache

L1 cache

Core 1

L1 cache

L2

Core 1 L2

Megosztott L2 cache Különálló L2 cache-ek

(18)

Hardveráttekintés (CPU) – HyperThreading

• A Hyperthreading technológiával (HT) rendelkező processzorok úgy jelennek meg az OS számára mint különálló logikai

processzorok.

• A processzor két szimmetrikus állapottároló (architecture state) egységgel rendelkezik áll, melyek osztoznak a processzor

végrehajtó egységein.

www.tankonyvtar.hu

Végrehajtó egységek

állapottároló egység

állapottároló egység HT nélküli kétmagos CPU

(dual-core with HT) HT-vel rendelkező kétmagos CPU

(dual-core with HT)

18

(19)

Hardveráttekintés (CPU) – HyperThreading

• „Front-end detailed pipeline”

(20)

Hardveráttekintés (CPU) – HyperThreading

• „Out-of-order execution engine”

www.tankonyvtar.hu

(21)

Hardveráttekintés (CPU) – HyperThreading

• A futtatási hatékonyság alakulása különböző architektúrák

esetében.

(22)

Az operációs rendszer szerepe

• Interfész a felhasználók és a hardver között.

www.tankonyvtar.hu

User Interface Program

(Shell, GUI)

OS HW

Web kliens

E-mail kliens

Egyéb alkalmazás

User mode

Kernel mode

Software

Hardware

22

(23)

Az operációs rendszer szerepe

• Az OS közvetlenül kezeli a hardvert, főbb feladatai:

– Folyamatok ütemezése.

– Memóriahozzáférés biztosítása.

– Processzor ütemezése.

– Megszakításkezelés.

– Háttértárolók kezelése.

– Rendszerhívások kiszolgálása.

– I/O eszközök kezelése.

– Fájlrendszer.

– Egyéb.

• User mód

– Az instrukcióknak csak egy részhalmaza érhető el.

• Kernel mód

– Teljes hozzáférés a hardverhez.

– A teljes instrukciókészlet elérhető (bármelyik instrukció futtatható).

(24)

Főbb OS struktúrák

• Monolitikus,

• rétegezett,

• microkernelek,

• kliens-szerver model,

• virtuális gépek.

www.tankonyvtar.hu

(25)

Monolitikus rendszerek

• Az OS teljes egészében kernel módban fut.

– Bármilyen hiba a teljes rendszer összeomlását idézheti elő.

• A rendszer egybe linkelt eljárások gyűjteménye, azaz egyetlen futtatható bináris programként van jelen.

• A rendszer szolgáltatásai egy felhasználói folyamatból ún.

rendszerhívással hívhatók (lásd később).

Application Programs

System Services

Hardware

User Mode

Kernel Mode

(26)

Rétegezett rendszerek

• A szolgáltatásokat biztosító rutinok rétegekbe szervezettek.

• Réteges struktúra előnyei

– Egy réteg magasabb szintű műveleteket biztosít a felette lévő számára, elrejti az alatta lévő részleteket.

www.tankonyvtar.hu

Application Programs

System Services

Memory & I/O Device Mgmt

Hardware

Process Schedule

Application Programs

User Mode

Kernel Mode

26

(27)

Microkernelek

• A kernel módban futó kód kevesebb, így a rendszer megbízhatóbb is egyben.

• Lehetőleg minél több OS funkció kerüljön a felhasználói módú, legfelső rétegbe.

A modern oprendszerek ebbe a kategóriába tartoznak

(28)

Kliens-szerver modell

• A folyamatok két osztályát különböztetjük itt meg:

– Kliensek, melyek a szolgáltatást igénybe veszik.

– Szerverek, melyek a szolgáltatást nyújtják.

• A kommunikáció a kliens és a szerver között üzenetküldéssel valósul meg.

– A kernel csak a kommunikációt (és az időosztást) biztosítja.

www.tankonyvtar.hu

Client Application

Thread lib.

File Server

Network Server

Display Server

Microkernel

Hardware

User Kernel

kérés válasz

28

(29)

Virtuális gépek

• A hardveren szoftverrel szimulált.

• Minden erőforrás virtualizált.

• Individuális OS ezen virtualizált erőforrásokon fut.

• A fizikai gép erőforrásai megosztottak az egyes virt. gépek között.

• Amikor a virtuális gépen futó OS privilegizált instrukciót futtat az ún. hypervisor közvetít.

HW Hypervisor

Windows Linux …

…

App-1 App-2

App-3 App-1 App-2

App-3

Vendég OS

HW Gazda OS

Vendég OS Vendég OS

Virtualizációt megvalósító alkalmazás

(30)

Virtuális kernel mód

• Kernel mód vs. virtuális kernel mód.

www.tankonyvtar.hu

HW

Hypervisor Trap on privileged instructions

Vendég OS

Felhasználói folyamatok

Virtual machine

virtual user mode

virtual kernel mode

kernel mode

30

(31)

Rendszerhívások

• Interfész a felhasználói programok és az OS között.

• Amikor egy „user” módban futó folyamat az OS valamelyik

szolgáltatását akarja igénybe venni (pl. olvasás fájlból) egy ún.

„trap” mechanizmust kell végrehajtania, amivel átadja az OS-nek az irányítást (lásd később).

• Az OS az átadott paraméterek alapján kideríti, milyen szolgáltatásról van szó.

• Ezután végrehajtja a rendszerhívást.

• Majd visszaadja az irányítást a rendszerhívást követő instrukció

címére.

(32)

Példa rendszerhívásra

• count = read(fd, buffer, nbytes)

www.tankonyvtar.hu

Increment SP Call read

Push fd Push &buffer

Push nbytes Return to caller

Trap to kernel

Put code for read in register

System call nr. examining

Running System call handler

1 2 3

4 5 6

7 8

9 10

32

(33)

Multiprocesszor OS típusok

• Jellemzők:

– OS kódja megosztva fut az egyes processzorokon.

– Memória felosztása annyi részre amennyi processzorunk van.

– I/O eszközök megosztása.

• Problémák:

– A rendszerhívást a hívó folyamatot futtató CPU kezeli le.

– A folyamatok nincsenek megosztva a CPU-k között.

– A memóriablokkok nem megosztottak.

– Független „buffer cache”-ek a legutóbb használt lemezblokkok tárolására (inkonzisztencia).

Has private OS

1 Data

2 data 3

Data 4 Data OS code

I/O

CPU-1 CPU-2 CPU-3 CPU-4 Memória

(34)

Mester-szolga multiprocesszor OS típusok

• Jellegzetességek:

– Minden rendszerhívás a mester CPU-hoz van irányítva.

– Az OS kódot futtató CPU a mester, a többi CPU szolga (alkalmazásokat futtatnak).

– Közösen használt memória.

– Egyetlen adatstruktúra a készenléti állapotban lévő folyamatok nyilvántartására – hatékony terhelése elosztás.

– Egyetlen „buffer cache” – inkonzisztencia nem lép fel.

– Mi a probléma? A mester túlterhelődhet.

www.tankonyvtar.hu

OS kódot futtat

Szolga Felhasználói folyamatokat

futtat

futtat OS code

I/O

34

(35)

Szimmetrikus multiprocesszorok (SMP)

• Jellegzetességek:

– Eliminálja a mester/szolga asszimmetriát.

– Egyetlen OS kód, de azt bármelyik CPU futtathatja.

– Közösen használt memória.

– Rendszerhívás esetén az a CPU lép kernel módba és kezeli le a

rendszerhívást, amelyik a rendszerhívást előidéző folyamat kódját futtatja.

– Dinamikus terheléselosztás.

OS kódot és felhasználói folyamatokat

is futtat

is futtat OS code

I/O

(36)

A Windows 2008 Server

• A Windows ún. SMP (symmetric multiprocessing) operációs rendszer.

– Nincs mester processzor – az operációs rendszer, úgy mint a felhasználói szálak is bármelyik processzoron futtathatók

– Minden processzor közös memóriaterületen osztozik.

• Az ASMP (asymmetric multiprocessing) esetében az OS kiválaszt egy CPU-t az OS kernel kódjának futtatására, míg a többi CPU csak user módú kódot futtat.

www.tankonyvtar.hu

Operating system

User thread User

Thread

User thread

User Thread

Memory

CPU A CPU B

User thread

User Thread

Memory

CPU A CPU B

User Thread

Szimmetrikus Aszimmetrikus

I/O I/O

36

(37)

A Windows 2008 Server

• A rendszer felépítésének főbb jellemzői

– A Windows felépítése rétegszerkezetű, számos alrendszerének működése a kliens-szerver architektúrára alapul.

– Jól definiált rétegekre bomlik, mely rétegek szigorúan interfészeken keresztül érintkeznek. A szolgáltatások túlnyomó részénél kliens-szerver architektúrát találunk.

– Nem tartották viszont szigorúan be a rendszer fejlesztői azt az elvet, hogy amennyiben mód van rá, a szolgáltató folyamatok felhasználói (user) módban fussanak és a rendszer a mikrokernelen keresztül érje el a hardvert.

– Ez azért van így, mert bizonyos szolgáltatásokat nem hatékony felhasználói módban megvalósítani. Így kernel módban azok a szolgáltatások kerültek, amelyek intenzíven használják a hardvert és futásuk gyorsaságára az egész rendszer teljesítménye érzékeny, vagyis a user módban történő

megvalósításuk a rendszert nagyon lelassítaná a gyakori környezetváltás miatt. (Ilyen például a cache manager, a memóriakezelő, az objektumkezelő és biztonsági alrendszer, vagy a WIN32-es alrendszer grafikus

szolgáltatásokat nyújtó részei stb.).

(38)

A Windows 2008 Server architektúrája

www.tankonyvtar.hu

Rendszer- támogató

folyamatok Szolgáltatások Felhasználói

alkalmazások Környezeti alrendszerek

Alrendszer dll-ek

Adminisztrációs réteg (executive layer) Kernel

Hardver absztrakciós réteg

Driverek Grafika

User mód Kernel mód

38

(39)

A Windows 2008 Server architektúrája

• Windows kernel (ntoskrnl.exe)

– Az operációs rendszer alapfunkcióit nyújtó komponense, mint pl.

• szálak ütemezése,

• megszakítás és kivétel kezelés,

• processzorok szinkronizálása.

– Hardverspecifikus kódrészletek itt még előfordulhatnak, mivel pl. a

környezetváltás esetében, annak megvalósításához ismerni kell, hogy az adott CPU milyen regiszterekkel rendelkezik.

• Windows executive (adminisztrációs réteg)

– Az operációs rendszer magasabb szintű funkcióit szolgáltató rétege:

• memóriamenedzsment,

• folyamat- és szálmenedzsment ,

• biztonság,

• I/O,

• hálózatkezelés,

• folyamatok közti kommunikáció.

(40)

A Windows 2008 Server architektúrája

• Windows Executive (folyt.)

– Az adatokat objektumokban tárolja, melyeket leírókkal (Handle) lehet csak interfészeken keresztül elérni. Minden objektumhoz biztonsági információ (access token) is tartozik.

• Eszközkezelők (Driverek)

– Az általános I/O hívásokat hardver specifikus az adott eszköznek szóló I/O kérésekre fordítják.

– A Windows rétegezett struktúrájú eszközkezelő modellel rendelkezik, melyben az egyes eszközkezelők (driverek) láncot alkotnak. Lásd később.

• Hardver-absztrakciós réteg (HAL)

– Feladata, hogy elfedje a platform specifikus hardver különbségeket és a felette lévő rétegeknek (kernel, eszközdriverek, executive) egységes interfészt nyújtson az alacsonyszintű hardver műveletekhez.

– Pl. alaplapok közti különbségeket.

• Grafikus felhasználói felület (GUI)

– Ablakok, felhasználók általi vezérlés…

www.tankonyvtar.hu

(41)

A Windows 2008 Server architektúrája

• Rendszertámogató folyamatok:

– Felhasználói módban futnak, nélkülözhetetlenek a rendszer elindulásához, működéséhez.

– Pl. logon process, session manager, service control manager, local security authority subsystem.

• Szolgáltatások:

– Olyan folyamatok, melyek a felhasználói felülettől és belépéstől függetlenül a háttérben futnak, és kibővítik az operációs rendszer alapszolgáltatásait.

– Pl. feladat ütemező, tároló szolgáltatások (user logontól függetlenül futnak a háttérben).

• Felhasználói alkalmazások (6 típus):

– Windows 32 bit.

– Windows 64 bit, Windows 3.1 16 bit, MS-DOS 16 bit.

– POSIX 32 bit vagy OS/2 32 bit.

– Ezeken keresztül szintén elérhették az alkalmazások az OS hívásait.

(42)

A Windows 2008 Server architektúrája

• Környezeti alrendszerek (folyt.)

– A Windows NT megjelenésekor háromféle programozói felület:

• POSIX, Win32 és OS/2 API .

– A Win32 alrendszer kitüntetett abban a tekintetben, hogy a Win32

alrendszer nélkül az NT nem tud futni. A másik két alrendszer opcionális, csak abban az esetben kezdenek futni, amikor az adott alrendszerhez tartozó

alkalmazást akar a felhasználó elindítani.

– Az alrendszerek elsődleges feladata, hogy a hozzájuk tartozó alkalmazások futásához szükséges szolgáltatásokat nyújtsák. Minden alrendszer a hozzá tartozó alkalmazásokat kontrollálja.

– Minden alrendszerhez tartozik egy ún. alrendszer DLL, melyen keresztül az alrendszerhez tartozó alkalmazás a rendszer szolgáltatásait elérheti. Ez tehát a programozói interfész (API: Application Programming Interface), ami az egyes alrendszerekhez tartozó applikációk számára elérhető.

– Ezt azért fontos kiemelni, mert ez az a publikált, jól definiált felület, amit minden program használhat. Az összes többi interfész (például NTDLL.DLL) nem publikus interfész.

www.tankonyvtar.hu

(43)

A Windows 2008 Server architektúrája

• Környezeti alrendszerek (folyt.)

– Az egyes alrendszerekhez tartozó API-k lényegesen különböznek egymástól.

A legszélesebb lehetőségeket a Win32 API biztosítja (például ablakozás, szálak kezelése stb.). Fontos tudni, hogy egy applikáció csak egy

alrendszerhez tartozhat, nem keveredhetnek egymással egy applikáción belül különböző alrendszerhez tartozó hívások.

(44)

A Windows 2008 Server architektúrája

www.tankonyvtar.hu

Service control mgr.

LSAA Winlogon Session manager

Services.exe SvcHost.exe WinMgt.exe SpoolSv.exe Services.exe

Services.exe Task Manager

Explorer User application Subsystem DLLs

Windows OS/2 POSIX

Windows DLLs

System Service Dispatcher

Kernel mode callable interfaces

I/O Mgr.

Device &

File Sys.

Drivers Device &

File Sys.

Drivers File System Cache Object Mgr. Plug and Play Mgr. Security reference monitor Virtual memory Processes & threads Configu- ration Mgr (registry) Local Procedure Call

Windows USER, GDI

Graphics drivers

Kernel

Hardware Abstraction Layer (HAL) NTDLL.DLL

System threads

User mode Kernel mode

44

(45)

A rendszer mechanizmusai

• A Windows különféle alapmechanizmusokat szolgáltat, melyeket a kernel módú komponensek (executive, kernel, eszközkezelők) használnak. A következőkben ezeket a mechanizmusokat

ismertetjük:

– Trap mechanizmus, ideértve a megszakításokat, késleltetett eljáráshívásokat (DPC), aszinkron eljáráshívásokat (APC), kivétel elküldését,

rendszerszolgáltatások indítását.

– Az executive objektum menedzser működése.

– Szinkronizálás:

• Spin lock ,

• kernel diszpécserobjektumok ,

• a várakozás megvalósítása .

– Rendszer dolgozó (worker) szálak.

– Lokális eljáráshívások (Local procedure call – LPC).

– Kernel események nyomon követése.

– Stb.

(46)

Trap mechanizmus

• A megszakítások (interrupt) és a kivételek (exception) olyan

események az operációs rendszerben, amelyek a CPU-t eltérítik az utasítások normál végrehajtási sorrendjétől.

• A megszakításokat és a kivételeket detektálhatják a rendszer hardver, és szoftver komponensei egyaránt.

• A trap (csapda) fogalom a processzor azon mechanizmusát jelöli, amelynek segítségével az egy végrehajtás alatt levő szálat állít meg egy megszakítás, vagy egy kivétel hatására.

• A trap mechanizmus a processzort felhasználói módról kernel módra kapcsolja át (lásd később), és a vezérlést az operációs rendszer egy fix helyére, a trapkezelő rutinra adja át.

• A trapkezelő eldönti, melyik operációs rendszer komponens képes a megszakítást, vagy kivételt kiváltó eseményt lekezelni.

www.tankonyvtar.hu

(47)

Trap mechanizmus

Interrupt service routines

System services

Exception dispatcher

Exception handlers

Virtual memory manager’s

pager (lapkezelő)

Virtuális cím kivételek Hardver és szoftver kivételek

Rendszerszolgáltatás hívás

Megszakítás

„Exception frame”

trapkezelők

(48)

Trap mechanizmus

• Amikor kivétel vagy megszakítás generálódik a CPU elegendő gépi állapotjelzőt ment el a megszakított szál kernel vermébe.

• A verembe helyezett adatok alapján biztosított a visszatérés a megszakított szál kódjának futtatásához.

• Felhasználói módban a Windows átvált a szál kernel módú

vermére, melyben egy ún. trap keret (trap frame) formájában a megszakított szál állapota elmentésre kerül.

www.tankonyvtar.hu

(49)

Kernel módba való váltás lépései

User Stack

Kernel kód ESP0

Kernel Stack

REGISZTEREK

CPU

ESP EIP EFLAGS (FLG) EAX, EBX, ECX,

EDX, EBP, ESI, EDI,…

User Thread

• Tételezzük fel, hogy felhasználói módban (user mode) vagyunk és kernel módba való váltás következik be az alábbi események

valamelyikének bekövetkezése esetén:

– szoftver megszakítás (INT n, INTO, INT3), – hardvermegszakítás,

– kivétel hatására.

(50)

Kernel módba való váltás lépései

www.tankonyvtar.hu

User Stack

Kernel Stack

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén elsősorban a következő főbb lépések hajtódnak

végre:

– TempSS ← SS – TempESP←ESP

– SS:ESP←TSS(SS0:ESP0)

50

(51)

Kernel módba való váltás lépései

User Stack

Kernel Stack ESP SS

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén a következő lépések hajtódnak végre:

– PUSH TempSS – PUSH TempESP

(52)

Kernel módba való váltás lépései

www.tankonyvtar.hu

User Stack

Kernel Stack FLG ESP SS

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén a következő lépések hajtódnak végre:

– PUSH TempSS – PUSH TempESP – PUSH EFLAGS – RESET FLAGS

52

(53)

Kernel módba való váltás lépései

User Stack

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén a következő lépések hajtódnak végre:

– PUSH CS – PUSH EIP

– A kernel belépési pontjának EIP-be való betöltése.

CS EIP

(54)

Kernel módba való váltás lépései

www.tankonyvtar.hu

User Stack

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén a következő lépések hajtódnak végre:

– Kivétel (Exception) esetén a kivétel hibakódja a verembe kerül.

CS EIP X

54

(55)

Kernel módba való váltás lépései

User Stack

REGISZTEREK

CPU

User Thread

• Külső megszakítás, kivétel vagy szoftver megszakítás (INT n, INTO, INT3) esetén a következő lépések hajtódnak végre:

– Kivétel (Exception) esetén a kivétel hibakódja a verembe kerül.

– További regiszterek verembe mentése (opcionális) – ez már a kernel feladata.

CS EIP X EDI…EAX

(56)

Védelmi szintek

• A gyakorlatban két szint használatos

– 0 – kernel.

– 3 – alkalmazások.

www.tankonyvtar.hu

Ring 3 Ring 2 Ring 1

Ring 0 Kernel mód

Felhasználói mód A CPU védelmi szintjei

56

(57)

Trap mechanizmus

• A trap keret a szál teljes kontextusának (lásd később) csupán egy részhalmaza.

– A „kernel debugger” parancssorába a dt nt!_ktrap_frame paranccsal a trap keret definíciója lekérdezhető.

• A feladat specifikus trapkezelő függvények futása előtt és után a kernel ún. „front-end” trapkezelőket alkalmaz az általános feladatok megvalósítása céljából.

– Pl. egy eszközmegszakítás hatására a „front-end” hardvermegszakítás trapkezelő a vezérlést arra a megszakítást kiszolgáló rutinra (ISR) adja át, melyet a megszakítást kiváltó eszköz eszközkezelője (driver) szolgáltat.

– Szolgáltatáshívás hatására a szolgáltatások „front-end” trapkezelője a vezérlést az adminisztrációs réteg azon specifikus függvényére adja át, amely az adott szolgáltatást implementálja.

(58)

Megszakítások típusai

• Aszinkron

– Külső eszköztől eredő megszakítások (I/O).

– Bekövetkezésük független az éppen végrehajtott instrukciótól.

• Szinkron (kivételek – exceptions)

– A CPU által detektált kivételek:

– Hibák („faults”)

• A kivétel lekezelése után EIP a hibát előidéző instrukcióra mutat.

• Pl. Page-fault handler.

– „Traps”

• Debuggolás („breakpoint”-hoz való érkezés).

• A trap handler lefutása után EIP a trapot kiváltó instrukció utánira mutat.

– Abortok

• Hardver hiba – következménye az érintett folyamat befejezése.

– Szoftvermegszakítások:

• Kernel szolgáltatás kérése (int/sysenter).

www.tankonyvtar.hu

(59)

Megszakítások típusai

• Maszkolható megszakítások

– Mindazon IRQ, amely valamelyik I/O eszköz által generált megszakításhoz tartozik.

• Nem maszkolható megszakítások

(60)

Megszakításkezelés

• A hardver által generált megszakítások tipikusan az I/O eszközök által kiváltott események, melyeken keresztül a processzort

értesíteni tudják, amennyiben szolgáltatást szeretnének igénybe venni.

• Az I/O műveletek és a CPU műveletek végrehajtása átfedheti egymást.

– Pl. egy szál I/O transzfert kezdeményez. Ezt követően a szál további

instrukciókat futtathat miközben az I/O eszköz a transzfert végzi. Amikor az eszköz befejezte tevékenységét (esetünkben a transzfert) megszakítást

generál.

– I/O intenzív folyamatok és CPU intenzív folyamatok.

• Szoftver is generálhat megszakításokat.

– A kernel megszakítást generál, pl. amikor új szálat akar futásra kijelölni vagy amikor be akar avatkozni a szál végrehajtásába.

• A kernel blokkolhatja a megszakításokat.

– Pl. amíg egy másik megszakítás feldolgozása folyamatban van.

www.tankonyvtar.hu

(61)

Megszakításkezelés

• A kernel, mint már említettük, megszakításkezelő rutinokat alkalmaz a megszakítások kiszolgálására. Ezek a megszakításkezelő rutinok a vezérlést vagy egy külső rutinra (ISR – Interrupt Service Routine) vagy egy belső kernel rutinra adják át.

• Az ISR-eket az eszközmeghajtók (driver) szolgáltatják az eszközmegszakítások kiszolgálásához, a kernel pedig belső rutinokat tart fenn az egyéb jellegű megszakítások kiszolgálása céljából.

• A Windows által támogatott hardver platformokon, egy külső I/O

megszakítás az ún. megszakításvezérlő áramkör egyik bemenetén

érkezik.

(62)

Megszakításkezelés

• A külső megszakításkérés kiszolgálása az alábbi módon megy végbe:

– A megszakítást igénylő eszköz jelez a megszakításvezérlőnek (I/O APIC).

– Az I/O APIC statikus vagy dinamikus megszakítás elosztási stratégiát

alkalmazva (lásd később) a megfelelő CPU-hoz tartozó lokális APIC vezérlőhöz irányítja a megszakítást.

– Ezt követően a lokális APIC vezérlő a „Task Priority Register”-ben (TPR) tárolt prioritási értéket összeveti a függőben levő megszakítások közül (TRR

regiszterben tárolt) a legnagyobb prioritással rendelkezővel.

– Amennyiben a függőben levő prioritás nagyobb TPR-nél, a lokális APIC a kérést a CPU-nak továbbítja (INTR jel aktív).

– A CPU nyugtázza a kérést (IACK jel aktív), melyre az APIC vezérlő válaszként CPU-nak elküldi a megszakításvektort.

– APIC az IRR regiszter a beállított legnagyobb prioritásnak megfelelő bitet nullázza, az ISR regiszter megfelelő bitjét pedig beállítja.

www.tankonyvtar.hu

(63)

Megszakításkezelés

– A CPU a vezérlést az IDT táblában a megszakítási vektort által indexelt

mezőben található címre – az megszakítás kiszolgáló rutin (ISR) címe – adja át.

• Az IDT tábla címe az IDTR regiszterben található.

– Az ISR befejezése előtt a kernel egy EOI (End of Interrupt) parancsot küld az APIC vezérlőnek.

– APIC az ISR regiszter megfelelő bitjét nullázza.

– Visszatérés a megszakítás eseménye előtti pontra.

• Miután befejezte a programot, kiolvassa a veremből az elmentett állapotot, és folytatja a megszakított programot.

• Példa IDT bejegyzésre:

– x86 és x64 esetében a page fault kivétel a 0xe értéket kapta (page-fault lásd később). Ez azt jelenti, hogy a 0x-dik bejegyzés az IDT táblában a rendszer page-fault kezelőjére mutat.

• Az APIC vezérlő 256 megszakítást támogat

– A 0–31 tartományba eső megszakítás vektorok a CPU architektúra által definiált kivételek és megszakítások részére fenntartottak.

– Folytatás…

www.tankonyvtar.hu

(64)

Megszakításkezelés

• A 32–255 tartományba eső megszakítás vektorok a felhasználó által definiált megszakításokat fedik le (forrás: külső megszakítások vagy int n instrukció).

• Maszkolható megszakítások

– Minden külső megszakítás, amely az INTR pin vagy a Lokális APIC vezérlőn keresztül jut el a CPU-hoz.

– STI és CLI instrukciók (IF flag beállítása/törlése).

– A 0–32 vektortartományba eső megszakítások esetében az IF flag beállítása hatástalan.

• Nem maszkolható megszakítás (megszakításvektor=2)

– Források:

• NMI pin,

• APIC busz vagy Rendszer busz.

www.tankonyvtar.hu

(65)

Lokális APIC vezérlő struktúrája

(66)

Lokális APIC vezérlő struktúrája

www.tankonyvtar.hu

(67)

Lokális APIC vezérlő struktúrája

(68)

Megszakításkezelés (vezérlők)

• Megszakítások disztribúciója a CPU-k között:

– Statikus

• Az ún. „Logical Destination” és a „Destination Format„ regiszterek értéke alapján.

• A megszakítás egyetlen CPU-nak, CPU-k csoportjának, vagy akár minden CPU-nak is továbbítható az I/O APIC buszon keresztül.

– Dinamikus

• Azon CPU Lokális APIC vezérlőjének

továbbítódik, amelyik a legkisebb prioritású folyamatot futtatja.

• „Task Priority Register” (TPR) – az aktuális prioritási szint meghatározására szolgál.

• Azonos prioritási szinten dolgozó CPU-k

esetén a megszakítások Round-Robin módon egyenletesen kerülnek szétosztásra.

– 256 IDT bejegyzés

www.tankonyvtar.hu

CPU 0 CPU 1

Local APIC

I/O APIC

i8259A equivalent

PIC I/O busz

Eszközmegszakítások (IRQ)

IDTR IDTR

IDT

(Interrupt Dispatch Table)

kezelő címe Megszakításvektor kezelő címe

kezelő címe kezelő címe

ISR

IDT

(Interrupt Dispatch Table) kezelő címe kezelő címe kezelő címe kezelő címe

68

(69)

www.tankonyvtar.hu

Megszakítások prioritási szintjei (IRQL)

– A Windows saját megszakítás prioritási szinteket definiál (interrupt request levels – IRQL).

– x86 architektúra esetében a kernel 0–31 prioritási szintet különböztet meg.

– A hardverabsztrakciós réteg (HAL) a hardware megszakítás értékeket az IRQL értékekre képzi le.

x86-IRQL x64-IRQL

High PowerFail

Inter-processor interrupt Clock

Eszköz n Profile

Eszköz 1 . . .

DPC/Dispatch APC PASSZÍV SZINT

Hardver megszakítások

Szoftver megszakítások

Normál szálak futtatása 0

1 2 26 27 28

3 29 30 31

High/Profile

Inter-processor interrupt/Power Clock

Eszköz n Synch (Srv 2003)

Eszköz 1 . . .

DPC/Dispatch APC PASSZÍV SZINT 0

1 2 11 12 13

3 14 15

69

(70)

Szoftvermegszakítás küldése

Az APIC vezérlő ICR regiszterének írásával:

xor ecx, ecx

mov cl, _HalpIRQLtoTPR[eax] ; get IDT Entry for IRQL or ecx, (DELIVER_FIXED OR ICR_SELF)

mov dword ptr APIC[LU_INT_CMD_LOW], ecx

_HalpIRQLtoTPR label byte

db ZERO_VECTOR ; IRQL 0 db APC_VECTOR ; IRQL 1 db DPC_VECTOR ; IRQL 2

#define APC_VECTOR 0x3D // IRQL 01 APC

#define DPC_VECTOR 0x41 // IRQL 02 DPC

www.tankonyvtar.hu

(71)

Megszakítások maszkolása

High PowerFail

Inter-processor interrupt Clock

Eszköz n Profile

Eszköz 1 . . .

DPC/Dispatch APC PASSZÍV SZINT

B CPU-n maszkolt megszakítások Az A CPU-n maszkolt

megszakítások

IRQL=DPC/DISPATCH IRQL=Clock

CPU A

CPU B

(72)

Megszakítások maszkolása

• Minden CPU IRQL beállítása meghatározza, hogy az milyen megszakításokat kaphat.

• Az IRQL-ek segítségével a kernel módú adatstruktúrákhoz való hozzáférés szinkronizálása is megvalósítható (lásd később).

• Megszakítás esetén a trapkezelő növeli a CPU IRQL-jét a megszakítás forrásához tartozó IRQL szintre.

• Az alacsonyabb szintű és ugyanazon megszakítások így maszkoltak lesznek (blokkolódnak) az adott CPU-n.

• A maszkolt megszakítások más CPU-k által lekezelhetők vagy

mindaddig függőben maradnak amíg az adott CPU IRQL-je le nem csökken.

• A rendszer komponensei igyekeznek az IRQL-t passzív szinten tartani.

– Ezen a szinten minden megszakítás engedélyezett (ez a normál szál futása során érvényes IRQL).

www.tankonyvtar.hu

(73)

Megszakítások maszkolása

• A Windows XP és az azt megelőző rendszerek esetében az APIC TPR regiszteréhez való hozzáférés (írás/olvasás) nagyon gyakori volt. Amikor az IRQL magasabb szintre került, az OS a local APIC TPR regiszterét annak megfelelően beállította. Ugyanez történik amikor az IRQL csökken.

• Windows Server 2003 és az azt követő rendszerek esetében ún.

lazy-IRQL koncepciót figyelhetünk meg. Amikor az IRQL magasabb szintre kerül, a HAL (hardver absztrakciós réteg) saját struktúrában megjegyzi az új IRQL értéket. Amikor a CPU közben egy újabb megszakítást kap, az OS összeveti a prioritását a tárolt IRQL értékkel és ezt követően módosítja az APIC TPR regiszterét.

• Ha a megszakítás kiszolgálása közben nem érkezik újabb

megszakítás az OS-nek nem kell a TPR regisztert módosítania.

(74)

Megszakításobjektumok

• A kernel külön mechanizmust biztosít az eszköz meghajtók

(driverek) számára, hogy azok regisztrálhassák megszakításkezelő rutinjaikat (ISR). Mindez az ún. megszakításobjektumokon

keresztül valósul meg.

• Amikor a megszakításobjektum inicializálódik, egy

KiInterruptTemplate nevezetű sablon kód kerül az objektum egy meghatározott szegmesébe. Eszköztől eredő megszakítás esetén, a vezérlés erre a kódra adódik át.

• A kód meghívja a valódi megszakítás diszpécsert

(KiInterruptDispatch vagy KiChainedDispatch rutinok

valamelyikét), melynek paraméterként átad egy mutatót a megszakításobjektumra.

• Ezek a rutinok az IRQL szintet az objektumban definiáltra emelik és meghívják az eszközhöz tartozó ISR-t.

www.tankonyvtar.hu

(75)

Megszakításobjektumok

Külső hardver eszköz CPU megszakítás- vezérlő

IDT tábla 0 2 3

n

ISR Address Spin Lock Dispatch Code

Interrupt Object

Read from device

Acknowledge- Interrupt Request DPC Raise IRQL

Lower IRQL Grab Spinlock

Drop Spinlock