本文主要是介绍linux设备驱动之时间，延迟及延缓操作（实践），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
一 jit.函数源码
/** jit.c -- the just-in-time module** Copyright (C) 2001,2003 Alessandro Rubini and Jonathan Corbet* Copyright (C) 2001,2003 O'Reilly & Associates** The source code in this file can be freely used, adapted,* and redistributed in source or binary form, so long as an* acknowledgment appears in derived source files. The citation* should list that the code comes from the book "Linux Device* Drivers" by Alessandro Rubini and Jonathan Corbet, published* by O'Reilly & Associates. No warranty is attached;* we cannot take responsibility for errors or fitness for use.** $Id: jit.c,v 1.16 2004/09/26 07:02:43 gregkh Exp $*/#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>#include <linux/time.h>
#include <linux/timer.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>#include <linux/param.h>
#include <linux/wait.h>
#include <linux/jiffies.h>
#include <linux/sched.h>#include <asm/hardirq.h>
/** This module is a silly one: it only embeds short code fragments* that show how time delays can be handled in the kernel.*/int delay = HZ; /* the default delay, expressed in jiffies */module_param(delay, int, 0);MODULE_AUTHOR("Alessandro Rubini");
MODULE_LICENSE("Dual BSD/GPL");/* use these as data pointers, to implement four files in one function */
enum jit_files {JIT_BUSY,JIT_SCHED,JIT_QUEUE,JIT_SCHEDTO
};/** This function prints one line of data, after sleeping one second.* It can sleep in different ways, according to the data pointer*/
int jit_fn(char *buf, char **start, off_t offset,int len, int *eof, void *data)
{unsigned long j0, j1; /* jiffies */wait_queue_head_t wait;init_waitqueue_head (&wait);j0 = jiffies;j1 = j0 + delay;switch((long)data) {case JIT_BUSY:while (time_before(jiffies, j1))cpu_relax();break;case JIT_SCHED:while (time_before(jiffies, j1)) {schedule();}break;case JIT_QUEUE:wait_event_interruptible_timeout(wait, 0, delay); break;case JIT_SCHEDTO:set_current_state(TASK_INTERRUPTIBLE);schedule_timeout (delay);break;}j1 = jiffies; /* actual value after we delayed */len = sprintf(buf, "%9li %9li\n", j0, j1);*start = buf;return len;
}/** This file, on the other hand, returns the current time forever*/
int jit_currentime(char *buf, char **start, off_t offset,int len, int *eof, void *data)
{struct timeval tv1;struct timespec tv2;unsigned long j1;u64 j2;/* get them four */j1 = jiffies;j2 = get_jiffies_64();do_gettimeofday(&tv1);tv2 = current_kernel_time();/* print */len=0;len += sprintf(buf,"0x%08lx 0x%016Lx %10i.%06i\n""%40i.%09i\n",j1, j2,(int) tv1.tv_sec, (int) tv1.tv_usec,(int) tv2.tv_sec, (int) tv2.tv_nsec);*start = buf;return len;
}/** The timer example follows*/int tdelay = 10;
module_param(tdelay, int, 0);/* This data structure used as "data" for the timer and tasklet functions */
struct jit_data {struct timer_list timer;struct tasklet_struct tlet;int hi; /* tasklet or tasklet_hi */wait_queue_head_t wait;unsigned long prevjiffies;unsigned char *buf;int loops;
};
#define JIT_ASYNC_LOOPS 5void jit_timer_fn(unsigned long arg)
{struct jit_data *data = (struct jit_data *)arg;unsigned long j = jiffies;data->buf += sprintf(data->buf, "%9li %3li %i %6i %i %s\n",j, j - data->prevjiffies, in_interrupt() ? 1 : 0,current->pid, smp_processor_id(), current->comm);if (--data->loops) {data->timer.expires += tdelay;data->prevjiffies = j;add_timer(&data->timer);} else {wake_up_interruptible(&data->wait);}
}/* the /proc function: allocate everything to allow concurrency */
int jit_timer(char *buf, char **start, off_t offset,int len, int *eof, void *unused_data)
{struct jit_data *data;char *buf2 = buf;unsigned long j = jiffies;data = kmalloc(sizeof(*data), GFP_KERNEL);if (!data)return -ENOMEM;init_timer(&data->timer);init_waitqueue_head (&data->wait);/* write the first lines in the buffer */buf2 += sprintf(buf2, " time delta inirq pid cpu command\n");buf2 += sprintf(buf2, "%9li %3li %i %6i %i %s\n",j, 0L, in_interrupt() ? 1 : 0,current->pid, smp_processor_id(), current->comm);/* fill the data for our timer function */data->prevjiffies = j;data->buf = buf2;data->loops = JIT_ASYNC_LOOPS;/* register the timer */data->timer.data = (unsigned long)data;data->timer.function = jit_timer_fn;data->timer.expires = j + tdelay; /* parameter */add_timer(&data->timer);/* wait for the buffer to fill */wait_event_interruptible(data->wait, !data->loops);if (signal_pending(current))return -ERESTARTSYS;buf2 = data->buf;kfree(data);*eof = 1;return buf2 - buf;
}void jit_tasklet_fn(unsigned long arg)
{struct jit_data *data = (struct jit_data *)arg;unsigned long j = jiffies;data->buf += sprintf(data->buf, "%9li %3li %i %6i %i %s\n",j, j - data->prevjiffies, in_interrupt() ? 1 : 0,current->pid, smp_processor_id(), current->comm);if (--data->loops) {data->prevjiffies = j;if (data->hi)tasklet_hi_schedule(&data->tlet);elsetasklet_schedule(&data->tlet);} else {wake_up_interruptible(&data->wait);}
}/* the /proc function: allocate everything to allow concurrency */
int jit_tasklet(char *buf, char **start, off_t offset,int len, int *eof, void *arg)
{struct jit_data *data;char *buf2 = buf;unsigned long j = jiffies;long hi = (long)arg;data = kmalloc(sizeof(*data), GFP_KERNEL);if (!data)return -ENOMEM;init_waitqueue_head (&data->wait);/* write the first lines in the buffer */buf2 += sprintf(buf2, " time delta inirq pid cpu command\n");buf2 += sprintf(buf2, "%9li %3li %i %6i %i %s\n",j, 0L, in_interrupt() ? 1 : 0,current->pid, smp_processor_id(), current->comm);/* fill the data for our tasklet function */data->prevjiffies = j;data->buf = buf2;data->loops = JIT_ASYNC_LOOPS;/* register the tasklet */tasklet_init(&data->tlet, jit_tasklet_fn, (unsigned long)data);data->hi = hi;if (hi)tasklet_hi_schedule(&data->tlet);elsetasklet_schedule(&data->tlet);/* wait for the buffer to fill */wait_event_interruptible(data->wait, !data->loops);if (signal_pending(current))return -ERESTARTSYS;buf2 = data->buf;kfree(data);*eof = 1;return buf2 - buf;
}int __init jit_init(void)
{create_proc_read_entry("currentime", 0, NULL, jit_currentime, NULL);create_proc_read_entry("jitbusy", 0, NULL, jit_fn, (void *)JIT_BUSY);create_proc_read_entry("jitsched",0, NULL, jit_fn, (void *)JIT_SCHED);create_proc_read_entry("jitqueue",0, NULL, jit_fn, (void *)JIT_QUEUE);create_proc_read_entry("jitschedto", 0, NULL, jit_fn, (void *)JIT_SCHEDTO);create_proc_read_entry("jitimer", 0, NULL, jit_timer, NULL);create_proc_read_entry("jitasklet", 0, NULL, jit_tasklet, NULL);create_proc_read_entry("jitasklethi", 0, NULL, jit_tasklet, (void *)1);return 0; /* success */
}void __exit jit_cleanup(void)
{remove_proc_entry("currentime", NULL);remove_proc_entry("jitbusy", NULL);remove_proc_entry("jitsched", NULL);remove_proc_entry("jitqueue", NULL);remove_proc_entry("jitschedto", NULL);remove_proc_entry("jitimer", NULL);remove_proc_entry("jitasklet", NULL);remove_proc_entry("jitasklethi", NULL);
}module_init(jit_init);
module_exit(jit_cleanup);二 Makefilewenjian源码
KERNELDIR = /usr/src/linux-headers-2.6.38-8-generic
PWD := $(shell pwd)obj-m := jit.o modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules三 编译及安装驱动
1 caoyin@caoyin:~/jit$ make
2 root@caoyin:/home/caoyin/jit# insmod ./jit.ko
四 测试例子
a 获取当前时间
root@caoyin:/home/caoyin/jit# head -8 /proc/currentime
b 忙等待
root@caoyin:/home/caoyin/jit# dd bs=20 count=5 < /proc/jitbusy
c 让出处理器
root@caoyin:/home/caoyin/jit# dd bs=20 count=5 < /proc/jitshed
d 超时
root@caoyin:/home/caoyin/jit# dd bs=20 count=5 < /proc/jitqueue
e tasklet的实现
root@caoyin:/home/caoyin/jit# cat /proc/jitasklet
这篇关于linux设备驱动之时间，延迟及延缓操作（实践）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
