linux内核tasklet机制

最新推荐文章于 2023-11-28 18:00:22 发布
最新推荐文章于 2023-11-28 18:00:22 发布
阅读量981 收藏 8
点赞数
分类专栏： 个人笔记，随笔 linux tiny4412 linux函数练习 文章标签： linux tiny4412 tasklet 按键中断 驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z961968549/article/details/78745271
版权

前言

前面讲了linux中断编程：顶半部、底半部
中断顶半部：做紧急的，耗时短的事情，同时还启动中断底半部（如果有）。
中断底半部：做耗时的事情，这个事件可以被中断
实现方法：tasklet、工作队列、软中断等机制。实际上是把耗时的事件推后执行，不在中断程序中执行。

内核tasklet机制

tasklet机制是一种比较特殊的软中断，tasklet一词原意是“小片任务”的意思，这里是指一小段可执行的代码，且通常以函数的形式出现。这个tasklet绑定的函数在一个时刻只能在一个CPU上运行，在SMP系统上不会出现并发问题。
tasklet（小任务）机制是中断处理下半部分最常用的一种方法，其使用也是非常简单的。正如在前文中你所知道的那样，一个使用tasklet的中断程序首先会通过执行中断处理程序来快速完成上半部分的工作，接着会通过调用tasklet使得下半部分的工作得以完成。可以看到，下半部分被上半部分所调用，至于下半部分何时执行则属于内核工作。对应到我们此刻所说的tasklet就是，在中断处理程序中，除了完成对中断的响应等工作，还要调用tasklet，如下图所示：

Created with Raphaël 2.1.0 中断发生 中断上半部（紧急的硬件操作，记录中断） 中断下半部（可以延后的耗时操作）

tasklet核心数据结构

路径：interrupt.h linux-3.5\include\linux

struct tasklet_struct
{
    struct tasklet_struct *next;   //用来实现多个 tasklet_struct 结构链表
    unsigned long state;           //当前这个tasklet是否已经被调度
    atomic_t count;                //值为0时候用户才可以调度
    void (*func)(unsigned long);   //指向tasklet绑定的函数的指针
    unsigned long data;            //传递给tasklet绑定函数的参数
};

使用tasklet机制就是定义一个这个结构体变量，然后填充必须的元素：count、func、data。

tasklet机制内核API

tasklet定义及初始化函数

头文件interrupt.h linux-3.5\include\linux

名称宏、函数作用
静态初始化DECLARE_TASKLET(name, func, data)初始化相关成员默认被调用
静态初始化DECLARE_TASKLET_DISABLED(name, func, data)初始化相关成员默认不能被调用
动态初始化extern void tasklet_init(struct tasklet_struct *t,初始化相关成员，处于激活状态
void (*func)(unsigned long), unsigned long data);默认可以被调用

补充tasklet_init函数源码：

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);  //默认设置为0  可以被调用
    t->func = func;
    t->data = data;
}

tasklet机制使能、失能函数

前面提到结构中atomic_t count成员值为0时用户才可以调度，如果用户想去调度一个没有激活的tasklet或者禁止调度一个已经激活的tasklet可以使用以下两个函数

名称函数
取消激活函数tasklet_disable(struct tasklet_struct *t)
激活函数void tasklet_enable(struct tasklet_struct *t)

说明：
如果对一个tasklet_struct结构变量调用了两次tasklet_disable函数，则count会增加为2，这时你在调用一次tasklet_enable，那实际count值还是1，还是处于非激活状态。enable与disable只是相对而言。
tasklet_disable源码补充：

static inline void tasklet_disable_nosync(struct tasklet_struct *t)
{
    atomic_inc(&t->count);       //单纯的+1
    smp_mb__after_atomic_inc();
}

static inline void tasklet_disable(struct tasklet_struct *t)
{
    tasklet_disable_nosync(t);
    tasklet_unlock_wait(t);
    smp_mb();
}

tasklet_enable源码补充：

void tasklet_enable(struct tasklet_struct *t)
{
    smp_mb__before_atomic_dec();
    atomic_dec(&t->count);      //单纯-1
}

tasklet调度函数 tasklet_schedule(struct tasklet_struct*t)

