qu'est-ce que le nœud de périphérique Linux

Le nœud de périphérique Linux est un pont de communication entre les applications et les pilotes de périphérique ; le nœud de périphérique est créé dans "/dev" et est le hub reliant le noyau et la couche utilisateur. Il est équivalent à l'inode du disque dur et des enregistrements. les informations du périphérique matériel. Emplacement et informations. Les nœuds de périphérique permettent aux utilisateurs de communiquer avec le noyau via le matériel, de lire et d'écrire des périphériques et d'effectuer d'autres opérations.

L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.

Qu'est-ce qu'un nœud d'appareil

Le pont de communication entre les gens est le langage. De même, les applications et les pilotes de périphériques ont également besoin d'un pont pour communiquer. Ce pont est le nœud du périphérique.

Pour les systèmes Linux, toutes les ressources IO sont des fichiers, notamment des fichiers, des répertoires, des disques durs, des périphériques, etc. Eh bien, le clavier est un périphérique d'entrée dans le système informatique, et le système d'exploitation le extrait également des fichiers. Si vous souhaitez obtenir les données saisies par l'utilisateur à partir du clavier, il vous suffit de lire le nœud de périphérique fourni par le clavier. .

Dans les systèmes Linux, le clavier est utilisé comme périphérique d'entrée et son nœud de périphérique correspondant se trouve sous "/dev/input". Il existe de nombreux fichiers commençant par event dans ce dossier. Ce sont les nœuds de périphérique de tous les périphériques d'entrée. Comment déterminer à quel nœud de périphérique correspond le clavier ? Connectez le clavier au Raspberry Pi, ouvrez le terminal, exécutez "sudo cat /dev/input/event0", appuyez sur le clavier, s'il n'y a pas de sortie, passez au nœud suivant jusqu'à ce que vous trouviez un nœud avec sortie, puis ce nœud est le clavier Le nœud de périphérique correspondant.

Le nœud de périphérique est créé sous /dev et est le hub reliant le noyau et la couche utilisateur. Cela signifie que le périphérique est connecté à quel ID de l'interface correspondante. Il équivaut à l'inode d'un disque dur et enregistre l'emplacement et les informations des périphériques matériels. Sous Linux, tous les périphériques sont stockés dans le répertoire /dev sous forme de fichiers et sont accessibles via les fichiers des nœuds de périphérique. Il s'agit du noyau Linux. abstraction des appareils. Un nœud de périphérique est un fichier. Les applications accèdent à l'appareil via un ensemble standardisé d'appels indépendants de tout pilote spécifique. Le pilote est responsable du mappage de ces appels standard aux opérations réelles spécifiques au matériel.

Le rôle des nœuds de périphérique

Les nœuds de périphérique permettent aux utilisateurs de communiquer avec le noyau sur le matériel, de lire et d'écrire des périphériques et d'effectuer d'autres opérations

Sous Linux, les périphériques existent comme des fichiers ordinaires. L'accès à un périphérique est comme c'est le cas. la même chose que l'accès à un fichier

Le numéro d'appareil majeur représente un type d'appareil, et le numéro d'appareil mineur représente différents individus du même type d'appareil. À ce stade, vous ne connaissez peut-être pas la forme d'existence du nœud d'appareil

.

La forme d'existence du nœud de périphérique

De plus, il existe un autre concept sous Linux, qui est l'inode et le bloc, qui sont des blocs et des nœuds sur un côté du disque dur. L'inode dans le disque dur est équivalent à un. fichier ou dossier. Il enregistre l'emplacement du fichier sous le fichier et l'emplacement du fichier. Il est aligné en fonction de la taille du bloc. Par exemple, certains systèmes ont une taille de 4K et la taille de l'inode est limitée, il y a donc un. disant qu'un seul fichier ne peut pas dépasser la 4G. D'après ma compréhension personnelle, le nœud du pilote Linux peut être considéré comme quelque chose de similaire à l'inode du disque dur, qui peut enregistrer l'emplacement du périphérique matériel et d'autres informations, et peut être utilisé lorsque l'utilisateur a besoin d'y accéder. Accédez à l'appareil en vous référant aux informations enregistrées par le nœud de l'appareil

Comment obtenir des données du nœud de l'appareil

La raison pour laquelle le système d'exploitation résume les IO dans des fichiers, le plus grand avantage est que ce fichier est accessible via un interface unifiée, pour communiquer avec différents appareils. Ces interfaces unifiées sont un ensemble d'appels système fournis par le système d'exploitation pour les opérations sur les fichiers : fonction d'ouverture, fonction de lecture, fonction d'écriture, etc. Par exemple, si vous avez besoin d'obtenir des données d'un appareil, il vous suffit d'appeler la fonction read pour lire le nœud de périphérique correspondant à l'appareil. Bien entendu, avant de lire, vous devez d'abord appeler la fonction open pour l'ouvrir. Prenons maintenant l'exemple de la saisie au clavier.

1. Ouvrez le nœud de l'appareil

Avant de lire les données du nœud de l'appareil, vous devez d'abord appeler la fonction open pour ouvrir le nœud de l'appareil. Pour une utilisation spécifique de la fonction open, veuillez vous référer au lien. Une brève description est la suivante :

Déclaration de fonction :

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

Fichier d'en-tête à inclure :

　　#include <fcntl.h>

Paramètres :

* Premier paramètre (const char *pathname) : Indique le chemin du fichier qui doit être ouvert

* Deuxième paramètre (drapeaux int) : indique la manière d'ouvrir le fichier, par exemple, "O_RDONLY" - ouvert en lecture uniquement ; "O_WRONLY" - ouvert en écriture uniquement "O_RDWR" - ouvert en lecture et en écriture, etc.

Valeur de retour :

Si l'ouverture réussit, le descripteur de fichier du fichier est renvoyé pour être utilisé par des fonctions telles que la lecture et l'écriture. Sinon, -1 est renvoyé.

Donc, pour ouvrir le fichier de périphérique du clavier (en supposant qu'il s'agit de "/dev/input/even10"), vous avez besoin du code suivant :

  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 Pour lire les données du nœud de périphérique, vous devez utiliser le read. fonction pour lire le nœud de l'appareil. Veuillez vous référer au lien pour les méthodes d'utilisation spécifiques. Une brève introduction est la suivante :

Déclaration de fonction :

　　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。

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

* 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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!