定时器例程

/* 文件名：kgrunt.c */
/* 说明：定时器例程 */

#include <linux/module.h> /* 模块编程 */
#include <linux/fs.h> /* 设备号、文件操作接口 */
#include <linux/cdev.h> /* 字符设备编程接口 */
#include <linux/uaccess.h> /* 访问用户态内存接口 */
#include <linux/timer.h> /* 定时器接口 */
#include <linux/sched.h> /* 进程调度相关 */
#include <linux/wait.h> /* 等待队列接口 */

MODULE_LICENSE("GPL"); /* 版权声明 */

#define BUF_SIZE 256 /* 内核缓冲区的大小 */

/* 以下类型表示 kgrunt 设备 */
struct kgrunt_dev {
    struct cdev cdev; /* 内嵌一个字符设备作为代表向内核注册 */
    char *buf; /* 保存内核缓冲区的首地址 */
    int len; /* 保存内核缓冲区的长度 */
    int bytes; /* 保存内核缓冲区中字符的个数 */
    struct timer_list timer; /* 定时器 */
    int timer_flag; /* 控制是否继续注册定时器 */
    wait_queue_head_t queue; /* 读操作等待队列 */
    dev_t dev; /* 保存对应的设备号 */
};

static void kgrunt_timer_fn(unsigned long d)
{
    /* 从参数得到 kgrunt 设备的地址 */
    struct kgrunt_dev *dev = (struct kgrunt_dev *)d;
    /* 得到定时器变量的地址 */
    struct timer_list *timer = &dev->timer;
    /* 输出字符串到内核缓冲区 */
    dev->bytes = scnprintf(dev->buf, dev->len,
            "timer expires: %lu, jiffies: %lu, current pid: %d, comm: %s.\n",
            timer->expires, jiffies, current->pid, current->comm);
    /* 唤醒等待读的进程 */
    wake_up_interruptible(&dev->queue);
    /* 如果需要继续注册定时器，则继续注册，过期时间推后一秒 */
    if (dev->timer_flag) mod_timer(timer, timer->expires+HZ);
}

/* 打开操作 */
static int kgrunt_open(struct inode *inode, struct file *file)
{
    /* 由 inode 对应的字符设备指针得到 kgrunt 设备的地址 */
    struct kgrunt_dev *dev =
        container_of(inode->i_cdev, struct kgrunt_dev, cdev);
    pr_debug("kgrunt_open: be called!\n");
    /* 将 kgrunt 设备的地址保存在打开的文件中 */
    file->private_data = dev;
    /* 注册定时器，如是已经（被其他进程）注册，则修改它 */
    mod_timer(&dev->timer, jiffies+HZ); /* 定时器将于一秒后触发 */
    dev->timer_flag = 1; /* 设置标志，让定时器持续注册自身 */
    /* 返回 0 表示打开成功 */
    return 0;
}

/* 关闭操作 */
static int kgrunt_release(struct inode *inode, struct file *file)
{
    /* 由 inode 对应的字符设备指针得到 kgrunt 设备的地址 */
    struct kgrunt_dev *dev =
        container_of(inode->i_cdev, struct kgrunt_dev, cdev);
    pr_debug("kgrunt_release: be called!\n");
    /* 先将继续注册定时器的标志清零，再注销定时器，否则在对称多处理器平台上，
     * 当 del_timer_sync 返回时可能定时器已经再次注册上 */
    dev->timer_flag = 0;
    /* 注销定时器 */
    del_timer_sync(&dev->timer);
    return 0;
}

/* 读操作 */
static ssize_t kgrunt_read(struct file *file, char __user *buf,
        size_t count, loff_t *pos)
{
    int err; /* 用于保存错误码 */
    /* 从 file 中得到对应的 kgrunt 设备 */
    struct kgrunt_dev *dev = (struct kgrunt_dev *)file->private_data;
    pr_debug("kgrunt_read: pos = %d, count = %d.\n", (int)*pos, count);
    /* 参数合法性检查 */
    if (count < 0) return -EINVAL; /* 非法参数 */
    if (count == 0) return 0; /* 直接返回 0 */
    if (dev->bytes == 0) { /* 无数据可读 */
        /* 非阻塞方式下返回 -EAGAIN */
        if (file->f_flags & O_NONBLOCK) return -EAGAIN;
        /* 等待直到缓冲区不空 */
        err = wait_event_interruptible(dev->queue, dev->bytes > 0);
        /* 发生信号则返回 -EINTR */
        if (err == -ERESTARTSYS) return -EINTR;
    }
    /* 控制读取的长度，不能超过当前有效数据的个数 */
    if (count > dev->bytes) count = dev->bytes;
    /* 从内核缓冲区复制数据到 buf 指向的用户态内存。
     * 让每次读都从缓冲区开始复制数据，因此读写位置无意义 */
    if (copy_to_user(buf, dev->buf, count) > 0) {
        pr_debug("kgrunt_read: copy_to_user() FAILED!\n");
        return -EFAULT;
    }
    /* 读取之后将缓冲区中的数据清空 */
    dev->bytes = 0;
    /* 返回读到的字节数 */
    return count;
}

