中断

中断是外围设备通知处理器的一种机制。

1. 中断控制器

外围设备不是把中断请求直接发送给处理器，而是发给中断控制器，由中断控制器转发给处理器。

不同种类的中断控制器的访问方法存在差异，为了屏蔽差异，内核定义了中断控制器描述符irq_chip，每种中断控制器自定义各种操作函数。GIC v2控制器的描述符如下：

drivers/irqchip/irq-gic.ctatic const struct irq_chip gic_chip = {.irq_mask		= gic_mask_irq,.irq_unmask		= gic_unmask_irq,.irq_eoi		= gic_eoi_irq,.irq_set_type		= gic_set_type,.irq_get_irqchip_state	= gic_irq_get_irqchip_state,.irq_set_irqchip_state	= gic_irq_set_irqchip_state,.flags			= IRQCHIP_SET_TYPE_MASKED |IRQCHIP_SKIP_SET_WAKE |IRQCHIP_MASK_ON_SUSPEND,
};

2. 中断域

一个大型系统可能有多个中断控制器，这些中断控制器可以级联，一个中断控制器作为中断源连接到另一个中断控制器，但只有一个中断控制器作为根控制器直接连接到处理器。为了把每个中断控制器本地的硬件中断映射到全局唯一的Linux中断号（也称为虚拟中断），内核定义了中断域irq_domain，每个中断控制器由自己的中断域。

2.1. 创建中断域

中断控制器的驱动程序使用分配函数irq_domain_add_*()创建和注册中断域。

2.2. 创建映射

创建中断域以后，需要向中断域添加硬件中断号到Linux中断号的映射，内核提供了函数irq_create_mapping：

unsigned int irq_create_mapping(struct irq_domain *host, irq_hw_number_t hwirq);

输入参数是中断域和硬件中断号，返回Linux中断号。

该函数首先分配Linux中断号，然后把硬件中断号到Linux中断号的映射添加到中断域。

2.3. 查找映射

中断处理程序需要根据硬件中断号查找Linux中断号，内核提供了函数irq_find_mapping：

unsigned int irq_find_mapping(struct irq_domain *host, irq_hw_number_t hwirq);

输入参数是中断域和硬件中断号，返回Linux中断号。

3. 中断控制器驱动初始化

3.1. 设备树源文件

ARM64架构使用扁平设备树（Flattened Device Tree，FDT）描述板卡的硬件信息，好处是可以把板卡的特定的代码从内核中删除，编译生成通用的板卡无关的内核。

设备树源文件是文本文件，扩展名是“.dts”，需要在设备树源文件中描述中断的相关信息：

（1）中断控制器的信息

（2）对于作为中断源的外围设备，需要描述设备连接到哪个中断控制器，使用哪个硬件中断号

参考arch/arm64/boot/dts/arm/foundation-v8.dtsi、arch/arm64/boot/dts/arm/foundation-v8-gicv2.dtsi。

3.2. 中断控制器匹配表

在GIC v2控制器的驱动程序中，定义了多个类型为of_device_id的静态变量，成员compatible是驱动程序支持的设备的名称，成员data是初始化函数，编译器把这些静态变量放在专用的节“__irqchip_of_table”里面。

我们把节“__irqchip_of_table”称为中断控制器匹配表，里面每个表项的格式是结构体of_device_id。

drivers/irqchip/irq-gic.cIRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
...
IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
...

把宏IRQCHIP_DECLARE展开以后是：

static const struct of_device_id __of_table_cortex_gic_400__section(__irqchip_of_table)= { .compatible = "arm,gic-g400",	.data = gic_of_init  }
...
static const struct of_device_id __of_table_cortex_a15_gic__section(__irqchip_of_table)= { .compatible = "arm,cortex-a15-gic",	.data = gic_of_init  }
static const struct of_device_id __of_table_cortex_a9_gic__section(__irqchip_of_table)= { .compatible = "arm,cortex-a9-gic",	.data = gic_of_init  }
...

3.3. 初始化

在内核初始化的时候，匹配设备树文件中的中断控制器的属性“compatible”和内核的中断控制器匹配表，找到合适的中断控制器驱动程序，执行驱动程序的初始化函数。

start_kernel()  ->  init_IRQ()  ->  irqchip_init()drivers/irqchip/irqchip.c
void __init irqchip_init(void)
{of_irq_init(__irqchip_of_table);    // 参数是中断控制器匹配表的起始地址__irqchip_of_table...
}

