Rechnernetze

BETRIEBSSYSTEME
ZUSAMMENFASSUNG
3. Semester
20.03.2008
Bearbeiter:
Angelo Menconi
Thomas Kränzler
2
Rechnernetze
Inhalt
1.
Einführung in Betriebssysteme ...................................................................................................................... 4
1.1.
Definition Betriebssystem ..................................................................................................................... 5
1.2.
Eigenschaften eines Betriebssystems .................................................................................................... 6
1.3.
Arten von Betriebssystemen ................................................................................................................. 7
1.3.1.
Mainframe ......................................................................................................................................... 7
1.3.2.
Server-Betriebssysteme .................................................................................................................... 7
1.3.3.
Multiprozessor-Betriebssysteme ...................................................................................................... 8
1.3.4.
Betriebssysteme für den PC .............................................................................................................. 8
1.3.5.
Echtzeitbetriebssysteme ................................................................................................................... 8
1.3.6.
Betriebssysteme für eingebettete System ........................................................................................ 9
1.3.7.
Betriebssysteme für Chipkarten ........................................................................................................ 9
1.4.
Mehrprozessorsysteme: Art der Kopplung .......................................................................................... 10
1.5.
Computer Hardware ............................................................................................................................ 11
1.5.1.
Prozessor ......................................................................................................................................... 11
1.5.2.
Hauptspeicher ................................................................................................................................. 12
1.5.3.
Ein-/Ausgabegeräte ......................................................................................................................... 13
1.5.4.
Exkurs: Unterbrechungsmechanismen ........................................................................................... 14
1.5.5.
Bussysteme ..................................................................................................................................... 14
1.6.
Betriebssystemkonzepte ..................................................................................................................... 15
1.6.1.
Prozesse .......................................................................................................................................... 15
1.6.2.
Deadlocks ........................................................................................................................................ 16
1.6.3.
Speicherverwaltung......................................................................................................................... 17
1.6.4.
Ein-/Ausgabeverwaltung ................................................................................................................. 17
1.6.5.
Dateiverwaltung .............................................................................................................................. 18
1.6.6.
Exkurs: Vergleich Prozesshierarchie und Dateihierarchie ............................................................... 19
1.6.7.
Sicherheit ........................................................................................................................................ 19
1.6.8.
Die Shell ........................................................................................................................................... 20
1.7.
Systemaufrufe ..................................................................................................................................... 20
1.8.
Strukturen der Betriebssysteme .......................................................................................................... 21
1.8.1.
Monolithische Systeme ................................................................................................................... 21
1.8.2.
Geschichtete/Hierarchische Systeme ............................................................................................. 23
1.8.3.
Micokernel/Client-Server-Systeme ................................................................................................. 24
18. September 2007
Einführung in Betriebssysteme
2
3
1.8.4.
2.
4.
Objektorientierte Systeme .............................................................................................................. 25
Scripting ........................................................................................................................................................ 26
2.1.
Interpreter- versus Compilersprachen & Java ..................................................................................... 26
2.2.
Unix und die Unix-Shell........................................................................................................................ 27
2.3.
Die Shell als Programmablaufumgebung............................................................................................. 28
2.3.1.
Starten von Kommandos ................................................................................................................. 28
2.3.2.
Ein-/Ausgabe-Umlenkung ............................................................................................................... 29
2.3.3.
Verkettung über Pipes ..................................................................................................................... 30
2.4.
3.
Rechnernetze
Die Shell als Programmiersprache ....................................................................................................... 31
2.4.1.
Wildcard-Zeichen ............................................................................................................................ 31
2.4.2.
Shell-Variable & Variablen-Substitution .......................................................................................... 31
2.4.3.
Quoting............................................................................................................................................ 32
2.4.4.
If-Anweisung ................................................................................................................................... 33
2.4.5.
Case-Anweisung .............................................................................................................................. 34
2.4.6.
For-Schleife...................................................................................................................................... 35
2.4.7.
While-Schleife ................................................................................................................................. 36
2.4.8.
Until-Schleife ................................................................................................................................... 37
2.4.9.
Break/Continue-Anweisung ............................................................................................................ 37
System-API (application programming interface) ........................................................................................ 38
3.1.
Exkurs: Bestandteile eines Prozesses .................................................................................................. 41
3.2.
Exkurs: Systemaufruf fork() ................................................................................................................. 41
3.3.
Exkurs: Ein-/Ausgabe-Umlenkung mittels der System-API .................................................................. 42
Prozessorverwaltung – Scheduling und Dispatching .................................................................................... 43
4.1.
Zustände eines Prozesses .................................................................................................................... 43
4.2.
Grundbegriffe zur Prozessorverwaltung.............................................................................................. 45
4.3.
Prozessorverwaltung: Der Scheduler .................................................................................................. 46
4.4.
Prozessorverwaltung: Der Dispatcher ................................................................................................. 46
4.5.
Prozessorverwaltung: Die Ziele ........................................................................................................... 47
4.6.
Zuteilungsstrategien ............................................................................................................................ 47
4.6.1.
Round-Robin-Verfahren .................................................................................................................. 48
4.6.2.
Multi-Level-Priority-Verfahren ........................................................................................................ 49
4.6.3.
Multi-Level-Feedback-Verfahren .................................................................................................... 50
18. September 2007
Einführung in Betriebssysteme
3
4
Rechnernetze
1. E INFÜHRUNG IN B ETRIEBSSYSTEME
Ein Rechnersystem besteht aus folgenden 3 Komponenten (Betriebssystem läuft
auch unter Systemprogramme):

Hardware
o Physische Geräte (Schaltungen, Drähte, Stromversorgung usw.)
o Mikroarchitektur (Datenbearbeitung wie z.B. Addition von zwei
Operanden, Ergebnis wird in Registern abgelegt)
o Maschinensprache (Ergebnisse der Datenbearbeitung sind
Anweisungen wie z.B. Zugriff auf Festplatte an der Position xy)

Betriebssystem
o Schnittstelle zwischen Hardware und System- sowie
Anwendungsprogrammen
o Ziel: Reduzierung der Komplexität für Programmierer von
Systemprogrammen und Bereitstellung von Funktionen für
Anwendungsprograme
o Läuft im Kernelmodus und wird dadurch von der Hardware vor
Manipulation geschützt und hat unbeschränkten Zugriff auf die
Hardware

Systemprogramme
o Compiler, Editoren und Kommando-Interpreter zum
programmieren und ausführen von Programmen
o Unterschied zum Betriebssystem: Betriebssystem läuft im
Kernelmodus, Systemprogramme dagegen im Benutzermodus.
Auswirkung: Systemprogramme können geändert werden (User
verwendet z.B. einen anderen Compiler als den vorinstallierten)

Anwendungsprogramme
o Programme die von Usern auf dem Rechner genutzt werden (z.B.
Tabellenkalkulation, Textverarbeitung, Browser)
o Laufen ebenfalls im Benutzermodus
18. September 2007
Einführung in Betriebssysteme
4
5
Rechnernetze
1.1. D EFINITION B ETRIEBSSYSTEM
Nach Tanenbaum erfüllt das Betriebssystem zwei Funktionen:
Erweiterung der Hardware
Reduzierung der Komplexität durch Abstraktion der
Hardware. Die realen Eigenschaften der Hardware
werden versteckt.
Beispiel: Programmierer muss sich z.B. nicht mehr mit
dem Zustand des Festplattenmotors beschäftigen
sondern nur noch mit den Dateioperationen wie
lesen, schreiben, löschen usw.
Stellt dem Benutzer eine virtuelle Maschine zur
Verfügung die einfacher zu handhaben ist wie die
Hardware
Schnittstelle für den Benutzer  Top-down-Sicht
18. September 2007
Verwaltung von Ressourcen
Ressourcenverwaltung nach Zeit.
Zuteilung von Ressourcen an konkurrierende
Prozesse mittels Zeitmultiplex.
Beispiel: Belegung des Druckers bei mehreren,
gleichzeitigen Druckaufträgen
Ressourcenverwaltung nach Raum.
Zuteilung von Ressourcen an konkurrierende
Prozesse mittels Raummultiplex.
Beispiel: Aufteilung des Hauptspeichers in mehrere
Bereich damit gleichzeitig mehrere Programme
zwischengespeichert werden
Verwaltung aller Bestandteile eines komplexen
Systems  Bottom-up-Sicht
Einführung in Betriebssysteme
5
6
Rechnernetze
1.2. E IGENSCHAFTEN
EINES
B ETRIEBSSYSTEMS
Ein Betriebssystem sollte mehrere Eigenschaften erfüllen, die zum Teil
konkurrierend sind.
Leistungsfähig
Betriebssystem
Wartungsfreundlich
Zuverlässig
Benutzerfreundlich
Beispiel für konkurrierende Eigenschaften:

Leistungsfähigkeit: optimale Auslastung der Hardware und gute
Antwortzeiten

Je besser die Komponenten ausgelastet sind (z.B. CPU), desto länger sind
die Antwortzeiten (Prozesse werden nacheinander von der CPU bearbeitet)
18. September 2007
Einführung in Betriebssysteme
6
7
Rechnernetze
1.3. A RTEN
VON
1.3.1.
Eigenschaften von Mainframes
Hohe Ein- und Ausgabebandreite
Ausführung vieler Prozesse
gleichzeitig
Sehr hoher Speicher- und
Rechenbedarf
M AI N FR A M E
Einsatz von Mainframes
Frühere Netzwerkarchitektur
Heute Comeback als große WebServer, e-Commerce-Server
1.3.2.
Eigenschaften von Servern
Große PCs, Workstations oder
Mainframes
Bedienen (serve) viele Nutzer über
ein Netzwerk (client/server)
Hoher Speicher- und
Rechenbedarf (je nach Einsatz)
B ETRIEBSSYSTEMEN
Beispiele für Mainframe-OS
IBM OS/390
Siemens BS2000
S ERV E R -B ET RI E B SS YS T E M E
Einsatz von Servern
Druckdienste
Beispiele für Server-OS
Unix
Dateifreigabe
Windows Server
Webdienste uvm.
Linux
18. September 2007
Einführung in Betriebssysteme
7
8
Rechnernetze
1.3.3.
M UL T I P RO Z E SS O R -B ET RI E B SS YS T EM E
Um höhere Rechenleistung zu erzielen werden mehrere Prozessoren in
einem Computer zusammengeschalten.
Andere Bezeichnungen für Multiprozessor-System:

Parallelcomputer

Multicomputer

Multiprozessor-Computer
1.3.4.
B E T RI E BS SY ST E M E
FÜ R D E N
PC
Betriebssystem für einen Personalcomputer. Hauptaufgabe ist die
Bereitstellung einer Schnittstelle für den Benutzer.
Eigenschaften von PCs
(meist grafische) Schnittstelle zum
Benutzer
Angemessene Speicher- und
Rechenausstattung
Einsatz von PCs
Büro und Zuhause
Beispiele von PC-OS
Windows XP, Vista
Textverarbeitung,
Tabellenkalkulation, Internet usw.
Suse Linux, Apple MacOS
1.3.5.
E CH T ZEI T B E T RI E BS SY S T E M E
Zeit als wichtiger Parameter bei der Ressourcenvergabe.
Beispiel: Schweißroboter auf einer Produktionslinie – wenn der Roboter
zu früh oder zu spät anfängt mit schweißen wird das Produkt zerstört!
Unterscheidung in zwei Untergruppen:

Hartes Echtzeitsystem: Aktion muss unter allen Umständen zu
einem bestimmten Zeitpunkt stattfinden

Weiches Echtzeitsystem: Toleranz beim Zeitpunkt der Aktion
(z.B. digitale Audio- und Multimediasysteme)
18. September 2007
Einführung in Betriebssysteme
8
9
Rechnernetze
1.3.6.
B E T RI E BS SY ST E M E
S YST E M
FÜ R E I N GE B ET T E T E
Vorrangig für kleinere Systeme gedacht bei denen es weniger auf die Einund Ausgabebandbreite ankommt.
Eigenschaften von Embedded
Systemen
Geringe Größe
Geringe Speicher- und
Rechenausstattung
Geringer Stromverbrauch
Einsatz von Embedded Systemen
Beispiele von Embedded-OS
Mobiltelefone
Thin-Clients
PalmOS
Windows CE
PDA
1.3.7.
B E T RI E BS SY ST E M E
FÜ R
C HI P K A RT EN
Die kleinsten Betriebssysteme laufen auf Smartcards. Durch den sehr
stark begrenzten Platz für Speicher- und Rechenleistung beherrschen die
Betriebssysteme oft nur eine bzw. wenige Aktionen (z.B. bezahlen,
abheben).
Es gibt auch Smartcards mit einem auf Java basierenden Betriebssystem,
d.h. die Karten besitzen einen Java Interpreter (Java Virtual Machine).
18. September 2007
Einführung in Betriebssysteme
9
1
0
Rechnernetze
1.4. M EHRPROZESSORS YSTEME : A RT
DER
K OPPLUNG
Bei eng gekoppelten Mehrprozessorsystemen (engl.: tightly-coupled multiprocessor system) greifen wenige (derzeit bis zu 16) Zentralprozessoren auf
einen geteilten großen Arbeitsspeicher zu. Sie befinden sich an einem Ort
und benutzen einen gemeinsamen Speicherbus.
Bei lose gekoppelten Mehrprozessorsystemen (engl.: loosely-coupled multiprocessor system) verfügt jeder Zentralprozessor über einen eigenen
(lokalen) Speicher. Die Prozessoren kommunizieren über geteilte
Verbindungen in der Form lokaler Netze oder Clusternetze.
18. September 2007
Einführung in Betriebssysteme
10
1
1
Rechnernetze
1.5. C OMPUTER H ARDWARE
Das Betriebssystem ist sehr eng mit der Hardware eines Rechners verbunden,
es verwaltet z.B. die Ressourcen oder erweitert den Befehlssatz eines
Rechners. Darum muss ein Betriebssystem über die Hardware genau
Bescheid wissen, und darüber wie ein Programmierer auf diese zugreifen
kann.
1.5.1.
P RO ZE S SO R
Die CPU ist das Gehirn des Computers. Sie holt sich Befehle aus dem
Speicher, dekodiert diese und führt sie aus.
(Holen Dekodieren  Ausführen)
Um den Durchsatz einer CPU zu steigern, also die Möglichkeit mehrere
Befehle gleichzeitig zu bearbeiten, gibt es zwei Ansätze:

Pipeline-Architektur: eine CPU besitzt (mehrere) getrennte Hol-,
Dekodier-, und Ausführungseinheiten die zu einer Pipeline
zusammengefasst werden.
Es gibt unterschiedliche Ausprägungen in Länge und
Komplexität von Pipelines.
Beispielgrafik: eine dreistufe Pipeline mit getrennten Einheiten.
Es kann Befehl „n“ ausgeführt werden, während Befehl „n+1“
dekodiert wird und Befehl „n+2“ gerade geholt wird.

Superskalare CPU: bei der superskalaren CPU gibt es mehrere
Ausführungseinheiten die auf gewisse Befehle spezialisiert sind
(z.B. für Integer-Arithmetik, Gleitkomma-Arithmetik, boolesche
Operationen usw.).
Es werden gleichzeitig mehrere Befehle aus dem Speicher
geholt, dekodiert und in einem Puffer abgelegt.
Sobald eine Ausführungseinheit bereit ist, sieht diese im Puffer
nach zu bearbeitenden Befehlen nach. Sind welche vorhanden,
werden diese aus dem Puffer geladen und ausgeführt.
Prozessoren besitzen zwei Modi:

Kernel-Modus: voller Zugriff auf die Hardware

User-Modus: für Benutzerprogramme, nur ein Teil der
Hardware und der Befehle ist verfügbar
18. September 2007
Einführung in Betriebssysteme
11
1
2
Rechnernetze
1.5.2.
H AU P T S P EI C H E R
Der Speicher dient als Puffer, Zwischenspeicher für Programme und die
langfristige Speicherung von Daten. Idealerweise sollte der Speicher
genauso so schnell sein wie die CPU, damit diese bei der Bearbeitung
von Befehlen nicht ausgebremst wird.
Da schneller Speicher aber extrem teuer ist, gibt es eine
Speicherhierarchie.
Absteigend wird, dem Verwendungszweck entsprechend, langsamerer
und günstigerer Speicher mit höherer Speichergröße gewählt:
18. September 2007
Einführung in Betriebssysteme
12
1
3
Rechnernetze
1.5.3.
E I N -/A U S GA B E GE R ÄT E
Wie in der Abbildung oben zu sehen, bestehen Ein-/Ausgabegeräte (z.B.
Monitor, Tastatur, Maus, Festplatte usw.) aus zwei Teilen:

