中断下半部

约定不等于承诺〃 2024-04-20 09:03 59阅读 0赞

原文网址：[中断下半部\_IT利刃出鞘的博客-CSDN博客][IT_-CSDN]

# 其他网址 #

《Linux设备驱动开发详解》=> 10.3.3 底半部机制

# tasklet #

## **简介** ##

执行上下文是软中断， 执行时机通常是顶半部返回的时候。 只需要定义tasklet及其处理函数，并将两者关联。  
tasklet即使用软中断作为基础，然后再实现tasklet。

## **定义和初始化** ##

法一  
DECLARE\_TASKLET(my\_tasklet, my\_tasklet\_func, data);  
定义的tasklet可以用tasklet\_schedule()加入到调度的。  
DECLARE\_TASKLET\_DISABLED(my\_tasklet, my\_tasklet\_func, data);  
定义的tasklet无法用tasklet\_schedule()加入到调度，需要使用tasklet\_enable()使能，才可以被调度运行。  
  
定义名称为my\_tasklet的tasklet， 并将其与my\_tasklet\_func（） 这个函数绑定， 而传入这个函数的参数为data。  
  
法二  
struct tasklet\_struct tl;  
void func(unsigned long)\{\}  
tasklet\_init(&tl, func, NULL);

## **函数原型** ##

\#define DECLARE\_TASKLET(name, func, data) \\  
struct tasklet\_struct name = \{ NULL, 0, ATOMIC\_INIT(0), func, data \}

\#define DECLARE\_TASKLET\_DISABLED(name, func, data) \\  
struct tasklet\_struct name = \{ NULL, 0, ATOMIC\_INIT(1), func, data \}  
  
void tasklet\_init(struct tasklet\_struct \*t,  
void (\*func)(unsigned long), unsigned long data);

## **其他函数** ##

下边函数参数全都是struct tasklet\_struct \*t  
tasklet\_schedule  
将tasklet加入到调度链表里面，tasklet就能得到执行，每调用这个函数一次，tasklet只能执行一次，要再次执行需要重新调用这个函数。

tasklet\_hi\_schedule  
比tasklet\_schedule优先级更高，可以得到更快处理。

tasklet\_hi\_schedule\_first  
和tasklet\_hi\_schedule差不多，只是更安全。

tasklet\_disable  
禁止tasklet，即使tasklet\_schedule已经把tasklet调度链表里，也得不到执行，必须要用tasklet\_enable使能才可以。如果当前tasklet正在运行，tasklet\_disable会等待执行完，然后禁止，返回。

tasklet\_disable\_nosync  
和tasklet\_disable一样，如果当前tasklet在运行，这个函数不会等待完成就先返回，当tasklet完成退出后，再禁止。

tasklet\_enable  
使能tasklet，和tasklet\_disable要成对使用。

tasklet\_kill  
设备关闭和模块卸载的时候，调用来杀死tasklet。如果当前tasklet在运行，会等待完成后，再杀死。

##    **代码示例** ##

/\* 定义tasklet和底半部函数并将它们关联 \*/  
void xxx\_do\_tasklet(unsigned long);  
DECLARE\_TASKLET(xxx\_tasklet, xxx\_do\_tasklet, 0);  
\* 中断处理底半部 \*/  
void xxx\_do\_tasklet(unsigned long)  
\{  
...  
\}

/\* 中断处理顶半部 \*/  
irqreturn\_t xxx\_interrupt(int irq, void \*dev\_id)  
\{  
...  
tasklet\_schedule(&xxx\_tasklet);  
...  
\}

/\* 设备驱动模块加载函数 \*/  
int \_\_init xxx\_init(void)  
\{  
...  
/\* 申请中断 \*/  
result = request\_irq(xxx\_irq, xxx\_interrupt,  
0, "xxx", NULL);  
...  
return IRQ\_HANDLED;  
\}

/\* 设备驱动模块卸载函数 \*/  
void \_\_exit xxx\_exit(void)  
\{  
...  
/\* 释放中断 \*/  
free\_irq(xxx\_irq, xxx\_interrupt);  
\}

# 工作队列 #

## 简介 ##

工作队列的执行上下文是内核线程， 因此可以调度和睡眠。  
定义和初始化

## 创建工作队列 ##

作用：创建进程（“内核线程”）来执行加入到这个workqueue的work。  
返回值：struct work\_queue \*  
函数：  
create\_workqueue(name)  
对于多核CPU，会在每个CPU上创建一个专用线程。  
create\_singlethread\_workqueue(name)  
对于单核或多核，只在其中一个CPU上创建线程。  
示例：  
struct work\_queue \*my\_wq;  
my\_wq = create\_workqueue("test\_wq");

