Chinaunix首页 | 论坛 | 博客
  • 博客访问: 109973
  • 博文数量: 76
  • 博客积分: 106
  • 博客等级: 民兵
  • 技术积分: 170
  • 用 户 组: 普通用户
  • 注册时间: 2010-11-04 16:55
文章分类

全部博文(76)

文章存档

2014年(47)

2013年(2)

2012年(20)

2011年(7)

分类: LINUX

2014-06-06 18:05:34

根据内核3.1.6版本源码、书籍和网上资料,对几个函数进行分析

       介绍这几个函数,不得不先介绍等待队列wait_queue_head_t

       等待队列用于使得进程等待某一特定事件的发生,无需频繁的轮询,进程在等待周期中睡眠,当时间发生后由内核自动唤醒。

等待队列

       (一)数据结构

       等待队列结构如下,因为每个等待队列都可以再中断时被修改,因此,在操作等待队列之前必须获得一个自旋锁。

  1. 点击(此处)折叠或打开

    1. struct __wait_queue_head {
    2.         spinlock_t lock;
    3.         struct list_head task_list;
    4. };
    5. typedef struct__wait_queue_head wait_queue_head_t

     
       等待队列是通过task_list双链表来实现,其数据成员是以下数据结构:

  1. typedef struct__wait_queue wait_queue_t;
  2. struct __wait_queue {
  3.         unsigned int flags;
  4. #defineWQ_FLAG_EXCLUSIVE 0x01 /* 表示等待进程想要被独占地唤醒 */
  5.         void *private; /* 指向等待进程的task_struct实例 */
  6.         wait_queue_func_t func; /* 用于唤醒等待进程 */
  7.         struct list_head task_list; /* 用于链表元素,将wait_queue_t链接到wait_queue_head_t */
  8. };


 其图如下:

       等待队列如何使用哪?分两步:

       1. 为了使得等待进程在一个等待队列中睡眠,需要调用函数wait_event()函数。进程进入睡眠,将控制权释放给调度器。

       2. 在内核中另一处,调用wake_up()函数唤醒等待队列中的睡眠进程。

注:使用wait_event()函数使得进程睡眠;而在内核另一处有一个对应的wake_up()函数被调用。

        (二)初始化等待队列元素

        有两种方法初始化队列:

        

  1. 动态初始化init_waitqueue_entry()

  2. static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
  3. {
  4.     q->flags = 0;
  5.     q->private = p;
  6.     q->func = default_wake_function;
  7. }


        2. 静态初始化DEFINE_WAIT()


  1. #define DEFINE_WAIT_FUNC(name, function) \
  2.     wait_queue_t name = { \
  3.         .private = current, \
  4.         .func = function, \
  5.         .task_list = LIST_HEAD_INIT((name).task_list), \
  6.     }
  7.   
  8. #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)

       其中函数autoremove_wake_function()是用来唤醒进程的,该函数不经调用default_wake_function(),还将所属等待队列成员从等待队列删除。   

       (三)进程睡眠

        1. 通过add_wait_queue()函数将一个进程添加到等待队列,首先获得队列的自旋锁,然后调用__add_wait_queue()实现将新的等待进程添加等待队列(添加到等待队列的头部),然后解锁;代码如下:

点击(此处)折叠或打开

  1. static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
  2. {
  3.     list_add(&new->task_list, &head->task_list);
  4. }

        另一个函数add_wait_queue_exclusive()的含义与add_wait_queue()函数类似,但是将等待进程添加到等待队列的尾部,并设置WQ_EXCLUSIXE标志。

        使得进程在等待队列上睡眠的另一种方法是:prepare_to_wait(),除了有add_wait_queue()函数的参数外,还要设置进程的状态。

        另一个函数prepare_to_wait_exclusive()语义类似。        

        通常情况下,add_wait_queue()函数不会直接使用,因为add_wait_queue()函数不与具体的逻辑相管理,单纯的一个等待队列的模型是没有意义的,因此通常使用的是wait_event()函数:

  1. /**
  2.  * wait_event - sleep until a condition gets true
  3.  * @wq: the waitqueue to wait on
  4.  * @condition: a C expression for the event to wait for
  5.  *
  6.  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  7.  * @condition evaluates to true. The @condition is checked each time
  8.  * the waitqueue @wq is woken up.
  9.  *
  10.  * wake_up() has to be called after changing any variable that could
  11.  * change the result of the wait condition.
  12.  */
  13. #define wait_event(wq, condition) \
  14. do { \
  15.     if (condition) \
  16.         break; \
  17.     __wait_event(wq, condition); \
  18. } while (0)
  19. 函数__wait_event()
  20. #define __wait_event(wq, condition) \
  21. do { \
  22.     DEFINE_WAIT(__wait); \
  23.                                     \
  24.     for (;;) { \
  25.         prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
  26.         if (condition) \
  27.             break; \
  28.         schedule(); \
  29.     } \
  30.     finish_wait(&wq, &__wait); \
  31. } while (0)

         其中wq是等待进程需要加入的等待队列,而condition是通过与所等待时间有关的一个C表达式形式给出。表示,条件满足时,可以立即停止处理。

