第10章 中断与时钟之内核定时器（秒字符设备驱动）

10.5.3　实例：秒字符设备

编写一个字符设备“second”（即“秒”）的驱动，它在被打开的时候初始化一个定时器并将其添加到内核定时器链表中，每秒输出一次当前的jiffies（为此，定时器处理函数中每次都要修改新的到期时间expires）。

1、驱动头文件

#ifndef __SECOND_H
#define __SECOND_H

#define DRIVER_AUTHOR "xz@vi-chip.com.cn"
#define DRIVER_DESC   "A sample driver" 

#define DEV_NAME "second"

typedef struct second_dev {
    struct cdev cdev;
    atomic_t counter; // 用于秒计数
    struct timer_list s_timer;
}second_dev;

#endif /* __SECOND_H */

2、驱动源代码文件

#include <linux/init.h> 
#include <linux/module.h> 
#include<linux/kernel.h> 
#include <linux/cdev.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>


#include "second.h"


#define SECOND_MAJOR 230 /* 主设备号 */

static int second_major = SECOND_MAJOR;
module_param(second_major, int, S_IRUGO); /* mode:S_IRUGO */


static second_dev *second_devp = NULL;


/**
*
* 超时时间到所执行的定时器处理函数
*
*/
static void second_timer_handler(unsigned long arg)
{
mod_timer(&second_devp->s_timer, jiffies + HZ);  /* 触发下一次定时 */
atomic_inc(&second_devp->counter);               /* 增加秒计数，增加1 */
 
printk(KERN_INFO "%s current jiffies is %ld\n", __func__, jiffies);
}


/**
*
* 打开设备文件的操作函数
*
*/
static int second_open(struct inode *inode, struct file *filp)
{
// 启动定时器，此后每1s会再次运行定时器处理函数
init_timer(&second_devp->s_timer);
second_devp->s_timer.function = &second_timer_handler; 
second_devp->s_timer.expires = jiffies + HZ; /* 超时时间 */
add_timer(&second_devp->s_timer); // 将定时器实例动态添加到内核链表中
atomic_set(&second_devp->counter, 0); /* 初始化秒计数为0 */
 
printk(KERN_INFO "%s.\n", __func__);
return 0;
}


/**
*
* 关闭设备文件的操作函数
*
*/
static int second_release(struct inode *inode, struct file *filp)
{
del_timer(&second_devp->s_timer); // 删除定时器

printk(KERN_INFO "%s.\n", __func__);

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);
printk(KERN_INFO "%s counter is [%d].\n", __func__, counter);
if (put_user(counter, (int *)buf))/* 复制counter到用户空间 */
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 minor)
{
int err, devno = MKDEV(second_major, minor);
 
cdev_init(&dev->cdev, &second_fops);
dev->cdev.owner = THIS_MODULE;
err = cdev_add(&dev->cdev, devno, 1);
if (err)
printk(KERN_ERR "Failed to add second device\n");
}

static int __init second_init(void)
{
int ret;

dev_t devno = MKDEV(second_major, 0);
if (second_major)
ret = register_chrdev_region(devno, 1, DEV_NAME); 
else {
ret = alloc_chrdev_region(&devno, 0, 1, DEV_NAME); 
second_major = MAJOR(devno);
}

if (ret < 0) 
return ret;

second_devp = kzalloc(sizeof(struct second_dev), GFP_KERNEL);
if (!second_devp) {
ret = -ENOMEM;
goto fail_kernel_malloc;
}

second_setup_cdev(second_devp, 0);

    printk(KERN_INFO "----second_init!----\n");


    return 0; 

fail_kernel_malloc:
unregister_chrdev_region(devno, 1); 
return ret;
}

static void __exit second_exit(void)
{
cdev_del(&second_devp->cdev); 
kfree(second_devp); 
unregister_chrdev_region(MKDEV(second_major, 0), 1); 
    printk(KERN_INFO "----second_exit!----\n");
}

module_init(second_init);
module_exit(second_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR(DRIVER_AUTHOR);

MODULE_DESCRIPTION(DRIVER_DESC);

3、Makefile

ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
all:                               
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:                                             
$(MAKE) -C $(KERNELDIR) M=$(PWD) clean
else
    obj-m := second.o

endif

4、驱动测试文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

#define DEV_NAME "/dev/second"

void main(void)
{
int fd;
int counter = 0;
int old_counter = 0;
 
fd = open(DEV_NAME, O_RDONLY); /* 打开设备文件 */
if (fd != - 1) {
while (1) {
read(fd, &counter, sizeof(unsigned int));/* 读目前经历的秒数 */
if(counter != old_counter) {
printf("seconds after open /dev/second :%d\n",counter);
old_counter = counter;
}
}
} else {
printf("Device open failure\n");
}

close(fd);

}

5、验证结果

1）sudo insmod second.ko

      sudo mknod -m 0666 /dev/second c 230 0

2)   gcc test.c -o test

3) 输出信息

内核打印信息如下（内核将不断地输出目前的jiffies值）：

<6>[29727.672260] second_timer_handler current jiffies is 4302324727
<6>[29728.672179] second_timer_handler current jiffies is 4302324977
<6>[29729.672098] second_timer_handler current jiffies is 4302325227
<6>[29730.672019] second_timer_handler current jiffies is 4302325477
<6>[29731.671938] second_timer_handler current jiffies is 4302325727
<6>[29732.671858] second_timer_handler current jiffies is 4302325977
<6>[29733.671778] second_timer_handler current jiffies is 4302326227

<6>[29734.671697] second_timer_handler current jiffies is 4302326477

从内核的打印消息可以看出，Ubuntu上的每秒jiffies大概走250次。应用程序将不断输出自/dec/second打开以后经历的秒数：
# ./test
seconds after open /dev/second :1
seconds after open /dev/second :2
seconds after open /dev/second :3
seconds after open /dev/second :4
seconds after open /dev/second :5