linux3.10 中断处理过程（三）softirq 软中断

oqqYuJi12345678

已于 2022-04-16 13:06:16 修改

阅读量2.7k

点赞数

分类专栏： linux中断处理文章标签： linux 软件中断 arm

于 2019-08-19 23:23:36 首次发布

本文链接：https://blog.csdn.net/oqqYuJi12345678/article/details/99771140

版权

linux中断处理专栏收录该内容

4 篇文章 1 订阅

订阅专栏

1. 为什么要软中断

编写驱动的时候，一个中断产生之后，内核在中断处理函数中可能需要完成很多工作。但是中断处理函数的处理是关闭了本地cpu中断的。如果在硬件中断中执行时间过长，可能会造成有可能丢失外部中断。于是，linux内核设计出了一种架构，中断函数需要处理的任务分为两部分，一部分在中断处理函数中执行，这时本地cpu关闭中断。另外一部分在软件中断中执行，这个时候开启中断，本地cpu可以响应外部中断（linux在arm处理器上，在中断发生的时候，硬件就会把本地cpu的cpsr的中断位置起，后面再硬件中断处理程序中，该位一直都是置起的，中断全程都是关闭的，只有在处理完硬件中断，在软中断函数中，才会把cpsr中断打开，处理完软中断后继续关闭中断，直到linux退出中断处理）

软中断（即使同一类型的软中断）可以并发运行在多个CPU上，因此软中断是可重入函数必须使用自旋锁保护其数据结构。

2. 什么时候处理软件中断

初识软中断，脑子里肯定有不少的疑问，首先就是软件中断在什么地方被触发处理？这个问题的答案就是：

（1）一个硬件中断处理完成之后

（2）软中断内核处理线程

（3）调用local_bh_enable，开启软件中断的时候，会进行一次调用

2.1 硬件中断处理结束以后执行软中断

下面的函数在处理完硬件中断之后退出中断处理函数，在irq_exit中会触发软件中断的处理。

void handle_IRQ(unsigned int irq, struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);

	irq_enter();

	/*
	 * Some hardware gives randomly wrong interrupts.  Rather
	 * than crashing, do something sensible.
	 */
	if (unlikely(irq >= nr_irqs)) {
		if (printk_ratelimit())
			printk(KERN_WARNING "Bad IRQ%u\n", irq);
		ack_bad_irq(irq);
	} else {
		generic_handle_irq(irq);
	}

	irq_exit();
	set_irq_regs(old_regs);
}

这里要注意，invoke_softirq必须满足两个条件才能被调用到，一个就是不是在硬件中断处理过程中或者在软件中断处理中，第二个就是必须有软件中断处于pending状态。第二个好理解，有软件中断产生才去处理，没有就不处理。第一个就不好理解了。

void irq_exit(void)
{
#ifndef __ARCH_IRQ_EXIT_IRQS_DISABLED
	local_irq_disable();
#else
	WARN_ON_ONCE(!irqs_disabled());
#endif

	account_irq_exit_time(current);
	trace_hardirq_exit();
	sub_preempt_count(HARDIRQ_OFFSET);
	if (!in_interrupt() && local_softirq_pending())
		invoke_softirq();

	tick_irq_exit();
	rcu_irq_exit();
}

在linux系统的进程数据结构里，有这么一个数据结构

#define preempt_count() (current_thread_info()->preempt_count)，

利用preempt_count可以表示是否处于中断处理或者软件中断处理过程中。

#define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
#define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
#define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
 
#define PREEMPT_OFFSET    (1UL << PREEMPT_SHIFT)
#define SOFTIRQ_OFFSET    (1UL << SOFTIRQ_SHIFT)
#define HARDIRQ_OFFSET    (1UL << HARDIRQ_SHIFT)

sub_preempt_count(IRQ_EXIT_OFFSET);

#define in_interrupt() (irq_count())

#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK))

