Completion in linux

最新推荐文章于 2022-10-18 21:48:28 发布
最新推荐文章于 2022-10-18 21:48:28 发布
阅读量284 收藏 2
点赞数 1
分类专栏： linux-驱动基础 文章标签： linux
原文链接：https://embetronicx.com/tutorials/linux/device-drivers/completion-in-linux/
版权

Completion

先决条件

在示例部分中，我使用kthread解释了此完成过程。如果您不知道什么是kthread以及如何使用它，那么我建议您使用下面的链接进行探索。

  1. Kthread Tutorial in Linux Kernel
  2. Waitqueue Tutorial in Linux Kernel

Completion

Completion, 和名字本身说的一样。当我们想在完成某些工作时通知或唤醒某个线程或某些东西时，可以使用完成。我们将采取一种情况。我们要等待一个线程运行。在此之前，该线程必须休眠。该过程完成后，我们需要唤醒正在休眠的线程。我们可以通过使用没有竞争条件的完成来做到这一点。

这些完成是一种同步机制，在上述情况下是一种很好的方法，而不是使用不正确的锁/信号量和繁忙循环。

Completion in Linux Device Driver

在Linux内核中，完成是通过使用waitqueue开发的。

使用Completion的优点是它们具有定义明确，目标明确的目的，可以很容易地看到代码的意图，但是由于所有线程都可以继续执行直到实际需要结果，因此它们还可以提高代码效率。使用低级调度程序的睡眠/唤醒功能，等待和信令均非常高效。

Completion中有5个重要步骤。

  1. 初始化completion
  2. 重新初始化completion
  3. 等待completion（代码正在等待并等待完成某件事）
  4. 唤醒任务（将信号发送到睡眠部分）
  5. 检查状态

初始化completion

我们必须#include <linux/completion.h>并创建一个struct completion类型的变量，该变量只有两个字段：

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

在这里，wait是等待任务放置的等待队列（如果有的话）。done是用于指示其是否完成的完成标志。
我们可以通过两种方式创建类型变量。

  1. 静态方法
  2. 动态方法
    您可以使用任何一种方法。

静态方法

DECLARE_COMPLETION(data_read_done);

其中data_read_done是将要静态创建的结构的名称。

动态方法

init_completion (struct completion * x);

其中x指向要初始化的completion结构

举例：

struct completion data_read_done;
init_completion(&data_read_done);

在此init_completion调用中，我们初始化等待队列并将完成设置为0，即not completed或not done。

重新初始化完成

reinit_completion (struct completion * x);

这里x指向要重新初始化的completion结构
举例：

reinit_completion(&data_read_done);

此函数应用于重新初始化completion结构，以便可以重用。在使用complete_all之后，这一点尤其重要。只需将->done字段重置为0（“not done”），而无需触摸等待队列。该函数的调用者必须确保没有并行的wait_for_completion()调用。

等待完成

为了让线程等待一些并发活动完成，它会根据用例调用该函数中的任何一个。

wait_for_completion

这用于使函数等待任务完成。

void wait_for_completion (struct completion * x);

这里x指向保持此特定完成的状态
等待等待完成特定任务的信号。它不是可中断的，没有超时。

例如：

wait_for_completion (&data_read_done);

请注意，wait_for_completion()正在调用spin_lock_irq()/spin_unlock_irq()，因此只有在知道启用了中断的情况下才能安全地调用它。从IRQs-off原子上下文中调用它会导致难以检测到的虚假中断启用。

wait_for_completion_timeout

这用于使函数等待超时的任务完成。超时最好使用msecs_to_jiffies()或usecs_to_jiffies()计算，以使代码在很大程度上保持HZ不变。

unsigned long wait_for_completion_timeout (struct completion * x, unsigned long timeout);

x指向保持此特定完成的状态
timeout单位是jiffies
这等待信号通知特定任务的完成或指定的超时时间到期。timeout的单位是jiffies。它不是可中断的。

如果超时，则返回0；
如果完成，则返回正值（剩下的jiffies时间：ret=timeout-runtime）。
举例：

wait_for_completion_timeout (&data_read_done);

wait_for_completion_interruptible

这是等待要发出信号的特定任务的完成。它是可中断的。

int wait_for_completion_interruptible (struct completion * x);

x指向 保持此特定完成的状态
timeout单位是jiffies
如果被中断，则返回-ERESTARTSYS;
如果超时，则返回0;
如果已完成，则返回正数（至少1，或直到超时的剩余数量）。

wait_for_completion_killable

