Linux内核中断

已于 2024-03-27 09:58:56 修改
阅读量875 收藏 2
点赞数 1
分类专栏： Linux内核 文章标签： linux
于 2018-07-06 17:26:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz5034/article/details/80944160
版权

定义

CSAPP

异常分为4类：中断（interrupt），陷阱（trap）、故障（fault）、终止（abort）
第1个是异步的，后3个是同步的

Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A: System Programming Guide, Part 1

irq_desc

struct irq_desc {
	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;
	raw_spinlock_t		lock;
	struct cpumask		*percpu_enabled;
#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_PROC_FS
	struct proc_dir_entry	*dir;
#endif
	int			parent_irq;
	struct module		*owner;
	const char		*name;
} ____cacheline_internodealigned_in_smp;

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),
	}
};

start_kernel

start_kernel()位于linux-4.20/init/main.c中，相当于main()

start_kernel
	init_IRQ
	time_init
		late_time_init = x86_late_time_init;
	late_time_init // x86_late_time_init
		x86_init.irqs.intr_mode_init(); // apic_intr_mode_init
			apic_bsp_setup
				setup_local_APIC
				setup_IO_APIC

init_IRQ()：初始化硬中断

init_IRQ位于linux-4.20/arch/x86/kernel/irqinit.c中
init_IRQ() -> native_init_IRQ() -> init_ISA_irqs() -> irq_set_chip_and_handler() -> irq_set_chip_and_handler_name() -> __irq_set_handler() -> __irq_do_set_handler()

void __init init_IRQ(void)
{
    ...
    x86_init.irqs.intr_init(); /* native_init_IRQ() */
}


struct x86_init_ops x86_init __initdata = {
    ...
    .irqs = {
        .pre_vector_init	= init_ISA_irqs,
		.intr_init		= native_init_IRQ,
		.trap_init		= x86_init_noop,
		.intr_mode_init		= apic_intr_mode_init
    },
    ...
};


void __init native_init_IRQ(void)
{
    ...
    x86_init.irqs.pre_vector_init(); /* init_ISA_irqs() */

    idt_setup_apic_and_irq_gates();
    ...
}


void __init init_ISA_irqs(void)
{
    ...
    for (i = 0; i < nr_legacy_irqs(); i++) /* 遍历每个中断号 */
		irq_set_chip_and_handler(i, chip, handle_level_irq); /* handle为handle_level_irq() */
}


static inline void irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip,
					    irq_flow_handler_t handle)
{
	irq_set_chip_and_handler_name(irq, chip, handle, NULL);
}


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(irq, handle, 0, name);
}


void
__irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
		  const char *name)
{
	...
	__irq_do_set_handler(desc, handle, is_chained, name);
	...
}


static void
__irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,
		     int is_chained, const char *name)
{
	...
	desc->handle_irq = handle; /* 设置desc->handle_irq为handle_level_irq() */
	...
}

void __init idt_setup_apic_and_irq_gates(void)
{
    ...
	entry = irq_entries_start + 8 * (i - FIRST_EXTERNAL_VECTOR);
	set_intr_gate(i, entry);
    ...
}

ENTRY(irq_entries_start)
    vector=FIRST_EXTERNAL_VECTOR
    .rept (FIRST_SYSTEM_VECTOR - FIRST_EXTERNAL_VECTOR)
	UNWIND_HINT_IRET_REGS
	pushq	$(~vector+0x80)			/* Note: always in signed byte range */
	jmp	common_interrupt
	.align	8
	vector=vector+1
    .endr
END(irq_entries_start)

common_interrupt:
	addq	$-0x80, (%rsp)			/* Adjust vector to [-256, -1] range */
	call	interrupt_entry
	UNWIND_HINT_REGS indirect=1
	call	do_IRQ	/* rdi points to pt_regs */

request_irq()：注册硬中断

request_irq() -> request_threaded_irq() -> __setup_irq()
对于ixgbe网卡驱动：ixgbe_open() -> ixgbe_request_irq() -> ixgbe_request_msix_irqs() -> request_irq()

