Linux驱动学习--时间、延迟及延缓操作

#ifdef __KERNEL__

# define HZ         CONFIG_HZ    /* Internal kernel timer frequency */

# define USER_HZ     100        /*
用户空间使用的HZ，User interfaces are in "ticks" */

# define
CLOCKS_PER_SEC    (USER_HZ)    /* like times() */

#else

# define HZ         100

#endif

#

# Kernel Features

#

# CONFIG_PREEMPT is not
set

# CONFIG_NO_IDLE_HZ is
not set

CONFIG_HZ=200

# CONFIG_AEABI is not
set

# CONFIG_ARCH_DISCONTIGMEM_ENABLE is
not set

#include
<linux/jiffies.h>

unsigned long j, stamp_1, stamp_half, stamp_n;

j = jiffies;
/* read the current value */

stamp_1 = j + HZ;
/* 1 second in the future */

stamp_half = j + HZ/2;
/* half a second */

stamp_n = j + n
* HZ / 1000;
/* n milliseconds */

#define time_after(a,b)
\

(typecheck(unsigned
long, a)
&& \

typecheck(unsigned
long, b)
&& \

((long)(b)
- (long)(a)
< 0))

#define time_before(a,b)     time_after(b,a)

#define time_after_eq(a,b)     \

(typecheck(unsigned
long, a)
&& \

typecheck(unsigned
long, b)
&& \

((long)(a)
- (long)(b)
>= 0))

#define time_before_eq(a,b)     time_after_eq(b,a)

#include
<linux/time.h>
/* ＃i nclude <linux/jiffies.h> --> \kernel\time.c*/

struct timespec
{

time_t     tv_sec;        /* seconds */

long     tv_nsec;    /* nanoseconds */

};

#endif

struct timeval
{

time_t         tv_sec;        /* seconds */

suseconds_t     tv_usec;    /* microseconds */

};

unsigned long timespec_to_jiffies(struct
timespec *value);

void jiffies_to_timespec(unsigned
long jiffies,
struct timespec
*value);

unsigned long timeval_to_jiffies(struct
timeval *value);

void jiffies_to_timeval(unsigned
long jiffies,
struct timeval
*value);

#include
<linux/jiffies.h>

u64 get_jiffies_64(void);

rdtsc(low32,high32);/*原子地读取
64-位TSC 值到 2 个 32-位 变量*/

rdtscl(low32);/*读取TSC的低32位到一个 32-位 变量*/

rdtscll(var64);/*读 64-位TSC 值到一个 long long 变量*/

/*下面的代码行测量了指令自身的执行时间:*/

unsigned long ini, end;

rdtscl(ini); rdtscl(end);

printk("time lapse: %li\n", end
- ini);

#include
<linux/timex.h>

cycles_t get_cycles(void);

/*这个函数在每个平台都有定义, 但在没有时钟周期计数器的平台上返回 0 */

/*由于s3c2410系列处理器上没有时钟周期计数器所以get_cycles定义如下：*/

typedef unsigned
long cycles_t;

static inline cycles_t get_cycles
(void)

{

return 0;

}

unsigned
long

mktime(const
unsigned intyear0,
const unsigned
intmon0,

const unsigned
intday,
const unsigned
inthour,

const unsigned
intmin,
const unsigned
intsec)

{

unsigned intmon
= mon0, year
= year0;

/* 1..12 -> 11,12,1..10 */

if (0
>= (int)
(mon -= 2))
{

mon += 12;    /* Puts Feb last since it has leap day */

year -= 1;

}

return ((((unsigned
long)

(year/4
- year/100
+ year/400 + 367*mon/12
+ day)
+

year*365 - 719499

)*24
+ hour /* now have hours */

)*60
+ min /* now have minutes */

)*60
+ sec; /* finally seconds */

}

/*这个函数将时间转换成从1970年1月1日0小时0分0秒到你输入的时间所经过的秒数，溢出时间为2106-02-07 06:28:16。本人认为这个函数的使用应这样：若你要计算2000-02-07 06:28:16 到2000-02-09 06:28:16 所经过的秒数：unsigned long time1 = mktime(2000,2,7,6,28,16)-mktime(2000,2,9,6,28,16)；
若还要转成jiffies，就再加上:unsigned long time2 = time1*HZ. 注意溢出的情况！*/

#include
<linux/time.h>

void do_gettimeofday(struct
timeval *tv);

struct timespec current_kernel_time(void);

/*得到的数据都表示当前时间距UNIX时间基准1970－01－01 00：00：00的相对时间*/

while
(time_before(jiffies, j1))

cpu_relax();

