linux内核的软中断实现教程

软中断是内核提供的一种延迟机制，完全由软件触发。虽然是延迟机制，实际上，在大多数情况下，它比普通进程能够得到更快的响应。软中断也是内核其他机制的基础，如tasklet、高分辨率timer等。

软中断资料有限，目前内核中实现了10中类型的软中断

1. enum

2. {

3. HI_SOFTIRQ=0,

4. TIMER_SOFTIRQ,

5. NET_TX_SOFTIRQ,

6. NET_RX_SOFTIRQ,

7. BLOCK_SOFTIRQ,

8. BLOCK_IOPOLL_SOFTIRQ,

9. TASKLET_SOFTIRQ,

10. SCHED_SOFTIRQ,

11. HRTIMER_SOFTIRQ,

12. RCU_SOFTIRQ,/*PreferableRCUshouldalwaysbethelastsoftirq*/

13.

14. NR_SOFTIRQS

15. };

内核开发者不建议擅自增加软中断数量，如果需要新的软中断，尽可能它实现为基于tasklet形式

1、ksoftirqd

early_initcall(spawn_ksoftirqd);---初始化的时候调用spawn_ksoftirqd函数。

smpboot_register_percpu_thread(&softirq_threads)---热插拔阶段为每个percpu上创建一个ksoftirqd守护进程

1.DEFINE_PER_CPU(structtask_struct*,ksoftirqd);

2.

3. staticstructsmp_hotplug_threadsoftirq_threads={

4. .store=&ksoftirqd,

5. .thread_should_run=ksoftirqd_should_run,/*判断是否应该运行处理软中断*/

6. .thread_fn=run_ksoftirqd,/*运行处理软中断*/

7. .thread_comm="ksoftirqd/%u",

8. };

9.

10. staticvoidrun_ksoftirqd(unsignedintcpu)

11. {

12. /*关闭本地cpu中断*/

13. local_irq_disable();

14. if(local_softirq_pending()){/*检查本地cpu上是否有软中断挂起*/

15. /*

16. *Wecansafelyrunsoftirqoninlinestack,aswearenotdeep

17. *inthetaskstackhere.

18. */

19. __do_softirq();/*处理软中断*/

20. local_irq_enable();/*使能本地cpu中断*/

21. cond_resched();/*有条件的重新调度*/

22.

23. preempt_disable();

24. rcu_note_context_switch(cpu);

25. preempt_enable();

26.

27. return;

28. }

29. local_irq_enable();

30. }

2、结构

Irq_cpustat_t,多个软中断可以同时在多个cpu运行，就算是同一个软中断，也有可能同时在多个cpu上运行。内核为每个cpu都管理着一个待决软中断pedding，他就是Irq_cpustat_t

1. typedefstruct{

2. unsignedint__softirq_pending;

3. }____cacheline_alignedirq_cpustat_t;

4.

5.irq_cpustat_tirq_stat[NR_CPUS]____cacheline_aligned;

1. structsoftirq_action

2. {

3. void(*action)(structsoftirq_action*);

4. };

5. staticstructsoftirq_actionsoftirq_vec[NR_SOFTIRQS]__cacheline_aligned_in_smp;

__softirq_pending中每个bit，对应某一个软中断，某个Bit被置位，说明有相应的软总段等待处理。因此最多只能定义32个软中断类型。

3、软中断触发

想触发软中断，只需要调用raise_softirq即可，它的实现简单先关闭本地cpu中断，然后调用raise_softirq_irqoff，再打开本地cpu中断。

1. voidraise_softirq(unsignedintnr)

2. {

3. unsignedlongflags;

4.

5. local_irq_save(flags);

6. raise_softirq_irqoff(nr);

7. local_irq_restore(flags);

8. }

再来看raise_softirq_irqoff

1. inlinevoidraise_softirq_irqoff(unsignedintnr)

2. {

3. __raise_softirq_irqoff(nr);

4.

5. ......

6. if(!in_interrupt())

7. wakeup_softirqd();

8. }

先通过__raise_softirq_irqoff设置cpu的软中断pending标志位(irq_stat(NR_CPUS))，然后通过in_interrupt判断是否在中断上下文中，如果不成立，则唤醒软中断守护进程，在守护进程中执行软中断的回调函数。

4、软中断的执行

软中断有两种执行方式，一种是在中断调用结束时，一种是在ksoftirqd守护进程中