主要工作由__wait_event()来完成:

       (1) 调用DEFINE_WAIT宏创建等待队列成员;

       (2) 使用一个无线循环,在循环体内,

                (a) 调用prepare_to_wait()使得进程在等待队列上等待,并将进程状态置为不可中断TASK_UNINTERRUPTIBLE

                (b) 当进程被唤醒时,检查指定的条件condition是否满足,如果满足则跳出循环,否则将控制权交给调度器,然后进程继续睡眠。

        (3) 调用函数finish_wait()将进程状态设置为TASK_RUNNING,并从等待队列的链表中移除对应的成员。

       其他与wait_event类似的函数:

       1. wait_event_interrupable()函数 ,使得进程处于可中断(TASK_INTERRUPTIBLE)状态,从而睡眠进程可以通过接收信号被唤醒;

       2. wait_event_timeout()函数,等待满足指定的条件,但是如果等待时间超过指定的超时限制则停止睡眠,可以防止进程永远睡眠;

       3. wait_event_interruptible_timeout() 使得进程睡眠,不但可以通过接收信号被唤醒,也具有超时限制。

       (四)进程唤醒

       内核中虽然定义了很多唤醒等待队列中进程的函数,但是最终调用的都是__wake_up()

  1. #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
  2. #define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
  3. #define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
  4. #define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL)
  5.   
  6. #define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
  7. #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
  8. #define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
  9. #define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
  10.        而__wake_up()函数在加锁之后调用的是__wake_up_common()

  11. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
  12.             int nr_exclusive, int wake_flags, void *key)
  13. {
  14.     wait_queue_t *curr, *next;
  15.   
  16.     list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
  17.         unsigned flags = curr->flags;
  18.   
  19.         if (curr->func(curr, mode, wake_flags, key) &&
  20.                 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
  21.             break;
  22.     }
  23. }

        其中:q是等待队列,mode指定进程的状态,用于控制唤醒进程的条件,nr_exclusive表示将要唤醒的设置了WQ_FLAG_EXCLUSIVE标志的进程的数目。 

        然后扫描链表,调用func(注册的进程唤醒函数,默认为default_wake_function)唤醒每一个进程,直至队列为空,或者没有更多的进程被唤醒,或者被唤醒的的独占进程数目已经达到规定数目。

简单的demo:


点击(此处)折叠或打开

  1. /*a simple wait_queue demo
  2.  *task_1,task_2 added into the wait_queue, if condition is 0.
  3.  *task_3 change condition to 1, and task_1 task_2 will be wake up
  4.  */

  5. #include <linux/kernel.h>
  6. #include <linux/init.h>
  7. #include <linux/module.h>
  8. #include <linux/sched.h>
  9. #include <linux/kthread.h>
  10. #include <linux/delay.h>

  11. MODULE_LICENSE("GPL");
  12. MODULE_AUTHOR("cengku@gmail.com");

  13. static int condition;
  14. static struct task_struct *task_1;
  15. static struct task_struct *task_2;
  16. static struct task_struct *task_3;

  17. DECLARE_WAIT_QUEUE_HEAD(wq);


  18. static int thread_func_1(void *data)
  19. {
  20.     int i = 0;
  21.     while (i++ < 100) {
  22.         wait_event(wq, condition == 1);
  23.         msleep(1000);
  24.         printk(">>>>>this task 1\n");
  25.     }
  26.     return 0;
  27. }

  28. static int thread_func_2(void *data)
  29. {
  30.     int i = 0;
  31.     while (i++ < 100) {
  32.         wait_event(wq, condition == 1);
  33.         msleep(1000);
  34.         printk(">>>>>this task 2\n");
  35.     }
  36.     return 0;
  37. }
  38. static int thread_func_3(void *data)
  39. {
  40.     int i = 0;
  41.     while (i++ < 10) {
  42.         condition = 0;
  43.         msleep(2000);
  44.         printk(">>>>>this task 3\n");
  45.         condition = 1;
  46.         wake_up(&wq);
  47.         msleep(2000);
  48.     }
  49.     return 0;
  50. }



  51. static int __init mod_init(void)
  52. {
  53.     printk("=====mod set up===\n");
  54.     condition = 0;

  55.     task_1 = kthread_run(thread_func_1, NULL, "thread%d", 1);
  56.     if (IS_ERR(task_1))
  57.         printk("**********create thread 1 failed\n");
  58.     else
  59.         printk("======success create thread 1\n");

  60.     task_2 = kthread_run(thread_func_2, NULL, "thread%d", 2);
  61.     if (IS_ERR(task_2))
  62.         printk("**********create thread 2 failed\n");
  63.     else
  64.         printk("======success create thread 2\n");

  65.     task_3 = kthread_run(thread_func_3, NULL, "thread%d", 3);
  66.     if (IS_ERR(task_3))
  67.         printk("**********create thread 3 failed\n");
  68.     else
  69.         printk("======success create thread 3\n");
  70.     return 0;
  71. }

  72. static void __exit mod_exit(void)
  73. {
  74.     int ret;
  75.     if (!IS_ERR(task_1)) {
  76.         ret = kthread_stop(task_1);
  77.         if (ret > 0)
  78.             printk("<<<<<<<<, ret);
  79.     }
  80.         
  81.     if (!IS_ERR(task_2)) {
  82.         ret = kthread_stop(task_2);
  83.         if (ret > 0)
  84.             printk("<<<<<<<<, ret);
  85.     }

  86.     if (!IS_ERR(task_3)) {
  87.         ret = kthread_stop(task_3);
  88.         if (ret > 0)
  89.             printk("<<<<<<<<, ret);
  90.     }
  91. }
  92. module_init(mod_init);
  93. module_exit(mod_exit);
Makefile:

点击(此处)折叠或打开

  1. KERNEL_DIR:=/lib/modules/`uname -r`/build
  2. PWD:=`pwd`
  3. obj-m:= wq_mod.o
  4. default:
  5. make -C $(KERNEL_DIR) M=$(PWD) modules
  6. clean:
  7. make -C $(KERNEL_DIR) M=$(PWD) clean


阅读(1998) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~