(1)函数of_irq_init

driver/of/irq.c
/*** of_irq_init - Scan and init matching interrupt controllers in DT* @matches: 0 terminated array of nodes to match and init function to call** This function scans the device tree for matching interrupt controller nodes,* and calls their initialization functions in order with parents first.*/
void __init of_irq_init(const struct of_device_id *matches)
{const struct of_device_id *match;struct device_node *np, *parent = NULL;struct of_intc_desc *desc, *temp_desc;struct list_head intc_desc_list, intc_parent_list;INIT_LIST_HEAD(&intc_desc_list);INIT_LIST_HEAD(&intc_parent_list);for_each_matching_node_and_match(np, matches, &match) {		/* 遍历设备树文件的设备节点。如果属性compatible和中断控制器匹配表中的任何一条表项的字段compatible匹配，处理如下 */if (!of_property_read_bool(np, "interrupt-controller") ||!of_device_is_available(np))		/* 如果没有节点属性interrupt-controller，说明设备不是中断控制器，忽略该设备 */continue;if (WARN(!match->data, "of_irq_init: no init function for %s\n",match->compatible))continue;/** Here, we allocate and populate an of_intc_desc with the node* pointer, interrupt-parent device_node etc.*/desc = kzalloc(sizeof(*desc), GFP_KERNEL);		/* 分配一个of_intc_desc实例 */if (WARN_ON(!desc)) {of_node_put(np);goto err;}desc->irq_init_cb = match->data;		/* 成员irq_init_cb保存初始化函数 */desc->dev = of_node_get(np);		/* 成员dev保存本设备的device_node */desc->interrupt_parent = of_irq_find_parent(np);		/* 成员interrupt保存父设备 */if (desc->interrupt_parent == np)desc->interrupt_parent = NULL;list_add_tail(&desc->list, &intc_desc_list);		/* 把of_intc_desc实例添加到链表intc_desc_list中 */}/** The root irq controller is the one without an interrupt-parent.* That one goes first, followed by the controllers that reference it,* followed by the ones that reference the 2nd level controllers, etc.*/while (!list_empty(&intc_desc_list)) {		/* 遍历链表intc_desc_list，从根设备开始，先执行父设备的初始化函数，然后执行子设备的初始化函数 *//** Process all controllers with the current 'parent'.* First pass will be looking for NULL as the parent.* The assumption is that NULL parent means a root controller.*/list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) {int ret;if (desc->interrupt_parent != parent)continue;list_del(&desc->list);of_node_set_flag(desc->dev, OF_POPULATED);pr_debug("of_irq_init: init %pOF (%p), parent %p\n",desc->dev,desc->dev, desc->interrupt_parent);ret = desc->irq_init_cb(desc->dev,desc->interrupt_parent);if (ret) {of_node_clear_flag(desc->dev, OF_POPULATED);kfree(desc);continue;}/** This one is now set up; add it to the parent list so* its children can get processed in a subsequent pass.*/list_add_tail(&desc->list, &intc_parent_list);}/* Get the next pending parent that might have children */desc = list_first_entry_or_null(&intc_parent_list,typeof(*desc), list);if (!desc) {pr_err("of_irq_init: children remain, but no parents\n");break;}list_del(&desc->list);parent = desc->dev;kfree(desc);}list_for_each_entry_safe(desc, temp_desc, &intc_parent_list, list) {list_del(&desc->list);kfree(desc);}
err:list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) {list_del(&desc->list);of_node_put(desc->dev);kfree(desc);}
}

设备树文件“arch/arm64/boot/dts/arm/foundation-v8.dts”里面中断控制器的属性“compatible”是：

compatible = "arm,cortex-a15-gic", "arm,cortex-a9-gic";

和中断控制器匹配表中的

{ .compatible = "arm,cortex-a15-gic", .data = gic_of_init  }
{ .compatible = "arm,cortex-a9-gic", .data = gic_of_init  }

匹配。

(2)gic_of_init

