Linux中下半部的工作队列简介及其简单使用

偏执的太偏执、 2022-10-19 05:39 198阅读 0赞

### Linux中下半部的工作队列简介及其简单使用 ###

*  1、简介
 *  2、使用流程
 *   *  1、定义并初始化
     *  2、调度工作队列
 *  3、参考事例如下

# 1、简介 #

工作队列是另外一种下半部执行方式，工作队列在进程上下文执行，工作队列将要推后的工作交给一个内核线程去执行，因为工作队列工作在进程上下文，因此工作队列允许睡眠或重新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列，否则的话就只能选择软中断或 tasklet。

Linux 内核使用 work\_struct 结构体表示一个工作，在内核中的路径 include\\linux\\workqueue.h，内容如下：

struct work_struct { 
    	atomic_long_t data;
    	struct list_head entry;
    	work_func_t func;    /* 工作队列处理函数 */
    #ifdef CONFIG_LOCKDEP
    	struct lockdep_map lockdep_map;
    #endif
    };

这些工作组织成工作队列，工作队列使用 workqueue\_struct 结构体表示，内容如下：

/* * The externally visible workqueue. It relays the issued work items to * the appropriate worker_pool through its pool_workqueues. */
    struct workqueue_struct { 
    	struct list_head	pwqs;		/* WR: all pwqs of this wq */
    	struct list_head	list;		/* PR: list of all workqueues */
    
    	struct mutex		mutex;		/* protects this wq */
    	int			work_color;	/* WQ: current work color */
    	int			flush_color;	/* WQ: current flush color */
    	atomic_t		nr_pwqs_to_flush; /* flush in progress */
    	struct wq_flusher	*first_flusher;	/* WQ: first flusher */
    	struct list_head	flusher_queue;	/* WQ: flush waiters */
    	struct list_head	flusher_overflow; /* WQ: flush overflow list */
    
    	struct list_head	maydays;	/* MD: pwqs requesting rescue */
    	struct worker		*rescuer;	/* I: rescue worker */
    
    	int			nr_drainers;	/* WQ: drain in progress */
    	int			saved_max_active; /* WQ: saved pwq max_active */
    
    	struct workqueue_attrs	*unbound_attrs;	/* WQ: only for unbound wqs */
    	struct pool_workqueue	*dfl_pwq;	/* WQ: only for unbound wqs */
    
    #ifdef CONFIG_SYSFS
    	struct wq_device	*wq_dev;	/* I: for sysfs interface */
    #endif
    #ifdef CONFIG_LOCKDEP
    	struct lockdep_map	lockdep_map;
    #endif
    	char			name[WQ_NAME_LEN]; /* I: workqueue name */
    
    	/* * Destruction of workqueue_struct is sched-RCU protected to allow * walking the workqueues list without grabbing wq_pool_mutex. * This is used to dump all workqueues from sysrq. */
    	struct rcu_head		rcu;
    
    	/* hot fields used during command issue, aligned to cacheline */
    	unsigned int		flags ____cacheline_aligned; /* WQ: WQ_* flags */
    	struct pool_workqueue __percpu *cpu_pwqs; /* I: per-cpu pwqs */
    	struct pool_workqueue __rcu *numa_pwq_tbl[]; /* FR: unbound pwqs indexed by node */
    };

Linux 内核使用工作者线程(worker thread)来处理工作队列中的各个工作， Linux 内核使用worker 结构体表示工作者线程， worker 结构体内容如下：

struct worker { 
    	/* on idle list while idle, on busy hash table while busy */
    	union { 
    		struct list_head	entry;	/* L: while idle */
    		struct hlist_node	hentry;	/* L: while busy */
    	};
    
    	struct work_struct	*current_work;	/* L: work being processed */
    	work_func_t		current_func;	/* L: current_work's fn */
    	struct pool_workqueue	*current_pwq; /* L: current_work's pwq */
    	bool			desc_valid;	/* ->desc is valid */
    	struct list_head	scheduled;	/* L: scheduled works */
    
    	/* 64 bytes boundary on 64bit, 32 on 32bit */
    
    	struct task_struct	*task;		/* I: worker task */
    	struct worker_pool	*pool;		/* I: the associated pool */
    						/* L: for rescuers */
    	struct list_head	node;		/* A: anchored at pool->workers */
    						/* A: runs through worker->node */
    
    	unsigned long		last_active;	/* L: last active timestamp */
    	unsigned int		flags;		/* X: flags */
    	int			id;		/* I: worker id */
    
    	/* * Opaque string set with work_set_desc(). Printed out with task * dump for debugging - WARN, BUG, panic or sysrq. */
    	char			desc[WORKER_DESC_LEN];
    
    	/* used only by rescuers to point to the target workqueue */
    	struct workqueue_struct	*rescue_wq;	/* I: the workqueue to rescue */
    };

从上面两个结构体可以看出每个 worker 都有一个工作队列，工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中，我们只需要定义工作(work\_struct)即可，关于工作队列和工作者线程我们基本不用去管。

# 2、使用流程 #

## 1、定义并初始化 ##

简单创建工作很简单，直接定义一个 work\_struct 结构体变量即可，然后使用 INIT\_WORK 宏来初始化工作， INIT\_WORK 宏定义如下：

#define INIT_WORK(_work, _func) \ __INIT_WORK((_work), (_func), 0)

参数含义如下：  
**\_work** ：表示要初始化的工作  
**\_func** ：工作对应的处理函数。

也可以使用 DECLARE\_WORK 宏一次性完成工作的创建和初始化，宏定义如下：

#define DECLARE_WORK(n, f) \ struct work_struct n = __WORK_INITIALIZER(n, f)

参数含义如下：  
**n** ：表示定义的工作(work\_struct)  
**f** ：表示工作对应的处理函数。

## 2、调度工作队列 ##

和 tasklet 一样，工作也是需要调度才能运行的，工作的调度函数为 schedule\_work，函数原  
型如下所示：

bool schedule_work(struct work_struct *work)

函数参数和返回值含义如下：  
**work**： 要调度的工作。  
**返回值**： 0 成功，其他值 失败。

# 3、参考事例如下 #

/* 定义工作(work) */
    struct work_struct testwork;
    /* work 处理函数 */
    void testwork_func_t(struct work_struct *work);
    { 
    	/* work 具体处理内容 */
    }
    /* 中断处理函数 */
    irqreturn_t test_handler(int irq, void *dev_id)
    { 
    	......
    	/* 调度 work */
    	schedule_work(&testwork);
    ......
    }
    /* 驱动入口函数 */
    static int __init xxxx_init(void)
    { 
    	......
    	/* 初始化 work */
    	INIT_WORK(&testwork, testwork_func_t);
    	/* 注册中断处理函数 */
    	request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
    	......
    }