1. 中断的概念

中断是指在CPU正常运行期间，由于内外部事件或由程序预先安排的事件引起的 CPU 暂时停止正在运行的程序，转而为该内部或外部事件或预先安排的事件服务的程序中去，服务完毕后再返回去继续运行被暂时中断的程序。Linux中通常分为外部中断（又叫硬件中断）和内部中断（又叫异常）。

软件对硬件进行配置后，软件期望等待硬件的某种状态（比如，收到了数据），这里有两种方式，一种是轮询（polling）： CPU 不断的去读硬件状态。另一种是当硬件完成某种事件后，给 CPU 一个中断，让 CPU 停下手上的事情，去处理这个中断。很显然，中断的交互方式提高了系统的吞吐。

当 CPU 收到一个中断 （IRQ）的时候，会去执行该中断对应的处理函数（ISR）。普通情况下，会有一个中断向量表，向量表中定义了 CPU 对应的每一个外设资源的中断处理程序的入口，当发生对应的中断的时候， CPU 直接跳转到这个入口执行程序。也就是中断上下文。（注意：中断上下文中，不可阻塞睡眠）。

 

2. Linux 中断 top/bottom

玩过 MCU 的人都知道，中断服务程序的设计最好是快速完成任务并退出，因为此刻系统处于被中断中。但是在 ISR 中又有一些必须完成的事情，比如：清中断标志，读/写数据，寄存器操作等。

在 Linux 中，同样也是这个要求，希望尽快的完成 ISR。但事与愿违，有些 ISR 中任务繁重，会消耗很多时间，导致响应速度变差。Linux 中针对这种情况，将中断分为了两部分：

1. 上半部（top half）：收到一个中断，立即执行，有严格的时间限制，只做一些必要的工作，比如：应答，复位等。这些工作都是在所有中断被禁止的情况下完成的。

2. 底半部（bottom half）：能够被推迟到后面完成的任务会在底半部进行。在适合的时机，下半部会被开中断执行。（具体的机制在下一篇文章分析）

 

3. 中断处理程序

驱动程序可以使用接口：

request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
	    const char *name, void *dev)

像系统申请注册一个中断处理程序。

其中的参数：

参数	含义
irq	表了该中断的中断号，一般 CPU 的中断号都会事先定义好。
handler	中断发生后的 ISR
flags	中断标志( IRQF_DISABLED / IRQFSAMPLE_RANDOM / IRQF_TIMER / IRQF_SHARED)
name	中断相关的设备 ASCII 文本，例如 "keyboard"，这些名字会在 /proc/irq 和 /proc/interrupts 文件使用
dev	用于共享中断线，传递驱动程序的设备结构。非共享类型的中断，直接设置成为 NULL

 

 

 

 

 

 

 

中断标志 flag 的含义：

标志	含义
IRQF_DISABLED	设置这个标志的话，意味着内核在处理这个 ISR 期间，要禁止其他中断（多数情况不使用这个）
IRQFSAMPLE_RANDOM	表明这个设备产生的中断对内核熵池有贡献
IRQF_TIMER	为系统定时器准备的标志
IRQF_SHARED	表明多个中断处理程序之间共享中断线。同一个给定的线上注册每个处理程序，必须设置这个

 

 

 

 

 

 

调用 request _irq 成功执行返回 0。常见错误是 -EBUSY，表示给定的中断线已经在使用（或者没有指定 IRQF_SHARED）

注意：request_irq 函数可能引起睡眠，所以不允许在中断上下文或者不允许睡眠的代码中调用。

 

释放中断：

const void *free_irq(unsigned int irq, void *dev_id)

用于释放中断处理函数。

注意：Linux 中的中断处理程序是无须重入的。当给定的中断处理程序正在执行的时候，其中断线在所有的处理器上都会被屏蔽掉，以防在同一个中断线上又接收到另一个新的中断。通常情况下，除了该中断的其他中断都是打开的，也就是说其他的中断线上的重点都能够被处理，但是当前的中断线总是被禁止的，故，同一个中断处理程序是绝对不会被自己嵌套的。

 

4. 中断上下文

与进程上下文不一样，内核执行中断服务程序的时候，处于中断上下文。中断处理程序并没有自己的独立的栈，而是使用了内核栈，其大小一般是有限制的（32bit 机器 8KB）。所以其必须短小精悍。同时中断服务程序是打断了正常的程序流程，这一点上也必须保证快速的执行。同时中断上下文中是不允许睡眠，阻塞的。

中断上下文不能睡眠的原因是：

