Achtung : Skript ist nicht notwendigerweise identisch mit den  mündlichen Erläuterungen !!!
                        

1. Einführung

Ziel der Übungen ist es, den praktischen Umgang mit konkreten Systemen einzuüben sowie Teile der theoretischen Konzepte in funktionierende Systeme umzusetzen.

Da das primäre Ziel darin besteht, Realzeitsysteme verstehen und erzeugen zu können, zielt diese Übungen darauf ab, möglichst schnell ein Verständnis für die praktische Generierung eines  Realzeitsystems zu bekommen, um so die Voraussetzungen zu schaffen, eigene Modelle gezielt implementieren zu können.

Ziel der heutigen Übung ist es, zunächst das Entwicklungswerkzeug ELinOS der Firma Sysgo AG nutzen zu lernen, ohne dass schon alle technischen und theoretischen Hintergründe geklärt sind; dies erfolgt schrittweise im Verlauf der nächsten Vorlesungen und Übungen (Achtung: für diese Übung benutzen wir nicht die neueste Version von ELinOS).

Für die ersten Beispiele wird ferner angenommen, dass diese Systeme per Diskette gebootet werden sollen. Die Libraries für Intel- und PowerPC-Plattformen stehen zur Verfügung. Wir werden zunächst nur die Intel-Plattformen berücksichtigen. Damit kann jeder das selbst erzeugte Betriebssystem auf jedem Intel-PC ausprobieren (andere Bootverfahren werden im weiteren Verlaufe noch behandelt. Wer z.B. das Booten von CD-ROM anstatt des Bootens von Floppy benutzen will, kann dies tun. Sofern die von CD-ROM bootfähige Version gut dokumentiert ist und sich durch andere reproduzieren lässt, gibt es dafür zusätzliche Übungs-Punkte).

2. ELinOS im RT-Lab

Die Software ELinOS steht jedem Studenten nach der Anmeldung entweder direkt im Realzeitlabor zur Verfügung oder über ssh von zu Hause aus ( 'ssh eigener_login_name@194.94.80.8' ). Die fertig kompilierten Dateien kann man dann mittels 'sftp eigener_login_name@194.94.80.8' auf den eigenen Rechner herunterladen und dort bootfähig machen. Wie dies geht, wird weiter unten beschrieben.

3. Eigenes init.c Programm

Das erste Projekt zur Erzeugung eines bootfähigen Systems soll gleich auch mit einer eigenen init.c Datei starten.  Damit kann man von Anbeginn festlegen, wie sich das System verhalten soll. Als Beispiel sei hier ein ganz einfaches init.c-Programm aufgelistet:

/*******************************
 *
 * init.c
 *
 * ****************************/

#include <stdio.h>
#include <unistd.h>


int main(void)
{
  int i;

  /***************************************
   Linux doesn_t like init to finish, therefore
   an infinite loop will be prepared...
  ***************************************/

	for(;;)
	{
		printf("Hallo wrld!!!\n");
		printf("This is the first Programm ...");
		for(i=0; i<100000000; i++){;}
	}
	
	return 0;
}

Bevor dieses Programm benutzt werden kann, müssen wir zunächst ein bootfägiges System mit einer init.c-Datei erstellen, die wir dann durech unsere eigene init.c-Datei ersetzen. Dieses System erstellen wir, indem wir uns auf den FH-Informatik-Realzeit-Server einloggen und die dort installierte ELinOS-Software benutzen.

4. Ferncompilierung

Von zu Hause aus startet man ein Shellfesnter und gibt den Befehl ssh eigener_login@194.94.80.8 ein.  Hier mein Beispiel:
gerd@kant:~/public_html/fh/I-RT05/EX/EX4> ssh doeben@194.94.80.8
Password:
Last login: Wed Dec 14 18:27:53 2005 from .....t-dialin.net
Have a lot of fun...

doeben@webserver:~> ls
BusyBox  Desktop   devc++    I-RT05    KDesktop1   Mail  nsmail             public_html  TEST
c++      Desktop1  DISKUSSION  index.html           KDesktop  kurse.html  MND   OpenOffice.org1.1  scilab.hist

Ich lande in  meinem eigenen Homeverzeichnis.  Dort gibt es erwartungsgemäss einige Ordner. Es gibt aber noch keinen Ordner MyFirst. Es soll jetzt mit Hilfe von ELinOS ein schon bestehendes Demoprojekt 'Hello' geklont werden, und zwar in den eigenen ordner mit Namen MyFirst.

START

5. Projekt MyFirst

Wir beginnen damit, ein schon vorhandes Projekt mit Namen 'Hello' im Verzeichnis '/opt/elinos/demos' in ein lauffähiges eingebettetes System zu verwandeln.

Der erste Schritt besteht darin, einen 'Clone' dieses Projektes zu erzeugen. Dazu wird zunächst nicht das grafische Frontend benutzt, sondern die verfügbaren Shell-Befehle, hier der Befehl elinos-cloneproject im Verzeichnis /opt/elinos/bin.Bevor man mit der Generierung des Programms beginnt muss man in das Verzeichnis /opt/elinos  wechseln, da nur dort die Quota für Studenten aufgehoben ist. Man muss das Quellprojekt angeben und den Zielnamen (Die nachfolgende Bildschirmausgabe stammt von einem lokalen Linuxrechner. Die Angaben sind aber direkt übersetzbar).