int __init
gic_of_init(struct device_node *node, struct device_node *parent)			/* 参数node是本中断控制器，参数parent是父设备 */
{struct gic_chip_data *gic;int irq, ret;if (WARN_ON(!node))return -ENODEV;if (WARN_ON(gic_cnt >= CONFIG_ARM_GIC_MAX_NR))return -EINVAL;gic = &gic_data[gic_cnt];		/* 从全局数组gic_data取一个空闲的元素来保存本中断控制器的信息 */ret = gic_of_setup(gic, node);		/* 调用函数gic_of_setup：从设备树文件读取中断控制器的属性reg，获取分发器和处理器接口的寄存器的物理地址范围，把物理地址映射到内核的虚拟地址空间 */if (ret)return ret;/** Disable split EOI/Deactivate if either HYP is not available* or the CPU interface is too small.*/if (gic_cnt == 0 && !gic_check_eoimode(node, &gic->raw_cpu_base))static_branch_disable(&supports_deactivate_key);ret = __gic_init_bases(gic, -1, &node->fwnode);		/* 调用函数__gic_init_bases以初始化结构体gic_chip_data */if (ret) {gic_teardown(gic);return ret;}if (!gic_cnt) {gic_init_physaddr(node);gic_of_setup_kvm_info(node);}if (parent) {		/* 如果本中断控制器有父设备，即作为中断源连接到其他中断控制器，处理如下 */irq = irq_of_parse_and_map(node, 0);		/* 调用函数irq_of_parse_and_map：从设备树文件中本设备节点的属性interrupts获取硬件中断号，把硬件中断号映射到Linux中断号n */gic_cascade_irq(gic_cnt, irq);		/* 调用函数gic_cascade_irq：把Linux中断号n中断描述符的成员handle_irq()设置为函数gic_handle_cascade_irq() */}if (IS_ENABLED(CONFIG_ARM_GIC_V2M))gicv2m_init(&node->fwnode, gic_data[gic_cnt].domain);gic_cnt++;return 0;
}

(3)函数__gic_init_bases

static int __init __gic_init_bases(struct gic_chip_data *gic,int irq_start,struct fwnode_handle *handle)
{char *name;int i, ret;if (WARN_ON(!gic || gic->domain))return -EINVAL;if (gic == &gic_data[0]) {		/* 如果本中断控制器是根控制器，处理如下： *//** Initialize the CPU interface map to all CPUs.* It will be refined as each CPU probes its ID.* This is only necessary for the primary GIC.*/for (i = 0; i < NR_GIC_CPU_IF; i++)gic_cpu_map[i] = 0xff;
#ifdef CONFIG_SMPset_smp_cross_call(gic_raise_softirq);		/* 把全局函数指针__smp_cross_call设置为函数gic_raise_softirq */
#endif											/* 用来发送软件生成的中断，即一个处理器向其他处理器发送中断 */cpuhp_setup_state_nocalls(CPUHP_AP_IRQ_GIC_STARTING,"irqchip/arm/gic:starting",gic_starting_cpu, NULL);set_handle_irq(gic_handle_irq);		/* 把全局函数指针handle_arch_irq设置为函数gic_handle_irq，该函数是中断处理程序C语言部分的入口 */if (static_branch_likely(&supports_deactivate_key))pr_info("GIC: Using split EOI/Deactivate mode\n");}/* 调用函数gic_init_chip以初始化中断控制器描述符irq_chip */if (static_branch_likely(&supports_deactivate_key) && gic == &gic_data[0]) {name = kasprintf(GFP_KERNEL, "GICv2");gic_init_chip(gic, NULL, name, true);} else {name = kasprintf(GFP_KERNEL, "GIC-%d", (int)(gic-&gic_data[0]));gic_init_chip(gic, NULL, name, false);}ret = gic_init_bases(gic, irq_start, handle);		/* 调用函数gic_init_bases进行初始化：为本中断控制器分配中断域，初始化中断控制器的分发器的各种寄存器，初始化中断控制器的处理器接口的各种寄存器 */if (ret)kfree(name);return ret;
}

4. Linux中断处理

对于中断控制器的每个中断源，向中断域添加硬件中断号到Linux中断号的映射时，内核分配一个Linux中断号和一个中断描述符irq_desc，中断描述符由两个层次的中断处理函数：

（1）第一层处理函数是中断描述符的成员handle_irq()

（2）第二层处理函数是设备驱动程序注册的处理函数。中断描述符由一个中断处理链表（irq_desc.action），每个中断处理描述符（irq_action）保存设备驱动程序注册的处理函数。因为多个设备可以共享同一个硬件中断号，所以中断处理链表可能挂载多个中断处理描述符。

怎么存储Linux中断号到中断描述符的映射关系？

有两种实现方式：

(1)如果中断编号是稀疏的（即不连续），那么使用基数树（radix tree）存储。需要开启配置宏CONFIG_SPARSE_IRQ。

(2)如果中断编号是连续的，那么使用数组存储。

#ifdef CONFIG_SPARSE_IRQ...
static RADIX_TREE(irq_desc_tree, GFP_KERNEL);
...#else /* !CONFIG_SPARSE_IRQ */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),}
};
...#endif /* !CONFIG_SPARSE_IRQ */

