在Linux驱动程序中,使用等待队列的作用?

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了在Linux驱动程序中,使用等待队列的作用?相关的知识,希望对你有一定的参考价值。

参考技术A 我帮你搜索到如下的回复希望对你有帮助《Linux就该这么学》
概念与术语
1内核里面的一个队列,可以将对象加入到队列中,
2可以选择条件休眠和无条件休眠,一般情况下是条件休眠用得较多。
3作用:阻塞读。当运用程序读数据但是现在还无数据可读时,往往会先挂起,
4让其他线程先走,等有数据可读时再唤醒。
5那么什么时候唤醒呢?怎样唤醒呢?
6这里等待队列就派上用场了。读的时候若无数据可读则加入到等待队列中,
7写入的时候唤醒这个队列。
8可以类比运用程序编程中的pthread_cond_wait()与pthread_cond_broadcast()记忆。
函数接口
include/linux/wait.h

linux 等待队列

inux内核中等待队列 

Linux内核中等待队列有很多用途,可用于中断处理、进程同步及定时。我们在这里只说,进程经常必须等待某些事件的发生。等待队列实现了在事件上的条件等待: 希望等待特定事件的进程把自己放进合适的等待队列,并放弃控制全。因此,等待队列表示一组睡眠的进程,当某一条件为真时,由内核唤醒它们。

等待队列由循环链表实现,其元素包括指向进程描述符的指针。每个等待队列都有一个等待队列头(wait queue head),等待队列头是一个类型为wait_queue_head_t的数据结构

(1)定义等待队列头(相关内容可以在linux/include/wait.h中找到)

等待队列头结构体的定义:

struct __wait_queue_head {

  spinlock_t  lock;          //自旋锁变量,用于在对等待队列头          

  struct list_head task_list;  // 指向等待队列的list_head

}; 

typedef struct __wait_queue_head  wait_queue_head_t;

使用等待队列时首先需要定义一个wait_queue_head,这可以通过DECLARE_WAIT_QUEUE_HEAD宏来完成,这是静态定义的方法。该宏会定义一个wait_queue_head,并且初始化结构中的锁以及等待队列。当然,动态初始化的方法也很简单,初始化一下锁及队列就可以了。

#define DECLARE_WAIT_QUEUE_HEAD(name) \\ 

wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

#define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \\

  .lock                = __SPIN_LOCK_UNLOCKED(name.lock),                \\

  .task_list        = { &(name).task_list, &(name).task_list } }

将lock赋为unlocked, 将等待队列头指向的等待队列链表指向name,从而将等待队列头和等待队列连起来;

 一般在写程序的时候将DECLARE_WAIT_QUEUE_HEAD分成两步来完成:

声明:

wait_queue_head_t  wait_que;

初始化:

init_waitqueue_head( &wait_que);

 

     Linux中等待队列的实现思想如下图所示,当一个任务需要在某个wait_queue_head上睡眠时,将自己的进程控制块信息封装到wait_queue中,然后挂载到wait_queue的链表中,执行调度睡眠。当某些事件发生后,另一个任务(进程)会唤醒wait_queue_head上的某个或者所有任务,唤醒工作也就是将等待队列中的任务设置为可调度的状态,并且从队列中删除。

 

技术分享

(2)等待队列中存放的是在执行设备操作时不能获得资源而挂起的进程

定义等待对列:

struct __wait_queue {

     unsigned int flags;  //prepare_to_wait()里有对flags的操作,查看以得出其含义

          #define WQ_FLAG_EXCLUSIVE        0x01 //一个常数,在prepare_to_wait()用于修改flags的值

                                                                                             

          void * private          //通常指向当前任务控制块

          wait_queue_func_t func;    //唤醒阻塞任务的函数 ,决定了唤醒的方式

     struct list_head task_list;    // 阻塞任务链表

};

typedef struct __wait_queue          wait_queue_t;

 //声明一个等待队列并初始化为name

#define DECLARE_WAITQUEUE(name, tsk)        \\

wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

 

#define __WAITQUEUE_INITIALIZER(name, tsk) {        \\ 

.private        = tsk,                                                \\                       

.func                = default_wake_function,                        \\      

.task_list        = { NULL, NULL } }

 

//下列两个函数用于对特定的成员进行赋值(当传入不同类型的参数时);

static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)

{

  q->flags = 0;

  q->private = p;          //私有数据指针

  q->func = default_wake_function;  //使用默认的唤醒函数

}

 

static inline void init_waitqueue_func_entry(wait_queue_t *q, wait_queue_func_t func)

{

  q->flags = 0;

  q->private = NULL;

  q->func = func;       // 自定义的唤醒函数

}

 

(3)对等待队列进行操作

  

static inline int waitqueue_active(wait_queue_head_t *q)