Controller: Chip auf der Hauptplatine zur Kontrolle des Geräts.
Der Chip erhält die Befehle vom Betriebssystem.

Geräte: das Gerät selber, z.B. die Tastatur
Der Controller ist dafür zuständig, die komplizierte Steuerung eines
Geräts, durch eine Schnittstelle zum Betriebssystem zu vereinfachen.
Beispiel: Benutzer will eine Datei öffnen und klickt diese dazu an.

Befehl von Betriebssystem an Controller: Lies die Datei „xy“.

Befehl von Controller an Festplatte:
o Umwandlung des Befehls in Zylinder, Spur und Sektor
o Prüfung ob fehlerhafte Sektoren ausgelagert wurden
o Momentane Position des Lesekopfs ermitteln
o Steuerung des Lesekopfs an die richtige Position
o Warten bis Lesekopf an Position und Lesevorgang
starten
o Usw.
Da es viele unterschiedliche Controllertypen gibt, benötigt man für jeden
Typ eine Software um diesen zu steuern.
Diese Software nennt man Gerätetreiber.
Der Gerätetreiber wird im Kernelmodus des Betriebssystems integriert
und spricht mit dem Controller, gibt ihm die Befehle und empfängt die
Antworten.
Betriebssystem
Gerätetreiber
Controller
Gerät
Eine Variante ist das der Gerätetreiber zur Laufzeit des Betriebssystems
geladen und gebunden wird. In diesem Fall ist kein Neustart notwendig.
Diese Variante nennt sich Hot-Plug und wird z.B. von USB-Geräten
verwendet.
18. September 2007
Einführung in Betriebssysteme
13
1
4
Rechnernetze
1.5.4.
E XK U RS : U N T E R BR E CH UN GS M E CH AN I S M EN
Moderne Betriebssysteme steuern Geräte mit Unterbrechungsmechanismen (Interrupts). Bei diesem Verfahren erteilt der
Gerätetreiber dem Gerät Befehle und signalisiert die Fertigstellung mit
einer Unterbrechung. Das Verfahren läuft folgendermaßen ab:
1.
2.
3.
Treiber erteilt dem Controller Befehle, Controller startet Gerät
Controller signalisiert dem Interrupt-Controller die
Fertigstellung der Befehle
CPU behandelt die Unterbrechung des Geräts und erkennt das
das Geräte für die nächsten Befehle frei ist.
(a)
(b)
Der Unterbrechungsmechanismus ermöglicht der CPU laufende
Befehlsbearbeitungen zu unterbrechen, z.B. bei Fertigmeldung eines
Geräts (siehe oben), Aufruf von Systemaufrufen (Traps) oder Ablauf
eines Zeitintervalls.
1.5.5.
B U SS YS T EM E
Aus Performancegründen besitzen moderne Hauptplatinen viele Busse
die unterschiedliche Geräte anbinden. Auf folgender Abbildung sieht
man z.B. 8 unterschiedliche Busse (Cache, Lokaler Bus, Speicherbus, PCI,
SCSI, USB, IDE, ISA):
18. September 2007
Einführung in Betriebssysteme
14
1
5
Rechnernetze
1.6. B ETRIEBSSYSTEMKONZEPT E
1.6.1.
P RO ZE S S E
Ein Prozess ist ein in Ablauf befindliches Programm.
Jedem Prozess wird ein Adressraum zugeordnet, in dem die zur
Ausführung benötigten Informationen liegen:

das ausführbare Programm

die Programmdaten

Stack

weitere Register

weitere Informationen die zur Ausführung benötigt werden
Die gesamte ausführbare Software und das Betriebssystem auf einem
System werden als eine Menge von Prozessen organisiert.
Ein Prozessor kann immer nur einen Prozess gleichzeitig bearbeiten.
Moderne Betriebssysteme besitzen Verfahren um die CPU-Rechenzeit
unter Prozessen so aufzuteilen, dass eine Quasiparallelität entsteht
(dem Benutzer kommt es vor als würden die Prozesse gleichzeitig
bearbeitet werden).
Dazu wurde die Möglichkeit entwickelt Prozesse nur teilweise
auszuführen, zu unterbrechen, und später wieder aufzusetzen und
fortzuführen, was im Prozessmodell beschrieben wird.
Das Prozessmodell beschreibt die drei wesentlichen Zustände eines
Prozesses:

WARTEND: Der Prozess wartet auf die Zuteilung eines
Prozessors

LAUFEND: Der Prozess ist aktuell einem Prozessor zugeordnet
und läuft ab.

UNTERBROCHEN: Der Prozess wurde durch einen anderen
Prozess oder die CPU unterbrochen.
Um die CPU-Rechenzeit aufzuteilen gibt es unterschiedliche Ansätze:

Zeitscheibenverfahren

Scheduling

Dispatcher

uvm.
Gesteuert werden Prozesse durch Signale. Signale funktionieren im
Softwarebereich Analog zu den Interrupts im Hardwarebereich.
Prozesse können diverse Systemaufrufe durchführen, wie z.B.:

Erzeugung und Beendigung von Prozessen

