(笔记)Linux内核学习(五)之中断推后处理机制

阅读量：5989 次

发布时间：2019-06-20

本文共 6963 字，大约阅读时间需要 23 分钟。

一中断

硬件通过中断与操作系统进行通信，通过对硬件驱动程序处注册中断处理程序，快速响应硬件的中断。

硬件中断优先级很高，打断当前正在执行的程序。有两种情况：

　　硬件中断在中断处理程序中处理

　　硬件中断延后再进行处理

　　这个具体硬件相关，在中断处理程序中处理，打断了当前正在执行的程序；所有中断都将被屏蔽；如果占用时间太长不合适，

造成系统交互性，反应能力都会受到影响。需要在其中判断平衡：

如果一个任务对时间非常敏感，将其放在中断处理程序中执行；

如果一个人和和硬件相关，将其放在中断处理程序中执行；

如果一个任务要保证不被其他中断打断，将其放在中断处理程序中执行；

其余情况考虑延后机制中执行——下半部。

二中断推后执行机制—— 软中断

软中断是在编译期间静态分配的，在程序执行前将软中断假如到表中。

下面看一下这个过程：

加入软中断类型：

Linux3.5.3代码：

enum{       HI_SOFTIRQ=0,       TIMER_SOFTIRQ,       NET_TX_SOFTIRQ,       NET_RX_SOFTIRQ,       BLOCK_SOFTIRQ,       BLOCK_IOPOLL_SOFTIRQ,       TASKLET_SOFTIRQ,       SCHED_SOFTIRQ,       HRTIMER_SOFTIRQ,       RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */        NR_SOFTIRQS};

//软中断表：

static struct softirq_action softirq_vec[NR_SOFTIRQS]

//软中断结构体

struct softirq_action{       void   (*action)(struct softirq_action *);};

注册软中断处理函数：