## 定义work ##

法一  
DECLARE\_WORK(n, f) //n:work的名字 f：work对应的函数  
示例：  
void my\_func(struct work\_struct \*work)\{\};  
DECLARE\_WORK(my\_work,func);  
法二  
INIT\_WORK(\_work, \_func)  
示例：  
void my\_func(struct work\_struct \*work)\{\};  
void my\_func1(struct work\_struct \*work)\{\};  
struct work\_struct my\_work;  
INIT\_WORK(&my\_work,my\_func);  
PREPARE\_WORK(&my\_work,my\_func1);

修改绑定的函数后，当下次调度到，my\_func1函数被调度，不再是my\_func

## 将work加入到workqueue ##

bool queue\_work(struct workqueue\_struct \*wq,struct work\_struct \*work);  
bool queue\_delayed\_work(struct workqueue\_struct \*wq,  
struct delayed\_work \*dwork,  
unsigned long delay);  
返回值：  
0: work在这之前，已经在workqueue中了  
非0: 表示work成功加入到workqueue中了

queue\_delayed\_work表示不是马上把work加入到workqueue中，而是延后delay（时间单位jiffies），再加入。 它的work（dwork参数）要用DECLARE\_DELAYED\_WORK或者INIT\_DELAYED\_WORK。

work被调度一次后，就从workqueue中取消了，如果还需要work被调度到（即work中的函数再被调用），需要重新加入到workqueue中，一般可以直接在work绑定的函数，最后一行调用这个两个函数再次加入。

## 取消work ##

本部分函数参数都是struct work\_struct \*  
  
queue\_work对应cancel\_work\_sync  
须确保work所在的workqueue没被销毁，调用这函数的进程会等待这个work执行完成（得不到执行，进程会阻塞等待），再取消这个work。这个函数返回后，work肯定是被执行了。

queue\_delayed\_work对应cancel\_delayed\_work或cancel\_delayed\_work\_sync

cancel\_delayed\_work：返回后，work并不一定被取消，有可能还在运行。  
cancel\_delayed\_work\_sync：返回后，work肯定已经被取消了。等到work被执行后，取消完成才返回。

销毁workqueue

void destroy\_workqueue(struct workqueue\_struct \*wq);  
在销毁前，最好调用flush\_workqueue来确保在这workqueue上的work都处理完了：  
void flush\_workqueue(struct workqueue\_struct \*wq);

总结：工作队列步骤，首先是创建workqueue和定义初始化work，然后将work加入到workqueue中。最后，不要时，销毁workqueue。

## 共享工作队列 ##

共享队列：系统创建了默认的workqueue，只需要定义初始化work，调用接口就完成。

bool schedule\_work(struct work\_struct \*work);  
bool schedule\_delayed\_work(struct delayed\_work \*dwork, unsigned long delay);

示例：

void my\_func(struct work\_struct \*work)\{\}  
struct work\_struct my\_work;  
INIT\_WORK(&my\_work, my\_func);  
schedule\_work(&my\_work);

取消

bool cancel\_work\_sync(struct work\_struct \*work);  
bool cancel\_delayed\_work(struct delayed\_work \*dwork);  
bool cancel\_delayed\_work\_sync(struct delayed\_work \*dwork);

对应版本接口，用对应版本接口取消。取消后，一般需要调用下面接口，确保work完成，并取消了:

void flush\_scheduled\_work(void);  
flush\_scheduled\_work能确保在系统默认创建的workqueue上所有的work都完成了。  
  
代码示例  
/\* 定义工作队列和关联函数 \*/  
struct work\_struct xxx\_wq;  
void xxx\_do\_work(struct work\_struct \*work);  
/\* 中断处理底半部 \*/  
void xxx\_do\_work(struct work\_struct \*work)  
\{  
...  
\}

/\*中断处理顶半部\*/  
irqreturn\_t xxx\_interrupt(int irq, void \*dev\_id)  
\{  
...  
schedule\_work(&xxx\_wq);  
...  
return IRQ\_HANDLED;  
\}

/\* 设备驱动模块加载函数 \*/  
int xxx\_init(void)  
\{  
...  
/\* 申请中断 \*/  
result = request\_irq(xxx\_irq, xxx\_interrupt,  
0, "xxx", NULL);  
...  
/\* 初始化工作队列 \*/  
INIT\_WORK(&xxx\_wq, xxx\_do\_work);  
...  
\}

/\* 设备驱动模块卸载函数 \*/  
void xxx\_exit(void)  
\{  
...  
/\* 释放中断 \*/  
free\_irq(xxx\_irq, xxx\_interrupt);  
...  
\}

[IT_-CSDN]: https://knife.blog.csdn.net/article/details/101065380