tasklet_schedule(struct tasklet_struct*t) tasklet_struct结构体中绑定了一个函数，当用户需要执行这个函数的时候，需要自己调用tasklet_schedule函数去通知内核帮我们调度所绑定的函数

static inline void tasklet_schedule(struct tasklet_struct *t)
{
    if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
        __tasklet_schedule(t);
}

tasklet取消调度函数tasklet_kill(struct tasklet_struct*t)

void tasklet_kill(struct tasklet_struct *t);

void tasklet_kill(struct tasklet_struct *t)
{
    if (in_interrupt())
        printk("Attempt to kill tasklet from interrupt\n");

    while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {
        do {
            yield();
        } while (test_bit(TASKLET_STATE_SCHED, &t->state));
    }
    tasklet_unlock_wait(t);
    clear_bit(TASKLET_STATE_SCHED, &t->state);
}

tasklet机制编程步骤

  • 第一步：写tasklet结构中的绑定函数
    void tasklet_func(unsigned long data)
    {
    ······
    }
  • 第二步：定义tasklet结构

    第一种使用静态定义：（定义出的tasklet能被调度）
    DECLARE_TASKLET(mttasklet,tasklet_func,123);
    第二种使用静态定义：（定义出的tasklet不能被调度）
    DECLARE_TASKLET_DISABLED(mttasklet,tasklet_func,123);
    第三种动态定义：一般在模块初始化时候
    1)先定义一个变量
    struct tasklet_struct mytasklet;
    2)对这个变量进行初始化，如果是静态定义结构体，略过这一步
    tasklet_init(&mytasklet,tasklet_func,123)

  • 第三步：初始化tasklet结构
    根据你想实现的功能是什么，在什么情况要调用到你绑定的函数，就在那里调用tasklet_schedule函数进行调度。
    tasklet_schedule(&mytasklet)
  • 第四步：在适当的地方进行调度
    如果中途不想使用tasklet，则可以删除它。
    tasklet_kill(&mytasklet)一般情况在模块卸载函数中编写。
  • 第五步：如果想取消调度，则在适当的地方取消

tasklet机制编程示例

简单的示例代码

#include<linux/module.h>
#include<linux/init.h>
//添加头文件
#include<linux/interrupt.h>

//实现一个tasklet工作函数
void tasklet_func(unsigned long data)
{
  printk("%s is call!!  data:%d\r\n",__FUNCTION__,data);
}
//定义一个tasklet_struct结构变量,并且进行初始化
DECLARE_TASKLET(mytasklet, tasklet_func, 123);

static int __init tasklet_init(void)
{
  //一安装模块就进行调度
  tasklet_schedule(&mytasklet);
  printk("%s is call!!",__FUNCTION__);  
  return 0;
}

static void __exit tasklet_exit(void)
{
  //删除tasklet
  tasklet_kill(&mytasklet);
  printk("tasklet is kill!\r\n");
}

MODULE_INIT(tasklet_init);
MODULE_EXIT(tasklet_exit);
MODULE_LICENSE("GPL");

开发板运行效果

[root@ZC/zhangchao]#insmod tasklet.ko 
[   34.940000] tasklett_init is call!![   34.940000] tasklet_func is call!!  data:123
[root@ZC/zhangchao]#

循环调度绑定函数

在tasklet工作函数中再调度即可 
#include<linux/module.h>
#include<linux/init.h>
//添加头文件
#include<linux/interrupt.h>
void tasklet_func(unsigned long data);


//定义一个tasklet_struct结构变量,并且进行初始化
DECLARE_TASKLET(mytasklet, tasklet_func, 123);


//实现一个tasklet工作函数
void tasklet_func(unsigned long data)
{
  static unsigned long cnt=0;
  printk("cnt:%d %s is call!!  data:%d\r\n",cnt++,__FUNCTION__,data);
  tasklet_schedule(&mytasklet);
}


static int __init tasklett_init(void)
{
  //一安装模块就进行调度
  tasklet_schedule(&mytasklet);
  printk("%s is call!!",__FUNCTION__);  
  return 0;
}

static void __exit tasklett_exit(void)
{
  //删除tasklet
  tasklet_kill(&mytasklet);
  printk("tasklet is kill!\r\n");
}

module_init(tasklett_init);
module_exit(tasklett_exit);
MODULE_LICENSE("GPL");