#define cpu_relax()
barrier()

while
(time_before(jiffies, j1)) ;

while
(time_before(jiffies, j1))
{

schedule();

}

#include
<linux/wait.h>

long wait_event_timeout(wait_queue_head_t q, condition,
long timeout);

long wait_event_interruptible_timeout(wait_queue_head_t q, condition,
long timeout);

/*这些函数在给定队列上睡眠, 但是它们在超时(以 jiffies 表示)到后返回。如果超时，函数返回 0; 如果这个进程被其他事件唤醒，则返回以 jiffies 表示的剩余的延迟实现；返回值从不会是负值*/

#include
<linux/sched.h>

signed long schedule_timeout(signed
long timeout);

/*timeout 是要延时的 jiffies 数。除非这个函数在给定的 timeout 流失前返回，否则返回值是 0 。schedule_timeout 要求调用者首先设置当前的进程状态。为获得一个不可中断的延迟, 可使用 TASK_UNINTERRUPTIBLE 代替。如果你忘记改变当前进程的状态, 调用 schedule_time 如同调用 shcedule，建立一个不用的定时器。一个典型调用如下:*/

set_current_state(TASK_INTERRUPTIBLE);

schedule_timeout (delay);

#include
<linux/delay.h>

void ndelay(unsigned
long nsecs);

void udelay(unsigned
long usecs);

void mdelay(unsigned
long msecs);

void msleep(unsigned
intmillisecs);

unsigned long msleep_interruptible(unsigned
intmillisecs);

void ssleep(unsigned
intseconds)

#include
<linux/timer.h>

struct timer_list {

struct list_head entry;

unsigned long expires;/*期望定时器运行的绝对 jiffies 值，不是一个 jiffies_64 值，因为定时器不被期望在将来很久到时*/

void (*function)(unsigned
long);
/*期望调用的函数*/

unsigned long data;/*传递给函数的参数，若需要在参数中传递多个数据项,可以将它们捆绑成单个数据结构并且将它的指针强制转换为 unsiged long 的指针传入。这种做法在所有支持的体系上都是安全的并且在内存管理中相当普遍*/

struct tvec_t_base_s
*base;

#ifdef CONFIG_TIMER_STATS

void *start_site;

char start_comm[16];

intstart_pid;

#endif

};

/*这个结构必须在使用前初始化，以保证所有的成员被正确建立（包括那些对调用者不透明的初始化）：*/

void init_timer(struct timer_list
*timer);

struct timer_list TIMER_INITIALIZER(_function, _expires, _data);

/*在初始化后和调用 add_timer 前，可以改变 3 个公共成员：expires、function和data*/

void add_timer(struct timer_list
* timer);

intdel_timer(struct timer_list
* timer);/*在到时前禁止一个已注册的定时器*/

intdel_timer_sync(struct timer_list
*timer);
/*如同 del_timer ，但还保证当它返回时, 定时器函数不在任何 CPU 上运行，以避免在 SMP 系统上竞态, 并且在 单处理器内核中和 del_timer 相同。这个函数应当在大部分情况下优先考虑。 如果它被从非原子上下文调用, 这个函数可能睡眠，但是在其他情况下会忙等待。当持有锁时要小心调用 del_timer_sync ，如果这个定时器函数试图获得同一个锁, 系统会死锁。如果定时器函数重新注册自己, 调用者必须首先确保这个重新注册不会发生;
这通常通过设置一个" 关闭 "标志来实现, 这个标志被定时器函数检查*/

intmod_timer(struct timer_list
*timer,
unsigned long expires);
/*更新一个定时器的超时时间, 常用于超时定时器。也可在正常使用 add_timer时在不活动的定时器上调用mod_timer*/

inttimer_pending(const
struct timer_list * timer);
/*通过调用timer_list结构中一个不可见的成员，返回定时器是否在被调度运行*/

#include
<linux/interrupt.h>

struct tasklet_struct

{

struct tasklet_struct
*next;

unsigned long state;

atomic_t count;

void (*func)(unsigned
long);

unsigned long data;

};

void tasklet_init(struct tasklet_struct
*t,

void (*func)(unsigned
long),
unsigned long data);

#define DECLARE_TASKLET(name, func, data) \

struct tasklet_struct name
= { NULL, 0, ATOMIC_INIT(0),
func, data }

#define DECLARE_TASKLET_DISABLED(name, func, data) \

struct tasklet_struct name
= { NULL, 0, ATOMIC_INIT(1),
func, data }

void tasklet_disable(struct tasklet_struct
*t);