static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
	    const char *name, void *dev)
{
	return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}


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)
{
	struct irqaction *action;
	struct irq_desc *desc;
	...
	desc = irq_to_desc(irq); /* 根据irq得到对应的irq_desc */
	...
	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL); /* 分配irqaction */
	...
	action->handler = handler; /* 设置action->handler为硬中断函数 */
	action->thread_fn = thread_fn;
	action->flags = irqflags;
	action->name = devname;
	action->dev_id = dev_id; /* 调用request_irq()时传入，作为硬中断函数的参数 */
	...
	retval = __setup_irq(irq, desc, action); /* 将action插入desc->action队尾 */
	...
}


/* 将new插入desc->action队尾 */
static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{
    struct irqaction *old, **old_ptr;
    ...
    new->irq = irq;
    ...
    old_ptr = &desc->action; /* old_ptr指向desc->action队头 */
    old = *old_ptr;
    if (old) {
		...
		do {
			...
			old_ptr = &old->next;
			old = *old_ptr;
		} while (old); /* old_ptr往右移动，直到desc->action队尾跳出循环 */
		...
	}
    ...
    *old_ptr = new; /* 将new插入desc->action队尾 */
    ...
    register_irq_proc(irq, desc);
	...
	register_handler_proc(irq, new);
	...
}

open_softirq()：注册软中断

net_dev_init() -> open_softirq()
设置全局数组softirq_vec的action为软中断函数

enum
{
	HI_SOFTIRQ=0,
	TIMER_SOFTIRQ,
	NET_TX_SOFTIRQ, /* 2 */
	NET_RX_SOFTIRQ, /* 3 */
	BLOCK_SOFTIRQ,
	IRQ_POLL_SOFTIRQ,
	TASKLET_SOFTIRQ,
	SCHED_SOFTIRQ,
	HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the
			    numbering. Sigh! */
	RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */

	NR_SOFTIRQS
};


static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp; /* 软中断向量表 */


static int __init net_dev_init(void)
{
    ...
    open_softirq(NET_TX_SOFTIRQ, net_tx_action); /* 注册发送软中断，软中断函数为net_tx_action() */
    open_softirq(NET_RX_SOFTIRQ, net_rx_action); /* 注册接收软中断，软中断函数为net_rx_action() */
    ...
}


void open_softirq(int nr, void (*action)(struct softirq_action *))
{
    softirq_vec[nr].action = action; /* 设置softirq_vec[nr].action为软中断函数 */
}

do_IRQ()：执行硬中断函数

do_IRQ位于linux-4.20/arch/x86/kernel/irq.c中
do_IRQ() -> handle_irq() -> generic_handle_irq_desc() -> handle_level_irq() -> handle_irq_event() -> handle_irq_event_percpu() -> __handle_irq_event_percpu() -> 硬中断函数
硬中断函数执行完后继续执行exiting_irq()

__visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
	...
	unsigned vector = ~regs->orig_ax;
	...
	desc = __this_cpu_read(vector_irq[vector]); /* 根据vector得到对应的irq_desc */
	...
	if (!handle_irq(desc, regs)) {
	...
	exiting_irq();
	...
}


bool handle_irq(struct irq_desc *desc, struct pt_regs *regs)
{
	...
	generic_handle_irq_desc(desc);
	...
}


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


void handle_level_irq(struct irq_desc *desc)
{
	...
	handle_irq_event(desc);
	...
}


irqreturn_t handle_irq_event(struct irq_desc *desc)
{
	...
	ret = handle_irq_event_percpu(desc);
	...
}


irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
{
	...
	retval = __handle_irq_event_percpu(desc, &flags);
	...
}


irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{
	...
	for_each_action_of_desc(desc, action) {
		...
		/* 硬中断函数
		 * 对于ixgbe网卡驱动：ixgbe_msix_clean_rings()/ixgbe_intr() */
		res = action->handler(irq, action->dev_id);
		...
	}
	...
}

__raise_softirq_irqoff()：抛出软中断