1、 中断处理的时候,不应该发生进程切换，因为在中断context中，唯一能打断当前中断handler的只有更高优先级的中断，它不会被进程打断，如果在 中断context中休眠，则没有办法唤醒它，因为所有的wake_up_xxx都是针对某个进程而言的，而在中断context中，没有进程的概念，没 有一个task_struct（这点对于softirq和tasklet一样），因此真的休眠了，比如调用了会导致block的例程，内核几乎肯定会死。

2、schedule()在切换进程时，保存当前的进程上下文（CPU寄存器的值、进程的状态以及堆栈中的内容），以便以后恢复此进程运行。中断发生后，内核会先保存当前被中断的进程上下文（在调用中断处理程序后恢复）；

但在中断处理程序里，CPU寄存器的值肯定已经变化了吧（最重要的程序计数器PC、堆栈SP等），如果此时因为睡眠或阻塞操作调用了schedule()，则保存的进程上下文就不是当前的进程context了.所以不可以在中断处理程序中调用schedule()。

3、内核中schedule()函数本身在进来的时候判断是否处于中断上下文:

if(unlikely(in_interrupt()))

BUG();

因此，强行调用schedule()的结果就是内核BUG。

4、中断handler会使用被中断的进程内核堆栈，但不会对它有任何影响，因为handler使用完后会完全清除它使用的那部分堆栈，恢复被中断前的原貌。

5、处于中断context时候，内核是不可抢占的。因此，如果休眠，则内核一定挂起。

 

5. 举例

比如 RTC 驱动程序 (drivers/char/rtc.c)。在 RTC 驱动的初始化阶段，会调用到 rtc_init 函数：

module_init(rtc_init);

在这个初始化函数中调用到了 request_irq 用于申请中断资源，并注册服务程序：

static int __init rtc_init(void)
{
...
    rtc_int_handler_ptr = rtc_interrupt;
...
    request_irq(RTC_IRQ, rtc_int_handler_ptr, 0, "rtc", NULL)
...
}

RTC_IRQ 是中断号，和处理器绑定。

rtc_interrupt 是中断处理程序：

static irqreturn_t rtc_interrupt(int irq, void *dev_id)
{
	/*
	 *	Can be an alarm interrupt, update complete interrupt,
	 *	or a periodic interrupt. We store the status in the
	 *	low byte and the number of interrupts received since
	 *	the last read in the remainder of rtc_irq_data.
	 */

	spin_lock(&rtc_lock);
	rtc_irq_data += 0x100;
	rtc_irq_data &= ~0xff;
	if (is_hpet_enabled()) {
		/*
		 * In this case it is HPET RTC interrupt handler
		 * calling us, with the interrupt information
		 * passed as arg1, instead of irq.
		 */
		rtc_irq_data |= (unsigned long)irq & 0xF0;
	} else {
		rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
	}

	if (rtc_status & RTC_TIMER_ON)
		mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);

	spin_unlock(&rtc_lock);

	wake_up_interruptible(&rtc_wait);

	kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);

	return IRQ_HANDLED;
}

每次收到 RTC 中断，就会调用进这个函数。

 

6. 中断处理流程

发生中断时，CPU执行异常向量vector_irq的代码， 即异常向量表中的中断异常的代码，它是一个跳转指令，跳去执行真正的中断处理程序，在vector_irq里面，最终会调用中断处理的总入口函数。

C 语言的入口为 ： asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

asmlinkage void __exception_irq_entry
asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
{
	handle_IRQ(irq, regs);
}

该函数的入参 irq 为中断号。

asm_do_IRQ -> handle_IRQ

void handle_IRQ(unsigned int irq, struct pt_regs *regs)
{
	__handle_domain_irq(NULL, irq, false, regs);
}

handle_IRQ -> __handle_domain_irq

int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
			bool lookup, struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);
	unsigned int irq = hwirq;
	int ret = 0;

	irq_enter();

#ifdef CONFIG_IRQ_DOMAIN
	if (lookup)
		irq = irq_find_mapping(domain, hwirq);
#endif

	/*
	 * Some hardware gives randomly wrong interrupts.  Rather
	 * than crashing, do something sensible.
	 */
	if (unlikely(!irq || irq >= nr_irqs)) {
		ack_bad_irq(irq);
		ret = -EINVAL;
	} else {
		generic_handle_irq(irq);
	}

	irq_exit();
	set_irq_regs(old_regs);
	return ret;
}

这里请注意：

先调用了 irq_enter 标记进入了硬件中断：

