Was ist ein Linux-Geräteknoten?

Der Linux-Geräteknoten ist eine Brücke für die Kommunikation zwischen Anwendungen und Gerätetreibern. Der Geräteknoten wird in „/dev“ erstellt und ist der Hub, der den Kernel und die Benutzerschicht verbindet. Er entspricht dem Inode der Festplatte und der Datensätze die Informationen zum Hardware-Gerät. Geräteknoten ermöglichen es Benutzern, über Hardware mit dem Kernel zu kommunizieren, Geräte zu lesen und zu schreiben und andere Vorgänge auszuführen.

Die Betriebsumgebung dieses Tutorials: Linux5.9.8-System, Dell G3-Computer.

Was ist ein Geräteknoten?

Die Kommunikationsbrücke zwischen Menschen ist die Sprache. Ebenso benötigen Anwendungen und Gerätetreiber eine Brücke zur Kommunikation. Diese Brücke ist der Geräteknoten.

Bei Linux-Systemen sind alle E/A-Ressourcen Dateien, einschließlich Dateien, Verzeichnisse, Festplatten, Geräte usw. Nun, die Tastatur ist ein Eingabegerät im Computersystem, und das Betriebssystem abstrahiert sie auch von Dateien. Wenn Sie die vom Benutzer eingegebenen Daten über die Tastatur erhalten möchten, müssen Sie nur den von der Tastatur bereitgestellten Geräteknoten lesen .

In Linux-Systemen wird die Tastatur als Eingabegerät verwendet und der entsprechende Geräteknoten befindet sich unter „/dev/input“. In diesem Ordner befinden sich viele Dateien, die mit „event“ beginnen. Dies sind die Geräteknoten aller Eingabegeräte. Wie kann festgestellt werden, welcher Geräteknoten die Tastatur ist? Schließen Sie die Tastatur an den Raspberry Pi an, öffnen Sie das Terminal, führen Sie „sudo cat /dev/input/event0“ aus, tippen Sie auf die Tastatur. Wenn keine Ausgabe erfolgt, wechseln Sie zum nächsten Knoten, bis Sie einen Knoten mit Ausgabe finden, dann diesen Knoten ist die Tastatur Der entsprechende Geräteknoten.

Der Geräteknoten wird unter /dev erstellt und ist der Hub, der den Kernel und die Benutzerschicht verbindet. Dies bedeutet, dass das Gerät mit der ID der entsprechenden Schnittstelle verbunden ist. Es entspricht dem Inode einer Festplatte und zeichnet den Standort und die Informationen von Hardwaregeräten auf. Unter Linux werden alle Geräte in Form von Dateien im Verzeichnis /dev gespeichert und auf Geräteknoten zugegriffen Abstraktion von Geräten. Ein Geräteknoten ist eine Datei. Anwendungen greifen über einen standardisierten Satz von Aufrufen auf das Gerät zu, die unabhängig von einem bestimmten Treiber sind. Der Treiber ist dafür verantwortlich, diese Standardaufrufe tatsächlichen hardwarespezifischen Vorgängen zuzuordnen.

Die Rolle von Geräteknoten

Geräteknoten ermöglichen es Benutzern, mit dem Kernel auf Hardware zu kommunizieren, Geräte zu lesen und zu schreiben und andere Vorgänge auszuführen.

Unter Linux existieren Geräte wie gewöhnliche Dateien das Gleiche wie der Zugriff auf eine Datei

Die Hauptgerätenummer repräsentiert einen Gerätetyp und die Nebengerätenummer repräsentiert verschiedene Personen desselben Gerätetyps. Zu diesem Zeitpunkt kennen Sie möglicherweise nicht die Existenzform des Geräteknotens

Die Existenzform des Geräteknotens

Darüber hinaus gibt es in Linux ein weiteres Konzept, nämlich Inode und Block, bei denen es sich um Blöcke und Knoten auf einer Seite der Festplatte handelt Es zeichnet den Speicherort der Datei und den Speicherort der Datei auf. Beispielsweise sind einige Systeme 4 KB groß und die Inode-Größe ist begrenzt Es heißt, dass eine einzelne Datei 4G nicht überschreiten darf. Nach meinem persönlichen Verständnis kann der Knoten im Linux-Treiber als etwas Ähnliches wie der Inode der Festplatte betrachtet werden, der den Standort des Hardwaregeräts und andere Informationen aufzeichnen und verwendet werden kann, wenn der Benutzer darauf zugreifen muss. Greifen Sie auf das Gerät zu, indem Sie sich auf die vom Geräteknoten aufgezeichneten Informationen beziehen einheitliche Schnittstelle, um mit verschiedenen Geräten zu kommunizieren. Bei diesen einheitlichen Schnittstellen handelt es sich um eine Reihe von Systemaufrufen, die vom Betriebssystem für Dateivorgänge bereitgestellt werden: Öffnungsfunktion, Lesefunktion, Schreibfunktion usw. Wenn Sie beispielsweise Daten von einem Gerät abrufen müssen, müssen Sie nur die Lesefunktion aufrufen, um den dem Gerät entsprechenden Geräteknoten zu lesen. Natürlich müssen Sie vor dem Lesen zuerst die Open-Funktion aufrufen, um ihn zu öffnen. Nehmen wir nun als Beispiel die Tastatureingabe.

