内核线程同步之completion

Completion，完成量，用于多线程间同步，即线程A要往下执行需要等待线程B执行到指定代码后才继续执行，这时就可以使用该机制，用于一个线程告诉另一个线程指定工作已完成。
在Linux Kernel源码include/linux/completion.h文件里有相关的结构体和接口函数的定义和声明，从结构体可以看到其是基于等待队列机制实现的，该机制后期再了解，下面是completion相关内容：
struct completion {
        unsigned int done;
        wait_queue_head_t wait;
};
static inline void init_completion(struct completion *x) ;
static inline void reinit_completion(struct completion *x);
extern void wait_for_completion(struct completion *);
extern int wait_for_completion_interruptible(struct completion *x);
extern int wait_for_completion_killable(struct completion *x);
extern unsigned long wait_for_completion_timeout(struct completion *x,
        unsigned long timeout);
extern long wait_for_completion_interruptible_timeout(
        struct completion *x, unsigned long timeout);
extern long wait_for_completion_killable_timeout(
        struct completion *x, unsigned long timeout);
extern bool try_wait_for_completion(struct completion *x);
extern bool completion_done(struct completion *x);

extern void complete(struct completion *);
extern void complete_all(struct completion *);
其中结构体中的done相当于一个统计量，当其为0时表示等待队列上还有线程在等待，如果大于0则表示有多少个线程等待的条件已完成，不需等待可继续执行。
init_completion初始化一个completion结构体，将done设置为0，并初始化wait等待队列头部。而 reinit_completion则是在complete_all执行后completion仍想继续使用时必须执行的函数。 wait_for_completion则等待创建的completion量完成，即等待complete或complete_done函数执行。而_interruptible则表示该等待可被信号中断，_killable则表示该等待可被kill信号打断，_timeout则表示该等待只等待有限的时间，还有其他的组合则是这3种条件的组成，而try_wait_for_completion则相当于wait_for_completion_timeout中timeout为0的情况。 completion_done则是个判断条件，返回0表示还有等待者，为1则没有等待者。
接下来就演示两个内核线程间如何使用completion量，源码如下：
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/completion.h>
#include <linux/signal.h>

static struct task_struct * slam1, * slam2;
static struct completion slam_comp;

extern unsigned long msleep_interruptible(unsigned int msecs);

static int slam1_func(void *data)
{
        do{
                printk("I'm in slam1,wating slam_comp completion!\n");
                wait_for_completion(&slam_comp);
                printk("slam1:slam_comp completion done!\n");
        }while(!kthread_should_stop());

        return 0;
}

static int slam2_func(void *data)
{
        int i = 0;
        do{
                printk("I'm in slam2_func,i'll do complete!\n");
                i++;
                if(i%2 == 0){
                        complete(&slam_comp);
                        i=0;
                }
                msleep_interruptible(5000);
        }while(!kthread_should_stop());

        return 0;
}

static __init int kthread_completion_init(void)
{
        init_completion(&slam_comp);

        slam1 = kthread_run(slam1_func, NULL, "slam1");
        if(IS_ERR(slam1))
        {
                printk("kthread_run slam1 failed!\n");
                return 1;
        }

        slam2 = kthread_run(slam2_func, NULL, "slam2");
        if(IS_ERR(slam2))
        {
                printk("kthread_run slam2 failed!\n");
                return 1;
        }
        return 0;
}

static __exit void kthread_completion_exit(void)
{
        if(!IS_ERR(slam1))
                kthread_stop(slam1);

        if(!IS_ERR(slam2))
                kthread_stop(slam2);
}

module_init(kthread_completion_init);
module_exit(kthread_completion_exit);
相应的Makefile文件内容如下：
obj-m += kthread_completion_example.o

CUR_PATH:=$(shell pwd)
LINUX_KERNEL_PATH:=/home/xinu/linux-3.13.6

all:
        make -C $(LINUX_KERNEL_PATH) M=$(CUR_PATH) modules

clean:
        make -C $(LINUX_KERNEL_PATH) M=$(CUR_PATH) clean
而相应的源码文件目录树如下：
/home/xinu/xinu/linux_kernel_driver_l1/kthread_completion_example
├── kthread_completion_example.c
└── Makefile
等我们编译加截后，就可以看到两个内核线程中的打印信息顺序了，这与我们预想的一样吧。但在卸载模块时要等很久才能结束，这个会随着线程数的增多而变得越慢，于是我们将kthread_should_stop改为自加的exit_flag标志，并且在卸载函数中修改exit_flag标志和complete_all完成相应的completion，源码修改后如下：
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/completion.h>
#include <linux/signal.h>

static struct task_struct * slam1, * slam2;
static struct completion slam_comp;

static int exit_flag = 0;

extern unsigned long msleep_interruptible(unsigned int msecs);

static int slam1_func(void *data)
{
        do{
                printk("I'm in slam1,wating slam_comp completion!\n");
                wait_for_completion(&slam_comp);
                printk("slam1:slam_comp completion done!\n");
        }while(!exit_flag);

        return 0;
}

static int slam2_func(void *data)
{
        int i = 0;
        do{
                printk("I'm in slam2_func,i'll do complete!\n");
                i++;
                if(i%2 == 0){
                        complete(&slam_comp);
                        i=0;
                }
                msleep_interruptible(5000);
        }while(!exit_flag);

        return 0;
}

