时钟与定时器

一、延后执行

### 长延时

忙等待

让出处理器

超时等待队列

### 短延时

ndelay udelay mdelay 纳秒、微秒、毫秒

实际上都是忙等待！

void ndelay(unsigned long nsecs);
void udelay(unsigned long usecs);
void mdelay(unsigned long msecs);

在内核中最好不要直接使用mdelay()函数，对于毫秒级以上的时延，内核提供了如下函数

void msleep(unsigned int millisecs);
unsigned long msleep_interruptible(unsigned int millisecs);  // 可以被打断
void ssleep(unsigned int secdonds);

二、内核定时器

在Linux设备驱动编程中，可以利用Linux内核中提供的一组函数和数据结构来完成定时触发工作或者完成某周期性的事务；

#include <linux/timer.h>
  struct time_list{
       struct list_head entry;  // 定时器列表
       unsigned long expires;  // 定时器到期时间
       void (*function)(unsigned long); // 定时器处理函数
       unsigned long data;  // 作为参数被传入定时器处理函数
   };

### 秒字符设备实例

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/timer.h> /*包括timer.h头文件*/

#define SECOND_MAJOR 252    /*预设的second的主设备号*/
static int second_major = SECOND_MAJOR;
/*second设备结构体*/
struct second_dev
{
  struct cdev cdev; /*cdev结构体*/
  atomic_t counter;/* 一共经历了多少秒？*/
  struct timer_list s_timer; /*设备要使用的定时器*/
};
struct second_dev *second_devp; /*设备结构体指针*/
/*定时器处理函数*/
static void second_timer_handle(unsigned long arg)
{
  mod_timer(&second_devp->s_timer,jiffies + HZ);
  atomic_inc(&second_devp->counter); 
  printk(KERN_NOTICE "current jiffies is %ld\n", jiffies);
}

/*文件打开函数*/
int second_open(struct inode *inode, struct file *filp)
{
  /*初始化定时器*/
  init_timer(&second_devp->s_timer);
  second_devp->s_timer.function = &second_timer_handle;
  second_devp->s_timer.expires = jiffies + HZ; 
  add_timer(&second_devp->s_timer); /*添加（注册）定时器*/
  atomic_set(&second_devp->counter,0); //计数清0
  return 0;
}
/*文件释放函数*/
int second_release(struct inode *inode, struct file *filp)
{
  del_timer(&second_devp->s_timer); 
  return 0;
}

/*globalfifo读函数*/
static ssize_t second_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{  
  int counter;  
  counter = atomic_read(&second_devp->counter);
  if(put_user(counter, (int*)buf))
    return - EFAULT;
  else
    return sizeof(unsigned int);  
}
/*文件操作结构体*/
static const struct file_operations second_fops =
{
  .owner = THIS_MODULE, 
  .open = second_open, 
  .release = second_release,
  .read = second_read,
};

/*初始化并注册cdev*/
static void second_setup_cdev(struct second_dev *dev, int index)
{
  int err, devno = MKDEV(second_major, index);
  cdev_init(&dev->cdev, &second_fops);
  dev->cdev.owner = THIS_MODULE;
  dev->cdev.ops = &second_fops;
  err = cdev_add(&dev->cdev, devno, 1);
  if (err)
    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}

/*设备驱动模块加载函数*/
int second_init(void)
{
  int ret;
  dev_t devno = MKDEV(second_major, 0);
  /* 申请设备号*/
  if (second_major)
    ret = register_chrdev_region(devno, 1, "second");
  else  /* 动态申请设备号 */
  {
    ret = alloc_chrdev_region(&devno, 0, 1, "second");
    second_major = MAJOR(devno);
  }
  if (ret < 0)
    return ret;
 }
 
 /* 动态申请设备结构体的内存*/
  second_devp = kmalloc(sizeof(struct second_dev), GFP_KERNEL);
  if (!second_devp)    /*申请失败*/
  {
    ret =  - ENOMEM;
    goto fail_malloc;
  }
  memset(second_devp, 0, sizeof(struct second_dev));
  second_setup_cdev(second_devp, 0);
  return 0;
  fail_malloc: unregister_chrdev_region(devno, 1);
}
/*模块卸载函数*/
void second_exit(void)
{
  cdev_del(&second_devp->cdev);   /*注销cdev*/
  kfree(second_devp);     /*释放设备结构体内存*/
  unregister_chrdev_region(MKDEV(second_major, 0), 1); /*释放设备号*/
}


MODULE_LICENSE("Dual BSD/GPL");

module_param(second_major, int, S_IRUGO);

module_init(second_init);
module_exit(second_exit);

/*测试函数*/
main()
{
  int fd;
  int counter = 0;
  int old_counter = 0; 
  /*打开/dev/second设备文件*/
  fd = open("/dev/second", O_RDONLY);
  if (fd !=  - 1)
  {
    while (1)
    {
      read(fd,&counter, sizeof(unsigned int));//读目前经历的秒数
      if(counter!=old_counter)
        {  
         printf("seconds after open /dev/second :%d\n",counter);
         old_counter = counter;
        }  
    }    
  }
  else
  {
    printf("Device open failure\n");
  }
}

三、Tasklets

这里的tasklet是指对要推迟执行的函数进行组织的一种机制。

struct tasklet_struct {
struct tasklet_struct *next;         /*指向链表中的下一个结构*/
          unsignedlong state;                /* 小任务的状态*/
          atomic_tcount;        /* 引用计数器*/
          void(*func) (unsigned long);                /* 要调用的函数*/
          unsignedlong data;                 /* 传递给函数的参数*/
}；

四、工作队列

工作队列（work queue）是另外一种将工作推后执行的形式，它和前面讨论的tasklet有所不同。工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行。这样，通过工作队列执行的代码能占尽进程上下文的所有优势。最重要的就是工作队列允许被重新调度甚至是睡眠。

如果推后执行的任务需要睡眠，那么就选择工作队列。如果推后执行的任务不需要睡眠，那么就选择tasklet。另外，如果需要用一个可以重新调度的实体来执行你的下半部处理，也应该使用工作队列。它是唯一能在进程上下文运行的下半部实现的机制，也只有它才可以睡眠。这意味着在需要获得大量的内存时、在需要获取信号量时，在需要执行阻塞式的I/O操作时，它都会非常有用。如果不需要用一个内核线程来推后执行工作，那么就考虑使用tasklet。

https://www.cnblogs.com/schips/p/using_tasklet_or_workqueue_handle_in_link_kernel_interrupt.html