Où est placé le périphérique de caractères Linux ?

Les périphériques de caractères Linux sont placés dans le répertoire "/dev". Les périphériques de caractères font référence aux périphériques qui ne peuvent être lus et écrits qu'octet par octet. Généralement, chaque périphérique de caractères ou périphérique bloc correspondra à un fichier de périphérique dans le répertoire "/dev", et chaque fichier de périphérique doit avoir un main/Devices avec le. le même numéro de périphérique mineur et le même numéro de périphérique majeur sont des périphériques similaires et utilisent le même pilote.

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

1. Classification des pilotes de périphériques Linux

Le système Linux divise les périphériques en trois catégories : Périphériques de caractère, périphériques de blocage et périphériques réseau Parmi ces trois catégories, les périphériques de caractère sont relativement simples et les applications. sont accessibles via les fichiers de périphériques de caractères. Cette conférence présente principalement les périphériques de caractères. Si vous êtes intéressé par les périphériques de bloc et les périphériques réseau, vous pouvez vous référer aux documents pertinents et en savoir plus à leur sujet.

---

2. Qu'est-ce qu'un dispositif de personnage ?

Le périphérique de caractère fait référence à un périphérique qui ne peut lire et écrire qu'octet par octet. Certaines données de l'appareil ne peuvent pas être lues de manière aléatoire et les données doivent être lues dans l'ordre. Les périphériques de caractères sont des périphériques orientés flux. Les périphériques de caractères courants incluent les souris, les claviers, les ports série, les consoles et les LED.

Généralement, chaque périphérique de caractère ou périphérique bloc correspondra à un fichier de périphérique dans le répertoire /dev, et chaque fichier de périphérique doit avoir un numéro de périphérique majeur/mineur. Les périphériques avec le même numéro de périphérique majeur sont des périphériques similaires. . Utilisez le même pilote.

Les programmes au niveau utilisateur Linux utilisent des pilotes pour faire fonctionner des périphériques de caractères ou bloquer des périphériques via des fichiers de périphérique.

Vous pouvez utiliser la commande

cat /proc/devices

pour afficher le numéro de périphérique principal du pilote de périphérique actuellement chargé.

En exécutant la commande

ls -l

dans le répertoire /dev, vous pouvez voir les numéros de périphérique majeurs et mineurs de tous les fichiers de périphérique :

La description suivante des fichiers de périphérique courants :

/dev/hd[a-t]：IDE设备

/dev/sd[a-z]：SCSI设备

/dev/fd[0-7]：标准软驱

/dev/md[0-31]：软raid设备

/dev/loop[0-7]：本地回环设备

/dev/mem：内存

/dev/null：无限数据接收设备,相当于黑洞

/dev/zero：无限零资源

/dev/tty[0-63]：虚拟终端

/dev/ttyS[0-3]：串口

/dev/lp[0-3]：并口

/dev/console：控制台

/dev/fb[0-31]：framebuffer

/dev/cdrom => /dev/hdc

/dev/modem => /dev/ttyS[0-9]

/dev/pilot => /dev/ttyS[0-9]

3. Comment créer des fichiers d'appareil ?

Il existe deux façons de créer un fichier de périphérique. L'une consiste à utiliser l'appel système mknod(). L'appel de cette fonction en programmation peut créer un nouveau nom de fichier de périphérique. L'autre consiste à utiliser la commande mknod. le nom du fichier de périphérique, le deuxième paramètre est le type de périphérique, par exemple, c représente un périphérique de type caractère, et les troisième et quatrième paramètres sont le numéro de périphérique principal et le numéro de périphérique mineur du fichier de périphérique, tels que 231 et 0. La combinaison du numéro de périphérique majeur et du numéro de périphérique mineur détermine de manière unique un périphérique. Les numéros de périphérique majeurs des différents types du même périphérique sont les mêmes, mais les numéros de périphérique mineurs sont différents. Par exemple, plusieurs partitions d'un disque dur ont. différents numéros de périphérique mineurs. Le numéro de périphérique peut associer le fichier de périphérique au pilote.

mknod filename type major minor

• filename : le nom du fichier de périphérique à créer ;
• type : type de périphérique, c représente un périphérique de caractère, b représente un périphérique de bloc ;
• major : numéro de périphérique majeur ;
mineur : numéro d'appareil mineur ;

4. Comment décrire les appareils de personnages ?

Le noyau Linux résume la structure struct cdev pour représenter un périphérique de caractère. cdev est défini dans . La structure la plus critique est la structure file_operations, qui est l'ensemble des opérations pour implémenter les périphériques de caractère.

struct cdev {
        struct kobject kobj;   //  内嵌内核对象
        struct module *owner;  //该字符设备所在的内核模块
        const struct file_operations *ops; //文件操作结构体
        struct list_head list;  //已注册字符设备链表
        dev_t dev; //由主、次设备号构成的设备号
        unsigned int count;//同一主设备号的次设备号的个数
};

Linux utilise la structure file_operations pour accéder aux fonctions du pilote. Le nom de chaque membre de cette structure correspond à un appel système.