开发板运行效果

[ 4010.785000] cnt:1573 tasklet_func is call!!  data:123
[ 4010.790000] cnt:1574 tasklet_func is call!!  data:123
[ 4010.795000] cnt:1575 tasklet_func is call!!  data:123
[ 4010.800000] cnt:1576 tasklet_func is call!!  data:123
[ 4010.805000] cnt:1577 tasklet_func is call!!  data:123
[ 4010.810000] cnt:1578 tasklet_func is call!!  data:123
[ 4010.815000] cnt:1579 tasklet_func is call!!  data:123
[ 4010.820000] cnt:1580 tasklet_func is call!!  data:123
[ 4010.825000] cnt:1581 tasklet_func is call!!  data:123
[ 4010.830000] cnt:1582 tasklet_func is call!!  data:123
[ 4010.835000] cnt:1583 tasklet_func is call!!  data:123
[ 4010.840000] cnt:1584 tasklet_func is call!!  data:123
[ 4010.845000] cnt:1585 tasklet_func is call!!  data:123
[ 4010.850000] cnt:1586 tasklet_func is call!!  data:123
[ 4010.855000] cnt:1587 tasklet_func is call!!  data:123
[ 4010.860000] cnt:1588 tasklet_func is call!!  data:123

失能函数

在初始化函数内先失能tasklet结构，再调度，将不会执行工作函数，但是`tasklet_kill` 一个没有使能但是调度了的`tasklet`内核会异常,造成模块卸载时内核会卡住。 
static int __init tasklet_init(void)
{
  //故意测试 失能tasklet再次调用看是否还能执行
  tasklet_disable(&mytasklet);
  //一安装模块就进行调度
  tasklet_schedule(&mytasklet);
  printk("%s is call!!",__FUNCTION__);  
  return 0;
}

//tasklet_kill 一个没有使能但是调度了的tasklet内核会异常
static void __exit tasklet_exit(void)
{
  //删除tasklet
  tasklet_kill(&mytasklet);
  printk("tasklet is kill!\r\n");
}

先失能后使能功能正常，卸载效果也正常

static int __init tasklet_init(void)
{
  //故意测试 失能tasklet再次调用看是否还能执行
  tasklet_disable(&mytasklet);

  tasklet_enable(&mytasklet);
  //一安装模块就进行调度
  tasklet_schedule(&mytasklet);
  printk("%s is call!!",__FUNCTION__);  
  return 0;
}

重复调度会出现什么状况呢？

**注意：先把工作函数中调度函数注释掉否则会重复调度，否则不能达成测试目的** 
static int __init tasklet_init(void)
{

  //一安装模块就进行调度
  tasklet_schedule(&mytasklet);
  tasklet_schedule(&mytasklet);
  tasklet_schedule(&mytasklet);
  tasklet_schedule(&mytasklet);

  printk("%s is call!!",__FUNCTION__);  
  return 0;
}
**运行效果表明：虽重复调度，但只执行一次工作函数**

linux使用tasklet机制实现中断底半部

思路：把以前写的按键驱动程序中的服务函数分为中断顶半部和中断底半部,下面是按键中断服务函数中所做的事

irqreturn_t key_handler(int irq, void * dev_id)
{
    int dn;        //存放按键状态
    //注册的时候传递进来的是每个案件元素的首地址，类型是struct key_info*
    //这里进行还原，还原后可以取得这个结构的所有元素信息
    struct key_info *pdev_data=(struct key_info*)dev_id;

    //判断按下还是松开按键；可通过读取按键IO电平状态来判断
    //硬件上，按下按键返回电平0 松开返回1
    dn=gpio_get_value(pdev_data->key_gpio);
    if(!dn)
        printk("key%d down!!\r\n",pdev_data->key_num+1);
    else
        printk("key%d up!!\r\n",pdev_data->key_num+1);
    //存储按键状态到按键缓冲区
    //这里我们想实现正逻辑，'0'表示没有按下，'1'表示按下。这里取反一次
    kbuf[pdev_data->key_num]= '0'+!dn;  
    press=1;
    wake_up_interruptible(&wq); 
    return IRQ_HANDLED;
}

软件思路

