Betriebssysteme. Tafelübung: Klausurvorbereitungsstunde. Olaf Spinczyk.

Transkript

1 Betriebssysteme Tafelübung: Klausurvorbereitungsstunde Olaf Spinczyk AG Eingebettete Systemsoftware Informatik 12, TU Dortmund

2 Agenda Prozesse Synchronisation Deadlocks Speicherverwaltung Ein-/Ausgabe Betriebssysteme: Fragestunde 2

3 Verwendung von fork()... /* includes */ int main () { int pid; printf( Elternpr.: PID %d PPID %d\n, getpid(), getppid()); pid = fork(); /* Prozess wird dupliziert! Beide laufen an dieser Stelle weiter. */ if (pid > 0) printf( Im Elternprozess, Kind-PID %d\n, pid); else if (pid == 0) printf( Im Kindprozess, PID %d PPID %d\n, getpid(), getppid()); else printf( Oh, ein Fehler!\n ); /* mehr dazu in der TÜ */ } olaf@xantos:~>./fork Elternpr.: PID 7553 PPID 4014 Im Kindprozess, PID 7554 PPID Betriebssysteme: Im Elternprozess, Fragestunde Kind-PID

4 Diskussion: Zombies Bevor der exit status eines terminierten Prozesses mit Hilfe von wait abgefragt wird, ist er ein Zombie. Die Ressourcen solcher Prozesse können freigegeben werden, aber die Prozessverwaltung muss sie noch kennen. Insbesondere der exit status muss gespeichert werden. & ps PID TTY TIME CMD 4014 pts/4 00:00:00 bash pts/4 00:00:00 wait pts/4 00:00:00 wait <defunct> pts/4 00:00:00 ps Exit Status: 42 Beispielprogramm mit beendetem Kindprozess ohne abgefragten exit Status. Zombies werden von ps als <defunct> dargestellt Betriebssysteme: Fragestunde 4

5 Leichtgewichtige Prozesse (Threads) Die 1:1-Beziehung zwischen Kontrollfluss und Adressraum wird aufgebrochen. Eng kooperierende Threads (deutsch Fäden ) können sich einen Adressraum teilen (code + data + bss + heap, aber nicht stack!). Vorteile: Aufwändige Operationen können in einen leichtgewichtigen Hilfsprozess ausgelagert werden, während der Elternprozess erneut auf Eingabe reagieren kann. Typisches Beispiel: Webserver Programme, die aus mehreren unabhängigen Kontrollflüssen bestehen, profitieren unmittelbar von Multiprozessor-Hardware. Schneller Kontextwechsel, wenn man im selben Adressraum bleibt. Je nach Scheduler eventuell mehr Rechenzeit. Nachteil: Programmierung ist schwierig: Zugriff auf gemeinsame Daten muss koordiniert werden. Betriebssysteme: Fragestunde 5

6 Vergleich: exec..() fork() pthread_create() Überlagerung eines Prozesses Keine gemeinsamen Daten schwergewichtig Prozess A STACK DATA, BSS, HEAP main thread /* TEXT Segment prog1 */ exec..( prog2...); Betriebssysteme: Fragestunde 6

7 Vergleich: exec..() fork() pthread_create() Überlagerung eines Prozesses Keine gemeinsamen Daten schwergewichtig Prozess A STACK STACK DATA, BSS, HEAP DATA, BSS, HEAP main thread /* TEXT Segment prog1 */ /* TEXT Segment prog2 */ int main(...)... int main(...) Betriebssysteme: Fragestunde 7

8 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A STACK DATA, BSS, HEAP main thread /* TEXT Segment */ switch(fork()){ case -1: exit(exit_failure); case 0:... break; case default:... break; } Betriebssysteme: Fragestunde 8

9 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP main thread /* TEXT Segment */ switch(fork()){ case -1: exit(exit_failure); case 0:... break; case default:... break; } main thread Betriebssysteme: Fragestunde 9

