一个简单字符型设备驱动及其测试

嵌入式Linux 1.5k 字 次

驱动对一些人来说很难，而对一些人来说很容易。窃以为，理解简单设备驱动模型不难，深入理解并与Linux内核设计联系到一起需要花费时间。对于移植者来说，如何将自己自定义的模块天衣无缝放到内核中，是比较重要的——不过，有许多现在的“模板”可供参考，总算不用白手起家。

本文所述的仅是一个独立的、简单的字符型设备驱动。最简单的字符设备当属经典的“Hello World”。而这个比它复杂一点：在用户空间写一字符串到内核空间，再将其写到用户空间。从应用层角度来看，先写一字符串到内核，再读这个字符串。

先说测试程序，代码如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#define device "/dev/bar"

int main(void)
{
        int fd;
        char buf[] = "Late Lee";
        char buf2[30]={0};
        int len;
        fd = open(device, O_RDWR);
        if (fd < 0)
        {
                perror("Open device faile!");
                return -1;
        }
        len = write(fd, buf, sizeof(buf));
        printf("buf: %s %d/n", buf, len);
        len = read(fd, buf2, 25); // 由此指定读取数据，可大可小，但是驱动只读取这个指定的(大者读实际值)，并返回
        printf("buf2: %s %d/n", buf2, len);
        close(fd);
        return 0;
}

代码很简单，使用open打开设备，调用write将buf的东西写到由fd指定的设备(文件)中。之后再使用read读到buf2中，打印字符串，最后关闭设备。就这么简单。
实际运行结果如下：

1
2
3
# ./a.out
buf: Late Lee 9
buf2: The voice from hell: Late 25

其中“The voice from hell:”仅仅表明这个字符来自驱动，无实际意义。
驱动程序也很简单，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/*************************************************************************
        Late Lee from http://www.latelee.org
简单的字符型设备驱动
从应用层获取一数据，再复制到应用层(在前面添加字符串)。
注册设备号及设备号的几个宏，均系ldd3例子scull。

何处释放data更好？看ldd3，似乎exit中更好。
2011-04-29 & 2011-05-06
*************************************************************************/

#include <linux/module.h>
#include <linux/kernel.h>       /**< printk() */
#include <linux/init.h>

#include <linux/cdev.h>                /**< cdev_* */
#include <linux/fs.h>
#include <asm/uaccess.h>        /**< copy_*_user */

#include <linux/types.h>        /**< size_t */
#include <linux/errno.h>        /**< error codes */
#include <linux/string.h>

#ifdef DEBUG /* define it in Makefile or somewhere */
/* KERN_INFO */
#define debug(fmt, ...) printk(KERN_DEBUG fmt, ##__VA_ARGS__)
#else
#define debug(fmt, ...)
#endif

#define DEV_NAME "foo"

//#define HAVE_MAJOR
#ifdef HAVE_MAJOR
#define DEVICE_MAJOR 248
#else        /* auto alloc */
#define DEVICE_MAJOR 0
#endif /* HAVE_MAJOR */

#define FOO_NR_DEVS 1

struct cdev foo_cdev;
int foo_major = DEVICE_MAJOR;
int foo_minor = 0;
int foo_nr_devs = FOO_NR_DEVS;
dev_t devno;
char *data;

static int foo_open(struct inode *inode, struct file *filp)
{
        debug("in %s()/n", __func__);
        return 0;
}

static int foo_release(struct inode *inode, struct file *filp)
{
        debug("in %s()/n", __func__);
        //kfree(data);
        //data = NULL;
        return 0;
}

static ssize_t foo_read(struct file *filp, char *buf, size_t count, loff_t *f_ops)
{
        int len;
        char *tmp;
       
        if (count < 0)
                return -EINVAL;
        tmp = (char *)kmalloc(sizeof(char) * (count+1), GFP_KERNEL); // ?? here
        sprintf(tmp, "The voice from hell: %s", data);
        len = strlen(tmp);
        if (len < count)
                count = len;
        if ( copy_to_user(buf, tmp, count) )
                return -EFAULT;
        debug("in %s() tmp: %s/n", __func__, tmp);
        debug("in %s() buf: %s/n", __func__, buf);
        debug("in %s() data: %s/n", __func__, data);
        kfree(tmp);
        return count;
}