把上面的代码分为两部分
顶半部:
只是单纯写调度底半部代码，因为当前代码没有什么非常紧急的事情需要完成。
底半部：
把原来中断程序中的代码原样复制过去，写在tasklet服务函数中去

修改部分

  • 添加头文件
    #include<linux/interrupt.h>
  • 修改按键结构体
    因为有四个按键，每个按键对应一个tasklet
struct key_info{
int key_gpio;  //按键IO
int key_num;   //按键编号
const char* name;  //按键名称
struct tasklet_struct keytasklet;  //按键对应tasklet结构体 
};
  • 构造tasklet服务函数
//实现 tasklet函数
void key_tasklet_func(unsigned long data)
{
    int dn;        //存放按键状态
    //注册的时候传递进来的是每个案件元素的首地址，类型是struct key_info*
    //这里进行还原，还原后可以取得这个结构的所有元素信息
    struct key_info *pdev_data=(struct key_info*)data;

    //判断按下还是松开按键；可通过读取按键IO电平状态来判断
    //硬件上，按下按键返回电平0 松开返回1
    dn=gpio_get_value(pdev_data->key_gpio);
    if(!dn)
        printk("key%d down!!\r\n",pdev_data->key_num+1);
    else
        printk("key%d up!!\r\n",pdev_data->key_num+1);
    //存储按键状态到按键缓冲区
    //这里我们想实现正逻辑，'0'表示没有按下，'1'表示按下。这里取反一次
    kbuf[pdev_data->key_num]= '0'+!dn;  
    press=1;
    wake_up_interruptible(&wq); 
}
  • 修改中断函数
irqreturn_t key_handler(int irq, void * dev_id)
{
    //注册的时候传递进来的是每个按键元素的首地址，类型是struct key_info*
    //这里进行还原，还原后可以取得这个结构的所有元素信息
    struct key_info *pdev_data=(struct key_info*)dev_id;

    //启动中断底半部
    tasklet_schedule(&pdev_data->keytasklet);
    return IRQ_HANDLED;
}
  • 初始化中注册tasklet这里不使用静态初始化，使用动态初始化，在模块初始化部分动态初始化

    for(i=0;i<4;i++)
        {
     //初始化每个按键 tasklet结构
     key_info[i].keytasklet;
     tasklet_init(&key_info[i].keytasklet,key_tasklet_func,&key[i]);
    irq=gpio_to_irq(keys[i].key_gpio);              
     err=request_irq(irq, key_handler,flags,keys[i].name,&keys[i]); //注册key1中断
    //如果有注册失败的 跳出循环
    if(err<0)
        {
        break;
      }
    }
  • 在模块卸载中 删除tasklet
for(i=0;i<4;i++)
    {
    irq=gpio_to_irq(keys[i].key_gpio);              
    free_irq(irq,&keys[i]);
    tasklet_kill(&key_info[i].keytasklet);  //删除tasklet
   }

驱动源码

#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/init.h>
#include<asm/uaccess.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/kdev_t.h>
#include<linux/slab.h>
#include<linux/device.h> //增加自动创建设备头文件
#include<linux/uaccess.h>
#include<linux/interrupt.h> //中断注册注销头文件
#include<linux/gpio.h>   //gpio相关的头文件
#include<linux/delay.h>
#include<linux/sched.h>
//定义等待队列  头 wq，要是一个全局变量
DECLARE_WAIT_QUEUE_HEAD(wq);

//按键数量
#define KEY_SIZE (4)

//按键缓冲区
unsigned char kbuf[KEY_SIZE]={"0000"};    //储存按键状态 初始化为字符 0,0表示没有按下，1表示按下 
//定义全局变量是否有按键标识
static int press=0;

struct key_info{
int key_gpio;  //按键IO
int key_num;   //按键编号
const char* name;  //按键名称
struct tasklet_struct keytasklet;  //按键对应tasklet结构体 
};

struct key_info keys[]={
{EXYNOS4_GPX3(2),0,"key1"},
{EXYNOS4_GPX3(3),1,"key2"},
{EXYNOS4_GPX3(4),2,"key3"},
{EXYNOS4_GPX3(5),3,"key4"}
};


//定义字符设备结构体
static struct cdev *xxxdriver_cdev;
//定义设备号（包含主次）
static dev_t xxxdriver_num=0;
//定义设备类
static struct class *xxxdriver_class;
//定义设备结构体
static struct device *xxxdriver_device;

