Linux中断子系统9

最新推荐文章于 2025-03-17 08:13:51 发布

原创最新推荐文章于 2025-03-17 08:13:51 发布 · 842 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#linux #运维 #服务器

Linux内核子系统专栏收录该内容

199 篇文章

订阅专栏

Linux中断子系统9（基于Linux6.6）---中断之tasklet

一、前情回顾

对于中断处理而言，linux将其分成了两个部分，一个叫做中断handler（top half），属于不那么紧急需要处理的事情被推迟执行，我们称之deferable task，或者叫做bottom half，。具体如何推迟执行分成下面几种情况：

1、推迟到top half执行完毕

2、推迟到某个指定的时间片（例如40ms）之后执行

3、推迟到某个内核线程被调度的时候执行

对于第一种情况，内核中的机制包括sotfirq机制和tasklet机制。第二种情况是属于softirq机制的一种应用场景（timer类型的softirq）。第三种情况主要包括threaded irq handler以及通用的workqueue机制。

中断之tasklet是Linux内核中一种处理中断的机制，主要用于将中断处理分为两部分：一部分是紧急的、需要快速响应的部分，另一部分是不太紧急的、可以稍后处理的部分。tasklet机制允许将不紧急的中断处理工作推迟到系统较为空闲的时候进行，从而提高了系统的响应性和效率。以下是对tasklet的详细概述：

tasklet的定义与特性

定义：tasklet是一种特定类型的软中断，它基于软中断机制实现，但相对于软中断来说更加灵活和易用。tasklet可以看作是一小段可执行的代码，通常以函数的形式出现。
特性：
- 一种特定类型的tasklet只能运行在一个CPU上，不能并行执行，只能串行处理。
- tasklet是在两种软中断类型的基础上实现的，如果不需要软中断的并行执行特性，tasklet是一个很好的选择。
- tasklet的执行效率较高，无需循环查表。
- tasklet可以在运行时动态改变，比如添加模块时。

二、为什么需要tasklet？

linux内核为什么还要引入tasklet机制呢？主要原因是软中断的pending标志位也就32位，一般情况是不随意增加软中断处理的。而且内核也没有提供通用的增加软中断的接口。其次内，软中断处理函数要求可重入，需要考虑到竞争条件比较多，要求比较高的编程技巧。所以内核提供了tasklet这样的一种通用的机制。

tasklet对于softirq而言，带来了几个显著的好处，这些好处主要体现在灵活性、易用性和同步保护等方面。以下是对这些好处的详细解释：

动态分配与注册：
- tasklet可以动态地分配和注册，这意味着开发者可以在运行时根据需要创建和销毁tasklet，而无需在编译时静态地分配它们。
- 相比之下，softirq通常是在编译期间静态分配的，其数量和类型在内核启动时就已经确定，无法在运行时动态改变。
易用性：
- tasklet提供了一种相对简单的编程接口，允许开发者通过定义处理函数和调度tasklet来管理中断处理任务。
- 由于tasklet在底层实现了同步保护（即同一类型的tasklet不会在不同的CPU上并行执行），开发者在编写tasklet处理函数时无需过多考虑并发问题，从而降低了编程复杂度。
同步保护：
- tasklet在设计时考虑了同步保护的需求，确保同一类型的tasklet不会在不同的CPU上并行执行。
- 这种同步保护机制有助于避免竞态条件和资源冲突，提高了系统的稳定性和可靠性。
- 相比之下，softirq虽然也支持并行处理，但开发者在编写softirq处理函数时需要自行考虑重入问题和同步保护。
执行效率：
- tasklet的执行效率通常较高，因为它们是在软中断上下文中运行的，且不需要像进程那样进行复杂的上下文切换。
- 此外，由于tasklet在调度时会被添加到相应的CPU的tasklet链表中，并在适当的时机由软中断处理函数执行，因此它们的执行时机和方式相对可控，有助于优化系统性能。
对SMP系统的支持：
- tasklet机制支持SMP（对称多处理）系统，允许多个CPU并行处理中断任务。
- 在SMP系统上，tasklet被确保在第一个调度它的CPU上运行，以提供更好的高速缓存行为，从而提高性能。

三、tasklet的基本原理

3.1、如何抽象一个tasklet

内核中用下面的数据结构来表示tasklet：include/linux/interrupt.h

struct tasklet_struct
{
	struct tasklet_struct *next;
	unsigned long state;
	atomic_t count;
	bool use_callback;
	union {
		void (*func)(unsigned long data);
		void (*callback)(struct tasklet_struct *t);
	};
	unsigned long data;
};

