Friedrich-Alexander-Universität UnivisSuche FAU-Logo
Techn. Fakultšt Willkommen am Department Informatik FAU-Logo
Logo I4
Lehrstuhl für Informatik 4
Betriebssysteme
 
  Vorlesung
    - UnivIS-Infos
    - Inhalt
    - Folien
 
  Übungen
    - UnivIS-Infos
    - Inhalt
    - Ergänzendes Material
    - Terminübersicht
    - Aufgaben
       * Umgebung
       * Typische Fehler
       * A 1
       * A 2
       * A 3
       * A 4
       * A 5
       * A 6
       * A 7
 
  Evaluation
Department Informatik  >  Informatik 4  >  Lehre  >  WS 2007/08  >  Betriebssysteme  >  Übungen  >  Aufgaben  >  Entwicklungsumgebung

Übungen zu BS - Entwicklungsumgebung

Für die Bearbeitung der Rechnerübungsaufgaben (und damit für die Entwicklung von OOStuBS) haben wir die benötigte Software unter /proj/i4bs/ bereitgestellt. Ihr könnt die Aufgaben natürlich auch zu Hause bearbeiten, wir empfehlen hierzu den Einsatz von Linux. Weiter unten finden sich einige Hinweise, wie ihr euren Linux-Rechner entsprechend konfigurieren könnt.

Achtung! Wer die Software bei sich zu Hause installieren möchte, trägt natürlich die volle Verantwortung für eventuelle Probleme. Fehlgeschlagene Installationen werden von uns auch nicht als Entschuldigung für verspätete Programmabgaben akzeptiert.

Da sich bei der Betriebssystementwicklung ab und zu auch Fehler einschleichen können, müsst ihr eure Lösungen testen, bevor ihr sie abgebt. Wir benutzen hierzu einen Emulator (bochs) und einen echten PC im Raum 01.155-N (Nebenraum des CIP-Pools im 1. Stock). Bei der Abgabe benutzen wir immer den echten PC, um eure Lösung zu kontrollieren. Ihr solltet deshalb immer auch mit dem echten PC testen, er ist die Referenzplattform!

Voraussetzungen zum Kompilieren von OOStuBS im CIP-Pool und zu Hause

Zum Kompilieren wird wie im Makefile vorgegeben g++ verwendet, zum Assemblieren des Startup-Codes und der hardwarenahen Teilprogramme der Netwide Assembler (nasm). Der x86-Emulator bochs eignet sich zum vorläufigen Testen und durch den eingebauten GDB-Stub vor allem zum Debuggen von OOStuBS. Im CIP-Pool ist die entsprechende Umgebung vorhanden bzw. unter /proj/i4bs/ gemountet; wer das Ganze zu Hause machen will, muss sich die genannte Software entsprechend einrichten. Bei Problemen könnt ihr uns gerne fragen.

Kompilieren von OOStuBS

  • oostubs.tar.gz aus /proj/i4bs/vorgaben/ in ein Verzeichnis entpacken (z. B. ~/oostubs):
    wanja@faui48a:~> mkdir oostubs
    wanja@faui48a:~> cd oostubs
    wanja@faui48a:~/oostubs> tar xzf /proj/i4bs/vorgaben/oostubs.tar.gz
  • Die Vorgaben (vorgabe1_patch.tar.gz usw.) müssen innerhalb dieses Verzeichnisses entpackt werden (die "Patches" enthalten alle für die jeweilige Aufgabe neuen notwendigen Dateien):
    wanja@faui48a:~/oostubs/loesung> tar xzf /proj/i4bs/vorgaben/vorgabe1_patch.tar.gz
  • Alle Vorgaben, die ihr von uns erhaltet, lassen sich korrekt übersetzen, enthalten aber nur unvollständigen Code. Ihr müsst also Code vervollständigen. Die entsprechenden Klassen und Funktionen sind unter Aufgaben beschrieben, die zugehoerigen Dateien enthalten dann die entsprechenden Hinweise, wenn etwas vervollständigt werden muss.
  • Das eigentliche Kompilieren von OOStuBS erfolgt durch den Aufruf von make im Lösungsverzeichnis. Alle .cc- und .asm-Dateien im Lösungsverzeichnis werden daraufhin mit den entsprechenden Tools (Compiler bzw. Assembler) übersetzt. Mit Hilfe des build-Tools, das in oostubs.tar.gz enthalten ist, wird dann in build ein Diskettenimage generiert (bootdisk.img). Dieses Diskettenimage wiederum kann dann zum Testen in bochs bzw. auf dem echten PC verwendet werden. Der Output des make-Prozesses sind in etwa folgendermaßen aus:
    wanja@faui48a:~/oostubs/loesung> make
    mkdir ./build
    nasm -f elf -o build/_startup.o startup.asm
    nasm -f elf -o build/_io_port.o ./machine/io_port.asm
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/cgastr.o ./device/cgastr.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/guardian.o ./guard/guardian.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/cgascr.o ./machine/cgascr.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/keyctrl.o ./machine/keyctrl.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/main.o main.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/o_stream.o ./object/o_stream.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/strbuf.o ./object/strbuf.cc
    g++ -c  -Wall -I. -g  -Wno-non-virtual-dtor -fno-rtti -fno-exceptions -o build/appl.o ./user/appl.cc
    ld -e startup -T sections -o ./build/system  ./build/_startup.o /usr/lib/gcc/i486-linux-gnu/4.2.3/../../../../lib/crti.o
    	/usr/lib/gcc/i486-linux-gnu/4.2.3/crtbegin.o ./build/_io_port.o ./build/cgastr.o ./build/guardian.o ./build/cgascr.o
    	./build/keyctrl.o ./build/main.o ./build/o_stream.o ./build/strbuf.o ./build/appl.o /usr/lib/gcc/i486-linux-gnu/4.2.3/crtend.o
    	/usr/lib/gcc/i486-linux-gnu/4.2.3/../../../../lib/crtn.o 
    objcopy -O binary build/system build/system.img
    cd ../tools && cc -o ../tools/build ../tools/build.c
    cd ../boot && make
    nasm -f bin bootsect.asm
    nasm -f bin setup.asm
    ../tools/build ../boot/bootsect ../boot/setup build/system.img 0:80:2:18:0:0:1 build/bootdisk.img
    BIOS-devicecode: 0x0
    Total T/H/S:     (80/2/18)
    Start T/H/S:     (0/0/1)
    
    Setup size is 1 sectors.
    System size is 11648 bytes.
    dd if=build/bootdisk.img of=build/bootdisk.vmi bs=1474560 conv=sync
    0+1 records in
    1+0 records out
    1474560 bytes (1.5 MB) copied, 0.053504 seconds, 27.6 MB/s
    wanja@faui48a:~/oostubs/loesung>