/* 写操作 */
static ssize_t kgrunt_write(struct file *file, const char __user *buf,
        size_t count, loff_t *pos)
{
    /* 不支持写操作，直接返回错误码 */
    return -EPERM;
}

/* 定位操作 */
static loff_t kgrunt_llseek(struct file *file, loff_t offset, int whence)
{
    /* 不支持定位操作，直接返回错误码 */
    return -EPERM;
}

/* 设备的文件操作，全局变量 */
static struct file_operations kgrunt_fops = {
    .owner = THIS_MODULE, /* 所属模块 */
    .open = kgrunt_open, /* 打开操作 */
    .release = kgrunt_release, /* 关闭操作 */
    .read = kgrunt_read, /* 读操作 */
    .write = kgrunt_write, /* 写操作 */
    .llseek = kgrunt_llseek, /* 定位操作 */
};

/* 全局变量，表示一个 kgrunt 设备 */
static struct kgrunt_dev kgrunt;

/* 模块的初始化函数 */
static __init int kgrunt_init(void)
{
    int err; /* 用于保存错误码 */
    pr_debug("kgrunt_init: be called!\n");
    /* 分配设备号 */
    if ((err = alloc_chrdev_region(&kgrunt.dev, 0, 1, "kgrunt")) < 0) {
        pr_debug("kgrunt_init: alloc_chrdev_region() ERR = %d!\n", -err);
        goto alloc_chrdev_region_fail;
    }
    pr_debug("kgrunt_init: dev = (%d, %d).\n",
            MAJOR(kgrunt.dev), MINOR(kgrunt.dev));
    /* 分配内核缓冲区 */
    if ((kgrunt.buf = kmalloc(BUF_SIZE, GFP_KERNEL)) == NULL) {
        pr_debug("kgrunt_init: kmalloc() ERR!\n");
        err = -ENOMEM; /* 此错误号表示内存不足 */
        goto kmalloc_kgrunt_buf_fail;
    }
    /* 保存缓冲区的长度 */
    kgrunt.len = BUF_SIZE;
    kgrunt.bytes = 0;
    /* 初始化字符设备 */
    cdev_init(&kgrunt.cdev, &kgrunt_fops);
    kgrunt.cdev.owner = kgrunt_fops.owner;
    /* 初始化定时器 */
    setup_timer(&kgrunt.timer, kgrunt_timer_fn, (unsigned long)&kgrunt);
    kgrunt.timer_flag = 0;
    /* 初始化等待队列 */
    init_waitqueue_head(&kgrunt.queue);
    /* 注册字符设备 */
    if ((err = cdev_add(&kgrunt.cdev, kgrunt.dev, 1)) < 0) {
        pr_debug("kgrunt_init: cdev_add() ERR = %d!\n", -err);
        goto cdev_add_fail;
    }
    return 0; /* 返回 0 表示初始化成功 */
/* 以下为出错处理，各个清理操作按初始化时的倒序排列，出错时跳转到相应的位置，
 * 这是驱动编程中常用的做法 */
cdev_add_fail:
    kfree(kgrunt.buf); /* 释放所分配的内存 */
kmalloc_kgrunt_buf_fail:
    unregister_chrdev_region(kgrunt.dev, 1); /* 注销所注册的设备号 */
alloc_chrdev_region_fail:
    return err;
}
module_init(kgrunt_init); /* 指定 kgrunt_init 为模块的初始化函数 */

/* 模块的退出函数 */
static __exit void kgrunt_exit(void)
{
    pr_debug("kgrunt_exit: be called!\n");
    /* 模块退出时进行清理，按初始化时的倒序操作 */
    cdev_del(&kgrunt.cdev); /* 注销字符设备 */
    kfree(kgrunt.buf); /* 释放所分配的内存 */
    unregister_chrdev_region(kgrunt.dev, 1); /* 注销所注册的设备号 */
}
module_exit(kgrunt_exit); /* 指定 kgrunt_exit 为模块的退出函数 */

# 文件名：Makefile

# 说明：定时器例程 Makefile



# 模块名

MOD_NAME := kgrunt



# 模块源码（不能出现与模块名相同的文件名）

SRCS := \



EXTRA_CFLAGS = -DDEBUG



OBJS := $(SRCS:.c=.o)



ifeq ($(KERNELRELEASE),)



KERNELDIR ?= /lib/modules/$(shell uname -r)/build

PWD := $(shell pwd)



default:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules



clean:

-rm -f $(MOD_NAME).ko

-rm -f $(MOD_NAME).o

-rm -f $(OBJS)

-rm -rf .tmp_versions

-rm -f .*.cmd

-rm -f *.mod.c

-rm -f *.mod.o

-rm -f Module.symvers

-rm -f modules.order



else



$(MOD_NAME)-objs := $(OBJS)

obj-m := $(MOD_NAME).o



endif