> Übung Betriebssysteme

Transkript

1 > Übung Betriebssysteme Übung 1 Aaron Scherzinger Wintersemester 2012/13 Gruppe Parallele und Verteilte Systeme (PVS) Institut für Informatik Westfälische Wilhelms-Universität Münster

2 Organisatorisches 2 Koordinator: Michel Steuwer Raum 705, Tel.: michel.steuwer@uni-muenster.de Sprechstunde: nach Vereinbarung Informationen zur Vorlesung und Übung, Aufgabenblätter: Im Web: Über Mailingliste pvs-bs@listserv.uni-muenster.de Anmeldung zur Mailingliste über Übungstermin: Mittwochs Uhr Uhr, Hörsaal M4 Auf den Folien steht viel aber nicht alles Teilnahme an einer Übung ist Voraussetzung zum Verständnis der Folien

3 Prüfungsleistungen 3 90-minütige benotete Klausur Termin: , Uhr, M1 Studiengänge: 1-Fach-Bachelor Informatik Diplom Informatik, Wirtschaftsinformatik, Geoinformatik, Mathematik (Nebenfach Informatik) Lehramt Sek II (und Sek I) Informatik LA Gymn./Ges. Informatik Abtestat (unbenotet) Bearbeitung der Übungsblätter (mind. 50% der Punkte) Modul Systemstrukturen für 2-Fach-Bachelor Informatik Modul Systemstrukturen besteht aus den Veranstaltungen Rechnerstrukturen und Betriebssysteme 4-stündige benotete Modulabschlussklausur (voraussichtlich am Ende des Wintersemesters) Zur Zulassung zur Modulabschlussklausur muss entweder die Klausur zu Rechnerstrukturen oder die Klausur zu Betriebssysteme (am ) bestanden werden

4 Übungsblätter 4 Im Netz werden Übungsblätter zur selbständigen Bearbeitung bereitgestellt Übungsblätter sollen praktische Kenntnisse vermitteln Intensive Beschäftigung mit den Übungsblättern ist Voraussetzung zum Verständnis der Übung Übungsblätter werden korrigiert! Insbesondere: Inhalt der Übung ist klausurrelevant!

5 Übungsblätter 5 Prüfungsleistung: Schein, CP: Klausur Abtestat, unbenotet (GI): 50% der Übungspunkte oder Bestehen der Klausur Jede mündliche Prüfung setzt das Bestehen der Klausur voraus! Bonuspunkte: Durch die erfolgreiche Bearbeitung der Übungen können bis zu 10% der Klausurpunkte erworben werden. Bei weniger als 50% der möglichen Punkte für die Übungsaufgaben werden keine Bonuspunkte vergeben. Ab 50% (1 Bonuspunkt) wird für weitere 5% der Übungspunkte je ein Bonuspunkt vergeben. Bonuspunkte werden erst nach regulärem Bestehen der Klausur angerechnet!

6 Übungsblätter 6 Voraussichtlich sieben Übungsblätter Bearbeitung In Gruppen von 3 4 Teilnehmern (nicht weniger!) Vorherige Anmeldung ist nicht nötig Zum Gründen von Gruppen kann die Mailingliste der Vorlesung genutzt werden! Abgabe Hinweise auf den Aufgabenblättern beachten!!! Abgabe per (pvs-bs-uebung@listserv.uni-muenster.de) Namen und Matrikelnummern aller Teilnehmer angeben Termin i.d.r. Dienstag vor der Übung (genauer Termin auf dem jeweiligem Blatt) Zur Bearbeitung der Übungsblätter ist eine gültige Nutzerkennung für die Mathematik/Informatik CIP-Pools hilfreich!

7 Ziel der Übungen 7 Ziel der Übung ist... die Vertiefung der in der Vorlesung vorgestellten Konzepte die praktische Anwendung aus Sicht des (System-)Programmierers Inhalte der Übungsblätter: ca. 50% Textaufgaben ca. 50% Programmieraufgaben Für Programmieraufgaben werden die Programmiersprache C und Unix/Linux verwendet

