Linux中断(interrupt)子系统之三:中断流控处理层【转】

简介:

转自:http://blog.csdn.net/droidphone/article/details/7489756

1.  中断流控层简介

早期的内核版本中,几乎所有的中断都是由__do_IRQ函数进行处理,但是,因为各种中断请求的电气特性会有所不同,又或者中断控制器的特性也不同,这会导致以下这些处理也会有所不同:

  • 何时对中断控制器发出ack回应;
  • mask_irq和unmask_irq的处理;
  • 中断控制器是否需要eoi回应?
  • 何时打开cpu的本地irq中断?以便允许irq的嵌套;
  • 中断数据结构的同步和保护;

/*****************************************************************************************************/
声明:本博内容均由http://blog.csdn.net/droidphone原创,转载请注明出处,谢谢!
/*****************************************************************************************************/
为此,通用中断子系统把几种常用的流控类型进行了抽象,并为它们实现了相应的标准函数,我们只要选择相应的函数,赋值给irq所对应的irq_desc结构的handle_irq字段中即可。这些标准的回调函数都是irq_flow_handler_t类型:

[cpp]  view plain  copy
  1. typedef void (*irq_flow_handler_t)(unsigned int irq,  
  2.                         struct irq_desc *desc);  

目前的通用中断子系统实现了以下这些标准流控回调函数,这些函数都定义在:kernel/irq/chip.c中,

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

驱动程序和板级代码可以通过以下几个API设置irq的流控函数:

  • irq_set_handler();
  • irq_set_chip_and_handler();
  • irq_set_chip_and_handler_name();

以下这个序列图展示了整个通用中断子系统的中断响应过程,flow_handle一栏就是中断流控层的生命周期:


                                                                                           图1.1  通用中断子系统的中断响应过程

2.  handle_simple_irq

该函数没有实现任何实质性的流控操作,在把irq_desc结构锁住后,直接调用handle_irq_event处理irq_desc中的action链表,它通常用于多路复用(类似于中断控制器级联)中的子中断,由父中断的流控回调中调用。或者用于无需进行硬件控制的中断中。以下是它的经过简化的代码:

[cpp]  view plain  copy
  1. void  
  2. handle_simple_irq(unsigned int irq, struct irq_desc *desc)  
  3. {  
  4.     raw_spin_lock(&desc->lock);  
  5.     ......  
  6.     handle_irq_event(desc);  
  7.   
  8. out_unlock:  
  9.     raw_spin_unlock(&desc->lock);  
  10. }  

3.  handle_level_irq

该函数用于处理电平中断的流控操作。电平中断的特点是,只要设备的中断请求引脚(中断线)保持在预设的触发电平,中断就会一直被请求,所以,为了避免同一中断被重复响应,必须在处理中断前先把mask irq,然后ack irq,以便复位设备的中断请求引脚,响应完成后再unmask irq。实际的情况稍稍复杂一点,在mask和ack之后,还要判断IRQ_INPROGRESS标志位,如果该标志已经置位,则直接退出,不再做实质性的处理,IRQ_INPROGRESS标志在handle_irq_event的开始设置,在handle_irq_event结束时清除,如果监测到IRQ_INPROGRESS被置位,表明该irq正在被另一个CPU处理中,所以直接退出,对电平中断来说是正确的处理方法。但是我觉得在ARM系统中,这种情况根本就不会发生,因为在没有进入handle_level_irq之前,中断控制器没有收到ack通知,它不会向第二个CPU再次发出中断请求,而当程序进入handle_level_irq之后,第一个动作就是mask irq,然后ack irq(通常是联合起来的:mask_ack_irq),这时候就算设备再次发出中断请求,也是在handle_irq_event结束,unmask irq之后,这时IRQ_INPROGRESS标志已经被清除。我不知道其他像X86之类的体系是否有不同的行为,有知道的朋友请告知我一下。以下是handle_level_irq经过简化之后的代码:
[cpp]  view plain  copy
  1. void  
  2. handle_level_irq(unsigned int irq, struct irq_desc *desc)  
  3. {  
  4.     raw_spin_lock(&desc->lock);  
  5.     mask_ack_irq(desc);  
  6.   
  7.     if (unlikely(irqd_irq_inprogress(&desc->irq_data)))  
  8.             goto out_unlock;  
  9.         ......  
  10.   
  11.     if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))  
  12.         goto out_unlock;  
  13.   
  14.     handle_irq_event(desc);  
  15.   
  16.     if (!irqd_irq_disabled(&desc->irq_data) && !(desc->istate & IRQS_ONESHOT))  
  17.         unmask_irq(desc);  
  18. out_unlock:  
  19.     raw_spin_unlock(&desc->lock);  
  20. }  
