Linux内核中断处理体系分析

前一篇博文中：linux内核初始化阶段通过early_trap_init()函数完毕了把异常向量复制到0xFFFF0000開始的地方，这些异常向量大部分指向通过vector_stub宏定义的那段代码。这段代码完毕的主要工作是计算异常返回地址、保存现场、切换到svc模式、跳转运行汇编异常处理函数，汇编异常处理函数工作在svc模式。先接管上一异常模式保存的现场，然后调用C处理函数，C函数返回后运行一段汇编代码完毕异常返回工作。

这一系列的工作就是基于arm9处理器的内核异常处理的体系架构。

linux内核irq中断也是异常事件的一类。可是irq中断发生源不止一个。arm920t仅仅有一个irq中断信号接收引脚，对详细的中断源的推断还须要依赖片外的中断控制器。再者，irq中断引脚是和外设上的中断引脚相连，外设的种类千奇百态，详细的外设有中断事件时须要处理器运行特殊的处理工作。我想基于这样的背景，必须要专门的一套中断处理体系结构来管理中断事件才干让处理器高效工作。

内核中断处理体系结构的搭建任务主要落在init_IRQ()函数,他直接由srart_kernel()函数来调用,定义于arch/arm/kernel/irq.c。

void __init init_IRQ(void)
{
	int irq; //中断号

	for (irq = 0; irq < NR_IRQS; irq++)
		irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE; //通过把每个中断号相应结构体成员“status”状态字段设置成未请求和未探測状态

	init_arch_irq(); //init_arch_irq实际上是一个函数指针，最初由setup_arch()函数来设置这个指针
}

函数分析：

①内核将全部的中断统一编号，习惯叫“中断号”。同一时候定义了irq_desc[NR_IRQS]结构体数据用来描写叙述每个中断。中断号就是用来在这个数组里面定位相应的中断描写叙述结构体的。irq_desc结构体后面再进行分析，如今先放一边。

②探索init_arch_irq()函数:找了一下发现他在start_kernel-->setup_arch函数中被初始化

void __init setup_arch(char **cmdline_p)
{
	.....
	
	init_arch_irq = mdesc->init_irq; //将void型指针init_arch_irq强制指向struct machine_desc结构体的init_irq成员
	
	.....
}

好。问题又来了：什么时候事先把“mdesc->init_irq”这个成员填充了初始？

struct machine_desc {
	......
	
	void	(*init_irq)(void);   //是个函数指针，在sourceinside里边搜一搜。
	
	......
};

init_irq成员在文件arch/arm/mach-s3c2440/mach-tq2440.c中被赋值为s3c24xx_init_irq函数

