complete_and_exit

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

 typedef struct __wait_queue_head wait_queue_head_t;

  struct completion {
          unsigned int done;
          wait_queue_head_t wait;
  };

 

 

 

 void fastcall complete(struct completion *x)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&x->wait.lock, flags);
         x->done++;
         __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE,
                          1, 0, NULL);
         spin_unlock_irqrestore(&x->wait.lock, flags);
 }

 completion是一种轻量级的机制，它允许一个线程告诉另一个线程工作已经完成。可以利用下面的宏静态创建completion：
                         DECLARE_COMPLETION(my_completion);
       
        如果运行时创建completion，则必须采用以下方法动态创建和初始化：
                         struct compltion my_completion;
                          init_completion(&my_completion);
        completion的相关定义包含在kernel/include/linux/completion.h中：
                        struct completion {
                                     unsigned int done;
                                     wait_queue_head_t wait;
                         };

#define COMPLETION_INITIALIZER(work) /
                                                           { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
#define DECLARE_COMPLETION(work) /
                                                      struct completion work = COMPLETION_INITIALIZER(work)
static inline void init_completion(struct completion *x)
{
          x->done = 0;
          init_waitqueue_head(&x->wait);
}
 
       要等待completion，可进行如下调用：
                    void wait_for_completion(struct completion *c);
       触发completion事件，调用：
                   void complete(struct completion *c);    //唤醒一个等待线程
                   void complete_all(struct completion *c);//唤醒所有的等待线程
        为说明completion的使用方法，将《Linux设备驱动程序》一书中的complete模块的代码摘抄如下：
/*
* complete.c -- the writers awake the readers
*
* Copyright (C) 2003 Alessandro Rubini and Jonathan Corbet
* Copyright (C) 2003 O'Reilly & Associates
*
* The source code in this file can be freely used, adapted,
* and redistributed in source or binary form, so long as an
* acknowledgment appears in derived source files.    The citation
* should list that the code comes from the book "Linux Device
* Drivers" by Alessandro Rubini and Jonathan Corbet, published
* by O'Reilly & Associates.     No warranty is attached;
* we cannot take responsibility for errors or fitness for use.
*
* $Id: complete.c,v 1.2 2004/09/26 07:02:43 gregkh Exp $
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>   /* current and everything */
#include <linux/kernel.h> /* printk() */
#include <linux/fs.h>      /* everything... */
#include <linux/types.h>   /* size_t */
#include <linux/completion.h>
MODULE_LICENSE("Dual BSD/GPL");
static int complete_major = 253;//指定主设备号
DECLARE_COMPLETION(comp);
ssize_t complete_read (struct file *filp, char __user *buf, size_t count, loff_t *pos)
{
         printk(KERN_DEBUG "process %i (%s) going to sleep/n",
         current->pid, current->comm);
         wait_for_completion(&comp);
         printk(KERN_DEBUG "awoken %i (%s)/n", current->pid, current->comm);
         return 0; /* EOF */
}
ssize_t complete_write (struct file *filp, const char __user *buf, size_t count,
    loff_t *pos)
{
         printk(KERN_DEBUG "process %i (%s) awakening the readers.../n",
         current->pid, current->comm);
         complete(&comp);
         return count; /* succeed, to avoid retrial */
}

struct file_operations complete_fops = {
         .owner = THIS_MODULE,
         .read =    complete_read,
         .write = complete_write,
};

int complete_init(void)
{
         int result;
/*
    * Register your major, and accept a dynamic number
    */
        result = register_chrdev(complete_major, "complete", &complete_fops);
        if (result < 0)
                return result;
        if (complete_major == 0)
                complete_major = result; /* dynamic */
        return 0;
}
void complete_cleanup(void)
{
         unregister_chrdev(complete_major, "complete");
}
module_init(complete_init);
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结构，具体代码如下：
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/completion.h>
MODULE_LICENSE("Dual BSD/GPL");
#undef KERN_DEBUG
#define KERN_DEBUG "<1>"
static int complete_major=253;
static int reader_count = 0;
DECLARE_COMPLETION(comp);
ssize_t complete_read (struct file *filp,char __user *buf,size_t count,loff_t *pos)
{
           printk(KERN_DEBUG "process %i (%s) going to sleep,waiting for writer/n",current->pid,current->comm);
           reader_count++;
           printk(KERN_DEBUG "In read ,before comletion: reader count = %d /n",reader_count);
           wait_for_completion(&comp);
           reader_count--;
           printk(KERN_DEBUG "awoken %s (%i) /n",current->comm,current->pid);
           printk(KERN_DEBUG "In read,after completion : reader count = %d /n",reader_count);
/*如果使用complete_all，则completion结构只能用一次，再次使用它时必须调用此宏进行重新初始化*/
           if(reader_count == 0)
                       INIT_COMPLETION(comp);

           return 0;
}
ssize_t complete_write(struct file *filp,const char __user *buf,size_t count,loff_t *pos)
{
           printk(KERN_DEBUG "process %i (%s) awoking the readers.../n",current->pid,current->comm);
           printk(KERN_DEBUG "In write ,before do complete_all : reader count = %d /n",reader_count);

           if(reader_count != 0)  
                   complete_all(&comp);

           printk(KERN_DEBUG "In write ,after do complete_all : reader count = %d /n",reader_count);

           return count;
}
struct file_operations complete_fops={
           .owner = THIS_MODULE,
           .read = complete_read,
           .write = complete_write,
};
int complete_init(void)
{
           int result;
           result=register_chrdev(complete_major,"complete",&complete_fops);
           if(result<0)
                    return result;
           if(complete_major==0)
                   complete_major =result;
           printk(KERN_DEBUG    "complete driver test init! complete_major=%d/n",complete_major);
           printk(KERN_DEBUG "静态初始化completion/n");

           return 0;
}
void complete_exit(void)
{
           unregister_chrdev(complete_major,"complete");
           printk(KERN_DEBUG    "complete driver    is removed/n");
}
module_init(complete_init);
module_exit(complete_exit);
这里测试步骤和上述一样，只不过需要多打开几个终端来执行多个进程同时读操作。
____________
参考资料：
1.Jonathan Corbet等著，魏永明等译.linux设备驱动程序(第三版)
2.Linux Kernel 

 

 

 

 #define spin_lock_irqsave(lock, flags) /
 do { /
         local_irq_save(flags); /
         preempt_disable(); /
         _raw_spin_lock_flags(lock, flags); /
 } while (0)

 

 

 

 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
                              int nr_exclusive, int sync, void *key)
 {
         struct list_head *tmp, *next;
 
         list_for_each_safe(tmp, next, &q->task_list) {
                 wait_queue_t *curr;
                 unsigned flags;
                 curr = list_entry(tmp, wait_queue_t, task_list);
                 flags = curr->flags;
                 if (curr->func(curr, mode, sync, key) &&
                     (flags & WQ_FLAG_EXCLUSIVE) &&
                     !--nr_exclusive)
                         break;
         }
 }

 asmlinkage NORET_TYPE void do_exit(long code)
 {
         struct task_struct *tsk = current;
 
         if (unlikely(in_interrupt()))
                 panic("Aiee, killing interrupt handler!");
         if (unlikely(!tsk->pid))
                 panic("Attempted to kill the idle task!");
         if (unlikely(tsk->pid == 1))
                 panic("Attempted to kill init!");
         if (tsk->io_context)
                 exit_io_context();
         tsk->flags |= PF_EXITING;
         del_timer_sync(&tsk->real_timer);
 
         if (unlikely(in_atomic()))
                 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d/n",
                                 current->comm, current->pid,
                                 preempt_count());
 
         profile_exit_task(tsk);
  
         if (unlikely(current->ptrace & PT_TRACE_EXIT)) {
                 current->ptrace_message = code;
                 ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP);
         }
 
         acct_process(code);
         __exit_mm(tsk);
 
         exit_sem(tsk);
         __exit_files(tsk);
         __exit_fs(tsk);
         exit_namespace(tsk);
         exit_thread();
 
         if (tsk->signal->leader)
                 disassociate_ctty(1);
 
         module_put(tsk->thread_info->exec_domain->module);
         if (tsk->binfmt)
                 module_put(tsk->binfmt->module);
 
         tsk->exit_code = code;
         exit_notify(tsk);
 #ifdef CONFIG_NUMA
         mpol_free(tsk->mempolicy);
         tsk->mempolicy = NULL;
 #endif
         schedule();
         BUG();
         /* Avoid "noreturn function does return".  */
         for (;;) ;
 }

 NORET_TYPE void complete_and_exit(struct completion *comp, long code)
 {
         if (comp)
                 complete(comp);
 
         do_exit(code);
 }