把硬件中断号映射到Linux中断号的时候，根据硬件中断的类型设置中断描述符的成员handle_irq()，以GIC v2控制器为例，函数gic_irq_domain_map所做的处理如下：

irq_create_mapping  ->  irq_domain_associate()  ->  domain->ops->map()  ->  gic_irq_domain_map()drivers/irqchip/irq-gic.c
tatic int gic_irq_domain_map(struct irq_domain *d, unsigned int irq,irq_hw_number_t hw)
{struct gic_chip_data *gic = d->host_data;if (hw < 32) {		/* 如果硬件中断号小于32，说明是软件生成的中断或私有外设中断，那么把终端描述符的成员handle_irq()设置为函数handle_percpu_devid_irq */irq_set_percpu_devid(irq);irq_domain_set_info(d, irq, hw, &gic->chip, d->host_data,handle_percpu_devid_irq, NULL, NULL);irq_set_status_flags(irq, IRQ_NOAUTOEN);} else {		/* 如果硬件中断号大于或等于32，说明共享外设中断，那么把中断描述符的成员handle_irq()设置为函数handle_fasteoi_irq */irq_domain_set_info(d, irq, hw, &gic->chip, d->host_data,handle_fasteoi_irq, NULL, NULL);irq_set_probe(irq);irqd_set_single_target(irq_desc_get_irq_data(irq_to_desc(irq)));}return 0;
}

在ARM64架构下，在异常级别1的异常向量表中，中断的入口有3个：

(1)如果处理器处在内核模式（异常级别1），中断的入口是el1_irq；

(2)如果处理器正在用户模式（异常级别0）下执行64位应用程序，中断的入口是el0_irq；

(3)如果处理器正在用户模式（异常级别0）下执行32位应用程序，中断的入口是el0_irq_compat。

假设处理器正在用户模式（异常级别0）下执行64位应用程序，中断控制器是GIC v2控制器，Linux中断处理流程如下：

函数el0_irq的代码如下：

arch/arm64/kernel/irq.c
/* 每个处理器有一个专用的中断栈 */
DEFINE_PER_CPU(unsigned long *, irq_stack_ptr);arch/arm64/kernel/entry.S
/** Interrupt handling.*/.macro	irq_handlerldr_l	x1, handle_arch_irqmov	x0, spirq_stack_entry		// 从进程的内核栈切换到中断栈blr	x1		// 调用函数指针handle_arch_irq指向的函数irq_stack_exit		// 从中断栈切换到进程的内核栈.endm.align	6
el1_irq:kernel_entry 1enable_da_f
#ifdef CONFIG_TRACE_IRQFLAGSbl	trace_hardirqs_off
#endifirq_handler            // irq_handler是一个宏#ifdef CONFIG_PREEMPTldr	x24, [tsk, #TSK_TI_PREEMPT]	// get preempt count	读取抢占计数cbnz	x24, 1f				// preempt count != 0		抢占计数不等于0bl	el1_preempt
1:
#endif
#ifdef CONFIG_TRACE_IRQFLAGSbl	trace_hardirqs_on
#endifkernel_exit 1
ENDPROC(el1_irq)

在gic_of_init()  ->  __gic_init_bases中初始化了函数handle_arch_irq，GIC v2控制器把该函数指针设置为函数gic_handle_irq。

