Die Ausgabe von dmesg zeigt, daß die Funktion cleanup_module() ausgeführt wurde.

Nun müssen wir nur noch wissen, wie man einem Modul Parameter übergeben kann. Dies geht aber überraschend einfach. Man kann den globalen Variablen Werte zuweisen, indem man die Zuweisung als Parameter von insmod schreibt. Zum Beispiel:

# insmod beispiel1.o output=4

# dmesg | tail -3

Output= 1

Adios, Bye, Ciao, Au revoir

Output= 4

Wir wissen jetzt schon alles Notwendige über Module, kehren wir zu RT-Linux zurück.

Das Echzeitprogramm

Erinnern wir uns, daß wir, um RT-Linux benutzen zu können, zuerst den Linuxkernel so vorbereiten mußten, daß er die Echtzeitmodule unterstützt. Dieser Vorgang wurde in der ersten Ausgabe dieser Serie beschrieben.

Man kann RT-Linux auf zwei unterschiedliche Arten anwenden:

1. Wie ein klassisches Echtzeitsystem mit einem Scheduler basierend auf festen Prioritäten.

2. Wie ein nackter PC, so ähnlich, wie man es in DOS machen kann: die Interrupts festhalten und die totale Kontrolle über den Computer übernehmen.

In diesem Artikel werde ich nur beschreiben, wie man RT-Linux entsprechend einem System mit festen Prioritäten einsetzt. Das Beispiel, das wir sehen werden, macht nichts Nützliches, es setzt lediglich ein Echtzeittask in Betrieb, nämlich eine einfache Schleife:

        
  #define MODULE
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/version.h>
  #include <linux/rt_sched.h>
  RT_TASK task;
          
  void fun(int computo) {
    int loop,x,limit;
    limit = 10;
    while(1){
      for (loop=0; loop<computo; loop++)
        for (x=1; x<limit; x++);
        
      rt_task_wait();
    }
  }
  
  int init_module(void) {

    RTIME now = rt_get_time(); 

    rt_task_init(&task,fun, 50 , 3000, 1);
    rt_task_make_periodic(&task,
          now+(RTIME)(RT_TICKS_PER_SEC*4000)/1000000,
         (RTIME)(RT_TICKS_PER_SEC * 100)/1000000);
    return 0;
  }

  void cleanup_module(void){
    rt_task_delete(&task);
  }
   

Um es zu kompilieren, verwenden wir folgende Befehlszeile:

# gcc -I /usr/src/linux/include/linux -O2 -Wall -D__KERNEL__ -D__RT__ -c beispiel2.c

Da dieses Programm ein Modul ist, ist der Ausgangspunkt die Funktion init_module(). Als erstes liest es den aktuellen Zeitpunkt und speichert ihn in einer lokalen Variablen; die Funktion rt_get_time() gibt die Zahl der RT_TICKS_PER_SEC zurück, die abgelaufen sind, seit der Computer gestartet wurde (in der aktuellen Einstellung hat RT_TICKS_PER_SEC den Wert 1.193.180, was eine Auflösung von 0.838 Mikrosekunden ergibt). Mit rt_task_init() wird die Struktur task initialisiert, doch der Task startet noch nicht. Das Hauptprogramm des zuvor erzeugten Task ist fun(), der zweite Parameter. Der folgende Parameter ist der Wert, der an den neuen Task übergeben wird, wenn seine Ausführung beginnt. Man beachte, daß fun() einen Parameter vom Typ int erwartet. Der folgende Parameter ist die Größe des Taskstapels. Da jeder Task eine eigene Ausführungsablauf hat, braucht er einen eigenen Stapel. Der letzte Parameter ist die Priorität. In diesem Fall, mit nur einem Task im System, kann jeder beliebige Wert für die Priorität gesetzt werden.

rt_task_make_periodic() macht den Task zu einem periodischen Task. Die Funktion erwartet zwei Zeitwerte als Parameter. Die erste Zeitangabe ist der absolute Zeitpunkt, zu dem er aktiviert wird und der nächste Parameter gibt den Zeitabstand zwischen den aufeinanderfolgenden Aktivierungen an.