Anfordern oder Freigeben von Speicher
18. September 2007
Einführung in Betriebssysteme
15
1
6
Rechnernetze
Erzeugt ein Prozess weitere Prozesse entsteht eine Prozesshierarchie.
Die Kommunikation zwischen Prozessen die in solch einer Beziehung
zueinander stehen nennt man Interprozesskommunikation.
1.6.2.
D E A D LO CK S
Ein Deadlock beschreibt die Situation wenn zwei oder mehrere Prozesse
sich gegenseitig blockieren.
Eine Menge von Prozessen ist dann blockiert, wenn jeder Prozess in
dieser Menge auf ein Ereignis wartet das nur von einem anderen Prozess
ausgelöst werden kann (Abhängigkeit, siehe Beispiel unten).
Tritt ein Deadlock auf, können die Prozesse nicht mehr weiterarbeiten.
18. September 2007
Einführung in Betriebssysteme
16
1
7
Rechnernetze
1.6.3.
S P EI C H ERV E RW A L T UN G
Im Hauptspeicher (Arbeitsspeicher) werden ausführbare Programme
gespeichert. Moderne Betriebssysteme erlauben es, gleichzeitig mehrere
Programme im Hauptspeicher zu speichern.
Damit sich die verschiedenen Programme und das Betriebssystem im
Hauptspeicher nicht gegenseitig stören gibt es Schutzmechanismen.
Diese Schutzmechanismen stecken in der Hardware, werden aber vom
Betriebssystem verwaltet.
Neben den Schutzmechanismen verwaltet das Betriebssystem auch die
Adressräume der Prozesse.
Jeder Prozess erhält einen eigenen Adressraum von 0 bis Obergrenze xx.
Für die Problematik, dass der Adressraum eines Prozesses größer als der
Hauptspeicher ist, wurde der virtuelle Speicher eingeführt.
Beim virtuellen Speicher werden der Hauptspeicher und der
Festplattenspeicher zusammen verwaltet. Das Betriebssystem kann Teile
von einem Speicher zum anderen – je nachdem wie es gerade günstig ist.
1.6.4.
E I N -/A U S GA B EV ER W A L T UN G
Ein Betriebssystem verfügt über ein Ein-/Ausgabe-Subsystem das die
Geräte (z.B. Tastatur, Maus, Monitor, Drucker) organisiert.
Es gibt Software die geräteunabhängig ist und für somit für alle Ein/Ausgabegeräte passt, und spezielle Software wie Gerätetreiber die für
ein Gerät programmiert ist.
18. September 2007
Einführung in Betriebssysteme
17
1
8
Rechnernetze
1.6.5.
D AT EI V E RW A LT U N G
Um Daten zu speichern unterstützen Betriebssysteme das Konzept der
Verzeichnisse. In Verzeichnissen werden Dateien gruppiert.
Um Verzeichnisse zu erstellen, zu löschen, sowie Dateien in
Verzeichnissen zu erstellen, zu löschen, usw., werden Systemaufrufe
bereitgestellt. Ein Verzeichnis kann sowohl Daten, als auch weitere
Verzeichnisse enthalten. Dadurch entsteht eine Hierarchie die
Dateisystem genannt wird.
Der Weg durch das Verzeichnis beginnt beim Wurzelverzeichnis (root
directory) und geht bis zum gewünschten Verzeichnis bzw. der
gewünschten Datei. Dieser Weg wird Pfad genannt und wird
folgendermaßen dargestellt (erster Schrägstrich steht für das
Wurzelverzeichnis):
/faculty/prof.brown/courses/cs101
Jedem Prozess ist ein aktuelles Arbeitsverzeichnis zugeordnet. Dieses
Arbeitsverzeichnis ist für den Prozess wie das Wurzelverzeichnis.
Ist z.B. /faculty/prof.brown das Arbeitsverzeichnis eines Prozesses, dann
reicht der Pfadname courses/cs101 aus, um dorthin zu gelangen.
Durch einen Systemaufruf mit einem Pfad als Argument, kann das
Arbeitsverzeichnis eines Prozess geändert werden.
Unter UNIX können Daten auf entfernbare Medien wie Disketten oder
CD´s nicht ohne weiteres benutzt werden. Dazu müssen diese Medien
erst in das Dateisystem integriert werden. Diesen Vorgang nennt man
mounten.
18. September 2007
Einführung in Betriebssysteme
18
1
9
Rechnernetze
1.6.6.
UN D
E XK U RS : V E R GL EI C H P RO Z E S SHI E RA R CHI E
D AT EI HI E RA R CHI E
Organisationsform
Organisationstiefe
Dauerhaftigkeit
Berechtigungen
Prozesshierarchie
Baumstruktur
2-3 Ebenen
Kurzlebig, max. wenige Minuten
Nur Vaterprozess auf Kindprozess
Kommunikation
Über Pipes
Verzeichnishierarchie
Baumstruktur
4-6 Ebenen und mehr
Langlebig, mehrere Jahre
Berechtigungsstufen für viele User
(siehe Thema Sicherheit)
Eine Pipe ist ein unidirektionaler Kanal zwischen zwei Prozessen.
Wenn Prozess 1 Daten an Prozess 2 senden möchte, schreibt er sie in die
Pipe, so als ob diese eine Ausgabedatei wäre.
Prozess 2 wiederum liest die Daten aus der Pipe wie aus einer
Eingabedatei.
Es gibt als eine sehr starke Ähnlichkeit zwischen dem normalen Lesen
und Schreiben einer Datei und der Kommunikation über eine Pipe.
Nur anhand eines Systemaufrufs erkennt ein Prozess, dass die Daten in
eine Pipe geschrieben werden, bzw. aus einer Pipe kommen.
1.6.7.
S I C HE R HEI T
Das Betriebssystem ist auch dafür zuständig Dateien vor nicht
berechtigtem Zugriff zu schützen. Hierzu arbeiten Betriebssysteme mit
verschiedenen Autorisierungsstufen.
Beispiel aus UNIX:

Schutz durch 9-Bit Code
o 3 Gruppen von 3-Bits: read, write, execute
o 3 Gruppen: Eigentümer, Gruppe, alle Anwender
o „-“ steht für: keine Berechtigung
o Beispiel: rwx r-x --x
18. September 2007
Einführung in Betriebssysteme
19
2
0
Rechnernetze
1.6.8.
D I E S H EL L
Ist nicht Teil des Betriebssystems (gehört in den Bereich
Systemsoftware). Sie ist aber die wichtigste Schnittstelle zwischen dem
Benutzer am Terminal und dem Betriebssystem, wenn es keine grafische
Oberfläche gibt.
Die Shell nutzt sehr stark die Eigenschaften des Betriebssystems wie
Systemaufrufe und Pipes, und besitzt Programmierspracheneigenschaften.
1.7. S YSTEMAU FRUFE
Systemaufrufe sind die Schnittstelle zwischen dem Betriebssystem und den
Benutzerprogrammen.
Systemaufrufe funktionieren wie Methodenaufrufe: das Benutzerprogramm führt
einen Systemaufruf auf, wartet bis dieser bearbeitet ist und geht dann im
Programmcode weiter.
Grund für Systemaufrufe ist die Trennung zwischen dem Betriebssystem im
Kernelmodus und den Benutzerprogrammen im Benutzermodus. Will ein
Benutzerprogramm eine Aufgabe erfüllen die nur im Kernelmodus möglich ist
(z.B. Zugriff auf die Hardware), führt es einen Systemaufruf durch.
Der Prozess bleibt ständig im Benutzermodus (Schutz des Systems).
1.
4.
5.
6.
Parameter werden im Stack abgelegt
Aufruf der Bibliotheksfunktion (system call) „read“
Systemaufruf wird im Register abgelegt
TRAP-Funktion wird ausgeführt zum Wechsel von Benutzermodus in
Kernelmodus (Betriebssystem übernimmt die Kontrolle)
7. Systemaufruf wird zur Bearbeitung geholt
8. Systemaufruf wird gestartet und bearbeitet
9. Nach Bearbeitung geht Kommando an die Bibliothek zurück die TRAP
ausgeführt hat
10. Bibliothek kehrt zum Benutzerprogramm zurück
11. Benutzerprogramm muss Systemaufruf beenden indem Stack geräumt wird
18. September 2007
Einführung in Betriebssysteme
20
2
1
Rechnernetze
1.8. S TRUKTUREN
DER
B ETRIEBSSYSTEME
Die Struktur eines Betriebssystems beschreibt den inneren Aufbau wie z.B.
die Anordnung des Programmcodes, der Prozeduren usw. Im Wesentlichen
geht es dabei um die Struktur des Kernels.
Ein Kernel hat meist folgenden Aufgaben:
1.8.1.

Speicherverwaltung

Prozessverwaltung

Geräte- und Hardwareverwaltung

Schnittstelle für Treiber oder Anwendungsprogramme

Dateisystemverwaltung
M O N O LI T HI SC H E S Y ST E M E
Organisationsform ist die „große Masse“ ohne Struktur. Das
Betriebssystem ist eine Menge von Prozeduren dich sich gegenseitig
aufrufen können. Jede Prozedur hat, wie eine Methode in der
Programmierung, eine Schnittstelle in Form von Parametern und
Rückgabewerten (Ergebnisse).
Monolithische Systeme bringen alle obengenannten Kernel-Funktionen,
wie z.B. Treiber, im Kernel unter.
Das hat folgende Vor- und Nachteile:
Vorteile
effiziente Kommunikation im Kern
Hardwarezugriffe jederzeit und unmittelbar
durchführbar (privilegierter Kernelmodus)
18. September 2007
Nachteile
kein Zugriffsschutz zwischen den Komponenten
Undurchsichtige, interne Struktur
(änderungsunfreundlich, fehleranfällig)
Einführung in Betriebssysteme
21
2
2
Rechnernetze
18. September 2007
Einführung in Betriebssysteme
22
2
3
Rechnernetze
1.8.2.
G E S CHI C HT ET E /H I E RA RC HI S CH E S Y ST E M E
Das Betriebssystem wird in Schichten aufgebaut, wobei jede Schicht auf
die darunterliegende aufbaut.
Vorteile
Schutz zwischen verschiedenen BS-Teilen
Interne Strukturierung
18. September 2007
Nachteile
Mehrfacher Schutzraumwechsel ist teuer
Unflexibler und nur einseitiger Schutz (von unten
nach oben)
Einführung in Betriebssysteme
23
2
4
Rechnernetze
1.8.3.
M I CR O K E RN E L /C LI E N T -S E RV ER -S Y ST E M E
Der Ansatz der Client-Server-Systeme ist es, möglichst alle
Funktionalitäten aus dem Kernel auszulagern. Damit bleibt nur ein
Mikrokern übrig.
Dazu werden die Funktionen in Benutzerprogrammen implementiert
(Server), die von Benutzerprozessen (Client) angesprochen werden.
Ähnlich der Kommunikation in einem Netzwerk wartet der Client dann
auf eine Antwort (Acknowledgement) des Servers.
Der Kernel kümmert sich dann nur um folgende Aufgaben:

einfaches Prozessmanagement

einfaches Speichermanagement