10 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP main thread /* TEXT Segment */ switch(fork()){ case -1: exit(exit_failure); case 0:... break; case default:... break; } main thread SHARED MEMORY Betriebssysteme: Fragestunde 10

11 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP main thread /* TEXT Segment */ switch(fork()){ case -1: exit(exit_failure); case 0: Erzeugung... break; case default:... break; } und Anbindung nötig main thread SHARED MEMORY Zugriff muss durch Semaphore synchronisiert werden Betriebssysteme: Fragestunde 11

12 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A STACK DATA, BSS, HEAP /* TEXT Segment */ main thread int main(void){... pthread_create(,&newthread,(void*)&thargs);... } Betriebssysteme: Fragestunde 12

13 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A MainThread STACK NEWthread STACK DATA, BSS, HEAP main thread /* TEXT Segment */ int main(void){ new thread void *NEWthread(void *thargs){ pthread_create( ); pthread_exit((void*)0); } } Betriebssysteme: Fragestunde 13

14 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A MainThread STACK NEWthread STACK DATA, BSS, HEAP main thread /* TEXT Segment */ Zugriff muss durch Mutexe oder Semaphore synchronisiert werden int main(void){ new thread void *NEWthread(void *thargs){ pthread_create( ); pthread_exit((void*)0); } } Betriebssysteme: Fragestunde 14

15 Agenda Prozesse Synchronisation Deadlocks Speicherverwaltung Ein-/Ausgabe Betriebssysteme: Fragestunde 15

16 Semaphor komplexere Interaktionen Beispiel: Das erste Leser/Schreiber-Problem /* gem. Speicher */ /* Leser */ Semaphore mutex; wait(&mutex); Semaphore wrt; readcount++; int readcount; if (readcount == 1) wait(&wrt); /* Initialisierung */ signal(&mutex); mutex = 1; wrt = 1;... lese readcount = 0; wait(&mutex); /* Schreiber */ readcount--; wait (&wrt); if (readcount == 0)... schreibe signal(&wrt); signal(&mutex): signal (&wrt); Betriebssysteme: Fragestunde 16

17 Naiver Lösungsansatz falsch! /* Schlossvariable (Initialwert 0) */ typedef unsigned char Lock; /* Kritischen Abschnitt betreten */ void acquire (Lock *lock) { while (*lock); *lock = 1; } /* Kritischen Abschnitt wieder verlassen */ void release (Lock *lock) { *lock = 0; } Betriebssysteme: Fragestunde 17

18 Naiver Lösungsansatz falsch! /* Schlossvariable */ typedef unsigned char Lock; /* K.A. betreten */ void acquire (Lock *lock) { while (*lock); *lock = 1; } /* K.A. verlassen */ void release (Lock *lock) { *lock = 0; } acquire soll einen kritischen Abschnitt schützen, ist dabei aber selbst kritisch! Problematisch ist der Moment nach dem Verlassen der Warteschleife und vor dem Setzen der Schlossvariablen. Bei Verdrängung des laufenden Prozesses in diesem Moment könnte ein anderer Prozess den kritischen Abschnitt frei vorfinden und ebenfalls betreten. Im weiteren Verlauf könnten (mindestens) zwei Prozesse den eigentlich durch acquire geschützten kritischen Abschnitt überlappt ausführen! Betriebssysteme: Fragestunde 18

19 Schloss mit atomaren Operationen Viele CPUs unterstützen unteilbare (atomare) Lese-/Modifikations-/Schreibzyklen, mit denen sich Schlossalgorithmen implementieren lassen: Motorola 68K: TAS (Test-and-Set) Setzt Bit 7 des Zieloperanden und liefert den vorherigen Zustand in Condition Code Bits acquire TAS lock BNE acquire Intel x86: XCHG (Exchange) Tauscht den Inhalt eines Registers mit dem einer Variablen im Speicher PowerPC: LL/SC (Load Linked/Store Conditional)... mov ax,1 acquire: xchg ax,lock cmp ax,0 jne acquire Betriebssysteme: Fragestunde 19