Der Echtzeittask (Funktion fun()) ist eine Endlosschleife, in der es nur zwei Aktionen gibt: eine Schleife, die nur der Zeitverwaltung dient, und der Aufruf von rt_task_wait(). rt_task_wait() ist eine Funktion, die die Ausführung des Task, der sie aufruft, bis zur nächten Aktivierung unterbricht. Dann wird die nächste Anweisung nach rt_task_wait() ausgeführt. Beachte, daß ein periodischer Task nicht bei jeder Aktivierung von Anfang an ausgeführt wird, sondern daß der eigentliche Task stehen bleiben (wenn er seine Arbeit erledigt hat) und auf die nächste Aktivierung warten muß. Auf diese Weise kann man einen Task programmieren, der nur bei der ersten Aktivierung bestimmte Initialisierungsaufgaben erledigt.

Um beispiel2 ausführen zu können, muß man zuerst das Modul rt_prio_sched installieren, danach braucht man die Funktionen rt_task_make_pericodic(), rt_task_delete() und rt_task_init(). Die Funktion rt_get_time() ist in keinem Modul enthalten, sondern ist in den Kernel kompiliert, weshalb man nichts installieren muß, um sie verwenden zu können.

# modprobe rt_prio_sched

# insmod ./beispiel2.o

Da rt_prio_sched ein Systemmodul ist - es wurde bei der Kompilierung des Linuxkernels erzeugt und ins Verzeichnis /var/modules/2.0.33/ kopiert - kann man den Befehl modprobe anwenden, der eine einfachere Möglichkeit darstellt, Module zu laden (modprobe kann das benötigte Modul in verschiedenen Verzeichnissen suchen; siehe modprobe(1)).

Wenn alles gut gegangen ist, kann man mit dem Befehl lsmod feststellen, daß die zwei Module richtig geladen worden sind.

Also, jetzt haben wir schon ein Echtzeittask zum Laufen gebracht. Fällt Dir etwas auf? Wenn der Prozessor ein bißchen langsam ist, bemerkst Du vielleicht schon, daß Linux etwas gemächlicher läuft als sonst. Man kann die Zahl der Iterationen der Schleife von fun() erhöhen, indem man den dritten Parameter von rt_task_init() verändert. Eine Möglichkeit zu sehen, daß Linux weniger Prozessorzeit hat, ist das Programm ico. Die Zeit, die von den Echtzeittasks gebraucht wird, bewirkt, daß der Prozessor langsamer zu laufen scheint. Linux glaubt, daß alle seine Prozesse mehr Zeit für diesselbe Arbeit benötigten. Wenn jetzt die Rechenzeit des Tasks (die Zeit, die für die Ausführung aller Iterationen der Schleife notwendig ist) länger ist als 100 ms, scheint Linux, sich "aufzuhängen", denn es ist der Task im Hintergrund und der Echtzeittask beansprucht 100 % der Rechenzeit. In Wirklichkeit hat sich Linux NICHT aufgehängt, es hat einfach keine Prozessorzeit zur Verfügung.

Kommunikation zwischen Tasks

In RT-Linux gibt es nur eine Kommunikationsform: Real-Time FIFO. Die Arbeitsweise ist den Pipes von Unix sehr ähnlich, die Kommunikation geschieht über einen Datenfluß ohne Struktur. Ein FIFO ist ein Bytes-Puffer mit fester Größe, auf den durch Lese- und Schreiboperationen zugegriffen werden kann.

Mit den FIFOs können Echtzeittasks sowohl unter sich als auch mit normalen Linuxtasks kommunizieren.

Aus der Sicht eines normalen Linuxprozesses ist ein FIFO eine spezielle (zeichenorientierte) Datei. Normalerweise ist sie in /dev/rtf0, /dev/rtf1, usw. Diese Dateien existieren in Linux nicht, weshalb man sie anlegen muß. Das kann man folgendermaßen machen:

# for i in 0 1 2 3; do mknod /dev/rtf$i c 63 $i; done

