等待队列

add_wait_queue_exclusive（）；

add_wait_queue（）；

插入队列的位置不同：一个从尾，一个在头。前者插入元素的优先级较高。

?

#include <linux/module.h>

#include <linux/sched.h>

#include <linux/list.h>

 

MODULE_LICENSE("GPL");

 

int my_function(void * argc)

{

    printk("<0>in the kernel thread function!\n");   

    printk("<0>the current pid is:%d\n",current->pid);

    printk("<0>out the kernel thread function\n");

    return 0;

}

 

static int __init my_init(void)

{  

    int result, result1, result2;  

    int wait_queue_num = 0;

    wait_queue_head_t head;

    wait_queue_t data, data1, data2, *curr, *next; 

 

    printk("<0>into my_init.\n");

     

                 

    result =kernel_thread(my_function,NULL,CLONE_KERNEL);

    result1=kernel_thread(my_function,NULL,CLONE_KERNEL);

    result2=kernel_thread(my_function,NULL,CLONE_KERNEL);

 

 

    struct pid * kpid = find_get_pid(result);

    struct task_struct * task = pid_task(kpid,PIDTYPE_PID);

 

    struct pid * kpid1 = find_get_pid(result1);

    struct task_struct * task1 = pid_task(kpid1,PIDTYPE_PID);

 

    struct pid * kpid2 = find_get_pid(result2);

    struct task_struct * task2 = pid_task(kpid2,PIDTYPE_PID);

 

    init_waitqueue_head(&head);

 

 

    init_waitqueue_entry(&data, task);

    init_waitqueue_entry(&data1,task1);

    init_waitqueue_entry(&data2,task2);

 

 

    add_wait_queue_exclusive(&head,&data1);

    add_wait_queue_exclusive(&head,&data2);

    add_wait_queue(&head,&data);

 

 

    list_for_each_entry_safe(curr, next, &(head.task_list), task_list)

    {

        wait_queue_num++;

         

        printk("<0>the flag value of the current data of the waitqueue is:%d\n",curr->flags); 

             

        printk("<0>the pid value of the current data of the waitqueue is:%d\n", \

                                                        ((struct task_struct *)(curr->private))->pid);

    }

 

    printk("<0>the value of the wait_queue_num is :%d\n",wait_queue_num);

     

    printk("<0>the result  of the kernel_thread is :%d\n", result);

    printk("<0>the result1 of the kernel_thread is :%d\n",result1);

    printk("<0>the result2 of the kernel_thread is :%d\n",result2);

    printk("<0>the current pid is:%d\n",current->pid);

    printk("<0>out my_init.\n");

    return 0;

}

 

static void __exit my_exit(void)

{  

        printk("<0>Goodbye mytest\n");   

}

 

module_init(my_init);

module_exit(my_exit);

又是一位内核界的明星，通过内核链表遍历一大串结构体的典型。

#define list_for_each_entry_safe(pos, n, head, member) \
    for ( pos = list_entry((head)->next, typeof(*pos), member),  \
             n = list_entry(pos->member.next, typeof(*pos), member); \
          &pos->member != (head);                    \
          pos = n, n = list_entry(n->member.next, typeof(*n), member) )

它都遍历了哪些东西，看看下面的结构体，也就一目了然了。

-- include/linux/wait.h --

struct  __wait_queue_head { 
      spinlock_t        lock; 
      struct list_head  task_list; 
}; 
typedef struct  __wait_queue_head  wait_queue_head_t;


struct  __wait_queue {
    unsigned int   flags; 
    void*private; 
    wait_queue_func_t     func; 
    struct  list_head     task_list; 
};
typedef struct  __wait_queue  wait_queue_t;

以下是运行的结果，通过遍历队列打印出的pid可以看出插入队列的方式。

?

[103891.133838] into my_init.

[103891.133875] the result  of the kernel_thread is :22093

[103891.133878] the result1 of the kernel_thread is :22094

[103891.133880] the result2 of the kernel_thread is :22095

[103891.133883] the current pid is:22092

[103891.133886] the flag value of the current data of the waitqueue is:0

[103891.133889] the pid value of the current data of the waitqueue is:22094

[103891.133891] the flag value of the current data of the waitqueue is:0

[103891.133894] the pid value of the current data of the waitqueue is:22093

[103891.133897] the flag value of the current data of the waitqueue is:1

[103891.133900] the pid value of the current data of the waitqueue is:22095

[103891.133903] the value of the wait_queue_num is :3

[103891.133905] out my_init.

[103891.134519] in the kernel thread function!

[103891.134522] the current pid is:22094

