文章目录
- 1. 前言
- 2. softirq 实现
- 2.1 softirq 初始化
- 2.1.1 注册各类 softirq 处理接口
- 2.1.2 创建 softirq 处理线程
- 2.2 softirq 的 触发 和 处理
- 2.1.1 softirq 触发
- 2.1.2 softirq 处理
- 2.1.2.1 在 中断上下文 处理 softirq
- 2.1.2.2 在 ksoftirqd 内核线程上下文 处理 softirq
- 3. softirq 之 tasklet
- 3.1 定义初始化 tasklet
- 3.2 使能调度 tasklet
- 3.3 执行 tasklet
- 4. softirq 同步
- 5. softirq 观测
- 6. softirq 的未来
1. 前言
2. softirq 实现
2.1 softirq 初始化
2.1.1 注册各类 softirq 处理接口
start_kernel() /* init/main.c */
...
sched_init(); /* kernel/sched/core.c */
...
init_sched_fair_class(); /* kernel/sched/fair.c */
#ifdef CONFIG_SMP
open_softirq(SCHED_SOFTIRQ, run_rebalance_domains); /* 调度均衡处理 软中断 */
...
#endif
...
...
/* 注册 RCU 软中断 处理接口 */
rcu_init(); /* kernel/rcu/tree.c */
...
open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
...
...
/*
* 所有 CPU 的 软件 timer 管理数据初始化,
* 以及 软件 timer 软中断处理接口注册.
*/
init_timers(); /* kernel/time/timer.c */
init_timer_cpus();
/* 注册软件 timer 处理接口: 在 softirq 中处理 每个 CPU 上的 软件 timer */
open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
...
/* tasklet 软中断 初始化 */
softirq_init(); /* kernel/softirq.c */
int cpu;
/* 初始每 CPU 的 tasklet, tasklet hi 队列为空 */
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;
}
/* 注册 taslet(TASKLET_SOFTIRQ), tasklet hi(HI_SOFTIRQ) 软中断 处理接口 */
open_softirq(TASKLET_SOFTIRQ, tasklet_action);
open_softirq(HI_SOFTIRQ, tasklet_hi_action);
start_kernel()
...
rest_init();
/* 在 BOOT CPU 上启动初始化线程, 处理剩下的初始化工作 */
pid = kernel_thread(kernel_init, NULL, CLONE_FS);
/* 初始化线程入口 */
kernel_init()
kernel_init_freeable();
do_basic_setup();
do_initcalls();
do_initcall_level(level);
do_one_initcall(*fn);
/*
* block/blk-softirq.c, blk_softirq_init()
* lib/irq_poll.c, irq_poll_setup()
* net/core/dev.c, net_dev_init()
*/
fn()
blk_softirq_init() /* block/blk-softirq.c */
...
open_softirq(BLOCK_SOFTIRQ, blk_done_softirq);
...
irq_poll_setup() /* lib/irq_poll.c */
...
open_softirq(IRQ_POLL_SOFTIRQ, irq_poll_softirq);
...
net_dev_init() /* net/core/dev.c */
...
/* 注册 网络设备 收、发 软中断 处理接口 */
open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);
...
从上面的代码分析中,我们看到了如下列表中、各类型软中断处理接口的注册:
/* include/linux/interrupt.h */
enum
{
HI_SOFTIRQ=0,
TIMER_SOFTIRQ,
NET_TX_SOFTIRQ,
NET_RX_SOFTIRQ,
BLOCK_SOFTIRQ,
IRQ_POLL_SOFTIRQ,
TASKLET_SOFTIRQ,
SCHED_SOFTIRQ,
HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the
numbering. Sigh! */
RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */
NR_SOFTIRQS
};
注册软中端处理接口的函数 open_softirq()
实现如下:
/* kernel/softirq.c */
static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;
void open_softirq(int nr, void (*action)(struct softirq_action *))
{
softirq_vec[nr].action = action;
}
2.1.2 创建 softirq 处理线程
open_softirq()
注册的各类软中断处理接口,可能运行于两种上下文:
1. 中断上下文,软中断处理接口在中断处理过程退出时被 irq_exit() 调用。
2. 每 CPU 的软中断线程 ksoftirqd 上下文。
本小节描述软中断接口运行的第2种上下文
建立的过程,即 每 CPU 的软中断线程 ksoftirqd
的建立过程。ksoftirqd
的建立,是在内核初始化线程
中完成:
kernel_init()
kernel_init_freeable();
do_pre_smp_initcalls();
for (fn = __initcall_start; fn < __initcall0_start; fn++)
do_one_initcall(*fn);
/* 调用 early_initcall(spawn_ksoftirqd); */
spawn_ksoftirqd() /* kernel/softirq.c */
static struct smp_hotplug_thread softirq_threads = {
.store = &ksoftirqd,
.thread_should_run = ksoftirqd_should_run,
.thread_fn = run_ksoftirqd,
.thread_comm = "ksoftirqd/%u",
};
static __init int spawn_ksoftirqd(void)
{
...
/* 注册每 CPU 软中断线程 ksoftirqd */
BUG_ON(smpboot_register_percpu_thread(&softirq_threads));
return 0;
}
上面的代码,为每个 CPU
创建了一个名为 ksoftirqd
的内核线程,内核线程的入口函数为 run_ksoftirqd()
。我们可以用 ps
命令观察到它们:
# ps -ef | grep ksoftirqd
10 root [ksoftirqd/0]
16 root [ksoftirqd/1]
21 root [ksoftirqd/2]
26 root [ksoftirqd/3]
我们看到,在这个带 4 核
CPU 的硬件上,Linux 内核创建了 4 个 ksoftirqd
内核线程。
2.2 softirq 的 触发 和 处理
2.1.1 softirq 触发
Linux 系统提供下列接口 抛出 或 生成 softirq
:
/* include/linux/interrupt.h */
extern void raise_softirq_irqoff(unsigned int nr);
extern void raise_softirq(unsigned int nr);
extern void __raise_softirq_irqoff(unsigned int nr);
来看下它们的实现:
/* kernel/softirq.c */
#ifndef __ARCH_IRQ_STAT
irq_cpustat_t irq_stat[NR_CPUS] ____cacheline_aligned; /* 每 CPU 的 softirq 挂起状态 */
EXPORT_SYMBOL(irq_stat);
#endif
void raise_softirq(unsigned int nr)
{
unsigned long flags;
/* ARMv7: 读取 CPSR 寄存器的值到 @flags, 同时关闭 CPU IRQ 中断 */
local_irq_save(flags);
raise_softirq_irqoff(nr);
/* ARMv7: CPSR = flags */
local_irq_restore(flags);
}
/*
* This function must run with irqs disabled!
*/
inline void raise_softirq_irqoff(unsigned int nr)
{
__raise_softirq_irqoff(nr);
/*
* If we're in an interrupt or softirq, we're done
* (this also catches softirq-disabled code). We will
* actually run the softirq once we return from
* the irq or softirq.
*
* Otherwise we wake up ksoftirqd to make sure we
* schedule the softirq soon.
*/
if (!in_interrupt())
wakeup_softirqd(); /* 唤醒 当前 CPU 的 ksoftirq 线程, 处理 softirq */
}
void __raise_softirq_irqoff(unsigned int nr)
{
trace_softirq_raise(nr);
or_softirq_pending(1UL << nr); /* 标记 [当前 CPU] 有挂起的、@x 类型的 softirq */
}
/* include/linux/interrupt.h */
#ifndef __ARCH_SET_SOFTIRQ_PENDING
#define set_softirq_pending(x) (local_softirq_pending() = (x))
#define or_softirq_pending(x) (local_softirq_pending() |= (x))
#endif
/* include/linux/irq_cpustat.h */
#ifndef __ARCH_IRQ_STAT
extern irq_cpustat_t irq_stat[]; /* defined in asm/hardirq.h */
#define __IRQ_STAT(cpu, member) (irq_stat[cpu].member)
#endif
#define local_softirq_pending() \
__IRQ_STAT(smp_processor_id(), __softirq_pending)
2.1.2 softirq 处理
/* arch/arm/kernel/entry-armv.S */
/*
* 中断向量表。
* 这里是第1级,每项是各模式下第2级向量表的指针,
* 即中断向量表是按 vector[8][16] 的形式组织。
* 第1级是各中断类型的入口: reset, undef, swi, ...
* 第2级是各中断类型下,各CPU模式的入口: usr, svc, irq, fiq, ...
*/
.section .vectors, "ax", %progbits
.L__vectors_start:
W(b) vector_rst /* 复位 */
W(b) vector_und /* 未定义指令异常向量表指针: vector_stub und, UND_MODE */
...
/* IRQ 中断 各 CPU 模式处理接口 组成 */
W(b) vector_irq /* IRQ: vector_stub irq, IRQ_MODE, 4 */
...
/*
* Interrupt dispatcher
*/
/* IRQ 中断 各 CPU 模式处理接口 组成 */
vector_stub irq, IRQ_MODE, 4 /* vector_irq */
// CPU User 模式 IRQ 中断处理入口
.long __irq_usr @ 0 (USR_26 / USR_32)
.long __irq_invalid @ 1 (FIQ_26 / FIQ_32)
.long __irq_invalid @ 2 (IRQ_26 / IRQ_32)
// CPU SVC 模式 IRQ 中断处理入口
.long __irq_svc @ 3 (SVC_26 / SVC_32)
......
.align 5
__irq_svc: // CPU SVC 模式 IRQ 中断处理入口 (中断发生在 内核态)
...
irq_handler
...
.align 5
__irq_usr: // CPU User 模式 IRQ 中断处理入口 (中断发生在 用户态)
...
irq_handler
...
我们看到,不管是内核态,还是用户态,中断处理都调用 irq_handler
,看它的定义:
/*
* Interrupt handling.
*/
.macro irq_handler
#ifdef CONFIG_MULTI_IRQ_HANDLER
ldr r1, =handle_arch_irq /* r1 = gic_handle_irq() */
mov r0, sp
badr lr, 9997f
ldr pc, [r1]
#else
...
#endif
9997:
.endm
irq_handler
是个汇编宏,它调用了 ARM GIC
芯片的中断处理接口 gic_handle_irq()
,这个接口是在初始化 GIC 中断芯片时注册的。gic_handle_irq()
在其处理中断即将退出前,处理 softirq
:
gic_handle_irq(regs) /* drivers/irqchip/irq-gic.c */
/* 处理 SPI, PPI */
if (likely(irqnr > 15 && irqnr < 1020)) { /* 处理 PPI, SPI */
handle_domain_irq(gic->domain, irqnr, regs); /* include/linux/irqdesc.h */
__handle_domain_irq(domain, hwirq, true, regs);
__handle_domain_irq(domain, hwirq, true, regs); /* kernel/irq/irqdesc.c */
irq_enter();
// 处理中断:这里不关心中断处理的细节
...
irq_exit(); /* 软中断, RCU 等等处理 */
set_irq_regs(old_regs);
return ret;
...
}
if (irqnr < 16) { /* 处理 SGI */
...
#ifdef CONFIG_SMP
...
handle_IPI(irqnr, regs); /* arch/arm/kernel/smp.c */
// 除了用来唤醒 CPU 的 IPI_WAKEUP 中断外,都会有 irq_enter() + irq_exit()。
// 至于要被唤醒的 CPU ,都还在睡大觉,就别指望它来处理 softirq 了。
irq_enter();
// 处理 IPI 中断
...
irq_exit();
...
#endif
...
}
先看下 irq_enter()
,因为它会更新一个和 sotfirq
处理相关的计数:
irq_enter() /* kernel/softirq.c */
...
__irq_enter(); /* include/linux/hardirq.h */
...
/* HARDIRQ_OFFSET 计数加 1 */
preempt_count_add(HARDIRQ_OFFSET); /* include/linux/preempt.h */
__preempt_count_add(HARDIRQ_OFFSET) /* include/asm-generic/preempt.h */
//*preempt_count_ptr() += HARDIRQ_OFFSET;
¤t_thread_info()->preempt_count += HARDIRQ_OFFSET;
...
这里的 current_thread_info()->preempt_count
有必要再展开下:
/* arch/arm/include/asm/thread_info.h */
struct thread_info {
...
/*
* 以下类型的计数, 分别占用 @preempt_count 不同 bits:
* PREEMPT_OFFSET, SOFTIRQ_OFFSET, SOFTIRQ_OFFSET, NMI_OFFSET
*/
int preempt_count; /* 0 => preemptable, <0 => bug */
...
/* thread_info 所属的 进程(对象) */
struct task_struct *task; /* main task structure */
...
};
...
/*
* how to get the current stack pointer in C
*/
register unsigned long current_stack_pointer asm ("sp");
/*
* how to get the thread information struct from C
*/
static inline struct thread_info *current_thread_info(void) __attribute_const__;
static inline struct thread_info *current_thread_info(void)
{
/* current_stack_pointer: SP 寄存器的值 */
return (struct thread_info *)
(current_stack_pointer & ~(THREAD_SIZE - 1));
}
看到了吧,preempt_count_add(HARDIRQ_OFFSET)
修改的计数值,是当前 CPU 上被 IRQ 中断进程的 struct thread_info
的 preempt_count
成员变量。后面的讨论和这个计数变量密切相关,我们需要提前了解它的来源。
前面讲到,softirq
会在 中断上下文
或 ksoftirqd 内核线程上下文
被处理,先来看在 中断上下文 处理 softirq
的细节。
2.1.2.1 在 中断上下文 处理 softirq
irq_exit()
...
/* 这里减去 irq_enter() 增加的 HARDIRQ_OFFSET 计数,将 HARDIRQ_OFFSET 计数 归 0 */
preempt_count_sub(HARDIRQ_OFFSET);
...
if (!in_interrupt() && local_softirq_pending())
invoke_softirq(); /* 处理当前 CPU 挂起待处理 softirq 事件 */
/*
* 如果 ksoftirqd 当前正在运行状态, 并且没有要求同步处理的
* tasklet, tasklet hi softirq 事件, 则将挂起的 softirq 交给
* ksoftirqd 处理, 而不是在这里的 IRQ 中断上下文处理.
*/
if (ksoftirqd_running(local_softirq_pending()))
return;
if (!force_irqthreads) { /* 如果 不是强制要求使用 ksoftirqd 处理 softirq, */
#ifdef CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK
/*
* We can safely execute softirq on the current stack if
* it is the irq stack, because it should be near empty
* at this stage.
*/
__do_softirq();
#else
/*
* Otherwise, irq_exit() is called on the task stack that can
* be potentially deep already. So call softirq in its own stack
* to prevent from any overrun.
*/
/*
* 在 IRQ 中断处理即将结束时, 如果 在 IRQ 中断上下文处理 softirq.
* 当前 CPU 的本地中断处于禁用状态.
*/
do_softirq_own_stack();
__do_softirq();
#endif
} else { /* 强制通过 ksoftirqd 处理 softirq, 则唤醒 ksoftirqd 处理 softirq */
wakeup_softirqd();
}
...
/* 中断上下文 和 ksoftirqd 内核线程上下文 处理 softirq 的公共逻辑 */
__do_softirq() /* kernel/softirq.c */
unsigned long end = jiffies + MAX_SOFTIRQ_TIME; /* softirq 处理超时时间: 2ms */
unsigned long old_flags = current->flags;
int max_restart = MAX_SOFTIRQ_RESTART; /* softirq 处理最大轮次 */
struct softirq_action *h;
...
__u32 pending;
int softirq_bit;
...
pending = local_softirq_pending(); /* 读取当前 CPU 挂起的 softirq 事件 */
...
/*
* 禁用 softirq,防止 __do_softirq() 当前 CPU 上的重入。
* 譬如中断抢占、嵌套的情形,可以避免 ksoftirqd 上下文 和 中断上下处理上下文
* 并发的问题,这可以让我们编写 softirq action 接口时,不必考虑所有的竞争场景,
* 这将在后面的章节 4. softirq 同步里面细述。
*/
__local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);
...
restart:
/* Reset the pending bitmask before enabling irqs */
set_softirq_pending(0); /* 清除当前 CPU 挂起的 softirq */
local_irq_enable(); /* 启用 CPU 本地中断,避免 softirq 耗时太长,使得中断得不到响应 */
h = softirq_vec;
/*
* 返回当前 CPU 挂起未处理的、最高优先级 softirq 类型,
* 按 softirq 优先级 从高到低 进行处理.
*/
while ((softirq_bit = ffs(pending))) {
unsigned int vec_nr;
...
h += softirq_bit - 1; /* 软中断向量: softirq_vec[vec_nr] */
vec_nr = h - softirq_vec; /* softirq 类型: HI_SOFTIRQ, ..., RCU_SOFTIRQ */
...
/*
* 统计当前 CPU @vec_nr 类型中断的发生次数。
* 用户空间可通过文件 /proc/softirqs
* 查看, 实现于代码文件 fs/proc/softirqs.c
*/
kstat_incr_softirqs_this_cpu(vec_nr);
trace_softirq_entry(vec_nr);
/*
* 各类型 softirq 处理接口, 优先级 从高到低:
* HI_SOFTIRQ: tasklet_hi_action()
* TIMER_SOFTIRQ: run_timer_softirq()
* NET_TX_SOFTIRQ: net_tx_action()
* NET_RX_SOFTIRQ: net_rx_action()
* BLOCK_SOFTIRQ: blk_done_softirq()
* IRQ_POLL_SOFTIRQ: irq_poll_softirq()
* TASKLET_SOFTIRQ: tasklet_action()
* SCHED_SOFTIRQ: run_rebalance_domains()
* HRTIMER_SOFTIRQ: 没用到, 占位符, 工具依赖的编号顺序
* RCU_SOFTIRQ: rcu_process_callbacks()
*/
h->action(h);
trace_softirq_exit(vec_nr);
...
h++;
pending >>= softirq_bit;
}
...
/*
* 重新禁用 CPU 本地中断.
* 在 接下来的一轮 (跳到 restart 处) softirq 处理
* 或
* 退出中断处理时
* 会重新启用.
*/
local_irq_disable();
/*
* 软中断处理接口有可能又抛出了 softirq 事件.
* 譬如有未启用的 tasklet, 后续需要在启用调度后得到机会
* 执行, 需要重新抛出 TASKLET_SOFTIRQ, 详见 tasklet_action().
* tasklet hi 也是类似的.
*/
pending = local_softirq_pending();
if (pending) {
/*
* 如果处理 softirq 期间, 又有新的 softirq 挂起,
* 且 同时满足下列条件:
* . 软中断处理没有超时 (MAX_SOFTIRQ_TIME == 2ms)
* . 没有挂起调度请求
* . 没有超过 softirq 处理轮数 (MAX_SOFTIRQ_RESTART == 10)
* 则接着发起新的一轮 softirq 处理.
*/
if (time_before(jiffies, end) && !need_resched() && --max_restart)
goto restart;
/*
* 不满足在此立刻发起新的 softirq 处理的条件, 则唤醒
* ksoftirqd, 将挂起 softirq 交给该内核线程处理.
*/
wakeup_softirqd();
}
...
__local_bh_enable(SOFTIRQ_OFFSET); /* 使能 softirq */
...
2.1.2.2 在 ksoftirqd 内核线程上下文 处理 softirq
/* kernel/softirq.c */
static void run_ksoftirqd(unsigned int cpu)
{
local_irq_disable();
if (local_softirq_pending()) {
/*
* We can safely run softirq on inline stack, as we are not deep
* in the task stack here.
*/
__do_softirq(); /* 在 线程上下文 处理本地 CPU 上的 softirq 事件,细节同中断上下文的分析 */
local_irq_enable();
...
return;
}
local_irq_enable();
}
3. softirq 之 tasklet
3.1 定义初始化 tasklet
/* include/linux/interrupt.h */
struct tasklet_struct
{
struct tasklet_struct *next;
/*
* bit-0: 1 表示 tasklet 为调度状态.
* 被 tasklet_trylock() 设置, tasklet_unlock() 清除.
* bit-1: 1 表示 tasklet 为运行态(仅用于 SMP),
* 被 tasklet_schedule() 设置, 被 __do_softirq()
* 执行过后清除.
*/
unsigned long state;
atomic_t count; /* 0 表示 tasklet 为启用状态,非 0 表示 tasklet 为禁用状态 */
void (*func)(unsigned long);
unsigned long data;
};
/* include/linux/interrupt.h */
/* 方法一: 静态定义 tasklet 对象 */
#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
DECLARE_TASKLET(my_tasklet, my_tasklet_function, (unsigned long)my_tasklet_data);
/* 方法二:动态定义 tasklet 对象 */
/* include/linux/interrupt.h */
struct tasklet_struct my_tasklet;
tasklet_init(&my_tasklet, my_tasklet_function, (unsigned long)my_tasklet_data); /* kernel/softirq.c */
t->next = NULL;
t->state = 0;
atomic_set(&t->count, 0);
t->func = func;
t->data = data;
3.2 使能调度 tasklet
/* include/linux/interrupt.h */
static inline void tasklet_schedule(struct tasklet_struct *t)
{
/*
* 标记 tasklet 为 TASKLET_STATE_SCHED 状态:
* TASKLET_STATE_SCHED 态的 tasklet 将在 softirq 里面被调度执行.
*/
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) /* 不能对 tasklet 重复调度 */
__tasklet_schedule(t);
}
/* kernel/softirq.c */
/*
* Tasklets
*/
struct tasklet_head {
struct tasklet_struct *head;
struct tasklet_struct **tail;
};
static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec); /* 每 CPU 的 tasklet 队列 (TASKLET_SOFTIRQ) */
static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec); /* 每 CPU 的 tasklet hi 队列 (HI_SOFTIRQ) */
void __tasklet_schedule(struct tasklet_struct *t)
{
unsigned long flags;
local_irq_save(flags);
t->next = NULL;
*__this_cpu_read(tasklet_vec.tail) = t;
__this_cpu_write(tasklet_vec.tail, &(t->next));
raise_softirq_irqoff(TASKLET_SOFTIRQ); /* 抛出 tasklet 软中断 */
local_irq_restore(flags);
}
用一张图来看下 tasklet
组织数据结构,有助于我们理解后面对 tasklet 执行过程
的分析:
3.3 执行 tasklet
/* kernel/softirq.c */
__do_softirq()
...
h->action(h);
tasklet_action()
...
这里只分析 tasklet_action()
,tasklet_hi_action()
的逻辑几乎完全一样,这里就不再赘述,感兴趣的读者可自行阅读相关源码。
static __latent_entropy void tasklet_action(struct softirq_action *a)
{
struct tasklet_struct *list;
/* 一次性处理当前 CPU 上所有挂起的 tasklet */
local_irq_disable();
list = __this_cpu_read(tasklet_vec.head); /* @list -> 当前 tasklet 列表的第 1 个 tasklet */
/*
* 清空当前 CPU 的 tasklet 列表:
* .head -> NULL
* .tail -> &.head
*/
__this_cpu_write(tasklet_vec.head, NULL);
__this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head));
local_irq_enable();
/* 处理列表 @list 中所有启用的、被调度的 tasklet */
while (list) {
struct tasklet_struct *t = list;
list = list->next;
/*
* 标记 tasklet 为 TASKLET_STATE_RUN 态锁定 tasklet:
* . 如果返回 false 表示 tasklet 已经处于 TASKLET_STATE_RUN,
* 锁定 tasklet 失败;
* . 否则返回 true 表示锁定 tasklet 成功.
*/
if (tasklet_trylock(t)) {
if (!atomic_read(&t->count)) { /* tasklet 为启用状态 */
if (!test_and_clear_bit(TASKLET_STATE_SCHED,
&t->state)) /* 已执行的 tasklet 清除调度标记 */
/*
* 如果
* !test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)
* 成立, 表示 tasklet 没有被设置 TASKLET_STATE_SCHED 位:
* 非 TASKLET_STATE_SCHED 态的 tasklet 出现在 tasklet_vec
* 中,被认为是一个 BUG.
* 程序代码通过 tasklet_schedule() 设置 TASKLET_STATE_SCHED.
*/
BUG();
t->func(t->data);
tasklet_unlock(t);
/*
* 继续执行下一个 tasklet.
*
* 可以看到, 启用并被调度的 tasklet 的执行是一次性的,
* 要想反复执行 tasklet, 需要重新通过 tasklet_schedule()
* 调度 tasklet 执行.
*/
continue;
}
/*
* tasklet 没有启用, 清除 tasklet 的 TASKLET_STATE_RUN 态释放
* tasklet, 接着将该 tasklet 归还到当前 CPU 的 队列, 以备后续
* 启用了再执行.
*/
tasklet_unlock(t);
}
/*
* tasklet 当前从当前 CPU 的 tasklet 队列中移除了,
* 而且 tasklet 没有被启用, 仍然归还到当前 CPU 的
* tasklet 队列中, 以备后续启用了再执行.
*/
local_irq_disable();
/* 将没有执行的 tasklet 归还到当前 CPU 的 tasklet 队列 */
t->next = NULL;
*__this_cpu_read(tasklet_vec.tail) = t;
__this_cpu_write(tasklet_vec.tail, &(t->next));
/*
* 当前 CPU 有未启用的、未被执行的 tasklet,
* 重新抛出 TASKLET_SOFTIRQ, 让这些未启用的
* tasklet 后续在启用并调度后有机会被执行.
*/
__raise_softirq_irqoff(TASKLET_SOFTIRQ);
local_irq_enable();
}
}
4. softirq 同步
对于 tasklet hi (HI_SOFTIRQ)
和 tasklet (TASKLET_SOFTIRQ)
,因为它们有每 CPU 独立的队列
,所以它们总是在
(通过 tasklet_schedule()
)提交的 CPU 上执行
,同一 CPU 队列上的 tasklet
也按提交的顺序串行
的执行;另外,同一个 tasklet
,无法同时提交到多个 CPU 上去执行,看 tasklet_schedule()
的实现:
static inline void tasklet_schedule(struct tasklet_struct *t)
{
/*
* 标记 tasklet 为 TASKLET_STATE_SCHED 状态:
* TASKLET_STATE_SCHED 态的 tasklet 将在 softirq 里面被调度执行.
*/
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) /* 不能对 tasklet 重复调度 */
__tasklet_schedule(t);
}
而对于剩余其它类型的 softirq
,虽然它们也总是在提交的 CPU 上执行
,但不同于 tasklet
的是,它们可能在多个 CPU 上并行,如 支持硬件多队列的网卡驱动,可能导致 net_rx_action()
在多个 CPU 上同时运行。
了解 softirq
的同步,有助于我们写出正确的代码,这是很重要的。
5. softirq 观测
# cat /proc/softirqs
CPU0 CPU1 CPU2 CPU3
HI: 0 0 0 0
TIMER: 6817 6083 8633 5130
NET_TX: 0 0 0 0
NET_RX: 2 16 6 10
BLOCK: 11161 11269 5199 4379
IRQ_POLL: 0 0 0 0
TASKLET: 1 1 8 1
SCHED: 4522 3375 3217 2745
HRTIMER: 0 0 0 0
RCU: 5661 5083 6497 4399
第 1 行示了系统中 CPU,接下来的每一行显示了每种类型 softirq
在每个 CPU 上发生的次数
。另外,从下面的代码:
static void __local_bh_enable(unsigned int cnt)
{
...
if (softirq_count() == (cnt & SOFTIRQ_MASK))
trace_softirqs_on(_RET_IP_);
...
}
asmlinkage __visible void __softirq_entry __do_softirq(void)
{
...
while ((softirq_bit = ffs(pending))) {
...
trace_softirq_entry(vec_nr);
h->action(h);
trace_softirq_exit(vec_nr);
...
}
...
}
看到,Linux 内核也提供 tracepoint / traceevent
来跟踪 softirq
的执行情况。
6. softirq 的未来
softirq
虽然存在发展很多年,但一直存在一些让人诟病的东西,社区有要移除 softirq
(一部分) 的声音,感兴趣的读者,可以阅读这边文章 The end of tasklets。该篇文章的一些参考链接,也值得阅读一下。