古老的BH、tasklet、softirq

  1. 古老的BH：作为一种特殊的tasklet

    kernel/softirq.c : static void (*bh_base[32])(void);

                                            struct tasklet_struct bh_task_vec[32];

在softirq_init中，注册32个bh_task_vec的函数指针为 bh_action; 
TASKLET_SOFTIRQ : tasklet_action;
HI_SOFTIRQ :              tasklet_hi_action;
NET_RX_SOFTIRQ :   net_rx_action;  [net_dev_init]
NET_TX_SOFTIRQ:    net_tx_action;

在sched_init中注册 TIMER_BH的处理函数指针为 timer_bh;
 init_bh(TIMER_BH, timer_bh);


对于数据包的接收发送，标志对应的 NET_RX_SOFTIRQ / NET_TX_SOFTIRQ;
对于应用的 tasklet ，标志对应的 TASKLET_SOFTIRQ;
对于古老的BH，例如时钟中断，在do_IRQ -> timer_interrupt -> do_timer_interrupt -> do_timer : 
  mark_bh(TIMER_BH) -> tasklet_hi_schedule(bh_task_vec+TIMER_BH)
  即将 TIMER_BH 所对应的 bh_task_vec 结构体挂接到对应的CPU的 tasklet_hi_vec 链表中，并标志HI_SOFTIRQ。
  do_softirq时，tasklet_hi_action 遍历对应CPU上的 tasklet_hi_vec 链表中的 tasklet_struct，执行其相应的action，也就是 bh_action 函数。
  bh_action 函数是个包装体，用于实际调用 bh_base 数组中的函数。对于时钟中断也就是 sched_init 中注册的 timer_bh 函数。
  




 

void __init softirq_init()
{
    int i;

    for (i=0; i<32; i++)
        tasklet_init(bh_task_vec+i, bh_action, i);

    open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);
    open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);
}

 

void tasklet_init(struct tasklet_struct *t,
          void (*func)(unsigned long), unsigned long data)
{
    t->next = NULL;
    t->state = 0;
    atomic_set(&t->count, 0);
    t->func = func;
    t->data = data;
}


 

void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
{
    softirq_vec[nr].data = data;
    softirq_vec[nr].action = action;
}

 

void fastcall __tasklet_hi_schedule(struct tasklet_struct *t)
{
    int cpu = smp_processor_id();
    unsigned long flags;

    local_irq_save(flags);
    t->next = tasklet_hi_vec[cpu].list;
    tasklet_hi_vec[cpu].list = t;
    cpu_raise_softirq(cpu, HI_SOFTIRQ);
    local_irq_restore(flags);
}

 

 

static void tasklet_hi_action(struct softirq_action *a)
{
    int cpu = smp_processor_id();
    struct tasklet_struct *list;

    local_irq_disable();
    list = tasklet_hi_vec[cpu].list;
    tasklet_hi_vec[cpu].list = NULL;
    local_irq_enable();

    while (list) {
        struct tasklet_struct *t = list;

        list = list->next;

        if (tasklet_trylock(t)) {
            if (!atomic_read(&t->count)) {
                if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
                    BUG();
                t->func(t->data);
                tasklet_unlock(t);
                continue;
            }
            tasklet_unlock(t);
        }

        local_irq_disable();
        t->next = tasklet_hi_vec[cpu].list;
        tasklet_hi_vec[cpu].list = t;
        __cpu_raise_softirq(cpu, HI_SOFTIRQ);
        local_irq_enable();
    }
}


static void bh_action(unsigned long nr)
{
    int cpu = smp_processor_id();

    if (!spin_trylock(&global_bh_lock))
        goto resched;

    if (!hardirq_trylock(cpu))
        goto resched_unlock;

    if (bh_base[nr])
        bh_base[nr]();

    hardirq_endlock(cpu);
    spin_unlock(&global_bh_lock);
    return;

resched_unlock:
    spin_unlock(&global_bh_lock);
resched:
    mark_bh(nr);
}