Skip to main content.

Navigation:

Entwicklungsumgebung

Für die Bearbeitung der Programmieraufgaben haben wir die benötigte Software in unserem Labor auf Linux-Maschinen (eos-lab*) installiert. Eine Entwicklung unter Solaris wird von uns nicht direkt unterstützt. Ihr könnt die Aufgaben natürlich auch zu Hause bearbeiten. Wir empfehlen hierzu den Einsatz von Linux (od. FreeBSD). Weiter unten finden sich einige Hinweise, wie ihr euren 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 auftretende Pannen. Fehlgeschlagene Installationen werden von uns auch nicht als Entschuldigung für verspätete Abgaben der Aufgaben akzeptiert. Da sich bei der Betriebssystementwicklung ab und zu auch Fehler einschleichen können, solltet ihr euere Lösungen vor der Abgabe testen. Ihr könnt dazu den Emulator (bochs) und einen echten PC im Labor (G29-334) benutzen.

Achtung! Bei der Abgabe benutzen wir immer den echten PC um euere Lösung zu kontrollieren.

OOStuBS EOS-Labor (eos-lab*)

OOStuBS auf anderen Rechnern

OOSTUBS Umgebung

Windows

Um OOSTUBS unter Windows entwickeln zu können, benötigt ihr die Entwicklungsumgebung Cygwin und den Bochs-Emulator. Bei der Installation von Cygwin sind folgende Pakete mit auszuwählen:

Nachdem ihr Cygwin installiert habt, müsst ihr die Cygwin-Shell starten, damit euer home-Verzeichniss erstellt wird. In dieses Verzeichniss müsst ihr, wie später beschrieben, die Entwicklungsumgebung (oostubs.tar.gz) sowie die Vorgaben entpacken. Ist die Entwicklungsumgebung entpackt, müsst ihr das Entwicklungssystem (Win98 für Windows 98 / Me; WinNT für Windows NT / 2000 / XP) im Makefile angeben. Dazu sucht ihr die Zeile in der die Variable GENSYS deklariert ist und ändert sie, z.B:

GENSYS = Linux verändert ihr beispielsweise zu: GENSYS = WinNT

Anschließend könnt ihr das System genau wie im Labor übersetzen. Wenn ihr zur Entwicklung Eclipse nutzen möchtet, muss das CDT-Plugin von Eclipse installiert und ein MakeFile-Projekt, das auf euer Vorgaben bzw. Lösungsverzeichniss zeigt, erzeugt sein. Um das Projekt zu übersetzen, muss im Projekt nur die Targets für make (all, clear und bootdisk) definiert werden.

Zum Testen eures Systems könnt ihr ebenfalls den Bochs-Emulator verwenden. Dazu müsst ihr die Windowsversion des Emulators installieren. Im Unterverzeichnis bochs der Entwicklungsumgebung ist bereits eine Batch Datei bochs.bat vorbereitet, mit der ihr den Emulator einfach starten könnt, indem ihr als Parameter ein Bootdisk-Image angebt. Vorher müsst ihr allerdings in der bochs.bat den Installationspfad des Emulators in der Variable BXSHARE angeben (z.B. set BXSHARE=c:\Programme\bochs-2.1.1). Danach könnt ihr den Emulator mit dem gewünschten Image starten (z.B. $ bochs/bochs.bat loesung/build/bootdisk.img)

Linux, Unix, FreeBSD

Um OOSTUBS unter Linux, Unix oder FreeBSD entwickeln zu können, benötigt ihr zusätzlich zum GCC den Netwider Assembler (NASM) und den Bochs-Emulator. Sind die dazu notwendigen Pakete installiert, kann die Entwicklungsumgebung wie folgt erzeugt werden.

  1. Verzeichniss für die Umgebung erzeugen (z.B. ~/oostubs)
  2. oostubs.tar.gz in dieses Verzeichniss entpacken
  3. make im Unterverzeichniss bochs ausführen. Dieser Aufruf passt einmalig die Pfade für die Konfiguration an (ersetzt Variablen mit absoluten Pfaden!!!).
  4. Ob euer bochs richtig installiert und konfiguriert ist, könnt ihr nun testen, indem ihr ins Verzeichniss oostubs/ wechselt und dort den Befehl bochs.sh bochs/bootdisk.img ausführt. 