//定义设备名称
#define XXXDRIVER_NAME "mydevice"



ssize_t XXX_read(struct file *file, char __user *usr, size_t size, loff_t *loft)
{
    if(size>KEY_SIZE)
        {
    size=KEY_SIZE;
    }
    //如果按键没有动作
    if(press==0)
        {
        //如果是非阻塞方式打开
        if(file->f_flags & O_NONBLOCK)
            {
            //返回错误码
            return -EAGAIN;
        }else
            {
            //休眠
            wait_event(wq,press);
        }
    }
    //清除按键处理标志，执行到这里表示发生了中断有了按键动作
    //一定清0，否则下次调用会出问题
    press=0;
    if(copy_to_user(usr,kbuf,size))
        {
        printk("copy to user faild\r\n");
    return -EFAULT;
    }

  return size;
}




int XXX_open (struct inode *node, struct file *pfile)
{
  printk("files open  success!!\r\n");
  return 0;
}


int XXX_release (struct inode *node, struct file *file)
{
  printk("file close  success!!\r\n");
  return 0;
}


/*key中断服务函数:
按键按下、松开都会进入中断服务函数
程序要把按键的状态，保存起来，让用户通过用户变成API接口来读取按键状态
所以，函数中完成1）：判断按键按下还是松开；2）把按键状态存储起来
*/
irqreturn_t key_handler(int irq, void * dev_id)
{
    //注册的时候传递进来的是每个案件元素的首地址，类型是struct key_info*
    //这里进行还原，还原后可以取得这个结构的所有元素信息
    struct key_info *pdev_data=(struct key_info*)dev_id;

    //启动中断底半部
    tasklet_schedule(&pdev_data->keytasklet);
    return IRQ_HANDLED;
}


//实现 tasklet函数
void key_tasklet_func(unsigned long data)
{
    int dn;        //存放按键状态
    //注册的时候传递进来的是每个案件元素的首地址，类型是struct key_info*
    //这里进行还原，还原后可以取得这个结构的所有元素信息
    struct key_info *pdev_data=(struct key_info*)data;

    //判断按下还是松开按键；可通过读取按键IO电平状态来判断
    //硬件上，按下按键返回电平0 松开返回1
    dn=gpio_get_value(pdev_data->key_gpio);
    if(!dn)
        printk("key%d down!!\r\n",pdev_data->key_num+1);
    else
        printk("key%d up!!\r\n",pdev_data->key_num+1);
    //存储按键状态到按键缓冲区
    //这里我们想实现正逻辑，'0'表示没有按下，'1'表示按下。这里取反一次
    kbuf[pdev_data->key_num]= '0'+!dn;  
    press=1;
    wake_up(&wq); 
}

//文件操作函数结构体
static struct file_operations xxxdriver_fops={
    .owner=THIS_MODULE,
    .open=XXX_open,
    .release=XXX_release,
    .read=XXX_read,
};