等待等待完成特定任务的信号。它可以被终止信号打断。

int wait_for_completion_killable (struct completion * x);

x指向保持此特定完成的状态
如果被中断，则返回-ERESTARTSYS;
如果超时，则返回0;

wait_for_completion_killable_timeout

这等待信号通知特定任务的完成或等待指定的超时时间到期。它可以被终止信号打断。超时最好使用msecs_to_jiffies（）或usecs_to_jiffies（）计算，以使代码在很大程度上保持HZ不变。

long wait_for_completion_killable_timeout (struct completion * x, unsigned long timeout);

x指向 保持此特定完成的状态
timeout单位是jiffies

如果被中断，则返回-ERESTARTSYS;
如果超时，则返回0;
如果已完成，则返回正数（至少1，或直到超时的剩余数量）。

try_wait_for_completion

此函数不会将线程放在等待队列中，而是在需要排队（阻塞）线程时返回false，否则它将消耗一个已发布的完成并返回true。

bool try_wait_for_completion (struct completion * x);

x指向 保持此特定完成的状态
如果无法完成则返回0;
如果成功则返回1。
在IRQ或原子上下文中可以安全地调用此try_wait_for_completion（）。

唤醒任务

complete

这将唤醒一个线程，等待完成。线程将以排队的顺序被唤醒。
x指向 保持此特定完成的状态
例子：

complete(&data_read_done);

complete_all

这将唤醒等待此特定完成事件的所有线程。

void complete_all (struct completion * x);

x指向 保持此特定完成的状态

检查状态

这是一项测试，以查看完成是否有任何等待。

bool completion_done (struct completion * x);

x指向 保持此特定完成的状态
如果有服务员，则返回0（wait_for_completion正在进行）;
如果没有服务员，则返回1。
可以在IRQ或原子上下文中安全地调用该complete_done（）。

Driver Source Code – Completion in Linux

首先，我将向您解释驱动程序代码的概念。

在此源代码中，我们将在两个地方发送完整的调用。一个来自读取功能，另一个来自驱动程序退出功能。

我创建了一个具有while(1)的线程（wait_function）。该线程将始终等待事件完成。它将一直处于睡眠状态，直到获得completion的调用。当它获得completion的调用时，它将检查条件。如果条件为1，则completion来自读取功能。它是2，则completion来自退出功能。如果完成来自读取功能，它将打印读取计数并再次等待。如果它来自退出函数，它将从线程中退出。

在这里，我添加了两个版本的代码。

  1. 通过静态方法创建的补全
  2. 通过动态方法创建的补全

但是从操作角度来看，两者是相同的。
GitHub

通过静态方法创建的补全

/***************************************************************************//**
*  \file       driver.c
*
*  \details    Simple linux driver (Completion Static method)
*
*  \author     EmbeTronicX
*
* *******************************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>                 //kmalloc()
#include <linux/uaccess.h>              //copy_to/from_user()
 
#include <linux/kthread.h>
#include <linux/completion.h>                // Required for the completion
 
 
uint32_t read_count = 0;
static struct task_struct *wait_thread;
 
DECLARE_COMPLETION(data_read_done);
 
dev_t dev = 0;
static struct class *dev_class;
static struct cdev etx_cdev;
int completion_flag = 0;
 
static int __init etx_driver_init(void);
static void __exit etx_driver_exit(void);
 
/*************** Driver Functions **********************/
static int etx_open(struct inode *inode, struct file *file);
static int etx_release(struct inode *inode, struct file *file);
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len,loff_t * off);
static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t * off);
 
static struct file_operations fops =
{
        .owner          = THIS_MODULE,
        .read           = etx_read,
        .write          = etx_write,
        .open           = etx_open,
        .release        = etx_release,
};
 
static int wait_function(void *unused)
{
        
        while(1) {
                printk(KERN_INFO "Waiting For Event...\n");
                wait_for_completion (&data_read_done);
                if(completion_flag == 2) {
                        printk(KERN_INFO "Event Came From Exit Function\n");
                        return 0;
                }
                printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
                completion_flag = 0;
        }
        do_exit(0);
        return 0;
}
 
static int etx_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Opened...!!!\n");
        return 0;
}
 
static int etx_release(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Closed...!!!\n");
        return 0;
}
 
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Read Function\n");
        completion_flag = 1;
        if(!completion_done (&data_read_done)) {
            complete (&data_read_done);
        }
        return 0;
}
 
static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Write function\n");
        return 0;
}
 