eosgr@eos-lab01:/tmp> cd ~
eosgr@eos-lab01:~> mkdir oostubs
eosgr@eos-lab01:~> cd oostubs
eosgr@eos-lab01:~/oostubs> tar xvfz oostubs.tar.gz
eosgr@eos-lab01:~/oostubs> cd bochs
eosgr@eos-lab01:~/oostubs/bochs> make

OOSTUBS übersetzen

Alle Vorgaben, die ihr von uns erhaltet, lassen sich korrekt übersetzen, enthalten aber nur unvollständigen Code. Ihr müsst den vorgegebenen Sourcecode vervollständigen, um die Aufgabe zu lösen. Hierzu solltet ihr am besten die Vorgaben in ein eigenes Verzeichnis kopieren, und die Aufgaben dort bearbeiten, da mit jeder Vorgabe neue Dateien hinzukommen werden. Ihr könnt diese dann später in euer Lösungsverzeichniss übernehmen.

eosgr@papst:~/oostubs> cp -R vorgabe1 loesung
eosgr@papst:~/oostubs> cd loesung
eosgr@papst:~/oostubs/loesung>

Achtung! Damit die Vorgaben compiliert werden können, müssen sie in das bei der Einrichtung der Entwicklungsumgebung von euch erstellt Verzeichniss (oostubs/) kopiert werden, da sie auf Dateien in diesem Verzeichniss zugreifen. Dazu müssen die Vorgaben (vorgabe1.tar.gz usw.) innerhalb dieses Verzeichnisses entpackt werden

      eosgr@papst:~/oostubs> tar xvfz vorgabe1.tar.gz

Das eigentliche Übersetzen von OOSTUBS erfolgt durch den Aufruf von 'make' im Lösungsverzeichnis. Alle .cc und .asm Dateien in diesem Verzeichnis werden daraufhin mit den entsprechenden Tools (Compiler bzw. Assembler) übersetzt. Mit Hilfe des Tools 'build', das in oostubs.tar.gz enthalten ist, wird dann in oostubs/loesung/build ein Diskettenimage generiert (bootdisk.img bzw. bootdisk.vmi).

eosgr@eos-lab01:~/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. -fno-rtti -fno-exceptions -o build/cgastr.o ./device/cgastr.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/guardian.o ./guard/guardian.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/cgascr.o ./machine/cgascr.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/main.o main.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/o_stream.o ./object/o_stream.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/strbuf.o ./object/strbuf.cc
g++ -c  -Wall -I. -fno-rtti -fno-exceptions -o build/appl.o ./user/appl.cc
ld -e startup -T sections -o ./build/system  ./build/_startup.o /proj/i4bs/i386/lib/crti.o
/proj/i4bs/i386/lib/gcc-lib/i386-linux/2.95.3/crtbegin.o ./build/_io_port.o ./build/cgastr.o
./build/guardian.o ./build/cgascr.o ./build/main.o ./build/o_stream.o ./build/strbuf.o
./build/appl.o /proj/i4bs/i386/lib/gcc-lib/i386-linux/2.95.3/crtend.o
/proj/i4bs/i386/lib/crtn.o
objcopy -O binary build/system build/system.img
../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 4752 bytes.
dd if=build/bootdisk.img of=build/bootdisk.vmi bs=1474560 conv=sync
0+1 records in
1+0 records out
eosgr@eos-lab01:~/oostubs/loesung>

OOSTUBS testen

Um euer Betriebssystem mit dem Emulator (bochs) zu testen, ruft ihr einfach den Emulator auf und übergebt ihm das Diskettenimage als Parameter. Ihr könnt euch dazu auch per ssh mit einem Rechner im Pool verbinden.

