Linux中断底半部机制总结

本文主要是介绍Linux中断底半部机制总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

linux实现底半部的机制主要有tasklet、workqueue、softirq和线程化irq。

1.tasklet

tasklet的使用较为简单，它的执行上下文是软中断，所以在tasklet中不能睡眠，它的执行时机通常是中断顶半部返回的时候。我们只需要定义tasklet及其处理函数，并将两者关联起来即可，例如：

1 void my_tasklet_func(unsigned long); /* 定义一个处理函数 */
2 DECLARE_TASKLET(my_tasklet, my_tasklet_func, data); /* 定义一个tasklet结构my_tasklet，与my_tasklet_func(data)函数相关联 */

代码 DECLEARE_TASKLET(my_tasklet, my_tasklet_func, data)实现了定义名称为my_tasklet的tasklet，并将其与my_tasklet_func()这个函数绑定，而传入这个函数的参数为data。在需要调度tasklet的时候引用一个tasklet_schedule()函数就能使系统在适当的时候进行调度运行:

tasklet_schedule(&my_tasklet);

 使用tasklet作为底半部处理中断的设备驱动程序模板如下：

struct xxx_struct {
　　int xxx_irq;
　　...
　　... 
};

static unsigned long data;

/* 定义 tasklet 和底半部函数并将它们关联 */
DECLARE_TASKLET(xxx_tasklet, xxx_do_tasklet, (unsigned long)&data); 
/*  中断处理底半部 */
void xxx_do_tasklet(unsigned long data)
{
 　　struct xxx_struct *pdata = (void *)*(unsigned long *)data;
 　　...  
}
 
/* 中断处理顶半部 */
irqreturn_t xxx_interrupt(int irq, void *dev_id)
{
　　...
　　data = (unsigned long)dev_id;
　　tasklet_schedule(&xxx_tasklet);
　　...  
}
 
/* 设备驱动模块探测函数 */
static int xxx_probe(struct platform_device *pdev)
{
　　...
　　struct xxx_struct *pdata = devm_kzalloc(&pdev->dev, sizeof(struct xxx_struct), GFP_KERNEL);
　　if (!pdata) {
　　　　dev_err(&pdev->dev, "Out of memory\n");
　　　　return -ENOMEM; 
　　}　
　　
　　platform_set_drvdata(pdev, pdata);
　　/* 申请中断 */
　　result = request_irq(pdata->xxx_irq, xxx_interrupt, 0, "xxx", pdata);
　　...
　　return IRQ_HANDLED;  
}
 
/* 设备驱动模块remove函数 */
static int xxx_remove(struct platforn_device *pdev)
{
　　struct xxx_struct *pdata = platform_get_drvdata(pdev);
　　...
　　/* 释放中断 */
　　free_irq(pdata->xxx_irq, NULL);
　　... 
}

上述程序在模块加载函数中申请中断，并在模块卸载函数中释放它。对应于xxx_irq的中断处理程序被设置为xxx_interrupt()函数，在这个函数中，tasklet_schedule(&xxx_tasklet)调度被定义的tasklet函数xxx_do_tasklet()在适当的时候执行。

2.工作队列

工作队列的使用方法和tasklet非常相似，但是工作队列的执行上下文是内核线程，因此可以调度和睡眠。下面的代码用于定义一个工作队列和一个底半部执行函数：

struct work_struct my_wq;    /* 定义一个工作队列 */
void my_wq_func(struct work_struct *work); /* 定义一个处理函数 */

通过INIT_WORK()可以初始化这个工作队列并将工作队列与处理函数绑定：

INIT_WORK(&my_wq, my_wq_func); /* 初始化工作队列并将其与处理函数绑定 */

与tasklet_schedule()对应的用于调度工作队列执行的函数为 schedule_work()，如:

schedule_work(&my_wq); /* 调度工作队列执行 */

使用工作队列处理中断底半部的设备驱动程序模板代码如下：

struct xxx_struct {
　　int xxx_irq;
　　struct work_struct xxx_wq; /* 定义工作队列 */
　　...
　　...
};

/* 中断处理底半部 */
void xxx_do_work(struct work_struct *work)
{
　　struct xxx_struct *pdata = container_of(work, struct xxx_struct, xxx_wq);
　　...
}

/* 中断处理顶半部 */
irqreturn_t xxx_interrupt(int irq, void *dev_id)
{
　　struct xxx_struct *pdata = (struct xxx_struct *)dev_id;
　　...
　　schedule_work(&pdata->xxx_wq);
　　...
　　return IRQ_HANDLED;
}

/* 设备驱动模块探测函数 */
int xxx_probe(struct platform_device *pdev)
{
　　...
　　struct xxx_struct *pdata = devm_kzalloc(&pdev->dev, sizeof(struct xxx_struct ), GFP_KERNEL);

　　/*申请中断*/
　　result = request_irq(pdata->xxx_irq, xxx_interrupt, 0, "xxx", pdata);
　　...
　　/* 初始化工作队列 */
　　INIT_WORK(&pdata->xxx_wq, xxx_do_work);
　　platform_set_drvdata(pdev, pdata);
　　...
}