drivers/irqchip/irq-gic.c
static void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
{u32 irqstat, irqnr;struct gic_chip_data *gic = &gic_data[0];void __iomem *cpu_base = gic_data_cpu_base(gic);do {irqstat = readl_relaxed(cpu_base + GIC_CPU_INTACK);		/* 读取处理器接口的中断确认寄存器得到中断号 */irqnr = irqstat & GICC_IAR_INT_ID_MASK;if (likely(irqnr > 15 && irqnr < 1020)) {		/* 如果硬件中断号大于15且小于1020，即中断是由外围设备发送的 */if (static_branch_likely(&supports_deactivate_key))		/* 把中断号写到处理器接口的中断结束寄存器中，指示中断处理完成 */writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);		isb();handle_domain_irq(gic->domain, irqnr, regs);		/* 如果是私有外设中断，那么中断描述符的成员handle_irq()是函数handle_percpu_devid_irq； */continue;					        /* 如果是共享外设中断，那么中断描述符的成员handle_irq()是函数handle_fasteoi_irq */}if (irqnr < 16) {		/* 如果硬件中断号小于16，即软件生成的中断 */writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);if (static_branch_likely(&supports_deactivate_key))		/* 把中断号写到处理器接口的中断结束寄存器中，指示中断处理完成 */writel_relaxed(irqstat, cpu_base + GIC_CPU_DEACTIVATE);
#ifdef CONFIG_SMP/** Ensure any shared data written by the CPU sending* the IPI is read after we've read the ACK register* on the GIC.** Pairs with the write barrier in gic_raise_softirq*/smp_rmb();handle_IPI(irqnr, regs);
#endifcontinue;}break;} while (1);
}

函数handle_domain_irq()：

include/linux/irqdesc.h
static inline void generic_handle_irq_desc(struct irq_desc *desc)
{desc->handle_irq(desc);
}kernel/irq/irqdesc.c
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;
}kernel/irq/irqdesc.c
#ifdef CONFIG_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_DOMAINif (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;
}
#endifinclude/linux/irqdesc.h
static inline int handle_domain_irq(struct irq_domain *domain,unsigned int hwirq, struct pt_regs *regs)
{return __handle_domain_irq(domain, hwirq, true, regs);
}

如果是私有外设中断，那么中断描述符的成员handle_irq()是函数handle_percpu_devid_irq，其代码如下：

kernel/irq/chip.c
void handle_percpu_devid_irq(struct irq_desc *desc)
{struct irq_chip *chip = irq_desc_get_chip(desc);struct irqaction *action = desc->action;unsigned int irq = irq_desc_get_irq(desc);irqreturn_t res;...if (chip->irq_ack)chip->irq_ack(&desc->irq_data);if (likely(action)) {...res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));...} else {...}if (chip->irq_eoi)chip->irq_eoi(&desc->irq_data);
}

如果是共享外设中断，那么中断描述符的成员handle_irq()是函数handle_fasteoi_irq，其代码如下：

kernel/irq/chip.c
void handle_fasteoi_irq(struct irq_desc *desc)
{struct irq_chip *chip = desc->irq_data.chip;raw_spin_lock(&desc->lock);if (!irq_may_run(desc))goto out;desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);/** If its disabled or no action available* then mask it and get out of here:*/if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {desc->istate |= IRQS_PENDING;mask_irq(desc);goto out;}kstat_incr_irqs_this_cpu(desc);if (desc->istate & IRQS_ONESHOT)mask_irq(desc);preflow_handler(desc);handle_irq_event(desc);		/* 调用函数handle_irq_event执行设备驱动程序注册的处理函数 */cond_unmask_eoi_irq(desc, chip);raw_spin_unlock(&desc->lock);return;
out:if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))chip->irq_eoi(&desc->irq_data);raw_spin_unlock(&desc->lock);
}

函数handle_irq_event把主要工作委托给函数__handle_irq_event_percpu。函数__handle_irq_event_percpu遍历中断描述符的中断处理链表，执行每个中断处理描述符的处理函数，其代码如下：

handle_irq_event()  ->  handle_irq_event_percpu()  ->  __handle_irq_event_percpu()kernel/irq/handle.c
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{irqreturn_t retval = IRQ_NONE;unsigned int irq = desc->irq_data.irq;struct irqaction *action;/* 遍历中断描述符的的中断处理链表，执行每个中断处理描述符的处理函数 */record_irq_time(desc);for_each_action_of_desc(desc, action) {		irqreturn_t res;trace_irq_handler_entry(irq, action);res = action->handler(irq, action->dev_id);trace_irq_handler_exit(irq, action, res);if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",irq, action->handler))local_irq_disable();switch (res) {case IRQ_WAKE_THREAD:/** Catch drivers which return WAKE_THREAD but* did not set up a thread function*/if (unlikely(!action->thread_fn)) {warn_no_thread(irq, action);break;}__irq_wake_thread(desc, action);/* 继续往下走，把action->flags作为生成随机数的一个因子 *//* Fall through to add to randomness */case IRQ_HANDLED:*flags |= action->flags;break;default:break;}retval |= res;}return retval;
}

5. 中断线程化

中断线程化就是使用内核线程处理中断，目的是减少系统关中断的时间，增强系统的实时性。内核提供的函数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)

