Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1748488
  • 博文数量: 199
  • 博客积分: 10
  • 博客等级: 民兵
  • 技术积分: 6186
  • 用 户 组: 普通用户
  • 注册时间: 2012-10-30 11:01
个人简介

Linuxer.

文章存档

2015年(4)

2014年(28)

2013年(167)

分类: LINUX

2013-07-18 11:05:38


  1. 一、软中断描述
  2. 1.中断服务程序往往都是在CPU关中断的条件下执行的,以避免中断嵌套而使控制复杂化。但是CPU关中断的时间不能太长,否则容易丢失中断信号。为此, Linux将中断服务程序一分为二,各称作“Top Half”和“Bottom Half”。前者通常对时间要求较为严格,必须在中断请求发生后立即或至少在一定的时间限制内完成。因此为了保证这种处理能原子地完成,Top Half通常是在CPU关中断的条件下执行的。
  3. //软中断本身是一种机制,同时也是一种框架。在这个框架里有bh机制(tasklet),即是一种特殊的软中断
  4. enum//四种软中断机制
  5. {
  6.     HI_SOFTIRQ=0, //实现高优先级的软中断
  7.     NET_TX_SOFTIRQ,
  8.     NET_RX_SOFTIRQ,
  9.     TASKLET_SOFTIRQ //tasklet机制
  10. };
  11. 具体地说,Top Half的范围包括:从在IDT中登记的中断入口函数一直到驱动程序注册在中断服务队列中的ISR。而Bottom Half则是Top Half根据需要来调度执行的,这些操作允许延迟到稍后执行,它的时间要求并不严格,因此它通常是在CPU开中断的条件下执行的。但是, Linux的这种Bottom Half(以下简称BH)机制有两个缺点,也即:
  12. (1)在任意一时刻,系统只能有一个CPU可以执行Bottom Half代码,以防止两个或多个CPU同时来执行Bottom Half函数而相互干扰。因此BH代码的执行是严格“串行化”的。
  13. (2)BH函数不允许嵌套。
  14. 这两个缺点在单CPU系统中是无关紧要的,但在SMP系统中却是非常致命的。因为BH机制的严格串行化执行显然没有充分利用SMP系统的多CPU特点。为此,Linux2.4内核在BH机制的基础上进行了扩展,这就是所谓的“软中断请求”(softirq)机制。

  15. 2.Linux 的softirq机制是与SMP紧密不可分的。为此,整个softirq机制的设计与实现中自始自终都贯彻了一个思想:“谁触发,谁执行”(Who marks,Who runs),也即触发软中断的那个CPU负责执行它所触发的软中断,而且每个CPU都由它自己的软中断触发与控制机制。这个设计思想也使得softirq 机制充分利用了SMP系统的性能和特点。
  16. Linux在include/linux/interrupt.h头文件中定义了数据结构softirq_action,来描述一个软中断请求,如下所示:
  17. struct softirq_action
  18. {
  19.     void (*action)(struct softirq_action *);//指向软中断请求的服务函数
  20.     void *data;//由服务函数自行解释的数据
  21. }
  22. static struct softirq_action softirq_vec[32] __cacheline_aligned;
  23. 在这里系统一共定义了32个软中断请求描述符。软中断向量i(0≤i≤31)所对应的软中断请求描述符就是softirq_vec[i]。这个数组是个系统全局数组,也即它被所有的CPU所共享。这里需要注意的一点是:每个CPU虽然都由它自己的触发和控制机制,并且只执行他自己所触发的软中断请求,但是各个CPU所执行的软中断服务例程却是相同的,也即都是执行softirq_vec[]数组中定义的软中断服务函数。

  24. 3.要实现“谁触发,谁执行”的思想,就必须为每个CPU都定义它自己的触发和控制变量。为此,Linux在include/asm-i386/hardirq.h头文件中定义了数据结构irq_cpustat_t来描述一个CPU的中断统计信息,其中就有用于触发和控制软中断的成员变量。数据结构irq_cpustat_t 的定义如下:
  25. typedef struct {
  26.     unsigned int __softirq_active;//表示软中断向量0~31的状态。如果bit[i](0≤i≤31)为1,则表示软中断向量i在某个CPU上已经被触发而处于active状态;为0表示处于非活跃状态。
  27.     unsigned int __softirq_mask; //32位的无符号整数,软中断向量的屏蔽掩码。如果bit[i](0≤i≤31)为1,则表示使能(enable)软中断向量i,为0表示该软中断向量被禁止(disabled)。
  28.     unsigned int __local_irq_count;
  29.     unsigned int __local_bh_count;
  30.     unsigned int __syscall_count;
  31.     unsigned int __nmi_count; /* arch dependent */
  32. } ____cacheline_aligned irq_cpustat_t;

  33. 根据系统中当前的CPU个数(由宏NR_CPUS表示),Linux在kernel/softirq.c文件中为每个CPU都定义了它自己的中断统计信息结构,如下所示:
  34. irq_cpustat_t irq_stat[NR_CPUS];
  35. 这样,每个CPU都只操作它自己的中断统计信息结构。假设有一个编号为id的CPU,那么它只能操作它自己的中断统计信息结构irq_stat[id](0≤id≤NR_CPUS-1),从而使各CPU之间互不影响。

  36. 二、软中断初始化
  37. 1.
  38. void __init softirq_init()
  39. {
  40.     int i;
  41.     
  42.     //初始化tasklet机制
  43.     for (i=0; i<32; i++)//对bh的32个tasklet_struct结构初始化
  44.         tasklet_init(bh_task_vec+i, bh_action, i);//tasklet机制func函数全部指向bh_action()
  45.     
  46.     //初始化软中断机制,软中断服务函数指针分别指向 tasklet_action()函数和tasklet_hi_action()函数
  47.     open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);//对TASKLET_SOFTIRQ软中断进行初始化
  48.     open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);//对HI_SOFTIRQ软中断进行初始化
  49. }

  50. 2.tasklet结构
  51. //原有的32个BH函数指针被保留
  52. static void (*bh_base[32])(void);
  53. //但是,每个BH函数都对应有一个tasklet,并由tasklet的可执行函数func来负责调用相应的bh函数(func函数的参数指定调用哪一个BH函数)。与32个BH函数指针相对应的tasklet的定义如下所示:
  54. struct tasklet_struct bh_task_vec[32];
  55. //Linux用数据结构tasklet_struct来描述一个tasklet,尽管tasklet机制是特定于软中断向量HI_SOFTIRQ和TASKLET_SOFTIRQ的一种实现,但是tasklet机制仍然属于 softirq机制的整体框架范围内的。
  56. struct tasklet_struct
  57. {
  58.     struct tasklet_struct *next;
  59.     unsigned long state;
  60.     atomic_t count;
  61.     void (*func)(unsigned long); //指向服务程序,最终执行的程序是bh_base[n]中定义的函数
  62.     unsigned long data;
  63. };

  64. //多个tasklet可以通过tasklet描述符中的next成员指针链接成一个单向对列。为此,Linux专门定义了数据结构tasklet_head来描述一个tasklet对列的头部指针。
  65. struct tasklet_head tasklet_hi_vec[NR_CPUS] __cacheline_aligned;
  66. struct tasklet_head
  67. {
  68.     struct tasklet_struct *list;
  69. } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));

  70. 3.tasklet初始化
  71. //bh_base[]数组中每个元素用来指向一个bh函数
  72. //init_bh()将具体的软中断服务程序挂入软中断服务队列
  73. //init_bh(TIMER_BH, timer_bh);
  74. //init_bh(TQUEUE_BH, tqueue_bh);
  75. //init_bh(IMMEDIATE_BH, immediate_bh);
  76. /*
  77. enum {
  78.     TIMER_BH = 0,
  79.     TQUEUE_BH,
  80.     DIGI_BH,
  81.     SERIAL_BH,
  82.     RISCOM8_BH,
  83.     SPECIALIX_BH,
  84.     AURORA_BH,
  85.     ESP_BH,
  86.     SCSI_BH,
  87.     IMMEDIATE_BH,
  88.     CYCLADES_BH,
  89.     CM206_BH,
  90.     JS_BH,
  91.     MACSERIAL_BH,
  92.     ISICOM_BH
  93. };
  94. */

  95. void init_bh(int nr, void (*routine)(void))
  96. {
  97.     bh_base[nr] = routine;//tasklet最终要去执行的函数
  98.     mb();//内存屏障
  99. }

  100. //初始化bh_task_vec[]
  101. void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)
  102. {
  103.     t->func = func;//全部指向bh_action()
  104.     t->data = data;
  105.     t->state = 0;
  106.     atomic_set(&t->count, 0);//使用计数设为0
  107. }

  108. 4.软中断初始化
  109. void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
  110. {
  111.     unsigned long flags;
  112.     int i;
  113.     
  114.     spin_lock_irqsave(&softirq_mask_lock, flags);
  115.     softirq_vec[nr].data = data;
  116.     softirq_vec[nr].action = action;//若是TASKLET_SOFTIRQ,则指向tasklet_action()
  117.     //将所有CPU的软中断屏蔽掩码变量softirq_mask中的对应位设置为1,以使能该软中断向量
  118.     for (i=0; i<NR_CPUS; i++)//NR_CPUS是系统cpu个数
  119.         softirq_mask(i) |= (1<<nr);
  120.     spin_unlock_irqrestore(&softirq_mask_lock, flags);
  121. }

  122. 三、tasklet机制的软中断执行
  123. /*bottom half通过发送软中断信号HI_SOFTIRQ,linux通过do_softirq处理,这时的过程是
  124. do_softirq-> tasklet_hi_action-> bh_task_vec->bh_action->bh_base。最终处理工作由bh_base函数指针数组指向的函数完成。
  125. init_bh(TIMER_BH, timer_bh);
  126. init_bh(TQUEUE_BH, tqueue_bh);
  127. init_bh(IMMEDIATE_BH, immediate_bh);
  128. 所以计时器bottom half的最终处理函数是timer_bh。
  129. */
  130. //mark_bh()提出执行保护函数的请求
  131. static inline void mark_bh(int nr)
  132. {
  133.     tasklet_hi_schedule(bh_task_vec+nr);
  134. }

  135. //tasklet_vec[]数组用于软中断向量TASKLET_SOFTIRQ,而tasklet_hi_vec[]数组则用于软中断向量 HI_SOFTIRQ。
  136. static inline void tasklet_hi_schedule(struct tasklet_struct *t)
  137. {
  138.     if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {//是否已经挂在别的队列上
  139.         int cpu = smp_processor_id();
  140.         unsigned long flags;
  141.     
  142.         local_irq_save(flags);
  143.         t->next = tasklet_hi_vec[cpu].list;
  144.         tasklet_hi_vec[cpu].list = t;//将tasklet挂入bh请求队列,即将bh_task_vec[nr]挂入头部指针tasklet_hi_vec中
  145.         __cpu_raise_softirq(cpu, HI_SOFTIRQ);//发出软中断请求
  146.         local_irq_restore(flags);
  147.     }
  148. }

  149. static inline void __cpu_raise_softirq(int cpu, int nr)
  150. {
  151.     softirq_active(cpu) |= (1<<nr);//软中断请求寄存器相应位置1
  152. }

  153. //在do_IRQ()执行完服务程序时,都会检查是否有软中断在等待
  154. //if (softirq_active(cpu) & softirq_mask(cpu))
  155. // do_softirq();
  156. //do_softirq-> tasklet_hi_action-> bh_task_vec->bh_action->bh_base。最终处理工作由bh_base函数指针数组指向的函数完成
  157. asmlinkage void do_softirq()
  158. {
  159. 52 int cpu = smp_processor_id();
  160. 53 __u32 active, mask;
  161. 54
  162. 55 if (in_interrupt())//不允许在硬中断服务程序和软中断服务程序中运行
  163. 56 return;
  164. 57 /*#define cpu_bh_disable(cpu) do { local_bh_count(cpu)++; barrier(); } while (0)
  165.     #define cpu_bh_enable(cpu) do { barrier(); local_bh_count(cpu)--;} while (0)
  166.     #define local_bh_disable() cpu_bh_disable(smp_processor_id())
  167.     #define local_bh_enable() cpu_bh_enable(smp_processor_id())
  168.    */
  169. 58 local_bh_disable();//把当前CPU的中断统计信息结构中的__local_bh_count成员变量加1,表示当前CPU已经处在软中断服务状态。
  170. 60 local_irq_disable();//关中断
  171. 61 mask = softirq_mask(cpu);//
  172. 62 active = softirq_active(cpu) & mask;//与mask相与看是否有软中断服务被触发
  173. 63
  174. 64 if (active) {
  175. 65 struct softirq_action *h;
  176. restart:
  177. 69 softirq_active(cpu) &= ~active;//先将当前CPU的__softirq_active中的相应位清零
  178. 71 local_irq_enable();//打开当前CPU的中断
  179. 72 //若是tasklet,则softirq_vec->action指向tasklet_action()
  180.         //若是HI_SOFTIRQ, 则softirq_vec->action指向tasklet_hi_action()
  181. 73 h = softirq_vec;
  182. 74 mask &= ~active;
  183. 75
  184. 76 do {
  185. 77 if (active & 1)
  186. 78 h->action(h);//循环来根据active的值去执行相应的软中断服务函数
  187. 79 h++; //若是tasklet,去执行tasklet_action()
  188. 80 active >>= 1;
  189. 81 } while (active);
  190. 82
  191. 83 local_irq_disable();//关中断,是为了下面再一次检查active的值
  192. 84
  193. 85 active = softirq_active(cpu);//读取当前CPU的 __softirq_active变量的值,
  194. 86 if ((active &= mask) != 0)//并将它与局部变量mask进行与操作,以看看是否又有其他软中断服务被触发了
  195. 87 goto retry;
  196. 88 }
  197. 90 local_bh_enable();//表示当前CPU已经离开软中断服务状态
  198. 96 return;
  199. 97
  200. retry:
  201. 99 goto restart;
  202. }

  203. static void tasklet_action(struct softirq_action *a)
  204. {
  205. 126 int cpu = smp_processor_id();
  206. 127 struct tasklet_struct *list;
  207. 128
  208. 129 local_irq_disable();
  209. 130 list = tasklet_vec[cpu].list;//从tasklet_vec数组中取出队列头
  210. 131 tasklet_vec[cpu].list = NULL;
  211. 132 local_irq_enable();
  212. 133
  213. 134 while (list != NULL) {//遍历由list所指向的tasklet队列,队列中的各个元素就是将在当前CPU上执行的tasklet
  214. 135 struct tasklet_struct *t = list;
  215. 137 list = list->next;
  216. 138 //依次取出队列中的bh_task_vec[nr]
  217. 139 if (tasklet_trylock(t)) {
  218. 140 if (atomic_read(&t->count) == 0) {//如果count为0,说明这个tasklet是允许执行的
  219. 141 clear_bit(TASKLET_STATE_SCHED, &t->state);//清TASKLET_STATE_SCHED标志
  220. 143 t->func(t->data);//执行bh_task_vec[nr]->func,都指向bh_action()
  221. #ifdef CONFIG_SMP
  222. 150 smp_mb__before_clear_bit();
  223. #endif
  224. 152 tasklet_unlock(t);
  225. 153 continue;
  226. 154 }
  227. 155 tasklet_unlock(t);
  228. 156 }
  229. 157 local_irq_disable();
  230. 158 t->next = tasklet_vec[cpu].list;
  231. 159 tasklet_vec[cpu].list = t;//把这个tasklet重新放回到当前CPU的tasklet队列的首部
  232. 160 __cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);//再触发一次软中断请求TASKLET_SOFTIRQ
  233. 161 local_irq_enable();
  234. 162 }
  235. }

  236. static void bh_action(unsigned long nr)
  237. {
  238. 248 int cpu = smp_processor_id();//当前cpu的逻辑号
  239. 249 //试图对自旋锁global_bh_lock进行加锁,同时该函数还将返回自旋锁global_bh_lock 的原有值的非
  240. 250 if (!spin_trylock(&global_bh_lock))
  241. 251 goto resched;
  242. 252 //锁定当前CPU,确保当前CPU不是处于硬件中断请求服务中
  243. 253 if (!hardirq_trylock(cpu))
  244. 254 goto resched_unlock;
  245. 255 //当前CPU上执行BH函数
  246. 256 if (bh_base[nr])//若是TIMER_BH, timer_bh
  247. 257 bh_base[nr]();//这里会去执行timer_bh()函数
  248. 258
  249. 259 hardirq_endlock(cpu);
  250. 260 spin_unlock(&global_bh_lock);
  251. 261 return;
  252. 262
  253. resched_unlock:
  254. 264 spin_unlock(&global_bh_lock);
  255. resched:
  256. 266 mark_bh(nr);
  257. }

  258. 四、实现原理
  259. 1.软中断实现原理图

  260. 2.Tasklet机制的实现原理如下图所示

阅读(10713) | 评论(0) | 转发(6) |
给主人留下些什么吧!~~