preempt_count的8～23位记录中断处理和软件中断处理过程的计数。如果有计数，表示系统在硬件中断或者软件中断处理过程中。系统这么设计是为了避免软件中断在中断嵌套中被调用，并且达到在单个CPU上软件中断不能被重入的目的。对于ARM架构的CPU不存在中断嵌套中调用软件中断的问题，因为ARM架构的CPU在处理硬件中断的过程中是关闭掉中断的。只有在进入了软中断处理过程中之后才会开启硬件中断，如果在软件中断处理过程中有硬件中断嵌套，也不会再次调用软中断，because硬件中断是软件中断处理过程中再次进入的，此时preempt_count已经记录了软件中断！对于其它架构的CPU，有可能在触发调用软件中断前，也就是还在处理硬件中断的时候，就已经开启了硬件中断，可能会发生中断嵌套，在中断嵌套中是不允许调用软件中断处理的。Why？我的理解是，在发生中断嵌套的时候，表明这个时候是系统突发繁忙的时候，内核第一要务就是赶紧把中断中的事情处理完成，退出中断嵌套。避免多次嵌套，哪里有时间处理软件中断，所以把软件中断推迟到了所有中断处理完成的时候才能触发软件中断。

2.2 软中断内核处理线程

软件中断执行的的位置一般是中断上下文中，但是也有特例，在软中断的内核线程中实际已经是进程的上下文。这里说的进程上下文指的就是系统为每个CPU建立的run_ksoftirqd进程。

什么情况下会需要内核线程来处理软件中断呢。

1 当调用raise_softirq来启动某个软件中断的时候，建检查到当前不再中断执行中，则使用wakeup_softirqd来唤醒软件中断内核处理线程处理。

2 之前我说到不能让CPU长时间来处理中断事务，这样会影响系统的响应时间，严重影响用户和系统之间的交互式体验。所以在之前的__do_softirq中最多将循环执行10次，那么当执行了10次仍然有软中断在pending状态，这个时候应该怎么处理呢？系统调用wakeup_softirqd将唤醒一个软件中断处理的内核进程，在内核进程中处理pending中的软件中断。

3 当设置force_irqthreads的时候，系统将不会使用中断上下文的软件中断，而都使用wakeup_softirqd唤醒软件中断处理线程来处理软件中断

先看一下系统如何初始化软中断内核处理线程：

kernel_init

------------->kernel_init_freeable

---------------->do_pre_smp_initcalls

static void __init do_pre_smp_initcalls(void)
{
	initcall_t *fn;
	for (fn = __initcall_start; fn < __initcall0_start; fn++){
		do_one_initcall(*fn);
	}
}

初始化时，会调用__initcall_start和__initcall0_start之间定义的初始化函数。在链接脚本中，可以看到有如下定义：

__initcall_start = .; *(.initcallearly.init) __initcall0_start = .;

说明定义在*(.initcallearly.init)段中的函数将会被调用到。而软中断内核线程初始化函数有如下定义：