参数thread_fn是线程处理函数。

少数中断不能线程化，典型的例子是时钟中断，有些流氓进程不主动让出处理器，内核只能依靠周期性的时钟中断夺回处理器的控制权，时钟中断是调度器的脉搏。对于不能线程化的中断，注册处理函数的时候必须设置标志IRQF_NO_THREAD。

如果开启了强制中断线程化的配置宏CONFIG_IRQ_FORCED_THREADING，并且在引导内核的时候指定内核参数“threadirqs”，那么强制除了标记IRQF_NO_THREAD以外的所有中断线程化。

每个中断描述符（irqaction）对应一个内核线程，其代码如下：

include/linux/interrupt.h
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;

request_threaded_irq()  ->  __setup_irq()  ->  setup_irq_thread()kernel/irq/manage.c
static int
setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
{struct task_struct *t;struct sched_param param = {.sched_priority = MAX_USER_RT_PRIO/2,		/*  */};if (!secondary) {t = kthread_create(irq_thread, new, "irq/%d-%s", irq,new->name);		/* 名称是“irq/”后面跟着Linux中断号，线程处理函数是irq_thread() */} else {t = kthread_create(irq_thread, new, "irq/%d-s-%s", irq,new->name);param.sched_priority -= 1;}if (IS_ERR(t))return PTR_ERR(t);sched_setscheduler_nocheck(t, SCHED_FIFO, &param);		/* 中断处理线程是优先级为50、调度策略是SCHED_FIFO的实时内核线程 *//** We keep the reference to the task struct even if* the thread dies to avoid that the interrupt code* references an already freed task_struct.*/get_task_struct(t);new->thread = t;/** Tell the thread to set its affinity. This is* important for shared interrupt handlers as we do* not invoke setup_affinity() for the secondary* handlers as everything is already set up. Even for* interrupts marked with IRQF_NO_BALANCE this is* correct as we want the thread to move to the cpu(s)* on which the requesting code placed the interrupt.*/set_bit(IRQTF_AFFINITY, &new->thread_flags);return 0;
}

在中断处理程序中，函数__handle_irq_event_percpu遍历中断描述符的中断处理链表，执行每个中断处理描述符的处理函数。如果返回IRQ_WAKE_THREAD，说明是线程化的中断，那么唤醒中断处理线程。

中断处理线程的处理函数是irq_thread()，调用函数irq_thread_fn()，然后函数irq_thread_fn()调用注册的线程处理函数。

kernel/irq/manage.cstatic irqreturn_t irq_thread_fn(struct irq_desc *desc,struct irqaction *action)
{irqreturn_t ret;ret = action->thread_fn(action->irq, action->dev_id);if (ret == IRQ_HANDLED)atomic_inc(&desc->threads_handled);irq_finalize_oneshot(desc, action);return ret;
}static int irq_thread(void *data)
{struct callback_head on_exit_work;struct irqaction *action = data;struct irq_desc *desc = irq_to_desc(action->irq);irqreturn_t (*handler_fn)(struct irq_desc *desc,struct irqaction *action);if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,&action->thread_flags))handler_fn = irq_forced_thread_fn;elsehandler_fn = irq_thread_fn;init_task_work(&on_exit_work, irq_thread_dtor);task_work_add(current, &on_exit_work, false);irq_thread_check_affinity(desc, action);while (!irq_wait_for_interrupt(action)) {irqreturn_t action_ret;irq_thread_check_affinity(desc, action);action_ret = handler_fn(desc, action);if (action_ret == IRQ_WAKE_THREAD)irq_wake_secondary(desc, action);wake_threads_waitq(desc);}/** This is the regular exit path. __free_irq() is stopping the* thread via kthread_stop() after calling* synchronize_hardirq(). So neither IRQTF_RUNTHREAD nor the* oneshot mask bit can be set.*/task_work_cancel(current, irq_thread_dtor);return 0;
}

6. 禁止/开启中断

禁止中断接口：

（1）local_irq_disable()

