[Linux内核驱动]工作队列

工作队列

工作队列的使用方法和tasklet类似，但是工作队列的执行上下文是内核线程，可以调度和睡眠。

使用工作队列构造下面数据表，并通过设备读取

   time   delta  inirq    pid   cpu command
     8890    0     0      3813   1   cat
     8890    0     0       108   0   kworker/u14:4
     8890    0     0       108   0   kworker/u14:4
     8890    0     0       108   0   kworker/u14:4
     8890    0     0       108   0   kworker/u14:4

struct work_struct

struct work_struct 是一个用来描述一个可延迟执行的工作的结构体。
使用 INIT_WORK(_work, _func) 宏可以初始化一个 work_struct 实例并与处理函数绑定。

工作队列API

alloc_workqueue

创建一个新的工作队列并返回一个指向新创建的workqueue_struct结构的指针。

struct workqueue_struct *alloc_workqueue(const char *name, int flags, int max_active,...);

• name:这是一个格式字符串，用于指定工作队列的名称。它可以包含%s、%d等格式化占位符，后跟相应的可变参数（…）。
• flags：用于配置工作队列的标志位。常见的标志包括：
  • WQ_UNBOUND：工作队列中的工作可以在任何CPU上执行，而不是仅限于创建工作队列的CPU。
  • WQ_MEM_RECLAIM：允许工作队列在内存不足时回收内存。
  • WQ_HIGHPRI：创建一个高优先级的工作队列，其中的工作会比其他工作队列中的工作更频繁地运行。
  • WQ_CPU_INTENSIVE：创建一个CPU密集型的工作队列，该队列中的工作会倾向于在相同的CPU上连续运行。
  • WQ_FREEZABLE：允许工作队列在冻结时暂停执行工作。
• max_active：工作队列中可以同时运行的最大工作数。如果设置为0，则没有限制。

queue_work

这个函数用于将一个工作（work_struct）添加到工作队列中。当工作队列的调度器线程（或线程池中的某个线程）变得可用时，它会执行这个工作。这个函数接受一个指向workqueue_struct的指针和一个指向work_struct的指针作为参数。

int queue_work(struct workqueue_struct *wq, struct work_struct *work);

destroy_workqueue()

这个函数用于销毁一个工作队列。在销毁之前，它会确保队列中的所有工作都已完成。这个函数接受一个指向workqueue_struct结构的指针作为参数。

void destroy_workqueue(struct workqueue_struct *wq);

代码

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/sched.h>

#include <linux/workqueue.h>

#define WORK_QUEUE_MAJOR 0
#define WORK_QUEUE_MINOR 0
#define WORK_QUEUE_NR_DEVS 1

static int work_queue_major = WORK_QUEUE_MAJOR;
static int work_queue_minor = WORK_QUEUE_MINOR;
static int work_queue_nr_devs = WORK_QUEUE_NR_DEVS;

struct work_queue_dev
{
  struct cdev cdev;
  struct device* cls_dev;
  wait_queue_head_t wq;

  char* buf;
  int loops;
  unsigned long pre_jiffies;
  struct work_struct work;
  struct workqueue_struct* work_queue;
};

static struct class* class = NULL;
static struct work_queue_dev* work_queue_devp;

static int work_queue_open_func(struct inode* inode, struct file* filp)
{
  struct work_queue_dev* dev = container_of(inode->i_cdev, struct work_queue_dev, cdev);
  filp->private_data = dev;
  return 0;
}

static int work_queue_release_func(struct inode* inode, struct file* filp)
{
  return 0;
}