struct file_operations {
       struct module *owner;
       loff_t (*llseek) (struct file *, loff_t, int);
       ssize_t (*read) (struct file *, char *, size_t, loff_t *);
       ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
       int (*readdir) (struct file *, void *, filldir_t);
       unsigned int (*poll) (struct file *, struct poll_table_struct *);
       int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
       int (*mmap) (struct file *, struct vm_area_struct *);
       int (*open) (struct inode *, struct file *);
       int (*flush) (struct file *);
       int (*release) (struct inode *, struct file *);
       int (*fsync) (struct file *, struct dentry *, int datasync);
       int (*fasync) (int, struct file *, int);
       int (*lock) (struct file *, int, struct file_lock *);
       ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,loff_t *);
       ssize_t (*writev) (struct file *, const struct iovec *, unsigned long,    loff_t *);
    };

Lorsque le processus utilisateur effectue des opérations telles que la lecture et l'écriture sur le fichier de périphérique, l'appel système trouve le pilote de périphérique correspondant via le numéro de périphérique principal du fichier de périphérique, puis lit le pointeur de fonction correspondant de cette structure de données, puis transfère le contrôle Passez la main à cette fonction, qui constitue le principe de base du fonctionnement des pilotes de périphériques Linux.

5. Interface entre le périphérique de caractères et le système de fichiers

Comme le montre la figure, dans le noyau Linux, à l'extrême gauche, la structure cdev est utilisée pour décrire le périphérique caractère ; via son membre dev_t, le numéro de périphérique (divisé en numéros de périphérique majeur et mineur) est défini pour déterminer le unicité du périphérique de caractère ; via son membre file_operations Pour définir les fonctions d'interface fournies par le pilote de périphérique de caractère au système de fichiers virtuel VFS, telles que les fonctions communes open(), read(), write(), etc., ces fonctions sont en fait faire fonctionner le périphérique matériel.

Regardons cette image basée sur l'image précédente. Le pilote de périphérique de caractère est chargé dans le noyau sous la forme d'un module du noyau. Tout d'abord, la fonction de chargement du module obtient le numéro de périphérique de manière statique ou dynamique. ; puis le caractère L'appareil fonction d'initialisation établit la connexion entre cdev et file_operations, et ajoute un cdev au système via la fonction d'enregistrement pour terminer l'enregistrement lorsque le module est déchargé, correspondant au chargement, le ; cdev doit être déconnecté et le numéro de périphérique est libéré.

Dans le programme utilisateur, ces fonctions implémentées par le pilote dans le noyau peuvent être appelées via des appels système tels que open(), read(), write(), etc. De cette façon, le chemin entre le mode utilisateur et le pilote du noyau est ouvert.

6. Écrire un pilote de périphérique de caractère simple

Comme le montre la figure, l'écriture d'un pilote de périphérique de caractère est divisée en trois étapes :

L'initialisation du pilote, qui est divisée en quatre étapes, l'appel la fonction correspondante est atteinte.
1. Implémentez le fonctionnement de l'appareil. L'opération spécifique dépend de la fonction que vous souhaitez implémenter. Seules les opérations de base sont répertoriées ici
2. Déconnexion du pilote, la déconnexion consiste à libérer des ressources.

Les fonctions des fonctions d'interface appelées sont les suivantes :

La première fonction est la fonction d'allocation, qui s'applique dynamiquement à la mémoire de cdev et alloue de l'espace mémoire à la structure.

La deuxième fonction est la fonction d'initialisation, qui initialise les membres de cdev et établit l'association entre cdev et file_operations.

La troisième fonction enregistre l'objet périphérique cdev, c'est-à-dire ajoute simplement le périphérique de caractère à la table des périphériques de caractère. comme tout le monde, l'inscription est la même que lors de l'inscription.

La quatrième fonction est l'appel du pilote de désinscription pour supprimer l'objet cdev du système.

La cinquième fonction libère la mémoire occupée par la structure de données cdev.

6.1 Application et libération du numéro d'appareil

Un appareil de caractère ou un appareil de bloc a un numéro d'appareil majeur et un numéro d'appareil mineur.

Le numéro principal de l'appareil est utilisé pour identifier le pilote connecté au fichier de l'appareil et reflète le type de périphérique. Le numéro d'appareil secondaire est utilisé par le conducteur pour identifier l'appareil qu'il utilise et pour distinguer les appareils du même type. Demandez un numéro d'appareil lors de votre inscription et divulguez le numéro d'appareil lors de la déconnexion, tout comme tout le monde a une carte d'étudiant lors de son inscription, et cette carte d'étudiant est libérée lorsqu'il obtient son diplôme et quitte l'école.

6.2 Transfert de données entre l'espace utilisateur et l'espace noyau

Lorsque nous appelons la fonction read() dans le programme utilisateur, nous tombons dans l'espace noyau. En fait, nous devons utiliser. la fonction copy_to_user() du noyau pour transférer les données. Les données dans le tampon de l'espace utilisateur sont copiées dans le tampon de l'espace utilisateur. Au contraire, lorsque nous appelons la fonction write(), le noyau copie les données de l'espace utilisateur dans le tampon du noyau. appelant la fonction copy_from_user().

Recommandations associées : "

Tutoriel vidéo 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!