{

  return !list_empty(&q->task_list);

}

  判断等待对列头是否为空,当一个进程访问设备而得不到资源时就会被放入等待队列头指向的等待队列中。

static inline void __add_wait_queue(wait_queue_head_t *head,\\                                         wait_queue_t *new)  /

{

list_add(&new->task_list, &head->task_list);

}

//增加一个等待队列new到等待队列头head指向的等待队列链表中;

 

static inline void __add_wait_queue_tail(wait_queue_head_t *head, wait_queue_t *new)

{

  list_add_tail(&new->task_list, &head->task_list);

}

增加一个等待队列到表尾

 

static inline void __remove_wait_queu (wait_queue_head_t *head,  wait_queue_t *old)

{

  list_del(&old->task_list);

}

 

 

 //wq: 在等待事件的等待队列,condition: 等待的条件

#define __wait_event(wq, condition) \\                                                                                 

do {                                                                        \\

DEFINE_WAIT(__wait);                \\  //定义并初始化一个wait_queue_t结构        

for (;;) {                                                        \\

  prepare_to_wait(&wq, &__wait,TASK_UNINTERRUPTIBLE);        \\

  if (condition)        \\  //看wait_queue:wq要等的condition是否满足

    break;                                                \\

  schedule();        \\     //condition不成立,放弃cpu重新调度一个task

}                                                                \\

finish_wait(&wq, &__wait);                                        \\

} while (0)

 上面程序的执行过程:

1.用当前的进程描述块(PCB)初始化一个wait_queue描述的等待任务。

2.在等待队列锁资源的保护下,将等待任务加入等待队列。

3.判断等待条件是否满足,如果满足,那么将等待任务从队列中移出,退出函数。

4.如果条件不满足,那么任务调度,将CPU资源交与其它任务。

5.当睡眠任务被唤醒之后,需要重复(2)、(3)步骤,如果确认条件满足,退出等待事件函数。

 我在一个程序中因为使用使用wait_event_interruptible()遇到了很大的麻烦,原因就是不知道condition在函数中具体起个什么作用,通过分析源码终于搞清楚。(后面会有专门的文章来介绍那个问题。)

 

等待队列编程接口:

wait_event(wq, condition)

这是一个宏,让当前任务处于等待事件状态。输入参数如下:

@wq:等待队列

@conditions:等待条件

 

wait_event_timeout(wq, condition, timeout)

功能与wait_event类似,多了一个超时机制。参数中多了一项超时时间。

 

wait_event_interruptible(wq, condition)

这是一个宏,与前两个宏相比,该宏定义的等待能够被消息唤醒。如果被消息唤醒,那么返回- ERESTARTSYS。输入参数如下:

@wq:等待队列

@condition:等待条件

@rt:返回值

 

wait_event_interruptible_timeout(wq, condition, timeout)

与上一个相比,多了超时机制

 

wake_up(x)

唤醒等待队列中的一个任务

 

wake_up_interruptible(x)

用于唤醒wake_event_interruptible()睡眠的进程

 

wake_up_all(x)

唤醒等待队列中的所有任务

 

Linux将进程状态描述为如下五种:

TASK_RUNNING:可运行状态。处于该状态的进程可以被调度执行而成为当前进程。

TASK_INTERRUPTIBLE:可中断的睡眠状态。处于该状态的进程在所需资源有效时被唤醒,也可以通过信号定时中断唤醒(因为有signal_pending()函数)。

TASK_UNINTERRUPTIBLE:不可中断的睡眠状态。处于该状态的进程仅当所需资源有效时被唤醒。

TASK_ZOMBIE:僵尸状态。表示进程结束且已释放资源,但其task_struct仍未释放。