Softirq.c (kernel):DEFINE_PER_CPU(struct task_struct *, ksoftirqd);//为每个cpu定义一个ksoftirqd task指针
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)
{
	register_cpu_notifier(&cpu_nfb);

	BUG_ON(smpboot_register_percpu_thread(&softirq_threads));

	return 0;
}
early_initcall(spawn_ksoftirqd);
#define __define_initcall(fn, id) \
	static initcall_t __initcall_##fn##id __used \
	__attribute__((__section__(".initcall" #id ".init"))) = fn

/*
 * Early initcalls run before initializing SMP.
 *
 * Only for built-in code, not modules.
 */
#define early_initcall(fn)		__define_initcall(fn, early)

spawn_ksoftirqd函数被放在 *(.initcallearly.init)段中。

看上面的smpboot_register_percpu_thread函数：

int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread)
{
	unsigned int cpu;
	int ret = 0;

	mutex_lock(&smpboot_threads_lock);
	for_each_online_cpu(cpu) {
		ret = __smpboot_create_thread(plug_thread, cpu);
		if (ret) {
			smpboot_destroy_threads(plug_thread);
			goto out;
		}
		smpboot_unpark_thread(plug_thread, cpu);
	}
	list_add(&plug_thread->list, &hotplug_threads);
out:
	mutex_unlock(&smpboot_threads_lock);
	return ret;
}

核心函数是 __smpboot_create_thread，为每个cpu调用一次：

static int
__smpboot_create_thread(struct smp_hotplug_thread *ht, unsigned int cpu)
{
	struct task_struct *tsk = *per_cpu_ptr(ht->store, cpu);
	struct smpboot_thread_data *td;

	if (tsk)
		return 0;

	td = kzalloc_node(sizeof(*td), GFP_KERNEL, cpu_to_node(cpu));
	if (!td)
		return -ENOMEM;
	td->cpu = cpu;
	td->ht = ht;

	tsk = kthread_create_on_cpu(smpboot_thread_fn, td, cpu,
				    ht->thread_comm);//创建task
	if (IS_ERR(tsk)) {
		kfree(td);
		return PTR_ERR(tsk);
	}
	get_task_struct(tsk);
	*per_cpu_ptr(ht->store, cpu) = tsk;
	if (ht->create) {
		/*
		 * Make sure that the task has actually scheduled out
		 * into park position, before calling the create
		 * callback. At least the migration thread callback
		 * requires that the task is off the runqueue.
		 */
		if (!wait_task_inactive(tsk, TASK_PARKED))
			WARN_ON(1);
		else
			ht->create(cpu);
	}
	return 0;
}

调用kthread_create_on_cpu创建task_struct,线程创建利用了kthreadd线程。线程创建完以后会调用smpboot_thread_fn

smpboot_thread_fn里面是一个大的while 循环，下面只给出关键代码：

if (!ht->thread_should_run(td->cpu)) {
			preempt_enable();
			schedule();
		} else {
			set_current_state(TASK_RUNNING);
			preempt_enable();
			ht->thread_fn(td->cpu);
}

当检测到需要执行软件中断处理，则执行ht->thread_fn，该函数如下定义：

static int ksoftirqd_should_run(unsigned int cpu)
{
	return local_softirq_pending();
}

static void run_ksoftirqd(unsigned int cpu)
{
	local_irq_disable();
	if (local_softirq_pending()) {
		__do_softirq();//调用软中断处理函数
		rcu_note_context_switch(cpu);
		local_irq_enable();
		cond_resched();
		return;
	}
	local_irq_enable();
}

ht->thread_fn对应的就是run_ksoftirqd，可以看到在内核线程中最终调用了软中断处理函数__do_softirq。

激活内核线程软中断处理函数的api为wakeup_softirqd：

static void wakeup_softirqd(void)
{
	/* Interrupts are disabled: no need to stop preemption */
	struct task_struct *tsk = __this_cpu_read(ksoftirqd);

	if (tsk && tsk->state != TASK_RUNNING)
		wake_up_process(tsk);
}

初始化时新建的task记录在per_cpu变量 ksoftirqd中，这边唤醒当前cpu的软中断内核处理函数。

2.3 local_bh_enable

local_bh_enable

------------->_local_bh_enable_ip

static inline void _local_bh_enable_ip(unsigned long ip)
{
	WARN_ON_ONCE(in_irq() || irqs_disabled());
#ifdef CONFIG_TRACE_IRQFLAGS
	local_irq_disable();
#endif
	/*
	 * Are softirqs going to be turned on now:
	 */
	if (softirq_count() == SOFTIRQ_DISABLE_OFFSET)
		trace_softirqs_on(ip);
	/*
	 * Keep preemption disabled until we are done with
	 * softirq processing:
 	 */
	sub_preempt_count(SOFTIRQ_DISABLE_OFFSET - 1);

	if (unlikely(!in_interrupt() && local_softirq_pending()))
		do_softirq();

	dec_preempt_count();
#ifdef CONFIG_TRACE_IRQFLAGS
	local_irq_enable();
#endif
	preempt_check_resched();
}

3. 软件中断的初始化

3.10版本的linux中定义了如下种类的软件中断，数值越小，优先级越高，在软中断中越早被处理

enum
{
	HI_SOFTIRQ=0,
	TIMER_SOFTIRQ,
	NET_TX_SOFTIRQ,
	NET_RX_SOFTIRQ,
	BLOCK_SOFTIRQ,
	BLOCK_IOPOLL_SOFTIRQ,
	TASKLET_SOFTIRQ,
	SCHED_SOFTIRQ,
	HRTIMER_SOFTIRQ,
	RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */

	NR_SOFTIRQS
};

内核用softirq_action结构管理软件中断的注册和激活等操作，它的定义如下：

struct softirq_action
{
	void	(*action)(struct softirq_action *);
};

然后调用如下函数来设置软件中断处理函数：

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

然后可以使用raise_softirq来设置软件中断：

void raise_softirq(unsigned int nr)
{
	unsigned long flags;

	local_irq_save(flags);
	raise_softirq_irqoff(nr);
	local_irq_restore(flags);
}
void __raise_softirq_irqoff(unsigned int nr)
{
	trace_softirq_raise(nr);
	or_softirq_pending(1UL << nr);
}
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();
}

传入的参数nr为需要设置的软件中断，在raise_softirq_irqoff函数中，先设置软中断的pending位，然后如果不再中断中，则唤醒软中断内核线程来处理。

多个软中断可以同时在多个cpu运行，就算是同一种软中断，也有可能同时在多个cpu上运行。内核为每个cpu都管理着一个待决软中断变量（pending），它就是irq_cpustat_t：

typedef struct {
	unsigned int __softirq_pending;
} ____cacheline_aligned irq_cpustat_t;
irq_cpustat_t irq_stat[NR_CPUS] ____cacheline_aligned;

__softirq_pending字段中的每一个bit，对应着某一个软中断，某个bit被置位，说明有相应的软中断等待处理。

4. 软件中断的处理过程

之前我已经说到，软中断的一个很大的目的就是避免中断处理中，处理的操作过多而丢失中断。同时中断还需要考虑到一件事情就是中断处理过程过长就会影响系统响应时间。如果一个中断处理一秒钟，那你一定能感受到串口卡住的现象。从另外一方面说呢，我们又必须考虑中断处理的操作一定的优先度，毕竟是硬件触发的事务，关系到网络、块设备的效率问题。Linux内核就中断方面就必须考虑平衡这三个方面的问题。而下面我要分析的__do_softirq函数就恰似在这三者之间打太极，游刃有余，面面俱到！

#define MAX_SOFTIRQ_RESTART 10
asmlinkage void __do_softirq(void)
{
	struct softirq_action *h;
	__u32 pending;
	unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
	int cpu;
	unsigned long old_flags = current->flags;
	int max_restart = MAX_SOFTIRQ_RESTART;

	/*
	 * Mask out PF_MEMALLOC s current task context is borrowed for the
	 * softirq. A softirq handled such as network RX might set PF_MEMALLOC
	 * again if the socket is related to swap
	 */
	current->flags &= ~PF_MEMALLOC;

	pending = local_softirq_pending();
	account_irq_enter_time(current);

	__local_bh_disable((unsigned long)__builtin_return_address(0),
				SOFTIRQ_OFFSET);
	lockdep_softirq_enter();

	cpu = smp_processor_id();
restart:
	/* Reset the pending bitmask before enabling irqs */
	set_softirq_pending(0);

	local_irq_enable();

	h = softirq_vec;

	do {
		if (pending & 1) {
			unsigned int vec_nr = h - softirq_vec;
			int prev_count = preempt_count();

			kstat_incr_softirqs_this_cpu(vec_nr);

			trace_softirq_entry(vec_nr);
			h->action(h);
			trace_softirq_exit(vec_nr);
			if (unlikely(prev_count != preempt_count())) {
				printk(KERN_ERR "huh, entered softirq %u %s %p"
				       "with preempt_count %08x,"
				       " exited with %08x?\n", vec_nr,
				       softirq_to_name[vec_nr], h->action,
				       prev_count, preempt_count());
				preempt_count() = prev_count;
			}

			rcu_bh_qs(cpu);
		}
		h++;
		pending >>= 1;
	} while (pending);

	local_irq_disable();

	pending = local_softirq_pending();
	if (pending) {
		if (time_before(jiffies, end) && !need_resched() &&
		    --max_restart)
			goto restart;

		wakeup_softirqd();
	}

	lockdep_softirq_exit();

	account_irq_exit_time(current);
	__local_bh_enable(SOFTIRQ_OFFSET);
	tsk_restore_flags(current, old_flags, PF_MEMALLOC);
}

__do_softirq函数处理软件中断过程如下图流程分析：

（1）首先调用local_softirq_pending函数取得目前有哪些位存在软件中断
（2）调用__local_bh_disable关闭软中断，其实就是设置正在处理软件中断标记，在同一个CPU上使得不能重入__do_softirq函数
（3）重新设置软中断标记为0，set_softirq_pending重新设置软中断标记为0，这样在之后重新开启中断之后硬件中断中又可以设置软件中断位。

（4）开启硬件中断

（5）之后在一个循环中，遍历pending标志的每一位，如果这一位设置就会调用软件中断的处理函数。在这个过程中硬件中断是开启的，随时可以打断软件中断。这样保证硬件中断不会丢失。

（6）之后关闭硬件中断，查看是否又有软件中断处于pending状态，如果是，并且在本次调用__do_softirq函数过程中没有累计重复进入软件中断处理的次数超过10次，就可以重新调用软件中断处理。如果超过了10次，就调用wakeup_softirqd();唤醒内核的一个进程来处理软件中断。设立10次的限制，也是为了避免影响系统响应时间。

5. tasklet

因为内核已经定义好了10种软中断类型，并且不建议我们自行添加额外的软中断，并且由于软中断必须使用可重入函数，这就导致设计上的复杂度变高，作为设备驱动程序的开发者来说，增加了负担。而如果某种应用并不需要在多个CPU上并行执行，那么软中断其实是没有必要的。但是，对于某些情况下，我们不希望一些操作直接在中断的handler中执行，但是又希望在稍后的时间里得到快速地处理，这就需要使用tasklet机制。 tasklet是建立在软中断上的一种延迟执行机制，它的实现基于TASKLET_SOFTIRQ和HI_SOFTIRQ这两个软中断类型。

它具有以下特性：
a）一种特定类型的tasklet只能运行在一个CPU上，不能并行，只能串行执行。
b）多个不同类型的tasklet可以并行在多个CPU上。
c）软中断是静态分配的，在内核编译好之后，就不能改变。但tasklet就灵活许多，可以在运行时改变（比如添加模块时）。

5.1 tasklet_struct

在软中断的初始化函数softirq_init的最后，内核注册了TASKLET_SOFTIRQ和HI_SOFTIRQ这两个软中断：

void __init softirq_init(void)
{
        ......
	open_softirq(TASKLET_SOFTIRQ, tasklet_action);
	open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

内核用一个tasklet_struct来表示一个tasklet，它的定义如下：

struct tasklet_struct
{
	struct tasklet_struct *next;
	unsigned long state;
	atomic_t count;
	void (*func)(unsigned long);
	unsigned long data;
};

next用于把同一个cpu的tasklet链接成一个链表，state用于表示该tasklet的当前状态，目前只是用了最低的两个bit，分别用于表示已经准备被调度执行和已经在另一个cpu上执行：

    enum
    {
    	TASKLET_STATE_SCHED,	/* Tasklet is scheduled for execution */
    	TASKLET_STATE_RUN	/* Tasklet is running (SMP only) */
    };

原子变量count用于tasklet对tasklet_disable和tasklet_enable的计数，count为0时表示允许tasklet执行，否则不允许执行，每次tasklet_disable时，该值加1，tasklet_enable时该值减1。func是tasklet被执行时的回调函数指针，data则用作回调函数func的参数。

5.2 初始化一个tasklet

有两种办法初始化一个tasklet，第一种是静态初始化，使用以下两个宏，这两个宏定义一个tasklet_struct结构，并用相应的参数对结构中的字段进行初始化：

#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_init函数进行初始化，该方法默认tasklet处于enable状态：

struct tasklet_struct tasklet_xxx;
......
tasklet_init(&tasklet_xxx, func, data);

看一下tasklet_init的实现：

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->data = data;
}

5.3 tasklet的使用方法

（1）使能和禁止tasklet，使用以下函数：

tasklet_disable() 通过给count字段加1来禁止一个tasklet，如果tasklet正在运行中，则等待运行完毕才返回（通

      过TASKLET_STATE_RUN标志）。
      tasklet_disable_nosync() tasklet_disable的异步版本，它不会等待tasklet运行完毕。
      tasklet_enable() 使能tasklet，只是简单地给count字段减1。

（2）调度tasklet的执行，使用以下函数：

             tasklet_schedule(struct tasklet_struct *t) 如果TASKLET_STATE_SCHED标志为0，则置位TASKLET_STATE_SCHED，然后把tasklet挂到该cpu等待执行的tasklet链表上，接着发出TASKLET_SOFTIRQ软件中断请求。

static inline void tasklet_schedule(struct tasklet_struct *t)
{
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_schedule(t);
}
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);
	local_irq_restore(flags);
}