eosgr@papst:~eosgr> cd ~/oostubs/loesung/
eosgr@papst:~/oostubs/loesung> bochs.sh ./build/bootdisk.img

Zum Testen mit richtiger PC-Hardware könnt ihr natürlich auch euren eigenen PC oder Laptop mit einer Bootdiskette (1,44MB 3 1/2") verwenden. Zum Erstellen dieser Bootdiskette gibt es eine eigenes TARGET: make bootdisk. Da heutzutage die meisten Rechner schon kein Floppy-Laufwerk mehr besitzen, sollte man aber in Betracht ziehen, sein Betriebssystem mit Hilfe eines bootbaren USB-Sticks zu testen. Einen solchen USB-Stick kann man sich entweder mit Hilfe von GRUB oder SYSLINUX erzeugen. Dazu geht man wie folgt vor:

Vorbereitung

Zuerst muss sichergestellt werden, dass der USB-Stick auch bootbar ist. Die meisten verfügbaren Sticks sind in der Lage als Bootstick zu fungieren, es muss nur noch die Partition als bootbar gekennzeichnet werden. Zu diesem Zweck kann fdisk verwendet werden (Kommandos: o,n,a,w). Will man seinen Stick komplett neu erzeugen, sollten die folgenden Kommandos verwendet werden (/dev/sdb ist das Device auf das der Stick gemountet wird.):

  cat /dev/zero > /dev/sdb
  fdisk /dev/sdb
  mkfs.dosfs /dev/sdb1

GRUB

Als nächstes erstellt man sich ein temporäres Arbeitsverzeichnis und kopiert dorthin die notwendigen Dateien.

  mkdir -p ~/usbboot/boot/grub
  cp /boot/grub/*stage* ~/usbboot/boot/grub
  cp /.../memdisk ~/usbboot/boot/
  echo '(hd0) /dev/sdb' > ~/usbboot/boot/grub/device.map

Danach wird das Bootmenu von GRUB über die Datei 'grub.conf' konfiguriert. Dies geschieht, indem die Datei mit 

  touch ~/usbboot/boot/grub/grub.conf
angelegt und dann mit folgendem Inhalt versehen wird.

  default=0
  timeout=5
  title OO-Stubs
    kernel /boot/memdisk
    initrd /boot/bootdisk.vmi

Abschließend muss nur noch der eigentliche Bootloader installiert werden. Dazu wird der Stick gemountet (Hier in das Verzeichniss /mnt), das temporäre Arbeitsverzeichniss auf den Stick verschoben und das Progamm 'grub-install' aufgerufen.

  mount /dev/sdb1 /mnt
  mv ~/usbboot/boot/ /mnt
  grub-install --root-directory=/mnt /dev/sdb

Der USB-Stick sollte nun bootbar sein und mit Hilfe von memdisk bei jedem Bootvorgang das Bootimage in 'bootdisk.vmi' starten. Durch einfaches Austauschen diese Images kann auch das gestartete Betriebssystemeinfach ausgetauscht werden.

SYSLINUX

Nachdem sichergestellt wurde, dass der Stick bootbar und das bootable-Flag gesetzt ist, wird zuerst ein temporäres Arbeitsverzeichniss erstellt.

  mkdir -p ~/usbboot/boot/

Dorthin wird die Datei memdisk kopiert und die Datei syslinux.cfg erzeugt. Die Datei syslinux.cfg sollte den folgenden Inhalt haben.

  PROMPT 1
  TIMEOUT 0
  DEFAULT 0

  LABEL 0
    KERNEL /boot/memdisk
    APPEND initrd=/boot/bootdisk.vmi

Abschließend wird SYSLINUX auf dem Stick installiert und das temporäre Arbeitsverzeichniss auf den Stick verschoben.

  syslinux /dev/sdb1
  mount /dev/sdb1 /mnt
  mv ~/usbboot/boot/ /mnt