irq_enter是更新一些系统的统计信息，同时在__irq_enter宏中禁止了进程的抢占。虽然在产生IRQ时，ARM会自动把CPSR中的I位置位，禁止新的IRQ请求，直到中断控制转到相应的流控层后才通过local_irq_enable()打开。那为何还要禁止抢占？这是因为要考虑中断嵌套的问题，一旦流控层或驱动程序主动通过local_irq_enable打开了IRQ，而此时该中断还没处理完成，新的irq请求到达，这时代码会再次进入irq_enter，在本次嵌套中断返回时，内核不希望进行抢占调度，而是要等到最外层的中断处理完成后才做出调度动作，所以才有了禁止抢占这一处理

再调用 generic_handle_irq

最后调用 irq_exit 删除进入硬件中断的标记

__handle_domain_irq -> generic_handle_irq

int generic_handle_irq(unsigned int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc)
		return -EINVAL;
	generic_handle_irq_desc(desc);
	return 0;
}
EXPORT_SYMBOL_GPL(generic_handle_irq);

首先在函数 irq_to_desc 中根据发生中断的中断号，去取出它的 irq_desc 中断描述结构，然后调用 generic_handle_irq_desc：

static inline void generic_handle_irq_desc(struct irq_desc *desc)
{
	desc->handle_irq(desc);
}

这里调用了 handle_irq 函数。

所以，在上述流程中，还需要分析 irq_to_desc  流程：

struct irq_desc *irq_to_desc(unsigned int irq)
{
	return (irq < NR_IRQS) ? irq_desc + irq : NULL;
}
EXPORT_SYMBOL(irq_to_desc);

NR_IRQS 是支持的总的中断个数，当然，irq 不能够大于这个数目。所以返回 irq_desc + irq。

irq_desc 是一个全局的数组：

struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
	[0 ... NR_IRQS-1] = {
		.handle_irq	= handle_bad_irq,
		.depth		= 1,
		.lock		= __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
	}
};

这里是这个数组的初始化的地方。所有的 handle_irq 函数都被初始化成为了 handle_bad_irq。

细心的观众可能发现了，调用这个 desc->handle_irq(desc) 函数，并不是咱们注册进去的中断处理函数啊，因为两个函数的原型定义都不一样。这个 handle_irq 是 irq_flow_handler_t 类型，而我们注册进去的服务程序是 irq_handler_t，这两个明显不是同一个东西，所以这里我们还需要继续分析。

 

6.1 中断相关的数据结构

Linux 中断相关的数据结构有 3 个

结构名称	作用
irq_desc	IRQ 的软件层面上的资源描述
irqaction	IRQ 的通用操作
irq_chip	对应每个芯片的具体实现

 

 

 

 

 

irq_desc 结构如下

struct irq_desc {
	struct irq_common_data	irq_common_data;
	struct irq_data		irq_data;
	unsigned int __percpu	*kstat_irqs;
	irq_flow_handler_t	handle_irq;
#ifdef CONFIG_IRQ_PREFLOW_FASTEOI
	irq_preflow_handler_t	preflow_handler;
#endif
	struct irqaction	*action;	/* IRQ action list */
	unsigned int		status_use_accessors;
	unsigned int		core_internal_state__do_not_mess_with_it;
	unsigned int		depth;		/* nested irq disables */
	unsigned int		wake_depth;	/* nested wake enables */
	unsigned int		irq_count;	/* For detecting broken IRQs */
	unsigned long		last_unhandled;	/* Aging timer for unhandled count */
	unsigned int		irqs_unhandled;
	atomic_t		threads_handled;
	int			threads_handled_last;
	raw_spinlock_t		lock;
	struct cpumask		*percpu_enabled;
	const struct cpumask	*percpu_affinity;
#ifdef CONFIG_SMP
	const struct cpumask	*affinity_hint;
	struct irq_affinity_notify *affinity_notify;
#ifdef CONFIG_GENERIC_PENDING_IRQ
	cpumask_var_t		pending_mask;
#endif
#endif
	unsigned long		threads_oneshot;
	atomic_t		threads_active;
	wait_queue_head_t       wait_for_threads;
#ifdef CONFIG_PM_SLEEP
	unsigned int		nr_actions;
	unsigned int		no_suspend_depth;
	unsigned int		cond_suspend_depth;
	unsigned int		force_resume_depth;
#endif
#ifdef CONFIG_PROC_FS
	struct proc_dir_entry	*dir;
#endif
#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
	struct dentry		*debugfs_file;
	const char		*dev_name;
#endif
#ifdef CONFIG_SPARSE_IRQ
	struct rcu_head		rcu;
	struct kobject		kobj;
#endif
	struct mutex		request_mutex;
	int			parent_irq;
	struct module		*owner;
	const char		*name;
} ____cacheline_internodealigned_in_smp;

 

irqaction 结构如下：

