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
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 : .
//定义等待队列头 wait_queue_head_t waitq_h; //初始化,等待队列头 init_waitqueue_head(wait_queue_head_t *q); //或 //定义并初始化等待队列头 DECLARE_WAIT_QUEUE_HEAD(waitq_name);
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;
Jetons ensuite un œil à la macro d'initialisation :«
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
”
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. . .
”
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);
“
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,我们只需要在驱动中注册的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); }
刚才我们讨论了如何使用等待队列实现阻塞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!