每个cpu都会维护一个链表，将本cpu需要处理的tasklet管理起来，next这个成员指向了该链表中的下一个tasklet。

func和data成员描述了该tasklet的callback函数，func是调用函数，data是传递给func的参数。

state成员表示该tasklet的状态，TASKLET_STATE_SCHED表示该tasklet以及被调度到某个CPU上执行，TASKLET_STATE_RUN表示该tasklet正在某个cpu上执行。

count成员是和enable或者disable该tasklet的状态相关，如果count等于0那么该tasklet是处于enable的，如果大于0，表示该tasklet是disable的。

在sotfirq中，local_bh_disable/enable函数就是用来disable/enable bottom half的，这里就包括softirq和tasklet。但是，有的时候内核同步的场景不需disable所有的softirq和tasklet，而仅仅是disable该tasklet，这时候，tasklet_disable和tasklet_enable就派上用场了。

include/linux/interrupt.h

 static inline void tasklet_disable(struct tasklet_struct *t)
{
	tasklet_disable_nosync(t);            /* 给tasklet的count加一 */
	tasklet_unlock_wait(t);               /* 如果该tasklet处于running状态，那么需要等到该tasklet执行完毕  */
	smp_mb();
}
 
static inline void tasklet_enable(struct tasklet_struct *t)
{
	smp_mb__before_atomic();
	atomic_dec(&t->count);                /* 给tasklet的count减一 */
}

asklet_disable和tasklet_enable支持嵌套，但是需要成对使用。

2.2、系统如何管理tasklet？

系统中的每个cpu都会维护一个tasklet的链表，定义如下：

kernel/softirq.c

static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec);
static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec);

linux kernel中，和tasklet相关的softirq有两项，HI_SOFTIRQ用于高优先级的tasklet，TASKLET_SOFTIRQ用于普通的tasklet。

对于softirq而言，优先级就是出现在softirq pending register（__softirq_pending）中的先后顺序，位于bit 0拥有最高的优先级，也就是说，如果有多个不同类型的softirq同时触发，那么执行的先后顺序依赖在softirq pending register的位置，kernel总是从右向左依次判断是否置位，如果置位则执行。

2.3、如何定义一个tasklet？

用下面的宏定义来静态定义tasklet：

include/linux/interrupt.h

#define DECLARE_TASKLET(name, _callback)		\
struct tasklet_struct name = {				\
	.count = ATOMIC_INIT(0),			\
	.callback = _callback,				\
	.use_callback = true,				\
}

#define DECLARE_TASKLET_DISABLED(name, _callback)	\
struct tasklet_struct name = {				\
	.count = ATOMIC_INIT(1),			\
	.callback = _callback,				\
	.use_callback = true,				\
}

2.4、如何调度一个tasklet

为了调度一个tasklet执行，使用tasklet_schedule这个接口：

include/linux/interrupt.h

static inline void tasklet_schedule(struct tasklet_struct *t)
{
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_schedule(t);
}

程序在多个上下文中可以多次调度同一个tasklet执行（也可能来自多个cpu core），不过实际上该tasklet只会一次挂入首次调度到的那个cpu的tasklet链表，也就是说，即便是多次调用tasklet_schedule，实际上tasklet只会挂入一个指定CPU的tasklet队列中（而且只会挂入一次），也就是说只会调度一次执行。这是通过TASKLET_STATE_SCHED这个flag来完成的，可以用下面的图来描述：

假设HW block A的驱动使用的tasklet机制并且在中断handler（top half）中将静态定义的tasklet（这个tasklet是各个cpu共享的，不是per cpu的）调度执行（也就是调用tasklet_schedule函数）。

当HW block A检测到硬件的动作（例如接收FIFO中数据达到半满）就会触发IRQ line上的电平或者边缘信号，GIC检测到该信号会将该中断分发给某个CPU执行其top half handler，假设这次是cpu0，因此该driver的tasklet被挂入CPU0对应的tasklet链表（tasklet_vec）并将state的状态设定为TASKLET_STATE_SCHED。HW block A的驱动中的tasklet虽已调度，但是没有执行，如果这时候，硬件又一次触发中断并在cpu1上执行，虽然tasklet_schedule函数被再次调用，但是由于TASKLET_STATE_SCHED已经设定，因此不会将HW block A的驱动中的这个tasklet挂入cpu1的tasklet链表中。

在分析底层的__tasklet_schedule函数：

kernel/softirq.c