20 Semaphor einfache Interaktionen einseitige Synchronisation /* gem. Speicher */ Semaphore elem; struct list l; struct element e; /* Initialisierung */ elem = 0; void producer() { enqueue(&l, &e); signal(&elem); } void consumer() { struct element *x; wait(&elem); x = dequeue(&l); } betriebsmittelorientierte Synchronisation /* gem. Speicher */ Semaphore resource; /* Initialisierung */ resource = N; /* N > 1 */ sonst wie beim gegenseitigen Ausschluss Betriebssysteme: Fragestunde 20

21 Agenda Prozesse Synchronisation Deadlocks Speicherverwaltung Betriebssysteme: Fragestunde 21

22 Ursachenforschung... am Beispiel 1 Käfer 1 belegt L und benötigt R Käfer 2 belegt R und benötigt L R 1 R L L 2 Verklemmung möglich 2 Verklemmung aufgetreten Betriebssysteme: Fragestunde 22

23 Ursachenforschung... abstrakt Fortschritt Prozess K2 1 2 '1'-'6': mögliche Abläufe : Verklemmung In diese Bereiche können die Prozesse nicht hinein! Betriebsmittel 3 Verklemmung unvermeidbar L R L R Betriebsmittel Fortschritt Prozess K Betriebssysteme: Fragestunde 23

24 Ursachenforschung... abstrakt Fortschritt Prozess K2 '1'-'6': mögliche Abläufe Eine Verklemmung kann in diesem Szenario nicht auftreten. Betriebsmittel L R 5 6 L R Betriebsmittel Fortschritt Prozess K Betriebssysteme: Fragestunde 24

25 Betriebsmittel... werden vom Betriebssystem verwaltet und den Prozessen zugänglich gemacht. Man unterscheidet zwei Arten: Wiederverwendbare Betriebsmittel Werden von Prozessen für eine bestimmte Zeit belegt und anschließend wieder freigegeben. Beispiele: CPU, Haupt- und Hintergrundspeicher, E/A-Geräte, Systemdatenstrukturen wie Dateien, Prozesstabelleneinträge,... Konsumierbare Betriebsmittel Werden im laufenden System erzeugt (produziert) und zerstört (konsumiert) Beispiele: Unterbrechungsanforderungen, Signale, Nachrichten, Daten von Eingabegeräten Betriebssysteme: Fragestunde 25

26 Wiederverwendbare Betriebsmittel Es kommt zu einer Verklemmung, wenn zwei Prozesse ein wiederwendbares Betriebsmittel belegt haben, dass vom jeweils anderen hinzugefordert wird. Beispiel: Ein Rechnersystem hat 200 GByte Hauptspeicher. Zwei Prozesse belegen den Speicher schrittweise. Die Belegung erfolgt blockierend. Prozess 1... Belege 80 GByte;... Belege 60 GByte; Prozess 2... Belege 70 GByte;... Belege 80 GByte; Wenn beide Prozesse ihre erste Anforderung ausführen bevor Speicher nachgefordert wird, ist eine Verklemmung unvermeidbar Betriebssysteme: Fragestunde 26

27 Konsumierbare Betriebsmittel Es kommt zu einer Verklemmung, wenn zwei Prozesse auf ein konsumierbares Betriebsmittel warten, das vom jeweils anderen produziert wird. Beispiel: Synchronisationssignale werden mit Hilfe der Semaphoroperation wait und signal zwischen zwei Prozessen verschickt. Prozess 1 Prozess 2 semaphore s1 = {0, NULL};... wait (&s1);... signal (&s2); semaphore s2 = {0, NULL};... wait (&s2);... signal (&s1); Jeder Prozess wartet auf ein Synchronisationssignal des anderen, das dieser aber nicht senden kann, da er selbst blockiert ist Betriebssysteme: Fragestunde 27

28 Verklemmung von Prozessen 1. Variante: Deadlock Passives Warten Prozesszustand BLOCKED 2. Variante: Livelock Aktives Warten (busy waiting oder lazy busy waiting) Prozesszustand beliebig (auch RUNNING), aber kein Fortschritt Deadlocks sind das vergleichsweise geringere Übel, da dieser Zustand eindeutig erkennbar ist und so die Basis zur Auflösung gegeben ist Betriebssysteme: Fragestunde 28

