tasklet的实现【2】

 2.调度tasklet

     已触发的tasklet存放在两个单处理器结构中：tasklet_vec(普通tasklet)和tasklet_hi_vec(高优先级的tasklet)。这两个数据结构都是有tasklet_struct结构体构成的链表，链表中的每个tasklet_struct代表一个不同的tasklet。

     tasklet由tasklet_schedule()和tasklet_hi_schedule()函数进行调度，它们接受一个指向tasklet_struct结构的指针作为参数。

2. 在<Interrupt.h(include/linux)>中
4. static inline void tasklet_schedule(struct tasklet_struct *t)
5. {
6.     if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))/*检查tasklet的状态是否为TASKLET_STATE_SCHED，如果是，说明tasklet已经被调度过了（有可能是一个tasklet已经被调度过但还没有来得及执行，而该tasklet又被唤起了一次），函数立即返回。*/
7.         __tasklet_schedule(t);
8. }
10. static inline void tasklet_hi_schedule(struct tasklet_struct *t)
11. {
12.     if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
13.         __tasklet_hi_schedule(t);
14. }
16. 在<Softirq.c(Kernel)>中
18. void fastcall __tasklet_schedule(struct tasklet_struct *t)
19. {
20.     unsigned long flags;
22.     local_irq_save(flags);//保存中断状态，然后禁止本地中断。
23.     /*把需要调度的tasklet加到每个处理器一个的tasklet_vec链表的表头上*/
24.     t->next = __get_cpu_var(tasklet_vec).list;
25.     __get_cpu_var(tasklet_vec).list = t;
26.    /*唤起TASKLET_SOFTIRQ软中断，下次调用do_softirq()时就会执行该tasklet*/
27.     raise_softirq_irqoff(TASKLET_SOFTIRQ);
28.     local_irq_restore(flags);/*恢复中断到原状态并返回*/
29. }
31. void fastcall __tasklet_hi_schedule(struct tasklet_struct *t)
32. {
33.     unsigned long flags;
35.     local_irq_save(flags);
36.     t->next = __get_cpu_var(tasklet_hi_vec).list;
37.     __get_cpu_var(tasklet_hi_vec).list = t;
38.     raise_softirq_irqoff(HI_SOFTIRQ);
39.     local_irq_restore(flags);
40. }
42. 在<Bitops.h(include/asm-i386)>
43. /**
44.  * __test_and_set_bit - Set a bit and return its old value
45.  * @nr: Bit to set
46.  * @addr: Address to count from
47.  *
48.  * This operation is non-atomic and can be reordered.  
49.  * If two examples of this operation race, one can appear to succeed
50.  * but actually fail.  You must protect multiple accesses with a lock.
51.  */
52. static inline int __test_and_set_bit(int nr, volatile unsigned long * addr)
53. {
54.     int oldbit;
56.     __asm__(
57.         "btsl %2,%1/n/tsbbl %0,%0"
58.         :"=r" (oldbit),"+m" (ADDR)
59.         :"Ir" (nr));
60.     return oldbit;
61. }

1. /**
2.  * test_and_set_bit - Set a bit and return its old value
3.  * @nr: Bit to set
4.  * @addr: Address to count from
5.  *
6.  * This operation is atomic and cannot be reordered.  
7.  * It may be reordered on other architectures than x86.
8.  * It also implies a memory barrier.
9.  */
10. static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
11. {
12.     int oldbit;
14.     __asm__ __volatile__( LOCK_PREFIX
15.         "btsl %2,%1/n/tsbbl %0,%0"
16.         :"=r" (oldbit),"+m" (ADDR)
17.         :"Ir" (nr) : "memory");
18.     return oldbit;
19. }   

 由于大部分tasklet和软中断都是在中断处理程序中被设置成待处理状态，所以最近一个中断返回的时候看起来就是执行do_softirq()的最佳时期。因为TASKLET_SOFTIRQ和HI_SOFTIRQ已经被触发了，所以do_softirq()会执行相应的软中断处理程序。tasklet_action()和tasklet_hi_action()，就是tasklet处理的核心。