对于ixgbe网卡驱动：ixgbe_msix_clean_rings()/ixgbe_intr() -> napi_schedule_irqoff() -> __napi_schedule_irqoff() -> ____napi_schedule() -> __raise_softirq_irqoff()

DECLARE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);

typedef struct {
	u16	     __softirq_pending;
	...
} ____cacheline_aligned irq_cpustat_t;


#define local_softirq_pending_ref irq_stat.__softirq_pending /* 软中断位图 */


void __raise_softirq_irqoff(unsigned int nr)
{
	trace_softirq_raise(nr);
	or_softirq_pending(1UL << nr); /* 设置软中断位图的第nr位为1 */
}


#define local_softirq_pending()	(__this_cpu_read(local_softirq_pending_ref)) /* 读软中断位图 */
#define set_softirq_pending(x)	(__this_cpu_write(local_softirq_pending_ref, (x))) /* 写软中断位图为x */
#define or_softirq_pending(x)	(__this_cpu_or(local_softirq_pending_ref, (x))) /* 软中断位图和x求或 */


#define __this_cpu_or(pcp, val)						\
({									\
	__this_cpu_preempt_check("or");					\
	raw_cpu_or(pcp, val);						\
})


#define raw_cpu_or(pcp, val)		__pcpu_size_call(raw_cpu_or_, pcp, val)


#define __pcpu_size_call(stem, variable, ...)				\
do {									\
	__verify_pcpu_ptr(&(variable));					\
	switch(sizeof(variable)) {					\
		case 1: stem##1(variable, __VA_ARGS__);break;		\
		case 2: stem##2(variable, __VA_ARGS__);break;		\
		case 4: stem##4(variable, __VA_ARGS__);break;		\
		case 8: stem##8(variable, __VA_ARGS__);break;		\
		default: 						\
			__bad_size_call_parameter();break;		\
	}								\
} while (0)


#define raw_cpu_or_2(pcp, val)		percpu_to_op("or", (pcp), val) /* percpu_to_op是一个汇编宏 */

exiting_irq()：执行软中断函数

exiting_irq() -> irq_exit() -> do_softirq() -> __do_softirq() -> 软中断函数

static inline void exiting_irq(void)
{
	irq_exit();
}


void irq_exit(void)
{
    ...
    /* 1、不在一个硬/软中断上下文中，且抢占功能是打开的
     * 2、没有软中断等待处理 */
    if (!in_interrupt() && local_softirq_pending())
		invoke_softirq();
    ...
}


static inline void invoke_softirq(void)
{
	if (ksoftirqd_running(local_softirq_pending()))
		return;

	if (!force_irqthreads) {
		...
		__do_softirq(); /* 处理软中断 */
		...
	} else {
		wakeup_softirqd(); /* 唤醒ksoftirqd线程处理软中断 */
	}
}


static bool ksoftirqd_running(unsigned long pending)
{
	struct task_struct *tsk = __this_cpu_read(ksoftirqd);

	if (pending & SOFTIRQ_NOW_MASK) /* 有HI_SOFTIRQ/TASKLET_SOFTIRQ软中断等待处理 */
		return false;
	return tsk && (tsk->state == TASK_RUNNING); /* ksoftirqd线程正在运行 */
}


