Hinweise zum Systemaufruf des Linux-Kernel-Gerätetreibers

/****************************
 * Systemaufruf********************************/

(1) Was ist ein Systemaufruf?

Der Systemaufruf ist die Schnittstelle zwischen dem Kernel und der Anwendung. Wenn die Anwendung auf Hardwaregeräte und andere Betriebssystemressourcen zugreifen möchte, muss sie dies über den Systemaufruf tun.

Unter Linux sind Systemaufrufe die einzige Möglichkeit für den Benutzer, auf den Kernel zuzugreifen. Abgesehen von Ausnahmen und Interrupts sind sie der einzige zulässige Einstiegspunkt in den Kernel. Die Anzahl der Systemaufrufe ist gering, nur etwa 300 auf i386.

(2) Beziehung zwischen C-Bibliothek und Systemaufrufen

Anwendungsprogrammierer programmieren über eine Anwendungsprogrammierschnittstelle (API) in der C-Bibliothek und nicht direkt über Systemaufrufe. Die Funktionen in der C-Bibliothek rufen möglicherweise keine Systemaufrufe auf, kapseln einfach einen Systemaufruf ein oder implementieren eine Funktion durch Aufrufen mehrerer Systemaufrufe.

Anwendung --> C-Bibliothek --> Kernel-Systemaufruf

Aus Sicht des Programmierers sind Systemaufrufe irrelevant, sie müssen sich nur mit der API befassen.

Aus Sicht des Kernels befasst sich der Kernel nur mit Systemaufrufen. Wie Bibliotheksfunktionen und Anwendungen Systemaufrufe verwenden, ist nicht Sache des Kernels.

Der Unix-Systemaufruf abstrahiert Funktionen, die zum Erreichen eines bestimmten Zwecks verwendet werden. Wie diese Funktionen verwendet werden, ist Sache des Benutzers und dem Kernel egal.

(3) Im Kernel implementierte Systemaufruffunktionen

Beispiel für die Verwendung von Systemaufrufen im Benutzerbereich

#include <unistd.h>
getpid();

Nach der Kapselung durch die glibc-Bibliothek wird schließlich die Funktion sys_getpid in kernel/timer.c im Kernel aufgerufen. Siehe diese Funktion. Alle Systemaufruffunktionen im Kernel beginnen mit sys_.

• asmlinkage weist den Compiler an, den lokalen Stack zur Parameterübergabe zu verwenden.
• Das FASTCALL-Makro weist den Compiler an, Register zur Übergabe von Parametern zu verwenden.

(4) Systemrufnummer

Da der Systemaufruf vom Benutzerbereich in den Kernelbereich gelangen muss, kann er nicht durch einen einfachen Funktionsaufruf abgeschlossen werden, sondern muss einige vom Prozessor unterstützte spezielle Mechanismen durchlaufen (den sogenannten Soft-Interrupt).

Unter x86 ist dieser spezielle Mechanismus der Assemblerbefehl int $0x80 und unter ARM der Assemblerbefehl SWI.

Dieser Befehl ist in einer Funktion in der C-Bibliothek gekapselt. Wenn das Programm diesen Befehl ausführt, wechselt die CPU in einen speziellen Ausnahmemodus (oder Soft-Interrupt-Modus) und springt mit dem Programmzeiger an eine bestimmte Stelle (z. B. 0x8 in der Interrupt-Vektortabelle für ARM).

Viele Systemaufrufe sind im Kernel implementiert. Die Adressen dieser Systemaufrufe werden der Reihe nach in einer Systemaufruftabelle abgelegt. Diese Tabelle ist ein Array namens sys_call_table mit insgesamt NR_syscalls-Einträgen. Über diese Tabelle können Sie alle vom Kernel definierten sys_-Funktionen aufrufen

