linux中断线程化分析

最近在为3.8版本的Linux内核打RT_PREEMPT补丁，并且优化系统实时性，这篇文章主要对RTlinux中中断线程化部分进行分析。我们知道在RT_PREEMPT补丁中之所以要将中断线程化就是因为硬中断的实时性太高，会影响实时进程的实时性，所以需要将中断处理程序线程化并设置优先级，使中断处理线程的优先级比实时进程优先级低，从而提高系统实时性。

网上看到一些网友说在2.6.25.8版本的内核，linux引入了中断线程化，具体是不是2.6.25.8版本开始引入中断线程化我没有去求证，因为版本比较老了改动很多，但据我的查证从2.6.30开始内核引入request_threaded_irq函数，从这个版本开始可以通过在申请中断时为request_irq设置不同的参数决定是否线程化该中断。而在2.6.39版内核__setup_irq引入irq_setup_forced_threading函数，开始可以通过#  define force_irqthreads(true)强制使中断线程化，那么从这个版本开始想实现中断线程化就已经变得很简单了，让force_irqthreads为真即可，所以在3.8版本的实时补丁中，正是这一段代码实现了中断的线程化：

#ifdef CONFIG_IRQ_FORCED_THREADING
-extern bool force_irqthreads;
+# ifndef CONFIG_PREEMPT_RT_BASE
+   extern bool force_irqthreads;
+# else
+#  define force_irqthreads	(true)
+# endif
 #else
-#define force_irqthreads	(0)
+#define force_irqthreads	(false)
 #endif

下面我们开始正式介绍中断线程化是怎么实现的。

Linux内核常见申请中断的函数request_irq，在内核源码include/linux/interrupt.h头文件中可以看到request_irq仅包含return request_threaded_irq(irq, handler, NULL, flags, name, dev);调用，request_threaded_irq函数在源码目录kernel/irq/manage.c文件中，下面通过分析manage.c中各个相关函数解读中断线程化的实现过程。

根据request_irq的调用，首先分析request_threaded_irq

int request_threaded_irq(unsigned int irq, irq_handler_t handler,
			 irq_handler_t thread_fn, unsigned long irqflags,
			 const char *devname, void *dev_id)
{
	struct irqaction *action;
	struct irq_desc *desc;
	int retval;

	/*
	 * Sanity-check: shared interrupts must pass in a real dev-ID,
	 * otherwise we'll have trouble later trying to figure out
	 * which interrupt is which (messes up the interrupt freeing
	 * logic etc).
	 */
	if ((irqflags & IRQF_SHARED) && !dev_id)	//共享中断必须有唯一确定的设备号，不然中断处理函数找不到发出中断请求的设备，注释写的很清楚
		return -EINVAL;

	desc = irq_to_desc(irq);
	if (!desc)
		return -EINVAL;

	if (!irq_settings_can_request(desc) ||
	    WARN_ON(irq_settings_is_per_cpu_devid(desc)))
		return -EINVAL;

	if (!handler) {	//handler和thread_fn都没有指针传入肯定是出错了，有thread_fn无handler则将irq_default_primary_handler给handler
		if (!thread_fn)
			return -EINVAL;
		handler = irq_default_primary_handler;
	}

	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
	if (!action)
		return -ENOMEM;

	action->handler = handler;
	action->thread_fn = thread_fn;
	action->flags = irqflags;
	action->name = devname;
	action->dev_id = dev_id;

	chip_bus_lock(desc);
	retval = __setup_irq(irq, desc, action);	//在__setup_irq中确定是否线程化并完成中断处理函数绑定
	chip_bus_sync_unlock(desc);

	if (retval)
		kfree(action);

#ifdef CONFIG_DEBUG_SHIRQ_FIXME
	if (!retval && (irqflags & IRQF_SHARED)) {
		/*
		 * It's a shared IRQ -- the driver ought to be prepared for it
		 * to happen immediately, so let's make sure....
		 * We disable the irq to make sure that a 'real' IRQ doesn't
		 * run in parallel with our fake.
		 */
		unsigned long flags;

		disable_irq(irq);
		local_irq_save(flags);

		handler(irq, dev_id);

		local_irq_restore(flags);
		enable_irq(irq);
	}
#endif
	return retval;
}

request_threaded_irq函数基本上是将传入的参数放到action结构体，然后调用__setup_irq函数，线程化的具体过程在__setup_irq函数中

static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{
	struct irqaction *old, **old_ptr;
	unsigned long flags, thread_mask = 0;
	int ret, nested, shared = 0;
	cpumask_var_t mask;

	if (!desc)
		return -EINVAL;

	if (desc->irq_data.chip == &no_irq_chip)
		return -ENOSYS;
	if (!try_module_get(desc->owner))
		return -ENODEV;

	/*
	 * Check whether the interrupt nests into another interrupt
	 * thread.
	 */
	nested = irq_settings_is_nested_thread(desc);
	if (nested) {
		if (!new->thread_fn) {
			ret = -E