Das Relay-Subsystem ermöglicht den Datenaustausch großer Datenmengen zwischen Kernel- und Userspace in Hochgeschwindigkeit. Diese Kern-Technik-Folge erklärt dies Schritt für Schritt.

Debug- oder Log-Informationen werden innerhalb des Kernels klassischerweise mit Hilfe von »printk()« in den Userspace übertragen und dort vom Syslog weiterverarbeitet. Neben dieser einfachen Variante hat sich in der Vergangenheit das Proc- und seit neuestem das Debug-Filesystem etabliert. Ob per »printk()« oder mit der Ausgabe über ein virtuelles Dateisystem: Der Transfer großer Datenmengen zwischen Kernel und Applikationen ist aufwändig und zudem programmiertechnisch kompliziert. Daten werden nämlich zuerst in Puffern (die überlaufen können) zwischengespeichert, bevor sie im Speicherbereich einer Applikation landen.

Um diese Probleme zu lösen, entwickelten einige Kernelhacker mit dem Relay-FS ein neues, virtuelles Dateisystem, das einerseits einfach zu handhaben ist und andererseits dank »mmap()« einer Anwendung den direkten Zugriff auf die Daten ohne weiteren Kopiervorgang ermöglicht. Mit dem Kernel 2.6.14 nahm Linus Torvalds dieses Dateisystem in den Kernel auf.

Suchen Sie allerdings in einem aktuellen Kernel nach dem Relay-Filesystem, wird die Suche vergeblich sein: Getreu dem Motto "Keep it simple" haben die Entwickler den Code kräftig abgespeckt, einige Betriebsmodi wie Lockless und den Part des virtuellen Dateisystems komplett entfernt und nur das Kernfeature übrig gelassen: schnelle Transfers großer Datenmengen zwischen Kernel- und Userspace. Statt eines speziellen Filesystems sollen die Nutzer jetzt die vorhandenen virtuellen Dateisysteme nutzen, insbesondere das Debug-Filesystem. An einer einfachen Anbindung des Sys-FS arbeiten die Entwickler noch.

Debug-Filesystem hilft

Wollen Sie also von einem Treiber oder einem anderen Kernelmodul aus einer Anwendung Daten zur Verfügung stellen, bietet sich eine Relay-Datei im Debug-Filesystem an. Das Verfahren ist denkbar einfach (siehe Abbildung 1): Als Erstes legen Sie mit »debugfs_create_dir()« im Debug-Filesystem ein Verzeichnis an und erzeugen dann einen so genannten Relay-Kanal (»rchan«, »relay_open()«, siehe Tabelle 1).

Abbildung 1: In vier Schritten zum eigenen Relay-Kanal. Dann ist er mit der Funktion »relay_write()« verwendbar.

Tabelle 1: Interface des Relay-Subsystems

Dafür ist es nötig, zwei kurze Callback-Funktionen zu implementieren (siehe Abbildung 2). Den ersten Callback ruft der Kernel auf, wenn das Relay-Subsystem die Relay-Datei anlegen möchte. Erzeugen Sie dazu die Datei mit Hilfe des Debug-Filesystems (siehe Kasten "Debug-Filesystem"). Der zweite Callback wird aufgerufen, um die Relay-Datei wieder zu entfernen. Damit löschen Sie die zuvor erzeugte Datei im Debug-Filesystem wieder.

Abbildung 2: Bei den zu implementierenden Callbacks für eine Relay-Datei sind optionale und obligatorische zu unterscheiden.

