soft irq and tasklet

最新推荐文章于 2024-01-08 22:03:34 发布

shuai_wen

最新推荐文章于 2024-01-08 22:03:34 发布

阅读量1.2k

点赞数

分类专栏： kernel

本文链接：https://blog.csdn.net/u011279649/article/details/11772373

版权

kernel 专栏收录该内容

74 篇文章 1 订阅

订阅专栏

创建 ksoftirqd

early_initcall(spawn_ksoftirqd);

static __init int spawn_ksoftirqd(void)
{
   void *cpu = (void *)(long)smp_processor_id();
   int err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
   cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
   register_cpu_notifier(&cpu_nfb);
   return 0;
}

int __cpuinit cpu_callback(struct notifier_block *nfb,
                  unsigned long action,
                  void *hcpu)
{
   int hotcpu = (unsigned long)hcpu;
   struct task_struct *p;

   switch (action) {
   case CPU_UP_PREPARE:
   case CPU_UP_PREPARE_FROZEN:
   /*创建 Kthread 并绑定某个CPU,这里给出了 thread funcion 绑定到某个CPU的方法*/
       p = kthread_create_on_node(run_ksoftirqd,
                       hcpu,
                       cpu_to_node(hotcpu),
                       "ksoftirqd/%d", hotcpu);
       kthread_bind(p, hotcpu);
       per_cpu(ksoftirqd, hotcpu) = p;
        break;
   /*唤醒并绑定某个CPU的Kthread */
   case CPU_ONLINE:
   case CPU_ONLINE_FROZEN:
       wake_up_process(per_cpu(ksoftirqd, hotcpu));
       break;
}

kthread function: run_ksoftirqd

/*ksoftirqd thread的当有pending的softirq时，调用处理函数
*没有pending 事件，则睡眠
**/
int run_ksoftirqd(void * __bind_cpu)
{
   __set_current_state(TASK_RUNNING);

   while (local_softirq_pending()) {
           __do_softirq();
   }

   set_current_state(TASK_INTERRUPTIBLE);
}

下面的问题是怎样pending位和怎样唤醒ksoftirqd, 当然还有怎样设置一个softirq

struct tasklet_struct
{
   struct tasklet_struct *next;
   unsigned long state;
   atomic_t count;
   void (*func)(unsigned long);
   unsigned long data;
};

定义一个 named tasklet_strct:

#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

tasklet_schedule

*test_and_set_bit(int nr, long* addr)
*将*addr 的第n位设置成1，并返回原来这一位的值
**/
static inline void tasklet_schedule(struct tasklet_struct *t)
{
   if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
       __tasklet_schedule(t);
}

/*将tasklet_struct提交到tasklet_vec*/
void __tasklet_schedule(struct tasklet_struct *t)
{
   *__this_cpu_read(tasklet_vec.tail) = t;
   __this_cpu_write(tasklet_vec.tail, &(t->next));
   raise_softirq_irqoff(TASKLET_SOFTIRQ);
}

/*设置pending并唤醒ksoftirqd thread*/
inline void raise_softirq_irqoff(unsigned int nr)
{
   __raise_softirq_irqoff(nr);

   if (!in_interrupt())
       wakeup_softirqd();
}

static void wakeup_softirqd(void)
{
   /* Interrupts are disabled: no need to stop preemption */
   struct task_struct *tsk = __this_cpu_read(ksoftirqd);
   if (tsk && tsk->state != TASK_RUNNING)
       wake_up_process(tsk);
}

何时调用do_softirq

/*
* Exit an interrupt context. Process softirqs if needed and possible:
*/
void irq_exit(void)
{
   if (!in_interrupt() && local_softirq_pending())
       invoke_softirq();
}

static inline void invoke_softirq(void)
{
   if (!force_irqthreads)
       do_softirq();
}

asmlinkage void do_softirq(void)
{
   __u32 pending;
   pending = local_softirq_pending();

   if (pending)
       __do_softirq();

}

__do_softirq唤醒kthread: ksoftirqd

在函数__do_softirq调用所有 pending 的action后，再次判断是否又有新的pending,

如果有则再次处理，但是这个过程最多循环MAX_SOFTIRQ_RESTART ：10次。

如果还有则唤醒进程: ksoftirqd

#define MAX_SOFTIRQ_RESTART 10

asmlinkage void __do_softirq(void)
{
   struct softirq_action *h;
   __u32 pending;
   int max_restart = MAX_SOFTIRQ_RESTART;
   int cpu;

   pending = local_softirq_pending();
   h = softirq_vec;

   do {
       if (pending & 1) {
           unsigned int vec_nr = h - softirq_vec;
           h->action(h);
       }
       h++;
       pending >>= 1;
   } while (pending);
   pending = local_softirq_pending();
   if (pending && --max_restart)
       goto restart;

   if (pending)
       wakeup_softirqd();
}

总结：

刚看代码有点疑惑，还以为所有的action 都是 ksoftirqd处理的，其实不然，是在中断退出的时候调用的 __do_softirq,在该函数中满足某些条件的时候才调用 kthread.

当然，可以强制使用 kthread的 macro:#define force_irqthreads (0).