tasklet_hi_schedule(struct tasklet_struct *t) 效果同上，区别是它发出的是HI_SOFTIRQ软件中断请求。

（3）销毁tasklet，使用以下函数：

tasklet_kill(struct tasklet_struct *t) 如果tasklet处于TASKLET_STATE_SCHED状态，或者tasklet正在执行，则会等待tasklet执行完毕，然后清除TASKLET_STATE_SCHED状态。

static inline void tasklet_hi_schedule(struct tasklet_struct *t)
{
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_hi_schedule(t);
}
void __tasklet_hi_schedule(struct tasklet_struct *t)
{
	unsigned long flags;

	local_irq_save(flags);
	t->next = NULL;
	*__this_cpu_read(tasklet_hi_vec.tail) = t;
	__this_cpu_write(tasklet_hi_vec.tail,  &(t->next));
	raise_softirq_irqoff(HI_SOFTIRQ);
	local_irq_restore(flags);
}

内核为每个cpu用定义了一个tasklet_head结构，用于管理每个cpu上的tasklet的调度和执行：

struct tasklet_head
{
	struct tasklet_struct *head;
	struct tasklet_struct **tail;
};
 
static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec);
static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec);

tasklet是利用TASKLET_SOFTIRQ和HI_SOFTIRQ这两个软中断来实现的，两个软中断只是有优先级的差别，所以我们只讨论TASKLET_SOFTIRQ的实现，TASKLET_SOFTIRQ的中断回调函数是tasklet_action，我们看看它的代码：

