Explication détaillée de la technologie du pilote Linux (5)_Blocage de périphérique/lecture et écriture non bloquantes

Dans le processus d'écriture des pilotes Linux, le blocage/lecture et l'écriture non bloquantes des périphériques est une technologie très importante. Il peut assurer une transmission de données et un traitement des événements efficaces, améliorant ainsi les performances du système et la vitesse de réponse. Dans cet article, nous approfondirons la technologie des pilotes Linux (5)_Les principes de mise en œuvre et les technologies associées de blocage/non-blocage des périphériques en lecture et en écriture.

La file d'attente est une structure de données très importante dans le noyau pour la planification des processus. Sa tâche est de maintenir une liste chaînée est un PCB (Process Control Block). la file d'attente Tous les processus sont programmés pour dormir jusqu'à ce qu'une certaine condition de réveil se produise. J'ai déjà discuté de l'utilisation des E/S bloquantes et des E/S non bloquantes au niveau de la couche application dans l'article Multiplexage des E/S Linux. Cet article explique principalement comment implémenter la lecture et l'écriture bloquantes et non bloquantes des E/S du périphérique dans le pilote. Évidemment, le mécanisme de file d'attente est nécessaire pour mettre en œuvre ce mécanisme lié au blocage. Le code source du noyau de cet article utilise la version 3.14.0

Mise en place d'un dispositif bloquant les IO

Lorsque nous lisons et écrivons les IO du fichier de périphérique, l'interface correspondante dans le pilote sera éventuellement rappelée, et ces

interfaces apparaîtront également dans l'espace de processus (noyau) du processus de lecture et d'écriture du périphérique. les conditions ne sont pas remplies, la fonction d'interface fera entrer le processus en état de veille, même si le processus utilisateur de lecture et d'écriture de l'appareil entre en veille, c'est ce que nous disons souvent qu'il est bloqué. En un mot, l'essence du blocage des fichiers de périphérique en lecture et en écriture est que le pilote implémente le blocage des fichiers de périphérique dans le pilote. Le processus de lecture et d'écriture peut être résumé comme suit : .

1. Définition - initialiser la tête de file d'attente

//定义等待队列头
wait_queue_head_t waitq_h;
//初始化，等待队列头
init_waitqueue_head(wait_queue_head_t *q);
 //或
//定义并初始化等待队列头
DECLARE_WAIT_QUEUE_HEAD(waitq_name);

Parmi les options ci-dessus, la dernière définira et initialisera directement un en-tête d'attente. Cependant, si vous utilisez des variables globales pour transmettre des paramètres dans le module, celle à utiliser dépend de vos besoins.

Nous pouvons retracer le code source et voir ce que font les lignes ci-dessus :

//include/linux/wait.h 
 35 struct __wait_queue_head { 
 36         spinlock_t              lock;
 37         struct list_head        task_list;
 38 };
 39 typedef struct __wait_queue_head wait_queue_head_t;

«

wait_queue_head_t –36–>Le spin lock utilisé par cette file d'attente
–27–>Le lien qui « enchaîne » toute la file d’attente

”

Jetons ensuite un œil à la macro d'initialisation :

 55 #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                           \
 56         .lock           = __SPIN_LOCK_UNLOCKED(name.lock),              \
 57         .task_list      = { &(name).task_list, &(name).task_list } }
 58 
 59 #define DECLARE_WAIT_QUEUE_HEAD(name) \
 60         wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

«

DECLARE_WAIT_QUEUE_HEAD() –60–>Créez une tête de file d'attente nommée name en fonction du nom de la chaîne entrante
–57–>Pour initialiser le champ task_list ci-dessus, la macro d'initialisation standard du noyau n'est pas utilisée. . .

”

2. Ajoutez ce processus à la file d'attente

Ajoutez des événements à la file d'attente, c'est-à-dire que le processus entre en état de veille et ne revient que lorsque la condition est vraie. La version de **_interruptible

indique que le sommeil peut être interrompu, et la version de _timeout** indique la version du délai d'attente, qui sera renvoyée lorsque le délai d'attente se produit. Cette convention de dénomination peut être vue partout dans l'API du noyau.