8 Unix und C 8 Warum Unix? Betriebssystem Windows Es gibt einige Hundert BS die tatsächlich verwendet werden oder wurden und mehrere Tausend (Forschungs-)Projekte Übersicht z.b. Unix Varianten (FreeBSD, OpenBSD, NetBSD, Linux,...) für jede gängige Hardware-Architektur kostenlos erhältlich Kostenlose Compiler, Editoren, Debugger, IDEs,... Im Source-Code verfügbar = Ideale Spielwiese ;-) Konzeptionell basieren alle gängigen Betriebssysteme auf Unix Man kann relativ einfach beobachten, was unter der Haube passiert Umfangreiche Literatur über Betriebssysteminterna

9 Unix und C 9 Warum C? Relativ alte Sprache (erste Versionen ab 1971) aber immer noch eine der wichtigsten überhaupt die meisten Anwendungen werden in C oder C++ entwickelt Sehr maschinennahe Sprache, deshalb gut für Systemprogrammierung geeignet So gut wie alle gängigen Betriebssysteme sind in C/C++ geschrieben Systemnahe Programmierung i. d. R. ebenfalls nur in C C wurde für die Betriebssystemprogrammierung erdacht (für Unix) Wer sich mit Betriebssystemen beschäftigt, kommt um C nicht herum!

10 C in der Übung 10 In den ersten Übungen wird eine kurze Einführung in C geben Vorausgesetzte Vorkenntnisse: Java In der Übung kann nur eine fundamentale Einführung gegeben werden. Eigenständige Übungen und Selbststudium sind notwendig! Standardwerk zu C: Brian W. Kernighan, Dennis M. Ritchie Programmieren in C 2. Ausgabe, Hanser Verlag, 1990 ISBN: Weiter Links zu C und Linux/Unix auf den Webseiten unter

11 Wiederholung von Grundlagen 11 Betriebssystem als... Virtuelle Maschine (Top-Down Sicht) Bietet abstrakte, einfache Sicht auf die Hardware Versteckt reale, low-level Eigenschaften Ressourcenmanager (Bottom-Up Sicht) Verwaltet Speicher, Platten, Terminals,... Koordiniert Zugriffe Fazit: Betriebssysteme müssen low-level Eigenschaften der Hardware berücksichtigen um diese steuern zu können; BS-Entwickler benötigen detaillierte Kenntnis der Hardware Im Folgenden werden kurz einige Grundlagen rekapituliert: Binärzahlen Prozessor und Speicher Compiler

12 Binärzahlen 12 Digitalrechner arbeiten mit Binärzahlen, deshalb hier eine kurze Wiederholung Beispiel: (123) 10 = ( ) 10 = ( ) 10 = ( ) 2 Umwandlung durch Division mit Rest (umgekehrtes Hornerschema) Kompaktere Darstellung durch Oktal- und Hexadezimalzahlen. Oktal: drei Binärziffern ergeben eine Oktalziffer (2 3 = 8) ( ) 2 = (145376) 8 Hexadezimal: vier Binärziffern ergeben eine Hexadezimalziffer (2 4 = 16) ( ) 2 = (CAFE) 16 Zwei Hexadezimalziffern ergeben ein Byte. Wegen der einfachen Umwandlung werden Binärziffern in Programmen i. d. R. Oktal oder Hexadezimal angegeben. Oft durch 0 für Oktal bzw. 0x für Hexadezimal gekennzeichnet, also bzw. 0xCAFE

13 Binärzahlen wichtige Eigenschaften 13 Umrechnung zwischen 2er und 10er Potenzen: 2 10 = K (eigentlich 1 Ki (kibi) statt 1 K (kilo)) M G 2 n n 3 Vorsicht: = Multiplikation/Division: = = m 2 n = 2 m+n 2 m /2 n = 2 m n Binärziffern: Mit m Binärziffern können 2 m verschiedene Zahlen dargestellt werden Mit m+n Binärziffern 2 m+n verschiedene Zahlen