29 Agenda Prozesse Synchronisation Deadlocks Speicherverwaltung Ein-/Ausgabe Betriebssysteme: Fragestunde 29

30 Grundlegende Politiken/Strategien Platzierungsstrategie (placement policy) obligatorisch Woher soll benötigter Speicher genommen werden? Wo der Verschnitt am kleinsten/größten ist Egal, weil Verschnitt zweitrangig ist Und zusätzlich bei Ein-/Auslagerung... Ladestrategie (fetch policy) Wann sind Speicherinhalte aus dem Hintergrundspeicher in den Hauptspeicher zu laden? Auf Anforderung oder im Voraus Ersetzungsstrategie (replacement policy) Welche Speicherinhalte sind ggf. in den Hintergrundspeicher zu verdrängen, falls der Speicher knapp wird? Das älteste, am seltensten genutzte Das am längsten ungenutzte Betriebssysteme: Fragestunde 30

31 Segmentierung Hardwareunterstützung: Abbildung logischer auf physikalische Adressen logischer Adressraum physikalischer Adressraum ROM + 0x x54ffff 0x xfffff 0 + 0x RAM 0x1fffff 0x Das Segment des logischen Adressraums kann an jeder beliebigen Stelle im physikalischen Adressraum liegen. Das Betriebssystem bestimmt, wo ein Segment im physikalischen Adressraum tatsächlich liegen soll Betriebssysteme: Fragestunde 31

32 Segmentierung (2) Realisierung mit Übersetzungstabelle Segmenttabellenbasisregister Segmenttabelle Startadr. Länge a02 logische Adresse ffe0 f fff ja < + Trap: Schutzverletzung ffe1 3a02 physikalische Adresse Betriebssysteme: Fragestunde 32

33 Seitenadressierung (paging) Einteilung des logischen Adressraums in gleichgroße Seiten, die an beliebigen Stellen im physikalischen Adressraum liegen können Lösung des Fragmentierungsproblems keine Kompaktifizierung mehr nötig Vereinfacht Speicherbelegung und Ein-/Auslagerungen logischer Adressraum physikalischer Adressraum ROM Seiten (pages) Kacheln (frames) RAM Betriebssysteme: Fragestunde 33

34 MMU mit Seiten-Kacheltabelle Tabelle setzt Seiten in Kacheln um SKT Basisregister Seiten-Kacheltabelle Startadr ffe0 fxxx a logische Adresse ffe0f 12a physikalische Adresse Betriebssysteme: Fragestunde 34

35 Mehrstufige Seitenadressierung Beispiel: zweifach indirekte Seitenadressierung logische Adresse a Präsenzbit auch für jeden Eintrag in den höheren Stufen... Tabellen werden aus- und einlagerbar Tabelle können bei Zugriff (=Bedarf) erzeugt werden (spart Speicher!) Aber: Noch mehr implizite Speicherzugriffe Betriebssysteme: Fragestunde 35

36 Translation Look-Aside Buffer (TLB) Schneller Registersatz wird konsultiert bevor auf die SKT zugegriffen wird: SKT Basisregister Seiten-Kacheltabelle Startadr. ffe0 fxxx a Translation Look Aside Buffer (TLB) a0123 bfff4 ffe0f logische Adresse... ffe0f physikalische Adresse Betriebssysteme: Fragestunde 36 12a

37 Translation Look-Aside Buffer (2) Schneller Zugriff auf Seitenabbildung, falls Information im voll-assoziativen Speicher des TLB keine impliziten Speicherzugriffe nötig Bei Kontextwechseln muss TLB gelöscht werden (flush) Bei Zugriffen auf eine nicht im TLB enthaltene Seite wird die entsprechende Zugriffsinformation in den TLB eingetragen Ein alter Eintrag muss zur Ersetzung ausgesucht werden TLB Größe Intel Core i7: 512 Einträge, Seitengröße 4K UltraSPARC T2: Daten TLB = 128, Code TLB = 64, Seitengröße 8K Größere TLBs bei den üblichen Taktraten zur Zeit nicht möglich Betriebssysteme: Fragestunde 37

