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成员
	
	.....
}

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

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

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

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

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

	/* 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\n", (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\n", (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\n", (int)pend);
		__raw_writel(pend, S3C2410_SUBSRCPND);
		last = pend;
	}

	/* register the main interrupts */
	// （2）注册主要的中断

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

	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)\n", 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)\n", 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)\n", 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\n");

	for (irqno = IRQ_S3CUART_RX0; irqno <= IRQ_S3CUART_ERR0; irqno++) {
		irqdbf("registering irq %d (s3c uart0 irq)\n", 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)\n", 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)\n", 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)\n", 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\n");
}

取一段来分析：

for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) 
{
	irqdbf("registering irq %d (extended s3c irq)\n", 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