asmlinkage __visible void __softirq_entry __do_softirq(void)
{
	unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
	...
	int max_restart = MAX_SOFTIRQ_RESTART;
	struct softirq_action *h;
	...
	__u32 pending;
	int softirq_bit;
	...
	pending = local_softirq_pending(); /* 读软中断位图 */
	...
restart:
	...
	h = softirq_vec; /* 软中断向量表 */
	...
	/* ffs（find first set）
	 * 从最低位开始，返回第一个为1的bit的index */
	while ((softirq_bit = ffs(pending))) {
		...
		h += softirq_bit - 1; /* h指向为1的bit对应的软中断向量 */
		...
		/* 软中断函数
		 * 对于网络收发包：net_tx/rx_action() */
		h->action(h);
		...
		h++;
		pending >>= softirq_bit;
	}
	...
	pending = local_softirq_pending(); /* 再次读软中断位图 */
	if (pending) {
		/* 时长没有达到MAX_SOFTIRQ_TIME、不需要重新调度、restart次数没有达到MAX_SOFTIRQ_RESTART */
		if (time_before(jiffies, end) && !need_resched() &&
		    --max_restart)
			goto restart;

		wakeup_softirqd(); /* 唤醒ksoftirqd线程处理软中断 */
	}
	...
}
hz5034
关注
专栏目录
linux内核中断实例
04-11
在这个"Linux内核中断实例"中，我们将深入探讨中断处理机制，并通过一个名为`interrupt_module`的示例模块来说明如何在内核中插入并处理指定的中断。 1. **中断的基本概念** - 中断是一种异步通信方式，当硬件设备...
LINUX软中断-ksoftirqd
human！的专栏
01-20 4772
ksoftirqd
Linux的ksoftirqd/0是干什么的？底层原理是什么？
长风破浪会有时的博客
07-15 1604
当一个软中断任务需要被处理时，ksoftirqd/0 会从队列中取出该任务，并调用相应的软中断处理函数来执行实际的任务。软中断是一种由内核使用的机制，用于处理一些高优先级的任务，例如网络数据包的接收和处理、定时器的处理、任务调度等。与硬中断不同，软中断在中断上下文中执行，但它是以线程的形式运行在内核空间中，不与特定的硬件设备相关。ksoftirqd/0 的运行是周期性的，它会在每个 CPU 核心上进行调度，并根据软中断的优先级进行任务处理。它的目标是尽可能快地处理软中断任务，以确保系统的响应性和性能。
Linux中断流程分析
Android开发
12-09 1158
参考文档 IHI0048B_b_gic_architecture_specification.pdf IHI0069E_gic_architecture_specification.pdf DUI0471M_software_development_guide.pdf GIC400架构 中断的类型 SGI:software generatedinterrupt,软件出发产生...
linux ksoftirqd进程,ksoftirqd进程导致cpu消耗殆尽
热门推荐
weixin_34526937的博客
05-11 1万+
今天晚上发现某台linux软路由负载突然升高，8核CPU飙升至8的负载应该算是很高了，排查CPU使用非常厉害，8核中有6核均为0%。通过top命令显示CPU使用最高的四个进程均是ksoftirqd(分别是ksoftirqd/0,ksoftirqd/1,ksoftirqd/2,ksoftirqd/3)，检查流量并没有升高，跟平时水平差不多，非常匪夷所思。由于消耗太多通过平衡CPU中断的方法已经没有办...
Linux内核网络中的软中断ksoftirqd
金荣的个人技术博客
08-24 7275
1. 前言 之前分享过Linux内核网络数据包的接收过程，当执行到网卡通过硬件中断（IRQ）通知CPU，告诉它有数据来了，CPU会根据中断表，调用已经注册的中断函数，这个中断函数会调到驱动程序（NIC Driver）中相应的函数。驱动先禁用网卡的中断，表示驱动程序已经知道内存中有数据了，告诉网卡下次再收到数据包直接写内存就可以了，不要再通知CPU了，这样可以提高效率，避免CPU不停的被中断。 由于硬中断处理程序执行的过程中不能被中断，所以如果它执行时间过长，会导致CPU没法响应其它硬件的中断，于是内核引入软
linux内核中断处理.doc
07-31
linux内核中断处理.doc
Linux内核中断分析.pdf
09-06
Linux内核中断分析主要涉及操作系统的核心机制，尤其是与Intel 80x86架构相关的中断处理。中断系统在计算机系统中扮演着至关重要的角色，它允许CPU暂停当前执行的程序，去响应来自硬件设备（如输入输出请求）或处理...
Linux内核中断分析
04-28
### Linux内核中断分析 #### 重要性及作用 中断系统是计算机系统中不可或缺的关键组件，在整个系统的运行中扮演着至关重要的角色。特别是在Linux操作系统中，中断机制的高效性和灵活性对于提升系统的整体性能至关...
linux 内核中断相关的源码阅读笔记
10-11
关于linux 内核中断相关的源码阅读笔记
【Linux内核】Linux软中断处理机制-ksoftirqd
平凡的世界
04-10 1858
软中断（softirq）是中断处理程序在开启中断的情况下执行的部分，可以被硬中断抢占。把延迟函数叫做软中断并不是因为它是一个真正的中断，而是因为延迟函数主要在中断上下文环境中运行。Linux中最多可以支持32种软中断操作，但目前Linux只实现了其中的几种。
内核问题解决方法记录
Peter的专栏
08-04 4425
内核问题解决方法记录♪ 张释文 在内核开发这块，基本工作都是：打补丁，调补丁，调bug。最耗神的就是调bug，调bug的过程最花时间的一步是定位问题，基...
linux ksoftirqd进程,14.9.6 软中断处理线程（ksoftirqd）
weixin_36230923的博客
05-11 1507
14.9.6 软中断处理线程(ksoftirqd)在前面曾经介绍过，对于软中断，内核会选择在几个特殊时刻进行处理。而在中断处理程序返回时处理软中断是最常见的。软中断被触发的频率有时可能会很高(例如，进行大流量的网络通信期间)。而且更糟糕的是软中断处理程序在执行时还可重新触发自己使其再次执行(也就是在软中断处理程序中调用raise_softirq或raise_softirq_irqoff函数使当前...
Linux: 默认进程介绍
最新发布
shunzi2016的博客
05-13 1015
这种内核线程共有32个，从watchdog/0到watchdog/31, 每个处理器核对应一个watchdog 内核线程，watchdog用于监视系统的运行，在系统出现故障时自动重新启动系统，包括一个内核 watchdog module 和一个用户空间的 watchdog 程序。它的基本思想是在进程执行过程中移动它，使得它在另一个计算机上继续存取它的所有资源并继续运行，而且不必知道运行进程或任何与其它相互作用的进程的知识就可以启动进程迁移操作，这意味着迁移是透明的。这里以散列计算和对称加密为例。
Linux进程管理
chaney的博客
04-27 807
在Linux下存在进程process 和线程thread两个操作系统的基本概念。计算机的核心是CPU，承担机器的计算任务，好比一个工厂，不断的进行加工生产任务。进程就好比是工厂的一个车间，一个工厂可能有多个车间，而线程就好比车间中的工人。
Linux 中断（ IRQ / softirq ）基础：原理及内核实现
关注微信公众号【开源Linux】，后台回复『10T』，领取10T学习资源大放送，涵盖Linux、虚拟化、容器、云计算、网络、Python、Go等书籍和视频
08-25 893
中断（IRQ），尤其是软中断（softirq）的重要使用场景之一是网络收发包， 但并未唯一场景。本文整理 IRQ/softirq 的通用基础，这些东西和网络收发包没有直接关系， 虽然整理本文的直接目的是为了更好地理解网络收发包。什么是中断？CPU 通过时分复用来处理很多任务，这其中包括一些硬件任务，例如磁盘读写、键盘输入，也包括一些软件任务，例如网络包处理。在任意时刻，一个 CPU 只能处理一个任...
linux内核学习10：中断和异常
weixin_40535588的博客
10-15 9446
一、中断 1.1 中断的概念 中断是指在CPU正常运行期间，由于内外部事件或由程序预先安排的事件引起的 CPU 暂时停止正在运行的程序，转而为该内部或外部事件或预先安排的事件服务的程序中去，服务完毕后再返回去继续运行被暂时中断的程序。Linux中通常分为外部中断（又叫硬件中断）和内部中断（又叫异常）。 软件对硬件进行配置后，软件期望等待硬件的某种状态（比如，收到了数据），这里有两种方式， 轮询（polling）： CPU 不断的去读硬件状态。 中断：当硬件完成某种事件后，给 CPU 一个中断，让 CPU
Linux系统中的知名内核线程(1)——ksoftirqd和events
W_E_DAY的博客
03-27 176
http://blog.chinaunix.net/uid-28541347-id-5716840.html https://blog.csdn.net/tiangwan2011/article/details/7254806 https://zhuanlan.zhihu.com/p/80371745
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值