TASK_STOPPED:暂停状态。处于该状态的进程通过其他进程的信号才能被唤醒。

  1 #include <linux/module.h>
  2 #include <linux/kernel.h>
  3 #include <linux/miscdevice.h>
  4 #include <linux/fs.h>
  5 #include <linux/interrupt.h>
  6 #include <linux/gpio.h>
  7 #include <mach/gpio.h>
  8 #include <asm-generic/ioctl.h>
  9 #include <asm/uaccess.h>
 10 #include <linux/wait.h>
 11 #include <linux/sched.h>
 12 
 13 #define     MAGIC                     ‘B‘
 14 #define     GET_BTN_VAL              _IOR(MAGIC, 1, unsigned long)
 15 
 16 typedef struct
 17 {
 18     unsigned int gpio;
 19     unsigned int btn;
 20     unsigned int irq;
 21     char*        name;
 22 }irq_typedef;
 23 
 24 static irq_typedef irqsource[] =
 25 {
 26     {EXYNOS4_GPX3(2),1,0,"btn1"},
 27     {EXYNOS4_GPX3(3),2,0,"btn2"},
 28     {EXYNOS4_GPX3(4),3,0,"btn3"},
 29     {EXYNOS4_GPX3(5),4,0,"btn4"}
 30 };
 31 
 32 DECLARE_WAIT_QUEUE_HEAD(btn_wait_que);
 33 static int condition;
 34 
 35 static unsigned long btn_num;
 36 
 37 static irqreturn_t gpio_irq_handler(int irq, void *dev)
 38 {
 39     irq_typedef* curdev = (irq_typedef *)dev;
 40 
 41     printk("%s\\n",curdev->name);
 42     printk("btn(drv):%d\\n",curdev->btn);
 43 
 44     btn_num = curdev->btn;
 45 
 46     condition=1;
 47     wake_up(&btn_wait_que);
 48     
 49     return 0;
 50 }
 51 
 52 static long btn_ioctl(struct file *fil, unsigned int cmd, unsigned long arg)
 53 {
 54     unsigned long ret;
 55     void __user *argp = (void __user *)arg;
 56 
 57     wait_event_interruptible(btn_wait_que, condition);
 58     condition = 0;
 59 
 60     switch(cmd)
 61     {
 62         case GET_BTN_VAL:
 63             ret = copy_to_user((void __user *) argp, (void *)&btn_num,4);
 64             // put_user(btn_num, (unsigned int __user *) argp);
 65             break;
 66         default:return -EINVAL;
 67     }
 68     
 69     return ret;
 70 }
 71 
 72 
 73 static struct file_operations btn_irq_fops =
 74 {
 75     .owner            = THIS_MODULE,
 76     .unlocked_ioctl    = btn_ioctl,
 77 };
 78 
 79 static struct miscdevice btn_irq_misc = 
 80 {
 81     .minor        = 255,
 82     .name        = "btn",
 83     .fops        = &btn_irq_fops,
 84 };
 85 
 86 static __init int btn_irq_init(void)
 87 {
 88     int i,ret;
 89 
 90     misc_register(&btn_irq_misc);
 91 
 92     for(i=0;i<4;i++)
 93     {
 94         irqsource[i].irq = gpio_to_irq(irqsource[i].gpio);
 95         ret = request_irq(irqsource[i].irq,gpio_irq_handler,IRQF_TRIGGER_FALLING,irqsource[i].name, &irqsource[i]);
 96     }
 97     
 98     return ret;
 99 }
100 
101 static __exit void btn_irq_exit(void)
102 {
103     int i;
104 
105     for(i=0;i<4;i++)
106         free_irq(irqsource[i].irq, &irqsource[i]);
107 
108     misc_deregister(&btn_irq_misc);
109 }
110 
111 module_init(btn_irq_init);
112 module_exit(btn_irq_exit);
113 MODULE_LICENSE("GPL");
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>

#define     MAGIC                     ‘B‘
#define     GET_BTN_VAL              _IOR(MAGIC, 1, unsigned long)

int main(int argc,char *argv[])
{
    int btn_fd,btn_val=0;

    if(argc!=2)
    {
        printf("Usage:<%s> </dev/?node>\\n",argv[0]);
        return -1;
    }

    btn_fd = open(argv[1],O_RDONLY);    

    while(1)
    {
        // ioctl(btn_fd,GET_BTN_VAL,btn_val);
        ioctl(btn_fd,GET_BTN_VAL,&btn_val);
        // sleep(1);

        printf("btn_val(irq):%d\\n",btn_val);
    }
}
 1 obj-m    += btnirq.o
 2 SOURCE =btntest.o
 3 
 4 CROSS_COMPLIE = arm-linux-
 5 CC = $(CROSS_COMPLIE)gcc
 6 
 7 KERNDIR = /file/samsung/linux-3.5
 8 #CURDIR  = $(shell pwd)
 9 CURDIR  = `pwd`
10 
11 .PHONY: module clean
12 
13 all: module $(SOURCE:.o=)
14 
15 module:
16     $(MAKE) -C $(KERNDIR) M=$(CURDIR) modules
17 
18 $(SOURCE:.o=):$(SOURCE)
19     $(CC) -o [email protected] $^
20 
21 %.o:%.c
22     $(CC) -c $<
23 
24 clean:
25     $(MAKE) -C $(KERNDIR) M=$(CURDIR) clean
26     rm $(SOURCE:.o=)

 

以上是关于在Linux驱动程序中,使用等待队列的作用?的主要内容,如果未能解决你的问题,请参考以下文章

linux驱动---等待队列工作队列Tasklets

在 Linux 中控制信号量队列中的出队顺序

等待队列源码分析

Linux——Linux驱动之使用等待队列降低CPU的占用率应用实战(阻塞与非阻塞等待队列的基本概念相关函数代码实战)

Linux——Linux驱动之使用等待队列降低CPU的占用率应用实战(阻塞与非阻塞等待队列的基本概念相关函数代码实战)

linux内核阻塞IO