/**
 * struct irqaction - per interrupt action descriptor
 * @handler:	interrupt handler function
 * @name:	name of the device
 * @dev_id:	cookie to identify the device
 * @percpu_dev_id:	cookie to identify the device
 * @next:	pointer to the next irqaction for shared interrupts
 * @irq:	interrupt number
 * @flags:	flags (see IRQF_* above)
 * @thread_fn:	interrupt handler function for threaded interrupts
 * @thread:	thread pointer for threaded interrupts
 * @secondary:	pointer to secondary irqaction (force threading)
 * @thread_flags:	flags related to @thread
 * @thread_mask:	bitmask for keeping track of @thread activity
 * @dir:	pointer to the proc/irq/NN/name entry
 */
struct irqaction {
	irq_handler_t		handler;
	void			*dev_id;
	void __percpu		*percpu_dev_id;
	struct irqaction	*next;
	irq_handler_t		thread_fn;
	struct task_struct	*thread;
	struct irqaction	*secondary;
	unsigned int		irq;
	unsigned int		flags;
	unsigned long		thread_flags;
	unsigned long		thread_mask;
	const char		*name;
	struct proc_dir_entry	*dir;
} ____cacheline_internodealigned_in_smp;

 

irq_chip 描述如下：

/**
 * struct irq_chip - hardware interrupt chip descriptor
 *
 * @parent_device:	pointer to parent device for irqchip
 * @name:		name for /proc/interrupts
 * @irq_startup:	start up the interrupt (defaults to ->enable if NULL)
 * @irq_shutdown:	shut down the interrupt (defaults to ->disable if NULL)
 * @irq_enable:		enable the interrupt (defaults to chip->unmask if NULL)
 * @irq_disable:	disable the interrupt
 * @irq_ack:		start of a new interrupt
 * @irq_mask:		mask an interrupt source
 * @irq_mask_ack:	ack and mask an interrupt source
 * @irq_unmask:		unmask an interrupt source
 * @irq_eoi:		end of interrupt
 * @irq_set_affinity:	Set the CPU affinity on SMP machines. If the force
 *			argument is true, it tells the driver to
 *			unconditionally apply the affinity setting. Sanity
 *			checks against the supplied affinity mask are not
 *			required. This is used for CPU hotplug where the
 *			target CPU is not yet set in the cpu_online_mask.
 * @irq_retrigger:	resend an IRQ to the CPU
 * @irq_set_type:	set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
 * @irq_set_wake:	enable/disable power-management wake-on of an IRQ
 * @irq_bus_lock:	function to lock access to slow bus (i2c) chips
 * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
 * @irq_cpu_online:	configure an interrupt source for a secondary CPU
 * @irq_cpu_offline:	un-configure an interrupt source for a secondary CPU
 * @irq_suspend:	function called from core code on suspend once per
 *			chip, when one or more interrupts are installed
 * @irq_resume:		function called from core code on resume once per chip,
 *			when one ore more interrupts are installed
 * @irq_pm_shutdown:	function called from core code on shutdown once per chip
 * @irq_calc_mask:	Optional function to set irq_data.mask for special cases
 * @irq_print_chip:	optional to print special chip info in show_interrupts
 * @irq_request_resources:	optional to request resources before calling
 *				any other callback related to this irq
 * @irq_release_resources:	optional to release resources acquired with
 *				irq_request_resources
 * @irq_compose_msi_msg:	optional to compose message content for MSI
 * @irq_write_msi_msg:	optional to write message content for MSI
 * @irq_get_irqchip_state:	return the internal state of an interrupt
 * @irq_set_irqchip_state:	set the internal state of a interrupt
 * @irq_set_vcpu_affinity:	optional to target a vCPU in a virtual machine
 * @ipi_send_single:	send a single IPI to destination cpus
 * @ipi_send_mask:	send an IPI to destination cpus in cpumask
 * @flags:		chip specific flags
 */
struct irq_chip {
	struct device	*parent_device;
	const char	*name;
	unsigned int	(*irq_startup)(struct irq_data *data);
	void		(*irq_shutdown)(struct irq_data *data);
	void		(*irq_enable)(struct irq_data *data);
	void		(*irq_disable)(struct irq_data *data);

	void		(*irq_ack)(struct irq_data *data);
	void		(*irq_mask)(struct irq_data *data);
	void		(*irq_mask_ack)(struct irq_data *data);
	void		(*irq_unmask)(struct irq_data *data);
	void		(*irq_eoi)(struct irq_data *data);

	int		(*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);
	int		(*irq_retrigger)(struct irq_data *data);
	int		(*irq_set_type)(struct irq_data *data, unsigned int flow_type);
	int		(*irq_set_wake)(struct irq_data *data, unsigned int on);