static void work_queue_handeler(struct work_struct* work)
{
  struct work_queue_dev* dev = container_of(work, struct work_queue_dev, work);
  dev->buf += sprintf(dev->buf,
    "%9li  %3li     %i    %6i   %i   %s\n",
    jiffies, jiffies - dev->pre_jiffies,
    in_interrupt() ? 1 : 0, current->pid,
    smp_processor_id(), current->comm);

  dev->loops--;
  if (dev->loops > 0)
  {
    queue_work(dev->work_queue, work);
    dev->pre_jiffies = jiffies;
  }
  else
    wake_up_interruptible(&dev->wq);
}
static ssize_t work_queue_read_func(struct file* filp, char __user* buf, size_t count, loff_t* f_pos)
{
  int ret = 0;
  char* tmp_buf;
  int cnt;
  struct work_queue_dev* dev = filp->private_data;
  if (*f_pos > 0)
    return 0;

  dev->work_queue = alloc_workqueue("work_queue", WQ_UNBOUND, 0);

  tmp_buf = kzalloc(300, GFP_KERNEL);
  if (!tmp_buf)
    return -ENOMEM;
  dev->loops = 4;
  dev->buf = tmp_buf;
  dev->buf += sprintf(dev->buf, "   time   delta  inirq    pid   cpu command\n");
  dev->buf += sprintf(dev->buf,
    "%9li  %3li     %i    %6i   %i   %s\n",
    jiffies, 0L, in_interrupt() ? 1 : 0,
    current->pid, smp_processor_id(), current->comm);
  dev->pre_jiffies = jiffies;

  INIT_WORK(&dev->work, work_queue_handeler);
  queue_work(dev->work_queue, &dev->work);

  wait_event_interruptible(dev->wq, !dev->loops);
  destroy_workqueue(dev->work_queue);

  cnt = dev->buf - tmp_buf;
  if (copy_to_user(buf, tmp_buf, cnt))
  {
    ret = -EFAULT;
    goto out;
  }

  *f_pos += cnt;
  ret = cnt;
out:
  kfree(tmp_buf);
  return ret;
}

struct file_operations work_queue_fops = {
    .owner = THIS_MODULE,
    .read = work_queue_read_func,
    .open = work_queue_open_func,
    .release = work_queue_release_func,
};

static int __init work_queue_init_module(void)
{
  int ret = 0, i;
  dev_t devno = MKDEV(work_queue_major, work_queue_minor);

  if (work_queue_major)
    ret = register_chrdev_region(devno, work_queue_nr_devs, "work_queue");
  else
  {
    ret = alloc_chrdev_region(&devno, work_queue_minor, work_queue_nr_devs, "work_queue");
    work_queue_major = MAJOR(devno);
  }

  if (ret < 0)
  {
    printk(KERN_ALERT "register_chrdev_region failed with %d\n", ret);
    goto out_1;
  }

  work_queue_devp = kzalloc(sizeof(struct work_queue_dev) * work_queue_nr_devs, GFP_KERNEL);
  if (!work_queue_devp)
  {
    ret = -ENOMEM;
    printk(KERN_ALERT "Out of memory\n");
    goto out_2;
  }

  class = class_create(THIS_MODULE, "work_queue_class");
  if (IS_ERR(class))
  {
    ret = PTR_ERR(class);
    printk(KERN_ALERT "class_create failed with %d\n", ret);
    goto out_3;
  }

  for (i = 0; i < work_queue_nr_devs; i++)
  {
    cdev_init(&work_queue_devp[i].cdev, &work_queue_fops);
    work_queue_devp[i].cdev.owner = THIS_MODULE;
    ret = cdev_add(&work_queue_devp[i].cdev, MKDEV(work_queue_major, work_queue_minor + i), 1);
    if (ret < 0)
      printk(KERN_ALERT "cdev_add failed with %d\n", ret);
    else
    {
      work_queue_devp[i].cls_dev = device_create(class, NULL, MKDEV(work_queue_major, work_queue_minor + i), NULL, "work_queue%d", i);
      if (IS_ERR(work_queue_devp[i].cls_dev))
        printk(KERN_ALERT "device_create failed with %d\n", ret);
    }
    init_waitqueue_head(&work_queue_devp[i].wq);
  }
  return 0;
out_3:
  kfree(work_queue_devp);
out_2:
  unregister_chrdev_region(devno, work_queue_nr_devs);
out_1:
  return ret;
}

static void __exit work_queue_exit_module(void)
{
  int i;
  for (i = 0; i < work_queue_nr_devs; i++)
  {
    device_destroy(class, MKDEV(work_queue_major, work_queue_minor + i));
    cdev_del(&work_queue_devp[i].cdev);
  }
  class_destroy(class);
  kfree(work_queue_devp);
  unregister_chrdev_region(MKDEV(work_queue_major, work_queue_minor), work_queue_nr_devs);
}

module_param(work_queue_major, int, S_IRUGO);
module_param(work_queue_minor, int, S_IRUGO);
module_param(work_queue_nr_devs, int, S_IRUGO);

module_init(work_queue_init_module);
module_exit(work_queue_exit_module);

MODULE_AUTHOR("lidonghang-02");
MODULE_LICENSE("GPL");