Linux设备驱动程序学习（10）-时间、延迟及延缓操作（Jit.c）

以下代碼基本演示了Linux设备驱动程序学习（10）-时间、延迟及延缓操作的所有知識

/*
 * 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/config.h>
#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/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; /* s3c24x0 HZ= 200*/

module_param(delay, int, 0);

/* 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();
                printk("cpu_relax()n");
            break;
        case JIT_SCHED:
            while (time_before(jiffies, j1)) {
                schedule();
                printk("schedule()n");
            }
            break;
        case JIT_QUEUE:
            wait_event_interruptible_timeout(wait, 0, delay);
            printk("one wait event for %d s",delay);
            break;
        case JIT_SCHEDTO:
            set_current_state(TASK_INTERRUPTIBLE);
            schedule_timeout (delay);
            printk("two wait event for %d s",delay);
            break;
    }
    j1 = jiffies; /* actual value after we delayed */

    len = sprintf(buf, "%9li %9lin", 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();
    //use two method to get the time
    do_gettimeofday(&tv1);
    tv2 = current_kernel_time();

    /* print */
    len=0;
    printk("the length is : %dn",len);
    len += sprintf(buf,"0x%08lx 0x%016Lx %10i.%06in"
         "%40i.%09in",
               j1, j2,
         (int) tv1.tv_sec, (int) tv1.tv_usec,
         (int) tv2.tv_sec, (int) tv2.tv_nsec);

    //here you can choose to show the message till you don't want (know the use of start)
    *start = buf; /*if you want currentime to output only onec ,disable this

    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 5

void 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   %sn",
                 j, j - data->prevjiffies, in_interrupt() ? 1 : 0,
                 current->pid, smp_processor_id(), current->comm);

    if (--data->loops)
    {
        data->prevjiffies = j;
        mod_timer(&data->timer, data->timer.expires+tdelay);
    }
    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 commandn");
    buf2 += sprintf(buf2, "%9li  %3li     %i    %6i   %i   %sn",
            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;
    //del_timer(&data->timer);
    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   %sn",
                 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);
        else
            tasklet_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 commandn");
    buf2 += sprintf(buf2, "%9li  %3li     %i    %6i   %i   %sn",
            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);
    else
        tasklet_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);

    //the method to use tranamit a data
    create_proc_read_entry("jitbusy", 0, NULL, jit_fn, (void *)JIT_BUSY/*pay more attention here*/);
    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);

MODULE_AUTHOR("Alessandro Rubini  ( modified by tekkaman )");
MODULE_LICENSE("Dual BSD/GPL");