虽然handle_level_irq对电平中断的流控进行了必要的处理,因为电平中断的特性:只要没有ack irq,中断线会一直有效,所以我们不会错过某次中断请求,但是驱动程序的开发人员如果对该过程理解不透彻,特别容易发生某次中断被多次处理的情况。特别是使用了中断线程(action->thread_fn)来响应中断的时候:通常mask_ack_irq只会清除中断控制器的pending状态,很多慢速设备(例如通过i2c或spi控制的设备)需要在中断线程中清除中断线的pending状态,但是未等到中断线程被调度执行的时候,handle_level_irq早就返回了,这时已经执行过unmask_irq,设备的中断线pending处于有效状态,中断控制器会再次发出中断请求,结果是设备的一次中断请求,产生了两次中断响应。要避免这种情况,最好的办法就是不要单独使用中断线程处理中断,而是要实现request_threaded_irq()的第二个参数irq_handler_t:handler,在handle回调中使用disable_irq()关闭该irq,然后在退出中断线程回调前再enable_irq()。假设action->handler没有屏蔽irq,以下这幅图展示了电平中断期间IRQ_PROGRESS标志、本地中断状态和触发其他CPU的状态:
                                          图3.1  电平触发中断状态
上图中颜色分别代表不同的状态:
状态 红色 绿色
IRQ_PROGRESS            TRUE        FALSE
是否允许本地cpu中断             禁止                 允许  
是否允许该设备再次触发中断(可能由其它cpu响应)             禁止           允许

4.  handle_edge_irq