14 Binärzahlen: Verknüpfungen 14 Logische Operationen: (UND) (ODER) (NEG) Werden bei modernen Rechnern i.d.r. nur als Operationen auf Maschinenworten (8, 16, 32 oder 64 Bit) angeboten, z. B.: Manipulation einzelner Bits: Setzen von Bit i in Wort x: x := x 2 i Löschen von Bit i in Wort x: x := x 2 i

15 Prozessor und Speicher 15 Grobstruktur eines einfachen Rechners: Prozessor: Rechenwerk (Arithmetic-Logic- Unit, ALU) Befehlsregister (Instruction Register, IR) Befehlszähler (Instruction Pointer, IP) Stapelzeiger (Stack Pointer, SP) Hauptspeicher: Fortlaufend adressiert, enthält Befehle und Daten Prozessor I/O Gerät I/O Reg I/O Reg Hauptspeicher... Befehle Befehle Befehle Befehle Daten Daten Daten Daten... I/O-Geräte: Über I/O-Register gesteuert, werden über spezielle Speicheradressen angesprochen Was sind Register? IR AKKU ALU SP IP n n+1 Bus n 2 n 1

16 Programmausführung 16 1 Laden des nächsten Befehls von der im Befehlszähler angegebenen Speicherstelle in das Befehlsregister 2 Erhöhen des Befehlszählers um eins (bzw. die Größe des geladenen Befehls) 3 Dekodieren des Befehls 4 Ggf. Laden weiterer Operanden aus dem Speicher 5 Berechnung des Ergebnisses 6 Speicherung des Ergebnisses (z. B. in einem Register (Akku)) Sprungbefehle: Manipulation des Befehlszählers (Laden der Zieladresse) Wichtig: Befehle und Daten liegen in einem fortlaufend und zusammenhängend adressierten Speicher

17 Stack (Stapel, Keller) 17 LIFO Puffer, das zuletzt abgelegte Element (push Befehl) muss auch als erstes wieder gelesen werden (pop Befehl) Extrem wichtiges, gleichzeitig einfach zu realisierendes Konzept, wird i. d. R. durch HW als Maschinenbefehle bereitgestellt: push Befehl: 1 Schreiben des Parameters an die Speicherstelle SP 2 Erhöhen von SP um 1 pop Befehl: 1 Verringern von SP um 1 2 Lesen des Wertes von Speicherstelle SP Wichtige Verwendungsmöglichkeit: Speichern von temporären Daten, insb. Sprungadressen und lokalen Variablen bei Funktionen

18 Compiler 18 Hochsprachen sind sehr abstrakt und dadurch einfach zu gebrauchen. Werden durch Compiler in Maschinensprache übersetzt (oder von einem anderen Programm interpretiert hier nicht weiter betrachtet) Für HW-nahe Programmierung (von BS) ist ein grobes Verständnis des Zusammenhangs mit dem Maschinencode wichtig Wie werden die folgenden Konzepte im Maschinencode realisiert: Variablen Datentypen Funktionen/Prozeduren

19 Variablen 19 Inhalt von Variablen liegt im Speicher Während der Übersetzung verwaltet der Compiler intern eine Tabelle mit den Speicheradressen der Variablen Im ausführbaren Maschinenprogramm gibt es keine Variablen mehr! Beispiel int a = 0; int b = 1; int result; result = a+b; movl $0, 4(%ebp) / a / movl $1, 8(%ebp) / b / movl 8(%ebp), %eax / b laden / addl 4(%ebp), %eax / a+b / movl %eax, 12(%ebp) / result / ($ Konstanten, % Register, %ebp Basisadresse, x(%y) Adresse %y+x)

20 Datentypen: Programmiersprache 20 In Programmiersprachen sind meist Daten (Variablen) typisiert Variablen dürfen nur Werte ihres Typs zugewiesen werden, z.b. int ganzzahlige Werte Anweisungen/Befehle ergeben sich aus Datentypen, z.b. + ist Addition für int und Konkatenation für String in Java Konvertierung: Um Daten verschiedenen Typs zu kombinieren müssen diese umgewandelt werden (casts), implizit (z. B. int nach float) oder explizit Korrektheit: Korrekte Typisierung wird vom Compiler/Laufzeitsystem überwacht, z.b. keine Division / für String