/*函数暂时禁止给定的 tasklet被 tasklet_schedule 调度，直到这个 tasklet 被再次被enable；若这个 tasklet 当前在运行, 这个函数忙等待直到这个tasklet退出*/

void tasklet_disable_nosync(struct tasklet_struct
*t);

/*和tasklet_disable类似，但是tasklet可能仍然运行在另一个 CPU */

void tasklet_enable(struct tasklet_struct
*t);

/*使能一个之前被disable的 tasklet;若这个 tasklet 已经被调度, 它会很快运行。 tasklet_enable 和tasklet_disable必须匹配调用, 因为内核跟踪每个 tasklet 的"禁止次数"*/

void tasklet_schedule(struct tasklet_struct
*t);

/*调度 tasklet 执行，如果tasklet在运行中被调度, 它在完成后会再次运行; 这保证了在其他事件被处理当中发生的事件受到应有的注意. 这个做法也允许一个 tasklet 重新调度它自己*/

void tasklet_hi_schedule(struct tasklet_struct
*t);

/*和tasklet_schedule类似，只是在更高优先级执行。当软中断处理运行时, 它处理高优先级 tasklet 在其他软中断之前，只有具有低响应周期要求的驱动才应使用这个函数, 可避免其他软件中断处理引入的附加周期*/

void tasklet_kill(struct tasklet_struct
*t);

/*确保了 tasklet 不会被再次调度来运行，通常当一个设备正被关闭或者模块卸载时被调用。如果 tasklet 正在运行, 这个函数等待直到它执行完毕。若 tasklet 重新调度它自己，则必须阻止在调用 tasklet_kill 前它重新调度它自己，如同使用 del_timer_sync*/

struct workqueue_struct
*create_workqueue(const
char *name);

struct workqueue_struct
*create_singlethread_workqueue(const
char *name);

/*需要填充work_struct或delayed_work结构，可以在编译时完成,
宏如下: */

struct work_struct
{

atomic_long_t data;

#define WORK_STRUCT_PENDING 0        /* T if work item pending execution */

#define WORK_STRUCT_FLAG_MASK
(3UL)

#define WORK_STRUCT_WQ_DATA_MASK
(~WORK_STRUCT_FLAG_MASK)

struct list_head entry;

work_func_t func;

};

struct delayed_work {

struct work_struct work;

struct timer_list timer;

};

DECLARE_WORK(n, f)

/*n 是声明的work_struct结构名称, f是要从工作队列被调用的函数*/

DECLARE_DELAYED_WORK(n, f)

/*n是声明的delayed_work结构名称, f是要从工作队列被调用的函数*/

/*若在运行时需要建立 work_struct 或 delayed_work结构, 使用下面 2 个宏定义:*/

INIT_WORK(struct work_struct
*work,
void (*function)(void
*));

PREPARE_WORK(struct work_struct
*work,
void (*function)(void
*));

INIT_DELAYED_WORK(struct delayed_work
*work,
void (*function)(void
*));

PREPARE_DELAYED_WORK(struct delayed_work
*work,
void (*function)(void
*));

/* INIT_* 做更加全面的初始化结构的工作，在第一次建立结构时使用. PREPARE_* 做几乎同样的工作, 但是它不初始化用来连接 work_struct或delayed_work 结构到工作队列的指针。如果这个结构已经被提交给一个工作队列, 且只需要修改该结构,则使用 PREPARE_* 而不是 INIT_* */

/*有 2 个函数来提交工作给一个工作队列:*/

intqueue_work(struct workqueue_struct
*queue,
struct work_struct *work);

intqueue_delayed_work(struct workqueue_struct
*queue,
struct delayed_work *work,
unsigned long delay);

/*每个都添加work到给定的workqueue。如果使用 queue_delay_work, 则实际的工作至少要经过指定的 jiffies 才会被执行。
这些函数若返回 1 则工作被成功加入到队列; 若为0，则意味着这个 work 已经在队列中等待，不能再次加入*/

intcancel_delayed_work(struct delayed_work
*work);

void cancel_work_sync(struct work_struct
*work)

void flush_workqueue(struct workqueue_struct
*queue);

void destroy_workqueue(struct workqueue_struct
*queue);

static
struct work_struct jiq_work;

static struct delayed_work jiq_work_delay;

/* this line is in jiq_init() */

INIT_WORK(&jiq_work, jiq_print_wq);

INIT_DELAYED_WORK(&jiq_work_delay, jiq_print_wq);

intschedule_work(&jiq_work);/*对于work_struct结构*/

int

schedule_delayed_work(&jiq_work_delay, delay);/*对于delayed_work结构*/

/*返回值的定义和

queue_work

一样*/

void flush_scheduled_work(void);