x86 kernel 中断分析三——中断处理流程

原创 2017年01月03日 15:12:59

CPU检测中断

CPU在执行每条程序之前会检测是否有中断到达,即中断控制器是否有发送中断信号过来

查找IDT

CPU根据中断向量到IDT中读取对应的中断描述符表项,根据段选择符合偏移确定中断服务程序的地址见附录2

interrupt数组

在分析一中,我们看到,填充IDT中断服务程序的是interrupt数组的内容,所以第2步跳转到interrupt数组对应的表项,表项的内容之前也已分析过

push vector num and jmp to common_interrupt

 778 /*
 779  * the CPU automatically disables interrupts when executing an IRQ vector,
 780  * so IRQ-flags tracing has to follow that:
 781  */
 782     .p2align CONFIG_X86_L1_CACHE_SHIFT
 783 common_interrupt:
 784     ASM_CLAC
 785     addl $-0x80,(%esp)  /* Adjust vector into the [-256,-1] range */ 
 786     SAVE_ALL
 787     TRACE_IRQS_OFF
 788     movl %esp,%eax
 789     call do_IRQ
 790     jmp ret_from_intr
 791 ENDPROC(common_interrupt)
 792     CFI_ENDPROC

addl $-0x80,(%esp)

根据第一篇分析,此时栈顶是(~vector + 0x80),这里减去0x80,所以值为vector num取反,范围在[-256, -1]。这么做是为了和系统调用区分,正值为系统调用号,负值为中断向量。

SAVE_ALL

保存现场,将所有寄存器的值压栈(cs eip ss esp由系统自动保存)

186 .macro SAVE_ALL
 187     cld
 188     PUSH_GS
 189     pushl_cfi %fs
 190     /*CFI_REL_OFFSET fs, 0;*/
 191     pushl_cfi %es
 192     /*CFI_REL_OFFSET es, 0;*/
 193     pushl_cfi %ds
 194     /*CFI_REL_OFFSET ds, 0;*/
 195     pushl_cfi %eax
 196     CFI_REL_OFFSET eax, 0
 197     pushl_cfi %ebp
 198     CFI_REL_OFFSET ebp, 0
 199     pushl_cfi %edi
 200     CFI_REL_OFFSET edi, 0
 201     pushl_cfi %esi
 202     CFI_REL_OFFSET esi, 0
 203     pushl_cfi %edx
 204     CFI_REL_OFFSET edx, 0
 205     pushl_cfi %ecx
 206     CFI_REL_OFFSET ecx, 0
 207     pushl_cfi %ebx
 208     CFI_REL_OFFSET ebx, 0
 209     movl $(__USER_DS), %edx
 210     movl %edx, %ds
 211     movl %edx, %es
 212     movl $(__KERNEL_PERCPU), %edx
 213     movl %edx, %fs
 214     SET_KERNEL_GS %edx
 215 .endm

movl %esp,%eax

将esp的值赋值给eax,eax作为do_IRQ的第一个参数,esp的值是以上压栈的寄存器的内容,以pt_reg形式传过去。

call do_IRQ

175 /*
176  * do_IRQ handles all normal device IRQ's (the special
177  * SMP cross-CPU interrupts have their own specific
178  * handlers).
179  */
180 __visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
181 {
182     struct pt_regs *old_regs = set_irq_regs(regs);
183
184     /* high bit used in ret_from_ code  */
185     unsigned vector = ~regs->orig_ax;       //获取向量号,这里有一个取反的操作,与之前的取反相对应得到正的向量号
186     unsigned irq;
187
188     irq_enter();
189     exit_idle();
190
191     irq = __this_cpu_read(vector_irq[vector]);       //通过向量号得到中断号
192
193     if (!handle_irq(irq, regs)) {
194         ack_APIC_irq();
195
196         if (irq != VECTOR_RETRIGGERED) {
197             pr_emerg_ratelimited("%s: %d.%d No irq handler for vector (irq %d)\n",
198                          __func__, smp_processor_id(),
199                          vector, irq);
200         } else {
201             __this_cpu_write(vector_irq[vector], VECTOR_UNDEFINED);
202         }
203     }
204
205     irq_exit();
206
207     set_irq_regs(old_regs);
208     return 1;
209 }

irq_enter