21 Datentypen: Maschinensprache 21 In Maschinensprache sind meist Befehle typisiert (wenn überhaupt) Beispiel Intel IA-32 (i386) Multiplikation: mul unsigned int, imul signed int, fmul floating point Daten im Speicher sind untypisierte Bitfolgen, man kann z.b. mul auf einen String anwenden Konvertierung: Maschinenbefehle um von einer Darstellung in eine andere umzuwandeln (float/integer) müssen explizit im Programm stehen Korrektheit: Keinerlei Überprüfung auf korrekte Typisierung! Auch Datentypen sind im Maschinenprogramm nicht mehr (so wie in einer Hochsprache) vorhanden

22 Funktionsaufruf 22 Funktionsaufrufe sind abstrakte Konstrukte (der Prozessor kennt keine Funktionen!) Hauptspeicher Funktion liegt als Maschinencode im Speicher Funktionsaufruf: Sprung an Anfangsadresse der Funktion Funktionsende: Rücksprung zur Stelle des Aufrufs funktion1 Dazu muss die Rücksprungadresse beim Aufruf gespeichert werden Rücksprungadressen werden auf einem Stapel abgelegt Funktionen müssen in der umgekehrten Reihenfolge ihres Aufrufs beendet werden = Die zuletzt abgelegte Adresse wird als erstes benötigt Entspricht LIFO-Eigenschaft des Stapels main funktion3 funktion2

23 Funktionsaufruf: Beispiel Hauptspeicher... funktion3()... funktion2() funktion1()... funktion2() Stapel funktion1 Befehlszähler main funktion3 funktion1() funktion3() return funktion2() return return funktion2() return funktion

24 Funktionsaufruf: Parameter und Variablen 24 Funktionsaufruf: Außer der Sicherung der Rücksprungadresse muss folgendes beachtet werden: Übergabe von Parametern Sichern von Registerinhalten die innerhalb der Funktion überschrieben werden Speicher für lokale Variablen reservieren Funktionsende: Freigeben lokaler Variablen Registerinhalte wiederherstellen Rückgabe des Ergebnisses Auch hier dient der Stapel zum Ablegen aller Daten Details sind Hardware- und Compiler-abhängig

25 Beispiel: C-Funktionsaufruf bei GCC/i int foo(int a, int b) { int c = 0; c = a + b; return c; } int main(int argc, char argv) { int x; } x = foo(1, 2); return 0; foo: / Vorspann / pushl %ebp movl %esp, %ebp subl $4, %esp movl $0, 4(%ebp) / Rumpf / movl 12(%ebp), %eax addl 8(%ebp), %eax movl %eax, 4(%ebp) / Nachspann / movl 4(%ebp), %eax leave ret / Aufruf in main / pushl $2 pushl $1 call foo Nicht Klausurrelevant ;-)

26 C-Programmierung unter Linux/Unix Überblick 26 Editor program.c program.h Compiler program.o otherprog.o Linker program

27 Editor 27 VIM: Aufruf mit vim <dateiname> Tutorial: :help XEmacs: Aufruf mit xemacs <dateiname> Tutorial: M-? t Speichern: C-x s Verlassen: C-x c Beide Editoren sind auf den meisten Unix-Systemen verfügbar und äußerst leistungsfähig das Lesen der Dokumentation lohnt sich! NEdit: Einfachere Bedienung Windows ähnlich

28 Compiler Details 28 Die Übersetzung eines C-Programms findet in mehreren Schritten statt 1 Präprozessor: Textuelle Ersetzung von Präprozessoranweisungen 2 Compiler: Übersetzung in Maschinencode. Ergebnisdatei program.o enthält nur Maschinencode von Funktionen aus program.c. Funktionsaufrufe anderer Funktionen sind speziell gekennzeichnet. 3 Linker: Verbindet mehrere.o-dateien und Bibliotheksdateien zu einem ausführbaren Programm. Fügt fehlende Funktionen aus.o-dateien und Bibliotheken, sowie Code zur Ausführung der Funktion main ein. In der Regel werden alle drei Schritte auf einmal erledigt ohne Mitwirkung durch den Benutzer

