148 kthread_worker：怎么把内核线程当工人？

一、前言

可以通过此结构体让内核为我们创建一个线程，在线程里面完成一件事情

驱动传输数据的两种方式

1、同步传输

低速数据：驱动同步传输
优点：简单直接
缺点：传输效率低，同步传输会造成当前线程阻塞，影响用户空间应用程序执行的效率

2、异步传输

高速数据：驱动交给内核来异步传输
优点：无阻塞
缺点：机制复杂、内核里面的相关代码很多

二、kthread_worker结构体

include/linux/kthread.h

把内核线程抽象为流水线工人，按序处理其他线程/进程交付的批量工作
内核里面的流水线工人可能有多个

struct kthread_worker {
	unsigned int		flags;
	// 自旋锁
	spinlock_t		lock;
	// 不需要延时的工作串联,即串联下面的kthread_work结构体
	struct list_head	work_list;
	// 需要延时完成的工作串联
	struct list_head	delayed_work_list;
	// 表示一个具体的进程或者线程
	struct task_struct	*task;
	// 指向正在处理的某一个具体的工作，详见下
	struct kthread_work	*current_work;
};

三、kthread_work结构体

include/linux/kthread.h

表示等待内核线程处理的具体工作

struct kthread_work {
	// 此链表节点将串联在kthread_worker->work_list
	struct list_head	node;
	// 为每一个具体工作指定一个具体的函数，真正负责完成具体的工作，自定义
	kthread_work_func_t	func;
	// 这个具体工作属于哪个工人，内核里面可能有多个工人，指向上面node成员指向的kthread_worker
	struct kthread_worker	*worker;
	/* Number of canceling calls that are running at the moment. */
	int			canceling;
};

• node：链表节点
• func：函数指针
• worker：处理该工作的内核线程工人

kthread_work_func_t 数据类型定义

typedef void (*kthread_work_func_t)(struct kthread_work *work);

四、kthread_flush_work 结构体

kernel/kthread.c

用于等待某个内核线程工人处理完所有工作

struct kthread_flush_work {
	struct kthread_work	work;
	struct completion	done;
};

• work：具体内核线程工作
• done：完成量，等待所有工作处理完毕

五、如何使用上面的数据结构

1、初始化 kthread_worker结构体

init_kthread_worker 函数

先定义，后初始化

// 定义一个工人
struct kthread_worker hi_worker;
// 初始化一个工人
init_kthread_worker(&hi_worker); 

2、为kthread_worker创建内核线程

先定义，后初始化

struct task_struct *kworker_task;
// kworker_task 要被hi_worker中的task成员所指向
kworker_task = kthread_run(kthread_worker_fn, &hi_worker, "nvme%d", 1);

• kthread_worker_fn：内核线程一直运行的函数，具体的工作就在这个函数指针里面完成。这是内核提供给我们的
• hi_worker：已初始化的kthread_worker结构体变量
• “nvme%d”：为内核线程设置名字

3、初始化kthread_work

先定义，后初始化

// 定义一个具体的工作变量
struct kthread_work hi_work;
// 为此工作变量指定一个具体的工作函数
init_kthread_work(&hi_work, xxx_work_fn); 

• xxx_work_fn：处理该工作的具体函数，自定义实现，负责完成具体的工作

4、启动工作

交付工作给内核线程工人

// hi_worker：具体内核线程工人，struct kthread_worker
// hi_work：具体工作，struct kthread_work
kthread_queue_work(&hi_worker, &hi_work);

注意工人手里可能有多个具体工作

5、FLUSH工作队列

刷新指定 kthread_worker上所有 work

// 等待此流水线工个人手里的工作完成
kthread_flush_worker(&hi_worker);

• hi_worker：具体内核线程工人

6、停止内核线程

停止创建的内核线程

// struct task_struct 指针
kthread_stop(kworker_task);

六、例程

1、驱动源文件

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/of.h>
#include<linux/of_address.h>
#include<linux/of_irq.h>
#include<linux/gpio.h>
#include<linux/of_gpio.h>
#include<linux/atomic.h>
#include<linux/timer.h>
#include<linux/jiffies.h>
#include<linux/interrupt.h>
#include<linux/completion.h>
#include<linux/ide.h>
#include<linux/kthread.h>
#include<linux/sched.h>

#define DTSLED_NAME "dtsled"
#define LED_OFF 0
#define LED_ON 1

// 定义一组全局变量，用于存放内存映射得到的虚拟地址
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

// 148：定义相关的变量
struct kthread_worker hi_worker;
struct kthread_work hi_work;
struct task_struct *kworker_task;

static unsigned int write_data;

extern struct dtsled_dev dtsled;

static void led_switch(u8 state)
{
    u32 val = 0;
    if(state == LED_ON)
    {
        val = readl(GPIO1_DR);
        val &= (~(1<<3));
        writel(val, GPIO1_DR);
    }
    else if(state == LED_OFF)
    {
        val = readl(GPIO1_DR);
        val |= (1<<3);
        writel(val, GPIO1_DR);
    }
}