void __tasklet_schedule(struct tasklet_struct *t)
{
	__tasklet_schedule_common(t, &tasklet_vec,
				  TASKLET_SOFTIRQ);
}
 
static void __tasklet_schedule_common(struct tasklet_struct *t,
				      struct tasklet_head __percpu *headp,
				      unsigned int softirq_nr)
{
	struct tasklet_head *head;
	unsigned long flags;
 
	local_irq_save(flags);            // 保存IF标志的状态，并禁用本地中断 1
	head = this_cpu_ptr(headp);       // 为该tasklet分配per_cpu变量
	t->next = NULL;                   // 2
	*head->tail = t;
	head->tail = &(t->next);
	raise_softirq_irqoff(softirq_nr); // 触发软中断，让其在下一次do_softirq()的时候，有机会被执行 3
	local_irq_restore(flags);         恢复前面保存的标志
}

（1）下面的链表操作是per-cpu的，因此这里禁止本地中断就可以拦截所有的并发。

（2）这里的三行代码就是将一个tasklet挂入链表的尾部。

（3）raise TASKLET_SOFTIRQ类型的softirq。

2.5、在什么时机会执行tasklet？

上面描述了tasklet的调度，当然调度tasklet不等于执行tasklet，系统会在适合的时间点执行tasklet callback function。由于tasklet是基于softirq的，因此，总结一下softirq的执行场景：

（1）在中断返回用户空间（进程上下文）的时候，如果有pending的softirq，那么将执行该softirq的处理函数。这里限定了中断返回用户空间也就是意味着限制了下面两个场景的softirq被触发执行：

（a）中断返回hard interrupt context，也就是中断嵌套的场景。

（b）中断返回software interrupt context，也就是中断抢占软中断上下文的场景。

（2）上面的描述缺少了一种场景：中断返回内核态的进程上下文的场景，需要详细说明。进程上下文中调用local_bh_enable的时候，如果有pending的softirq，那么将执行该softirq的处理函数。由于内核同步的要求，进程上下文中有可能会调用local_bh_enable/disable来保护临界区。

在临界区代码执行过程中，中断随时会到来，抢占该进程（内核态）的执行（注意：这里只是disable了bottom half，没有禁止中断）。

在这种情况下，中断返回的时候是否会执行softirq handler呢？当然不会，、disable了bottom half的执行，也就是意味着不能执行softirq handler，但是本质上bottom half应该比进程上下文有更高的优先级，一旦条件允许，要立刻抢占进程上下文的执行，因此，当立刻离开临界区，调用local_bh_enable的时候，会检查softirq pending，如果bottom half处于enable的状态，pending的softirq handler会被执行。

（3）系统太繁忙了，不断的产生中断，raise softirq，由于bottom half的优先级高，从而导致进程无法调度执行。这种情况下，softirq会推迟到softirqd这个内核线程中去执行。

对于TASKLET_SOFTIRQ类型的softirq，其handler是tasklet_action，我们来看看各个tasklet是如何执行的：

kernel/softirq.c

static __latent_entropy void tasklet_action(struct softirq_action *a)
{
	tasklet_action_common(a, this_cpu_ptr(&tasklet_vec), TASKLET_SOFTIRQ);    //获取该cpu上的tasklet_vec链表
}

 
static void tasklet_action_common(struct softirq_action *a,
				  struct tasklet_head *tl_head,
				  unsigned int softirq_nr)
{
	struct tasklet_struct *list;
 
	local_irq_disable();            //关本cpu中断  1
	list = tl_head->head;           //取出本cpu的tl的链表头
	tl_head->head = NULL;           // 将当前处理器上的该链表设置为NULL, 达到清空的效果。
	tl_head->tail = &tl_head->head;
	local_irq_enable();
 
    //循环遍历获得链表上的每一个待处理的tasklet
	while (list) {
		struct tasklet_struct *t = list;
 
		list = list->next;
 
		if (tasklet_trylock(t)) {                // ----- 2  判断该tasklet还没被执行
			if (!atomic_read(&t->count)) {       // ----- 3  判断是该tasklet不是可以执行(没disable)
				if (!test_and_clear_bit(TASKLET_STATE_SCHED,   // 检查是不是可以调度(执行)
							&t->state))
					BUG();
				t->func(t->data);        //执行绑定的任务函数
				tasklet_unlock(t);
				continue;                //能处理的链表这里都会处理掉
			}
			tasklet_unlock(t);
		}
 
		local_irq_disable();    //下面执行的是暂时不能执行的链表,把这些链表挂到tl的尾部,下一次再执行
		t->next = NULL;
		*tl_head->tail = t;
		tl_head->tail = &t->next;
		__raise_softirq_irqoff(softirq_nr);    //再次触发softirq，等待下一个执行时机
		local_irq_enable();
	}
}