38 Seitenersetzung Was tun, wenn keine freie Kachel vorhanden? Eine Seite muss verdrängt werden, um Platz für neue Seite zu schaffen! Auswahl von Seiten, die nicht geändert wurden (dirty bit in der SKT) Verdrängung erfordert Auslagerung, falls Seite geändert wurde Vorgang: Seitenfehler (page fault): Trap in das Betriebssystem Auslagern einer Seite, falls keine freie Kachel verfügbar Einlagern der benötigten Seite Wiederholung des Zugriffs Problem Welche Seite soll ausgewählt werden (das Opfer )? Betriebssysteme: Fragestunde 38

39 Ersetzungsstrategien Betrachtung von Ersetzungsstrategien und deren Wirkung auf Referenzfolgen Referenzfolge Folge von Seitennummern, die das Speicherzugriffsverhalten eines Prozesses abbildet Ermittlung von Referenzfolgen z.b. durch Aufzeichnung der zugegriffenen Adressen - Reduktion der aufgezeichneten Sequenz auf Seitennummern - Zusammenfassung von unmittelbar hintereinanderstehenden Zugriffen auf die gleiche Seite Beispiel für eine Referenzfolge: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, Betriebssysteme: Fragestunde 39

40 Optimale Ersetzungsstrategie Vorwärtsabstand Zeitdauer bis zum nächsten Zugriff auf die entsprechende Seite Strategie OPT (oder MIN) ist optimal (bei fester Kachelmenge): minimale Anzahl von Einlagerungen/Ersetzungen (hier 7) Ersetze immer die Seite mit dem größten Vorwärtsabstand! Referenzfolge Kachel Hauptspeicher Kachel Kachel Kachel > > > > > Kontrollzustände Kachel 2 > > > > > (Vorwärtsabstand) Kachel 3 > > > Betriebssysteme: Fragestunde 40

41 Optimale Ersetzungsstrategie Implementierung von OPT praktisch unmöglich Referenzfolge müsste vorher bekannt sein OPT ist nur zum Vergleich von Strategien brauchbar Suche nach Strategien, die möglichst nahe an OPT kommen z.b. Least Recently Used (LRU) Betriebssysteme: Fragestunde 41

42 Least Recently Used (LRU) Rückwärtsabstand Zeitdauer, seit dem letzten Zugriff auf die Seite LRU Strategie (10 Einlagerungen) Ersetze die Seite mit dem größten Rückwärtsabstand! Referenzfolge Kachel Hauptspeicher Kachel Kachel Kontrollzustände (Rückwärtsabstand) Kachel Kachel 2 > Kachel 3 > > Betriebssysteme: Fragestunde 42

43 Least Recently Used (LRU) Vergrößerung des Hauptspeichers (4 Kacheln): 8 Einlagerungen Referenzfolge Kachel Kachel Hauptspeicher Kachel Kachel Kachel Kontrollzustände Kachel 2 > (Rückwärtsabstand) Kachel 3 > > Kachel 4 > > > Betriebssysteme: Fragestunde 43

44 Least Recently Used (LRU) Keine Anomalie Allgemein gilt: Es gibt eine Klasse von Algorithmen (Stack-Algorithmen), bei denen keine Anomalie auftritt: - Bei Stack-Algorithmen ist bei k Kacheln zu jedem Zeitpunkt eine Untermenge der Seiten eingelagert, die bei k+1 Kacheln zum gleichen Zeitpunkt eingelagert wären! - LRU: Es sind immer die letzten k benutzten Seiten eingelagert - OPT: Es sind die k bereits benutzten Seiten eingelagert, die als nächstes zugegriffen werden Problem Implementierung von LRU nicht ohne Hardwareunterstützung möglich Es muss jeder Speicherzugriff berücksichtigt werden Betriebssysteme: Fragestunde 44

