Linux驱动中completion接口浅析(wait_for_complete例子，很好)

Dear 丶 2022-09-30 03:51 8阅读 0赞

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