[103891.134525] out the kernel thread function

[103891.134621] in the kernel thread function!

[103891.134623] the current pid is:22095

[103891.134625] out the kernel thread function

[103891.134679] in the kernel thread function!

[103891.134681] the current pid is:22093

[103891.134683] out the kernel thread function

  

------------------------------------------------------------------------------

现在便有了一个真真切切的队列，作为进程调度的东西，离不开休眠、唤醒、休眠、唤醒……智商为正的大伙都能看出来：这玩意是成对儿的嘛。函数的设计也确实如此。

?

int my_function(void * argc)

{

    printk("<0>the state of the real_parent is :%ld\n",current->real_parent->state);

    __wake_up(&head,TASK_ALL,0,NULL);   //唤醒

    printk("<0>the state of the real_parent after __wake_up is :%ld\n",current->real_parent->state);

    printk("<0>out the kernel thread function\n");

    return 0;

}

 

static int __init my_init(void)

{

    int result=0;

    long left_time=0;

    wait_queue_t data;

 

    printk("<0>into my_init.\n");

    result=kernel_thread(my_function, NULL, CLONE_KERNEL);

             init_waitqueue_head(&head);

    init_waitqueue_entry(&data, current);

    add_wait_queue(&head, &data);

 

    left_time=sleep_on_timeout(&head, 100);     //休眠

    printk("<0>the return result of the sleep_on_timeout is:%ld\n", left_time);

 

    printk("<0>out my_init.\n");

    return 0;

}

主进程生了个子进程后，将自己放入队列里，睡午觉去了。

子进程运行过程中唤醒老爸，于是乎，闹钟还未响却被孩子吵醒，如此看来，带孩子的男人确实不容易a。

  

当然，从这个sleep_on_timeout的参数也能看出，这一睡就睡了整个一个队列。我想单独控制队列个别元素该怎么办？

?

static int __init my_init(void)

{  

    int result, result1;   

    int  wait_queue_num=0;

    wait_queue_head_t head;

    wait_queue_t data, data2, *curr, *next;

 

    printk("<0>into my_init.\n");        

             

    result1=kernel_thread(my_function,NULL,CLONE_KERNEL);

    result2=kernel_thread(my_function,NULL,CLONE_KERNEL);

 

    struct pid * kpid1 = find_get_pid(result);

    struct task_struct * task1 = pid_task(kpid1,PIDTYPE_PID);

    struct pid * kpid2 = find_get_pid(result1);

    struct task_struct * task2 = pid_task(kpid2,PIDTYPE_PID);

 

    init_waitqueue_head(&head);

 

    init_waitqueue_entry(&data1, task1);

    data.task_list.next=&data1.task_list;    //这里注意了，要使用prepare_to_wait，这里就必须这样初始化即将插入的队列元素

    printk("<0>the state of the current thread is:%ld\n",current->state);

    prepare_to_wait(&head, &data1, 130);  //插入队列后，同时也将当下的进程的状态改为了130

    printk("<0>the state of the current thread is:%ld\n",current->state);

 

    init_waitqueue_entry(&data2, task2);

    data2.task_list.next=&data2.task_list;

    prepare_to_wait_exclusive(&head, &data2, 2);    //又插了一个

    printk("<0>the state of the current thread is:%ld\n",current->state);

     

    list_for_each_entry_safe(curr, next, &(head.task_list), task_list)

    {

        wait_queue_num++;

    }      

    printk("<0>the value of the wait_queue_num is :%d\n",wait_queue_num);    //打印后发现，队列里确实有两个元素

    finish_wait(&head,&data2);

    printk("<0>the state of the current thread is:%ld\n",current->state);

 

    wait_queue_num=0;

    list_for_each_entry_safe(curr, next, &(head.task_list), task_list)

    {

        wait_queue_num++;

    }

    printk("<0>the value of the wait_queue_num is :%d\n",wait_queue_num);        //删掉一个后，当然就剩下一个咯

 

    printk("<0>out my_init.\n");

    return 0;

}

首先先解释下什么是130，当然就是128+2啦，对应的第二位和第八位。也就是说内核用一位代表了一种进程状态。在这里，

2：    TASK_INTERRUPTIBLE         128： TASK_WAKEKILL

2.6.32的版本，设计了九种状态，咋是九种？不是只有八位不？——@##% ，不是还有个零么！

  

当然，内核api里还有许多函数会对队列进行更精细的操作，比如 wake_up_process，sleep_on_interrupt_timeout 什么的，看多了，也就发现其中有着相当的规律，尤其是函数名字的命名方式，这样，对内核api的学习也算是一点点慰藉。