	void		(*irq_bus_lock)(struct irq_data *data);
	void		(*irq_bus_sync_unlock)(struct irq_data *data);

	void		(*irq_cpu_online)(struct irq_data *data);
	void		(*irq_cpu_offline)(struct irq_data *data);

	void		(*irq_suspend)(struct irq_data *data);
	void		(*irq_resume)(struct irq_data *data);
	void		(*irq_pm_shutdown)(struct irq_data *data);

	void		(*irq_calc_mask)(struct irq_data *data);

	void		(*irq_print_chip)(struct irq_data *data, struct seq_file *p);
	int		(*irq_request_resources)(struct irq_data *data);
	void		(*irq_release_resources)(struct irq_data *data);

	void		(*irq_compose_msi_msg)(struct irq_data *data, struct msi_msg *msg);
	void		(*irq_write_msi_msg)(struct irq_data *data, struct msi_msg *msg);

	int		(*irq_get_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool *state);
	int		(*irq_set_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool state);

	int		(*irq_set_vcpu_affinity)(struct irq_data *data, void *vcpu_info);

	void		(*ipi_send_single)(struct irq_data *data, unsigned int cpu);
	void		(*ipi_send_mask)(struct irq_data *data, const struct cpumask *dest);

	unsigned long	flags;
};

irq_chip 是一串和芯片相关的函数指针，这里定义的非常的全面，基本上和 IRQ 相关的可能出现的操作都全部定义进去了，具体根据不同的芯片，需要在不同的芯片的地方去初始化这个结构，然后这个结构会嵌入到通用的 IRQ 处理软件中去使用，使得软件处理逻辑和芯片逻辑完全的分开。

好，我们接下来继续前进。

 

6.2 初始化 Chip 相关的 IRQ

众所周知，启动的时候，C 语言从 start_kernel 开始，在这里面，调用了和 machine 相关的 IRQ 的初始化 init_IRQ()：

asmlinkage __visible void __init start_kernel(void)
{
	char *command_line;
	char *after_dashes;

.....

    early_irq_init();
    init_IRQ();

.....

}

在 init_IRQ 中，调用了 machine_desc->init_irq()：

void __init init_IRQ(void)
{
	int ret;

	if (IS_ENABLED(CONFIG_OF) && !machine_desc->init_irq)
		irqchip_init();
	else
		machine_desc->init_irq();

	if (IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_CACHE_L2X0) &&
	    (machine_desc->l2c_aux_mask || machine_desc->l2c_aux_val)) {
		if (!outer_cache.write_sec)
			outer_cache.write_sec = machine_desc->l2c_write_sec;
		ret = l2x0_of_init(machine_desc->l2c_aux_val,
				   machine_desc->l2c_aux_mask);
		if (ret && ret != -ENODEV)
			pr_err("L2C: failed to init: %d\n", ret);
	}

	uniphier_cache_init();
}

machine_desc->init_irq() 完成对中断控制器的初始化，为每个irq_desc结构安装合适的流控handler，为每个irq_desc结构安装irq_chip指针，使他指向正确的中断控制器所对应的irq_chip结构的实例，同时，如果该平台中的中断线有多路复用（多个中断公用一个irq中断线）的情况，还应该初始化irq_desc中相应的字段和标志，以便实现中断控制器的级联。

这里初始化的时候回调用到具体的芯片相关的中断初始化的地方。

例如：

int __init s5p_init_irq_eint(void)
{
	int irq;
 
	for (irq = IRQ_EINT(0); irq <= IRQ_EINT(15); irq++)
		irq_set_chip(irq, &s5p_irq_vic_eint);
 
	for (irq = IRQ_EINT(16); irq <= IRQ_EINT(31); irq++) {
		irq_set_chip_and_handler(irq, &s5p_irq_eint, handle_level_irq);
		set_irq_flags(irq, IRQF_VALID);
	}
 
	irq_set_chained_handler(IRQ_EINT16_31, s5p_irq_demux_eint16_31);
	return 0;
}

而在这些里面，都回去调用类似于：

void
irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
			      irq_flow_handler_t handle, const char *name);

irq_set_handler(unsigned int irq, irq_flow_handler_t handle)
{
	__irq_set_handler(irq, handle, 0, NULL);
}

static inline void
irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)
{
	__irq_set_handler(irq, handle, 1, NULL);
}

void
irq_set_chained_handler_and_data(unsigned int irq, irq_flow_handler_t handle,
				 void *data);

这些函数定义在 include/linux/irq.h 文件。是对芯片初始化的时候可见的 APIs，用于指定中断“流控”中的 ：