static int __init etx_driver_init(void)
{
        /*Allocating Major number*/
        if((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) <0){
                printk(KERN_INFO "Cannot allocate major number\n");
                return -1;
        }
        printk(KERN_INFO "Major = %d Minor = %d \n",MAJOR(dev), MINOR(dev));
 
        /*Creating cdev structure*/
        cdev_init(&etx_cdev,&fops);
        etx_cdev.owner = THIS_MODULE;
        etx_cdev.ops = &fops;
 
        /*Adding character device to the system*/
        if((cdev_add(&etx_cdev,dev,1)) < 0){
            printk(KERN_INFO "Cannot add the device to the system\n");
            goto r_class;
        }
 
        /*Creating struct class*/
        if((dev_class = class_create(THIS_MODULE,"etx_class")) == NULL){
            printk(KERN_INFO "Cannot create the struct class\n");
            goto r_class;
        }
 
        /*Creating device*/
        if((device_create(dev_class,NULL,dev,NULL,"etx_device")) == NULL){
            printk(KERN_INFO "Cannot create the Device 1\n");
            goto r_device;
        }
 
        //Create the kernel thread with name 'mythread'
        wait_thread = kthread_create(wait_function, NULL, "WaitThread");
        if (wait_thread) {
                printk("Thread Created successfully\n");
                wake_up_process(wait_thread);
        } else
                printk(KERN_INFO "Thread creation failed\n");
 
        printk(KERN_INFO "Device Driver Insert...Done!!!\n");
        return 0;
 
r_device:
        class_destroy(dev_class);
r_class:
        unregister_chrdev_region(dev,1);
        return -1;
}
 
static void __exit etx_driver_exit(void)
{
        completion_flag = 2;
        if(!completion_done (&data_read_done)) {
            complete (&data_read_done);
        }
        device_destroy(dev_class,dev);
        class_destroy(dev_class);
        cdev_del(&etx_cdev);
        unregister_chrdev_region(dev, 1);
        printk(KERN_INFO "Device Driver Remove...Done!!!\n");
}
 
module_init(etx_driver_init);
module_exit(etx_driver_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX <embetronicx@gmail.com>");
MODULE_DESCRIPTION("A simple device driver - Completion (Static Method)");
MODULE_VERSION("1.23");

通过动态方法完成

/****************************************************************************//**
*  \file       driver.c
*
*  \details    Simple linux driver (Completion Dynamic method)
*
*  \author     EmbeTronicX
*
* *******************************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>                 //kmalloc()
#include <linux/uaccess.h>              //copy_to/from_user()
 
#include <linux/kthread.h>
#include <linux/completion.h>                // Required for the completion
 
 
uint32_t read_count = 0;
static struct task_struct *wait_thread;
 
struct completion data_read_done;
 
dev_t dev = 0;
static struct class *dev_class;
static struct cdev etx_cdev;
int completion_flag = 0;
 
static int __init etx_driver_init(void);
static void __exit etx_driver_exit(void);
 
/*************** Driver Functions **********************/
static int etx_open(struct inode *inode, struct file *file);
static int etx_release(struct inode *inode, struct file *file);
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len,loff_t * off);
static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t * off);
 
static struct file_operations fops =
{
        .owner          = THIS_MODULE,
        .read           = etx_read,
        .write          = etx_write,
        .open           = etx_open,
        .release        = etx_release,
};
 
static int wait_function(void *unused)
{
        
        while(1) {
                printk(KERN_INFO "Waiting For Event...\n");
                wait_for_completion (&data_read_done);
                if(completion_flag == 2) {
                        printk(KERN_INFO "Event Came From Exit Function\n");
                        return 0;
                }
                printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
                completion_flag = 0;
        }
        do_exit(0);
        return 0;
}
 
static int etx_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Opened...!!!\n");
        return 0;
}
 
static int etx_release(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Closed...!!!\n");
        return 0;
}
 
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Read Function\n");
        completion_flag = 1;
        if(!completion_done (&data_read_done)) {
            complete (&data_read_done);
        }
        return 0;
}
 
static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Write function\n");
        return 0;
}
 
