linux等待队列简析

「爱情、让人受尽委屈。」 2022-02-05 00:34 262阅读 0赞

在阅读Tun驱动时看到，有一些类似 add\_wait\_queue 的函数，这些函数正是执行等待队列的相关操作，要说等待队列还得从 **linux**内核进程调度说起，内核调度系统内进程，分配时间片，但是有些进程如从网卡中读数据，在网卡有数据到达之前进程处于阻塞状态，如果此时给相应进程分配时间片做调度，无疑是浪费系统资源，所以系统内每个进程都有自己的状态标志 task->state，这些状态定义于文件 include/linux/sched.h  
  
  
\#define TASK\_RUNNING            0  
\#define TASK\_INTERRUPTIBLE      1  
\#define TASK\_UNINTERRUPTIBLE    2  
...  
  
  
**[linux][]**内核只会调用标志是 TASK\_RUNNING 的进程，如果需要等待资源，可以设置自己的进程标志为 TASK\_INTERRUPTIBLE （可中断）或者 TASK\_UNINTERRUPTIBLE （不可中断），然后调用 schedule();放弃CPU，此进程就不会被内核调度了，但随之而来的问题是，如果进程所需资源可以使用，如何唤醒进程呢，这就要依赖于等待队列了，进程在放弃控制权之前，把自己加入一个队列中，当所需条件满足，其他进程便可wakeup该队列，修改进程状态为 TASK\_RUNNING，等待进程便可顺利往下执行了。  
  
  
与等待队列相关的操作有如下几种：  
  
  
/\* 等待队列头声明 \*/  
wait\_queue\_head\_t simple\_queue;  
  
  
/\* 初始化等待队列头 \*/  
init\_waitqueue\_head(&simple\_queue);  
  
  
/\* 定义等待队列项 \*/  
DECLARE\_WAITQUEUE (name, tsk);  
  
  
/\* 添加删除等待项 \*/  
void fastcall add\_wait\_queue(wait\_queue\_head\_t \* q, wait\_queue\_t \* wait);  
void fastcall remove\_wait\_queue(wait\_queue\_head\_t \* q, wait\_queue\_t \* wait);  
  
  
/\* 唤醒等待头中的所有项 \*/  
void wake\_up(wait\_queue\_head\_t \* queue);  
void wake\_up\_interruptible(wait\_queue\_head\_t \* queue);  
结合这些函数，再往simple驱动里添加一些简单的机制支持等待。在 simple\_read 函数中修改当前进程状态，加入等待队列后，放弃控制权，另加入 simple\_write 函数唤醒队列。  
  
  
\#include<linux/init.h>  
\#include<linux/module.h>  
  
  
\#include<linux/fs.h>  
\#include<linux/types.h>  
\#include<linux/cdev.h>  
\#include<linux/mm.h>  
\#include<linux/sched.h>  
\#include<asm/io.h>  
\#include<asm/uaccess.h>  
\#include<asm/system.h>  
  
  
\#include<linux/device.h>  
  
  
dev\_t devno;  
struct class \* simple\_class;  
static struct cdev cdev;  
  
  
wait\_queue\_head\_t simple\_queue;  
  
  
char test\_data\[255\];  
int len;  
  
  
ssize\_t simple\_read(struct file \* pfile,  
    char \_\_user \* buf, size\_t size, loff\_t \* ppos)  
\{  
    /\* 定义一个等待项，添加到等待队列，并设置进程状态后放弃执行权 \*/  
    DECLARE\_WAITQUEUE (simple\_item, current);  
    add\_wait\_queue(&simple\_queue, &simple\_item);  
    current->state = TASK\_INTERRUPTIBLE;  
    schedule();  
    /\* 被唤醒以后，从队列中移除 \*/  
    remove\_wait\_queue(&simple\_queue, &simple\_item);  
  
  
    if (copy\_to\_user(buf, test\_data, len))  
        return -EFAULT;  
    else  
        return len;  
\}  
  
  
ssize\_t simple\_write(struct file \* pfile, const char \_\_user \* buf, size\_t count, loff\_t \* ppos)  
\{  
    if (count > 255)  
    \{  
        return -EFAULT;  
    \}  
  
  
    if (!copy\_from\_user(test\_data, buf, count))  
    \{  
        len = count;  
        /\* 唤醒等待队列中所有进程 \*/  
        wake\_up(&simple\_queue);  
    \}  
    return len;  
\}  
  
  
int simple\_open(struct inode \* pnode, struct file \* pfile)  
\{  
    printk(KERN\_INFO "open simple\\n");  
    return 0;  
\}  
  
  
int simple\_release(struct inode \* pnode, struct file \* pfile)  
\{  
    printk(KERN\_INFO "close simple\\n");  
    return 0;  
\}  
  
  
static struct file\_operations simple\_op =  
\{  
    .owner = THIS\_MODULE,  
    .read = simple\_read,  
    .open = simple\_open,  
    .release = simple\_release,  
    .write = simple\_write,  
\};  
  
  
static int \_\_init initialization(void)  
\{  
    int result;  
  
  
    result = alloc\_chrdev\_region(&devno, 0, 1, "simple");  
    if (result < 0)  
        return result;  
  
  
    cdev\_init(&cdev, &simple\_op);  
    result = cdev\_add(&cdev, devno, 1);  
  
  
    simple\_class = class\_create(THIS\_MODULE, "simple");  
    device\_create(simple\_class, NULL, devno, NULL, "simple");  
  
  
    printk(KERN\_INFO " init simple\\n");  
  
  
    init\_waitqueue\_head(&simple\_queue);  
  
  
    return result;  
\}  
  
  
static void \_\_exit cleanup(void)  
\{  
    device\_destroy(simple\_class, devno);  
    class\_destroy(simple\_class);  
  
  
    cdev\_del(&cdev);  
    unregister\_chrdev\_region(devno, 1);  
    printk(KERN\_INFO " cleanup simple\\n");  
\}  
  
  
module\_init(initialization);  
module\_exit(cleanup);  
  
  
MODULE\_AUTHOR("alloc cppbreak@gmail.com");  
MODULE\_DESCRIPTION("A simple linux kernel module");  
MODULE\_VERSION("V0.2");  
MODULE\_LICENSE("Dual BSD/GPL");  
加载模块 insmod simple.ko 后，使用cat读取数据，cat /dev/simple， 会发现进程处于等待状态，不会输出任何信息，新打开一个终端，输入echo “test” > /dev/simple执行写操作，cat便会输出数据，紧接着再次处于等待状态。  
  
  
insmod simple.ko  
cat /dev/simple        --->    进程等待  
first            --->    echo "first" > /dev/simple  
cool            --->    echo "cool" > /dev/simple

[linux]: http://blog.csdn.net/shanzhizi