45 Least Recently Used (LRU) Naive Idee: Hardwareunterstützung durch Zähler CPU besitzt einen Zähler, der bei jedem Speicherzugriff erhöht wird (inkrementiert wird) bei jedem Zugriff wird der aktuelle Zählerwert in den jeweiligen Seitendeskriptor geschrieben Auswahl der Seite mit dem kleinsten Zählerstand (Suche!) Aufwändige Implementierung viele zusätzliche Speicherzugriffe hoher Speicherplatzbedarf Minimum-Suche in der Seitenfehler-Behandlung Betriebssysteme: Fragestunde 45

46 Second Chance (Clock) So wird s gemacht: Einsatz von Referenzbits Referenzbit im Seitendeskriptor wird automatisch durch Hardware gesetzt, wenn die Seite zugegriffen wird - einfacher zu implementieren - weniger zusätzliche Speicherzugriffe - moderne Prozessoren bzw. MMUs unterstützen Referenzbits (z.b. x86: access bit) Ziel: Annäherung von LRU bei einer frisch eingelagerten Seite wird das Referenzbit zunächst auf 1 gesetzt wird eine Opferseite gesucht, so werden die Kacheln reihum inspiziert - ist das Referenzbit 1, so wird es auf 0 gesetzt (zweite Chance) - ist das Referenzbit 0, so wird die Seite ersetzt Betriebssysteme: Fragestunde 46

47 Second Chance (Clock) Implementierung mit umlaufendem Zeiger (Clock) A 1 Referenzbit A 1 I 1 B 0 I 1 B 0 H 0 C 1 H 0 C 0 G 1 D 1 G 1 D 0 F 1 E 0 F 1 an der Zeigerposition wird Referenzbit getestet - falls Referenzbit 1, wird Bit gelöscht - falls Referenzbit gleich 0, wurde ersetzbare Seite gefunden - Zeiger wird weitergestellt; falls keine Seite gefunden: Wiederholung falls alle Referenzbits auf 1 stehen, wird Second Chance zu FIFO E 0 Seite wird ersetzt Betriebssysteme: Fragestunde 47

48 Second Chance (Clock) Ablauf bei drei Kacheln (9 Einlagerungen) Referenzfolge Kachel Hauptspeicher Kachel Kachel Kachel Kontrollzustände Kachel (Referenzbits) Kachel Umlaufzeiger Betriebssysteme: Fragestunde 48

49 Second Chance (Clock) Vergrößerung des Hauptspeichers (4 Kacheln): 10 Einlagerungen Referenzfolge Kachel Hauptspeicher Kachel Kachel Kachel Kachel Kachel Kontrollzustände Kachel (Referenzbits) Kachel Umlaufzeiger Betriebssysteme: Fragestunde 49

50 Second Chance (Clock) Bei Second Chance kann es auch zur FIFO Anomalie kommen Wenn alle Referenzbits gleich 1, wird nach FIFO entschieden Im Normalfall kommt man aber LRU nahe Erweiterung Modifikationsbit kann zusätzlich berücksichtigt werden (Dirty Bit) Drei Klassen: (0,0), (1,0) und (1,1) mit (Referenzbit, Modifikationsbit) Suche nach der niedrigsten Klasse (Einsatz im MacOS) Betriebssysteme: Fragestunde 50

51 Agenda Prozesse Synchronisation Deadlocks Speicherverwaltung Ein-/Ausgabe Betriebssysteme: Fragestunde 51

52 Geräteklassen Zeichenorientierte Geräte Tastatur, Drucker, Modem, Maus,... Meist rein sequentieller Zugriff, selten wahlfreie Positionierung Blockorientierte Geräte Festplatte, Diskette, CD-ROM, DVD, Bandlaufwerke,... Meist wahlfreier blockweiser Zugriff (random access) Andere Geräte passen weniger leicht in dieses Schema Grafikkarten (insbesondere 3D-Beschleunigung) Netzwerkkarten (Protokolle, Adressierung, Broadcast/Multicast, Nachrichtenfilterung,...) Zeitgeberbaustein (Einmalige oder periodische Unterbrechungen) Betriebssysteme: Fragestunde 52