（1）从本cpu的tasklet链表中取出全部的tasklet，保存在list这个临时变量中，同时重新初始化本cpu的tasklet链表，使该链表为空。由于bottom half是开中断执行的，因此在操作tasklet链表的时候需要使用关中断保护。

（2）tasklet_trylock主要是用来设定该tasklet的state为TASKLET_STATE_RUN，同时判断该tasklet是否已经处于执行状态，这个状态很重要，它决定了后续的代码逻辑。

include/linux/interrupt.h

static inline int tasklet_trylock(struct tasklet_struct *t)
{
	return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
}
 
static inline void tasklet_unlock(struct tasklet_struct *t)
{
	smp_mb__before_atomic();
	clear_bit(TASKLET_STATE_RUN, &(t)->state);
}
 
static inline void tasklet_unlock_wait(struct tasklet_struct *t)
{
	while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
}

在调用tasklet_schedule函数将会使得该driver的tasklet挂入cpu1的tasklet链表中。由于cpu0在处理其他硬件中断，因此，cpu1的tasklet后发先至，进入tasklet_action函数调用，这时候，当从cpu1的tasklet摘取所有需要处理的tasklet链表中，HW block A对应的tasklet实际上已经是在cpu0上处于执行状态了。

在设计tasklet的时候就规定，同一种类型的tasklet只能在一个cpu上执行，因此tasklet_trylock就是起这个作用的。

（3）检查该tasklet是否处于enable状态，如果是，说明该tasklet可以真正进入执行状态了。主要的动作就是清除TASKLET_STATE_SCHED状态，执行tasklet callback function。

（4）如果该tasklet已经在别的cpu上执行了，那么将其挂入该cpu的tasklet链表的尾部，这样，在下一个tasklet执行时机到来的时候，kernel会再次尝试执行该tasklet，在这个时间点，也许其他cpu上的该tasklet已经执行完毕了。通过这样代码逻辑，保证了特定的tasklet只会在一个cpu上执行，不会在多个cpu上并发。

上面几句可以简化为如下：

在遍历执行时，在tasklet_trylock()和tasklet_unlock()这一段函数中，完成的功能是：首先会去检查count值时否为0，前面已经分析过，当值不为0的时候，说明该tasklet被禁止，如果没有被禁止，则执行其注册的函数，首先会检查tasklet_state的标志位是否是TASKLET_STATE_RUN状态，如果是，则表示该任务已经在别的处理器上运行，如果没有运行，则将其状态标志设置为TASKLET_STATE_RUN，这样别的处理器就不会再去执行它了，这就保证了在同一时间里，相同类型的tasklet只能有一个在运行。

最后说一下tasklet是在start_kernel初始化的时候就被初始化为前面看的这个action。

kernel/softirq.c