static void tasklet_action(struct softirq_action *a)
{
	struct tasklet_struct *list;

	local_irq_disable();
	list = __this_cpu_read(tasklet_vec.head);
	__this_cpu_write(tasklet_vec.head, NULL);
	__this_cpu_write(tasklet_vec.tail, &__get_cpu_var(tasklet_vec).head);
	local_irq_enable();

	while (list) {
		struct tasklet_struct *t = list;

		list = list->next;

		if (tasklet_trylock(t)) {
			if (!atomic_read(&t->count)) {
				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();
		t->next = NULL;
		*__this_cpu_read(tasklet_vec.tail) = t;
		__this_cpu_write(tasklet_vec.tail, &(t->next));
		__raise_softirq_irqoff(TASKLET_SOFTIRQ);
		local_irq_enable();
	}
}

（1）关闭本地中断的前提下，移出当前cpu的待处理tasklet链表到一个临时链表后，清除当前cpu的tasklet链表，之所以这样处理，是为了处理当前tasklet链表的时候，允许新的tasklet被调度进待处理链表中。
（2）遍历临时链表，用tasklet_trylock判断当前tasklet是否已经在其他cpu上运行，而且tasklet没有被禁止：

如果没有运行，也没有禁止，则清除TASKLET_STATE_SCHED状态位，执行tasklet的回调函数。
如果已经在运行，或者被禁止，则把该tasklet重新添加会当前cpu的待处理tasklet链表上，然后触发TASKLET_SOFTIRQ软中断，等待下一次软中断时再次执行。

6 软中断重入

6.1 软件中断的重入分析

软中断之所以有可能在多个cpu之间重入，可以从源代码中看到具体的处理过程，回到上面的raise_softirq:

raise_softirq

---------->raise_softirq_irqoff

------------->__raise_softirq_irqoff
void __raise_softirq_irqoff(unsigned int nr)
{
	trace_softirq_raise(nr);
	or_softirq_pending(1UL << nr);
}
在or_softirq_pending 函数中：
#define or_softirq_pending(x)  (local_softirq_pending() |= (x))
#define local_softirq_pending() \
	__IRQ_STAT(smp_processor_id(), __softirq_pending)
#define __IRQ_STAT(cpu, member)	(irq_stat[cpu].member)
可以看到最终要设置的那个软中断位，根据当前cpu的id号，设置进了irq_stat[cpu]数组中，也就是有几个cpu，这个数组就会有几项，每个cpu管理自己单独的一项，所以同一个软中断可能会设置进数组的不同项，在不同cpu上面去执行，但是不会在同一个cpu上面并发。

再看一下处理的时候是如何取出该软中断的，在__do_softirq：

__do_softirq

---------->local_softirq_pending
#define local_softirq_pending() \
	__IRQ_STAT(smp_processor_id(), __softirq_pending)
#define __IRQ_STAT(cpu, member)	(irq_stat[cpu].member)
可以看到本地cpu也是根据cpu id 从数组中去取，和设置软中断处理函数是相对应的

6.2 tasklet不可重入分析

tasklet的启动函数中

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

如果该tasklet已经被启动，设置了TASKLET_STATE_SCHED，并且还没有被运行，则不能再被启动，tasklet 是用链表来管理的，重复启动会冲刷之前的链表结构，带来灾难性的后果。所以一个未被运行的tsaklet不能被重复设置多次。

tasklet_schedule

----------->__tasklet_schedule

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);
	local_irq_restore(flags);
}

