适用场景
复杂、耗时的事情,尽量使用内核线程来处理。
工作队列用起来挺简单,但是它有一个缺点:工作队列中有多个 work,前一个 work 没处理完会影响后面的 work。
解决方法有很多种,比如干脆自己创建一个内核线程,不跟别的 work 凑在一块了。
在 Linux 系统中,对于存储设备比如 SD/TF 卡,它的驱动程序就是这样做的,它有自己的内核线程。
对于中断处理,还有另一种方法:threaded_irq,线程化的中断处理。
//irq中断号,handler中断上半部处理函数,thread_fn下半部处理函数,flags中断触发条件等位置,中断名称,
extern int __must_check
request_threaded_irq(unsigned int irq, irq_handler_t handler, irq_handler_t thread_fn,
unsigned long flags, const char *name, void *dev);
内核机制
调用此函数后,会在struct irq_desc结构体的action里,创建一项链表,其中handler和thread_fn都是创建的时候提供的。
如果你的thread_fn非空,内核会调用khread_create创建中断函数。
当发生中断时内核先调用handler函数,返回IRQ_HANDLED表示中断处理完毕,返回IRQ_WAKE_THREAD则唤醒线程。
如果返回的是IRQ_WAKE_THREAD,内核线程会执行thread_fn,thread_fn执行完后,就可以唤醒等待中断中的线程了。
使用synchronize_irq来等待thread_fn被执行。
request_threaded_irq函数在kernel\irq\manage.c中
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)
{
//... 一些标志位设置
if (!handler) {
if (!thread_fn)
return -EINVAL;
//如果没有设置handler,那么内核默认设置一个handler函数,这个函数直接返回IRQ_WAKE_THREAD
handler = irq_default_primary_handler;
}
//创建了一个irqaction结构体,并填写了所有数据
action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
if (!action)
return -ENOMEM;
action->handler = handler;
action->thread_fn = thread_fn;
action->flags = irqflags;
action->name = devname;
action->dev_id = dev_id;
retval = irq_chip_pm_get(&desc->irq_data);
if (retval < 0) {
kfree(action);
return retval;
}
retval = __setup_irq(irq, desc, action); //进一步处理
if (retval) {
irq_chip_pm_put(&desc->irq_data);
kfree(action->secondary);
kfree(action);
}
//....
return retval;
}
EXPORT_SYMBOL(request_threaded_irq);
__setup_irq在kernel\irq\manage.c中
static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{
//...
if (new->thread_fn && !nested) {
ret = setup_irq_thread(new, irq, false); //进一步处理
if (ret)
goto out_mput;
if (new->secondary) {
ret = setup_irq_thread(new->secondary, irq, true);
if (ret)
goto out_thread;
}
}
//...
}
setup_irq_thread在kernel\irq\manage.c中
static int
setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
{
struct task_struct *t;
struct sched_param param = {
.sched_priority = MAX_USER_RT_PRIO/2,
};
//中断的内核线程是以irq起始,后面跟终端号,和我们设置的名字
if (!secondary) {
t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
new->name);
} else {
t = kthread_create(irq_thread, new, "irq/%d-s-%s", irq,
new->name);
param.sched_priority -= 1;
}
if (IS_ERR(t))
return PTR_ERR(t);
sched_setscheduler_nocheck(t, SCHED_FIFO, ¶m);
get_task_struct(t);
new->thread = t;
set_bit(IRQTF_AFFINITY, &new->thread_flags);
return 0;
}
我们再分析__handle_irq_event_percpu,在kernel/irq/handle.c中
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{
irqreturn_t retval = IRQ_NONE;
unsigned int irq = desc->irq_data.irq;
struct irqaction *action;
record_irq_time(desc);
for_each_action_of_desc(desc, action) {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id); //1.调用注册的handle函数
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD: //2.如果返回的是IRQ_WAKE_THREAD
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
__irq_wake_thread(desc, action); //3.唤醒对应的thread
/* Fall through to add to randomness */
case IRQ_HANDLED:
*flags |= action->flags;
break;
default:
break;
}
retval |= res;
}
return retval;
}
线程处理函数为irq_thread,代码在kernel/irq/manage.c中
static int irq_thread(void *data)
{
//...
while (!irq_wait_for_interrupt(action)) { //1.休眠等待中断
irqreturn_t action_ret;
irq_thread_check_affinity(desc, action);
action_ret = handler_fn(desc, action); //2.执行thread_fn
if (action_ret == IRQ_WAKE_THREAD)
irq_wake_secondary(desc, action);
wake_threads_waitq(desc); //3.唤醒等待thread_fn线程
}
//...
}
相关函数
//注册中断线程,irq中断号,handler中断上半部处理函数,thread_fn下半部处理函数,flags中断触发条件等位置,中断名称
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)
//卸载中断线程,irq中断号,dev_id中断名称
const void *free_irq(unsigned int irq, void *dev_id)
源码
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/uaccess.h>
#include <linux/irqreturn.h>
#include <linux/gpio/consumer.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
struct gpio_key {
int gpio;
struct gpio_desc *gpiod;
int flag;
int irq;
struct timer_list timer;
struct tasklet_struct tasklet;
struct work_struct work;
};
static struct gpio_key *myBtn_key;
static int button_major = 0;
static struct class *button_class;
static struct fasync_struct *btn_async;
static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);
#define MaxSize 128
struct QNode {
int Data[MaxSize];
int rear;
int front;
};
typedef struct QNode *Queue;
int IsEmpty(Queue Q);
void AddQ(Queue PtrQ, int item);
int DeleteQ(Queue PtrQ);
int IsEmpty(Queue Q)
{
return (Q->rear == Q->front); //1:empty 0:not empty
}
void AddQ(Queue PtrQ, int item)
{
if((PtrQ->rear+1)%MaxSize == PtrQ->front) {
printk("%s,Queue full\n", __FUNCTION__);
return;
}
PtrQ->rear = (PtrQ->rear+1)%MaxSize;
PtrQ->Data[PtrQ->rear] = item;
}
int DeleteQ(Queue PtrQ)
{
if(PtrQ->front == PtrQ->rear) {
printk("%s,Queue empty\n", __FUNCTION__);
return -1;
} else {
PtrQ->front = (PtrQ->front+1)%MaxSize;
return PtrQ->Data[PtrQ->front];
}
}
static Queue irqBuff;
static ssize_t button_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
int err;
int val;
if(IsEmpty(irqBuff) && (file->f_flags & O_NONBLOCK)) {
return -EAGAIN;
}
wait_event_interruptible(gpio_key_wait, !IsEmpty(irqBuff));
val = DeleteQ(irqBuff);
err = copy_to_user(buf, &val, 4);
// if(err != 4) {
// return -1;
// }
return 4;
}
static unsigned int button_poll(struct file *fp, poll_table * wait)
{
printk("%s,button poll\n", __FUNCTION__);
poll_wait(fp, &gpio_key_wait, wait);
return IsEmpty(irqBuff) ? 0 : POLLIN | POLLRDNORM;
}
int button_fasync(int fd, struct file *file, int on)
{
if(fasync_helper(fd, file, on, &btn_async) >= 0)
return 0;
else
return -EIO;
}
static struct file_operations button_ops = {
.owner = THIS_MODULE,
.read = button_read,
.poll = button_poll,
.fasync = button_fasync,
};
static irqreturn_t myBtn_irq_request(int irq, void *dev_id)
{
struct gpio_key *gpio_key = dev_id;
//printk(KERN_WARNING"myBtn_irq_request key %d irq happened\n", gpio_key->gpio);
tasklet_schedule(&myBtn_key->tasklet);
schedule_work(&myBtn_key->work);
mod_timer(&gpio_key->timer, jiffies + HZ/50);
return IRQ_WAKE_THREAD;
}
static void myBtn_timer(unsigned long data)
{
struct gpio_key *gpio_key = (struct gpio_key*)data;
int val;
val = gpiod_get_value(gpio_key->gpiod);
printk(KERN_WARNING"key %d %d\n", gpio_key->gpio, val);
val = (myBtn_key->gpio << 8)|val;
AddQ(irqBuff, val);
wake_up_interruptible(&gpio_key_wait);
kill_fasync(&btn_async, SIGIO, POLLIN);
}
static void myBtn_tasklet(unsigned long data)
{
struct gpio_key *gpio_key = (struct gpio_key*)data;
int val;
val = gpiod_get_value(gpio_key->gpiod);
printk(KERN_WARNING"tasklet key %d %d\n", gpio_key->gpio, val);
}
static void myBtn_workqueue(struct work_struct *work)
{
struct gpio_key *gpio_key = container_of(work, struct gpio_key, work);
int val;
val = gpiod_get_value(gpio_key->gpiod);
printk(KERN_WARNING"key_work_func: the process is %s pid %d\n",current->comm, current->pid);
printk(KERN_WARNING"workqueue key %d %d\n", gpio_key->gpio, val);
}
static irqreturn_t myBtn_irqthreaded(int irq, void *data)
{
struct gpio_key *gpio_key = data;
int val;
val = gpiod_get_value(gpio_key->gpiod);
printk(KERN_WARNING"myBtn_irq_handler: the process is %s pid %d\n",current->comm, current->pid);
printk(KERN_WARNING"threaded_irq key %d %d\n", gpio_key->gpio, val);
return IRQ_HANDLED;
}
static int my_button_probe(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
int count;
enum of_gpio_flags flag;
int i, err;
count = of_gpio_count(node);
if(!count) {
printk("%s,there isn't any gpio availiable\n", __FUNCTION__);
return -1;
}
myBtn_key = (struct gpio_key*)kzalloc(sizeof(struct gpio_key)*count, GFP_KERNEL);
if(!myBtn_key) {
printk("%s,kzalloc malloc failed\n", __FUNCTION__);
return -1;
}
for(i=0;i<count;i++) {
myBtn_key[i].gpio = of_get_gpio_flags(node, i, &flag);
if(myBtn_key[i].gpio < 0) {
printk("%s, of_get_gpio_flags failed\n", __FUNCTION__);
return -1;
}
myBtn_key[i].gpiod = gpio_to_desc(myBtn_key[i].gpio);
myBtn_key[i].flag = flag & OF_GPIO_ACTIVE_LOW;
myBtn_key[i].irq = gpio_to_irq(myBtn_key[i].gpio);
setup_timer(&myBtn_key[i].timer, myBtn_timer, (unsigned long)&myBtn_key[i]);
myBtn_key[i].timer.expires = ~0;
tasklet_init(&myBtn_key[i].tasklet, myBtn_tasklet, (unsigned long)&myBtn_key[i]);
INIT_WORK(&myBtn_key[i].work, myBtn_workqueue);
// err = request_irq(myBtn_key[i].irq, myBtn_irq_request, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
// "myBtn_key", &myBtn_key[i]);
err = request_threaded_irq(myBtn_key[i].irq, myBtn_irq_request, myBtn_irqthreaded, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"myBtn_key", &myBtn_key[i]);
}
button_major = register_chrdev(0, "mybutton", &button_ops);
if (button_major < 0) {
printk(KERN_ERR "button : couldn't get a major number.\n");
return -1;
}
button_class = class_create(THIS_MODULE, "button_class");
if(IS_ERR(button_class)) {
printk(KERN_ERR "button class: create failed\n");
unregister_chrdev(button_major, "mybutton");
return -1;
}
device_create(button_class, NULL, MKDEV(button_major, 0), NULL, "mybutton%d", 0);
return 0;
}
static int my_button_remove(struct platform_device *pdev)
{
struct device_node *node= pdev->dev.of_node;
int count;
int i;
device_destroy(button_class, MKDEV(button_major, 0));
class_destroy(button_class);
unregister_chrdev(button_major, "mybutton");
count = of_gpio_count(node);
for(i=0;i<count;i++) {
free_irq(myBtn_key[i].irq, &myBtn_key[i]);
del_timer(&myBtn_key[i].timer);
tasklet_kill(&myBtn_key[i].tasklet);
}
kfree(myBtn_key);
return 0;
}
static struct of_device_id mybuttons[] = {
{ .compatible = "mybtn,btn_drv" },
{ },
};
static struct platform_driver my_button_driver = {
.probe = my_button_probe,
.remove = my_button_remove,
.driver = {
.name = "button_dirver",
.of_match_table = mybuttons,
},
};
static int gpio_button_init(void)
{
int err;
irqBuff = (Queue)kzalloc(sizeof(struct QNode), GFP_KERNEL);
err = platform_driver_register(&my_button_driver);
printk(KERN_WARNING"my button dirver init\n");
return 0;
}
static void gpio_button_exit(void)
{
platform_driver_unregister(&my_button_driver);
kfree(irqBuff);
printk(KERN_WARNING"my button dirver exit\n");
}
module_init(gpio_button_init);
module_exit(gpio_button_exit);
MODULE_LICENSE("GPL");