1. 在<Softirq.c（kernel）>中
2. static void tasklet_action(struct softirq_action *a)
3. {
4.     struct tasklet_struct *list;
6.     local_irq_disable();/*禁止中断*/
7.     list = __get_cpu_var(tasklet_vec).list;
8.     __get_cpu_var(tasklet_vec).list = NULL;/*将当前处理器上的该链表设置为NULL，达到清空的效果*/
9.     local_irq_enable();/*恢复响应中断*/
10.     /*循环遍历获得链表上的每一个待处理的tasklet*/
11.     while (list) {
12.         struct tasklet_struct *t = list;
14.         list = list->next;
15. /* 如果是多处理器系统，通过检查TASKLET_STATE_RUN状态标志来判断这个tasklet是否正在其他处理器上运行。如果它正在运行，那么现在就不要执行，跳到下一个待处理的tasklet去 。如果当前这个tasklet没有执行，将其状态标志设置为TASKLET_STATE_RUN，这样别的处理器就不会再去执行它了，它就执行tasklet的处理程序，即if{}内的语句。*/
16.         if (tasklet_trylock(t)) {
17. /*检查count值是否为0，确保tasklet没有被禁止。如果tasklet被禁止了则跳到下一个挂起的tasklet去。*/
18.             if (!atomic_read(&t->count)) {
19.                 if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
20.                     BUG();
21.                 t->func(t->data);/*执行tasklet的处理程序*/
22.                 tasklet_unlock(t);
23.                 continue;
24.             }
25.             tasklet_unlock(t);
26.         }
28.     /*如果TASKLET_STATE_RUN标志被设置，同一类型的tasklet已经在其他CPU上运行，因此该函数将该tasklet描述符重新插入tasklet_vec链表中，这样，直到其他CPU上没有同一类型的tasklet运行该tasklet才执行。*/
29.         local_irq_disable();
30.         t->next = __get_cpu_var(tasklet_vec).list;
31.         __get_cpu_var(tasklet_vec).list = t;
32.         __raise_softirq_irqoff(TASKLET_SOFTIRQ);/*重新激活TASKLET_SOFTIRQ*/
33.         local_irq_enable();
34.     }
35. }
37. static void tasklet_hi_action(struct softirq_action *a)
38. {
39.     struct tasklet_struct *list;
41.     local_irq_disable();
42.     list = __get_cpu_var(tasklet_hi_vec).list;
43.     __get_cpu_var(tasklet_hi_vec).list = NULL;
44.     local_irq_enable();
46.     while (list) {
47.         struct tasklet_struct *t = list;
49.         list = list->next;
51.         if (tasklet_trylock(t)) {
52.             if (!atomic_read(&t->count)) {
53.                 if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
54.                     BUG();
55.                 t->func(t->data);
56.                 tasklet_unlock(t);
57.                 continue;
58.             }
59.             tasklet_unlock(t);
60.         }
62.         local_irq_disable();
63.         t->next = __get_cpu_var(tasklet_hi_vec).list;
64.         __get_cpu_var(tasklet_hi_vec).list = t;
65.         __raise_softirq_irqoff(HI_SOFTIRQ);
66.         local_irq_enable();
67.     }
68. }

1. 在<Interrupt.h(includelinux)>中
3. enum
4. {
5.     TASKLET_STATE_SCHED,    /* Tasklet is scheduled for execution */
6.     TASKLET_STATE_RUN   /* Tasklet is running (SMP only) */
7. };
9. #ifdef CONFIG_SMP
10. static inline int tasklet_trylock(struct tasklet_struct *t)
11. {
12.     return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
13. }
15. static inline void tasklet_unlock(struct tasklet_struct *t)
16. {
17.     smp_mb__before_clear_bit(); 
18.     clear_bit(TASKLET_STATE_RUN, &(t)->state);
19. }
21. static inline void tasklet_unlock_wait(struct tasklet_struct *t)
22. {
23.     while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); }
24. }
25. #else
26. #define tasklet_trylock(t) 1
27. #define tasklet_unlock_wait(t) do { } while (0)
28. #define tasklet_unlock(t) do { } while (0)
29. #endif