1. Öffnen Sie den Geräteknoten

Bevor Sie die Daten des Geräteknotens lesen, müssen Sie zunächst die Öffnungsfunktion aufrufen, um den Geräteknoten zu öffnen. Informationen zur spezifischen Verwendung der Öffnungsfunktion finden Sie unter dem Link. Eine kurze Beschreibung lautet wie folgt:

Funktionsdeklaration:

int open(const char *pathname, int flags);

Einzubindende Header-Datei:

　　#include <fcntl.h>

Parameter:

* Erster Parameter (const char *Pfadname): Gibt den Dateipfad an, der geöffnet werden muss

* Zweiter Parameter (int-Flags): Gibt die Art und Weise an, wie die Datei geöffnet werden soll, zum Beispiel „O_RDONLY“ – nur zum Lesen öffnen; „O_WRONLY“ – nur zum Schreiben öffnen usw.

Rückgabewert:

Wenn das Öffnen erfolgreich ist, wird der Dateideskriptor der Datei zur Verwendung durch Funktionen wie Lesen und Schreiben zurückgegeben. Andernfalls wird -1 zurückgegeben.

Um die Gerätedatei der Tastatur zu öffnen (vorausgesetzt, sie ist „/dev/input/even10“), benötigen Sie den folgenden Code:

  int keys_fd;
    keys_fd = open("/dev/input/even10", O_RDONLY);
    if(keys_fd <= 0)
    {
        printf("open /dev/input/event10 device error!\n");
        return -1;
    }

2. Um den Geräteknoten zu lesen , müssen Sie die Lesefunktion verwenden. Bitte beachten Sie den Link für spezifische Verwendungsmethoden. Eine kurze Einführung lautet wie folgt:

Funktionsdeklaration:

　　ssize_t read(int fd, void *buf, size_t count);

需要包含的头文件：

　　#include <unistd.h>

参数：

* 第一个参数（int fd）：要打开文件的文件描述符，来源一般是上述open函数的返回值。

* 第二个参数（void *buf）：读取到的数据存放的起始位置指针

* 第三个参数（size_t count）：要读取的数据字节数

返回值：

* 如果读取成功，则返回实际读取到的字节数

* 如果读取失败，则返回-1

* 如果返回值小于第三个参数count，则表示已经读取到文件结尾，返回值表示实际读取的字节数。

在读取键盘的例子中，我们循环读取键盘设备的文件节点，并将设备保存到一个char buf[24]的数组中去。具体代码如下：

char buf[24];
while(1)
{
    if(read(keys_fd, buf, 24) == 24)
    {
        // 成功的从设备节点中获取到了24个字节
        ...
    }
}

根据read函数用法，当要读取24个字节，且read函数的返回值是24时，表示成功的从设备节点中获取到了24个字节。

3、分析从设备节点获取的数据

为什么这里要从键盘的设备驱动获取24个字节呢？这是因为正常情况下，从键盘设备节点获取的数据实际上是一个struct input_event结构。其定义为：

struct input_event {
    struct timeval time;
    __u16 type;
    __u16 code;
    __s32 value;
};

显然，上述结构体的大小为24。

　　这里需要理解的是：设备节点是设备驱动程序提供的，且设备节点的数据是设备驱动写入的，而且写入时，是以上述结构的规则写入的，这是双方通过约定好的，那么应用程序去设备节点中读取数据之后，也需要按照上述结构去解析数据。那这个结构具体是什么意思呢？

* struct timeval time：其大小为16个字节，具体意义暂时不考虑。

* __u16 type：其大小为2个字节，表示input设备的类型，比如：EV_KEY表示上报的是键盘类型的数据，EV_REL表示相对路径，鼠标就属于这种类型，还是其他等等。

* __u16 code：其大小为2个字节，表示事件的代码。比如，如果type为EV_KEY，那么该代码code为设备键盘代码。code值实际上是应用程序和驱动程序约定好的一些固定的值，它可取的值位于include/uapi/linux/input-event-codes.h中。举例来讲，根据Linux源码下的include/uapi/linux/input-event-codes.h文件的第91行#define KEY_Q 16，如果键盘上按下或松开了Q键，那么键盘的驱动程序上报的code值应该是16；反之，如果应用程序获取到的值是19，那么，表示用户按下或松开了键盘上的Q键。

* __s32 value：其大小为4个字节，事件的值。如果事件的类型代码是EV_KEY，当按键按下时值为1，松开时值为0；

根据上述解释，我们可以添加以下代码来解析从设备节点中获取的数据。

if(t.type == EV_KEY)                // 我们只关心input event类型为EV_KEY（按键）的消息
    if(t.value == 0 || t.value == 1)
    {
        printf("key %d %s\n", 
        t.code,                     // t.code表示按下或松开了哪个按键
        (t.value) ? "Pressed" : "Released");   // t.value表示按下还是松开了相应的按键
    }

4、关闭设备节点

在从设备节点获取数据完成后，务必调用close函数，来关闭设备节点。即

close(keys_fd);

相关推荐：《Linux视频教程》

Das obige ist der detaillierte Inhalt vonWas ist ein Linux-Geräteknoten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!