319 /*
  320  * Enter an interrupt context.  //进入中断上下文,因为首先处理的是硬中断,所以我们可以把irq_enter认为是硬中断的开始
  321  */
  322 void irq_enter(void)
  323 {
  324     rcu_irq_enter();                                    //inform RCU that current CPU is entering irq away from idle
  325     if (is_idle_task(current) && !in_interrupt()) {   //如果当前是pid==0的idle task并且不处于中断上下文中
  326         /*
  327          * Prevent raise_softirq from needlessly waking up ksoftirqd
  328          * here, as softirq will be serviced on return from interrupt.
  329          */
  330         local_bh_disable();
  331         tick_irq_enter();     //idle进程会被中断或者其他进程抢占,在系统中断过程中用irq_enter->tick_irq_enter()恢复周期性tick以得到正确的jiffies值(这段注释摘录自http://blog.chinaunix.net/uid-29675110-id-4365095.html)
  332         _local_bh_enable();
  333     }
  334
  335     __irq_enter();
  336 }

__irq_enter

28 /*
 29  * It is safe to do non-atomic ops on ->hardirq_context,
 30  * because NMI handlers may not preempt and the ops are
 31  * always balanced, so the interrupted value of ->hardirq_context
 32  * will always be restored.
 33  */
 34 #define __irq_enter()                   \
 35     do {                        \
 36         account_irq_enter_time(current);    \
 37         preempt_count_add(HARDIRQ_OFFSET);  \             //HARDIRQ_OFFSET等于1左移16位,即将preempt_count第16 bit加1,preempt_count的格式见附录
 38         trace_hardirq_enter();          \
 39     } while (0)

exit_idle

如果系统正处在idle状态,那么退出IDLE

258 /* Called from interrupts to signify idle end */
259 void exit_idle(void)
260 {
261     /* idle loop has pid 0 */          //如果当前进程不为0,直接退出,不需要退出 idle
262     if (current->pid)
263         return;
264     __exit_idle();            //如果是idle进程,那么通过__exit_idle调用一系列notification
265 }

handle_irq

165 bool handle_irq(unsigned irq, struct pt_regs *regs)
166 {
167     struct irq_desc *desc;
168     int overflow;
169
170     overflow = check_stack_overflow();  //x86架构下如果sp指针距离栈底的位置小于1KB,则认为有stack overflow的风险
171
172     desc = irq_to_desc(irq);                        //获取desc,从刚开始的vector num-->irq num--> desc
173     if (unlikely(!desc))
174         return false;
175  //如果发生中断时,CPU正在执行用户空间的代码,处理中断需切换到内核栈,但此时内核栈是空的,所以无需再切换到中断栈
176     if (user_mode_vm(regs) || !execute_on_irq_stack(overflow, desc, irq)) {     // 在CPU的irq stack执行,否则在当前进程的栈执行,调用下面的desc->handle_irq  
177         if (unlikely(overflow))
178             print_stack_overflow();
179         desc->handle_irq(irq, desc);
180     }
181
182     return true;
183 }

中断栈的定义及初始化

按照目前的内核设计,中断有自己的栈,用来执行中断服务程序,这样是为了防止中断嵌套破坏与之共享的
中断栈的定义,可以看到与进程上下文的布局相同,thread info + stack

 58 /*
 59  * per-CPU IRQ handling contexts (thread information and stack)
 60  */
 61 union irq_ctx {
 62     struct thread_info      tinfo;
 63     u32                     stack[THREAD_SIZE/sizeof(u32)];
 64 } __attribute__((aligned(THREAD_SIZE)));

中断栈的初始化:

创建percpu变量hardirq_ctx和softirq_ctx,类型为irq_ctx,所以每个cpu的软硬中断有各自的stack

 66 static DEFINE_PER_CPU(union irq_ctx *, hardirq_ctx);
 67 static DEFINE_PER_CPU(union irq_ctx *, softirq_ctx);

native_init_IRQ->irq_ctx_init
hardirq_ctx和softirq_ctx的初始化方式相同,如下