Wenn man mehr FIFOs braucht, legt man sie einfach an: rtf4, rtf5 usw. Diese speziellen Dateien sind die Schnittstellen für einen Treiber des Betriebssystems, aber wenn es keinen Treiber gibt, nützt die Datei nichts. Der Versuch, eine spezielle Datei zu öffnen, für die das Betriebssystem keinen Treiber hat, wird fehlschlagen.

Aus der Sicht eines Echtzeittasks werden die FIFOs mittels spezieller Funktionen angesprochen:

• rt_create(unsigned int fifo, int size): erzeugt ein FIFO mit einem Puffer der Größe size. Von da an existiert das Device, zu dem man von /dev/rtf[fifo] aus Zugang hat, und man kann es benutzen bis man es löscht.

• rt_destroy(unsigned int fifo): löscht das FIFO und macht den Speicher frei.

• rt_fifo_put(fifo, char *buf, int count): versucht count Bytes aus dem Puffer buf zu schreiben. Wenn im FIFO nicht genügend Platz ist, wird -1 zurückgegeben.

• rt_fifo_get(fifo, char *buf, count): versucht count Bytes aus dem FIFO in buff einzulesen. Wenn nicht genügend Daten zu Verfügung stehen, wird -1 zurückgegeben.

Sehen wir nun ein Beispiel eines Systems, das von diesen Funktionen Gebrauch macht. Dieses Beispiel ist eine kleine Abänderung eines der Beispiele des RT-Linux-Pakets (sound):

        
  #define MODULE
  #include <linux/module.h>
  #include <linux/rt_sched.h> 
         
  #include <linux/rtf.h>
  #include <asm/io.h>

  RT_TASK task;  

  static int filter(int x){
    static int oldx;
    int ret;
    if (x & 0x80) {
      x = 382 - x;
    }
    ret = x > oldx;
    oldx = x;
    return ret;
  }

  void fun(int dummy) {
    char data;
    char temp;
    while (1) {
      if (rtf_get(0, &data, 1) >  0) {
        data = filter(data);
        temp = inb(0x61);            
        temp &= 0xfd;
        temp |= (data & 1) <<  1;
        outb(temp,0x61);
      }
      rt_task_wait();
    }
  }

  int init_module(void){
    rtf_create(0, 4000);
    
    /* enable counter 2 */
    outb_p(inb_p(0x61)|3, 0x61);
    
    /* to ensure  that the output of the counter is 1 */
    outb_p(0xb0, 0x43);
    outb_p(3, 0x42);
    outb_p(00, 0x42);
    
    rt_task_init(&task, fun,  0 , 3000, 1);   
    rt_task_make_periodic(&task, 
                   (RTIME)rt_get_time()+(RTIME)1000LL, 
                   (RTIME)(RT_TICKS_PER_SEC / 8192LL));

    return 0;
  } 

  void cleanup_module(void){
    rt_task_delete(&task);  
    rtf_destroy(0);
  }
   

Genau wie im Beispiel2 brauchen wir das Modul rt_prio_sched, aber hier benötigen wir auch das Modul rt_fifo_new, um die FIFOs verwenden zu können.

Es wird ein periodischer Echtzeittask mit einer Frequenz von 8192 Hz erzeugt. Dieser liest Bytes vom FIFO 0, und wenn er etwas findet, schickt er es an die Schnittstelle für den PC-Lautsprecher. Wenn wir eine Sound Datei im ".au"-Format nach /dev/rtf0 kopieren , können wir sie anhören. Man braucht nicht zu sagen, daß die Tonqualität miserabel ist, denn die Hardware des PC läßt nur ein Bit zur Erzeugung eines Signals zu. Im Verzeichnis testing/sound des Pakets befindet sich die Datei linux.au zum Ausprobieren.

Zur Kompilierung und Ausführung:

# gcc -I /usr/src/linux/include/linux -O2 -Wall -D__KERNEL__ -D__RT__ -c beispiel3.c

# modprobe rt_fifo_new; modprobe rt_prio_sched; insmod beispiel3.o

