• 深度解析Linux内核—中断

    中断

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

    1. 中断控制器

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

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

    1. drivers/irqchip/irq-gic.c
    2.  
    3. tatic const struct irq_chip gic_chip = {
    4. 	.irq_mask		= gic_mask_irq,
    5. 	.irq_unmask		= gic_unmask_irq,
    6. 	.irq_eoi		= gic_eoi_irq,
    7. 	.irq_set_type		= gic_set_type,
    8. 	.irq_get_irqchip_state	= gic_irq_get_irqchip_state,
    9. 	.irq_set_irqchip_state	= gic_irq_set_irqchip_state,
    10. 	.flags			= IRQCHIP_SET_TYPE_MASKED |
    11. 				  IRQCHIP_SKIP_SET_WAKE |
    12. 				  IRQCHIP_MASK_ON_SUSPEND,
    13. };

    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中断号。

    【文章福利】小编推荐自己的Linux内核技术交流群：【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份价值699的内核资料包（含视频教程、电子书、实战项目及代码）

    内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

    学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

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

    3.1. 设备树源文件

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

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

    （1）中断控制器的信息

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

    3.2. 中断控制器匹配表

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

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

    1. drivers/irqchip/irq-gic.c
    2.  
    3. IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
    4. ...
    5. IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
    6. IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
    7. ...

    把宏IRQCHIP_DECLARE展开以后是：

    1. static const struct of_device_id __of_table_cortex_gic_400
    2. 	__section(__irqchip_of_table)
    3. 		= { .compatible = "arm,gic-g400",	
    4. 		    .data = gic_of_init  }
    5. ...
    6. static const struct of_device_id __of_table_cortex_a15_gic
    7. 	__section(__irqchip_of_table)
    8. 		= { .compatible = "arm,cortex-a15-gic",	
    9. 		    .data = gic_of_init  }
    10. static const struct of_device_id __of_table_cortex_a9_gic
    11. 	__section(__irqchip_of_table)
    12. 		= { .compatible = "arm,cortex-a9-gic",	
    13. 		    .data = gic_of_init  }
    14. ...

    3.3. 初始化

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

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

    (1)函数of_irq_init

    1. driver/of/irq.c
    2. /**
    3.  * of_irq_init - Scan and init matching interrupt controllers in DT
    4.  * @matches: 0 terminated array of nodes to match and init function to call
    5.  *
    6.  * This function scans the device tree for matching interrupt controller nodes,
    7.  * and calls their initialization functions in order with parents first.
    8.  */
    9. void __init of_irq_init(const struct of_device_id *matches)
    10. {
    11. 	const struct of_device_id *match;
    12. 	struct device_node *np, *parent = NULL;
    13. 	struct of_intc_desc *desc, *temp_desc;
    14. 	struct list_head intc_desc_list, intc_parent_list;
    15.  
    16. 	INIT_LIST_HEAD(&intc_desc_list);
    17. 	INIT_LIST_HEAD(&intc_parent_list);
    18.  
    19. 	for_each_matching_node_and_match(np, matches, &match) {		/* 遍历设备树文件的设备节点。如果属性compatible和中断控制器匹配表中的任何一条表项的字段compatible匹配，处理如下 */
    20. 		if (!of_property_read_bool(np, "interrupt-controller") ||
    21. 				!of_device_is_available(np))		/* 如果没有节点属性interrupt-controller，说明设备不是中断控制器，忽略该设备 */
    22. 			continue;
    23.  
    24. 		if (WARN(!match->data, "of_irq_init: no init function for %s\n",
    25. 			 match->compatible))
    26. 			continue;
    27.  
    28. 		/*
    29. 		 * Here, we allocate and populate an of_intc_desc with the node
    30. 		 * pointer, interrupt-parent device_node etc.
    31. 		 */
    32. 		desc = kzalloc(sizeof(*desc), GFP_KERNEL);		/* 分配一个of_intc_desc实例 */
    33. 		if (WARN_ON(!desc)) {
    34. 			of_node_put(np);
    35. 			goto err;
    36. 		}
    37.  
    38. 		desc->irq_init_cb = match->data;		/* 成员irq_init_cb保存初始化函数 */
    39. 		desc->dev = of_node_get(np);		/* 成员dev保存本设备的device_node */
    40. 		desc->interrupt_parent = of_irq_find_parent(np);		/* 成员interrupt保存父设备 */
    41. 		if (desc->interrupt_parent == np)
    42. 			desc->interrupt_parent = NULL;
    43. 		list_add_tail(&desc->list, &intc_desc_list);		/* 把of_intc_desc实例添加到链表intc_desc_list中 */
    44. 	}
    45.  
    46. 	/*
    47. 	 * The root irq controller is the one without an interrupt-parent.
    48. 	 * That one goes first, followed by the controllers that reference it,
    49. 	 * followed by the ones that reference the 2nd level controllers, etc.
    50. 	 */
    51. 	while (!list_empty(&intc_desc_list)) {		/* 遍历链表intc_desc_list，从根设备开始，先执行父设备的初始化函数，然后执行子设备的初始化函数 */
    52. 		/*
    53. 		 * Process all controllers with the current 'parent'.
    54. 		 * First pass will be looking for NULL as the parent.
    55. 		 * The assumption is that NULL parent means a root controller.
    56. 		 */
    57. 		list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) {
    58. 			int ret;
    59.  
    60. 			if (desc->interrupt_parent != parent)
    61. 				continue;
    62.  
    63. 			list_del(&desc->list);
    64.  
    65. 			of_node_set_flag(desc->dev, OF_POPULATED);
    66.  
    67. 			pr_debug("of_irq_init: init %pOF (%p), parent %p\n",
    68. 				 desc->dev,
    69. 				 desc->dev, desc->interrupt_parent);
    70. 			ret = desc->irq_init_cb(desc->dev,
    71. 						desc->interrupt_parent);
    72. 			if (ret) {
    73. 				of_node_clear_flag(desc->dev, OF_POPULATED);
    74. 				kfree(desc);
    75. 				continue;
    76. 			}
    77.  
    78. 			/*
    79. 			 * This one is now set up; add it to the parent list so
    80. 			 * its children can get processed in a subsequent pass.
    81. 			 */
    82. 			list_add_tail(&desc->list, &intc_parent_list);
    83. 		}
    84.  
    85. 		/* Get the next pending parent that might have children */
    86. 		desc = list_first_entry_or_null(&intc_parent_list,
    87. 						typeof(*desc), list);
    88. 		if (!desc) {
    89. 			pr_err("of_irq_init: children remain, but no parents\n");
    90. 			break;
    91. 		}
    92. 		list_del(&desc->list);
    93. 		parent = desc->dev;
    94. 		kfree(desc);
    95. 	}
    96.  
    97. 	list_for_each_entry_safe(desc, temp_desc, &intc_parent_list, list) {
    98. 		list_del(&desc->list);
    99. 		kfree(desc);
    100. 	}
    101. err:
    102. 	list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) {
    103. 		list_del(&desc->list);
    104. 		of_node_put(desc->dev);
    105. 		kfree(desc);
    106. 	}
    107. }

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

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

    和中断控制器匹配表中的

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

    匹配。

    (2)gic_of_init

    1. int __init
    2. gic_of_init(struct device_node *node, struct device_node *parent)			/* 参数node是本中断控制器，参数parent是父设备 */
    3. {
    4. 	struct gic_chip_data *gic;
    5. 	int irq, ret;
    6.  
    7. 	if (WARN_ON(!node))
    8. 		return -ENODEV;
    9.  
    10. 	if (WARN_ON(gic_cnt >= CONFIG_ARM_GIC_MAX_NR))
    11. 		return -EINVAL;
    12.  
    13. 	gic = &gic_data[gic_cnt];		/* 从全局数组gic_data取一个空闲的元素来保存本中断控制器的信息 */
    14.  
    15. 	ret = gic_of_setup(gic, node);		/* 调用函数gic_of_setup：从设备树文件读取中断控制器的属性reg，获取分发器和处理器接口的寄存器的物理地址范围，把物理地址映射到内核的虚拟地址空间 */
    16. 	if (ret)
    17. 		return ret;
    18.  
    19. 	/*
    20. 	 * Disable split EOI/Deactivate if either HYP is not available
    21. 	 * or the CPU interface is too small.
    22. 	 */
    23. 	if (gic_cnt == 0 && !gic_check_eoimode(node, &gic->raw_cpu_base))
    24. 		static_branch_disable(&supports_deactivate_key);
    25.  
    26. 	ret = __gic_init_bases(gic, -1, &node->fwnode);		/* 调用函数__gic_init_bases以初始化结构体gic_chip_data */
    27. 	if (ret) {
    28. 		gic_teardown(gic);
    29. 		return ret;
    30. 	}
    31.  
    32. 	if (!gic_cnt) {
    33. 		gic_init_physaddr(node);
    34. 		gic_of_setup_kvm_info(node);
    35. 	}
    36.  
    37. 	if (parent) {		/* 如果本中断控制器有父设备，即作为中断源连接到其他中断控制器，处理如下 */
    38. 		irq = irq_of_parse_and_map(node, 0);		/* 调用函数irq_of_parse_and_map：从设备树文件中本设备节点的属性interrupts获取硬件中断号，把硬件中断号映射到Linux中断号n */
    39. 		gic_cascade_irq(gic_cnt, irq);		/* 调用函数gic_cascade_irq：把Linux中断号n中断描述符的成员handle_irq()设置为函数gic_handle_cascade_irq() */
    40. 	}
    41.  
    42. 	if (IS_ENABLED(CONFIG_ARM_GIC_V2M))
    43. 		gicv2m_init(&node->fwnode, gic_data[gic_cnt].domain);
    44.  
    45. 	gic_cnt++;
    46. 	return 0;
    47. }

    (3)函数__gic_init_bases

    1. static int __init __gic_init_bases(struct gic_chip_data *gic,
    2. 				   int irq_start,
    3. 				   struct fwnode_handle *handle)
    4. {
    5. 	char *name;
    6. 	int i, ret;
    7.  
    8. 	if (WARN_ON(!gic || gic->domain))
    9. 		return -EINVAL;
    10.  
    11. 	if (gic == &gic_data[0]) {		/* 如果本中断控制器是根控制器，处理如下： */
    12. 		/*
    13. 		 * Initialize the CPU interface map to all CPUs.
    14. 		 * It will be refined as each CPU probes its ID.
    15. 		 * This is only necessary for the primary GIC.
    16. 		 */
    17. 		for (i = 0; i < NR_GIC_CPU_IF; i++)
    18. 			gic_cpu_map[i] = 0xff;
    19. #ifdef CONFIG_SMP
    20. 		set_smp_cross_call(gic_raise_softirq);		/* 把全局函数指针__smp_cross_call设置为函数gic_raise_softirq */
    21. #endif											/* 用来发送软件生成的中断，即一个处理器向其他处理器发送中断 */
    22. 		cpuhp_setup_state_nocalls(CPUHP_AP_IRQ_GIC_STARTING,
    23. 					  "irqchip/arm/gic:starting",
    24. 					  gic_starting_cpu, NULL);
    25. 		set_handle_irq(gic_handle_irq);		/* 把全局函数指针handle_arch_irq设置为函数gic_handle_irq，该函数是中断处理程序C语言部分的入口 */
    26. 		if (static_branch_likely(&supports_deactivate_key))
    27. 			pr_info("GIC: Using split EOI/Deactivate mode\n");
    28. 	}
    29. 		/* 调用函数gic_init_chip以初始化中断控制器描述符irq_chip */
    30. 	if (static_branch_likely(&supports_deactivate_key) && gic == &gic_data[0]) {
    31. 		name = kasprintf(GFP_KERNEL, "GICv2");
    32. 		gic_init_chip(gic, NULL, name, true);
    33. 	} else {
    34. 		name = kasprintf(GFP_KERNEL, "GIC-%d", (int)(gic-&gic_data[0]));
    35. 		gic_init_chip(gic, NULL, name, false);
    36. 	}
    37.  
    38. 	ret = gic_init_bases(gic, irq_start, handle);		/* 调用函数gic_init_bases进行初始化：为本中断控制器分配中断域，初始化中断控制器的分发器的各种寄存器，初始化中断控制器的处理器接口的各种寄存器 */
    39. 	if (ret)
    40. 		kfree(name);
    41.  
    42. 	return ret;
    43. }

    4. Linux中断处理

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

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

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

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

    有两种实现方式：

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

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

    1. #ifdef CONFIG_SPARSE_IRQ
    2.  
    3. ...
    4. static RADIX_TREE(irq_desc_tree, GFP_KERNEL);
    5. ...
    6.  
    7. #else /* !CONFIG_SPARSE_IRQ */
    8.  
    9. struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
    10. 	[0 ... NR_IRQS-1] = {
    11. 		.handle_irq	= handle_bad_irq,
    12. 		.depth		= 1,
    13. 		.lock		= __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
    14. 	}
    15. };
    16. ...
    17.  
    18. #endif /* !CONFIG_SPARSE_IRQ */

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

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

    在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的代码如下：

    1. arch/arm64/kernel/irq.c
    2. /* 每个处理器有一个专用的中断栈 */
    3. DEFINE_PER_CPU(unsigned long *, irq_stack_ptr);
    4.  
    5. arch/arm64/kernel/entry.S
    6. /*
    7.  * Interrupt handling.
    8.  */
    9. 	.macro	irq_handler
    10. 	ldr_l	x1, handle_arch_irq
    11. 	mov	x0, sp
    12. 	irq_stack_entry		// 从进程的内核栈切换到中断栈
    13. 	blr	x1		// 调用函数指针handle_arch_irq指向的函数
    14. 	irq_stack_exit		// 从中断栈切换到进程的内核栈
    15. 	.endm
    16.  
    17. 	.align	6
    18. el1_irq:
    19. 	kernel_entry 1
    20. 	enable_da_f
    21. #ifdef CONFIG_TRACE_IRQFLAGS
    22. 	bl	trace_hardirqs_off
    23. #endif
    24.  
    25. 	irq_handler            // irq_handler是一个宏
    26.  
    27. #ifdef CONFIG_PREEMPT
    28. 	ldr	x24, [tsk, #TSK_TI_PREEMPT]	// get preempt count	读取抢占计数
    29. 	cbnz	x24, 1f				// preempt count != 0		抢占计数不等于0
    30. 	bl	el1_preempt
    31. 1:
    32. #endif
    33. #ifdef CONFIG_TRACE_IRQFLAGS
    34. 	bl	trace_hardirqs_on
    35. #endif
    36. 	kernel_exit 1
    37. ENDPROC(el1_irq)

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

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

    函数handle_domain_irq()：

    1. include/linux/irqdesc.h
    2. static inline void generic_handle_irq_desc(struct irq_desc *desc)
    3. {
    4. 	desc->handle_irq(desc);
    5. }
    6.  
    7. kernel/irq/irqdesc.c
    8. int generic_handle_irq(unsigned int irq)
    9. {
    10. 	struct irq_desc *desc = irq_to_desc(irq);
    11.  
    12. 	if (!desc)
    13. 		return -EINVAL;
    14. 	generic_handle_irq_desc(desc);
    15. 	return 0;
    16. }
    17.  
    18. kernel/irq/irqdesc.c
    19. #ifdef CONFIG_HANDLE_DOMAIN_IRQ
    20. int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
    21. 			bool lookup, struct pt_regs *regs)
    22. {
    23. 	struct pt_regs *old_regs = set_irq_regs(regs);
    24. 	unsigned int irq = hwirq;
    25. 	int ret = 0;
    26.  
    27. 	irq_enter();
    28.  
    29. #ifdef CONFIG_IRQ_DOMAIN
    30. 	if (lookup)
    31. 		irq = irq_find_mapping(domain, hwirq);
    32. #endif
    33.  
    34. 	/*
    35. 	 * Some hardware gives randomly wrong interrupts.  Rather
    36. 	 * than crashing, do something sensible.
    37. 	 */
    38. 	if (unlikely(!irq || irq >= nr_irqs)) {
    39. 		ack_bad_irq(irq);
    40. 		ret = -EINVAL;
    41. 	} else {
    42. 		generic_handle_irq(irq);
    43. 	}
    44.  
    45. 	irq_exit();
    46. 	set_irq_regs(old_regs);
    47. 	return ret;
    48. }
    49. #endif
    50.  
    51. include/linux/irqdesc.h
    52. static inline int handle_domain_irq(struct irq_domain *domain,
    53. 				    unsigned int hwirq, struct pt_regs *regs)
    54. {
    55. 	return __handle_domain_irq(domain, hwirq, true, regs);
    56. }

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

    1. kernel/irq/chip.c
    2. void handle_percpu_devid_irq(struct irq_desc *desc)
    3. {
    4. 	struct irq_chip *chip = irq_desc_get_chip(desc);
    5. 	struct irqaction *action = desc->action;
    6. 	unsigned int irq = irq_desc_get_irq(desc);
    7. 	irqreturn_t res;
    8.  
    9. 	...
    10. 	if (chip->irq_ack)
    11. 		chip->irq_ack(&desc->irq_data);
    12.  
    13. 	if (likely(action)) {
    14. 		...
    15. 		res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));
    16. 		...
    17. 	} else {
    18. 		...
    19. 	}
    20.  
    21. 	if (chip->irq_eoi)
    22. 		chip->irq_eoi(&desc->irq_data);
    23. }

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

    1. kernel/irq/chip.c
    2. void handle_fasteoi_irq(struct irq_desc *desc)
    3. {
    4. 	struct irq_chip *chip = desc->irq_data.chip;
    5.  
    6. 	raw_spin_lock(&desc->lock);
    7.  
    8. 	if (!irq_may_run(desc))
    9. 		goto out;
    10.  
    11. 	desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
    12.  
    13. 	/*
    14. 	 * If its disabled or no action available
    15. 	 * then mask it and get out of here:
    16. 	 */
    17. 	if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
    18. 		desc->istate |= IRQS_PENDING;
    19. 		mask_irq(desc);
    20. 		goto out;
    21. 	}
    22.  
    23. 	kstat_incr_irqs_this_cpu(desc);
    24. 	if (desc->istate & IRQS_ONESHOT)
    25. 		mask_irq(desc);
    26.  
    27. 	preflow_handler(desc);
    28. 	handle_irq_event(desc);		/* 调用函数handle_irq_event执行设备驱动程序注册的处理函数 */
    29.  
    30. 	cond_unmask_eoi_irq(desc, chip);
    31.  
    32. 	raw_spin_unlock(&desc->lock);
    33. 	return;
    34. out:
    35. 	if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
    36. 		chip->irq_eoi(&desc->irq_data);
    37. 	raw_spin_unlock(&desc->lock);
    38. }

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

    1. handle_irq_event()  ->  handle_irq_event_percpu()  ->  __handle_irq_event_percpu()
    2.  
    3. kernel/irq/handle.c
    4. irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
    5. {
    6. 	irqreturn_t retval = IRQ_NONE;
    7. 	unsigned int irq = desc->irq_data.irq;
    8. 	struct irqaction *action;
    9. 	/* 遍历中断描述符的的中断处理链表，执行每个中断处理描述符的处理函数 */
    10. 	record_irq_time(desc);
    11. 	
    12. 	for_each_action_of_desc(desc, action) {		
    13. 		irqreturn_t res;
    14.  
    15. 		trace_irq_handler_entry(irq, action);
    16. 		res = action->handler(irq, action->dev_id);
    17. 		trace_irq_handler_exit(irq, action, res);
    18.  
    19. 		if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
    20. 			      irq, action->handler))
    21. 			local_irq_disable();
    22.  
    23. 		switch (res) {
    24. 		case IRQ_WAKE_THREAD:
    25. 			/*
    26. 			 * Catch drivers which return WAKE_THREAD but
    27. 			 * did not set up a thread function
    28. 			 */
    29. 			if (unlikely(!action->thread_fn)) {
    30. 				warn_no_thread(irq, action);
    31. 				break;
    32. 			}
    33.  
    34. 			__irq_wake_thread(desc, action);
    35. 			/* 继续往下走，把action->flags作为生成随机数的一个因子 */
    36. 			/* Fall through to add to randomness */
    37. 		case IRQ_HANDLED:
    38. 			*flags |= action->flags;
    39. 			break;
    40.  
    41. 		default:
    42. 			break;
    43. 		}
    44.  
    45. 		retval |= res;
    46. 	}
    47.  
    48. 	return retval;
    49. }

    5. 中断线程化

    中断线程化就是使用内核线程处理中断，目的是减少系统关中断的时间，增强系统的实时性。内核提供的函数request_threaded_irq()用来注册线程化的中断：

    1. int request_threaded_irq(unsigned int irq, irq_handler_t handler,
    2. 			 irq_handler_t thread_fn, unsigned long irqflags,
    3. 			 const char *devname, void *dev_id)

    参数thread_fn是线程处理函数。

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

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

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

    1. include/linux/interrupt.h
    2. struct irqaction {
    3. 	irq_handler_t		handler;
    4. 	void			*dev_id;
    5. 	void __percpu		*percpu_dev_id;
    6. 	struct irqaction	*next;		/* 中断处理描述符链表 */
    7. 	irq_handler_t		thread_fn;		/* 指向线程处理函数 */
    8. 	struct task_struct	*thread;		/* 指向内核线程的进程描述符 */
    9. 	struct irqaction	*secondary;
    10. 	unsigned int		irq;
    11. 	unsigned int		flags;
    12. 	unsigned long		thread_flags;
    13. 	unsigned long		thread_mask;
    14. 	const char		*name;
    15. 	struct proc_dir_entry	*dir;
    16. } ____cacheline_internodealigned_in_smp;

    1. request_threaded_irq()  ->  __setup_irq()  ->  setup_irq_thread()
    2.  
    3. kernel/irq/manage.c
    4. static int
    5. setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
    6. {
    7. 	struct task_struct *t;
    8. 	struct sched_param param = {
    9. 		.sched_priority = MAX_USER_RT_PRIO/2,		/*  */
    10. 	};
    11.  
    12. 	if (!secondary) {
    13. 		t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
    14. 				   new->name);		/* 名称是“irq/”后面跟着Linux中断号，线程处理函数是irq_thread() */
    15. 	} else {
    16. 		t = kthread_create(irq_thread, new, "irq/%d-s-%s", irq,
    17. 				   new->name);
    18. 		param.sched_priority -= 1;
    19. 	}
    20.  
    21. 	if (IS_ERR(t))
    22. 		return PTR_ERR(t);
    23.  
    24. 	sched_setscheduler_nocheck(t, SCHED_FIFO, &param);		/* 中断处理线程是优先级为50、调度策略是SCHED_FIFO的实时内核线程 */
    25.  
    26. 	/*
    27. 	 * We keep the reference to the task struct even if
    28. 	 * the thread dies to avoid that the interrupt code
    29. 	 * references an already freed task_struct.
    30. 	 */
    31. 	get_task_struct(t);
    32. 	new->thread = t;
    33. 	/*
    34. 	 * Tell the thread to set its affinity. This is
    35. 	 * important for shared interrupt handlers as we do
    36. 	 * not invoke setup_affinity() for the secondary
    37. 	 * handlers as everything is already set up. Even for
    38. 	 * interrupts marked with IRQF_NO_BALANCE this is
    39. 	 * correct as we want the thread to move to the cpu(s)
    40. 	 * on which the requesting code placed the interrupt.
    41. 	 */
    42. 	set_bit(IRQTF_AFFINITY, &new->thread_flags);
    43. 	return 0;
    44. }

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

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

    1. kernel/irq/manage.c
    2.  
    3. static irqreturn_t irq_thread_fn(struct irq_desc *desc,
    4. 		struct irqaction *action)
    5. {
    6. 	irqreturn_t ret;
    7.  
    8. 	ret = action->thread_fn(action->irq, action->dev_id);
    9. 	if (ret == IRQ_HANDLED)
    10. 		atomic_inc(&desc->threads_handled);
    11.  
    12. 	irq_finalize_oneshot(desc, action);
    13. 	return ret;
    14. }
    15.  
    16. static int irq_thread(void *data)
    17. {
    18. 	struct callback_head on_exit_work;
    19. 	struct irqaction *action = data;
    20. 	struct irq_desc *desc = irq_to_desc(action->irq);
    21. 	irqreturn_t (*handler_fn)(struct irq_desc *desc,
    22. 			struct irqaction *action);
    23.  
    24. 	if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,
    25. 					&action->thread_flags))
    26. 		handler_fn = irq_forced_thread_fn;
    27. 	else
    28. 		handler_fn = irq_thread_fn;
    29.  
    30. 	init_task_work(&on_exit_work, irq_thread_dtor);
    31. 	task_work_add(current, &on_exit_work, false);
    32.  
    33. 	irq_thread_check_affinity(desc, action);
    34.  
    35. 	while (!irq_wait_for_interrupt(action)) {
    36. 		irqreturn_t action_ret;
    37.  
    38. 		irq_thread_check_affinity(desc, action);
    39.  
    40. 		action_ret = handler_fn(desc, action);
    41. 		if (action_ret == IRQ_WAKE_THREAD)
    42. 			irq_wake_secondary(desc, action);
    43.  
    44. 		wake_threads_waitq(desc);
    45. 	}
    46.  
    47. 	/*
    48. 	 * This is the regular exit path. __free_irq() is stopping the
    49. 	 * thread via kthread_stop() after calling
    50. 	 * synchronize_hardirq(). So neither IRQTF_RUNTHREAD nor the
    51. 	 * oneshot mask bit can be set.
    52. 	 */
    53. 	task_work_cancel(current, irq_thread_dtor);
    54. 	return 0;
    55. }

    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是硬件中断号，其代码如下：

    1. arch/arm64/kernel/smp.c
    2. void handle_IPI(int ipinr, struct pt_regs *regs)
    3. {
    4. 	unsigned int cpu = smp_processor_id();
    5. 	struct pt_regs *old_regs = set_irq_regs(regs);
    6.  
    7. 	if ((unsigned)ipinr < NR_IPI) {
    8. 		trace_ipi_entry_rcuidle(ipi_types[ipinr]);
    9. 		__inc_irq_stat(cpu, ipi_irqs[ipinr]);
    10. 	}
    11. 		/* 目前支持7种处理间中断 */
    12. 	switch (ipinr) {
    13. 	case IPI_RESCHEDULE:		/* 硬件中断号是0，重新调度进程，函数smp_send_reschedule()生成的中断 */
    14. 		scheduler_ipi();
    15. 		break;
    16.  
    17. 	case IPI_CALL_FUNC:		/* 硬件中断号是1，执行函数，函数smp_call_function生成的中断 */
    18. 		irq_enter();
    19. 		generic_smp_call_function_interrupt();
    20. 		irq_exit();
    21. 		break;
    22.  
    23. 	case IPI_CPU_STOP:		/* 硬件中断号是2，使处理器停止，函数smp_send_stop()生成的中断 */
    24. 		irq_enter();
    25. 		ipi_cpu_stop(cpu);
    26. 		irq_exit();
    27. 		break;
    28.  
    29. 	case IPI_CPU_CRASH_STOP:		/* 硬件中断号是3，使处理器停止，函数smp_send_crash_stop()生成的中断 */
    30. 		if (IS_ENABLED(CONFIG_KEXEC_CORE)) {
    31. 			irq_enter();
    32. 			ipi_cpu_crash_stop(cpu, regs);
    33.  
    34. 			unreachable();
    35. 		}
    36. 		break;
    37.  
    38. #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
    39. 	case IPI_TIMER:		/* 硬件中断号是4，广播的时钟事件，函数tick_broadcast()生成的中断 */
    40. 		irq_enter();
    41. 		tick_receive_broadcast();
    42. 		irq_exit();
    43. 		break;
    44. #endif
    45.  
    46. #ifdef CONFIG_IRQ_WORK
    47. 	case IPI_IRQ_WORK:		/* 硬件中断号是5，在硬中断上下文中执行回调函数，函数irq_work_queue()生成的中断 */
    48. 		irq_enter();
    49. 		irq_work_run();
    50. 		irq_exit();
    51. 		break;
    52. #endif
    53.  
    54. #ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
    55. 	case IPI_WAKEUP:		/* 硬件中断号是6，唤醒处理器，函数acpi_parking_protocol_cpu_boot()生成的中断 */
    56. 		WARN_ONCE(!acpi_parking_protocol_valid(cpu),
    57. 			  "CPU%u: Wake-up IPI outside the ACPI parking protocol\n",
    58. 			  cpu);
    59. 		break;
    60. #endif
    61.  
    62. 	default:
    63. 		pr_crit("CPU%u: Unknown IPI message 0x%x\n", cpu, ipinr);
    64. 		break;
    65. 	}
    66.  
    67. 	if ((unsigned)ipinr < NR_IPI)
    68. 		trace_ipi_exit_rcuidle(ipi_types[ipinr]);
    69. 	set_irq_regs(old_regs);
    70. }

     

  • 相关阅读:
    只看优点，这2款可视化产品你更心水谁？
    lombok总结
    2022/11/18[指针] 关于指针的初步理解
    如何确保您的数据提供值得信赖的见解
    宏集案例 | eX707G人机界面在石油钻井工程中的应用
    使用Redis完成商品秒杀业务
    ​力扣解法汇总764. 最大加号标志
    【负荷预测】基于双向LSTM模型进行电力需求预测（Matlab代码实现）
    在Linux/Ubuntu/Debian中使用7z压缩和解压文件
    汽车以太网IOP测试新利器
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/128132781