29 GNU C Compiler (gcc) 29 Aufruf: gcc <datei.c> Zusätzlich können noch Optionen angegeben werden: -Wall: Viele Warnungen ausgeben (z. B. bei if(a=b) warnen) -o <datei>: Name der zu erzeugenden Datei (sonst: a.out) Aufruf für die Übungsaufgaben: gcc -Wall -Werror -pedantic-errors -o prog prog.c Aufruf von gcc bewirkt übersetzen und linken Verhindern des linkens: -c gcc -Wall -Werror -pedantic-errors -c -o prog.o prog.c Weitere Optionen: -E nur Präprozessor -g Einbinden von Debug-Informationen -O, -O1, -O2, -O3 Optimierungsstufe

30 Man-Pages 30 Unix Hilfe Seiten Anzeige mit man <befehl/funktion/schluesselwort> z.b. man gcc Man-Pages sind in Abschnitte (Sections) untergliedert. Abschnitt 1: Benutzerbefehle Abschnitt 2: Systemaufrufe Abschnitt 3: Bibliotheksfunktionen Angabe des Abschnitts: man <abschnitt> <befehl> z.b. man 3 printf auf Solaris: man -s <abschnitt> <befehl> Innerhalb von Man-Pages werden andere Seiten oft in der Form befehl(abschnitt) angegeben, z. B. fork(2) Nach Hilfeseiten suchen: man -k <Schlüsselwort> man man Alternativ

31 Make 31 Automatisierte Erzeugung von Programmen aus Quelldateien Berücksichtigt Abhängigkeiten zwischen Dateien stacktest.c stack.h stack.c compile stacktest.o stack.o link stacktest Steuerung der Übersetzung durch Regeln in Datei Makefile # Ziel: Quellen # <tab> Befehle stacktest: stacktest.o stack.o gcc stacktest.o stack.o o stacktest stacktest.o: stacktest.c stack.h gcc o stacktest.o c Wall stacktest.c stack.o: stack.c stack.h gcc o stack.o c Wall stack.c

32 Make: Implizite Regeln 32 Neben expliziten Regeln enthält make implizite Standardregeln, z. B. Regel zur Erzeugung von datei.o aus datei.c Standardregeln sind über Variablen konfigurierbar Für C-Programme: CC: Compiler CFLAGS: Kommandozeilenparameter für Compiler Anwendung impliziter Regeln wenn Befehle weggelassen werden CC=gcc CFLAGS= Wall Werror pedantic errors std=c99 stacktest: stacktest.o stack.o stack.o: stack.c stack.h stacktest.o: stack.h stacktest.c Aufruf mit gmake oder gmake Ziel

33 GNU Debugger: gdb, ddd 33 Aufruf: gdb <programm> Vorgehensweise für den Fehler zwischendurch: run <Kommandozeilenparameter> startet das Programm kill bricht das Programm ab break <funktion> setzt breakpoint (Ausführung wird bei Beginn von funktion unterbrochen) print <ausdruck> gibt Wert von <ausdruck> (beliebige Programmvariablen, Zeiger,...) aus cont führt Ausführung fort Bei Absturz: bt ( backtrace ) gibt an, an welcher Stelle das Programm abgestürzt ist Graphische Oberfläche für gdb: ddd (Data Display Debugger) ddd <programm>

34 Zusammenfassung 34 Wichtig für Programmieraufgaben: Bei Programmieraufgaben wird ein Makefile zur Verfügung gestellt Programme müssen mit diesem Makefile auf einem Rechner des IVV5 (z.b. Räuber) übersetzbar sein Alternative zu Linux: Cygwin und MinGW ABER: Kein Support durch Tutoren! Weitere Alternative: Programm an Heim-PC schreiben und via SSH auf einem Linux-Rechner übersetzen Genaueres zu Makefiles, Debugger in der ersten Globalübung