底半部之工作队列和tasklet，内核定时器。

1、软中断机制
  不能以模块形式出现
  使用起来不够灵活
2、tasklet
  核心数据结构
      struct tasklet_struct
      {
          function
          data
          ....
      }  
  1）定义tasklet变量
  2）初始化tasklet变量
     DECLARE_TASKLET //定义并初始化tasklet变量
 
  3）使用tasklet变量登记底半部
 
  注意事项：
      tasklet登记的底半部函数也是运行中断上下文中的
      也就意味着在底半部函数中不能调用引起阻塞或者
      睡眠的函数
  如果底半部函数中 必须调用引起阻塞或者睡眠的函数
  可以考虑使用工作队列的方式登记底半部

3、工作队列
  核心数据结构
     struct work_struct
     {
        //保存底半部函数的地址
        work_func_t func;
        ...
     }
  步骤：
     1）定义work变量
        struct work_struct btn_work;
     2）初始化work变量
        INIT_WORK(&btn_work, btn_work_func)
        
        以上两个步骤可以使用
        DECLARE_WORK(btn_work, btn_work_func)
            
     3）使用work变量登记底半部
        schedule_work(&btn_work);
     4）flush或者cancel
        bool flush_work(struct work_struct *work)
        cancel_work_sync(struct work_struct *work)   
        
   
   tasklet和work登记底半部的对比
     1）通过工作队列去登记底半部
        底半部函数工作于进程上下文中 不受限制
     2）如果同时使用了tasklet和工作队列登记了底半部
        一定是taklet登记的底半部函数最先被执行到          
     详细对比  tasklet_work.png          
 
  如果希望底半部函数登记后隔10s再去执行 实现方式
 
  核心数据结构：
      struct delayed_work {
    struct work_struct work;
    struct timer_list timer;
      };
  使用步骤：
      1）定义delayed_work变量
         struct delayed_work btn_dwork;
      2) 初始化delayed_work变量
         INIT_DELAYED_WORK(&btn_dwork, func)
      3) 使用delayed_work登记底半部
         schedule_delayed_work(&btn_dwork, 延时时间)  
      4）当卸载模块时 对已经登记并未得到执行的
         底半部做处理？
         a)flush 阻塞到指定dwork被执行到才返回
           flush_delayed_work(struct delayed_work *dwork)
         b)cancel 取消约定
           cancel_delayed_work(struct delayed_work *work)
             
   1）连续两次登记底半部 几次有效？哪次有效？
      
      只有1次有效
      第一次有效
   2）登记底半部后 ，直接卸载模块 内核崩溃 为什么？
     
4、内核定时器
  软件意义上的定时器
 
  系统时钟中断：CPU会周期性 不停地收到系统时钟中断信号
                执行系统时钟中断处理函数
                timer_event_init()
                {
                   setup_irq(info->irqno, &timer_event_irqaction);
                }
                timer_event_irqaction.timer_event_handler()
                {
                    /*硬件相关的事*/
                    
                    /*硬件无关动作*/
                    tick_periodic()
                    {
                        更新墙上时间
                        jiffies++;
                        给当前正在执行的线程时间片做--操作
                        判断当前线程的时间片是否耗尽
                        一旦耗尽重新做任务调度
                        选出新的线程放入CPU中运行
                    }
                }
   HZ:决定了1s产生的系统时钟中断的次数
      当前系统中HZ=1000
   tick, 系统时钟滴答
         tick = 1/HZ;
   jiffies, 记录自开机以来产生的系统时钟中断次数      
            unsigned int 类型
            
            例如HZ=1000
            在某个时间点1读取jiffies 为10000
            在某个时间点2读取jiffies 为20000
   
   内核定时器（软件意义上的）
      struct timer_list
      {
          //超时时间
          unsigned long expires;
          //定时时间到后执行的动作
          void (*function)(unsigned long);
          //指定调用function时传递的参数值
          unsigned long data;
          ...
      }
   定时器的使用步骤：
      1）定义一个timer_list变量
         struct timer_list led_timer;
      2) 初始化timer_list变量
         init_timer(&led_timer)
         
         led_timer.function=xxx
         led_timer.expires = xxx
         led_timer.data = xxx
     3) 启动定时器  
        
        void add_timer(struct timer_list *timer)
        
        int mod_timer(struct timer_list *timer, unsigned long expires)
     4) 修改定时器超时时间
        int mod_timer(struct timer_list *timer, unsigned long expires)
     5）取消定时器
        int del_timer(struct timer_list *timer)

标签：定时器,struct,work,delayed,timer,半部,内核,tasklet
来源： https://www.cnblogs.com/DXGG-Bond/p/11859049.html