问一个completion的问题

Question

completion 可以使用一个线程唤醒另外一个线程。

那么它跟 wake_up_interruptible 有什么区别么？？ 这个函数同样也能唤醒另外一个线程啊

Answer 1

completion是一种轻量级的机制，它允许一个线程告诉另一个线程工作已经完成。可以利用下面的宏静态创建completion：
DECLARE_COMPLETION(my_completion);
如果运行时创建completion，则必须采用以下方法动态创建和初始化：

2. struct compltion my_completion;
3. init_completion(&my_completion);
4. completion的相关定义包含在kernel/include/linux/completion.h中:
5. struct completion {
6. unsigned int done;
7. wait_queue_head_t wait;
8. };
9. #define COMPLETION_INITIALIZER(work)
10.         { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
11. #define DECLARE_COMPLETION(work)
12.         struct completion work = COMPLETION_INITIALIZER(work)
13. static inline void init_completion(struct completion *x)
14. {
15.     x->done = 0;
16.     init_waitqueue_head(&x->wait);
17. }

复制代码
要等待completion，可进行如下调用：
void wait_for_completion(struct completion *c);
触发completion事件，调用：
void complete(struct completion *c);      //唤醒一个等待线程
void complete_all(struct completion *c); //唤醒所有的等待线程
为说明completion的使用方法，将<<Linux设备驱动程序>>一书中的complete模块的代码摘抄如下：

2. /*
3. * complete.c -- the writers awake the readers
4. */
5. ------------------------------------------------------------
6. #include <linux/module.h>
7. #include <linux/init.h>
8. #include <linux/sched.h>   /* current and everything */
9. #include <linux/kernel.h> /* printk() */
10. #include <linux/fs.h>      /* everything... */
11. #include <linux/types.h>   /* size_t */
12. #include <linux/completion.h>
13. MODULE_LICENSE("Dual BSD/GPL");
14. static int complete_major = 253; //指定主设备号
15. DECLARE_COMPLETION(comp);
16. ssize_t complete_read (
17.     struct file *filp, char __user *buf,
18.     size_t       count, loff_t       *pos)
19. {
20.     printk(KERN_DEBUG "process %i (%s) going to sleepn",
21.             current->pid, current->comm);
22.     wait_for_completion(&comp);
23.     printk(KERN_DEBUG "awoken %i (%s)n", current->pid, current->comm);
24.     return 0;
25. }
26. ssize_t complete_write (
27.     struct file *filp, const char __user *buf,
28.     size_t       count, loff_t            *pos)
29. {
30.     printk(KERN_DEBUG "process %i (%s) awakening the readers...n",
31.             current->pid, current->comm);
32.     complete(&comp);
33.     return count;
34. }
35. struct file_operations complete_fops = {
36.     .owner = THIS_MODULE,
37.     .read = complete_read,
38.     .write = complete_write,
39. };
40. int complete_init(void)
41. {
42.     int result;
43.     result = register_chrdev(complete_major, "completion", &complete_fops);
44.     if (result < 0)
45.         return result;
46.     if (complete_major == 0)
47.         complete_major = result;
48.     return 0;
49. }
50. void complete_cleanup(void)
51. {
52.     unregister_chrdev(complete_major, "completion");
53. }
54. module_init(complete_init);
55. module_exit(complete_cleanup);

复制代码
该模块定义了一个简单的completion设备：任何试图从该设备中读取的进程都将等待，直到其他设备写入该设备为止。编译此模块的Makefile如下：
obj-m := complete.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD   := $(shell pwd)
default:
    $(MAKE) -C $(KDIR) M=$(PWD) modules
clean:
    rm -f *.ko *.o *.mod.c
在linux终端中执行以下命令，编译生成模块，并进行动态加载
# make
# mknod completion c 253 0
# insmod complete.ko
再打开三个终端，一个用于读进程：
# cat completion
一个用于写进程：
# echo >completion
另一个查看系统日志：
# tail -f /var/log/messages
值得注意的是，当我们使用的complete_all接口时，如果要重复使用一个completion结构，则必须执行INIT_COMPLETION (struct completion c)来重新初始化它。可以在kernel/include/linux/completion.h中找到这个宏的定义：
#define INIT_COMPLETION(x) ((x).done = 0)
以下代码对书中原有的代码进行了一番变动，将唤醒接口由原来的complete换成了complete_all，并且为了重复利用completion结构，所有读进程都结束后就重新初始化completion结构，具体代码如下：

2. #include <linux/module.h>
3. #include <linux/init.h>
4. #include <linux/sched.h>
5. #include <linux/kernel.h>
6. #include <linux/fs.h>
7. #include <linux/types.h>
8. #include <linux/completion.h>
9. MODULE_LICENSE("Dual BSD/GPL");
10. #undef KERN_DEBUG
11. #define KERN_DEBUG "<1>"
12. static int complete_major=253;
13. static int reader_count = 0;
14. DECLARE_COMPLETION(comp);
15. ssize_t complete_read (struct file *filp,char __user *buf,size_t count,loff_t *pos)
16. {
17.     printk(KERN_DEBUG "process %i (%s) going to sleep,waiting for writern",current->pid,current->comm);
18.     reader_count++;
19.     printk(KERN_DEBUG "In read ,before comletion: reader count = %d n",reader_count);
20.     wait_for_completion(&comp);
21.     reader_count--;
22.     printk(KERN_DEBUG "awoken %s (%i) n",current->comm,current->pid);
23.     printk(KERN_DEBUG "In read,after completion : reader count = %d n",reader_count);
24.     /*如果使用complete_all，则completion结构只能用一次，再次使用它时必须调用此宏进行重新初始化*/
25.     if(reader_count == 0)
26.         INIT_COMPLETION(comp);
27.     return 0;
28. }
29. ssize_t complete_write(struct file *filp,const char __user *buf,size_t count,loff_t *pos)
30. {
31.     printk(KERN_DEBUG "process %i (%s) awoking the readers...n",current->pid,current->comm);
32.     printk(KERN_DEBUG "In write ,before do complete_all : reader count = %d n",reader_count);
33.     if(reader_count != 0)
34.         complete_all(&comp);
35.     printk(KERN_DEBUG "In write ,after do complete_all : reader count = %d n",reader_count);
36.     return count;
37. }
38. struct file_operations complete_fops={
39.     .owner = THIS_MODULE,
40.     .read = complete_read,
41.     .write = complete_write,
42. };
43. int complete_init(void)
44. {
45.     int result;
46.     result=register_chrdev(complete_major,"complete",&complete_fops);
47.     if(result<0)
48.         return result;
49.     if(complete_major==0)
50.         complete_major =result;
51.     printk(KERN_DEBUG    "complete driver test init! complete_major=%dn",complete_major);
52.     printk(KERN_DEBUG "静态初始化completionn");
53.     return 0;
54. }
55. void complete_exit(void)
56. {
57.     unregister_chrdev(complete_major,"complete");
58.     printk(KERN_DEBUG    "complete driver    is removedn");
59. }
60. module_init(complete_init);
61. module_exit(complete_exit);

复制代码
这里测试步骤和上述一样，只不过需要多打开几个终端来执行多个进程同时读操作。

Answer 2

我知道啊， 但是这些功能同样能够用 waike_up_interrutpible 完成啊

Answer 3

void fastcall __sched wait_for_completion(struct completion *x) {     might_sleep();     spin_lock_irq(&x->wait.lock);     if (!x->done) {         DECLARE_WAITQUEUE(wait, current);         wait.flags |= WQ_FLAG_EXCLUSIVE;         __add_wait_queue_tail(&x->wait, &wait);         do {             __set_current_state(TASK_UNINTERRUPTIBLE);             spin_unlock_irq(&x->wait.lock);             schedule();             spin_lock_irq(&x->wait.lock);         } while (!x->done);         __remove_wait_queue(&x->wait, &wait);     }     x->done--;     spin_unlock_irq(&x->wait.lock); }