static ssize_t foo_write(struct file *filp, const char *buf, size_t count, loff_t *f_ops)
{
        if (count < 0)
                return -EINVAL;
        data = (char *)kmalloc(sizeof(char) * (count+1), GFP_KERNEL);
        if (data == NULL)
                return -ENOMEM;
        if (copy_from_user(data, buf, count+1))
                return -EFAULT;
        debug("in %s() buff: %s/n", __func__, buf);
        debug("in %s() data: %s/n", __func__, data);
        return count;
}

static int foo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
        switch (cmd)
        {
       
        default:
                return -EINVAL;
        }
        return 0;
}

static struct file_operations foo_fops = {
        .owner   = THIS_MODULE,
        .open    = foo_open,
        .release = foo_release,
        .read    = foo_read,
        .write   = foo_write,
        .ioctl   = foo_ioctl,
};

static int __init foo_init(void)
{
        int ret = -1;

        cdev_init(&foo_cdev, &foo_fops);
        foo_cdev.owner = THIS_MODULE;
        /* register to who? */
        if (foo_major)
        {
                devno = MKDEV(foo_major, foo_minor);
                ret = register_chrdev_region(devno, foo_nr_devs, DEV_NAME);
        }
        else
        {
                ret = alloc_chrdev_region(&devno, foo_minor, foo_nr_devs, DEV_NAME); /* get devno */
                foo_major = MAJOR(devno); /* get major */
               
        }
        if (ret < 0)
        {
                debug(" %s can't get major %d/n", DEV_NAME, foo_major);
                return -EINVAL;
        }
       
        ret = cdev_add(&foo_cdev, devno, 1);
        if (ret < 0)
        {
                debug(" %s cdev_add failure!/n", DEV_NAME);
                return -EINVAL;
        }
       
        debug("%s init ok!/n", DEV_NAME);
        return 0;
}

static void __exit foo_exit(void)
{
        if (data != NULL)
                kfree(data);
        unregister_chrdev_region(devno, 1);
        cdev_del(&foo_cdev);
        debug("%s exit ok!/n", DEV_NAME);
}

module_init(foo_init);
module_exit(foo_exit);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Chiangchin Li");

其中最后两个函数foo_init和foo_exit分别在加载驱动和卸载驱动时执行。如果驱动程序直接编入内核，可以在启动信息中看到，如果是单独加载，在执行insmod时执行，当然，在何处显示与printk打印级别有关系。
我们的驱动中使用KERN_DEBUG，因此可以使用dmesg查看——注意，由于insmod、rmmod等等需要使用root权限，文中统一使用root，shell提示符为“#”。 

1
2
3
4
# insmod GotoHell.ko
# dmesg | tail
……
foo init ok!

当执行应用层的测试程序时，dmesg的显示如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
# ./a.out
buf: Late Lee 9
buf2: The voice from hell: Late 25
# dmesg | tail
……
foo init ok!
in foo_open()
in foo_write() buff: Late Lee
in foo_write() data: Late Lee
in foo_read() tmp: The voice from hell: Late Lee
in foo_read() buf: The voice from hell: Late
in foo_read() data: Late Lee
in foo_release()

可以看到，当执行close时，驱动中执行foo_release。当卸载模块时，dmesg显示如下：

1
2
3
4
5
6
7
8
9
10
11
12
# rmmod GotoHell.ko
# dmesg | tail     
……
foo init ok!
in foo_open()
in foo_write() buff: Late Lee
in foo_write() data: Late Lee
in foo_read() tmp: The voice from hell: Late Lee
in foo_read() buf: The voice from hell: Late
in foo_read() data: Late Lee
in foo_release()
foo exit ok!

对照测试程序及驱动显示的调试信息，可以看到应用层调用的如open、write、read、close等等系统调用，在驱动中均在对应的函数，它正是通过如下结构体来实现的：

1
2
3
4
5
6
7
8
static struct file_operations foo_fops = {
 .owner   = THIS_MODULE,
 .open    = foo_open,
 .release = foo_release,
 .read    = foo_read,
 .write   = foo_write,
 .ioctl   = foo_ioctl,
};

由于程序比较简单，不作注释和解释，一切尽在代码中。本文中的“模块”、“驱动”在某种意义上是同义词。
本文完整的“工程”代码可以在下面地址下载，为确保下载的东西的确是本文所提及的代码，最好确认一下它的md5和：deb16fcfbdc5e7f136ae988a0a26aad3
工程：简单字符型设备驱动例子-来自latelee.org