Betriebssystembau (BSB): 1. Übung · – Jeder Gruppenteilnehmer sollte also die Lösung zu jeweils 2 der 6 Aufgaben demonstrieren und erläutern – Demonstration auf echter PC-Hardware,

Betriebssystembau (BSB)

1. Übung

http://ess.cs.tu-dortmund.de/DE/Teaching/WS2013/BSB/

Olaf Spinczyk

[email protected]://ess.cs.tu-dortmund.de/~os

AG Eingebettete SystemsoftwareInformatik 12, TU Dortmund

technische universität dortmund

mailto:[email protected]

22. Okt 2013 Betriebssystembau: 1. Übung 2


embedded system software

Überblick● Organisatorisches● C++ Crashkurs (Teil 1)● CGA-Programmierung

● … und in einer Woche:● C++ Crashkurs (Teil 2)● Tastatur-Programmierung




Betriebssystembau: Übungen● 2 SWS „Tafel“übung (hier :-)) und 2 SWS Rechnerübung

● Die Tafelübung vermittelt...

– Grundlagen der PC-Hardware-Architektur

– Grundwissen zur Bearbeitung der Rechnerübungen

– C++-Programmierkenntnisse

– ...und dient der Abgabe der Aufgaben!● Die Rechnerübung...

– dient zum Bearbeiten der Rechneraufgaben

– ist zum Fragen stellen da● Es gibt keine theoretischen Aufgaben!




Betriebssystembau: Aufgaben● Aufgaben alle 2-3 Wochen, insgesamt 7 Aufgaben

● Wettbewerb: 7. Aufgabe — eine OOStuBS-Anwendung

● Bearbeitung in Dreiergruppen

● Anwesenheit zu den Abgabeterminen erforderlich!

● Abgabe innerhalb der Gruppe soll reihum erfolgen– Jeder Gruppenteilnehmer sollte also die Lösung zu jeweils 2 der 6

Aufgaben demonstrieren und erläutern

– Demonstration auf echter PC-Hardware, nicht im Emulator

● Bearbeitung der Aufgaben auch zu Hause möglich

– auf Linux (ggf. VM installieren)









Betriebssystembau: Einführung C++● Grundlage für die Rechnerübungen

● Voraussetzungen:

– Programmierkenntnisse in einer objektorientierten Sprache (z.B. Java)

● Wir konzentrieren uns auf die Unterschiede zwischen Java und C++

– ...und die kleinen Eigenheiten, auf die man achten muss, wenn man C++ für Systemprogrammierung einsetzt...




Literatur● Es gibt jede Menge Bücher und Tutorials zu C++...

● Eine gute Einführung (€ 17,95) ist

– Marko Meyer: „C++ programmieren im Klartext“Pearson Verlag, ISBN 3-8273-7093-0

● Kostenlos und gut – Folien und Skript von Prof. Ring, Uni Siegen:

– http://www.math.uni-siegen.de/ring/cpp.html

● ...und außerdem der Kurs „Von Java nach C++“von Prof. Müller und Frank Weichert

– die Basis für diese Folien

– http://ess.cs.tu-dortmund.de/Teaching/WS2013/BSB/Downloads/Java2C.pdf




C++● Wie so üblich: „Hello, World“ in C++

● Java-Version:

#include <iostream>int main() {

cout << "Hello, world" << endl;return 0;

}

import whatever.u.like.*;class Test { public static void main(String[] argv) { System.out.println("Hello, world"); }}




C++-Konzepte● Kontrollstrukturen und Variablentypen in C++

● Komplexe Datentypen (structs)

● Zeiger (Pointer) und Referenzen

● Quelltextorganisation

● Vererbung und Mehrfachvererbung

● Virtuelle Funktionen

● Überladen von Operatoren




Kontrollstrukturen und Variablentypen ● bedingte Anweisungen, Schleifen, Verbundanweisungen

(Blöcke)

– sind identisch in C++ und Java!

● In C++ sind „globale“ Funktionen möglich, in Java dagegen müssen Methoden immer innerhalb einer Klasse stehen