/* 设备驱动模块remove函数 */
int xxx_remove(struct platform_device *pdev)
{
　　struct xxx_struct *pdata = platform_get_drvdata(pdev);
　　...
　　/* 释放中断 */
　　free_irq(pdata->xxx_irq, NULL);
　　...
}

工作队列早期的实现是在每个CPU核上创建一个worker内核线程，所有在这个核上调度的工作都在该worker线程中执行，其并发性显然差强人意。在linux 2.6.36以后，转而实现了 “Concurrency-managed workqueues”，简称"cmwq"，cmwq会自动维护工作队列的线程池以提高并发性，同时保持了API的向后兼容。

延时工作队列

　　1. 数据结构delayed_work用于处理延迟执行

struct delayed_work {
    struct work_struct work;
    struct timer_list timer;

    /* target workqueue and CPU ->timer uses to queue ->work */
    struct workqueue_struct *wq;
    int cpu;
};

　　2.在工作队列中被调用的函数原形如下

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

　　3. 初始化数据结构

INIT_DELAYED_WORK(struct delayed_work *work, work_func_t func)

　　4. 提交延时任务到工作队列

int schedule_delayed_work(struct delayed_work *work, unsigned long delay);

　　5.删除提交到工作队列的任务

int cancel_delayed_work(strcut delayed_work *work);

　　6. 刷新默认工作队列（常跟cancle_delayed_work一起使用)

void flush_schedlue_work(void);
或者
int cancel_delayed_work_sync(strcut delayed_work *work);

使用延时工作队列处理中断底半部的设备驱动程序模板代码如下：

struct xxx_struct {　　
　　int xxx_irq;
　　struct delayed_work xxx_dwork; /* 定义延时工作队列 */
　　...
　　...
};

/* 中断处理底半部 */
void xxx_do_work(struct work_struct *work)
{
　　struct xxx_struct *pdata = container_of(work, struct xxx_struct, xxx_dwork.work);
　　...
}

/* 中断处理顶半部 */
irqreturn_t xxx_interrupt(int irq, void *dev_id)
{
　　struct xxx_struct *pdata = (struct xxx_struct *)dev_id;
　　...
　　
　　/*
 　　* delay 2000ms
 　　*/
　　schedule_delayed_work(&pdata->xxx_dwork, msesc_to_jiffies(2000)); 
　　...

　　return IRQ_HANDLED;
}

/* 设备驱动模块探测函数 */
int xxx_probe(struct platform_device *pdev)
{
　　...
　　struct xxx_struct *pdata = devm_kzalloc(&pdev->dev, sizeof(struct xxx_struct ), GFP_KERNEL);

　　/*申请中断*/
　　result = request_irq(pdata->xxx_irq, xxx_interrupt, 0, "xxx", pdata);
　　...
　　/* 初始化工作队列 */
　　INIT_DELAYED_WORK(&pdata->xxx_dwork, xxx_do_work);
　　platform_set_drvdata(pdev, pdata);
　　...
}

/* 设备驱动模块remove函数 */
int xxx_remove(struct platform_device *pdev)
{
　　struct xxx_struct *pdata = platform_get_drvdata(pdev);
　　...
　　/* 释放中断 */
　　free_irq(pdata->xxx_irq, NULL);
　　...
}

3.软中断

软中断（Softirq）也是一种传统的底半部处理机制，它的执行时机通常是顶半部返回的时候，tasklet是基于软中断实现的，因此也运行于软中断上下文。

在Linux内核中，用softirq_action结构体表征一个软中断，这个结构体包含软中断处理函数指针和传递给该函数的参数。使用open_softirq()函数可以注册软中断对应的处理函数，而raise_softirq()函数可以触发一个软中断。

软中断和tasklet运行于软中断上下文，仍然属于原子上下文的一种，而工作队列则运行于进程上下文。因此，在软中断和tasklet处理函数中不允许睡眠，而在工作队列处理函数中允许睡眠。

local_bh_disable() 和 local_bh_enable() 是内核中用于禁止和使能软中断及tasklet底半部机制的函数。

内核中采用softirq的地方包括 HI_SOFTIRQ、TIMER_SOFTIRQ、NET_TX_SOFTIRQ、NET_RX_SOFTIRQ、SCSI_SOFTIRQ、TASKLET_SOFTIRQ等，一般来说，驱动的编写者不会也不宜直接使用softirq。

硬中断、软中断和信号的区别：

　　硬中断是外部设备对CPU的中断，软中断是中断底半部的一种处理机制，而信号则是由内核（或其他进程）对某个进程的中断。在设计系统调用的场合，人们也常说通过软中断（例ARM为swi）陷入内核，此时软中断的概念是指由软件指令引发的中断，和我们这个地方所说的softirq是两个完全不同的概念，一个是software，一个是soft。