static int __init etx_driver_init(void)
{
        /*Allocating Major number*/
        if((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) <0){
                printk(KERN_INFO "Cannot allocate major number\n");
                return -1;
        }
        printk(KERN_INFO "Major = %d Minor = %d \n",MAJOR(dev), MINOR(dev));
 
        /*Creating cdev structure*/
        cdev_init(&etx_cdev,&fops);
        etx_cdev.owner = THIS_MODULE;
        etx_cdev.ops = &fops;
 
        /*Adding character device to the system*/
        if((cdev_add(&etx_cdev,dev,1)) < 0){
            printk(KERN_INFO "Cannot add the device to the system\n");
            goto r_class;
        }
 
        /*Creating struct class*/
        if((dev_class = class_create(THIS_MODULE,"etx_class")) == NULL){
            printk(KERN_INFO "Cannot create the struct class\n");
            goto r_class;
        }
 
        /*Creating device*/
        if((device_create(dev_class,NULL,dev,NULL,"etx_device")) == NULL){
            printk(KERN_INFO "Cannot create the Device 1\n");
            goto r_device;
        }
 
        //Create the kernel thread with name 'mythread'
        wait_thread = kthread_create(wait_function, NULL, "WaitThread");
        if (wait_thread) {
                printk("Thread Created successfully\n");
                wake_up_process(wait_thread);
        } else
                printk(KERN_INFO "Thread creation failed\n");
 
        //Initializing Completion
        init_completion(&data_read_done);
 
        printk(KERN_INFO "Device Driver Insert...Done!!!\n");
        return 0;
 
r_device:
        class_destroy(dev_class);
r_class:
        unregister_chrdev_region(dev,1);
        return -1;
}
 
static void __exit etx_driver_exit(void)
{
        completion_flag = 2;
        if(!completion_done (&data_read_done)) {
            complete (&data_read_done);
        }
        device_destroy(dev_class,dev);
        class_destroy(dev_class);
        cdev_del(&etx_cdev);
        unregister_chrdev_region(dev, 1);
        printk(KERN_INFO "Device Driver Remove...Done!!!\n");
}
 