可以看到任务被挂载进tasklet_vec.tail的percpu变量中，接着设置TASKLET_SOFTIRQ中断标志，

接着看其处理函数：

static void tasklet_action(struct softirq_action *a)
{
。。。。。。。。。。。。。。。。。。。。。。
		if (tasklet_trylock(t)) {
			if (!atomic_read(&t->count)) {
				if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
					BUG();
				t->func(t->data);
				tasklet_unlock(t);
				continue;
			}
			tasklet_unlock(t);
		}
。。。。。。。。。。。。。
}

可以看到，在处理某个tasklet时，先调用tasklet_trylock看是否能锁定该tasklet，如果该tasklet已经在运行，（什么时候会处于这种情况，当一个cpu开始处理这个tasklet时，设置成TASKLET_STATE_RUN状态，这时候新的tasklet可以被重新挂载入其他cpu的链表，为保证这个tasklet不能再两个cpu上同时run，所以这边加了这个保护）则当前cpu不对其再进行处理，保证了同一个tasklet不能在不同的cpu上面并行处理，但是不同的tasklet是可以在不同cpu上面进行并行处理的

更多内容请参考下面两篇博文：

linux软中断机制分析-alloysystem-ChinaUnix博客

Linux中断（interrupt）子系统之五：软件中断（softIRQ）_DroidPhone的博客-CSDN博客_linux软中断例子

oqqYuJi12345678

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
linux3.10 中断处理过程（三）softirq 软中断

1. 为什么要软中断编写驱动的时候，一个中断产生之后，内核在中断处理函数中可能需要完成很多工作。但是中断处理函数的处理是关闭了中断的。也就是说在响应中断时，系统不能再次响应外部的其它中断。这样的后果会造成有可能丢失外部中断。于是，linux内核设计出了一种架构，中断函数需要处理的任务分为两部分，一部分在中断处理函数中执行，这时系统关闭中断。另外一部分在软件中断中执行，这个时候开启中断，系统可...
复制链接

扫一扫