使用内核定时器的second字符设备驱动

second.c:

#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/fs.h>  //file_operations
#include<linux/types.h> //dev_t
#include<linux/cdev.h>
#include<linux/slab.h> //kcalloc
#include<linux/uaccess.h> //copy_to_user,copy_from_user
#include<linux/interrupt.h>//中断
#include<linux/timer.h>

#define SECOND_MAJOR 112

static int second_major = SECOND_MAJOR;

//second设备结构体
struct second_dev{
    struct cdev cdev;
    atomic_t counter; //一共经历了多少秒
    struct timer_list s_timer;  //设备要使用的定时器
};

struct second_dev *second_devp;

//定时器处理函数
static void second_timer_handle(unsigned long arg){
    mod_timer(&second_devp->s_timer,jiffies + HZ);  //修改定时器的到期时间
    atomic_inc(&second_devp->counter);  //经历时间+1秒
    printk(KERN_NOTICE "current jiffies is %ld\n",jiffies);
}

//文件打开函数
int second_open(struct inode *inode,struct file *filp){
    //初始化定时器
    init_timer(&second_devp->s_timer);
    second_devp->s_timer.function = &second_timer_handle; //关联
    second_devp->s_timer.expires = jiffies + HZ;

    //添加（注册）定时器
    add_timer(&second_devp->s_timer);
    //计数清零
    atomic_set(&second_devp->counter,0);

    return 0;
}

//文件释放函数
int second_release(struct inode *inode,struct file *filp){
    del_timer(&second_devp->s_timer);
    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); //atomic原子
    //相对于copy_to_user和copy_from_user，这两个函数主要用于完成一些简单类型变量(char、int、long等)的拷贝任务
    //对于一些复合类型的变量，比如数据结构或者数组类型，get_user和put_user函数还是无法胜任
    if(put_user(counter,(int *)buf))
        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,
};

//初始化并注册cdev
static void second_setup_cdev(struct second_dev *dev,int index){
    int err,devno = MKDEV(second_major,index);

    cdev_init(&dev->cdev,&second_fops); //cdev初始化并关联fops
    dev->cdev.owner = THIS_MODULE;
    dev->cdev.ops = &second_fops;
    err = cdev_add(&dev->cdev,devno,1);  //添加设备
    if(err)
        printk(KERN_NOTICE "error %d adding %d",err,index);
}

//设备驱动模块加载函数
static __init int second_init(void){ //必须有void !!!!!
    int ret;
    dev_t devno = MKDEV(second_major,0); //此设备号0

    //申请设备号
    if(second_major)
        ret = register_chrdev_region(devno,1,"second");
    else {  //动态申请
        ret = alloc_chrdev_region(&devno,0,1,"second");
        second_major = MAJOR(devno);
    }
    if(ret < 0)
        return ret;
    //动态申请设备结构体内存
    second_devp = kmalloc(sizeof(struct second_dev),GFP_KERNEL);
    if(!second_devp){ //失败
        ret = - ENOMEM;
        goto fail_malloc;
    }

    memset(second_devp,0,sizeof(struct second_dev));
    second_setup_cdev(second_devp,0);

    return 0;
    fail_malloc:unregister_chrdev_region(devno,1);
    return ret;
}

//模块卸载函数
void second_exit(void){  //必须要有void !!!!!!!!!
    cdev_del(&second_devp->cdev);  //删除设备
    kfree(second_devp);
    unregister_chrdev_region(MKDEV(second_major,0),1);
}

MODULE_AUTHOR("ZHYANG");
MODULE_LICENSE("Dual BSD/GPL");

module_param(second_major,int,S_IRUGO);

module_init(second_init);
module_exit(second_exit);

test_second.c:

#include<stdio.h>
#include<fcntl.h>

int main(){
    int fd;
    int counter=0;
    int old_counter = 0;

    //打开/dev/second设备文件
    fd = open("/dev/second",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);
}

以上代码在3内核版本中测试通过