01 ...
02 static struct dentry *vardir, *varfile;
03 static u32 index=99;
04 
05 static int __init mod_init(void)
06 {
07     vardir = debugfs_create_dir("vardir", NULL);
08     if( vardir==NULL ) {
09         printk("Kann debugfs-dir nicht anlegenn" );
10         return -EIO;
11     }
12     varfile = debugfs_create_u32("index", S_IRUGO|S_IWUGO, vardir, &index);
13     if( varfile==NULL ) {
14         printk("Kann debugfs-file nicht erzeugenn");
15         debugfs_remove( vardir );
16         return -EIO;
17     }
18     printk("Laden: index hat den Wert: %dn", index );
19     return 0;
20 }
21 
22 static void __exit mod_exit(void)
22 {
23     printk("Entladen: index hat den Wert: %dn", index );
24     debugfs_remove( varfile );
25     debugfs_remove( vardir );
26 }
27 ...

Tabelle 2: Kernel-Schnittstelle zum Debug-Filesystem

Mehrere CPUs

Die über den so angelegten Relay-Kanal publizierten Informationen bildet der Userspace auf einen Dateizugriff ab, wobei für jede CPU eine eigene Ausgabedatei existiert. Auf einer Einprozessor-Maschine gibt es also eine, auf einer Zweiprozessor-Maschine zwei Relay-Dateien. Hintergrund dieser Maßnahme: Jede CPU schreibt die Daten in eigene Per-CPU-Variablen (Ringpuffer), Locking ist nicht notwendig (siehe [1]). Der für jede CPU einmal vorhandene Ringpuffer unterteilt sich wiederum in Teilpuffer (siehe Abbildung 3).

Abbildung 3: Kernel-intern ist die Relay-Datei als Ringpuffer realisiert, der seinerseits aus mehreren Teilpuffern besteht.

Größe und Anzahl dieser Puffer werden beim Erzeugen des Kanals festgelegt. Die Gesamtgröße des verwendeten Speichers ergibt sich über die Formel: Gesamtgröße = (Anzahl_Puffer * Puffergröße) * Anzahl_Prozessoren.

Mehrere Kriterien bestimmen die Größe der einzelnen Puffer. Zum einen sollte sie ein Vielfaches von 2 sein und am besten in Beziehung zu einer Page (4096 Bytes) stehen. Das Relay-Subsystem reserviert den notwendigen Speicher nämlich auf Basis von Speicherseiten. Zum anderen sollte die längste, durch einen Funktionsaufruf zu schreibende Nachricht in den Puffer passen. Denn das Relay-Subsystem weigert sich aus Performance-Gründen, Log-Messages auf mehrere Puffer aufzusplitten. Wählen Sie beispielsweise eine Puffergröße von 128 Bytes, können Sie nicht mit einem einzelnen Aufruf 129 Bytes schreiben, die Daten würden verworfen.

Sind die zu schreibenden Häppchen klein genug, werden sie hintereinander in den aktiven Puffer geschrieben, solange noch ausreichend Platz ist, um die Nachricht komplett abzulegen. Sollte der Puffer bereits so weit gefüllt sein, dass die Daten des aktuellen Auftrags nicht mehr hineinpassen, gilt der Puffer als gefüllt, auch wenn einige Bytes ungenutzt bleiben, die man Padding-Bytes nennt. Die Daten des aktuellen Auftrags fließen dann in den nächsten Puffer.

Sobald der letzte Puffer gefüllt ist, legt das Relay-Subsystem die Daten wieder im ersten Puffer ab. Ob es tatsächlich dazu kommt, hängt allerdings davon ab, ob eine Applikation die Daten in der Zwischenzeit gelesen hat. Ist dies nicht der Fall, werden die neuen Daten verworfen. Zur Realisierung zählt das Relay-Subsystem beim Aufruf von »read()« mit, wie viele Daten bereits in den Userspace transferiert wurden.

Sie können diesen Artikel als PDF für 99 Cent kaufen. Klicken Sie dazu einfach auf eine der beiden Bezahloptionen Paypal oder ClickandBuy.

Das Relay-Subsystem ermöglicht den Datenaustausch großer Datenmengen zwischen Kernel- und Userspace in Hochgeschwindigkeit. Diese Kern-Technik-Folge erklärt dies Schritt für Schritt.