void __init softirq_init(void)
{
	int cpu;
 
	for_each_possible_cpu(cpu) {
		per_cpu(tasklet_vec, cpu).tail =
			&per_cpu(tasklet_vec, cpu).head;
		per_cpu(tasklet_hi_vec, cpu).tail =
			&per_cpu(tasklet_hi_vec, cpu).head;
	}
 
	open_softirq(TASKLET_SOFTIRQ, tasklet_action);
	open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

四、Tsklet提供的API

4.1、声明一个Tasklet

静态创建
声明一个tasklet，可以使用下面两个宏中的一个：

include/linux/interrupt.h

 #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 }

这两个宏都能根据给定的名字静态的创建一个tasklet_struct结构。当该tasklet被调度后，给定的函数func会被执行，data为其参数。这两个宏的区别在于前者前面一个宏把创建的tasklet的引用计数器设置为0，该tasklet处于激活状态，另一个把引用计数器设置为1，所以该tasklet处于禁止状态。

动态创建
也可以使用一个间接的引用（一个指针）赋给一个动态创建的tasklet_struct结构的方式来初始化一个tasklet_init()函数。

kernel/softirq.c

void tasklet_init(struct tasklet_struct *t,
		  void (*func)(unsigned long), unsigned long data)
{
	t->next = NULL;
	t->state = 0;
	atomic_set(&t->count, 0);
	t->func = func;
	t->use_callback = false;
	t->data = data;
}
EXPORT_SYMBOL(tasklet_init);

4.2、编写tasklet处理函数

因为是软中断实现的，这就意味着不能在tasklet处理函数中使用信号量或者一些阻塞的函数。两个相同的tasklet绝不会同时执行，所以，如果tasklet和其他的tasklet或者是软中断共享了数据，必须进行相应的锁保护。

4.3、调度

只有通过调度才能使tasklet有机会被执行，这就使用上面提到的tasklet_shedule()函数。

include/linux/interrupt.h

static inline void tasklet_schedule(struct tasklet_struct *t)
{
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_schedule(t);
}

4.4、禁止或者激活一个tasklet

include/linux/interrupt.h

static inline void tasklet_disable_nosync(struct tasklet_struct *t)
{
	atomic_inc(&t->count);
	smp_mb__after_atomic();
}

可以用来禁止指定的tasklet,不过它无须再返回前等待tasklet执行完毕，这么做往往不太安全，因为无法估计该tasklet是否仍在执行。

include/linux/interrupt.h

static inline void tasklet_disable(struct tasklet_struct *t)
{
	tasklet_disable_nosync(t);
	tasklet_unlock_wait(t);
	smp_mb();
}

tasklet_disable()函数来禁止某个指定的tasklet,如果该tasklet当前正在执行，这个函数会等到它执行完毕再返回。

include/linux/interrupt.h

static inline void tasklet_enable(struct tasklet_struct *t)
{
	smp_mb__before_atomic();
	atomic_dec(&t->count);
}

tasklet_enable()函数可以激活一个tasklet。

4.5、删除一个tasklet

通过调用tasklet_kill()函数从挂起的队列中去掉一个tasklet。该函数的参数是一个指向某个tasklet的tasklet_struct的指针。这个函数会等待tasklet执行完毕，然后再将它移除。该函数可能会引起休眠，所以要禁止在中断上下文中使用。

kernel/softirq.c

void tasklet_kill(struct tasklet_struct *t)
{
	if (in_interrupt())
		pr_notice("Attempt to kill tasklet from interrupt\n");

	while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		wait_var_event(&t->state, !test_bit(TASKLET_STATE_SCHED, &t->state));

	tasklet_unlock_wait(t);
	tasklet_clear_sched(t);
}
EXPORT_SYMBOL(tasklet_kill);

五、举例

如何使用 Tasklet？

在 Linux 内核中，tasklet 是通过 tasklet_struct 结构体来定义的，可以通过 tasklet_init 来初始化任务，并通过 tasklet_schedule 来调度任务执行。以下是一个简单的例子，演示如何编写和使用 tasklet。

例子：编写自己的 Tasklet 任务

假设我们要实现一个硬件中断处理程序，它通过 tasklet 延迟执行一些处理任务。我们首先需要定义一个 tasklet，然后在中断上下文中调度它。

1. 定义 `tasklet` 任务

#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>

static void my_tasklet_function(unsigned long data)
{
    pr_info("Tasklet executed: data = %lu\n", data);
}

static DECLARE_TASKLET(my_tasklet, my_tasklet_function, 1234);

这里，我们定义了一个 my_tasklet，它的执行函数是 my_tasklet_function，并传递了一个数据（1234）作为参数。在 my_tasklet_function 中，我们只是简单地打印出接收到的数据。

2. 初始化和调度 Tasklet

通常，我们会在某个中断处理函数中调度这个 tasklet：

static irqreturn_t my_irq_handler(int irq, void *dev_id)
{
    pr_info("Interrupt occurred, scheduling tasklet...\n");
    
    // 调度 tasklet
    tasklet_schedule(&my_tasklet);
    
    return IRQ_HANDLED;
}

当硬件中断发生时，my_irq_handler 会被调用，然后 tasklet_schedule 函数会调度 my_tasklet 来执行。注意，这里的任务是异步的，它会在当前中断上下文完成后执行。

3. 模块初始化和清理

接下来，我们需要初始化和清理中断及 tasklet：

static int __init my_module_init(void)
{
    int ret;

    pr_info("Module loaded\n");

    // 假设我们请求一个中断（IRQ 1）
    ret = request_irq(1, my_irq_handler, IRQF_SHARED, "my_irq", NULL);
    if (ret) {
        pr_err("Failed to request IRQ\n");
        return ret;
    }

    return 0;
}

static void __exit my_module_exit(void)
{
    pr_info("Module unloaded\n");

    // 释放中断
    free_irq(1, NULL);
    
    // 清理 tasklet
    tasklet_kill(&my_tasklet);
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Example of using Tasklet in Linux Kernel");