MACHINE_START(S3C2440, "TQ2440")
	.phys_io	= S3C2410_PA_UART,
	.io_pg_offst	= (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
	.boot_params	= S3C2410_SDRAM_PA + 0x100,

	.init_irq	= s3c24xx_init_irq, //最终找到了!! init_IRQ()函数中通过函数指针init_arch_irq调用的真正内容了！！
！
分析这个函数，看看到底做了些真么。
	.map_io		= tq2440_map_io,
	.init_machine	= tq2440_machine_init, 
	.timer		= &s3c24xx_timer,
MACHINE_END

分析到这里，中断处理框架算没開始搭建，由于还没有设置好各种中断的触发模式和处理函数之类的东西，设置这些内容就是将irq_desc结构体数组中的主要成员初始化，以下看看是不是这样！

③探索s3c24xx_init_irq()函数：也是在arch/arm/kernel/irq.c文件里定义。里面是个庞大的函数调用关系

功能：完毕对中断控制器的初始化，而且设置中断描写叙述符的相应的函数指针的值，以在中断发生时发生时，调用这些函数来完毕芯片级的处理。即建立一个中断源相应一个处理函数的映射关系！

void __init s3c24xx_init_irq(void)
{
	unsigned long pend;
	unsigned long last;
	int irqno;
	int i;

	irqdbf("s3c2410_init_irq: clearing interrupt status flags
");

	/* first, clear all interrupts pending... */
	//（1）在開始设置之前，清除全部中断源等待
	last = 0;
	for (i = 0; i < 4; i++) {
		pend = __raw_readl(S3C24XX_EINTPEND);

		if (pend == 0 || pend == last)
			break;

		__raw_writel(pend, S3C24XX_EINTPEND);
		printk("irq: clearing pending ext status %08x
", (int)pend);
		last = pend;
	}

	last = 0;
	for (i = 0; i < 4; i++) {
		pend = __raw_readl(S3C2410_INTPND);

		if (pend == 0 || pend == last)
			break;

		__raw_writel(pend, S3C2410_SRCPND);
		__raw_writel(pend, S3C2410_INTPND);
		printk("irq: clearing pending status %08x
", (int)pend);
		last = pend;
	}

	last = 0;
	for (i = 0; i < 4; i++) {
		pend = __raw_readl(S3C2410_SUBSRCPND);

		if (pend == 0 || pend == last)
			break;

		printk("irq: clearing subpending status %08x
", (int)pend);
		__raw_writel(pend, S3C2410_SUBSRCPND);
		last = pend;
	}

	/* register the main interrupts */
	// （2）注冊基本的中断

	irqdbf("s3c2410_init_irq: registering s3c2410 interrupt handlers
");

	for (irqno = IRQ_EINT4t7; irqno <= IRQ_ADCPARENT; irqno++) {
		/* set all the s3c2410 internal irqs */

		switch (irqno) {
			/* deal with the special IRQs (cascaded) */

		case IRQ_EINT4t7:
		case IRQ_EINT8t23:
		case IRQ_UART0:
		case IRQ_UART1:
		case IRQ_UART2:
		case IRQ_ADCPARENT:
			set_irq_chip(irqno, &s3c_irq_level_chip);
			set_irq_handler(irqno, handle_level_irq);
			break;

		case IRQ_RESERVED6:
		case IRQ_RESERVED24:
			/* no IRQ here */
			break;

		default:
			//irqdbf("registering irq %d (s3c irq)
", irqno);
			set_irq_chip(irqno, &s3c_irq_chip);
			set_irq_handler(irqno, handle_edge_irq);
			set_irq_flags(irqno, IRQF_VALID);
		}
	}

	/* setup the cascade irq handlers */
	// （3）设置级联中断处理

	set_irq_chained_handler(IRQ_EINT4t7, s3c_irq_demux_extint4t7);
	set_irq_chained_handler(IRQ_EINT8t23, s3c_irq_demux_extint8);

	set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
	set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
	set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
	set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);

	/* register external interrupts */
	// （4）注冊外部中断

	for (irqno = IRQ_EINT0; irqno <= IRQ_EINT3; irqno++) {
		irqdbf("registering irq %d (ext int)
", irqno);
		set_irq_chip(irqno, &s3c_irq_eint0t4);
		set_irq_handler(irqno, handle_edge_irq);
		set_irq_flags(irqno, IRQF_VALID);
	}

	for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) {
		irqdbf("registering irq %d (extended s3c irq)
", irqno);
		set_irq_chip(irqno, &s3c_irqext_chip);
		set_irq_handler(irqno, handle_edge_irq);
		set_irq_flags(irqno, IRQF_VALID);
	}

	/* register the uart interrupts */
	// （5）注冊UART中断

	irqdbf("s3c2410: registering external interrupts
");

	for (irqno = IRQ_S3CUART_RX0; irqno <= IRQ_S3CUART_ERR0; irqno++) {
		irqdbf("registering irq %d (s3c uart0 irq)
", irqno);
		set_irq_chip(irqno, &s3c_irq_uart0);
		set_irq_handler(irqno, handle_level_irq);
		set_irq_flags(irqno, IRQF_VALID);
	}
	
	for (irqno = IRQ_S3CUART_RX1; irqno <= IRQ_S3CUART_ERR1; irqno++) {
		irqdbf("registering irq %d (s3c uart1 irq)
", irqno);
		set_irq_chip(irqno, &s3c_irq_uart1);
		set_irq_handler(irqno, handle_level_irq);//设置处理函数
		set_irq_flags(irqno, IRQF_VALID);
	}

	for (irqno = IRQ_S3CUART_RX2; irqno <= IRQ_S3CUART_ERR2; irqno++) {
		irqdbf("registering irq %d (s3c uart2 irq)
", irqno);
		set_irq_chip(irqno, &s3c_irq_uart2);
		set_irq_handler(irqno, handle_level_irq);//设置处理函数
		set_irq_flags(irqno, IRQF_VALID);
	}

	for (irqno = IRQ_TC; irqno <= IRQ_ADC; irqno++) {
		irqdbf("registering irq %d (s3c adc irq)
", irqno);
		set_irq_chip(irqno, &s3c_irq_adc);
		set_irq_handler(irqno, handle_edge_irq);//设置处理函数
		set_irq_flags(irqno, IRQF_VALID);
	}

	irqdbf("s3c2410: registered interrupt handlers
");
}

函数分析：
主要是使用set_irq_chip()、set_irq_handler()、set_irq_flags()这三个函数来初始化irq_desc结构体中的chip、handle_irq、flags，初始化也就是把他指向某个东东（结构体、函数等）

取一段来分析：

for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) 
{
	irqdbf("registering irq %d (extended s3c irq)
", irqno);
	set_irq_chip(irqno, &s3c_irqext_chip);
	set_irq_handler(irqno, handle_edge_irq);
	set_irq_flags(irqno, IRQF_VALID);
}

set_irq_chip():运行的效果就是irq_desc[irqno]=&s3c_irqext_chip,把中断描写叙述符的struct irq_chip *chip结构指针指向针对s3cxxx芯片的设置好的struct irq_chip s3c_irqext_chip结构体，他里边的成员主要是用来设置外部中断的屏蔽与否、触发方式之类的函数指针

static struct irq_chip s3c_irqext_chip = {
	.name		= "s3c-ext",
	.mask		= s3c_irqext_mask,   //屏蔽中断源
	.unmask		= s3c_irqext_unmask, //开启接收中断源
	.ack		= s3c_irqext_ack,    //响应中断：一般是清除当前中断使得能够接收下一个中断
	.set_type	= s3c_irqext_type,   //触发方式
	.set_wake	= s3c_irqext_wake    //唤醒相关
};

分析到这里中断处理的框架就算是搭建出来了，例如以下图所看到的。图中用户注冊的中断处理函数主要是指驱动开发的时候程序猿加入的。

以下以handle_edge_irq中断处理函数的处理过程进行分析。

④中断处理函数，就跟我们自己玩裸机的时候自己写的意思是一样：清中断和处理中断，就是它这里考虑到的东西比較多，所以看起来复杂，事实它也是比較复杂。

void handle_edge_irq(unsigned int irq, struct irq_desc *desc)
{
	spin_lock(&desc->lock);

	desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);

	/*
	 * If we're currently running this IRQ, or its disabled,
	 * we shouldn't process the IRQ. Mark it pending, handle
	 * the necessary masking and go out
	 * 非正常处理
	 */
	if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
		    !desc->action)) {
		desc->status |= (IRQ_PENDING | IRQ_MASKED);
		mask_ack_irq(desc, irq);
		desc = irq_remap_to_desc(irq, desc);
		goto out_unlock;
	}
	kstat_incr_irqs_this_cpu(irq, desc);

	/* Start handling the irq 開始处理中断 */
	if (desc->chip->ack)
		desc->chip->ack(irq);  //##清中断处理
	desc = irq_remap_to_desc(irq, desc);

	/* Mark the IRQ currently in progress.*/
	desc->status |= IRQ_INPROGRESS;

	do {
		struct irqaction *action = desc->action; //##取出irq_desc结构里边的action成员，action链表里面的是用户注冊的处理函数
		irqreturn_t action_ret;

		if (unlikely(!action)) {
			desc->chip->mask(irq);
			goto out_unlock;
		}

		/*
		 * When another irq arrived while we were handling
		 * one, we could have masked the irq.
		 * Renable it, if it was not disabled in meantime.
		 * 非正常处理：假设另外一个中断到来，屏蔽它
		 */
		if (unlikely((desc->status &
			       (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
			      (IRQ_PENDING | IRQ_MASKED))) {
			desc->chip->unmask(irq);
			desc->status &= ~IRQ_MASKED;
		}

		desc->status &= ~IRQ_PENDING;
		spin_unlock(&desc->lock);
		action_ret = handle_IRQ_event(irq, action); //##进入handle_IRQ_event函数中发现是：取出action链表里边的成员，运行action->handle
		if (!noirqdebug)
			note_interrupt(irq, desc, action_ret);
		spin_lock(&desc->lock);

	} while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);

	desc->status &= ~IRQ_INPROGRESS;
out_unlock:
	spin_unlock(&desc->lock);
}

来看看handle_IRQ_event函数：遍历中断号相应的中段描写叙述符中的action链表，并运行action结构体的handler成员，即处理函数

irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
	irqreturn_t ret, retval = IRQ_NONE;
	unsigned int status = 0;

	if (!(action->flags & IRQF_DISABLED))
		local_irq_enable_in_hardirq();

	do {
		trace_irq_handler_entry(irq, action);
		ret = action->handler(irq, action->dev_id); //运行action->handler函数
		trace_irq_handler_exit(irq, action, ret);

		switch (ret) {
		case IRQ_WAKE_THREAD:
			ret = IRQ_HANDLED;
			if (unlikely(!action->thread_fn)) {
				warn_no_thread(irq, action);
				break;
			}
			if (likely(!test_bit(IRQTF_DIED,
					     &action->thread_flags))) {
				set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
				wake_up_process(action->thread);
			}
		case IRQ_HANDLED:
			status |= action->flags;
			break;

		default:
			break;
		}

		retval |= ret;
		action = action->next;
	} while (action);  //取出链表中的成员

	if (status & IRQF_SAMPLE_RANDOM)
		add_interrupt_randomness(irq);
	local_irq_disable();

	return retval;
}

⑤情景分析：按键中断发生时，函数处理流程：

首先进入异常模式运行b   vector_irq+offset --> 然后vecrot_stubs做一些保护现场工作并切换到svc模式-->跳到跳转表__usr_irq运行再接管“现场”数据，之后调用asm_do_IRQ。他依据中断号找到irq_desc[irq].handle_irq

-->如果irq_desc[irq].handle_irq指向handle_edge_irq，这个函数就会进行上面第④点的工作。