116 /*
117  * allocate per-cpu stacks for hardirq and for softirq processing
118  */
119 void irq_ctx_init(int cpu)
120 {
121     union irq_ctx *irqctx;
122
123     if (per_cpu(hardirq_ctx, cpu))
124         return;
125
126     irqctx = page_address(alloc_pages_node(cpu_to_node(cpu),      //分配2个page      
127                            THREADINFO_GFP,
128                            THREAD_SIZE_ORDER));
129     memset(&irqctx->tinfo, 0, sizeof(struct thread_info));       //初始化其中的部分成员
130     irqctx->tinfo.cpu       = cpu;
131     irqctx->tinfo.addr_limit    = MAKE_MM_SEG(0);
132
133     per_cpu(hardirq_ctx, cpu) = irqctx;                             //赋值给hardirq_ctx
134
135     irqctx = page_address(alloc_pages_node(cpu_to_node(cpu),
136                            THREADINFO_GFP,
137                            THREAD_SIZE_ORDER));
138     memset(&irqctx->tinfo, 0, sizeof(struct thread_info));
139     irqctx->tinfo.cpu       = cpu;
140     irqctx->tinfo.addr_limit    = MAKE_MM_SEG(0);
141
142     per_cpu(softirq_ctx, cpu) = irqctx;
143
144     printk(KERN_DEBUG "CPU %u irqstacks, hard=%p soft=%p\n",
145            cpu, per_cpu(hardirq_ctx, cpu),  per_cpu(softirq_ctx, cpu));
146 }

网上找的一张图,如下
这里写图片描述

中断栈的切换

发生中断时需要从当前进程栈切换到中断栈

 80 static inline int
 81 execute_on_irq_stack(int overflow, struct irq_desc *desc, int irq)
 82 {
 83     union irq_ctx *curctx, *irqctx;
 84     u32 *isp, arg1, arg2;
 85
 86     curctx = (union irq_ctx *) current_thread_info();       //获取当前进程的process context,即栈的起始地址
 87     irqctx = __this_cpu_read(hardirq_ctx);                  //获取硬中断的hardirq context,即栈的起始地址
 88
 89     /*
 90      * this is where we switch to the IRQ stack. However, if we are
 91      * already using the IRQ stack (because we interrupted a hardirq
 92      * handler) we can't do that and just have to keep using the
 93      * current stack (which is the irq stack already after all)
 94      */
 95     if (unlikely(curctx == irqctx))                //如果当前进程的栈和中断栈相同,说明发生了中断嵌套,此时当前进程就是一个中断的服务例程
 96         return 0;                                   //这种情况下不能进行栈的切换,还是在当前栈中运行,只要返回0即可
 97
 98     /* build the stack frame on the IRQ stack */
 99     isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));           //获取中断栈的isp
100     irqctx->tinfo.task = curctx->tinfo.task;                    //获取当前进程的task和stack point
101     irqctx->tinfo.previous_esp = current_stack_pointer;
102
103     if (unlikely(overflow))
104         call_on_stack(print_stack_overflow, isp);
105
106     asm volatile("xchgl %%ebx,%%esp \n"                    //具体的栈切换发生在以下汇编中,基本上就是保存现场,进行切换,不深入研究汇编了...
107              "call  *%%edi      \n"
108              "movl  %%ebx,%%esp \n"
109              : "=a" (arg1), "=d" (arg2), "=b" (isp)
110              :  "0" (irq),   "1" (desc),  "2" (isp),
111             "D" (desc->handle_irq)                                    //不管是共享栈还是独立栈,最后都会调用到irq desc对应的handle_irq
112              : "memory", "cc", "ecx");
113     return 1;
114 }

handle_level_irq

kernel中对于中断有一系列的中断流处理函数

handle_simple_irq  用于简易流控处理;
handle_level_irq   用于电平触发中断的流控处理;
handle_edge_irq    用于边沿触发中断的流控处理;
handle_fasteoi_irq  用于需要响应eoi的中断控制器;
handle_percpu_irq   用于只在单一cpu响应的中断;
handle_nested_irq   用于处理使用线程的嵌套中断;

我们在第二篇分析中,init_ISA_irqs把legacy irq的中断流处理函数都设置为handle_level_irq,以此为例做分析:

//level type中断,当硬件中断line的电平处于active level时就一直保持有中断请求,这就要求处理中断过程中屏蔽中断,响应硬件后打开中断
387 /**
388  *  handle_level_irq - Level type irq handler          //电平触发的中断处理函数
389  *  @irq:   the interrupt number
390  *  @desc:  the interrupt description structure for this irq
391  *
392  *  Level type interrupts are active as long as the hardware line has          
393  *  the active level. This may require to mask the interrupt and unmask        
394  *  it after the associated handler has acknowledged the device, so the
395  *  interrupt line is back to inactive.
396  */
397 void
398 handle_level_irq(unsigned int irq, struct irq_desc *desc)
399 {
400     raw_spin_lock(&desc->lock);                         //上锁
401     mask_ack_irq(desc);       //mask对应的中断,否则一直接收来自interrupt line的中断信号
402
403     if (unlikely(irqd_irq_inprogress(&desc->irq_data)))  //如果该中断正在其他cpu上被处理
404         if (!irq_check_poll(desc))  //这边不是很理解,irq的IRQS_POLL_INPROGRESS(polling in a progress)是什么意思?只能等后续代码遇到这个宏的时候再说。如果是在该状态,cpu relax,等待完成
405             goto out_unlock;                        //直接解锁退出
406     //清除IRQS_REPLAY和IRQS_WAITING标志位
407     desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
408     kstat_incr_irqs_this_cpu(irq, desc);   //该CPU上该irq触发次数加1,总的中断触发次数加1
409
410     /*
411      * If its disabled or no action available
412      * keep it masked and get out of here
413      */
414     if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
415         desc->istate |= IRQS_PENDING;                   //设置为pending
416         goto out_unlock;
417     }
418
419     handle_irq_event(desc);                        //核心函数
420
421     cond_unmask_irq(desc);                           //使能中断线
422
423 out_unlock:
424     raw_spin_unlock(&desc->lock);
425 }
426 EXPORT_SYMBOL_GPL(handle_level_irq);

handle irq event

182 irqreturn_t handle_irq_event(struct irq_desc *desc)
183 {
184     struct irqaction *action = desc->action;         //获取irqaction链表
185     irqreturn_t ret;
186
187     desc->istate &= ~IRQS_PENDING;        //正式进入处理流程,清除irq desc的pending标志位
188     irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);        //处理中断前设置IRQD_IRQ_INPROGRESS标志
189     raw_spin_unlock(&desc->lock);
190
191     ret = handle_irq_event_percpu(desc, action);            
192
193     raw_spin_lock(&desc->lock);
194     irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);   //处理中断后清除IRQD_IRQ_INPROGRESS标志
195     return ret;
196 }

handle_irq_event_percpu

132 irqreturn_t
133 handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
134 {
135     irqreturn_t retval = IRQ_NONE;
136     unsigned int flags = 0, irq = desc->irq_data.irq;
137
138     do {
139         irqreturn_t res;
140
141         trace_irq_handler_entry(irq, action);
142         res = action->handler(irq, action->dev_id); //调用硬中断处理函数
143         trace_irq_handler_exit(irq, action, res);
144
145         if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
146                   irq, action->handler))
147             local_irq_disable();
148
149         switch (res) {
150         case IRQ_WAKE_THREAD:      //线程化中断的硬中断,通常只是响应一下硬件ack,就返会IRQ_WAKE_THREAD,唤醒软中断线程
151             /*
152              * Catch drivers which return WAKE_THREAD but
153              * did not set up a thread function
154              */
155             if (unlikely(!action->thread_fn)) {
156                 warn_no_thread(irq, action);
157                 break;
158             }
159
160             irq_wake_thread(desc, action);            //唤醒软中断线程
161
162             /* Fall through to add to randomness */
163         case IRQ_HANDLED:                        //表示已经在硬中断中处理完毕
164             flags |= action->flags;
165             break;
166
167         default:
168             break;
169         }
170
171         retval |= res;
172         action = action->next;            //对于共享中断,所有irqaction挂在同一desc下
173     } while (action);
174
175     add_interrupt_randomness(irq, flags);    //这块代码其实和中断流程的关系不大,利用用户和外设作为噪声源,为内核随机熵池做贡献....(http://jingpin.jikexueyuan.com/article/23923.html)
176
177     if (!noirqdebug)
178         note_interrupt(irq, desc, retval);
179     return retval;
180 }

以上就是中断处理流程的简要分析,有个问题,中action的handler及线程化的软中断从何而来?下篇分析见。

附录1:

CPU使用IDT查到的中断服务程序的段选择符从GDT中取得相应的段描述符,段描述符里保存了中断服务程序的段基址和属性信息,此时CPU就得到了中断服务程序的起始地址。这里,CPU会根据当前cs寄存器里的CPL和GDT的段描述符的DPL,以确保中断服务程序是高于当前程序的,如果这次中断是编程异常(如:int 80h系统调用),那么还要检查CPL和IDT表中中断描述符的DPL,以保证当前程序有权限使用中断服务程序,这可以避免用户应用程序访问特殊的陷阱门和中断门[3]。
如下图显示了从中断向量到GDT中相应中断服务程序起始位置的定位方式:

这里写图片描述

附录2. preempt_count:

 44 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)         // 1左移16位
 32 #define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)  // 8 + 8 = 16
 31 #define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)  // 0 + 8 = 8
 30 #define PREEMPT_SHIFT   0
 25 #define PREEMPT_BITS    8
 26 #define SOFTIRQ_BITS    8

2500 void __kprobes preempt_count_add(int val)
2501 {
2502 #ifdef CONFIG_DEBUG_PREEMPT
2503     /*
2504      * Underflow?
2505      */
2506     if (DEBUG_LOCKS_WARN_ON((preempt_count() < 0)))
2507         return;
2508 #endif
2509     __preempt_count_add(val);    //除去debug相关的内容,只有这一行关键代码,将preempt_count中第16 bit加1
2510 #ifdef CONFIG_DEBUG_PREEMPT
2511     /*
2512      * Spinlock count overflowing soon?
2513      */
2514     DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
2515                 PREEMPT_MASK - 10);
2516 #endif
2517     if (preempt_count() == val)
2518         trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
2519 }
2520 EXPORT_SYMBOL(preempt_count_add);

preempt_count的布局如下:
这里写图片描述

X86架构中断的处理

中断控制器8259A的原理和使用   讨论这些问题,首先要了解中断的概念,什么是中断,中断是怎么一回事。这是基础,可以查阅相关资料去学习。 中断控制器呢?就是在有多个中断源的系统中,接受外部的中...
  • pankul
  • pankul
  • 2013年02月26日 18:38
  • 1259

x86中断控制器

UP的APIC的建立过程讲述UP的中断建立过程。内核版本2.6.9-78;ich8,cpu:intel-530。许多内容不讲,一带而过。内核config:# CONFIG_SMP is not set...

实验3前篇——X86的中断管理

实验3主要内容是用户进程的创建,运行,销毁;从操作系统的角度来看用户进程,可以看作是动态加载可运行的程序,然后进行不断地动态切换,这里我们当然也可以从虚拟机的角度来考察操作系统——操作系统其实是在硬件...
  • yiye_01
  • yiye_01
  • 2015年11月11日 21:34
  • 865

linux kernel中断处理

一、什么是下半部中断是一个很霸道的东西,处理器一旦接收到中断,就会打断正在执行的代码,调用中断处理函数。如果在中断处理函数中没有禁止中断,该中断处理函数执行过程中仍有可能被其他中断打断。出于这样的原因...

Linux内核源代码情景分析-中断下半部(软中断)

Tasklet机制是一种较为特殊的软中断。Tasklet一词的原意是“小片任务”的意思,这里是指一小段可执行的代码,且通常以函数的形式出现。软中断向量HI_SOFTIRQ和TASKLET_SOFTIR...
  • jltxgcy
  • jltxgcy
  • 2015年03月13日 08:25
  • 950

把握linux内核设计思想(四):下半部机制之tasklet

【版权声明:尊重原创,转载请保留出处:blog.csdn.net/shallnet,文章仅供学习交流,请勿用于商业用途】         tasklet是利用软中断实现的一种下半部机制。tasklet...

Exynos4412 中断驱动开发(二)—— 中断处理流程分析

前面已经学习了中断的注册过程,下面由一张流程图来看一下当中断发生时的处理流程: 中断发生之后处理流程 a -- 具体的CPU architecture相关模块进行现场保护,然后调用machin...

Exynos4412 中断驱动开发(二)—— 中断处理流程分析

前面已经学习了中断的注册过程,下面由一张流程图来看一下当中断发生时的处理流程: 中断发生之后处理流程 a -- 具体的CPU architecture相关模块进行现...

linux内核分析--中断处理流程

linux内核的中断处理, 里面由始至终都贯穿着"重要的事马上做, 不重要的事推后做"的异步处理思想. 于是整理一下~ 第一阶段--获取中断号 每个CPU都有响应中断的能力, 每个CPU响应中断时...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:x86 kernel 中断分析三——中断处理流程
举报原因:
原因补充:

(最多只允许输入30个字)