三、arm32中断处理软件子系统
中断软件子系统负责cpu检测到中断以后的处理，总体来看，可以分为三个部分：中断向量函数、中断控制器驱动部分以及用户接口部分；
中断向量函数放在中断向量表里面，每一种中断对应一个中断向量函数，软件在初始化时需要创建一个中断向量表，放在内存中并通过协处理器cp15告诉cpu中断向量表的位置；cpu检测到中断后，会自动将处理器模式切换到对应的中断模式，然后将pc指向对应的中断向量函数。中断向量函数中会将处理器模式切换到svc模式，将被中断前处理器的硬件上下文保存起来，然后跳转到中断控制器驱动注册的处理函数，至此，中断传递到中断控制器驱动；
中断控制器驱动负责管理所有类型的中断，包括外设中断、SMP核间中断以及cpu热插拔等中断；向下提供中断控制器操作接口，向上提供用户处理中断的各种接口；
最后是上层用户接口，上层通过中断控制器提供的接口注册回调函数处理中断事件；
3.1 中断向量表
由于arm处理器处理中断的方式：cpu执行完当前指令，检测到中断后，会自动将工作模式切换到对应的中断模式，然后将pc指向中断向量表中对应中断的中断向量。
因此，软件需要创建一个中断向量表，并通过设置协处理器cp15告诉cpu中断向量表的位置。
中断向量表定义在entry-armv.S文件中：
.L__vectors_start:
W(b) vector_rst
W(b) vector_und
W(ldr) pc, .L__vectors_start + 0x1000
W(b) vector_pabt
W(b) vector_dabt
W(b) vector_addrexcptn
W(b) vector_irq
W(b) vector_fiq
__vectors_start的地址定义在vmlinux.lds.S文件中，这个是默认地址，内核初始化过程中会重新设置
__vectors_start = .;
.vectors 0xffff0000 : AT(__vectors_start) {
*(.vectors)
}
. = __vectors_start + SIZEOF(.vectors);
__vectors_end = .;
__stubs_start = .;
.stubs ADDR(.vectors) + 0x1000 : AT(__stubs_start) {
*(.stubs)
}
. = __stubs_start + SIZEOF(.stubs);
__stubs_end = .;
devicemaps_init函数中会申请内存，并将中断向量表拷贝到内存，然后，根据协处理器cp15的寄存器C1的bit[13]是否被置1，将中断向量表的物理地址映射到0xffff0000或者0x0，详细函数调用流程如下图所示：
3.2 中断向量函数的实现
中断向量表中的跳转函数都通过.macro vector_stub, name, mode, correction=0宏进行定义，该宏具体如下：
/*
* Vector stubs.
*
* This code is copied to 0xffff1000 so we can use branches in the
* vectors, rather than ldr's. Note that this code must not exceed
* a page size.
*
* Common stub entry macro:
* Enter in IRQ mode, spsr = SVC/USR CPSR, lr = SVC/USR PC
*
* SP points to a minimal amount of processor-private memory, the address
* of which is copied into r0 for the mode specific abort handler.
*/
.macro vector_stub, name, mode, correction=0
.align 5
vector_/name:
.if /correction
sub lr, lr, #/correction
.endif
@
@ Save r0, lr_<exception> (parent PC) and spsr_<exception>
@ (parent CPSR)
@
stmia sp, {r0, lr} @ save r0, lr
mrs lr, spsr
str lr, [sp, #8] @ save spsr
@
@ Prepare for SVC32 mode. IRQs remain disabled.
@
mrs r0, cpsr
eor r0, r0, #(/mode ^ SVC_MODE | PSR_ISETSTATE)
msr spsr_cxsf, r0
@
@ the branch table must immediately follow this code
@
and lr, lr, #0x0f
THUMB( adr r0, 1f )
THUMB( ldr lr, [r0, lr, lsl #2] )
mov r0, sp
ARM( ldr lr, [pc, lr, lsl #2] )
movs pc, lr @ branch to handler in SVC mode
ENDPROC(vector_/name)
以IRQ中断向量vector_irq为例，通过vector_stub irq, IRQ_MODE, 4宏定义，如下：
/*
* Interrupt dispatcher
*/
vector_stub irq, IRQ_MODE, 4
.long __irq_usr @ 0 (USR_26 / USR_32)
.long __irq_invalid @ 1 (FIQ_26 / FIQ_32)
.long __irq_invalid @ 2 (IRQ_26 / IRQ_32)
.long __irq_svc @ 3 (SVC_26 / SVC_32)
.long __irq_invalid @ 4
.long __irq_invalid @ 5
.long __irq_invalid @ 6
.long __irq_invalid @ 7
.long __irq_invalid @ 8
.long __irq_invalid @ 9
.long __irq_invalid @ a
.long __irq_invalid @ b
.long __irq_invalid @ c
.long __irq_invalid @ d
.long __irq_invalid @ e
.long __irq_invalid @ f
于是，IRQ中断产生后就跳转到vector_stub irq, IRQ_MODE, 4。
以程序工作在用户模式时被中断为例，在vector_irq函数中，会将处理器的运行模式切换到SVC模式，然后，进入__irq_svc，保存处理器被中断前的硬件上下文，最后，跳转到中断控制器驱动初始化时绑定的中断入口函数handle_arch_irq（进入这个函数时，cpu本地中断处于屏蔽状态），具体内容如下表：
/* 将r0、lr寄存器（lr就是被中断的下一条指令）以及spsr（用户模式的cpsr）保存到irq模式的栈 */
stmia sp, {r0, lr}
mrs lr, spsr --- /* 此时lr保存的是spsr，也就是用户模式的cpsr，也就是被中断前处理器所处的模式 */
str lr, [sp, #8]
/* 将spsr寄存器修改为svc模式，为切换到管理模式做准备 */
mrs r0, cpsr --- /* 此时中断模式的CPSR，中断还是屏蔽状态 */
eor r0, r0, #(/mode ^ SVC_MODE | PSR_ISETSTATE)
msr spsr_cxsf, r0
/* 获取被中断前处理器所处的模式 */
and lr, lr, #0x0f
THUMB(adr r0, 1f)
THUMB(ldr lr, [r0, lr, lsl #2])
/* 让r0寄存器指向中断模式下堆栈的基地址 */
mov r0, sp
/* 将lr设置为__irq_usr（此时的lr只是作为临时寄存器使用），然后跳转到__irq_usr */
ARM(ldr lr, [pc, lr, lsl #2])
movs pc, lr --- /* movs指令会同时将spsr_irq赋值给cpsr，从而实现向svc模式切换 */
__irq_usr:
/* usr_entry进行irq_handler前，硬件上下文的保存*/
sub sp, sp, #S_FRAME_SIZE --- /* 分配svc模式的栈 */
/* r0-r12是所有模式公共的，保存到栈 */
ARM(stmib sp, {r1 - r12})
THUMB(stmia sp, {r0 - r12})
/* 将之前保存在中断模式堆栈中的r0_usr,lr,spsr分别存储到r3-r5中 --- 当前r0是中断模式堆栈的基地址 */
ldmia r0, {r3 - r5}
add r0, sp, #S_PC
mov r6, #-1
/* 保存用户模式下的sp_usr,lr_usr */
stmia r0, {r4 - r6}
ARM(stmdb r0, {sp, lr}^)
THUMB(store_user_sp_lr r0, r1, S_SP - S_PC)
/* 进入irq_handler */
irq_handler
/*
* Interrupt handling.
*/
.macro irq_handler
#ifdef CONFIG_MULTI_IRQ_HANDLER
ldr r1, =handle_arch_irq --- /* 然后，进入这个函数执行 */
mov r0, sp
badr lr, 9997f
ldr pc, [r1]
#else
arch_irq_handler_default
#endif
9997:
.endm
/* 恢复用户模式 */
b ret_to_user_from_irq
3.3 中断控制器驱动
3.3.1 中断控制器驱动初始化
如上图所示，中断控制器驱动主要围绕struct gic_chip_data结构体进行；该结构体中包含两个主要的结构体struct irq_chip和struct irq_domain，其中，struct irq_chip用来表示中断控制器芯片，一个系统中可能使用多片中断控制器，一片中断控制器用一个struct irq_chip结构体表示，这个结构体里面填充了中断控制器的操作函数，比如irq_enable和irq_disable；struct irq_domain用于硬件中断号和虚拟中断号的管理。
中断控制器驱动，主要完成如下3部分功能：
1. 将上层的中断处理函数绑定给中断向量里面的回调函数，比如为IRQ中断向量中的回调函数handle_arch_irq绑定为gic_handle_irq，还有SMP核间交互的回调函数gic_raise_softirq以及cpu热插拔的回调函数gic_starting_cpu；
2. 提供中断控制器芯片的操作接口给上层模块调用；
3. 中断控制器中每个中断以实际的硬件中断号标识，linux内核对每个中断以虚拟中断号标识，因此中断控制器驱动还要管理硬件中断号和虚拟中断号之间的映射。
中断控制器的初始化流程如下图所示：
中断控制器驱动初始化的入口函数是gic_of_init，这个函数放在IRQCHIP_DECLARE宏里面，内核对每一种中断控制器都声明一个IRQCHIP_DECLARE宏，如下，宏里面包含的compatible字段和中断控制器初始化入口函数，of_irq_init(__irqchip_of_table)函数中，将设备树中中断控制器节点的compatible字段和这些宏的compatible比较，找到该中断控制器对应的IRQCHIP_DECLARE宏，然后调用里面的回调函数gic_of_init进行中断控制器驱动的初始化；itop4412中断控制器的设备树节点如下，compatible字段是”arm,cortex-a9-gic”，于是和IRQCHIP_DECLARE(cortex_a9_gic, “arm,cortex-a9-gic”, gic_of_init)匹配。
IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init); IRQCHIP_DECLARE(arm11mp_gic, "arm,arm11mp-gic", gic_of_init); IRQCHIP_DECLARE(arm1176jzf_dc_gic, "arm,arm1176jzf-devchip-gic", 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(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init); IRQCHIP_DECLARE(msm_8660_qgic, "qcom,msm-8660-qgic", gic_of_init); IRQCHIP_DECLARE(msm_qgic2, "qcom,msm-qgic2", gic_of_init); IRQCHIP_DECLARE(pl390, "arm,pl390", gic_of_init);
itop4412中断控制器设备树节点：
gic: interrupt-controller@10490000 {
compatible = "arm,cortex-a9-gic";
#interrupt-cells = <3>;
interrupt-controller;
reg = <0x10490000 0x10000>, <0x10480000 0x10000>;
};
3.3.2 中断管理
每个硬件中断在中断控制器中有个固定的硬件中断号，在linux内核中对应一个虚拟中断号，多个外设可以共享一条硬件中断线，那么一个虚拟中断号就可以挂接多个中断处理函数以对应多个外设。
每个硬件中断用中断描述符struct irq_desc描述，这个结构体里面主要包含如下几个内容：
1. struct irq_domain结构体，负责硬件中断号和虚拟中断号的映射管理；
2. struct irq_chip结构体，中断控制器芯片的操作函数；
3. irq_flow_handler_t handle_irq函数，中断产生后，中断向量的回调函数中最终会调用到这个函数；
4. struct irqaction结构体，用户注册中断时，注册接口会创建一个irqaction结构体，将用户注册的中断处理函数绑定到这个结构体，然后放到中断描述符irq_desc的struct irqaction链表里面，当中断产生时，处理函数irq_flow_handler就会遍历这个链表，逐个处理用户注册的中断处理。
用户通过request_irq/request_threaded_irq函数注册中断处理函数，在这个函数里面会根据虚拟中断号获取中断描述符，分配action结构体，并填充，包括中断回调函数、线程回调函数等，进行线程化处理逻辑，如果是非共享中断，进行开中断以及cpu亲和性等处理，然后将action结构体放到中断描述符的链表尾部，最后还会在proc文件系统中添加相关信息，具体过程如下：
/*
* 获取中断描述符
* 分配action结构体，并填充，包括中断回调函数、线程回调函数等
* 创建内核线程
* 如果是非共享中断，进行开中断以及cpu亲和性等处理
* 将action结构体放到中断描述符的链表尾部
* 在proc文件系统中添加相关信息
*/
request_irq
request_threaded_irq
/*
* 虚拟中断号获取中断描述符
*/
desc = irq_to_desc(irq);
/*
* 分配结构体struct irqaction，并填充
*/
action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
action->handler = handler;
action->thread_fn = thread_fn;
action->flags = irqflags;
action->name = devname;
action->dev_id = dev_id;
/*
* __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
* 中断注册主要处理函数
* irq -> 虚拟中断号
* desc -> 中断描述符
* action -> 前面kzalloc分配的结构体
*/
__setup_irq(irq, desc, action)
new->irq = irq;
nested = irq_settings_is_nested_thread(desc);
if (nested)
/* 如果中断绑定在其他中断线程中，需要特别处理 */
new->handler = irq_nested_primary_handler;
else
/* 判断是否能线程化，进行强制线程化处理 */
if (irq_settings_can_thread(desc))
/*
* 强制线程化处理
* 填充前面分配的action结构体
* 创建secondary action
*/
irq_setup_forced_threading(new)
new->flags |= IRQF_ONESHOT;
new->secondary = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
set_bit(IRQTF_FORCED_THREAD, &new->thread_flags);
/*
* 1、将线程回调函数设置成中断处理函数new->handler
* 2、将中断处理函数设置成默认的处理函数irq_default_primary_handler
* ??? 为什么要这样设置？？？
*/
new->thread_fn = new->handler;
new->handler = irq_default_primary_handler;
/*
* 创建一个内核线程
*/
if (new->thread_fn && !nested)
setup_irq_thread(new, irq, false)
t = kthread_create(irq_thread, new, "irq/%d-%s", irq, new->name);
/* 设置线程的调度策略 */
sched_setscheduler_nocheck(t, SCHED_FIFO, ¶m);
/*
* 中断描述符的action链表为空，也就是第一次挂接action，需要分配资源
*/
if (!desc->action)
irq_request_resources(desc)
struct irq_data *d = &desc->irq_data;
struct irq_chip *c = d->chip;
/* 调用gic驱动的回调函数申请资源 */
c->irq_request_resources ? c->irq_request_resources(d) : 0;
/*
* 共享中断
* 在已经挂接action的情况下，将当前action挂接到链表中
*/
old_ptr = &desc->action;
old = *old_ptr;
if (old)
do {
/*
* Or all existing action->thread_mask bits,
* so we can find the next zero bit for this
* new action.
*/
thread_mask |= old->thread_mask;
old_ptr = &old->next;
old = *old_ptr;
} while (old); --- /* 循环结束后，old指向链表尾部，指针内容为NULL */
shared = 1;
/*
* 非共享中断要特殊处理
*/
if (!shared)
init_waitqueue_head(&desc->wait_for_threads);
__irq_set_trigger(desc, new->flags & IRQF_TRIGGER_MASK);
irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
if (new->flags & IRQF_PERCPU)
irqd_set(&desc->irq_data, IRQD_PER_CPU);
irq_settings_set_per_cpu(desc);
/* Exclude IRQ from balancing if requested */
if (new->flags & IRQF_NOBALANCING)
irq_settings_set_no_balancing(desc);
irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
if (irq_settings_can_autoenable(desc))
/*
* 开启中断，并进行亲和性设置
*/
irq_startup(desc, IRQ_RESEND, IRQ_START_COND)
if (irqd_is_started(d)) {
irq_enable(desc);
} else {
switch (__irq_startup_managed(desc, aff, force)) {
case IRQ_STARTUP_NORMAL:
ret = __irq_startup(desc);
irq_setup_affinity(desc);
break;
case IRQ_STARTUP_MANAGED:
irq_do_set_affinity(d, aff, false);
ret = __irq_startup(desc);
break;
case IRQ_STARTUP_ABORT:
return 0;
}
}
/* 将action结构体放到中断描述符链表的尾部 */
*old_ptr = new;
/*
* 将内核线程设置为可执行状态
*/
wake_up_process(new->thread);
/* 在proc文件系统中添加相关信息 */
register_irq_proc(irq, desc);
irq_add_debugfs_entry(irq, desc);
new->dir = NULL;
register_handler_proc(irq, new);
3.4 完整的中断处理流程
处理器检测到中断后，会将工作模式切换到对应的中断模式，然后将pc指向中断向量，从而跳转到中断向量执行；在中断向量中，软件会将工作模式切换到SVC模式，保存硬件上下文，然后跳转到控制器驱动初始化时注册的回调函数；在这个回调函数里面会通过硬件中断号找到对应的虚拟中断号，从而找到该中断对应的中断描述符irq_desc；最后依次调用中断描述符irq_desc中用户注册的中断处理函数。
以处理器工作在用户模式被IRQ中断为例，具体流程如下：
1. 处理器切换到IRQ中断模式，跳转到中断向量vector_irq
W(b) vector_irq
Vector_irq展开后为宏定义vector_stub irq, IRQ_MODE, 4
2. 在vector_irq中，将处理器模式切换到SVC模式（需要指出的时，此时的IRQ中断通过CPSR寄存器被屏蔽掉了），跳转到__irq_usr
将lr设置为__irq_usr（此时的lr只是作为临时寄存器使用），然后跳转到__irq_usr
ARM(ldr lr, [pc, lr, lsl #2])
movs pc, lr --- movs指令会同时将spsr_irq赋值给cpsr，从而实现向svc模式切换
3. 在__irq_usr中，调用irq_handler，然后，在irq_handler里面跳转到handle_arch_irq，handle_arch_irq这个函数指针在中断控制器驱动初始化的时候被赋值为gic_handle_irq
set_handle_irq(gic_handle_irq)
void __init set_handle_irq(void (*handle_irq)(struct pt_regs *))
handle_arch_irq = handle_irq;
4. gic_handle_irq这个函数里面会进行循环处理完所有待处理的中断，
从中断控制器的寄存器读取硬件中断号，
irqstat = readl_relaxed(cpu_base + GIC_CPU_INTACK);
irqnr = irqstat & GICC_IAR_INT_ID_MASK;
当硬件中断号小于16，表示核间IPI中断，调用handle_IPI
if (irqnr < 16) {
writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
if (static_key_true(&supports_deactivate))
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);
#endif
continue;
}
当硬件中断号大于15小于1020，表示共享和CPU私有中断，调用handle_domain_irq
if (likely(irqnr > 15 && irqnr < 1020)) {
if (static_key_true(&supports_deactivate))
writel_relaxed(irqstat, cpu_base + GIC_CPU_EOI);
isb();
handle_domain_irq(gic->domain, irqnr, regs);
continue;
}
当读取的硬件中断号无效，则退出while循环
5. IRQ中断，进入handle_domain_irq函数
6. handle_domain_irq函数中，首先会调用irq_enter函数进入中断上下文
irq_enter();
7. irq_enter函数，将处理器preempt_count变量的HARDIRQ部分+1表示进入硬件中断上下文；系统会根据preempt_count变量来判断是否可以调度及抢占，只有preempt_count值为0时，才可以调度和抢占；那么handle_domain_irq函数在退出前，系统一直处于不可抢占状态，那么当前中断就一直使用被中断进程的上下文，比如内核栈、current以及preempt_count等都一直是被中断进程的上下文
#define __irq_enter() /
do { /
account_irq_enter_time(current); /
preempt_count_add(HARDIRQ_OFFSET); /
trace_hardirq_enter(); /
} while (0)
8. 取出虚拟中断号
irq = irq_find_mapping(domain, hwirq)
9. 进一步调用上层的处理函数generic_handle_irq
10. 通过generic_handle_irq_desc调用中断描述符的handle_irq，在建立硬件中断号和虚拟中断号的映射关系时，gic_irq_domain_map函数中给handle_irq绑定了处理函数，
硬件中断号小于32时，handle_irq被绑定为handle_percpu_devid_irq
if (hw < 32) {
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);
}
硬件中断号大于等于32时，handle_irq被绑定为handle_fasteoi_irq
irq_domain_set_info(d, irq, hw, &gic->chip, d->host_data,
handle_fasteoi_irq, NULL, NULL);
11. 进入handle_fasteoi_irq函数，使用raw_spin_lock对中断描述符访问加自旋锁
raw_spin_lock(&desc->lock);
修改中断状态
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
12. 如果用户没有注册中断处理函数（即action链表为空），或者该中断处于屏蔽状态，那么将中断状态修改为IRQS_PENDING，调用mask_irq在中断控制器级屏蔽该中断线，然后，退出handle_fasteoi_irq函数
/*
* 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;
}
13. 如果是IRQS_ONESHOT类型中断，那么屏蔽该中断
if (desc->istate & IRQS_ONESHOT)
mask_irq(desc);
14. 进一步调用handle_irq_event
handle_irq_event(desc);
15. 进入handle_irq_event函数
将中断状态修改为IRQD_IRQ_INPROGRESS
desc->istate &= ~IRQS_PENDING;
irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
进一步调用handle_irq_event_percpu
16. 进入handle_irq_event_percpu函数
扫描action链表，依次调用用户注册的中断处理函数
for_each_action_of_desc(desc, action)
irqreturn_t res;
/*
* arm32处理器，此时读出的cpsr寄存器bit[7]被置1，说明cpu本地IRQ中断被禁止了，那就是不会发生IRQ硬件中断嵌套的情况了？
*/
res = action->handler(irq, action->dev_id);
根据返回值res判断，是否进行了线程化，如果进行了线程化，则唤醒对应的内核线程
switch (res)
case IRQ_WAKE_THREAD:
__irq_wake_thread(desc, action);
非线程化，则修改flag，然后返回
case IRQ_HANDLED:
17. generic_handle_irq函数返回有，__handle_domain_irq会调用irq_exit函数退出中断上下文
irq_exit();
18. 进入irq_exit函数
如果本地中断没有被屏蔽，则会产生告警
#ifndef __ARCH_IRQ_EXIT_IRQS_DISABLED
local_irq_disable();
#else
WARN_ON_ONCE(!irqs_disabled());
#endif
统计硬件中断退出的次数
account_irq_exit_time(current);
退出硬件中断上下文
preempt_count_sub(HARDIRQ_OFFSET);
如果不在硬件上下文，并且有软中断需要处理，那么开始执行软中断
如果没有设置软中断强制线程化，那么直接调用软中断的回调函数执行，此时中断使用的栈还没有完全释放干净，因此使用的还是硬件堆栈
__do_softirq();
如果设置了软中断强制线程化，那么调度软中断内核线程运行，每个cpu都绑定了一个软中断内核线程
wakeup_softirqd();
本文大部分内容参考如下博客，梳理总结只为自己更好地理解，如有侵权，请联系删除
参考资料：
https://www.cnblogs.com/LoyenWang/p/12996812.html
原创文章，作者：745907710，如若转载，请注明出处：https://blog.ytso.com/270438.html