effiziente Wege zur Inter-Prozess-Kommunikation (IPC)
Das hat folgende Vor- und Nachteile:
Vorteile
Gute Modularisierung durch Trennung der Server
Schutz der Komponenten voreinander
(stürzt ein Server ab, läuft das System weiter)
18. September 2007
Nachteile
Kommunikation zwischen Modulen ist teuer
Einführung in Betriebssysteme
24
2
5
Rechnernetze
1.8.4.
O B J EK T O RI EN T I E RT E S YST E M E
Vorteile
Schutz auf mehreren Ebenen (Sprache, Code-Prüfung,
Adressraum)
Modularisierung und Effizienz möglich
18. September 2007
Nachteile
Komplexes Sicherheitsmodell
Einführung in Betriebssysteme
25
2
6
Rechnernetze
2. S CRIPTING
Skriptsprachen sind Programmiersprachen, die vor allem für kleine, überschaubare
Programmieraufgaben gedacht sind. Skriptsprachen sind Interpretersprachen.
Häufig werden sie von Administratoren zur Automatisierung bestimmter Aufgaben
verwendet:

Administration von Betriebssystemen

Benutzerverwaltung, Anmeldeskripte

Netzwerkinstallationen
2.1. I NTERPRETER J AVA
Interpretersprache
Quellcode wird direkt, Zeile für Zeile gelesen,
analysiert und ausgeführt
Keine Compilier- und Linkzeit
Langsam, da Quellcode erst interpretiert werden
muss
Schneller Korrektur- / Test-Zyklus
Beispiele: DOS Batch-Prozessor, UNIX Shell, OS/2
REXX, JavaScript, JScript, VBScript
VERSUS
C OMPILERS PRACHEN &
Compilersprache
Quellcode wird compiliert und gelinkt. Entstandenes
Programm kann ausgeführt werden
Compilier- und Linkzeit nötig
Schnell, da Programm bereits compiliert und Code
damit schon in Maschinensprache vorliegt
langsame Korrektur- / Test-Zyklus
C, C++, Pascal
Java vereint die Funktionen von Interpreter- und Compilersprachen.
Warum das funktioniert erklärt folgender Artikel:
„Java ist fast eine Interpretersprache. Das "fast" ist das Neue an Java. Java
interpretiert keinen Quellcode sondern einen Bytecode. Dieser sieht auf den
ersten Blick aus wie Maschinencode. Er ist es auch, aber nur für die Virtuelle
Java Maschine. Dieser Bytecode muss natürlich nicht vom Programmierer
geschrieben werden. Er wird vom Java-Compiler erzeugt. Der Interpreter
führt ihn dann aus, indem er die systemspezifischen Befehle ausführt.“
18. September 2007
Scripting
26
2
7
Rechnernetze
2.2. U NIX
UND DIE
U NIX -S HELL
UNIX ist ein Multi-User- und Multitasking-Betriebssystem. Es baut auf dem
Schichtenmodell auf. In diesem besitzt nur der Kernel Zugriff auf die
Hardware. Die Schnittstelle vom Benutzer zur Hardware läuft über SystemCalls, wodurch die Benutzerprozesse im Kernelmodus laufen.
Die Unix-Shell ist die Benutzerschnittstelle in welcher der Benutzer
Kommandos eintippt, die der Computer dann sofort ausführt. Man spricht
darum auch von einem Kommandozeileninterpreter.
Die meisten gängigen Unix-Shells bieten die folgenden Funktionen:

Starten von Kommandos (2.3.1)

Dateinamen-Wildcards (globs) als Kommandoargumente (2.3.4)

Bedingungen (if, case) und Schleifen (while, for)

interne Kommandos (cd, read)

interne Variablen ($HOME)

Manipulation der Umgebungsvariablen für die neuen Prozesse

Ein-/Ausgabeumlenkung (2.3.2)

Verkettung über Pipes (Starten mehrerer Prozesse) (2.3.3)

Starten von Prozessen im Hintergrund
18. September 2007
Scripting
27
2
8
Rechnernetze
2.3. D IE S HELL
ALS
P ROGRAMMABLAUFUMGEBUN G
Eigenschaften von UNIX als Programmablaufumgebung:

Programme sind ausführbare Dateien

Prozesse sind Programme in Ausführung

Prozesse werden von anderen Prozessen mittels „fork“-Systemcall
erstellt

Programme werden mittels „exec“-Systemcall ausgeführt
Die UNIX-Shell ist ein interaktiver Kommandozeileninterpreter:

Liest Befehlszeile, interpretiert sie als Befehl

Erzeugt einen Kindprozess mittels „fork“

Kindprozess führt den Befehl mittels „exec“ aus

Anschließend Aufforderung zur weiteren Eingabe (neue
Befehlszeile)
2.3.1.
S T AR T EN
VON
K O M MA N DO S
Bei der synchronen Ausführung wird ein Befehl nach dem anderen
eingegeben und bearbeitet. Erst nach der Ausführung eines Befehls
erscheint wieder die Eingabeaufforderung.
Bei der asynchronen Ausführung können mittels „&“ mehrere Befehle
nacheinander eingegeben werden, da die Eingabeaufforderung sofort
erscheint (während der zuerst eingegebene Befehl im Hintergrund
ausgeführt wird).
Befehlszeichen für einfache Verknüpfung von Befehlen: prog1 ; prog2
Beispiel: sleep 240 ; who
Befehle können auch durch UND bzw. ODER verknüpft werden
(bedingte Ausführung). Dadurch wird die Ausführung weiterer Befehle
vom Ergebnis des vorigen Befehls abhängig.
Befehlszeichen für UND: prog1 && prog 2
(prog2 wird nur bei Erfolg (return code rc=0) von prog1 ausgeführt)
Befehlszeichen für ODER: prog 1 || prog2
(prog2 wird nur bei Misserfolg von prog1 (rc <> 0) ausgeführt)
18. September 2007
Scripting
28
2
9
Rechnernetze
2.3.2.
E I N -/A U S GA B E -U M L EN K UN G
UNIX verfügt über drei Standard Ein- und Ausgabegeräte. Das sind die
sogenannten Standard-Deskriptoren, die über eine Nummer eindeutig
identifizierbar sind.
• Standardausgabe
• Bildschirm
1
• Standardfehlerausgabe
• Bildschirm
2
• Standardeingabe
• Tastatur
0
Ein- und Ausgaben können umgelenkt werden um so z.B. die Ausgabe
direkt in eine Datei zu speichern (Logfile) oder die Eingabe aus einer
bereits vorhandenen Datei zu lesen (z.B. Kundenstamm). Auch eine
Umlenkung auf das Netzwerk ist möglich, um so z.B. mit einem Server zu
kommunizieren.
Befehlszeichen für die Umlenkung:
Aufgabe
Umlenkung der Standardausgabe
Umlenkung der Standardfehlerausgabe
Umlenkung der Standardeingabe
18. September 2007
„>“ bzw. „<“
Befehl
Prog > file oder Prog >> file (wird hinten angehängt,
keine Überschreibung bereits vorhandener Daten)
Prog 2 > file
Prog < file
Scripting
29
3
0
Rechnernetze
2.3.3.
V ERK ET T UN G
ÜB E R
P I P ES
Die Pipe bezeichnet einen uni- oder bidirektionalen Datenstrom
zwischen zwei Prozessen nach dem „First In – First Out“-Prinzip.
Unter UNIX ist die Pipe ein Standardmittel zur Verknüpfung zweier
Prozesse. Dabei führt der eine Prozess seine Standardausgabe dem
Nachfolger als Standardeingabe zu.
Befehlszeichen für die Verkettung über Pipes: Befehl 1 | Befehl 2
A UNIX pipe after forking
(pp[1] = Standardausgabe, pp[0] = Standardeingabe).
Es gibt zwei Arten von Pipes: die anonyme und die named Pipe.
Anonyme Pipe
Nur bidirektionale Kommunikation möglich
Kommunikation nur zw. verwandten Prozessen
(parent process/child process)
Erzeugung: pipe()
Wird mit close() vom System entfernt
Schreib-/Lesezugriff: read()/write() Systemaufrufe
Named Pipe
Unidirektionale Kommunikation möglich
Kommunikation zw. beliebigen Prozessen, z.B. auch
über ein Netzwerk
Jeder Prozess kann Pipe über deren Namen benutzen
Erzeugung: mknod(), Zugriff: open()
Ist permanent im System vorhanden
Schreib-/Lesezugriff: read()/write() Systemaufrufe
int pipe(int zipfel[2]);
Es werden mit dem Aufruf von pipe zwei Dateihandles erzeugt, die Sie nach dem Aufruf in dem
Parameter zipfel finden. zipfel[0] enthält das Ende zum Lesen und zipfel[1] enthält das Ende
zum Schreiben in die Pipe. Als nächstes erfolgt typischerweise ein Aufruf von fork(). Dann
übernimmt der Vater das eine und das Kind das andere Ende der Pipe und schließt das jeweils
andere, je nach dem, wer von beiden Datenproduzent und wer Datenkonsument ist. Der
Produzent benutzt write() und der Konsument read(). Beide Enden der Pipe müssen separat per
close() geschlossen werden.
18. September 2007
Scripting
30
3
1
Rechnernetze
2.4. D IE S HELL
ALS
P ROGRAMMIERSPRACHE
Die Shell ist nicht nur einfach ein Befehlsempfänger, sondern auch eine
Programmiersprache. Gemischt mit der Kombinierbarkeit der UNIX-Befehle
entsteht die Möglichkeit, auch komplexere Abläufe zu programmieren.
Folgende Programmsprachelemente bietet die Shell:

Variablen

Kontrollstrukturen (if, Schleifen mit for und while)

Zusammenfassung von Befehlen in Skripten (Pedant zu Quelldatei)

Skripte können wie ein Programm direkt ausgeführt werden
2.4.1.
W I L D C AR D -Z EI C H EN
Wildcards sind Platzhalter für Zeichen bzw. Zeichenfolgen. Sie werden
z.B. für Dateiselektionen und -operationen eingesetzt. Im Internet
unterstützen auch viele Suchmaschinen diese Wildcards.

„?“ steht genau für ein beliebiges Zeichen
Beispiel: a?tion (würde das deutsche 'Aktion' als auch den
englischen Begriff 'action' finden)

„*“ (auch Asterisk genannt) steht für eine Zeichenfolge
Beispiel: invest* (würde Wörter wie Investition, Investment,
Investor, investieren etc. finden)
2.4.2.
S H EL L -V A RI A B L E & V A RI A B L EN S UB ST I T UT I O N
Es gibt eine Reihe vordefinierter Variablen, deren Benutzung ein
wesentlicher Bestandteil des Shell-Programmierens ist. Die wichtigsten
eingebauten Shell-Variablen sind:



n Aufrufparameter mit der Nummer n, n <= 9
* Alle Aufrufparameter als 1 String ("$*" == "$1 $2 $3 ...")
@ Alle Aufrufparameter als einzelne Strings ("$@" == "$1"
"$2" "$3" ...)




#
?
$
!
Anzahl der Aufrufparameter
Rückgabewert des letzten Kommandos
Prozessnummer der aktiven Shell
Prozessnummer des letzten Hintergrundprozesses
Unter Variablen-Substitution versteht man verschiedene Methoden, um
die Inhalte von Variablen zu benutzen. Im Folgenden zwei oft benutze
Methoden:

Variable=Wert
Setzt die Variable auf den Wert

${Variable}
Nutzt den Wert der (Shell-)Variable
Beispiel: $7 (Aufrufparameter 7 wird
genutzt), $dir (Wert von dir)
18. September 2007
Scripting
31
3
2
Rechnernetze
2.4.3.
Q UO T I N G
Ouoting behandelt das Thema in der Shell ähnlich aussehenden Zeichen,
völlig unterschiedliche Bedeutungen haben. Das Quoten dient dazu,
Zeichen mit einer Sonderbedeutung vor der Shell zu „verstecken“.
Dies kann z.B. notwendig sein wenn ein Sonderzeichen in einem String
eingesetzt werden soll, oder einfach per „echo“-Befehl auf der
Standardausgabe angezeigt werden soll.
Die folgenden Zeichen haben eine spezielle Bedeutung innerhalb der
Shell:

;
Befehls-Trennzeichen

&
Hintergrund-Verarbeitung

()
Befehls-Gruppierung

|
Pipe

<>&
Umlenkungssymbole

*?[]~+-@!
Meta-Zeichen für Dateinamen

` ` (Backticks)
Befehls-Substitution

$
Variablen-Substitution

[newline] [space] [tab]Wort-Trennzeichen
Die folgenden Zeichen können zum Quoten verwendet werden:

" " (Anführungszeichen) Alles zwischen diesen Zeichen ist
buchstabengetreu zu interpretieren. Ausnahmen sind folgende
Zeichen, die ihre spezielle Bedeutung beibehalten: $ ` "

' ' (Ticks) Alles zwischen diesen Zeichen wird wörtlich
genommen, mit Ausnahme eines weiteren ' und \.

\ (Backslash) Das Zeichen nach einem \ wird wörtlich
genommen. Anwendung z. B. innerhalb von " ", um ", $ und ` zu
entwerten. Häufig verwendet zur Angabe von Leerzeichen
(space) und Zeilenendezeichen, oder um ein \-Zeichen selbst
anzugeben.
18. September 2007
Scripting
32
3
3
Rechnernetze
2.4.4.
I F -A N W EI SU N G
Die if-Anweisung in der Shell funktioniert genau so wie in anderen
Programmiersprachen. Sie testet eine Bedingung auf Wahrheit und
macht davon den weiteren Ablauf des Programms abhängig.
18. September 2007
Scripting
33
3
4
Rechnernetze
2.4.5.
C A S E -A N W EI S UN G
Auch die case-Anweisung ist vergleichbar in vielen anderen Sprachen
vorhanden. Sie dient, ähnlich wie die if-Anweisung, zur Fallunterscheidung. Allerdings wird hier nicht nur zwischen zwei Fällen
unterschieden (Entweder / Oder), sondern es sind mehrere Fälle
möglich.
Wenn der Wert mit dem Muster1 übereinstimmt, wird die
entsprechende Befehlsgruppe (Befehle1) ausgeführt, bei
Übereinstimmung mit Muster2 werden die Kommandos der zweiten
Befehlsgruppe (Befehle2) ausgeführt, usw.
Der letzte Befehl in jeder Gruppe muss mit ;; gekennzeichnet werden.
Das bedeutet für die Shell soviel wie springe zum nächsten esac, so
dass die anderen Bedingungen nicht mehr überprüft werden.
In den Mustern sind die gleichen Meta-Zeichen erlaubt wie bei der
Auswahl von Dateinamen. Wenn in einer Zeile mehrere Muster
angegeben werden sollen, müssen sie durch ein
Pipezeichen (|, bitweises ODER) getrennt werden.
18. September 2007
Scripting
34
3
5
Rechnernetze
2.4.6.
F O R -S C HL EI F E
In anderen Sprachen wird die for-Schleife meistens dazu benutzt, eine
Zählvariable über einen bestimmten Wertebereich iterieren zu lassen
(for i = 1 to 100...next). In der Shell dagegen wird die Laufvariable nicht
mit aufeinanderfolgenden Zahlen belegt, sondern mit einzelnen Werten
aus einer anzugebenden Liste.
Wird keine Liste angegeben (for x do…) dann gilt: for x in $* do…
(x nimmt also Wert aller Argumente an, siehe zweiten Screenshot)
18. September 2007
Scripting
35
3
6
Rechnernetze
2.4.7.
W HI L E -S C H L EI F E
Die while-Schleife ist wieder ein Konstrukt, das einem aus vielen anderen
Sprachen bekannt ist: Die kopfgesteuerte Schleife.
Die Bedingung prüft ob die Anzahl der Aufrufparameter > 0 ist. Ist die
Bedingung erfüllt werden alle Aufrufparameter in der Standardausgabe
angezeigt.
Mit „shift“ werden die Aufrufparameter um einen Wert nach links
verschoben (der Wert von $9 wird in $8 geschrieben, $8 in S7 usw.).
Die Schleife wird so oft durchgeführt bis durch das Verschieben auch in
$1 kein Wert mehr steht, die Anzahl der Parameter ist dann nicht mehr
größer 0.
18. September 2007
Scripting
36
3
7
Rechnernetze
2.4.8.
U N T I L -S CH L EI F E
Die until-Schleife ist das Gegenstück zur while-Schleife: Die ebenfalls aus
vielen anderen Sprachen bekannte Schleife.
Die Befehle werden ausgeführt, bis die Bedingung erfüllt ist.
Die Bedingung wird dabei üblicherweise, genau wie bei der
if-Anweisung, mit dem Befehl test) formuliert. Wenn die Ausführung
eines Schleifendurchlaufs bzw. der ganzen Schleife abgebrochen werden
soll, müssen die Kommandos continue bzw. break benutzt werden.
Beispiel: Hier wird die Bedingung nicht per test sondern mit dem
Rückgabewert des Programms grep formuliert.
2.4.9.
B R E AK /C O N T I N U E -A N W EI SU N G
Man benutzt continue um die restlichen Befehle in einer Schleife zu
überspringen und mit dem nächsten Schleifendurchlauf anzufangen.
Wenn der Parameter n angegeben wird, werden n Schleifenebenen
übersprungen.
Mit break kann man die innerste Ebene (bzw. n Schleifenebenen)
verlassen ohne den Rest der Schleife auszuführen.
18. September 2007
Scripting
37
3
8
Rechnernetze
3. S YSTEM -API
( AP P L I C AT I O N
P RO G R A M MI N G I N T E RF A C E )
Das Thema System-API und Systemaufrufe wird bereits im Kapitel 1.7 behandelt.
Über die System-API stellt das Betriebssystem Anwendungsprogrammen
(application programms) die im Benutzermodus laufen eine Schnittstelle zu
wichtigen Betriebsmitteln zu Verfügung.
Zweck dieser Maßnahme ist es, die Betriebsmittel zu schützen und das System zu
stabilisieren, indem nur über definierte Schnittstellen auf die Hardware und das
Betriebssystem zugegriffen werden darf.
Nur das Betriebssystem ist autorisiert Zugriffe auf die Hardware durchzuführen da es
im Kernelmodus arbeitet.
Anwendungsprogramme im Benutzermodus sind nicht autorisiert, und müssen die
zur Verfügung gestellten Schnittstellen nutzen die wiederum Befehle im
Kernelmodus auslösen.
Allgemeiner Ablauf von Systemaufrufen:

Prozess im Benutzer-Modus benötigt Zugriff auf die Hardware

Prozess führt einen Systemaufruf aus und wird unterbrochen

Systemaufruf wird im Kernelmodus durchgeführt

Ergebnis des Systemaufruf wird an den aufrufenden Prozess gegeben

Prozess wird wieder gestartet und führt den Programmcode an der Stelle
weiter als der Systemaufruf veranlasst wurde

Prozess hat nie den Benutzermodus verlassen und konnte dadurch die
Stabilität des Systems gefährden
18. September 2007
interface)
System-API (application programming
38
3
9
Rechnernetze
Aufbau eines Systems: Unterteilung in Anwendungsprogramme, Systemprogramme
und Hardware:
In den meisten Fällen wird die System-API in Form einer (Programm-)Bibliothek zur
Verfügung gestellt. Hierzu werden zusammengehörende Aufgaben in Sammlungen
zusammengefasst.
Häufig verwendete Funktionen, die auf Systemaufrufen basieren, sind unter
anderem die Dateiverarbeitungsfunktionen open, close, read und write, sowie exec,
fork oder exit. Diese können vom Programmierer wie normale Benutzer-ModusFunktionen genutzt werden, führen aber unbemerkt im Hintergrund einen
Kontextwechsel (in den Kernelmodus) durch.
18. September 2007
interface)
System-API (application programming
39
4
0
Rechnernetze
Im Folgenden einige Beispiele für Systemaufrufe und Bibliotheken unter UNIX:
18. September 2007
interface)
System-API (application programming
40
4
1
Rechnernetze
3.1. E XKURS : B ESTANDTEILE
EINES
P ROZESS ES
Ein Prozess besitzt folgende Hauptbestandteile:

PID: Process ID, ganzzahliger Wert zur eindeutigen Identifikation des
Prozesses

PPID: Parent Process ID

UID: User ID, ganzzahliger Wert zur eindeutigen Identifikation des
ausführenden User

Priorität des Prozesses (siehe Scheduling)

Der momentane Prozesszustand (wartend/laufend/laufbereit,…)
o Falls rechnend: der ausführende Prozessorkern
o Falls wartend: Ereignis auf das der Prozess wartet

Inhalte der Register

Verweis auf den Adressraum des Prozesses
3.2. E XKURS : S YSTEMAU FRUF
FORK ()
Ein neuer Prozess entsteht durch den Aufruf von „fork()“.
Er dupliziert den aktuell laufenden Prozess. Anschließend laufen beide
Prozesse parallel. Der neue Prozess ist ein Duplikat der Arbeitsumgebung des
Vaters, inklusive des Zustands der CPU, des gesamten Speicherzustands
sowie aller offenen Dateien.
An dem Rückgabewert von fork() wird erkannt, in welchem Prozess man sich
befindet. Liefert fork() eine 0 zurück, kennzeichnet dies den Kindprozess, im
Vaterprozess wird die PID des Kindes zurückgeliefert. Bei einem Fehler liefert
fork() einen Wert kleiner 0 und kein Kindprozess wurde erzeugt.
18. September 2007
interface)
System-API (application programming
41
4
2
Rechnernetze
3.3. E XKURS : E IN -/A US GABE -U MLENKUNG
DER S YSTEM -API
MITTELS
Ein-/Ausgabe-Umlenkung innerhalb der Shell: siehe Kapitel 2.2
Bei einer Umsetzung mittels der System-API wird durch den Systemaufruf
„dup()“ der Deskriptor „fd“ dupliziert und der Variablen „newfd“
zugewiesen. Die neue Variable „newfd“ erhält den niedrigsten freien
Deskriptor aus der Datei-Deskriptortabelle.

newfd = dup(fd);
Beispiel:
18. September 2007
interface)
System-API (application programming
42
4
3
Rechnernetze
4. P ROZESSORVERWALTUNG – S CHEDULING UND
D ISPATCHING
Moderne Betriebssysteme sind Multitasking-fähig, das bedeutet dass mehrere
Programme parallel laufen. Eine CPU kann jedoch tatsächlich immer nur einen
Prozess (= Programm in Ausführung) gleichzeitig ausführen. Dadurch das die CPU
innerhalb von Millisekunden zwischen den Prozessen hin- und herwechselt wird der
Eindruck von Parallelität erweckt. In diesem Zusammenhang wird darum oft von
Quasiparallelität gesprochen.
Übersteigt also die Zahl der laufenden Prozesse die Anzahl der CPUs werden
Verfahren notwendig wie die Rechenzeit der CPU unter den Prozessen aufgeteilt
wird.
Solche Verfahren nennt man Zuteilungsstrategien. Für die Durchführung der
Zuteilungsstrategien sind der Scheduler und der Dispatcher verantwortlich.
4.1. Z USTÄNDE
EINES
P ROZESSES
Prozesse kennen mehrere Zustände.
Ein Prozess kann z.B. in den Zustand „wartend“ (blocked) wechseln wenn er
nicht weiterarbeiten kann da ihm noch Eingabedaten fehlen.
Oder das Betriebssystem entscheidet einen Prozess in den Zustand
„wartend“ zu versetzen damit die Rechenzeit der CPU vorübergehend einem
anderen Prozess zur Verfügung gestellt wird.
Der Unterschied zw. diesen beiden Beispielen: im ersten Fall liegt die
Verzögerung in der Aufgabe  die Eingabe des Benutzers fehlt.
Im zweiten Beispiel ist die Verzögerung technischer Art
 das Betriebssystem teilt die CPU-Rechenzeit auf.
Im Wesentlichen gibt es drei Zustände für Prozesse und nur bestimmte
Möglichkeiten für einen Zustandswechsel (z.B. von rechenbereit zu
rechnend)
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
43
4
4
Rechnernetze
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
44
4
5
Rechnernetze
4.2. G RUNDBEGRIFFE
ZU R
P ROZESSORVERWALTUNG
Gibt zwei unterschiedliche Ansätze für eine Zuteilungsstrategie
(preemptiv = unterbrechbar):

Non-preemptiv: Prozess hat die Kontrolle über das System und
entscheidet selbst über Unterbrechungen (z.B. versetzt sich der
Prozess in den Zustand „wartend“ wenn ihm noch Eingabedaten
fehlen)
o FIFO bzw. FCFS (First-in-first-out, first-comes-first-serves)
o SJF (Shortest Job First)

Preemptiv: Preemptiv bedeutet das ein Prozess jederzeit
unterbrochen werden kann. Das kann durch den Prozess selbst
passieren (siehe oben) oder durch das Betriebssystem
(Zwei Gründe: Prozess mit höherer Priorität kommt oder die
Zeitscheibe des Prozesses ist abgelaufen).
o SRT (Shortest Remaining Time)
o Round Robin
o Multi Level Priority
o Multi Level Priority mit Feedback
o Fair-Share-Scheduling
Es gibt drei zeitliche Planungsstufen bei der Prozessorverwaltung:

Langfristig: Organisation des Zugangs von Prozessen zum System

Mittelfristig: Planung von Zuteilungsreihenfolgen und Prioritäten,
Suspendierung und Wiederaufnahme von Prozessen

Kurzfristig: Zuweisung der CPU-Rechenzeit zu Prozessen unter
Berücksichtigung der mittelfristigen Planung sowie Organisation
der Prozesswechsel
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
45
4
6
Rechnernetze
4.3. P ROZESSORVERWALTUNG : D ER S CHEDU LER
Der Scheduler ist für die lang- und mittelfristige Prozessorzuteilung
zuständig. Er erstellt sozusagen den Fahrplan, während der Dispatcher dann
als Fahrer den Fahrplan (Prozessablaufplanung) ausführt (siehe Kapitel 4.4).
Das größte Problem des Schedulers ist die Tatsache, dass die benötigten
Betriebsmittel für die einzelnen Prozesse nicht im Vorfeld bekannt sind. Es
lässt sich also im Allgemeinen keine optimale Planung erstellen, sondern der
Scheduler muss dynamisch auf geänderte Anforderungen reagieren. Dabei
können (abhängig vom Scheduler) verschiedene Zuteilungsstrategien zum
Einsatz kommen (non-preemptive und preemptive, siehe Kapitel xx).
Der Scheduler hat folgende Aufgaben:

Startzeitpunkt und Priorität neuer Prozesse festlegen

Prioritäten für Reihenfolge der Prozesswechsel aus „bereit“ zu
„laufend“ festlegen

Entscheidungen über Suspendierung und Wiederaufnahme treffen
In folgenden Situationen kommt der Scheduler zum Einsatz:

Ein Betriebsmittel wird angefordert

Ein Betriebsmittel wird freigegeben

Ein Prozess wird/ist terminiert

Ein neuer Prozess wird/ist gestartet
4.4. P ROZESSORVERWALTUNG : D ER D ISPATCHER
Wie oben erwähnt führt der Dispatcher die Anweisungen des Schedulers
durch. Der Dispatcher (engl. to dispatch = etwas erledigen, abschicken) ist
ein Einsatzleiter, Koordinator, Zuteiler. Wörtlich „Schnell-Erlediger“.
Im Rahmen der Prozessverwaltung dient der Dispatcher dazu, bei einem
Prozesswechsel dem derzeit aktiven Prozess die CPU zu entziehen und diese
anschließend dem nächsten Prozess zuzuteilen. Die Entscheidung, welcher
Prozess der nächste ist, wird vom Scheduler im Rahmen der
Zuteilungsstrategie getroffen.
Der Dispatcher hat folgende Aufgaben:

Prüfen ob laufender Prozess noch derjenige mit der höchsten
Priorität ist

Sicherung des Prozess-Zustands

Restaurierung des Prozess-Zustands des nächsten Prozesses

Aktivierung des nächsten Prozesses
In folgenden Situationen kommt der Dispatcher zum Einsatz:

Aktive Prozess kann CPU nicht mehr nutzen

Anderer Grund für Zuteilungsänderung liegt vor (z.B. externe
Unterbrechung, Fehler im Prozess, Warte auf Eingabedaten)
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
46
4
7
Rechnernetze
4.5. P ROZESSORVERWALTUNG : D IE Z IELE

Durchsatz (Anzahl bearbeiteter Prozesse pro Zeiteinheit
maximieren)

Verweilzeit (Prozess soll so schnell wie möglich abgearbeitet sein)

Wartezeit (Dauer im Zustand "wartend" minimieren)

Effizienz (Prozessorleistung maximal ausnutzen)

Antwortzeit (möglichst kurze Reaktionszeiten für den Benutzer)

Fairness (gerechte Verteilung der Prozessorzeit)

Lastverhalten (vernünftiges Verhalten bei hoher Last, „graceful
degradation“)

Minimale Kosten (Overhead)

Prioritäten (Berücksichtigung von Prozessprioritäten)

Flaschenhälse (Verhinderung von Bottlenecks durch bevorzugen
von Prozessen die wichtige, nicht entziehbare Betriebsmittel
halten)

Auslastung (Gute Auslastung aller Betriebsmittel durch bevorzugen
von Prozessen die wenig benutzte Betriebsmittel anfordern)
Es ist nicht möglich CPU-Auslastung und Durchsatz zu maximieren und
gleichzeitig Warte- und Antwortzeit zu minimieren. Deshalb müssen alle
Scheduling Algorithmen Kompromisse (richtige Balance) eingehen.
4.6. Z UTEILUNGSSTRATEGIEN
Wie bereits erwähnt, verwendet der Scheduler einen Algorithmus zur
Verteilung der CPU-Rechenzeit an Prozesse (Zuteilungsstrategie).
Je nach Einsatzzweck gibt es Scheduler die auf bestimmte Ziele (siehe oben)
ihren Schwerpunkt setzen (z.B. Echtzeitbetriebssystem  Einhaltung der
erforderlichen Antwortzeit).
Alle gebräuchlichen Algorithmen kommen aus der Warteschlangentheorie.
Alle Prozesse welche den Prozessor fordern werden in eine Warteschlange
eingereiht.
Ein Übersicht der Warteschlangentheorien und ihrer Einteilung in nonpreemptive und preemptive Verfahren gibt es in Kapitel 4.2.
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
47
4
8
Rechnernetze
4.6.1.
R O UN D -R O BI N -V E R FA HR EN
Einem Prozess wird nach Ablauf seiner Zeitscheibe (q) die CPU entzogen.
In der Warteschlange für bereite Prozesse wird das FIFO-Verfahren
angewendet.
Für optimale Antwortzeiten sollte q > 10x Kontextwechsel (ca. 1-10msec)
sein. Wenn q unendlich ist, die Zeitscheibe also niemals abläuft, haben wir
ein einfaches FIFO-Verfahren da die Prozesse in der Warteschleife ebenfalls
im FIFO-Verfahren sortiert sind.
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
48
4
9
Rechnernetze
4.6.2.
M UL T I -L EV E L -P RI O RI T Y -V ER F AH R EN
Das Multi-Level-Priority-Verfahren verwendet Prioritäten, die den
einzelnen Prozessen zugeordnet sind. Für Prozesse die im Zustand
„bereit“ sind, werden für jede Priorität Warteschlangen gebildet.
Es werden immer zuerst die Prozesse aus der Warteschlange mit der
höchsten Priorität ausgeführt. Da dies ein verdrängendes Verfahren ist,
besteht die Gefahr das niedrig priorisierte Prozesse nie ausgeführt
werden.
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
49
5
0
Rechnernetze
4.6.3.
M UL T I -L EV E L -F E E D BA CK -V E RF A HR EN
Bei diesem Verfahren gibt es eine feste Anzahl von
Prioritätswarteschlangen. Neue Prozesse werden in die Warteschlange
mit der höchsten Priorität eingeteilt. Nach Ablauf der Zeitscheibe wird
der Prozess in die Warteschlange mit der niedrigsten Priorität eingeteilt.
Weitere Maßnahme damit Prozesse in niederprioren Warteschlangen
nicht „verhungern“: die Zeitscheibe q wird mit abnehmender Priorität
immer größer.
Innerhalb der Warteschlangen wird das FIFO-Verfahren angewendet. In
der Warteschlange mit der niedrigsten Priorität wird das Round-RobinVerfahren angewendet.
18. September 2007
Dispatching
Prozessorverwaltung – Scheduling und
50