1. /*

2. *Exitaninterruptcontext.Processsoftirqsifneededandpossible:

3. */

4. voidirq_exit(void)

5. {

6. #ifndef__ARCH_IRQ_EXIT_IRQS_DISABLED

7. local_irq_disable();

8. #else

9. WARN_ON_ONCE(!irqs_disabled());

10. #endif

11.

12. account_irq_exit_time(current);

13. preempt_count_sub(HARDIRQ_OFFSET);

14. /*

15. 在中断发生嵌套时，通过in_interrupt能确保在最外层的中断Irq_exit阶段

16. invoke_softirq才会被调用

17. */

18. if(!in_interrupt()&&local_softirq_pending())

19. invoke_softirq();

20.

21. tick_irq_exit();

22. rcu_irq_exit();

23. trace_hardirq_exit();/*mustbelast!*/

24. }

代码最终都会进入到__do_softirq中，执行软中断的重点都在该函数中。

1. asmlinkagevoid__do_softirq(void)

2. {

3. unsignedlongend=jiffies+MAX_SOFTIRQ_TIME;

4. unsignedlongold_flags=current->flags;

5. intmax_restart=MAX_SOFTIRQ_RESTART;

6. structsoftirq_action*h;

7. boolin_hardirq;

8. __u32pending;

9. intsoftirq_bit;

10. intcpu;

11.

12. /*

13. *MaskoutPF_MEMALLOCscurrenttaskcontextisborrowedforthe

14. *softirq.AsoftirqhandledsuchasnetworkRXmightsetPF_MEMALLOC

15. *againifthesocketisrelatedtoswap

16. */

17. current->flags&=~PF_MEMALLOC;

18. /*

19. 复制软中断掩码到局部变量，这是必要的

20. 因为local_softirq_pending中的值在开中断后将不再可靠，必须先保存

21. */

22. pending=local_softirq_pending();

23. account_irq_enter_time(current);

24.

25. /*

26. 标志下面的代码正在处理softirq

27. */

28. __local_bh_disable_ip(_RET_IP_,SOFTIRQ_OFFSET);

29. in_hardirq=lockdep_softirq_start();

30.

31. cpu=smp_processor_id();

32. restart:

33. /*Resetthependingbitmaskbeforeenablingirqs*/

34. set_softirq_pending(0);/*清空pending*/

35.

36. local_irq_enable();/*打开本地中断*/

37.

38. /*

39. 到这里已经打开了本地中断，下面在软中断处理执行过程中可能会被硬件中断抢占

40. */

41. /*

42. 根据软中断标志位处理软中断

43. */

44. /* softirq_vec 存放action的结构体*/

45. h=softirq_vec;

46.

47. while((softirq_bit=ffs(pending))){

48. unsignedintvec_nr;

49. intprev_count;

50.

51. h+=softirq_bit-1;

52.

53. vec_nr=h-softirq_vec;

54. prev_count=preempt_count();

55.

56. kstat_incr_softirqs_this_cpu(vec_nr);

57.

58. trace_softirq_entry(vec_nr);

59. h->action(h);

60. trace_softirq_exit(vec_nr);

61. if(unlikely(prev_count!=preempt_count())){

62. pr_err("huh,enteredsoftirq%u%s%pwithpreempt_count%08x,exitedwith%08x",

63. vec_nr,softirq_to_name[vec_nr],h->action,

64. prev_count,preempt_count());

65. preempt_count_set(prev_count);

66. }

67. rcu_bh_qs(cpu);

68. h++;

69. pending>>=softirq_bit;

70. }

71.

72. /*关掉本地中断*/

73. local_irq_disable();

74. /*

75. 由于前面有打开过本地中断，因此这次可能会有新的软中断未处理，再检查处理，

76. */

77. pending=local_softirq_pending();

78. if(pending){

79. if(time_before(jiffies,end)&&!need_resched()&&

80. --max_restart)

81. gotorestart;

82.

83. wakeup_softirqd();

84. }

85.

86.

87. lockdep_softirq_end(in_hardirq);

88. account_irq_exit_time(current);

89. __local_bh_enable(SOFTIRQ_OFFSET);

90. WARN_ON_ONCE(in_interrupt());

91. tsk_restore_flags(current,old_flags,PF_MEMALLOC);

92. }

5、软中断注册

void open_softirq(int nr,void (*action)(struct softirq_action *))