53 Polling (oder Programmierte E/A )... bedeutet aktives Warten auf ein Ein-/Ausgabegerät /* Zeichen in Kern-Puffer p kopieren */ copy_from_user (buffer, p, count); /* Schleife über alle Zeichen */ for (i=0; i<count; i++) { Pseudo-Code einer Betriebssystemfunktion zum Drucken von Text im Polling- Betrieb. /* Warte aktiv bis Drucker bereit */ while (*printer_status_reg!= READY); } /* Ein Zeichen ausgeben */ *printer_data_reg = p[i]; return_to_user (); Betriebssysteme: Fragestunde 53

54 Unterbrechungsgetriebene E/A... bedeutet, dass die CPU während der Wartezeit einem anderen Prozess zugeteilt werden kann. copy_from_user (buffer, p, count); /* Druckerunterbrechungen erlauben */ enable_interrupts (); /* Warte bis Drucker bereit */ while (*printer_status_reg!= READY); /* Erstes Zeichen ausgeben */ *printer_data_reg = p[i++]; scheduler (); return_to_user (); Code, der die E/A-Operation initiiert. if (count > 0) { *printer_data_reg = p[i]; count--; i++; } else unblock_user (); acknowledge_interrupt (); return_from_interrupt (); Unterbrechungsbehandlungsroutine Betriebssysteme: Fragestunde 54

55 DMA-getriebene E/A... bedeutet, dass die Software nicht mehr für den Datentransfer zwischen Controller und Hauptspeicher zuständig ist. Die CPU wird weiter entlastet. copy_from_user (buffer, p, count); set_up_dma_controller (p, count); scheduler (); return_to_user (); Code, der die E/A-Operation initiiert. acknowledge_interrupt (); unblock_user (); return_from_interrupt (); Unterbrechungsbehandlungsroutine Betriebssysteme: Fragestunde 55

56 UNIX Block Buffer Cache Pufferspeicher für Plattenblöcke im Hauptspeicher Verwaltung mit Algorithmen ähnlich wie bei Kachelverwaltung Read ahead: beim sequentiellen Lesen wird auch der Transfer von Folgeblöcken angestoßen Lazy write: Block wird nicht sofort auf Platte geschrieben (erlaubt Optimierung der Schreibzugriffe und blockiert den Schreiber nicht) Verwaltung freier Blöcke in einer Freiliste Kandidaten für Freiliste werden nach LRU Verfahren bestimmt Bereits freie aber noch nicht anderweitig benutzte Blöcke können reaktiviert werden (Reclaim) Betriebssysteme: Fragestunde 56

57 UNIX Block Buffer Cache (2) Schreiben erfolgt, wenn keine freien Puffer mehr vorhanden sind, regelmäßig vom System (fsflush Prozess, update Prozess), beim Systemaufruf sync(), und nach jedem Schreibaufruf im Modus O_SYNC. Adressierung Adressierung eines Blocks erfolgt über ein Tupel: (Gerätenummer, Blocknummer) Über die Adresse wird ein Hash-wert gebildet, der eine der möglichen Pufferlisten auswählt Betriebssysteme: Fragestunde 57

58 Journaled File Systems Zusätzlich zum Schreiben der Daten und Meta-Daten (z.b. Inodes) wird ein Protokoll der Änderungen geführt Alle Änderungen treten als Teil von Transaktionen auf. Beispiele für Transaktionen: Erzeugen, löschen, erweitern, verkürzen von Dateien Dateiattribute verändern Datei umbenennen Protokollieren aller Änderungen am Dateisystem zusätzlich in einer Protokolldatei (Log File) Beim Bootvorgang wird Protokolldatei mit den aktuellen Änderungen abgeglichen und damit werden Inkonsistenzen vermieden Betriebssysteme: Fragestunde 58