1. 在<Bitops.h(inclide/asm-i386)>
2. /**
3.  * clear_bit - Clears a bit in memory
4.  * @nr: Bit to clear
5.  * @addr: Address to start counting from
6.  *
7.  * clear_bit() is atomic and may not be reordered.  However, it does
8.  * not contain a memory barrier, so if it is used for locking purposes,
9.  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
10.  * in order to ensure changes are visible on other processors.
11.  */
12. static inline void clear_bit(int nr, volatile unsigned long * addr)
13. {
14.     __asm__ __volatile__( LOCK_PREFIX
15.         "btrl %1,%0"
16.         :"+m" (ADDR)
17.         :"Ir" (nr));
18. }
20. static inline void __clear_bit(int nr, volatile unsigned long * addr)
21. {
22.     __asm__ __volatile__(
23.         "btrl %1,%0"
24.         :"+m" (ADDR)
25.         :"Ir" (nr));
26. }
28. #define test_bit(nr,addr) /
29. (__builtin_constant_p(nr) ? /
30.  constant_test_bit((nr),(addr)) : /
31.  variable_test_bit((nr),(addr)))
33. #define smp_mb__before_clear_bit()  barrier() 
34. #define smp_mb__after_clear_bit()   barrier()

1. #if 0 /* Fool kernel-doc since it doesn't do macros yet */
2. /**
3.  * test_bit - Determine whether a bit is set
4.  * @nr: bit number to test
5.  * @addr: Address to start counting from
6.  */
7. static int test_bit(int nr, const volatile void * addr);
8. #endif
10. static __always_inline int constant_test_bit(int nr, const volatile unsigned long *addr)
11. {
12.     return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
13. }
15. static inline int variable_test_bit(int nr, const volatile unsigned long * addr)
16. {
17.     int oldbit;
19.     __asm__ __volatile__(
20.         "btl %2,%1/n/tsbbl %0,%0"
21.         :"=r" (oldbit)
22.         :"m" (ADDR),"Ir" (nr));
23.     return oldbit;
24. }
26. #define test_bit(nr,addr) /
27. (__builtin_constant_p(nr) ? /
28.  constant_test_bit((nr),(addr)) : /
29.  variable_test_bit((nr),(addr)))

1. 在<Bitops.h>中
3. /**
4.  * test_and_clear_bit - Clear a bit and return its old value
5.  * @nr: Bit to clear
6.  * @addr: Address to count from
7.  *
8.  * This operation is atomic and cannot be reordered.
9.  * It can be reorderdered on other architectures other than x86.
10.  * It also implies a memory barrier.
11.  */
12. static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
13. {
14.     int oldbit;
16.     __asm__ __volatile__( LOCK_PREFIX
17.         "btrl %2,%1/n/tsbbl %0,%0"
18.         :"=r" (oldbit),"+m" (ADDR)
19.         :"Ir" (nr) : "memory");
20.     return oldbit;
21. }
23. 在<Atomic.h(include/asm-i386)>中
24. /**
25.  * atomic_read - read atomic variable
26.  * @v: pointer of type atomic_t
27.  * 
28.  * Atomically reads the value of @v.
29.  */ 
30. #define atomic_read(v)      ((v)->counter)

1. 在<Bug.h(include/asm-i386)>
3. /*
4.  * Tell the user there is some problem.
5.  * The offending file and line are encoded encoded in the __bug_table section.
6.  */
8. #ifdef CONFIG_BUG
9. #define HAVE_ARCH_BUG
11. #ifdef CONFIG_DEBUG_BUGVERBOSE
12. #define BUG()                               /
13.     do {                                /
14.         asm volatile("1:/tud2/n"                /
15.                  ".pushsection __bug_table,/"a/"/n"     /
16.                  "2:/t.long 1b, %c0/n"          /
17.                  "/t.word %c1, 0/n"             /
18.                  "/t.org 2b+%c2/n"              /
19.                  ".popsection"              /
20.                  : : "i" (__FILE__), "i" (__LINE__),    /
21.                  "i" (sizeof(struct bug_entry)));       /
22.         for(;;) ;                       /
23.     } while(0)
25. #else
26. #define BUG()                               /
27.     do {                                /
28.         asm volatile("ud2");                    /
29.         for(;;) ;                       /
30.     } while(0)
31. #endif
32. #endif

呵呵，总算把代码帖完了：P