Beim Aufruf der Assembler-Anweisung int $0x80 bzw. SWI muss gleichzeitig eine Systemaufrufnummer übergeben werden. Diese Systemaufrufnummer wird dann als Index verwendet, um den entsprechenden Systemaufruf aus der sys_call_table auszuwählen.

int80 speichert die Systemaufrufnummer im eax-Register, während SWI diese direkt in den Befehl integriert (wie SWI 0x124).

(5) Mechanismus zur Implementierung des Systemaufrufs

Die Funktion, die Systemaufrufe im Kernel verarbeitet, ist in system_call in arch/i386/kernel/entry.s definiert, während das Arm-System in vector_swi in arch/arm/kernel/entry-common.s definiert ist. Die Systemaufruftabelle für das x86-System ist in arch/i386/kernel/syscall_table.s (oder direkt in entry.s) definiert, während die Arm-Systemaufruftabelle in arch/arm/kernel/calls.s definiert ist. Die Systemaufrufnummer ist in include/asm/unistd.h definiert.

(6) Welche Aspekte sollten bei der Implementierung von Systemaufrufen beachtet werden?

Es ist nicht schwierig, Linux einen Systemaufruf hinzuzufügen. Die Schwierigkeit besteht jedoch darin, einen Systemaufruf zu entwerfen und zu implementieren. Linux befürwortet nicht die Verwendung von Mehrzweck-Systemaufrufen (Bereitstellung unterschiedlicher Funktionen basierend auf unterschiedlichen Parametern).

Systemaufrufe müssen die Gültigkeit eingehender Parameter, insbesondere der vom Benutzer bereitgestellten Zeiger, sorgfältig prüfen und Folgendes sicherstellen:

• * Der Speicherbereich, auf den der Zeiger zeigt, gehört zum Benutzerbereich, und der Prozess kann den Kernel nicht dazu verleiten, Daten im Kernelbereich zu lesen
• *Der Speicherbereich, auf den der Zeiger zeigt, gehört zum Adressraum des Prozesses und kann den Kernel nicht dazu verleiten, Daten aus anderen Prozessen zu lesen
• *Ein Prozess kann die Berechtigungen zum Speicherzugriff nicht umgehen.

Beim Ausführen eines Systemaufrufs befindet sich der Kernel im Prozesskontext und kann in den Ruhezustand versetzt oder unterbrochen werden. Daher muss der Systemaufruf reentrant sein.

(7) Ein Beispiel für einen Systemaufruf (einschließlich Kernelmodifikation und Programmimplementierung im User Space)

Implementieren Sie einen Systemaufruf sys_foo

a. Systemrufnummer hinzufügen

Ändern Sie include/asm/unistd.h , fügen Sie hinzu: #define __NR_foo 289 und ändern Sie: #define NR_syscalls 290

b. Zur Systemaufruftabelle hinzufügen

Ändern Sie arch/i386/kernel/entry.s oder syscall_table.s und fügen Sie hinzu:

.long sys_foo

c. Systemaufrufe müssen in das Kernel-Image kompiliert werden. Die Definition des Systemaufrufs kann in den Code eingefügt werden, der am engsten mit seiner Funktion zusammenhängt, z. B. kernel/sys.c, und hinzugefügt werden:

#include <asm/thread_info.h>
/* 
 * gibt die Größe des Kernel-Stacks zurück
 */
asmlinkage lang sys_foo(void)
{
 gibt THREAD_SIZE zurück;
}

d. Aufruf im Benutzerbereich

Normalerweise werden Systemaufrufe von der C-Bibliothek unterstützt, und glibc kann unsere eigenen Systemaufrufe nicht unterstützen. Derzeit müssen wir eine Reihe von Makros verwenden, die von Linux selbst bereitgestellt werden, um direkt auf die Systemaufrufe zuzugreifen.

man 2 syscall

Zusammenfassen

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Lernwert für Ihr Studium oder Ihre Arbeit hat. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM. Wenn Sie mehr darüber erfahren möchten, schauen Sie sich bitte die folgenden Links an