irq_flow_handler_t handle

也就是中断来的时候，最后那个函数调用。

中断流控函数，分几种，电平触发的中断，边沿触发的，等：

/*
 * Built-in IRQ handlers for various IRQ types,
 * callable via desc->handle_irq()
 */
extern void handle_level_irq(struct irq_desc *desc);
extern void handle_fasteoi_irq(struct irq_desc *desc);
extern void handle_edge_irq(struct irq_desc *desc);
extern void handle_edge_eoi_irq(struct irq_desc *desc);
extern void handle_simple_irq(struct irq_desc *desc);
extern void handle_untracked_irq(struct irq_desc *desc);
extern void handle_percpu_irq(struct irq_desc *desc);
extern void handle_percpu_devid_irq(struct irq_desc *desc);
extern void handle_bad_irq(struct irq_desc *desc);
extern void handle_nested_irq(unsigned int irq);

而在这些处理函数里，会去调用到 ： handle_irq_event 

比如：

/**
 *	handle_level_irq - Level type irq handler
 *	@desc:	the interrupt description structure for this irq
 *
 *	Level type interrupts are active as long as the hardware line has
 *	the active level. This may require to mask the interrupt and unmask
 *	it after the associated handler has acknowledged the device, so the
 *	interrupt line is back to inactive.
 */
void handle_level_irq(struct irq_desc *desc)
{
	raw_spin_lock(&desc->lock);
	mask_ack_irq(desc);

	if (!irq_may_run(desc))
		goto out_unlock;

	desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);

	/*
	 * If its disabled or no action available
	 * keep it masked and get out of here
	 */
	if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
		desc->istate |= IRQS_PENDING;
		goto out_unlock;
	}

	kstat_incr_irqs_this_cpu(desc);
	handle_irq_event(desc);

	cond_unmask_irq(desc);

out_unlock:
	raw_spin_unlock(&desc->lock);
}

而这个 handle_irq_event 则是调用了处理，handle_irq_event_percpu：

irqreturn_t handle_irq_event(struct irq_desc *desc)
{
	irqreturn_t ret;

	desc->istate &= ~IRQS_PENDING;
	irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
	raw_spin_unlock(&desc->lock);

	ret = handle_irq_event_percpu(desc);

	raw_spin_lock(&desc->lock);
	irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
	return ret;
}

handle_irq_event_percpu->__handle_irq_event_percpu-> 【action->handler()】

这里终于看到了调用 的地方了，就是咱们通过 request_irq 注册进去的函数

 

7. /proc/interrupts

这个 proc 下放置了对应中断号的中断次数和对应的 dev-name

 

中断

为了对计算机的硬件（键盘，硬盘，鼠标，网卡等）进行管理，内核需要和这些硬件通信。一种方式是使用轮询（polling）的方式，这种方式周期性地查看所有硬件设备的状态并做相应处理，这会造成很多不必要的系统开销。Linux内核使用中断的方式来管理硬件设备，中断本质上是一种电信号，设备通过和中断控制器引脚相连的总线发出电信号来发出中断。中断控制器是一种控制芯片，多个设备的中断请求线同时连接到中断控制器上，如果多个设备同时发出中断信号，中断控制器根据优先级选择其中一个发送给处理器处理器，处理器收到中断请求后，就中断当前正在执行的任务，进行中断处理。内核通过中断号（中断号是系统为每个中断请求线interrupt request line分配的编号）来区分不同的设备产生的中断，从而执行对应的中断处理程序。

人们经常把中断和异常（Exception）放在一起讨论，前者是异步中断，后者是同步中断。同步是指在一个处理器指令执行完毕后产生的（是由处理器产生的），异步指的是在任何时候都有可能发生，和处理器是否完成当前指令无关，当然处理器会将正在执行的指令执行完毕才会去检查是否有中断请求。异常又可以分为处理器检测到的异常(Processor-detected exception)和可编程的异常(programmmed exception)，前者又分为fault, trap, abort三种，后者是为了进入内核态（软中断/系统调用）。缺页异常和除以0都属于fault。异常的具体分类在网上看到了很多，各有各的说法，看得我大脑都混乱了，这里的分类参考的是哥伦比亚大学的一份上课PPT的分类法。

中断处理程序

当接收到一个中断时，内核会执行中断处理程序（interrupt handler），每个可以产生中断的设备都有一个对应的中断处理程序。中断处理程序是设备驱动的一部分，中断处理程序的函数声明必须遵照规定的格式，中断处理程序本质上是一个函数，和内核其他函数的区别在于中断处理程序是由内核响应中断时调用的，它运行在一个被称为中断上下文的特殊上下文中。中断上下文中不能被阻塞，所以有时候也会被称为原子上下文。