Hier muss man sich für eine Architektur entscheiden. Für ältere PCs hat sich die Option '486' bewährt.

Hier folgen nun weitere Eingaben:

Damit sind die Vorbereitungen getroffen. Man muss jetzt nur eine Reihe von Umgebungsvariablen mittels des Shell-Scripts ELINOS.sh initialisieren. Dies tut man, indem man die Shell mit dem vorgeschalteten Punkt startet:

Dies sind nur einige der vielen Shellvariablen, die gesetzt werden. Man koennte sich auch all anzeigen lassen. Hier nun kann man die vorerzeugte init.c-Datei durch die eigene init.c-Datei ersetzen. Dazu muss man die Datei init.c im Verzeichnis src/rc ersetzen. Dies erfolgt in 2 Schritten: (i) Löschen der vorgegebenen Datei, (ii) Hochladen der eigenen Datei.

Nachdem man sich aus der ssh ausgelogged hat, greift man mittels sftp wieder neu zu, um die eigene Datei hochzuladen:

Nun gibt es den Ordner 'MyFirst'. In diesen muss man hineingehen und dort im Verzeichnis src/rc die neue Datei init.c ablegen:

Nachdem die eigene Datei in den ordner src/rc eingefügt worden ist, muss man sich wieder mittels ssh einloggen, um den Kopiervorgang starten zu können.

Wir schauen kurz nach, ob auch tatsaechlich die eigene Datei vorhanden ist:

Es sieht so aus. Dann starten wir den Bootprozess. Das kann etwas dauern...

Nachdem alles kompiliert worden ist, fordert das Programm uns auf, die folgenden Dateien auf eine Diskette zu kopieren. Anschliessend muss die Floppy bootfähig gemacht werden.

Da wir aus der Ferne kein Floppy einlegen können holen wir uns die Dateien mit sftp auf den eigenen Rechner, präparieren dort eine Floppy und machen diese dann bootfähig (alternativ würde man die Dateien auf eine CD-ROM bringen oder auf einen USB-Stick. Für die vorliegende Übung werden allerdings nur Floppy oder CD-ROM akzeptiert).

Da es bis jetzt noch kein Verzeichnis MyFirst auf dem lokalen Rechner gibt, wird dieser Ordner jetzt angelegt, um darin die Dazeien abzulegen:

Damit sind alle Dateien im lokalen Ordner MyFirst. Damit kann man sich wieder ausloggen und die Übertragung auf die Floppy vorbereiten. Entweder man hat schon eine fertig formatierte MS-DOS-Diskette oder man muss eine erstellen. Unter Linux bieten sich folgende Befehle an:

Falls man die mtools installiert hat (was bei den meisten Distributionen der Fall ist), kann man nun einfach die m-Befehle benutzen:

Das Floppy ist formatiert. Jetzt müssen die Dateien vom lokalen Verzeichnis auf das Floppy kopiert werden. Dabei ist zu beachten, dass die Datei mit Namen 'vmlinuz' umbenannt werden muss in 'linux'.

Jetzt sind zwar alle Dateien auf dem Floppy, aber man muss es noch bootfähig machen.  Dies kann man unter Linux mit dem recht vielseitigen Programm 'syslinux' tun. Man kann sich dieses programm entweder selbst aus dem Internet herunterladen und installieren, oder aber --für den vorliegenden Fall-- einfach mittels sftp aus dem Verzeichnis /opt/elinos/bin herunterladen.

Nachdem man das Programm heruntergeladen hat, kann man mit diesem Programm dann die Diskette bootfähig machen. Dazu muss man normalerweise root sein. Statt sich als normaler User abzumelden und als root neu anzumelden kann man verschiedene Umwege gehen. einer ist der Befehl 'sudo' (:= super user do). Man gibt den Befehl ein gefolgt von dem Befehl ./syslinux und dem Argument /dev/fd0:

Ab jetzt sollte diese Diskette von jedem geeigneten Intel-PC als Bootdiskette akzeptiert werden. Man muss sich allerdings vergewissern, dass im Falle einer bootfähigen Floppy der PC auch so eingestellt ist, dass er zunächst vom Diskettenlaufwerk aus booten will. Wenn dies der Fall ist, dann kann man nun seine eigene bootfähige Diskette in das Laufwerk schieben und zuschauen, wie der PC mit dem eigenen System bootet.......Man sollte diesen letzten Test eher nicht erst während der Übung machen. Das könnte schiefgehen.....

6. Aufgabe

Die Übung Nr.4 zielt darauf ab, (i) das Programm ELinOS so benutzen zu lernen, dass man eigene Betriebssystemkerne bootfähig erzeugen kann, und (ii), dass man im Rahmen des Betriebssystems ein eigenes Programm init.c implementieren kann, das das Verhalten des Systems steuert.

Erwartetes Ergebnis: eine bootfähige beschriftete Diskette mit einem eigenen ausführbaren Programm, das sich von den vorausgehenden Beispielen unterscheidet. (5 Pkt). Dazu kleiner Vortrag und Dolumentation des eigenen init.c-Programms.

Sonderpunkte: Falls ein Team es schafft, eine bootfähige CD-ROM zu erstellen, wobei der Prozess der Erstellung gut dokumentiert sein muss und von Dritten reproduzierbar ist, dann kann es  dafür bis zu 10 Pkte extra geben.