void wait_event(wait_queue_head_t *waitq_h,int condition);
void wait_event_interruptible(wait_queue_head_t *waitq_h,int condition);
void wait_event_timeout(wait_queue_head_t *waitq_h,int condition);
void wait_event_interruptible_timeout(wait_queue_head_t *waitq_h,int condition);

C'est le cœur de la file d'attente, jetons un coup d'oeil

“

wait_event
└── wait_event
└── _wait_event
├── abort_exclusive_wait
├── finish_wait
├── prepare_to_wait_event
└── ___wait_is_interruptible

”

244 #define wait_event(wq, condition)                                       \
245 do {                                                                    \
246         if (condition)                                                  \
247                 break;                                                  \
248         __wait_event(wq, condition);                                    \ 
249 } while (0)

“

wait_event
–246–>如果condition为真，立即返回
–248–>否则调用__wait_event

”

194 #define ___wait_event(wq, condition, state, exclusive, ret, cmd)        \       
195 ({                                                                      \
206         for (;;) {                                                      \
207                 long __int = prepare_to_wait_event(&wq, &__wait, state);\
208                                                                         \  
209                 if (condition)                                          \       
210                         break;                                          \
212                 if (___wait_is_interruptible(state) && __int) {         \
213                         __ret = __int;                                  \
214                         if (exclusive) {                                \
215                                 abort_exclusive_wait(&wq, &__wait,      \
216                                                      state, NULL);      \
217                                 goto __out;                             \
218                         }                                               \
219                         break;                                          \
220                 }                                                       \
222                 cmd;                                                    \
223         }                                                               \
224         finish_wait(&wq, &__wait);                                      \
225 __out:  __ret;                                                          \
226 })

“

___wait_event
–206–>死循环的轮询
–209–>如果条件为真，跳出循环，执行finish_wait();进程被唤醒
–212–>如果进程睡眠的方式是interruptible的，那么当中断来的时候也会abort_exclusive_wait被唤醒
–222–>如果上面两条都不满足，就会回调传入的schedule()，即继续睡眠

”

模板

struct wait_queue_head_t xj_waitq_h;
static ssize_t demo_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    if(!condition)    //条件可以在中断处理函数中置位
        wait_event_interruptible(&xj_waitq_h,condition);
}
static file_operations fops = {
    .read = demo_read,
};
static __init demo_init(void)
{
    init_waitqueue_head(&xj_waitq_h);
}

IO多路复用的实现

对于普通的非阻塞IO，我们只需要在驱动中注册的read/write接口时不使用阻塞机制即可，这里我要讨论的是IO多路复用，即当驱动中的read/write并没有实现阻塞机制的时候，我们如何利用内核机制来在驱动中实现对IO多路复用的支持。下面这个就是我们要用的API

int poll(struct file *filep, poll_table *wait);
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)  

当应用层调用select/poll/epoll机制的时候，内核其实会遍历回调相关文件的驱动中的poll接口，通过每一个驱动的poll接口的返回值，来判断该文件IO是否有相应的事件发生，我们知道，这三种IO多路复用的机制的核心区别在于内核中管理监视文件的方式，分别是位，数组，链表，但对于每一个驱动，回调的接口都是poll。

模板

struct wait_queue_head_t waitq_h;
static unsigned int demo_poll(struct file *filp, struct poll_table_struct *pts)
{
    unsigned int mask = 0;
    poll_wait(filp, &wwaitq_h, pts);
    if(counter){
        mask = (POLLIN | POLLRDNORM);
    }
    return mask;
}

static struct file_operations fops = {
    .owner  = THIS_MODULE,
    .poll   = demo_poll,
};
static __init demo_init(void)
{
    init_waitqueue_head(&xj_waitq_h);
}

其他API

刚才我们讨论了如何使用等待队列实现阻塞IO，非阻塞IO，其实关于等待队列，内核还提供了很多其他API用以完成相关的操作，这里我们来认识一下

//在等待队列上睡眠
sleep_on(wait_queue_head_t *wqueue_h);
sleep_on_interruptible(wait_queue_head_t *wqueue_h);

//唤醒等待的进程
void wake_up(wait_queue_t *wqueue);
void wake_up_interruptible(wait_queue_t *wqueue);

总之，设备阻塞/非阻塞读写是Linux驱动程序编写过程中不可或缺的一部分。它可以实现高效的数据传输和事件处理，提高系统的性能和响应速度。希望本文能够帮助读者更好地理解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!