中断处理程序必须快速地完成执行，这样才能快速地对中断做出响应的同时确保被中断抢占的代码可以尽快地恢复执行。但是中断处理程序往往有大量工作要做，比如网卡的中断处理程序就需要将网络中的数据包从硬件上复制到内存中，处理数据包，最后将数据包交给合适的协议栈或者应用程序。

上半部和下半部

中断程序有两个目标：快速完成执行和处理大量工作。很显然，这两个目标是冲突的。为了能够同时达到这两个目标，对中断的响应被分成了两部分：上半部和下半部。上半部是中断处理程序，上半部在接受到中断请求后立刻执行，但是只处理对时延敏感的任务，如对中断进行应答（通过给中断线置低电平告诉设备处理器已经收到中断了）或者复位硬件。对时延不敏感的任务都被放在了下半部，延后执行（下一篇博文将会介绍下半部）。

还是以网卡为例，网卡收到数据包，发出中断请求，告诉内核收到了数据包。因为网卡上接受数据包的缓冲区大小固定，并且比系统内存小得多，为了避免网卡缓冲区溢出丢包，内核需要快速的完成以下工作：通知网卡中断已经响应（通常是给网卡的寄存器复位）并将数据包拷贝到系统内存，到此中断处理程序（上半部）完成，然后将处理器的使用权交还给内核其他部分（调度程序这个时候就要负责选择下一个执行的进程了，详见Linux内核学习笔记（六）进程调度）

中断处理程序的注册、注销和实现

注册

每个设备都有一个对应的设备驱动，如果该设备使用中断（大部分都会使用），那么设备驱动必须要注册一个中断处理程序。注册中断处理程序的函数是 request_irq()，声明在<linux/interrupt.h>中，声明如下:

/* request_irq: allocate a given interrupt line */
int request_irq(unsigned int irq, irq_handler_t handler,
                unsigned long flags, const char *name, void *dev)

参数irq是对应的终端号。系统时钟和键盘这样的传统PC设备的中断号通常是固定的，对于大部分设备，这个值是动态确定的（通过探测或者编程方式）。
参数handler是一个函数指针，指向要注册的中断处理程序。

参数flags是作为bitmask使用，规定了中断和中断处理程序的一些属性，比较重要的有：

• IRQF_DISABLED 内核在执行该中断处理程序时会禁止所有中断。如果没有这个，内核只会禁止当前的中断处理程序的中断请求线，其他中断请求线仍然可以发出中断，这意味着当前中断处理程序可能会被其他优先级更高的中断请求线的处理程序抢占，这就也叫做中断嵌套。
• IRQF_SAMPLE_RANDOM 该设备产生的中断会为内核熵池（entropy pool）作出贡献，内核熵池负责从各种随机事件（比如中断）中衍生出真正的随机数。
• IRQF_SHARED 这个标志表示该中断线可以被多个中断处理程序共享（即多个设备共用同一个中断线，个人感觉一个设备注册多个共享中断线的中断处理程序也是有可能的，但是估计不会有人这样做）

参数name用于传入设备的名字。

参数dev用于区分共享同一个中断线的多个中断处理程序（注销共享中断线的其中一个中断处理程序时要用到）以及给中断处理程序传递有价值的数据（实践中通常会传递设备驱动用来表示设备的device结构）。

如果irq对应的中断线当前处于禁用状态（说明没有中断处理程序注册在该中断线上），request_irq()还会激活该中断线。因为request_irq()可能阻塞，所以不能在中断上下文（interrupt context，稍后会详细介绍）中调用。并且无论IRQF_DISABLED是否被设置，内核都会禁用当前中断处理程序的中断线，所以共享同一个中断线的中断处理程序不会发生嵌套或者重入（后面有详细讨论）。

注销

当卸载一个设备的时候，需要注销该设备的中断处理程序。注销函数是

void free_irq(unsigned int irq, void *dev)

如果中断号irq对应的中断线不是共享的，free_irq()会将irq的中断处理程序移除，并禁用irq对应的中断线。如果中断号irq是共享的，free_irq()会将dev对应的中断处理程序移除，如果移除的中断处理程序是irq的最后一个中断处理程序，那么free_irq()会同时禁用irq对应的中断线。因为free_irq()可能被阻塞，所以同样不能在中断上下文中调用。

实现

中断处理程序的声明规范如下：

static irqreturn_t intr_handler(int irq, void *dev)