# cat linux.au > /dev/rtf0

Man beachte, wie man das Programm cat dazu benutzen kann, um in jede beliebige Datei zu schreiben, sogar in spezielle, wie etwa Gerätedateien (unter /dev/). Man könnte auch den Befehl cp verwenden.

Um sehen zu können, wie die Echtzeit die Wiedergabequalität beeinflußt, muß man einfach ein Programm schreiben, das dasselbe, aber in einem Userprozeß macht:

 #include <unistd.h>
  #include <asm/io.h>
  #include <time.h>

  static int filter(int x){
    static int oldx;
    int ret;
    if (x & 0x80)
      x = 382 - x;
    ret = x > oldx;
    oldx = x;
    return ret;
  }
  espera(int x){
    int v;
    for (v=0; v<x; v++);
  }
  void fun() {
    char data;
    char temp;

    while (1) {
      if (read(0, &data, 1) >  0) {
        data = filter(data);
        temp = inb(0x61);
        temp &= 0xfd;
        temp |= (data & 1) << 1;
        outb(temp,0x61);
      }
      espera(3000);
    }
  }

  int main(void){
    unsigned char dummy,x;
    ioperm(0x42, 0x3,1); ioperm(0x61, 0x1,1);

    dummy= inb(0x61);espera(10);
    outb(dummy|3, 0x61);

    outb(0xb0, 0x43);espera(10);

    outb(3, 0x42);espera(10);
    outb(00, 0x42);

    fun();
  }    
   

Dieses Programm wird wie ein normales Programm kompiliert:

# gcc -O2 beispiel4.c -o beispiel4

Und zur Ausführung:

# cat linux.au | beispiel4

Um von einem normalen Linuxprogramm aus auf die Hardwareschnittstellen des Computers zugreifen zu können, muß man sich vom Betriebssystem die Berechtigung verschaffen. Dies ist eine grundlegende und notwendige Schutzvorkehrung, um zu verhindern, daß ein Programm z. B. direkt auf die Festplatte zugreifen kann. Der Befehl ioperm() zeigt dem Betriebssystem an, daß man auf eine bestimmte Kategorie von E/A-Adressen zugreifen will. Der Zugriff wird nur den Programmen gewährt, die mit Superuserrechten ausgeführt werden. Als weiteres Detail ist hervorzuheben, wie die Frequenz von 8192 Hz erzeugt wird, mit der der Ton ertönt. Wenn auch einen Befehl nanodelay() existiert, so hat dieser nur eine Auflösung von einer Millisekunde, weshalb man den Zeitablauf durch eine Warteschleife steuern muß. Die Schleife wird so eingestellt, daß sie mehr oder weniger auf einem Pentium 100 MHz funktioniert.

Versuche nun, beispiel4 zusammen mit dem Programm ico auszuführen. Wie hört es sich an? Hast du den Eindruck, daß Echtzeit zu etwas zu gebrauchen ist?

Schlußfolgerung

Bibliographie:

"Online KURT" B. Srinivasan. http://hegel.ittc.ukans.edu/projects/kurt

"A Linux-based Real-Time Operating System" von Michael Barabanov. Master of Science, New Mexico Institute of Mioning and Technology.

"Linux as an Embedded Operating System" von Jerry Epplin http://www.embedded.com/97/fe39710.htm

"Implementing Loadable Kernel Modules for Linux" von Matt Welsh http://www.ddj.com/ddj/1995/1995.05/welsh.html

"Linux Kernel Internals" von M. Beck, H. Böhme, M. Dziadzka, U. Kunitz, R. Magnus, D. Verworner. Ed: Addison-Wesley.

"Programación Linux 2.0, API de sistema y funcionamiento del núcleo" von Rémy Card, Eric Dumas y Franck Mével. (Original auf französisch, übersetzt ins spanische). Ed: Eyrolles, Ediciones Gestión 2000.

"On Satisfying Timing Constrains in Hard-Real-Time Systems" von J. Xu & L. Parmas. IEEE Trans. on Software Engineering. Jan 1993