// 148 需要让内核线程执行的函数
// 每一次控制led的工作留给内核线程
void led_control(struct kthread_work *work)
{
    u32 a=0, b=0, c=0;
	printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
	if (write_data)
	{
		led_switch(LED_ON);
	}
	else
	{
		led_switch(LED_OFF);
	}
    printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
	return;
}

static int dtsled_open(struct inode *inode, struct file *filp)
{
    int ret;

    if(filp->f_flags & O_NONBLOCK)
    {
        ;
    }
    else
    {
        ;
    }
    
	// struct file 结构体定义在 include/linux/fs.h 中
	// struct file 有一个成员（空指针）：void *private_data
    filp->private_data = &dtsled;
    // 148：创建一个内核线程
    kworker_task =kthread_run(kthread_worker_fn, &hi_worker, "nvme%d", 1);
    return 0;
}

static int dtsled_release(struct inode *inode, struct file *filp)
{
    //struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
    return 0;
}

static ssize_t dtsled_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
    int ret;
    u8 databuf[32] = {0};
    //struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
    printk("%s(%d):buf=(%s), count=%d\n", __FILE__, __LINE__, buf, count);
    ret = copy_from_user(databuf, buf, count);
    printk("%s(%d):databuf=(%s)\n", __FILE__, __LINE__, databuf);
    if(ret < 0)
    {
        printk("%s(%d):Kernel write failed.\r\n", __FILE__, __LINE__);
        return -1;
    }
	// s是输入字符串,base可以是10(10进制)或16(16进制),或者是0自动识别,res存放转换后的整形值
	// kstrtox.c
    ret = kstrtoint(databuf, 16, &write_data);
    printk("%s(%d):write_data=%d\n", __FILE__, __LINE__, write_data);
    // 为工作变量指定一个具体的工作函数
    init_kthread_work(&hi_work, led_control);
    printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
    // 将此工作变量交付给工人
    queue_kthread_work(&hi_worker, &hi_work);
    printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
    return count;
}



// 操作集结构体，是 struct cdev 的成员
static const struct file_operations dtsled_fops =
{
    .owner = THIS_MODULE,
    .write = dtsled_write,
    .open = dtsled_open,
    .release = dtsled_release,
};

// 自定义结构体类型来描述 LED
struct dtsled_dev
{
   dev_t devid;
   struct cdev cdev; // 用于注册字符设备，操作集结构体是其成员变量
   struct file_operations dtsled_fops; // 操作集结构体
   struct class *class; // 用于自动创建设备节点
   struct device *device; // 用于自动创建设备节点
   u32 major;
   u32 minor;
   struct device_node *nd; // 设备树结点，用来表示 LED 设备节点
};

// 自定结构体来描述 LED 
struct dtsled_dev dtsled;