需要特别说明的是，软中断以及基于软中断的tasklet如果在某段时间内大量出现的话，内核会把后续软中断放入 ksoftirqd 内核线程中执行。总的来说，中断优先级高于软中断，软中断优先级又高于任何一个线程。软中断适度线程化，可以缓解高负载情况下系统的响应。

4.threaded_irq

在内核中除了可以通过request_irq()、devm_request_irq()申请中断以外，还可以通过request_threaded_irq() 和 devm_request_threaded_irq() 申请。这两个函数的原型为：

/**
 *    request_threaded_irq - allocate an interrupt line
 *    @irq: Interrupt line to allocate
 *    @handler: Function to be called when the IRQ occurs.
 *          Primary handler for threaded interrupts.
 *          If handler is NULL and thread_fn != NULL
 *          the default primary handler is installed.
 *    @thread_fn: Function called from the irq handler thread
 *            If NULL, no irq thread is created
 *    @irqflags: Interrupt type flags
 *    @devname: An ascii name for the claiming device
 *    @dev_id: A cookie passed back to the handler function
 *
 *    This call allocates interrupt resources and enables the
 *    interrupt line and IRQ handling. From the point this
 *    call is made your handler function may be invoked. Since
 *    your handler function must clear any interrupt the board
 *    raises, you must take care both to initialise your hardware
 *    and to set up the interrupt handler in the right order.
 *
 *    If you want to set up a threaded irq handler for your device
 *    then you need to supply @handler and @thread_fn. @handler is
 *    still called in hard interrupt context and has to check
 *    whether the interrupt originates from the device. If yes it
 *    needs to disable the interrupt on the device and return
 *    IRQ_WAKE_THREAD which will wake up the handler thread and run
 *    @thread_fn. This split handler design is necessary to support
 *    shared interrupts.
 *
 *    Dev_id must be globally unique. Normally the address of the
 *    device data structure is used as the cookie. Since the handler
 *    receives this value it makes sense to use it.
 *
 *    If your interrupt is shared you must pass a non NULL dev_id
 *    as this is required when freeing the interrupt.
 *
 *    Flags:
 *
 *    IRQF_SHARED        Interrupt is shared
 *    IRQF_TRIGGER_*        Specify active edge(s) or level
 *    IRQF_ONESHOT        Run thread_fn with interrupt line masked
 */
int request_threaded_irq(unsigned int irq, irq_handler_t handler,
             irq_handler_t thread_fn, unsigned long irqflags,
             const char *devname, void *dev_id)；

/**
 *    devm_request_threaded_irq - allocate an interrupt line for a managed device
 *    @dev: device to request interrupt for
 *    @irq: Interrupt line to allocate
 *    @handler: Function to be called when the IRQ occurs
 *    @thread_fn: function to be called in a threaded interrupt context. NULL
 *            for devices which handle everything in @handler
 *    @irqflags: Interrupt type flags
 *    @devname: An ascii name for the claiming device, dev_name(dev) if NULL
 *    @dev_id: A cookie passed back to the handler function
 *
 *    Except for the extra @dev argument, this function takes the
 *    same arguments and performs the same function as
 *    request_threaded_irq().  IRQs requested with this function will be
 *    automatically freed on driver detach.
 *
 *    If an IRQ allocated with this function needs to be freed
 *    separately, devm_free_irq() must be used.
 */
int devm_request_threaded_irq(struct device *dev, unsigned int irq,
                  irq_handler_t handler, irq_handler_t thread_fn,
                  unsigned long irqflags, const char *devname,
                  void *dev_id)；

由此可见，它们比request_irq()、devm_request_irq()多了一个参数 thread_fn。用这两个API申请中断的时候，内核会为相应的中断号分配一个对应的内核线程。注意这个线程只针对这个中断号，如果其他中断也通过request_threaded_irq()申请，自然会得到新的内核线程。

参数handler对应的函数执行于中断上下文，thread_fn参数对应的函数则执行于内核线程。如果handler结束的时候，返回值是 IRQ_WAKE_THREAD，内核会调度对应线程执行 thread_fn 对应的函数。

request_threaded_irq() 和 devm_request_threaded_irq() 支持在 irqflags 中设置 IRQF_ONESHOT标记，这样内核会自动帮助我们在中断上下文中屏蔽对应的中断号，而在内核调度 thread_fn 执行后，重新使能该中断号。对于我们无法在上半部清除中断的情况， IRQ_ONESHOT 特别有用，避免了中断服务程序一退出，中断就洪泛的情况。

handler 参数可以设置为NULL，这种情况下，内核会用默认的 irq_default_primary_handler() 代替 handler，并会使用 IRQ_ONESHOT标记。 irq_default_primary_handler() 定义为：

/*
 * Default primary interrupt handler for threaded interrupts. Is
 * assigned as primary handler when request_threaded_irq is called
 * with handler == NULL. Useful for oneshot interrupts.
 */
static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
{
    return IRQ_WAKE_THREAD;
}

这篇关于Linux中断底半部机制总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！