static __init int xxxdriver_init(void)
{
 //定义错误返回类型
  int   err;
 //定义中断编号
 int irq,i;
 //设置中断属性 非共享中断 上升下降沿触发
 unsigned long flags=IRQF_DISABLED | 
                      IRQF_TRIGGER_FALLING | 
                      IRQF_TRIGGER_RISING;

    for(i=0;i<4;i++)
        {
     //初始化每个按键 tasklet结构
     tasklet_init(&keys[i].keytasklet,key_tasklet_func,&keys[i]);
    irq=gpio_to_irq(keys[i].key_gpio);              
     err=request_irq(irq, key_handler,flags,keys[i].name,&keys[i]); //注册key1中断
    //如果有注册失败的 跳出循环
    if(err<0)
        {
    break;
    }
    }
    //有注册失败的 将前面注册成功的释放掉
    if(err<0){
    for(--i;i>0;i--)
        {
    irq=gpio_to_irq(keys[i].key_gpio);              
     free_irq(irq, &keys[i]);
    }
    }


//分配字符设备结构体，前面只是定义没有分配空间
xxxdriver_cdev=cdev_alloc();
//判断分配成功与否
if(xxxdriver_cdev==NULL)
{
  err=-ENOMEM;
  printk("xxxdriver alloc is err\r\n");
  goto err_xxxdriver_alloc;
}

//动态分配设备号
err=alloc_chrdev_region(&xxxdriver_num, 0, 1, XXXDRIVER_NAME);
//错误判断
if(err<0)
{
  printk("alloc xxxdriver num is err\r\n");
  goto err_alloc_chrdev_region;
}

//初始化结构体
cdev_init(xxxdriver_cdev,&xxxdriver_fops);

//驱动注册
err=cdev_add(xxxdriver_cdev,xxxdriver_num,1);
if(err<0)
{
  printk("cdev add is err\r\n");
  goto err_cdev_add;
}

//创建设备类
xxxdriver_class=class_create(THIS_MODULE,"xxx_class");
  err=PTR_ERR(xxxdriver_class);
  if(IS_ERR(xxxdriver_class))
    {
printk("xxxdriver creat class is err\r\n");
goto err_class_create;
  }


//创建设备
  xxxdriver_device=device_create(xxxdriver_class,NULL, xxxdriver_num,NULL, "xxxdevice");
 err=PTR_ERR(xxxdriver_device);
    if(IS_ERR(xxxdriver_device))
        {
printk("xxxdriver device creat is err \r\n");
goto err_device_create;
    }


printk("xxxdriver init is success\r\n");
return 0;

//硬件初始化部分

err_device_create:
class_destroy(xxxdriver_class);
err_class_create:
 cdev_del(xxxdriver_cdev);
err_cdev_add:
unregister_chrdev_region(xxxdriver_num, 1);

err_alloc_chrdev_region:
kfree(xxxdriver_cdev);

err_xxxdriver_alloc:
return err;

}

static __exit void xxxdriver_exit(void)
{

   int irq,i;
   for(i=0;i<4;i++)
    {
    irq=gpio_to_irq(keys[i].key_gpio);              
    free_irq(irq,&keys[i]);
    tasklet_kill(&keys[i].keytasklet);  //删除tasklet
   }

  device_destroy(xxxdriver_class,xxxdriver_num);
  class_destroy(xxxdriver_class);
  cdev_del(xxxdriver_cdev);
  unregister_chrdev_region(xxxdriver_num, 1);
  printk("xxxdriver is exit\r\n");
}


module_init(xxxdriver_init);
module_exit(xxxdriver_exit);
MODULE_LICENSE("GPL");

app函数

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char *argv[])
{
  int i,file_fp;
  unsigned char btn[4]={"0000"},cur[4]={"0000"};
  file_fp = open(argv[1],O_RDWR);
    while(1)
        {
        read(file_fp,cur,4);
    for(i=0;i<4;i++)
        {
    if(cur[i]!=btn[i])
        {
        btn[i]=cur[i];
        if(cur[i]=='1')
            printf("按键%d 按下\r\n",i+1);
        else
            printf("按键%d 弹起\r\n",i+1);
    }
    }
    }
  close(file_fp);
}

Makefile

KERN_DIR = /zhangchao/linux3.5/linux-3.5
all:
    make -C $(KERN_DIR) M=`pwd` modules
clean:
    make -C $(KERN_DIR) M=`pwd` modules clean
    rm -rf modules.order
prog:
    arm-linux-gcc btn_app.c -o app
obj-m += btn.o

开发板运行效果

[root@ZC/zhangchao]#insmod btn.ko 
[ 1943.005000] xxxdriver init is success
[root@ZC/zhangchao]#./app /dev/xxxdevice 
[ 1954.680000] files open  success!!
[ 1958.160000] key1 down!!
按键1 按下
[ 1958.345000] key1 up!!
按键1 弹起
[ 1959.135000] key2 down!!
按键2 按下
[ 1959.305000] key2 up!!
按键2 弹起

开发板运行效果与单纯运行按键中断代码效果相同，当然这里只是一个简单的例子没有实际意义。

