[Linux内核]软中断与硬中断

 1 static struct softirq_action softirq_vec[NR_SOFTIRQS];  
 2   
 3 enum {  
 4     HI_SOFTIRQ = 0, /* 优先级高的tasklets */  
 5     TIMER_SOFTIRQ, /* 定时器的下半部 */  
 6     NET_TX_SOFTIRQ, /* 发送网络数据包 */  
 7     NET_RX_SOFTIRQ, /* 接收网络数据包 */  
 8     BLOCK_SOFTIRQ, /* BLOCK装置 */  
 9     BLOCK_IOPOLL_SOFTIRQ,  
10     TASKLET_SOFTIRQ, /* 正常优先级的tasklets */  
11     SCHED_SOFTIRQ, /* 调度程序 */  
12     HRTIMER_SOFTIRQ, /* 高分辨率定时器 */  
13     RCU_SOFTIRQ, /* RCU锁定 */  
14     NR_SOFTIRQS /* 10 */  
15 };  

 1 static inline void __rasie_softirq_irqoff(unsigned int nr)  
 2 {  
 3     trace_softirq_raise(nr);  
 4     or_softirq_pending(1UL << nr);  
 5 }  
 6   
 7 typedef struct {  
 8     unsigned int __softirq_pending;  
 9     unsigned int __nmi_count; /* arch dependent */  
10 } irq_cpustat_t;  
11   
12 irq_cpustat_t irq_stat[];  
13 #define __IRQ_STAT(cpu, member) (irq_stat[cpu].member)  
14 #define or_softirq_pending(x) percpu_or(irq_stat.__softirq_pending, (x))  
15 #define local_softirq_pending() percpu_read(irq_stat.__softirq_pending)   

1 static void wakeup_softirqd(void)  
2 {  
3     /* Interrupts are disabled: no need to stop preemption */  
4     struct task_struct *tsk = __get_cpu_var(ksoftirqd);  
5   
6     if (tsk && tsk->state != TASK_RUNNING)  
7         wake_up_process(tsk);  
8 }  

 1 asmlinkage void do_softirq(void)  
 2 {  
 3     __u32 pending;  
 4     unsigned long flags;  
 5   
 6     /* 如果当前已处于硬中断或软中断中，直接返回 */  
 7     if (in_interrupt())   
 8         return;  
 9   
10     local_irq_save(flags);  
11     pending = local_softirq_pending();  
12     if (pending) /* 如果有激活的软中断 */  
13         __do_softirq(); /* 处理函数 */  
14     local_irq_restore(flags);  
15 }  

 1 /* We restart softirq processing MAX_SOFTIRQ_RESTART times, 
 2  * and we fall back to softirqd after that. 
 3  * This number has been established via experimentation. 
 4  * The two things to balance is latency against fairness - we want 
 5  * to handle softirqs as soon as possible, but they should not be 
 6  * able to lock up the box. 
 7  */  
 8 asmlinkage void __do_softirq(void)  
 9 {  
10     struct softirq_action *h;  
11     __u32 pending;  
12     /* 本函数能重复触发执行的次数，防止占用过多的cpu时间 */  
13     int max_restart = MAX_SOFTIRQ_RESTART;  
14     int cpu;  
15   
16     pending = local_softirq_pending(); /* 激活的软中断位图 */  
17     account_system_vtime(current);  
18     /* 本地禁止当前的软中断 */  
19     __local_bh_disable((unsigned long)__builtin_return_address(0), SOFTIRQ_OFFSET);  
20     lockdep_softirq_enter(); /* current->softirq_context++ */  
21     cpu = smp_processor_id(); /* 当前cpu编号 */  
22   
23 restart:  
24     /* Reset the pending bitmask before enabling irqs */  
25     set_softirq_pending(0); /* 重置位图 */  
26     local_irq_enable();  
27     h = softirq_vec;  
28     do {  
29         if (pending & 1) {  
30             unsigned int vec_nr = h - softirq_vec; /* 软中断索引 */  
31             int prev_count = preempt_count();  
32             kstat_incr_softirqs_this_cpu(vec_nr);  
33   
34             trace_softirq_entry(vec_nr);  
35             h->action(h); /* 调用软中断的处理函数 */  
36             trace_softirq_exit(vec_nr);  
37   
38             if (unlikely(prev_count != preempt_count())) {  
39                 printk(KERN_ERR "huh, entered softirq %u %s %p" "with preempt_count %08x,"  
40                     "exited with %08x?
", vec_nr, softirq_to_name[vec_nr], h->action, prev_count,  
41                     preempt_count());  
42             }  
43             rcu_bh_qs(cpu);  
44         }  
45         h++;  
46         pending >>= 1;  
47     } while(pending);  
48   
49     local_irq_disable();  
50     pending = local_softirq_pending();  
51     if (pending & --max_restart) /* 重复触发 */  
52         goto restart;  
53   
54     /* 如果重复触发了10次了，接下来唤醒ksoftirqd/n内核线程来处理 */  
55     if (pending)  
56         wakeup_softirqd();   
57   
58     lockdep_softirq_exit();  
59     account_system_vtime(current);  
60     __local_bh_enable(SOFTIRQ_OFFSET);  
61 }   

 1 static int run_ksoftirqd(void *__bind_cpu)  
 2 {  
 3     set_current_state(TASK_INTERRUPTIBLE);  
 4     current->flags |= PF_KSOFTIRQD; /* I am ksoftirqd */  
 5   
 6     while(! kthread_should_stop()) {  
 7         preempt_disable();  
 8   
 9         if (! local_softirq_pending()) { /* 如果没有要处理的软中断 */  
10             preempt_enable_no_resched();  
11             schedule();  
12             preempt_disable():  
13         }  
14   
15         __set_current_state(TASK_RUNNING);  
16   
17         while(local_softirq_pending()) {  
18             /* Preempt disable stops cpu going offline. 
19              * If already offline, we'll be on wrong CPU: don't process. 
20              */  
21              if (cpu_is_offline(long)__bind_cpu))/* 被要求释放cpu */  
22                  goto wait_to_die;  
23   
24             do_softirq(); /* 软中断的统一处理函数 */  
25   
26             preempt_enable_no_resched();  
27             cond_resched();  
28             preempt_disable();  
29             rcu_note_context_switch((long)__bind_cpu);  
30         }  
31   
32         preempt_enable();  
33         set_current_state(TASK_INTERRUPTIBLE);  
34     }  
35   
36     __set_current_state(TASK_RUNNING);  
37     return 0;  
38   
39 wait_to_die:  
40     preempt_enable();  
41     /* Wait for kthread_stop */  
42     set_current_state(TASK_INTERRUPTIBLE);  
43     while(! kthread_should_stop()) {  
44         schedule();  
45         set_current_state(TASK_INTERRUPTIBLE);  
46     }  
47   
48     __set_current_state(TASK_RUNNING);  
49     return 0;  
50 }