Testen und Debuggen von OOStuBS

  • Wenn ihr euer OOStuBS mit dem Emulator (bochs) testen wollt, dann ruft ihr einfach make bochs auf, was den Emulator mit dem Diskettenimage als virtueller eingelegter Diskette startet:
    wanja@faui48a:~/oostubs/loesung> make bochs
  • Alternativ kann man bochs auch mit eingebautem GDB-Stub verwenden, um sich mit einem Debugger (gdb oder ddd) zu der Emulation zu verbinden. Auf diese Weise könnt ihr bequem durch euren Betriebssystemcode steppen, um den Grund für Abstürze oder ungewünschtes Verhalten herauszufinden. Dafür stellen wir im Makefile ein Target bochs-gdb bereit:
    wanja@faui48a:~/oostubs/loesung> make bochs-gdb
    In dieser Konfiguration gibt bochs eine Portnummer aus (von uns eingestellt auf die Prozess-ID des Skripts; falls der Port schon benutzt wird, einfach noch einmal das Skript ausführen, um eine neue Prozess-ID und damit auch eine neue Port-Nummer zu erhalten), über die sich ein gdb oder ddd mit bochs verbinden kann, um das System zu debuggen. Dazu solltet ihr ein weiteres Fenster öffnen oder bochs im Hintergrund starten. Beim gdb-Aufruf darf nicht das Diskettenimage als Parameter angegeben werden, sondern die Datei build/system, da nur sie die nötigen Debug-Informationen enthält. Mit target remote localhost:Portnummer verbindet sich nun der Debugger mit dem GDB-Stub von bochs. Die beiden Targets gdb und ddd in dem von uns bereitgestellten Makefile erledigen dies bereits für euch; zusätzlich führen sie noch ein break main und continue aus, so dass der Debugger bei main () startet.
    wanja@faui48a:~/oostubs/loesung> make gdb
    wanja@faui48a:~/oostubs/loesung> make ddd
    Die folgende, eventuell auftretende Warnung des Debuggers, dass er beim Verbinden eine Antwort des GDB-Stubs nicht versteht, könnt ihr ignorieren:
    warning: Remote failure reply: Eff
  • Zum Testen mit richtiger PC-Hardware (Referenzplattform!) müsst ihr eine Bootdiskette (1,44 MB, 3.5") erstellen. In unserem Rechnerübungsraum (01.155-N) stehen dazu diverse Linux-PCs bereit (faui07a-j), auf denen ihr euch einloggen könnt. Dort könnt ihr dann die Bootdiskette schreiben. Ein separater Rechner steht als Testrechner zur Verfügung. Bitte verwendet nur diesen Rechner zum Testen; die Linux-Rechner werden vom CIP-Pool administriert! Zu Hause könnt ihr natürlich auch euren eigenen PC oder Laptop verwenden. Zum Erstellen der Bootdiskette gibt es eine eigenes Makefile-Target bootdisk, welches das Diskettenimage auf die Diskette kopiert:
    wanja@faui07a:~/oostubs/loesung> make bootdisk
  Impressum Stand: 2007-11-22 14:51   AG, WH