– insbesondere lassen sich in C++ auch „normale“ C- und Assembler-Funktionen aufrufen

– ...und man kann C++-Funktionen als von C und Assembler aufrufbar deklarieren mittels extern „C“ (wird für OOStuBS aber nicht benötigt)

– eine wichtige globale Funktion ist die „main“-Funktion :-)




Kontrollstrukturen und Variablentypen ● Arrays (Felder) werden in C++

wie folgt definiert:

● Es findet keine Überprüfung der Array-Grenzen statt!

– Potentiell großes Sicherheitsproblem: „Buffer Overflows“, bei denen z.B. über die Grenzen von Arrays hinaus Werte (andere Variableninhalte, Rücksprungadressen auf dem Stack etc.) überschrieben werden

● Variablen haben keine Default-Werte, müssen also immer explizit initialisiert werden. Erfolgt das nicht, generiert der Compiler eine warning (aber keinen error!)

● Die Speicherverwaltung muss durch den Programmierer erfolgen. Ein Garbage Collector wie in Java ist nicht vorhanden

int a[4]; // oder mit Initialisierungint a[] = { 1, 2, 3 };




Typwandlung (type casting)● In C++ können Typen – wie in Java –

explizit gewandelt werden:

– (Typ) Ausdruck, z.B.:

● Eine weitere Möglichkeit, die nur in C++ verfügbar ist:

– Typ(Ausdruck), z.B.:

int a=3;double b=(double)a/2; // b==1.5

int a=3;double b=double(a)/2; // b==1.5




Wertebereiche● In C++ existieren vorzeichenbehaftete und nicht vorzeichenbehaftete

Typen (char, short, int, long), z.B.:

– int von -2^31 bis 2^31-1

– unsigned int von 0 bis 2^32-1

● Bei arithmetischen Operationen erfolgtkeine Überprüfung auf Overflow bzw.Underflow! Sicherheitsproblem!→

● Die Wertebereiche sind maschinenabhängig!

– z.B. kann ein int 32 oder 64 Bit „lang“ sein

● Mittels typedef lassen sichneue Namen für Datentypen definieren:

unsigned int i=0;i = i – 1;// i==4294967295

typedef int Index;Index a = 3;




Komplexe Datentypen● enums: Aufzählungstypen

Oft Alternative zu #defines

● structs: Benutzerdefinierte zusammengesetzte Datentypen

● Verwendung:

enum { caps_lock = 4, num_lock = 2, scroll_lock = 1 };

struct Rechteck { int xp, yp; int width, height; int color; ...};

Rechteck r;r.xp = 100; r.yp = 200; r.width = 20; r.height = 40;




Klassen in C++● Eine Klasse in C++ besteht aus

– Deklaration in Headerdatei (z.B. keyctrl.h)

– und Implementierungsdatei (keyctrl.cc)

– Name der .h/.cc-Files und Name der Klasse müssen nicht übereinstimmen!

class Keyboard_Controller { ... };

#include “machine/keyctrl.h“...




Aufbau der Headerdatei● Ausschnitt aus keyctrl.h:

class Keyboard_Controller {private: unsigned char code; // Attribute unsigned char prefix; ... public: Keyboard_Controller (); // Konstruktor ~Keyboard_Controller (); // Destruktor

Key key_hit (); // Methoden void reboot (); void set_repeat_rate (int speed, int delay); ...};




Aufbau der Headerdatei● Beginn der Klassendefinition mit Schlüsselwort „class“

● Klassen sind immer public

● Attribute

– (Instanz-)Variablen dürfen bei der Deklaration nicht initialisiert werden

● Konstruktoren und Destrukturen

– Konstruktoren: Instanziierung von Objekten

– Destruktoren: Löschen instanziierter Objekte● Deklaration von Methoden

● Klassendefinition wird mit Semikolon beendet!




Aufbau der Implementierungsdatei● Einbinden der Header-Datei mit #include

● Durch den Klassennamen und den Bereichsoperator „::“ wird die Zugehörigkeit zur Klasse gekennzeichnet:

#include “keyctrl.h“

Keyboard_Controller::Keyboard_Controller () { ...}

Keyboard_Controller::~Keyboard_Controller () {}

void Keyboard_Controller::reboot () { ...}




Pointer (Zeiger)● Jede Speicherstelle, die einem Objekt (einer Variablen)

zugeordnet ist, hat eine eindeutige Adresse

– Bei der Betriebssystemprogrammierung kann dies auch die Speicherstelle sein, an der ein bestimmtes Gerät Speicher oder Kontrollregister einblendet — z.B. der Bildschirmspeicher

● Ein Pointer ist eine Variable, deren Wert die Speicheradresse einer Variablen, einer Struktur oder eines Objekts ist

● Pointer sind typisiert, z.B. Typ “Zeiger auf int”

● Zeiger-Typen sind durch das Symbol „*“ gekennzeichnet, z.B.:

int a; // kein Pointerint *int_zeiger; // Zeiger auf Integer-Variable




Pointer (Zeiger)● Der Inhalt eines Zeigers ist der Wert, der an einer

referenzierten Speicherstelle gespeichert ist

● Die Größe des Inhalts (in Bytes) ist vom jeweiligen zugeordneten Datentyp abhängig

– z.B. 1 Byte für char, 2 Byte für short usw.

– Diese Größen sind in C/C++ architektur- und compilerabhängig, also nicht portabel !!!




Pointer (Zeiger)Es existieren zwei Operatoren zu Pointern:

● Adressoperator „&“

– Liefert die zu einer Variablengehörende Speicheradresse

● Dereferenzierungsoperator „*“

– Gibt den Wert zurück, der an derAdresse gespeichert ist, auf diedie Pointervariable zeigt(den Inhalt)

int_zeiger = &a;

*int_zeiger = 42;




Pointer (Zeiger): BeispielUmwandlung einer konstanten Adresse in einen ZeigerUmwandlung einer konstanten Adresse in einen Zeiger

Anlegen einer Zeigervariablen CGA_START (Zeiger auf char)Anlegen einer Zeigervariablen CGA_START (Zeiger auf char)

Zeigerarithmetik: 'pos' zeigt nun auf die Speicherstelle, in der der Zeichencode des Zeichens an Position (x, y) abgelegt ist.

Zeigerarithmetik: 'pos' zeigt nun auf die Speicherstelle, in der der Zeichencode des Zeichens an Position (x, y) abgelegt ist.

Dereferenzierung: Das Zeichen an Position (x, y) wird durch ein 'Q' überschrieben.

Dereferenzierung: Das Zeichen an Position (x, y) wird durch ein 'Q' überschrieben.

char *CGA_START = (char *)0xb8000;char *pos;int x=20, y=20;pos = CGA_START + 2*(x + y*80);*pos = 'Q';




Referenzen als Parameter● Neben den Zeigern gibt es in C++ auch “Referenzen”. Diese

werden häufig für Funktionsparameter benutzt:

● Dies entspricht einem „call by reference“, d.h. es wird eine Referenz auf die entsprechende Variable übergeben und auch zurückgegeben. Der Aufruf erfolgt dann so:

int& max(int& a, int& b) { if (a>b) return a; else return b;}

int a=5, b=7;max(a,b)++; // erhöht b um 1!




Überladen von Operatoren● Operatoren funktionieren abhängig vom Datentyp, auf dem sie

operieren (in Java nicht realisiert)

● Beispiel: Operator „+“

– für int, float, double-Variablen wird die jeweilige Additionsfunktion für den entsprechenden Zahlentyp aufgerufen

– für String-Objekte werden die beiden Operanden konkateniert

● In OOStuBS: Operator „<<“

– für int-Werte bewirkt der „<<“-Operator, dass der in der Variablen enthaltene Zahlenwert um n Bits (2. Operand) nach links geschoben wird — z.B. ist 2 << 3 == 16

– für Ausgabestreams siehe „Hello World“: cout << "Hello" << endl;

– Operator „>>“ entsprechend für Eingabe-Streams




Überladen von Operatoren● Es können nur von der Sprache definierte Operatoren überladen, die

Definition neuer Operatoren ist nicht möglich

● Unterstützt werden dabei

– unäre Operatoren:

– binäre Operatoren:

+ - * & ~ ! ++ -- -> ->*

+ - * / % ^ & | << >> += -= *= /= %= ^= &= |= <<= >>= < <= > >= == != && || , [] () new new[] delete delete[]




Überladen von Operatoren: Beispiel● Addition von ganzen Zahlen zu einem Datum:

Die Addition liefert ein neues Datum zurück und als rechter Operand ist eine ganze Zahl zulässig. So kann das Datum durch einfache Addition um 14 Tage weitergeschoben werden:

class tDatum {public: // .... tDatum operator+(int Tage);};

tDatum tDatum::operator+(int Tage) { // Berechnung des Datums return *this;}

tdatum heute;heute = heute + 14;




Systemprogrammierung in C++● Keine Laufzeitumgebung vorhanden!

– man muss alles selber von Hand bauen...

● Damit sind auch keine Objekte dynamisch instanziierbar!

– kein „new“ und „delete“ möglich...

– ...woher soll auch die passende Speicherverwaltung dazu kommen?

● Für Spezialisten... das geht auch nicht:– Exceptions, Assertions, runtime type information

● Ein falscher Pointer kann das Ende sein...

– der Rechner hängt und das war's

– keine „segmentation violation“, keine core dumps









Ausgabestream● Stringbuffer: put(c), flush()

– Sinn der Pufferung? Sinnvolle Puffergröße?

● O_Stream: ähnlich C++-std::ostream– Formatierung, Zahlendarstellung

– verwendet Stringbuffer::put(c)

● CGA_Stream: flush()




CGA_Screen (1)● wird von CGA_Stream beim flush() verwendet● show(x,y,c,attrib)

– Zeichen c mit Attribut attrib an Position x/y– Code aus dem C++-Crashkurs:

– Was fehlt hier?

char *CGA_START = (char *)0xb8000;char *pos;int x = 20, y = 20;

pos = CGA_START + 2*(x + y*80);*pos = 'Q';




CGA_Screen (2)




CGA_Screen (3)● je zwei Bytes im Bildspeicher pro Bildposition!● gerade Adressen: ASCII-Code● ungerade Adressen: Attributbyte

● Was passiert ohne diese zusätzliche Zeile?

char *CGA_START = (char *)0xb8000;char *pos;int x = 20, y = 20;

pos = CGA_START + 2*(x + y*80);*pos = 'Q';*(pos + 1) = 0x0f; // weiss auf schwarz




CGA_Screen (4)● setpos/getpos

– ändern internen Zustand von CGA_Screen

● aktuelle Position wird in print() benötigt!

– positionieren den CGA-Cursor

● allgemein: Zugriff auf PC-Peripherie– zwei Adressräume: Speicher-Adressraum, E/A-Adressraum

– Speicher: direkt über Pointer adressierbar (Graphikspeicher)

– E/A: über CPU-Befehle in/out (inb/inw/inl; outb/outw/outl)● in OOStuBS gekapselt in der Klasse IO_Port

– manche Geräte verwenden sogar beides (z.B. eben CGA)

– Performance vs. einfachere Dekodierschaltung




CGA_Screen (5)● speziell CGA: Speicher und E/A

– in Speicher-Adressraum eingeblendeter Graphikspeicher– CGA-Register im E/A-Adressraum

● mehr Register als E/A-Adressen– Multiplexing über Index-/Datenport




CGA_Screen (6)● print(char *text, int length, unsigned char attrib)

– baut auf show() und setpos() auf– unten angekommen? scrollen!

Documents

Betriebssystembau (BSB): 1. Übung · – Jeder Gruppenteilnehmer sollte also die Lösung zu jeweils 2 der 6 Aufgaben demonstrieren und erläutern – Demonstration auf echter PC-Hardware,