module_init(etx_driver_init);
module_exit(etx_driver_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX <embetronicx@gmail.com>");
MODULE_DESCRIPTION("A simple device driver - Completion (Dynamic Method)");
MODULE_VERSION("1.24");

MakeFile

obj-m += driver.o
KDIR = /lib/modules/$(shell uname -r)/build
all:
    make -C $(KDIR)  M=$(shell pwd) modules
clean:
    make -C $(KDIR)  M=$(shell pwd) clean

构建和测试驱动程序

make #编译
insmod driver.ko # 加载模块
dmesg #查看打印

因此该线程正在等待事件。现在我们将通过使用

sudo cat /dev/etx_device

rmmod driver # 移除模块
山羊哥-老宋
关注
专栏目录
内核线程同步之completion
阿xin*的嵌入式AI
09-10 85
Linux内核线程同步机制Completion使用及编程。
linux驱动20：completion（用于同步）
dongyoubin的博客
05-14 194
completion是一种轻量级同步机制，允许一个线程通知另外一个线程某个工作已经完成。 头文件：<linux/completion.h> 初始化： init_completion(struct completion *c); 等待完成： void wait_for_completion(struct completion *c); 执行一个非中断的等待，如果代码调用了该函数且没有人调用completion，将产生一个不可杀进程。 触发完成： void completion(st
completion
coldsnow33的专栏
01-20 1252
1 数据结构 struct completion { unsigned int done; wait_queue_head_t wait;//等待队列头 }; 2 初始化 2.1 动态 static inline void init_completion(struct completion *x) { x->done = 0; init_waitqueue_head(&x->wai
进程调度API之completion_done
jason的笔记
12-15 1272
bool completion_done(struct completion *x) 用于判断是否还有wait等待在completion *x 这个完成量上，然后true 表示没有等待，false 表示有wait在等待 其源码分析如下: bool completion_done(struct completion *x) { if (!READ_ONCE(x->done)) return f
内核并发控制---完成量 （来自网易）
wangpengqi的专栏
10-08 722
定义在头文件linux/completion.h中; 完成量(completion)是Linux系统提供的一种比信号量更好的同步机制,是对信号量的一种补充;它用于一个执行单元等待另一个执行单元完成某事;使用完成量等待时,调用进程是以独占睡眠方式进行等待的;不是忙等待; 1).定义完成量: struct completion my_completion;    //定义完成量my_comple
LDD3之并发和竞态-completion(完成量)的学习和验证
alianqiugui的博客
01-18 563
原文:http://blog.csdn.net/kangear/article/details/34898267 LDD3之并发和竞态-completion(完成量)的学习和验证 首先说下测试环境： Linux2.6.32.2 Mini2440开发板 一开始难以理解书上的书面语言，这里《linux中同步例子(完成量completion)》举了一个公交车上司机和乘客
Linux内核wait,进程调度 – Linux内核API wait_for_completion
weixin_35212670的博客
05-02 981
wait_for_completion函数功能描述：此函数用于阻塞当前进程，等待其他进程的执行结束，被等待进程保存在输入参数的wait字段所代表的等待队列中，只有当等待队列中的进程被函数complete( )或complete_all( )唤醒之后，等待才有可能结束，当前的进程才能够继续执行，否则会一直等待。此函数将当前进程置于不可中断的等待状态，所以等待不能够强制结束，并且等待的时间是MAX_S...
linux4.0-camera-uvc.patch
07-17
解决camera运行出现uvcvideo: Non-zero status (-71) in video completion handler.
Linux中10个有用的命令行补全例子
01-11
在 Linux 系统中，当你输入一个命令，再按两次TAB 键，就会列出所有以你输入字符开头的可用命令。这并不新鲜，可能你已经知道了。这个功能被称作命令行补全bash completion。默认情况下，bash 命令行可以自动补全...
Linux for Beginners: An Introduction to the Linux Operating System
02-11
inux for Beginners doesn't make any ...What you learn in "Linux for Beginners" applies to any Linux environment including Ubuntu, Debian, Linux Mint, RedHat, Fedora, OpenSUSE, Slackware, and more.
linux completion接口
05-29 1779
头文件 /*  * struct completion - structure used to maintain state for a "completion"  *  * This is the opaque structure used to maintain the state for a "completion".  * Completions currently use a
Linux completion
weixin_41028621的博客
11-06 644
了解Linux wait queues/completion 1.Introduction   在Linux内核中，completion信号量是一个轻量级的机制，它允许一个线程告诉另一个线程某个工作已经做完了。线程(进程)之间的同步大多使用completion，而互斥资源的保护大多使用信号量(互斥锁or自旋锁)。completion在内核中的实现基于等待队列。要使用completion，必须在...
linux中同步例子(完成量completion)
wangpengqi的专栏
10-10 949
这是一个公交司机和售票员之间的线程调度，用于理解完成量，完成量是对信号量的一种补充，主要用于多处理器系统上发生的一种微妙竞争 在这里两个线程间同步，只有当售票员把门关了后，司机才能开动车，只有当司机停车后，售票员才能开门。 #include #include #include #include #include MODULE_LICENSE("D
【linux kernel】一文总结linux内核的完成量机制
iriczhao的博客
04-23 3113
文章目录一、completion完成量二、使用方法（2-1）初始化完成量（2-1-1）动态初始化完成量（2-1-2）静态声明和初始化完成量（2-2）等待完成量（2-3）发送信号量完成（2-4） try_wait_for_completion()/completion_done()三、使用实例 一、completion完成量 linux内核中，completion是一种代码同步机制。如果有一个或多个线程必须等待某个内核活动操作达到某个点或某个特定状态，那么completion完成量可以提供一个无竞争的解决方案
Linux内核同步：completion
hong
02-05 706
定义数据结构如下：struct completion { unsigned int done; //指示等待的事件是否完成。初始化时为0。 //如果为0,则表示等待的事件未完成。大于0表示等待的事件已经完成 wait_queue_head_t wait;//存放等待该事件完成的进程队列 };初始化1) init_completion(&c
Linux内核之completion机制
大吉
09-20 1560
Linux内核之completion机制
【内核同步机制】深入理解Linux内核 -- completion机制
诸葛一帆丶的博客
12-17 3541
completion 机制 在linux内核中，引入锁机制主要是解决资源并发与竞争问题； 主要常用锁机制：信号量，自旋锁，互斥锁； 该篇文章主要讲解的是completion信号量。 completion信号量： completion信号量是一个轻量级的机制，它允许一个线程告诉另一个线程某个工作已经做完了； completion 关键结构 completion 结构 struct completion { unsigned int done; struct swait_queue_head wait; }
并发控制中的completion
weixin_43583605的博客
03-20 445
作用： 用于一个执行单元等待另一个执行单元执行完某事,解决某些同步问题,提供一种比信号量更好的同步机制。 1. 定义completion结构体 struct completion my_completion; //定义类型为completion 的结构体my_completion 2.初始化completion init_completion(&my_completion); re...
Linux内核完成量Completion
10-18 800
Linux内核完成量Completion
"基于TCP/IP的Linux文件传输系统设计与开发
This document serves as a valuable resource for individuals interested in understanding the design and development of file transfer systems under the Linux environment, particularly those based on ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值