精华内容
下载资源
问答
  • timer_list

    2011-12-20 14:29:36
    nclude/linux/timer.h里声明。  struct timer_list {  struct timer_list *next;  struct timer_list *prev;  unsigned long expires;  unsigned long data;
    nclude/linux/timer.h里声明。     
    
      struct   timer_list   {    
      struct   timer_list   *next;    
      struct   timer_list   *prev;    
      unsigned   long   expires;    
      unsigned   long   data;    
      void   (*function)(unsigned   long);    
      };    
      void   add_timer(struct   timer_list   *   timer);    
      int   del_timer(struct   timer_list   *   timer);    

      void   init_timer(struct   timer_list   *   timer);    


                      使用时钟,先声明一个timer_list结构,调用init_timer对它进行初始化。time_list结构里expires是标明这个时钟的周期,单位采用jiffies的单位。jiffies是Linux一个全局变量,代表时间。它的单位随硬件平台的不同而不同。系统里定义了一个常数HZ,代表每秒种最小时间间隔的数目。这样jiffies的单位就是1/HZ。Intel平台jiffies的单位是1/100秒,这就是系统所能分辨的最小时间间隔了。所以expires/HZ就是以秒为单位的这个时钟的周期。function就是时间到了以后的回调函数,它的参数就是timer_list中的 data。data这个参数在初始化时钟的时候赋值,一般赋给它设备的device结构指针。在预置时间到系统调用function,同时系统把这个 time_list从定时队列里清除。所以如果需要一直使用定时函数,要在function里再次调用add_timer()把这个timer_list 加进定时队列。  
    展开全文
  • Linux kernel定时器timer_list1.简单介绍一下定时器timer_list:2.实例演示3.总结 1.简单介绍一下定时器timer_list: 1.0 所在头文件: linux/timer.h 1.1 结构体: struct timer_list { /* * All fields that ...

    1.简单介绍一下定时器timer_list:

    1.0 所在头文件:
    linux/timer.h
    1.1 结构体:

    	struct timer_list {
    		/*
    		* All fields that change during normal runtime grouped to the
    		* same cacheline
    		*/
    		struct list_head entry;
    		unsigned long expires;
    		struct tvec_base *base;
    	
    		void (*function)(unsigned long);
    		unsigned long data;
    	
    		int slack;
    	
    	#ifdef CONFIG_TIMER_STATS
    		int start_pid;
    		void *start_site;
    		char start_comm[16];
    	#endif
    	#ifdef CONFIG_LOCKDEP
    		struct lockdep_map lockdep_map;
    	#endif
    	};
    

    1.2 成员介绍:
    list 实现的时候使用的,和定时器功能无关;
    expires 是定时器定时的滴答数(当前的滴答数为jiffies);
    void (*function)(unsigned long) 定时器超时处理函数;
    data 传递到超时处理函数的参数,主要在多个定时器同时使用时,区别是哪个timer超时。

    1.3 提供的API接口:
    a. init_timer(struct timer_list*):定时器初始化函数;
    b. add_timer(struct timer_list*):往系统添加定时器;
    c. mod_timer(struct timer_list *, unsigned long jiffier_timerout):修改定时器的超时时间为jiffies_timerout;
    d. timer_pending(struct timer_list ):定时器状态查询,如果在系统的定时器列表中则返回1,否则返回0;
    e. del_timer(struct timer_list
    ):删除定时器。
    5. 使用方法:
    a. 创建定时器时需要先定义struct timer_list my_timer;
    b. 在file_operation指定的open函数中初始化定时器init_timer(&my_timer);
    c. 在超时处理函数结尾重新加载定时器时间mod_timer(&my_timer,HZ);
    d. 如果自己编写的驱动中有中断,需要在中断入口处del_timer(&my_timer);并且在入口处重新重新加载定时器时间mod_timer(&my_timer,HZ)。

    2.实例演示

    #include <linux/module.h>
    
    #include <linux/kernel.h>
    
    #include <linux/init.h>
    
    #include <linux/sched.h>//jiffies在此头文件中定义
    
    #include <linux/init.h>
    
    #include <linux/timer.h>
    
    struct timer_list timer;//定义一个定时器
    
    void  timer_function(unsigned long arg)
    
    {
    
        printk("Mytimer is ok\n");
    
        printk("receive data from timer: %d\n",arg);
    
        //mod_timer(&timer, jiffies + (5*HZ));//重新设置定时器,每隔5秒执行一次
    
    }
    
    static int __init chaos_init (void)
    
    {
    
        printk("chaos,world\n");
    
        init_timer(&timer);     //初始化定时器
    
        timer.expires = jiffies+(5*HZ);//设定超时时间,5秒
    
        timer.data = 5;    //传递给定时器超时函数的值
    
        timer.function = timer_function;//设置定时器超时函数
    
        add_timer(&timer); //添加定时器,定时器开始生效
    
        return 0;
    
    }
    
    static void __exit chaos_exit (void)
    
    {
    
        del_timer(&timer);//卸载模块时,删除定时器
    
        printk("chaos module exit\n");
    
    }
    
    module_init(chaos_init);
    
    module_exit(chaos_exit);
    
    MODULE_AUTHOR("chaos");
    
    MODULE_LICENSE("GPL");
    

    3.总结

    3.0 定义一个结构体:
    static struct timer_list test_timer;

    3.1 初始化
    init_timer(&test_timer);
    test_timer.function = timer_func;
    add_timer(&test_timer);

    3.2 10ms后启动定时器
    mod_timer(&test_timer, jiffies+HZ/100); //HZ为1S,则HZ/100为10ms

    展开全文
  • Linux 内核定时器 timer_list hrtimer

    千次阅读 2017-05-18 17:12:43
    10.5内核定时器 10.5.1内核定时器编程 1.timer_list struct timer_list my_...void init_timer(struct timer_list *timer); 3.增加定时器 void add_timer(struct timer_list *timer); 4.删除定时器


    10.5内核定时器
    10.5.1内核定时器编程


    1.timer_list
    struct timer_list my_timer;


    2.初始化定时器
    void init_timer(struct timer_list *timer);


    3.增加定时器
    void add_timer(struct timer_list *timer);


    4.删除定时器
    int del_timer(struct timer_list *timer);


    5.修改定时器的expire
    int mod_timer(struct timer_list *timer, unsigned long expires);


    10.10 内核定时器使用模板
    //xxx设备结构体
    struct xxx_dev
    {
    struct cdev cdev;
    .....
    timer_list xxx_timer;//设备要使用的定时器
    };
    //xxx驱动中的某函数
    xxx_funcl(...)
    {
    struct xxx_dev *dev = filp->private_data;
    ...
    //初始化定时器
    init_timer(&dev->xxx_timer);
    dev->xxx_timer.function = &xxx_do_timer;
    dev->xxx_timer.data = (unsigned long)dev;
    //设备结构体指针作为定时器处理函数参数
    dev->xxx_timer.expires = jiffies + delay;
    //添加(注册)定时器
    add_timer(&dev->xxx_timer);
    }


    //xxx驱动中的某函数
    xxx_func2(...)
    {
    ....
    //删除定时器
    del_timer(&dev->xxx_timer);
    ....
    }


    //定时器处理函数
    static void xxx_do_timer(unsigned long arg)
    {
    struct xxx_device *dev = (struct xxx_device *)(arg);
    ...
    //调度定时器再执行
    dev->xxx_timer.expires = jiffies + delay;
    add_timer(&dev->xxx_timer);
    ...
    }




    hrtimer(high resolution timer)表示高精度定时器:
    ==============================================================================
    API
    ktime_t ktime_add_ns(const ktime_t kt, u64 nsec)
    ktime_t ktime_sub_ns(const ktime_t kt, u64 nsec)
    ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs)
    void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t clock_id,
      enum hrtimer_mode mode)
      
    u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)   
    int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
    unsigned long delta_ns, const enum hrtimer_mode mode)


    int
    hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
    int hrtimer_try_to_cancel(struct hrtimer *timer)
    int hrtimer_cancel(struct hrtimer *timer)
    ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
    void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
     enum hrtimer_mode mode)
    int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
    int __sched schedule_hrtimeout(ktime_t *expires,
          const enum hrtimer_mode mode)






    /*
     * Mode arguments of xxx_hrtimer functions:
     */
    enum hrtimer_mode {
    HRTIMER_MODE_ABS = 0x0, /* Time value is absolute */
    HRTIMER_MODE_REL = 0x1, /* Time value is relative to now */
    HRTIMER_MODE_PINNED = 0x02, /* Timer is bound to CPU */
    HRTIMER_MODE_ABS_PINNED = 0x02,
    HRTIMER_MODE_REL_PINNED = 0x03,
    };




    /*
     * Return values for the callback function
     */
    enum hrtimer_restart {
    HRTIMER_NORESTART, /* Timer is not restarted */
    HRTIMER_RESTART, /* Timer must be restarted */
    };       
           
    #define HRTIMER_STATE_INACTIVE 0x00
    #define HRTIMER_STATE_ENQUEUED 0x01
    #define HRTIMER_STATE_CALLBACK 0x02
    #define HRTIMER_STATE_MIGRATE 0x04


    /* Parameters used to convert the timespec values: */
    #define MSEC_PER_SEC 1000L
    #define USEC_PER_MSEC 1000L
    #define NSEC_PER_USEC 1000L
    #define NSEC_PER_MSEC 1000000L
    #define USEC_PER_SEC 1000000L
    #define NSEC_PER_SEC 1000000000L
    #define FSEC_PER_SEC 1000000000000000LL

    hrtimer用法:


    struct hrtimer acc_timer; //定义hrtimer
    ktime_t acc_poll_delay; //定义ktimer_t 类型 时间变量。


    //hrtimer 调用函数
    static enum hrtimer_restart stk_acc_timer_func(struct hrtimer *timer)
    {
    struct stk831x_data *stk = container_of(timer, struct stk831x_data, acc_timer);
    queue_work(stk->stk_acc_wq, &stk->stk_acc_work);
    hrtimer_forward_now(&acc_timer, acc_poll_delay); //
    //hrtimer_forward_now(&gw_hrtimer,ktime_set(0, 62500));//直接设置为62500ns
    return HRTIMER_RESTART;
    }


    int __init xxx_init(void)
    {
    ....
    hrtimer_init(&acc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
    acc_poll_delay = ns_to_ktime(2500 * USEC_PER_MSEC);
    acc_timer.function = stk_acc_timer_func;
    ......
    }


    //启动
    int xxx_probe(void)
    {
    hrtimer_start(&stk->acc_timer, stk->acc_poll_delay, HRTIMER_MODE_REL);
    }


    void xxx_suspend(void)
    {
    hrtimer_cancel(&acc_timer);
    }


    void __exit xxx_exit(void)
    {
    hrtimer_try_to_cancel(&acc_timer);
    }
    展开全文
  • timer_list变量timer

    2012-11-30 14:41:26
    主要需要定义一个timer_list变量timer、先初始化timer  init_timer(&timer);  then 对timer的相关参数赋值:  timer.function = fun;  timer.expires = jiffies + TIMER_DELAY;  add_timer(&timer);  在...
     
    


     

    总的来说,timer的用法还是很简单的。主要需要定义一个timer_list变量timer、先初始化timer

      init_timer(&timer);

      then 对timer的相关参数赋值:

      timer.function = fun;

      timer.expires = jiffies + TIMER_DELAY;

      add_timer(&timer);

      在定时器时间到的时候,会执行fun,如果继续定时,可以通过

      在fun中执行

      mod_timer(&timer, jiffies + TIMER_DELAY);

      在不需要的时候通过调用

      del_timer(&timer);

      删除定时器。

      简单吧。这样一个简单的定时器就完成了。

      呵呵。

      附程序:

      

    #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>

    #include <asm/atomic.h>

     

    #define SECOND_MAJOR 0

     

    static int second_major = SECOND_MAJOR;

     

    struct second_dev

    {

    struct 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_ERR "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);

    return 0;

    }

     

    int second_release(struct inode *inode, struct file *filp)

    {

    del_timer(&second_devp->s_timer);

     

    return 0;

    }

    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,

    };

    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 add second%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);

    kfree(second_devp);

    unregister_chrdev_region(MKDEV(second_major, 0), 1);

    }

     

    MODULE_AUTHOR("Song Baohua");

    MODULE_LICENSE("Dual BSD/GPL");

     

    module_param(second_major, int, S_IRUGO);

     

    module_init(second_init);

    module_exit(second_exit);

     

    附上用户端的测试程序:

    #include <stdio.h>

    #include <unistd.h>

    #include <fcntl.h>

     

    int main(void)

    {

    int fd, i;

    int data;

    fd = open("/dev/second",O_RDONLY);

    if (fd < 0)

    {

    printf("open /dev/second error\n");

    }

    for(i = 0; i < 20; i++)

    {

    read(fd, &data, sizeof(data));

    printf("read /dev/second is %d\n",data);

    sleep(1);

    }

    close(fd);

    }

     

    展开全文
  • 内核定时器timer_list使用

    千次阅读 2018-03-05 14:15:06
    数据类型:struct timer_list;包含的主要成员: a. data:传递到超时处理函数的参数,主要在多个定时器同时使用时,区别是哪个timer超时。 b. expires:定时器超时的时间,以linux的jiffies来衡量。 c. void (*...
  • linux内核使用timer_list 结构体当作定时器。 点击(此处)折叠或打开 #include linux/timer.h> #include linux/module.h> MODULE_LICENSE("GPL"); //不加这句话,虽然不影响功能,但“有时候”程序执行...
  • 转自:... 1.Linux在include/linux/timer.h头文件中定义了数据结构timer_list来描述一个内核定时器: struct timer_list { struct list_head list; unsigned long expires
  • timer_list结构体

    2014-03-05 21:00:26
    在用户态程序编程时,延时常常使用sleep(),我在 windows下面写Bat脚本还用过”ping localhost”来延时1秒。再写驱动程序时,sleep就不能...time_list结构体位于内核文件include/linux/timer.h struct timer_list
  • 7.6.1 Linux内核对定时器的描述 Linux在include/linux/timer.h头文件中定义了数据结构timer_list来描述一个内核定时器: ...struct list_head list; unsigned long expires; unsigned long data; void (*func
  • 内核定时器timer_list
  • 在ril.cpp中定义了3个队列,分别是watch_table,timer_list和pending_list,他们里面都存放的是ril_event结构,他们的主要作用如下: 1. watch_table是一个指针数组,它里面存放的是靠多路复用来驱动的ril_event,起...
  • Linux内核定时器timer_list的使用

    千次阅读 2019-08-15 15:47:18
    Linux内核定时器timer_list的使用 内核定时器: 定时器(优势也称为动态地上那个时期或内核定时器)是管理内核流逝时间放的基础。内核经常需要推后执行某些代码,如中断的下半部机制就是为了将工作放到 以后执行...
  • linux 内核定时器 timer_list

    千次阅读 2013-12-22 17:17:26
    linux内核使用timer_list 结构体当作定时器。 点击(此处)折叠或打开 #include linux/timer.h> #include linux/module.h> MODULE_LICENSE("GPL"); //不加这句话,虽然不影响功能,但“有...
  • 一.概述  信号量是Linux进程间通信的常用方法之一,这里使用POSIX标准的信号量,而不是System V的。 二....linux/timer.h ...二.... struct list_head entry; //定时器链表的入口 unsigned long expir
  • 定时器 timer_list (二)

    2011-01-18 12:40:00
    kernel timer_list usageinclude/linux/timer.h struct timer_list { struct list_head entry; unsigned long expires; <br />spinlock_t lock; unsigned long magic; <br />void (*...
  • linux kernel中struct timer_list使用

    千次阅读 2014-10-21 10:38:58
    linux kernel中struct timer_list使用 内核中最终的计时资源是定时器。定时器用于定时器超时处理程序在未来某个特定时间点执行,或者周期性的轮询硬件的状态。Linux提供了内核定时器完成这类工作。 一般来说...
  • 定时器 timer_list (一)

    2011-01-18 12:38:00
    定时器 timer_list (一)    struct timer_list |-----------------------------------| |struct list_head entry | |unsigned long expires | |void (*function)...
  • 设置定时器结构体的回调函数参数、回调函数、到期时间 初始化定时器 添加定时器 如果需要重复执行,则在回调函数里...struct timer_list test_timer; static void test_func(unsigned long data) { printk("jiffies:
  • struct list_head entry: 链表了,用于存放定时器unsigned long expires: 定时时间,expires后,调用其成员函数function,data字段为function参数,expires的单位是jiffies,一秒定时设定为expires=jiffies+HZ*1...
  • 内核定时器 timer_list 分析

    千次阅读 2011-01-09 13:11:00
    struct timer_list |-----------------------------------| |struct list_head entry | |unsigned long expires | |void (*function)(unsigned long)| |unsigned long data...
  • Linux内核定时器timer_list

    千次阅读 2016-03-17 17:18:39
    list_head entry; unsigned long expires; struct tvec_base *base; void (*function)(unsigned long ); unsigned long data; int slack; #ifdef CONFIG_TIMER_STATS int start_pid; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,857
精华内容 40,342
关键字:

TIMER_LIST