（2）local_irq_save(flags)：首先把中断状态保存在参数flags中，然后禁止中断

这两个接口只能禁止本处理器的中断，不能禁止其他处理器的中断。

开启中断接口：

（1）local_irq_enable()

（2）local_irq_restore(flags)：恢复本处理器的中断状态

local_irq_disable()和local_irq_enable()不能嵌套使用，local_irq_save(flags)和local_irq_restore(flags)可以嵌套使用。

7. 禁止/开启单个中断

禁止中断的函数是：void disable_irq(unsigned int irq)，参数irq是Linux中断号

开启中断的函数是：void enable_irq(unsigned int irq)，参数irq是Linux中断号

8. 中断亲和性

在多处理器系统中，管理员可以设置中断亲和性，允许中断控制器把某个中断转发给哪些处理器，有两种配置方法：

（1）写文件“/proc/irq/IRQ#/smp_affinity”，参数是位掩码

（2）写文件“/proc/irq/IRQ#/smp_affinity_list”，参数是处理器列表

内核提供了设置中断亲和性的函数：

int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)

参数irq是Linux中断号，参数cpumask是处理器位掩码。

9. 处理器间中断

处理器间中断（Inter-Processor Interrupt，IPI）是一种特殊的中断，在多处理器系统中，一个处理器可以向其他处理器发送中断，要求目标处理器执行某件事情。

常见的使用处理器间中断的函数如下：

（1）在所有处理器上执行同一个函数：

int up_smp_call_function(smp_call_func_t func, void *info， int wait);

（2）在指定的处理器上执行一个函数

int smp_call_function_single(int cpuid, smp_call_func_t func, void *info, int wait);

（3）要求指定的处理器重新调度进程

void smp_send_reschedule(int cpu);

对于ARM64架构的GIC控制器，把处理器间生成的中断称为软件生成的中断。

函数handle_IPI负责处理处理器减中断，参数ipinr是硬件中断号，其代码如下：

arch/arm64/kernel/smp.c
void handle_IPI(int ipinr, struct pt_regs *regs)
{unsigned int cpu = smp_processor_id();struct pt_regs *old_regs = set_irq_regs(regs);if ((unsigned)ipinr < NR_IPI) {trace_ipi_entry_rcuidle(ipi_types[ipinr]);__inc_irq_stat(cpu, ipi_irqs[ipinr]);}/* 目前支持7种处理间中断 */switch (ipinr) {case IPI_RESCHEDULE:		/* 硬件中断号是0，重新调度进程，函数smp_send_reschedule()生成的中断 */scheduler_ipi();break;case IPI_CALL_FUNC:		/* 硬件中断号是1，执行函数，函数smp_call_function生成的中断 */irq_enter();generic_smp_call_function_interrupt();irq_exit();break;case IPI_CPU_STOP:		/* 硬件中断号是2，使处理器停止，函数smp_send_stop()生成的中断 */irq_enter();ipi_cpu_stop(cpu);irq_exit();break;case IPI_CPU_CRASH_STOP:		/* 硬件中断号是3，使处理器停止，函数smp_send_crash_stop()生成的中断 */if (IS_ENABLED(CONFIG_KEXEC_CORE)) {irq_enter();ipi_cpu_crash_stop(cpu, regs);unreachable();}break;#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCASTcase IPI_TIMER:		/* 硬件中断号是4，广播的时钟事件，函数tick_broadcast()生成的中断 */irq_enter();tick_receive_broadcast();irq_exit();break;
#endif#ifdef CONFIG_IRQ_WORKcase IPI_IRQ_WORK:		/* 硬件中断号是5，在硬中断上下文中执行回调函数，函数irq_work_queue()生成的中断 */irq_enter();irq_work_run();irq_exit();break;
#endif#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOLcase IPI_WAKEUP:		/* 硬件中断号是6，唤醒处理器，函数acpi_parking_protocol_cpu_boot()生成的中断 */WARN_ONCE(!acpi_parking_protocol_valid(cpu),"CPU%u: Wake-up IPI outside the ACPI parking protocol\n",cpu);break;
#endifdefault:pr_crit("CPU%u: Unknown IPI message 0x%x\n", cpu, ipinr);break;}if ((unsigned)ipinr < NR_IPI)trace_ipi_exit_rcuidle(ipi_types[ipinr]);set_irq_regs(old_regs);
}