该函数用于处理边沿触发中断的流控操作。边沿触发中断的特点是,只有设备的中断请求引脚(中断线)的电平发生跳变时(由高变低或者有低变高),才会发出中断请求,因为跳变是一瞬间,而且不会像电平中断能保持住电平,所以处理不当就特别容易漏掉一次中断请求,为了避免这种情况,屏蔽中断的时间必须越短越好。内核的开发者们显然意识到这一点,在正是处理中断前,判断IRQ_PROGRESS标志没有被设置的情况下,只是ack irq,并没有mask irq,以便复位设备的中断请求引脚,在这之后的中断处理期间,另外的cpu可以再次响应同一个irq请求,如果IRQ_PROGRESS已经置位,表明另一个CPU正在处理该irq的上一次请求,这种情况下,他只是简单地设置IRQS_PENDING标志,然后mask_ack_irq后退出,中断请求交由原来的CPU继续处理。因为是mask_ack_irq,所以系统实际上只允许挂起一次中断。
[cpp]  view plain  copy
  1. if (unlikely(irqd_irq_disabled(&desc->irq_data) ||  
  2.          irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {  
  3.     if (!irq_check_poll(desc)) {  
  4.         desc->istate |= IRQS_PENDING;  
  5.         mask_ack_irq(desc);  
  6.         goto out_unlock;  
  7.     }  
  8. }  
  9.   
  10. desc->irq_data.chip->irq_ack(&desc->irq_data);  
从上面的分析可以知道,处理中断期间,另一次请求可能由另一个cpu响应后挂起,所以在处理完本次请求后还要判断IRQS_PENDING标志,如果被置位,当前cpu要接着处理被另一个cpu“委托”的请求。内核在这里设置了一个循环来处理这种情况,直到IRQS_PENDING标志无效为止,而且因为另一个cpu在响应并挂起irq时,会mask irq,所以在循环中要再次unmask irq,以便另一个cpu可以再次响应并挂起irq:
[cpp]  view plain  copy
  1. do {  
  2.                ......  
  3.     if (unlikely(desc->istate & IRQS_PENDING)) {  
  4.         if (!irqd_irq_disabled(&desc->irq_data) &&  
  5.             irqd_irq_masked(&desc->irq_data))  
  6.             unmask_irq(desc);  
  7.     }  
  8.   
  9.     handle_irq_event(desc);  
  10.   
  11. while ((desc->istate & IRQS_PENDING) &&  
  12.      !irqd_irq_disabled(&desc->irq_data));  
IRQS_PENDING标志会在handle_irq_event中清除。

                                 图4.1   边沿触发中断状态
上图中颜色分别代表不同的状态:
状态         红色         绿色
IRQ_PROGRESS         TRUE         FALSE
是否允许本地cpu中断         禁止         允许
是否允许该设备再次触发中断(可能由其它cpu响应)         禁止         允许
是否处于中断上下文     处于中断上下文     处于进程上下文

由图4.1也可以看出,在处理软件中断(softirq)期间,此时仍然处于中断上下文中,但是cpu的本地中断是处于打开状态的,这表明此时嵌套中断允许发生,不过这不要紧,因为重要的处理已经完成,被嵌套的也只是软件中断部分而已。这个也就是内核区分top和bottom两个部分的初衷吧。

5.  handle_fasteoi_irq

现代的中断控制器通常会在硬件上实现了中断流控功能,例如ARM体系中的GIC通用中断控制器。对于这种中断控制器,CPU只需要在每次处理完中断后发出一个end of interrupt(eoi),我们无需关注何时mask,何时unmask。不过虽然想着很完美,事情总有特殊的时候,所以内核还是给了我们插手的机会,它利用irq_desc结构中的preflow_handler字段,在正式处理中断前会通过preflow_handler函数调用该回调。
[cpp]  view plain  copy
  1. void  
  2. handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)  
  3. {  
  4.     raw_spin_lock(&desc->lock);  
  5.   
  6.     if (unlikely(irqd_irq_inprogress(&desc->irq_data)))  
  7.         if (!irq_check_poll(desc))  
  8.             goto out;  
  9.         ......  
  10.     if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {  
  11.         desc->istate |= IRQS_PENDING;  
  12.         mask_irq(desc);  
  13.         goto out;  
  14.     }  
  15.   
  16.     if (desc->istate & IRQS_ONESHOT)  
  17.         mask_irq(desc);  
  18.   
  19.     preflow_handler(desc);  
  20.     handle_irq_event(desc);  
  21.   
  22. out_eoi:  
  23.     desc->irq_data.chip->irq_eoi(&desc->irq_data);  
  24. out_unlock:  
  25.     raw_spin_unlock(&desc->lock);  
  26.     return;  
  27.         ......  
  28. }  
此外,内核还提供了另外一个eoi版的函数: handle_edge_eoi_irq,它的处理类似于handle_edge_irq,只是无需实现mask和unmask的逻辑。

6.  handle_percpu_irq

该函数用于smp系统,当某个irq只在一个cpu上处理时,我们可以无需用自旋锁对数据进行保护,也无需处理cpu之间的中断嵌套重入,所以函数很简单:
[cpp]  view plain  copy
  1. void  
  2. handle_percpu_irq(unsigned int irq, struct irq_desc *desc)  
  3. {  
  4.     struct irq_chip *chip = irq_desc_get_chip(desc);  
  5.   
  6.     kstat_incr_irqs_this_cpu(irq, desc);  
  7.   
  8.     if (chip->irq_ack)  
  9.         chip->irq_ack(&desc->irq_data);  
  10.   
  11.     handle_irq_event_percpu(desc, desc->action);  
  12.   
  13.     if (chip->irq_eoi)  
  14.         chip->irq_eoi(&desc->irq_data);  
  15. }  

7.  handle_nested_irq

该函数用于实现其中一种中断共享机制,当多个中断共享某一根中断线时,我们可以把这个中断线作为父中断,共享该中断的各个设备作为子中断,在父中断的中断线程中决定和分发响应哪个设备的请求,在得出真正发出请求的子设备后,调用handle_nested_irq来响应中断。所以,该函数是在进程上下文执行的,我们也无需扫描和执行irq_desc结构中的action链表。父中断在初始化时必须通过irq_set_nested_thread函数明确告知中断子系统:这些子中断属于线程嵌套中断类型,这样驱动程序在申请这些子中断时,内核不会为它们建立自己的中断线程,所有的子中断共享父中断的中断线程。

[cpp]  view plain  copy
    1. void handle_nested_irq(unsigned int irq)  
    2. {  
    3.     ......  
    4.         might_sleep();  
    5.   
    6.     raw_spin_lock_irq(&desc->lock);  
    7.         ......  
    8.     action = desc->action;  
    9.     if (unlikely(!action || irqd_irq_disabled(&desc->irq_data)))  
    10.         goto out_unlock;  
    11.   
    12.     irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);  
    13.     raw_spin_unlock_irq(&desc->lock);  
    14.   
    15.     action_ret = action->thread_fn(action->irq, action->dev_id);  
    16.   
    17.     raw_spin_lock_irq(&desc->lock);  
    18.     irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);  
    19.   
    20. out_unlock:  
    21.     raw_spin_unlock_irq(&desc->lock);  










本文转自张昺华-sky博客园博客,原文链接: http://www.cnblogs.com/sky-heaven/p/7457903.html ,如需转载请自行联系原作者
相关实践学习
容器服务Serverless版ACK Serverless 快速入门:在线魔方应用部署和监控
通过本实验,您将了解到容器服务Serverless版ACK Serverless 的基本产品能力,即可以实现快速部署一个在线魔方应用,并借助阿里云容器服务成熟的产品生态,实现在线应用的企业级监控,提升应用稳定性。
云原生实践公开课
课程大纲 开篇:如何学习并实践云原生技术 基础篇: 5 步上手 Kubernetes 进阶篇:生产环境下的 K8s 实践 相关的阿里云产品:容器服务 ACK 容器服务 Kubernetes 版(简称 ACK)提供高性能可伸缩的容器应用管理能力,支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力,打造云端最佳容器化应用运行环境。 了解产品详情: https://www.aliyun.com/product/kubernetes
相关文章
|
5月前
|
Ubuntu Linux
Win10 Ubuntu子系统(内嵌ubuntu18.04)运行32bit Linux原生程序 解决Exec format error错误
Win10 Ubuntu子系统(内嵌ubuntu18.04)运行32bit Linux原生程序 解决Exec format error错误
118 0
|
7月前
|
安全 Linux
Linux内核OverlayFS子系统权限提升漏洞(CVE-2023-0386)
Linux内核OverlayFS子系统权限提升漏洞,在Linux内核的 OverlayFS子系统中,当用户将一个具有权限的文件从一个nosuid挂载点复制到另一个挂载点时,未经授权的攻击者可以执行setuid文件,导致权限提升。
102 1
|
3月前
|
Linux Windows Ubuntu
Windows 使用 Linux 子系统,轻轻松松安装多个linux
Windows 使用 Linux 子系统,轻轻松松安装多个linux
50 0
Windows 使用 Linux 子系统,轻轻松松安装多个linux
|
3月前
|
算法 Linux 芯片
Linux驱动-I2C子系统基本分析
Linux驱动-I2C子系统基本分析
33 0
|
3月前
|
消息中间件 存储 Linux
嵌入式Linux系统中SPI 子系统基本实现
嵌入式Linux系统中SPI 子系统基本实现
29 0
|
3月前
|
存储 Ubuntu 关系型数据库
在Windows WSL (Linux的Windows子系统)上运行的Ubuntu 20.04安装Bacula失败
Bacula 是一个开源的跨平台网络备份工具,提供基于客户端/服务器(CS)架构的企业级备份解决方案。它支持对数据进行备份、恢复以及完整性校验,并且可以运行在多种操作系统上,包括 Windows 和 Linux 等。
23 0
|
3月前
|
算法 Linux API
一文聊聊Linux Kernel的加密子系统【Crypto Subsystem】
一文聊聊Linux Kernel的加密子系统【Crypto Subsystem】
94 1
|
4月前
|
人工智能 Ubuntu Linux
linux配置魔搭社区modelscope时的whl下载中断问题和解决方案
本文提供了断点续传和手动安装两个方案。
112 3
|
4月前
|
存储 安全 Linux
Linux中断(tasklet,工作队列,内核线程的使用)
Linux中断(tasklet,工作队列,内核线程的使用)
38 0
|
4月前
|
存储 Linux API
Linux系统对中断的处理
Linux系统对中断的处理
50 0