void open_softirq(int nr, void (*action)(struct softirq_action *)){       //关联表中对应类型    　　softirq_vec[nr].action = action;}

触发软中断：

void raise_softirq(unsigned int nr){       unsigned long flags;       //停止但保存中断标志       local_irq_save(flags);       //将相应软中断挂起状态       raise_softirq_irqoff(nr);       //恢复中断       local_irq_restore(flags);}

执行软中断：

void irq_exit(void){            　　invoke_softirq();  //do_softirq();}void __do_softirq(void){       struct softirq_action *h;       __u32 pending;       int max_restart = MAX_SOFTIRQ_RESTART;       int cpu;             //获取CPU软中断状态标志位 32位代表最多32个软中断       pending = local_softirq_pending(); restart:       /* Reset the pending bitmask before enabling irqs */       set_softirq_pending(0);       local_irq_enable();       h = softirq_vec;       do {              //被触发则执行软中断处理程序              if (pending & 1) {　　　　　　　　　　h->action(h);              }              //下一个软中断              h++;              //下一个软中断状态标志位              pending >>= 1;       } while (pending);        local_irq_disable();       pending = local_softirq_pending();       if (pending && --max_restart)              goto restart;       if (pending)              wakeup_softirqd();       lockdep_softirq_exit();　　　　__local_bh_enable(SOFTIRQ_OFFSET);}

软中断的基本结构如下图表示：

三中断推后执行机制——tasklet

软中断中表中有一种类型是：TASKLET_SOFTIRQ

Tasklet就是利用软中断实现中断推后处理机制。通常使用较多的是tasklet而不是软中断。

Tasklet数据结构：

struct tasklet_struct{       //链表中下一个tasklet       struct tasklet_struct *next;       //tasklet状态       unsigned long state;       //引用计数器       atomic_t count;       //tasklet处理函数       void (*func)(unsigned long);       //处理函数参数　　　　unsigned long data;};

state:

enum{    　　TASKLET_STATE_SCHED,   /* Tasklet is scheduled for execution */    　　TASKLET_STATE_RUN /* Tasklet is running (SMP only) */};

count：为0允许激活执行

声明tasklet：可以动态或者静态方式

静态：

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

动态：

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;}

　　同时需要编写tasklet处理函数。

调度tasklet：

void tasklet_hi_schedule(struct tasklet_struct *t){       unsigned long flags;       local_irq_save(flags);       t->next = NULL;       *__this_cpu_read(tasklet_vec.tail) = t;       __this_cpu_write(tasklet_vec.tail, &(t->next));       raise_softirq_irqoff(TASKLET_SOFTIRQ);       local_irq_restore(flags);}

执行tasklet处理程序：

继续看上面调度tasklet程序执行：

inline void raise_softirq_irqoff(unsigned int nr){       __raise_softirq_irqoff(nr);       if (!in_interrupt())              wakeup_softirqd();}//使用ksoftirqd内核线程来处理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);}

Ksoftirqd内核线程：

软中断才被触发频率很高，在处理过程中还会重新触发软中断；执行会导致用户空间进程无法获得处理时间处于饥饿状态；

对重新触发的软中断立即处理，会导致占据处理时间过长；不进行立即处理不合适；

对此解决方法：

　　l 只要还有被触发并等待处理和过程中重新触发的软中断的软中断，本次执行就要负责处理；软中断立即处理，用户空间得不到执行时间。

　　l 不处理过程中触发的软中断，放到下一个中断执行时机时处理。软中断得不到立即处理，系统空闲时造成不合理；保证用户空间得到执行时间。

两种方式有存在问题，只能在这其中采取这种的方式：

内核使用线程处理软中断，线程优先级较低，可以被抢占；能够保证软中断被处理，也能保证用户空间程序得到执行时间。

每个CPU上有存在这样一个线程：ksoftirqd/0或者ksoftirqd/1……

static __init int spawn_ksoftirqd(void){       void *cpu = (void *)(long)smp_processor_id();       int err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);              ……       return 0;}early_initcall(spawn_ksoftirqd);static 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:              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;       ……}

四中断推后执行机制——工作队列

工作队列（work queue）通过内核线程将中断下半部分程序推后执行到线程中执行，工作队列可以创建线程来处理相应任务。

工作队列创建的线程为工作者线程：worker thread；系统提供默认的线程来处理工作者队列。

工作者线程数据结构：

struct workqueue_struct {       unsigned int        flags;            /* W: WQ_* flags */       union {              struct cpu_workqueue_struct __percpu       *pcpu;              struct cpu_workqueue_struct         *single;              unsigned long                           v;       } cpu_wq;                          /* I: cwq's */       struct list_head   list;        /* W: list of all workqueues */       ……}

CPU工作队列数据结构：

struct cpu_workqueue_struct {
           //每个CPU工作队列信息       struct global_cwq      *gcwq;                //每个CPU工作队列       struct workqueue_struct *wq;              ……};

工作数据结构：

struct work_struct {       atomic_long_t data;       struct list_head entry;       work_func_t func;};

声明工作队列：

静态：

#define DECLARE_WORK(n, f)                             \       struct work_struct n = __WORK_INITIALIZER(n, f)

动态：

#define INIT_WORK(_work, _func)                                   \       do {                                           \              __INIT_WORK((_work), (_func), 0);              \       } while (0)

需要编写工作队列处理函数：

typedef void (*work_func_t)(struct work_struct *work);

调度工作队列：

int schedule_work(struct work_struct *work){       return queue_work(system_wq, work);}int queue_work(struct workqueue_struct *wq, struct work_struct *work){      ret = queue_work_on(get_cpu(), wq, work);}

唤醒工作者队列线程处理。

执行工作者队列处理程序：

static int worker_thread(void *__worker){       do {              struct work_struct *work =                     list_first_entry(&gcwq->worklist,                                   struct work_struct, entry);              process_one_work(worker, work);       } while (keep_working(gcwq));}