Linux中断一网打尽(1) - IDT及中断处理的实现
通过阅读本文您可以了解到:
- IDT是什么 ;
- IDT如何被初始化;
- 什么是门;
- 传统系统调用是如何实现的;
- 硬件中断的实现;
如何设置IDT
IDT 中断描述符表定义
中断描述符表简单来说说是定义了发生中断/异常时,CPU按这张表中定义的行为来处理对应的中断/异常。
#define IDT_ENTRIES 256
gate_desc idt_table[IDT_ENTRIES] __page_aligned_bss;
从上面我们可以知道,其包含了256项,它是一个gate_desc
的数据,其下标0-256就表示中断向量,gate_desc
我们在下面马上介绍。
中断描述符项定义
当中断发生,cpu获取到中断向量后,查找IDT中断描述符表得到相应的中断描述符,再根据中断描述符记录的信息来作权限判断,运行级别转换,最终调用相应的中断处理程序;
-
这里涉及到Linux kernel的分段式内存管理,我们这里不详细展开,有兴趣的同学可以自行学习。如下简述之:
我们知道CPU只认识逻辑地址,逻辑地址经分段处理转换成线性地址,线性地址经分页处理最终转换成物理地址,这样就可以从内存中读取了;
逻辑地址你可以简单认为就是CPU执行代码时从CS(代码段寄存器) : IP (指令计数寄存器)中加载的代码,实际上通过CS可以得到逻辑地址的基地址,再加上IP这个相对于基地址的偏移量,就得到真正的逻辑地址;
CS寄存器16位,它不会包含真正的基地址,它一般被称为
段选择子
,包括一个index索引,指向GDT
或LDT
的一项;一个指示位,指示index索引是属于GDT
还是LDT
; 还有CPL
, 表明当前代码运行权限;GDT
: 全局描述符表,每一项记录着相应的段基址,段大小,段的访问权限DPL
等,到这里终于可以获取到段基地址了,再加上之前IP
寄存器里存放的偏移量,真正的逻辑地址就有了。-
附上简图:
-
我们先看中断描述符的定义:
struct gate_struct { u16 offset_low; u16 segment; struct idt_bits bits; u16 offset_middle; #ifdef CONFIG_X86_64 u32 offset_high; u32 reserved; #endif } __attribute__((packed));
其中:
offset_high
,offset_middle
和offset_low
合起来就是中断处理函数地址的偏移量;segment
就是相应的段选择子,根据它在GDT
中查找可以最终获取到段基地址;-
bits
是该中断描述符的一些属性值:struct idt_bits { u16 ist : 3, zero : 5, type : 5, dpl : 2, p : 1; } __attribute__((packed));
ist
表示此中断处理函数是使用pre-cpu的中断栈,还是使用IST的中断栈;type
表示所中断是何种类型,目前有以下四种:enum { GATE_INTERRUPT = 0xE, //中断门 GATE_TRAP = 0xF, // 陷入门 GATE_CALL = 0xC, // 调用门 GATE_TASK = 0x5, // 任务门 };
门
的概念这里主要用作权限控制,我们从一个区域进到另一个区域需要通过一扇门,有门禁权限才可以通过,因此dpl
就是这个权限,实际中我们一般称为RPL
;我们后面会通过一个例子来讲一下
CPL
,RPL
和DPL
三者之间的关系。
IDT 中断描述符表本身的存储
IDT 中断描述符表的物理地址存储在IDTR寄存器中,这个寄存器存储了IDT的基地址和长度。查询时,从 IDTR 拿到 base address ,加上向量号 * IDT entry size,即可以定位到对应的表项(gate)。
设置IDT
-
设置中断门类型的IDT描述符
static void set_intr_gate(unsigned int n, const void *addr) { struct idt_data data; BUG_ON(n > 0xFF); memset(&data, 0, sizeof(data)); data.vector = n; // 中断向量 data.addr = addr; // 中断处理函数的地址 data.segment = __KERNEL_CS; // 段选择子 data.bits.type = GATE_INTERRUPT; // 类型 data.bits.p = 1; idt_setup_from_table(idt_table, &data, 1, false); }
上面的函数主要是填充好
idt_data
,然后调用idt_setup_from_table
; -
idt_setup_from_table
:static void idt_setup_from_table(gate_desc *idt, const struct idt_data *t, int size, bool sys) { gate_desc desc; for (; size > 0; t++, size--) { idt_init_desc(&desc, t); write_idt_entry(idt, t->vector, &desc); if (sys) set_bit(t->vector, system_vectors); } }
首先使用
idt_data
结构来填充中断描述符变量idt_init_desc
, 然后将这个中断描述符变量copy进idt_table
。看,就是这么简单~~~
-
gate_desc
的多种初始化方法因为
gate_desc
是通过ida_dat
填充的,所以这里关键是idt_data
的初始化,我们详细看一下:/* Interrupt gate 中断门,DPL = 0 只能从内核调用 */ #define INTG(_vector, _addr) \ G(_vector, _addr, DEFAULT_STACK, GATE_INTERRUPT, DPL0, __KERNEL_CS) /* System interrupt gate 系统中断门,DPL = 3 可以从用户态调用,比如系统调用 */ #define SYSG(_vector, _addr) \ G(_vector, _addr, DEFAULT_STACK, GATE_INTERRUPT, DPL3, __KERNEL_CS) /* * Interrupt gate with interrupt stack. The _ist index is the index in * the tss.ist[] array, but for the descriptor it needs to start at 1. 中断门, DPL = 0 只能从内核态调用,使用TSS.IST[]作为中断栈 */ #define ISTG(_vector, _addr, _ist) \ G(_vector, _addr, _ist + 1, GATE_INTERRUPT, DPL0, __KERNEL_CS) /* Task gate 任务门, DPL = 0 只能作内核态调用 */ #define TSKG(_vector, _gdt) \ G(_vector, NULL, DEFAULT_STACK, GATE_TASK, DPL0, _gdt << 3)
我们再来看下
G
这个宏的实现:#define G(_vector, _addr, _ist, _type, _dpl, _segment) \ { \ .vector = _vector, \ .bits.ist = _ist, \ .bits.type = _type, \ .bits.dpl = _dpl, \ .bits.p = 1, \ .addr = _addr, \ .segment = _segment, \ }
实际上就是填充
idt_data
的各个字段。
传统系统调用的实现
这里所说的传统系统调用主要指旧的32位系统使用 int 0x80
软件中断来进入内核态,实现的系统调用。因为这种传统系统调用方式需要进入内核后作权限验证,还要切换内核栈后作大量压栈方式,调用结束后清理栈作恢复,两个字太慢,后来CPU从硬件上支持快速系统调用sysenter/sysexit
, 再后来又发展到syscall/sysret
, 这两种都不需要通过中断方式进入内核态,而是直接转换到内核态,速度快了很多。
传统系统调用相关 IDT 的设置
-
Linux系统启动过程中内核压解后最终都调用到
start_kernel
, 在这里会调用trap_init
, 然后又会调用idt_setup_traps
:void __init idt_setup_traps(void) { idt_setup_from_table(idt_table, def_idts, ARRAY_SIZE(def_idts), true); }
我们来看这里的
def_idts
的定义:static const __initconst struct idt_data def_idts[] = { .... #if defined(CONFIG_IA32_EMULATION) SYSG(IA32_SYSCALL_VECTOR, entry_INT80_compat), #elif defined(CONFIG_X86_32) SYSG(IA32_SYSCALL_VECTOR, entry_INT80_32), #endif };
上面的SYSG(IA32_SYSCALL_VECTOR, entry_INT80_32)
就是设置系统调用的异常中断处理程序,其中 #define IA32_SYSCALL_VECTOR 0x80
再看一下SYSG
的定义:
#define SYSG(_vector, _addr) \
G(_vector, _addr, DEFAULT_STACK, GATE_INTERRUPT, DPL3, __KERNEL_CS)
它初始化一个中断门,权限是DPL3, 因此从用户态是允许发起系统调用的。
我们调用系统调用,不大可能自已手写汇编代码,都是通过glibc来调用,基本流程是保存参数到寄存器,然后保存系统调用向量号到
eax
寄存器,然后调用int 0x80
进入内核态,切换到内核栈,将用户态时的ss/sp/eflags/cs/ip/error code依次压入内核栈。-
entry_INT80_32
系统调用对应的中断处理程序ENTRY(entry_INT80_32) ASM_CLAC pushl %eax /* pt_regs->orig_ax */ SAVE_ALL pt_regs_ax=$-ENOSYS switch_stacks=1 /* save rest */ TRACE_IRQS_OFF movl %esp, %eax call do_int80_syscall_32 .Lsyscall_32_done: ... .Lirq_return: INTERRUPT_RETURN ... ENDPROC(entry_INT80_32)
我们略去了中间的一些细节部分,可以看到首先将中断向量号压栈,再保存所有当前的寄存器值到
pt_regs
, 保存当前栈指针到%eax寄存器,最后再调用do_int80_syscall_32
, 这个函数中就会执行具体的中断处理,然后INTERRUPT_RETURN
恢复栈,作好返回用户态的准备。 do_int80_syscall_32
调用do_syscall_32_irqs_on
,我们看一下其实现:
static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs)
{
struct thread_info *ti = current_thread_info();
unsigned int nr = (unsigned int)regs->orig_ax;
#ifdef CONFIG_IA32_EMULATION
ti->status |= TS_COMPAT;
#endif
if (READ_ONCE(ti->flags) & _TIF_WORK_SYSCALL_ENTRY) {
nr = syscall_trace_enter(regs);
}
if (likely(nr < IA32_NR_syscalls)) {
nr = array_index_nospec(nr, IA32_NR_syscalls);
#ifdef CONFIG_IA32_EMULATION
regs->ax = ia32_sys_call_table[nr](regs);
#else
regs->ax = ia32_sys_call_table[nr](
(unsigned int)regs->bx, (unsigned int)regs->cx,
(unsigned int)regs->dx, (unsigned int)regs->si,
(unsigned int)regs->di, (unsigned int)regs->bp);
#endif /* CONFIG_IA32_EMULATION */
}
syscall_return_slowpath(regs);
}
通过中断向量号nr
从ia32_sys_call_table
中断向量表中索引到具体的中断处理函数然后调用之,其结果最终合存入%eax
寄存器。
一图以蔽之
硬件中断的实现
硬件中断的IDT初始化和调用流程
这里我们不讲解具体的代码细节,只关注流程 。
硬件中断相关IDT的初始化也是在Linux启动时完成,在start_kernel
中通过调用init_IRQ
完成,我们来看一下:
void __init init_IRQ(void)
{
int i;
for (i = 0; i < nr_legacy_irqs(); i++)
per_cpu(vector_irq, 0)[ISA_IRQ_VECTOR(i)] = irq_to_desc(i);
BUG_ON(irq_init_percpu_irqstack(smp_processor_id()));
x86_init.irqs.intr_init(); // 即调用 native_init_IRQ
}
void __init native_init_IRQ(void)
{
/* Execute any quirks before the call gates are initialised: */
x86_init.irqs.pre_vector_init();
idt_setup_apic_and_irq_gates();
lapic_assign_system_vectors();
if (!acpi_ioapic && !of_ioapic && nr_legacy_irqs())
setup_irq(2, &irq2);
}
重点在于idt_setup_apic_and_irq_gates
:
*/
void __init idt_setup_apic_and_irq_gates(void)
{
int i = FIRST_EXTERNAL_VECTOR;
void *entry;
idt_setup_from_table(idt_table, apic_idts, ARRAY_SIZE(apic_idts), true);
for_each_clear_bit_from(i, system_vectors, FIRST_SYSTEM_VECTOR) {
entry = irq_entries_start + 8 * (i - FIRST_EXTERNAL_VECTOR);
set_intr_gate(i, entry);
}
}
其中的set_intr_gate
用来初始化硬件相关的调用门,其对应的中断门处理函数在irq_entries_start
中定义,它位于arch/x86/entry/entry_64.S
中:
.align 8
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)
这段汇编实现对不大熟悉汇编的同学可能看起来有点晕,其实很简单它相当于填充一个中断处理函数的数组,填充多少次呢? (FIRST_SYSTEM_VECTOR - FIRST_EXTERNAL_VECTOR)
这就是次数,数组的每一项都是一个函数:
UNWIND_HINT_IRET_REGS
pushq $(~vector+0x80) /* Note: always in signed byte range */
jmp common_interrupt
即先将中断号压栈,然后跳转到common_interrupt
执行,可以看到这个common_interrupt
是硬件中断的通用处理函数,它里面最主要的就是调用do_IRQ
:
__visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
struct irq_desc * desc;
/* high bit used in ret_from_ code */
unsigned vector = ~regs->orig_ax;
entering_irq();
/* entering_irq() tells RCU that we're not quiescent. Check it. */
RCU_LOCKDEP_WARN(!rcu_is_watching(), "IRQ failed to wake up RCU");
desc = __this_cpu_read(vector_irq[vector]);
if (likely(!IS_ERR_OR_NULL(desc))) {
if (IS_ENABLED(CONFIG_X86_32))
handle_irq(desc, regs);
else
generic_handle_irq_desc(desc);
} else {
ack_APIC_irq();
if (desc == VECTOR_UNUSED) {
pr_emerg_ratelimited("%s: %d.%d No irq handler for vector\n",
__func__, smp_processor_id(),
vector);
} else {
__this_cpu_write(vector_irq[vector], VECTOR_UNUSED);
}
}
exiting_irq();
set_irq_regs(old_regs);
return 1;
}
首先根据中断向量号获取到对应的中断描述符irq_desc, 然后调用generic_handle_irq
来处理:
static inline void generic_handle_irq_desc(struct irq_desc *desc)
{
desc->handle_irq(desc);
}
这里最终会调用到中断描述符的handle_irq
,因此另一个重点就是这个中断描述符的设置了,它可以单开一篇文章来讲,我们暂不详述了。