static __init int kthread_completion_init(void)
{
        init_completion(&slam_comp);

        slam1 = kthread_run(slam1_func, NULL, "slam1");
        if(IS_ERR(slam1))
        {
                printk("kthread_run slam1 failed!\n");
                return 1;
        }

        slam2 = kthread_run(slam2_func, NULL, "slam2");
        if(IS_ERR(slam2))
        {
                printk("kthread_run slam2 failed!\n");
                return 1;
        }

        return 0;
}

static __exit void kthread_completion_exit(void)
{
        exit_flag = 1;
        complete_all(&slam_comp);

        if(!IS_ERR(slam1))
                kthread_stop(slam1);

        if(!IS_ERR(slam2))
                kthread_stop(slam2);
}

module_init(kthread_completion_init);
module_exit(kthread_completion_exit);
修改后的代码在卸载时间就跟以前的模块一样了，很快就可以退出。感受了一遍completion，我们以后就可以在多线程中开始有“秩序”了，因为多个线程到底哪个先哪个慢执行，这取决于操作系统的调度算法。
参考网址：
http://www.cnblogs.com/zhuyp1015/archive/2012/06/13/2548458.html
http://blog.csdn.net/qb_2008/article/details/6837262
http://silverfoxkkk.pixnet.net/blog/post/44902897-lddp%3A%E5%8D%81%E3%80%81%E5%90%8C%E6%AD%A5%E8%88%87%E9%8E%96%E5%AE%9A

评论

发表评论

此博客中的热门博文

I/O映射之I/O端口

图片
对于外设，操作系统会采用端口映射和内存映射两种方式来对其进行控制，其中端口映射就是操作系统规定好一段地址给指定换上设，其与外设的寄存器按顺序一一对应上。 在Linux内核源码include/asm-generic/io.h头文件里有如下我们对I/O port进行操作的函数： static inline u8 inb(unsigned long addr) { return readb(addr + PCI_IOBASE); } static inline u16 inw(unsigned long addr) { return readw(addr + PCI_IOBASE); } static inline u32 inl(unsigned long addr) { return readl(addr + PCI_IOBASE); } static inline void outb(u8 b, unsigned long addr) { writeb(b, addr + PCI_IOBASE); } static inline void outw(u16 b, unsigned long addr) { writew(b, addr + PCI_IOBASE); } static inline void outl(u32 b, unsigned long addr) { writel(b, addr + PCI_IOBASE); } #define inb_p(addr) inb(addr) #define inw_p(addr) inw(addr) #define inl_p(addr) inl(addr) #define outb_p(x, addr) outb((x), (addr)) #define outw_p(x, addr) outw((x), (addr)) #define outl_p(x, addr) outl((x), (addr)) 分别对应对端口进行读取或写入字节、字、双字大小数据的操作。 该头文件中还有其他的操作函数及宏定义，请自行深入了解。 我们可通过读取/proc/ioports文件来了解Linux里I/O端口的映射
阅读全文

通过Netlink检测网线插拔

  最近有个需求需要检测RJ45网卡的网线有没有接上，而最近正在了解Netlink相关资料，刚好也看下通过Netlink可以进行检测，故在此做下粗略笔记：   1.首先要创建一个Netlink Socket，在用户层使用如下参数来调用socket()函数：    fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);    上面这个函数第一个参数必须是AF_NETLINK或PF_NETLINK，这两个标志在Linux下是一样的，第二个参数可以是SOCK_RAW或SOCK_DGRAM（对应用到TCP或UDP协议），而最后一个参数NETLINK_ROUTE为“路由守护进程”，用于接收来自内核的路由通知事件。   2.将上面创建的Socket绑定    addr.nl_family = AF_NETLINK;    addr.nl_groups = RTNLGRP_LINK; //指定接收路由多播组消息    bind(fd, (struct sockaddr*)&addr, sizeof(addr));    上面将创建的socket与相应的协议族和组进行绑定，接下来通过读fd这个socket来获得相应的消息数据struct nlmsghdr，再对该结构体数据进行判断来获得网线是接上或是拔掉，相应的源码如下： #include <sys/types.h>  #include <sys/socket.h>  #include <asm/types.h>  #include <linux/netlink.h>  #include <linux/rtnetlink.h>  #include <stdlib.h>  #include <stdio.h>  #include <sys/ioctl.h>  #include <linux/if.h>  #include <string.h>  #define BUFLEN 20480  int main(int argc, char *argv[])  {      int fd, retval;      char buf[BUFLEN] = {0};
阅读全文

使用seq_file

在《使用procfs》一文的源码示例中有说到proc文件系统每次读取的数据只能是1个页，如果超过则需多次读取，这样的话会增加读取次数，增多系统调用次数，影响了整体的效率，故而才有seq file序列文件的出现，该项功能使得内核对于大文件的读取更加容易。 对于seq file，其结构体定义在include/linux/seq_file.h文件中，内容如下： struct seq_file { char *buf; size_t size; size_t from; size_t count; size_t pad_until; loff_t index; loff_t read_pos; u64 version; struct mutex lock; const struct seq_operations *op; int poll_event; #ifdef CONFIG_USER_NS struct user_namespace *user_ns; #endif void *private; }; 这里不详细说明该结构体，仅供感受下。 对于seq_file，相应的文件操作需要实现seq_operations结构体的成员，该结构体在同一头文件中有如下定义： struct seq_operations { void * (*start) (struct seq_file *m, loff_t *pos); void (*stop) (struct seq_file *m, void *v); void * (*next) (struct seq_file *m, void *v, loff_t *pos); int (*show) (struct seq_file *m, void *v); }; 实现该结构体成员后，需要使用seq_open打开，让文件与该seq_operations关联起来，最终这个open函数要作为file_oper
阅读全文