// 驱动入口函数
static int __init dtsled_init(void)
{
    int ret = 0;
    int val = 0;
    const char *str;
    u32 regdata[10];
    u8 i;

    // 1、使用新方法来获取设备号
    dtsled.major = 0;
    if(dtsled.major)
    {
        dtsled.devid = MKDEV(dtsled.major, 0);
        ret = register_chrdev_region(dtsled.devid, 1, DTSLED_NAME);
    }
    else
    {
        ret = alloc_chrdev_region(&dtsled.devid, 0, 1, DTSLED_NAME);
        dtsled.major = MAJOR(dtsled.devid);
        dtsled.minor = MINOR(dtsled.devid);
    }
    if(ret < 0)
    {
        printk("%d:Register char dev error.\r\n", __LINE__);
        goto fail_devid;
    }
    
    // 2、添加（注册）字符设备
    dtsled.cdev.owner = THIS_MODULE;
    // zhu yi liang ge qu di zhi fu !
    cdev_init(&dtsled.cdev, &dtsled_fops);
    ret = cdev_add(&dtsled.cdev, dtsled.devid, 1);
    if(ret < 0)
    {
        goto fail_cdev;
    }
    
    // 3、自动创建设备节点，需要一个 struct class，一个 struct device
    dtsled.class = class_create(THIS_MODULE, DTSLED_NAME);
    if(IS_ERR(dtsled.class))
    {
        ret = PTR_ERR(dtsled.class);
        goto fail_class;
    }
    
    //  第一个 NULL 表示副设备,  第二个 NULL 表示 drvdata
    dtsled.device = device_create(dtsled.class, NULL, dtsled.devid, NULL, DTSLED_NAME);
    if(IS_ERR(dtsled.device))
    {
        ret = PTR_ERR(dtsled.device);
        goto fail_device;
    }
    
    // 4、设备树相关，读取属性值
    dtsled.nd = of_find_node_by_path("/alpha_led");
    if(dtsled.nd == NULL)
    {
        goto fail_findnd;
    }
    // 获取状态属性，注意是指针的指针
    ret = of_property_read_string(dtsled.nd, "status", &str);
    if(ret)
    {
        printk("%d:fail\r\n", __LINE__);
        goto fail_rs;
    }
    else
    {
        printk("%d:status = \"%s\"\r\n", __LINE__, str);
    }
    //huoqu shuxing
    ret = of_property_read_string(dtsled.nd, "compatible", &str);
    if(ret)
    {
        printk("%d:fail\r\n", __LINE__);
        goto fail_rs;
    }
    else
    {
        printk("%d:compatible = \"%s\"\r\n", __LINE__, str);
    }
    // 获取 reg 属性, 也就是获取 u32 类型属性值的方法
    ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);
    if(ret < 0)
    {
        printk("%d:fail\r\n", __LINE__);
        goto fail_rs;
    }
    else
    {
        printk("< reg > = < ");
        for(i=0; i<10; i++)
        {
            printk("%#X ", regdata[i]);
        }
        printk(">\r\n");
    }

    // 5、初始化 LED
    IMX6U_CCM_CCGR1 = of_iomap(dtsled.nd, 0);
    SW_MUX_GPIO1_IO03 = of_iomap(dtsled.nd, 1);
    SW_PAD_GPIO1_IO03 = of_iomap(dtsled.nd, 2);
    GPIO1_DR = of_iomap(dtsled.nd, 3);
    GPIO1_GDIR = of_iomap(dtsled.nd, 4);

    // 初始化 LED 相关寄存器
    val = readl(IMX6U_CCM_CCGR1);
    val &= (~(3<<26));
    val |= (3<<26);
    writel(val, IMX6U_CCM_CCGR1);
   
    writel(0X5, SW_MUX_GPIO1_IO03);//io mux
    writel(0X10B0, SW_PAD_GPIO1_IO03); // set electrical properity
   
    val = readl(GPIO1_GDIR); // set bit3, out
    val |= (1<<3); 
    writel(val, GPIO1_GDIR);

    val = readl(GPIO1_DR);
    val &= (~(1<<3));//turn on led 
    writel(val, GPIO1_DR);

    // 初始化一个流水线工人
    init_kthread_worker(&hi_worker); 

    return 0;

fail_rs:
fail_findnd:
    device_destroy(dtsled.class, dtsled.devid);
fail_device:
    class_destroy(dtsled.class);
fail_class:
    cdev_del(&dtsled.cdev);
fail_cdev:
    unregister_chrdev_region(dtsled.devid, 1);
fail_devid:
    return ret;
}

// 出口函数
static void __exit dtsled_exit(void)
{
    unsigned int val = 0;
    printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
    flush_kthread_worker(&hi_worker);
    kthread_stop(kworker_task);
    val = readl(GPIO1_DR);
    val |= (1<<3); // turn off led
    writel(val, GPIO1_DR);
    // 取消地址映射
    iounmap(IMX6U_CCM_CCGR1);
    iounmap(SW_MUX_GPIO1_IO03);
    iounmap(SW_PAD_GPIO1_IO03);
    iounmap(GPIO1_DR);
    iounmap(GPIO1_GDIR);

    // 删除字符设备
    cdev_del(&dtsled.cdev);
    // 释放设备号
    unregister_chrdev_region(dtsled.devid, 1);
    // 删除设备
    device_destroy(dtsled.class, dtsled.devid);
    // 删除类
    class_destroy(dtsled.class);
}

// 注册出口函数和入口函数
module_init(dtsled_init);
module_exit(dtsled_exit);
MODULE_LICENSE("GPL");

2、现象

/ # cd lib/modules/4.1.15/
/lib/modules/4.1.15 # 
/lib/modules/4.1.15 # 
/lib/modules/4.1.15 # 
/lib/modules/4.1.15 # modprobe test.ko 
229:status = "okay"
240:compatible = "alientek, alphaled"
< reg > = < 0X20C406C 0X4 0X20E0068 0X4 0X20E02F4 0X4 0X209C000 0X4 0X209C004 0X4 >
/lib/modules/4.1.15 # 
/lib/modules/4.1.15 # echo 0 > /dev/dtsled 
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(112):buf=(0
]), count=2
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(114):databuf=(0
)
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(123):write_data=0
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(126):dtsled_write
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(67):led_control
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(129):dtsled_write
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(76):led_control
/lib/modules/4.1.15 # 
/lib/modules/4.1.15 # rmmod test.ko 
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(305):dtsled_exit

注意驱动文件中的write函数在，将具体的工作变量kthread_work交付给kthread_worker执行后，二者是并行的。
即write函数在交付后继续向下执行，而另起一个内核线程来执行具体的工作函数。

若内核线程阻塞，那么再卸载内核模块时，出口函数中flush_kthread_worker也会阻塞等待内核线程完成。