年纪青青
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【分析笔记】Linux tasklet 机制的理解
lovemengx的博客
07-23 1915
Linux 内核的 tasklet 机制的分析和理解
Linux下中断机制之tasklet执行过程（详细）总结
Luckiers的博客
03-31 3122
一、简介 由于中断会打断内核中进程的正常调度运行，所以要求中断服务程序尽可能的短小精悍；但是在实际系统中，当中断到来时，要完成工作往往进行大量的耗时处理。因此期望让中断处理程序运行得快，并想让它完成的工作量多，这两个目标相互制约，诞生——顶/底半部机制，本文主要介绍tasklet的执行过程。 读者可根据情况了解以下知识： 软中断过程总结 中断机制详细总结 由于软中断必须使用可重入函数，这就导致设计上的复杂度变高，作为设备驱动程序的开发者来说，增加了负担。而如果某种应用并不需要在多个CPU上并行执行，那么软
Linux的tasklet函数详解
技术交流
12-09 2933
tasklet主要用在中断函数中。它对于中断处理特别有用，由于硬件中断必须尽快处理, 但大部分的数据管理可以延后到以后安全的时间执行。所以可以使用tasklet。 tasklet的使用比较简单，只需要定义tasklet及其处理函数并将两者关联即可，在定义时可以采用两种形式。 例子： struct tasklet_struct my_tasklet; Void my...
驱动程序使用tasklet机制
RichardYSteven的专栏
08-24 1603
驱动程序在初始化时，通过函数task_init建立一个tasklet，然后调用函数tasklet_schedule将这个tasklet放在tasklet_vec链表的头部，并唤醒后台线程ksoftirqd。当后台线程ksoftirqd运行调用__do_softirq时，会执行在中断向量表softirq_vec里中断号TASKLET_SOFTIRQ对应的tasklet_action函数，
linux kernel之软中断和tasklet（小任务）机制
哈米的博客
07-17 298
linux kernel之软中断和tasklet（小任务）机制
linux 内核工作延迟机制-softirq-tasklet
qq_42931917的博客
11-18 439
tasklet
Linux内核tasklet机制和工作队列
01-09
　上面我们介绍了软中断机制，linux内核为什么还要引入tasklet机制呢？主要原因是软中断的pending标志位也32位，一般情况是不随意增加软中断处理的。而且内核也没有提供通用的增加软中断的接口。其次内，软中断处理...
linux内核tasklet机制.txt
03-25
例如，假设一个数据块已经达到了网线，当中断控制器接受到这个中断请求信号时，Linux内核只是简单地标志数据到来了，然后让处理器恢复到它以前运行的状态，其余的处理稍后再进行（如把数据移入一个缓冲区，接受数据...
linux 内核同步机制
11-29
本文档介绍在linux内核中两个不同进程或者过程访问和使用同一共享资源时，处理顺序的随机性，可能出现访问错误。结果依赖于多个任务的相对执行顺序（竟态条件）。其中处理竟态条件的同步机制在不同内核过程中处理的...
Linux 2.6内核的中断机制.pdf
09-06
在实时性方面，Linux内核的默认实现并不理想，尤其对于需要快速响应的嵌入式系统而言。针对这一问题，研究者们提出了一些改进方案，例如应用Ingo Molnar的实时化补丁，以增强内核的实时性能。 在Linux 2.6内核中，...
Linux内核延时研究与函数代码分析
07-29
Linux内核延时研究与函数代码分析 Linux内核延时研究是Linux系统中一个重要的概念...Linux内核延时研究与函数代码分析是一个重要的概念，需要了解Linux内核的延时机制和函数代码，以便更好地编写驱动程序和应用程序。
优化命令之taskset——查询或设置进程绑定CPU
ver_mouth__的博客
06-13 8580
目录一：taskset概述二：安装taskset工具2.1taskset语法2.2taskset用法2.2.1指定PID为8528的进程在CPU1上运行2.2.2更改具体某一进程（或 线程）CPU亲和性2.2.3 查看具体某一进程（或 线程）的处理器亲和性(掩码)2.2.4为具体某一进程（或 线程）CPU亲和性指定一组范围三：依托nginx进行验证四：总结 我的 Linode十分繁忙，在跑一些密集操作数据库的Rake任务时尤其如此。但我观察发现，Linode服务器的4核CPU，只有第1个核心（CPU#0）非
tasklet使用方法
lee_jimmy的博客
09-05 1266
tasklet的概念我这里就不多讲了，因为网上的文章很多，我这里只介绍怎么在我们的驱动程序中使用tasklet提供的接口函数。一般，从定义到最后注销，一共有4步，下面我们分别介绍这4个接口函数。 静态定义tasklet static void my_tasklet_func(unsigned long data); DECLARE_TASKLET_DISABLED(tasklet, my_...
linux内核之tasklet使用
仗劍走天涯
08-31 4486
内核微线程 ---- tasklet和工作队列一样，可以用于推后执行的代码。tasklet（小任务）机制是中断处理下半部分最常用的一种方法，其使用也是非常简单的。一个使用tasklet的中断程序首先会通过执行中断处理程序来快速完成上半部分的工作，接着通过调用tasklet使得下半部分的工作得以完成。在中断处理程序中，除了完成对中断的响应等工作，还要调用tasklet。 1、 数据结构 ...
Tasklets 机制浅析
流风回雪的博客
08-27 481
一 、Tasklets 机制基础知识点 1、Taklets 机制概念 Tasklets 机制是linux中断处理机制中的软中断延迟机制。通常用于减少中断处理的时间，将本应该是在中断服务程序中完成的任务转化成软中断完成。 为了最大程度的避免中断处理时间过长而导致中断丢失，有时候我们需要把一些在中断处理中不是非常紧急的任务放在后面执行，而让中断处理程序尽快返回。在老版本的 linux 中通常将中断处理分为 top half handler 、 bottom half handler...
深入分析Tasklet机制
duoerbasilu
07-23 305
深入分析Tasklet机制 一、tasklet使用 Tasklet的使用比较简单，每个Tasklet结构体有一个函数指针，指向你自己定义的函数。当我们要使用 tasklet ，首先新定义一个tasklet_struct结构，并初始化好要执行函数指针，然后将它挂接到 task_vec 链表中，并触发一个软中断就可以等着被执行了。 1.1.定义tasklet_struct结构 Void my_t...
linux将进/线程绑定核心运行（cpu亲和性）
hiele的博客
10-30 2709
查看cpu核心数 cpu一般有多个物理核心，但在运行进程和线程时候，可以将其绑定或者指定到某一个或者多个核心上运行。我们在系统上有两种方法可以查看cpu核心数。 1.cat /proc/cpuinfo查看cpu的核心数以及信息，这里以树莓派3B为例： processor : 0 model name : ARMv7 Processor rev 4 (v7l) BogoMIPS : 38.40 Features : half thumb fastmult...
linux 内核tasket机制
最新发布
一叶知秋的博客
11-28 341
linux 内核tasket机制
LINUX的tasklet怎么用
06-02
在 Linux 内核中，Tasklet 是一种延迟执行的机制，可以在中断上下文中执行，用于处理一些低优先级的事件。Tasklet 可以在中断处理程序执行完毕后，而不需要立即执行，从而避免了在中断上下文中进行的复杂操作，使得中断处理程序可以快速返回。 Tasklet 与软中断的工作方式类似，但是 Tasklet 只能在进程上下文中执行，而不能在硬件中断上下文中执行。Tasklet 通常用于处理一些低优先级的事件，比如网络数据包的到达、定时器的到期等。 下面是 Tasklet 的使用步骤： 1. 定义 Tasklet 函数： ```c void my_tasklet_handler(unsigned long data); DECLARE_TASKLET(my_tasklet, my_tasklet_handler, 0); ``` 2. 实现 Tasklet 函数： ```c void my_tasklet_handler(unsigned long data) { // 处理事件 // ... } ``` 3. 注册 Tasklet： ```c int ret = request_irq(irq, my_interrupt_handler, IRQF_SHARED, "my_interrupt", (void *)(my_interrupt_handler)); if (ret) { printk(KERN_INFO "request_irq failed\n"); return -1; } tasklet_init(&my_tasklet, my_tasklet_handler, 0); ``` 4. 触发 Tasklet： ```c void my_interrupt_handler(int irq, void *dev_id, struct pt_regs *regs) { // 处理中断事件 // ... // 触发 Tasklet tasklet_schedule(&my_tasklet); } ``` 总的来说，Tasklet 是一种非常有效的机制，可以在中断上下文中处理低优先级的事件，避免在中断上下文中进行复杂的操作，提高系统的效率和可靠性。在处理一些低优先级的事件时，可以使用 Tasklet 来优化系统的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值