irq是该中断处理程序要处理的中断请求线的中断号。dev和传递给request_irq()的dev是一样的，用于区分共享中断线的中断处理程序。dev可以指向中断处理程序使用的数据结构，通常驱动中用于表示设备的device结构，这样既能保证唯一性，也可以给中断处理程序提供有价值的数据。中断处理程序的返回值irqreturen_t实质上就是int，但是只有两种返回值：IRQ_NONE和IRQ_HANDLED。中断处理程序被调用时如果发现不是自己的设备发出的中断，就会返回IRQ_NONE。如果判断是自己的设备发出的中断时，就会在处理后返回IRQ_HANDLED。

中断处理程序的工作内容完全取决于设备和产生中断的原因，但是一个最基本的任务是告诉设备中断已经被响应（中断应答）。复杂的设备通常需要发送、接受数据以及执行额外的工作。驱动程序的编写者需要决定哪些任务必须放在上半部，哪些任务可以放在下半部，能放在下半部的任务要尽可能地放在下半部。

中断上下文

当执行一个中断处理程序时，内核处于中断上下文（interrupt context）中。与中断上下文相对的是进程上下文，进程上下文是内核所处的工作模式（注意只有在内核态才可能处于进程上下文），在进程上下文中，内核代表进程执行——比如执行系统调用和运行内核线程，此时可以通过current宏访问当前进程。在进程上下文中可以睡眠。（我个人的理解是中断处理不是一个进程，也没有关联的进程，只有关联的中断。而系统调用或者内核线程执行时有关联的进程，所以是在进程上下文中。此外《Linux Kernel Development 3rd》的作者Robert Love在Quora上亲自回答了进程上下文的问题，说得很详细，可以点击去看一下。）

中断上下文不和一个进程关联（虽然current宏指向被中断的进程），因为没有一个后备的关联进程，因为无法被再次调度，所以中断上下文不能睡眠（我个人对此的理解是因为没有关联的进程，所以没有可用于切换时保存上下文数据的对象。那为什么不让中断处理程序关联一个进程呢，因为这样的话，虽然可以切换出去了，但是在中断处理程序（或者说上半部）中的任务是时延敏感的，必须立刻执行完毕，所以不能切换出去，那么也就没必要关联一个进程了）。所以不能在中断上下文中调用可能睡眠的函数，这限制了中断处理程序的能力（可以做的事情）。

中断处理程序使用自己的栈——中断栈（interrupt stack）。中断栈每个处理器一个，栈大小为一个页大小（在32bit机器中通常为4KB)。早起内核版本中，中断程序共用被中断的进程的内核栈。

一个中断处理的详细过程

中断处理程序的实现是和体系结构、处理器、中断控制器类型、机器本身密切相关的，下图展示了从硬件发出中断到中断处理返回的完整流程图

硬件设备通过和中断控制器连接的总线发出电信号来向中断控制器发出中断，如果中断请求线是激活的（中断线是可以被屏蔽的），中断控制器将中断发送给处理器，除非处理器禁用中断了（这也同样是可能的，稍后会说），否则，处理器会在执行完当前指令后，禁用处理器中断，然后跳转到预先设置好的内存位置，并执行那里的代码。这个位置是内核设置的处理中断请求的程序的入口点，入口点是中断在内核中旅行的起点。

入口点会将中断号和被中断进程的寄存器值保存到中断栈中，然后调用do_IRQ()，do_IRQ()从中断栈中提取中断号，然后给该中断线发送一个中断应答信号（其实就是让CPU回送一个低电平的电信号），并禁用该中断线，然后调用handle_IRQ_event()。

handle_IRQ_event()先检查IRQF_DISABLE是否被设置，如果没有设置，就重新打开处理器中断（处理器收到中断后把处理器中断禁用了)，需要注意的是当前的中断线仍然是禁用的。然后handle_IRQ_event()会按序调用注册在该中断线上的所有中断处理程序，每个中断处理程序都要先检查自己的设备是否发出了中断，如果没有立刻返回，返回值为IRQ_NONE，如果有就进行中断处理，最后返回IRQ_HANDLED。通常这种判断是通过查看设备上的状态寄存器来判断的。（补充说明一点：多个设备共享一个中断线时，如果该中断线产生了中断，那么该中断线上可能只有一个设备发出了中断，也有可能有多个设备同时发出了中断（其实就是中断线被置了高电平），所以该中断线上的每个中断处理程序都会被调用一次）

查看中断系统的状态 /proc/interrupts

查看/proc/interrupts可以获得当前系统中注册的中断以及他们的统计信息，包括被注册过的中断号、每个CPU收到的该中断号的次数以及该中断号的中断处理程序的名字、设备的名字。

参考资料

《Linux Kernel Development 3rd Edition》
《Understanding The Linux Kernel 3rd Edition》