Linux 驱动程序初窥
今天天气不错，微风习习，清爽宜人。这么好的天气不能辜负，不如我们来写个linux驱动程序吧。。。- -|||
====================================================================================================
首先亮一下装备：
参考资料：LDD
平台：Ubuntu 8.10 ，linux内核 2.6.27
编译器：gcc
友情出演：python、emacs
目的：编写一个什么都不干的字符设备驱动，了解linux驱动工作原理
====================================================================================================
基础知识：
不同于windows驱动程序，Linux设备驱动程序在与硬件设备之间建立了标准的抽象接口。通过这个接口，用户可以像处理普通文件一样，通过open，close，read，write等系统调用对设备进行操作，如此一来也大大简化了linux驱动程序的开发，后面会看到，通过file_operations这个结构体（实际上是一个函数指针的集合），把驱动的操作和设备号联系起来，程序员所要做的工作只是通过file_operations挂接自己的系统调用函数。
linux中的设备可大致分为字符设备、块设备、网络设备等。本文关注的是字符设备驱动的编写。
（右图为linux驱动工作的基本示意图）
====================================================================================================
动手编写：
linux内核源码中驱动程序占了相当大的比重，这些驱动程序可以被编译进内核，也可以编译为模块以供动态加载，为了便于调试以及一些列不可告人的目的，猪的第一个驱动程序将以模块的形式出现（废话，难道为了一个什么都不做的驱动重新编译内核？）
首先列出这个驱动的源码：
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] #include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h> /* printk() */ #include <linux/fs.h> #include <linux/errno.h> /* error codes */ #include <linux/types.h> /* size_t */ #include <linux/cdev.h> #include <asm/uaccess.h> /* copy_to_user() */ /* function prototypes */ static int hello_open( struct inode *inode, struct file *filp );
static int hello_release( struct inode *inode, struct file *filp );
ssize_t hello_read( struct file *flip, char __user *buf, size_t count,loff_t
*f_pos);
ssize_t hello_write( struct file *filp, const char __user *buf, size_t count,
loff_t *f_pos );
static int hello_major = 0; /* major device number */ MODULE_AUTHOR( "xiaobenzhu" );
MODULE_LICENSE( "Dual BSD/GPL" );
static struct cdev helloDev; /* hello device structure */ /* file operations for hello device */ static struct file_operations hello_ops = {
.owner = THIS_MODULE,
.open = hello_open,
.read = hello_read,
.write = hello_write,
.release = hello_release,
};
/* Open the device */ static int hello_open( struct inode *inode, struct file *filp ){
printk( KERN_NOTICE"Hello device open!\n" );
return 0;
}
/* Close hello_device */ static int hello_release( struct inode *inode, struct file *filp ){
printk( KERN_NOTICE"Hello device close!\n" );
return 0;
}
/* set up the cdev stucture for a device */ static void hello_setup_cdev( struct cdev *dev, int minor, struct file_operations *fops ){ int err;
int devno = MKDEV( hello_major, minor );
/* initialize the cdev struct */ cdev_init( dev,fops ); dev->owner = THIS_MODULE; dev->ops = fops; /* why not do it in cdev_init ? */ err = cdev_add( dev, devno, 1 ); /* register the cdev in the kernel */ if( err )
printk( KERN_NOTICE"Error %d adding hello%d\n",err ,minor );
}
/* Module housekeeping */ static int hello_init(void){
int result;
dev_t dev = MKDEV( hello_major, 0 );
/* alloc the major device number dynamicly */ result = alloc_chrdev_region(&dev, 0 ,1, "hello" );
if( result < 0 ){
printk( KERN_NOTICE"Hello: unable to get major %d\n",hello_major );
return result;
}
hello_major = MAJOR(dev);
/* set up devices, in this case, there is only one device */ printk( KERN_NOTICE"hello init: %d, %d\n",hello_major,0 );
//printk( KERN_ALERT"hello init: %d, %d\n",hello_major,0 ); hello_setup_cdev(&helloDev, 0 , &hello_ops ); return 0;
}
/* Exit routine */ static void hello_exit(void){
/* remove the cdev from kernel */ cdev_del(&helloDev ); /* release the device numble alloced earlier */ unregister_chrdev_region( MKDEV( hello_major, 0 ), 1 ); printk( KERN_NOTICE"hello exit. major:%d,minor %d\n",hello_major,0 );
}
/* user read from hello device*/ ssize_t hello_read( struct file *flip, char __user *buf, size_t count,loff_t
*f_pos){
ssize_t retval = 0;
char *bank;
bank = kmalloc(count+1, GFP_KERNEL );
if( bank == NULL )
return -1;
memset( bank, 'A',count );
if( copy_to_user( buf, bank, count ) ){
retval = -EFAULT;
goto out;
}
retval += count;
*(bank+count)=0;
printk( KERN_NOTICE"hello: user read %d bytes from me. %s\n",count,bank );
out:
kfree(bank);
return retval;
}
/* write to hello device */ ssize_t hello_write( struct file *filp, const char __user *buf, size_t count,
loff_t *f_pos ){
ssize_t retval = 0;
char *bank = kmalloc( count ,GFP_KERNEL );
if( bank == NULL )
return retval;
if( copy_from_user(bank, buf, count ) ){
retval = -EFAULT;
printk( KERN_NOTICE"hello: write error\n" );
goto out;
}
retval += count;
printk( KERN_NOTICE"hello: user has written %d bytes to me: %s\n",count,
bank );
out:
kfree(bank );
return retval;
}
/* register the init and exit routine of the module */ module_init( hello_init ); module_exit( hello_exit );
注意事项：
1. MODULE_LICENSE( "Dual BSD/GPL" ); 指定模块使用的许可证
能被内核识别的许可证有GPL、GPL v2、 Dual BSD/GPL、 Dual MPL/GPL、Proprietary（专有）等，如果模块没有显式标记许可证，则会被认定为“专有”，内核加载这样的模块会被“污染”。
2.最后两句module_init( hello_init ); module_exit( hello_exit );指定了模块初始化和关闭函数
3.因为驱动工作在内核空间，不能使用用户空间的libc函数，所以程序中打印语句为内核提供的printk，而非printf，KERN_NOTICE宏其实标记的是日志级别（共有八个）不同级别的消息会记录到不同的地方。如果你运行本模块，可能会发现printk语句并没有输出到控制台，这是正常的，控制台只显示一定级别的消息。当日志级别小于console_loglevel时，消息才能显示出来。你可以通过dmsg命令看到这些信息，也可以通过修改日志级别使之输出到你的虚拟终端。方法详见：http://blog.sina.com.cn/s/blog_4a4832fe0100cvrk.html###
猪还有一个更方便的方法，就是另开一个终端，输入命令
# cat /proc/kmsg
然后这个终端就会变成你的内核日志记录器。
===============================================================================================================================
驱动详解：
1.模块被加载伊始，进入hello_init 函数，在这个函数中，动态的为我们的驱动申请了主设备号。设备号是干什么吃的？据LDD记载，对字符设备的访问是通过文件系统内的设备名称进行的。那些被称为特殊文件、设备文件的节点，通常位于/dev目录，如果ls -l 查看该目录，第一列中带有c标志的即为字符设备，有b标志的为块设备。而第5、6列所示的两个数字分别为设备的主、次设备号。通常，主设备号标识设备所用的驱动程序（现在大多设备仍然采用“一个主设备号对应一个驱动程序”的规则），次设备号用于确定设备，比如你有两块网卡，使用同一驱动，主设备号相同，那么他们将由次设备号区分。
这里主设备号的分配由alloc_chrdev_region（第一个参数为dev_t 指针，用来存放设备编号，第二个参数为要使用的第一个次设备号，通常为0，第三个参数为请求的连续设备编号个数）动态分配，当然也可以静态指定一个未被使用的主设备号，相应函数为register_chrdev_region,但不推荐这样做。在模块被卸载时（hello_exit）,通过unregister_chrdev_region释放设备号。MKDEV宏将给出的主、次设备号转换成dev_t类型，MAJOR，MINOR分别从dev_t中析取主次设备号。
这里几个函数的原型为：
int register_chrdev_region(dev_t first, unsigned int count, char *name);
int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, char *name);
void unregister_chrdev_region(dev_t first, unsigned int count);
2.然后进入hello_setup_cdev函数，对设备进行初始化
这里cdev结构体是内核内部使用来表示字符设备的。在内核调用设备操作之前，必须分配并注册一个或多个这样的结构。猪为了方便，没有动态使用cdev_alloc函数分配空间，而是定义了一个全局静态cdev变量。通常你可以将你的cdev嵌入到自定义的结构体中（猪这个驱动很naive，没有这么做），通过cdev_init 函数初始化。这里注意第二个参数，这就是传说中的file_operations, 用来挂载你的设备操作，他是一个函数指针集合，结构大致为
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
...
};
猪实现了其中的open,read,write,close,因此在初始化ops变量时
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] static struct file_operations hello_ops = {
.owner = THIS_MODULE,
.open = hello_open,
.read = hello_read,
.write = hello_write,
.release = hello_release,
};
.owner为所有者字段，防止在使用时模块被卸载。一边都设为THIS_MODULE
在cdev_init 之后，还需要对cdev中的类似的owner字段进行初始化。之后调用cdev_add函数在内核注册设备。（第二个参数为该设备对应的第一个设备编号，第三个参数是关联设备编号数量），注册之后设备的操作就可以被内核调用了。在模块卸载时，调用cdev_del注销设备。
相关函数原型：
void cdev_init(struct cdev *dev, struct file_operations *fops);
int cdev_add(struct cdev *dev, dev_t num, unsigned int count);
void cdev_del(struct cdev *dev);
3.接下来就是实现open,close,read,write操作了，这个驱动什么都没干，所以很好理解，用户请求read系统调用时，这个虚拟设备反回相应长度的“A”字符串，用户write时，将内容显示到日志中。
这里要注意的是，内核空间中不能使用用户态的malloc，而是使用kmalloc/kfree。而且，用户read/write提供的buf地址也是用户态的，内核自然不能直接访问，需要通过copy_to_user/copy_from_user 进行数据拷贝。
4.你可能会注意到open和release函数头中的file和inode结构体，inode是内核内部文件的表示，当其指向一个字符设备时，其中的i_cdev成员既包含了指向cdev结构的指针。而file表示打开的文件描述符，对一个文件，若打开多次，则会有多个file结构，但只有一个inode与之对应。
===============================================================================================================================
编译模块：
这就是这个驱动的全部内容了，下面猪来编译它。
makefile这样来写：
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] #DEBUG = y
# Add your debugging flag (or not) to EXTRA_CFLAGS
ifeq ($(DEBUG),y)
DEBFLAGS = -O -g # "-O" is needed to expand inlines
else DEBFLAGS = -O2 endif EXTRA_CFLAGS += $(DEBFLAGS)
# 如果已经定义KERNELRELEASE，则说明是从内核构造系统调用的
# 因此可以利用其内建语句
ifneq ($(KERNELRELEASE),)
# call from kernel build system obj-m := hello.o
# 否则，是直接从命令行调用的
# 这时要调用内核构造系统
else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
depend .depend dep:
$(CC) $(EXTRA_CFLAGS) -M *.c > .depend
TEST_SOURCES = test_hello.c
.PHONY: test
test:$(TEST_SOURCES)
$(CC) $< -o $@
ifeq (.depend,$(wildcard .depend))
include .depend
endif
2.6内核的模块构造方法与2.4不同，新构造系统使用更加简单，了解细节请阅读内核源码Documentation/kbuild目录下的文件，猪没有研究过
这里真正有用的只有一句，obj-m := hello.o ，若你的模块有多个.o文件组成，应该写成
obj-m := hello.o
hello-objs := file1.o file2.o
上面的makefile之所以看上去比较麻烦，是因为他应对在内核树之外构造模块，当makefilel从命令行调用时，KERNELRELEASE尚未设置，那么设定KERNELDIR 为 当前模块目录中的build，这其实是一个符号链接，指向对应的内核构造树，这样一来就可以定位内核源码目录，然后调用default:目标，这使得make命令第二次被调用，这时，会检测KERNELRELEASE已然设置，那么设置obj-m, 然后内核的makefile真正负责构造模块。 具体过程请阅读LDD第二章内容
还有，在新版本内核中，过去的CFLAGS标志要改为EXTRA_CFLAGS
===============================================================================================================================
模块加载&设备文件节点构造：
1. 编译成功后，会得到hello.ko, 这时你就可以通过insmod命令加载模块
# insmod hello.ko
这时你的日志控制台中会出现hello_init中的打印信息，如果你使用lsmod列出当前已加载模块，会发现hello模块赫然在目
2.要想使用驱动，你需要在/dev 目录下建立设备文件节点，语法是
mknod [options] name {bc} major minor
这里需要知道设备的主、次设备号，何以知之？使用cat /proc/devices | grep hello 你就会得到其主设备号
比如猪得知hello的主设备号为250
那么就用下面的命令：
# mknod /dev/hello0 c 250 0
c表示字符设备，这样就可以通过该设备文件操作设备了。
这里mknod所创建的文件必定是属于root用户的，为了能让广大人民都能使用，使用chgrp和chmod命令更改其所属组和权限位
# chmod 664 /dev/hello0
# chgrp benzhu /dev/hello0
上述一系列动作可以写一个shell脚本来简化工作
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] #!/bin/sh
module="hello"
device="hello"
mode="664"
# Group: since distributions do it differently, look for wheel or use staff
if grep '^staff:' /etc/group > /dev/null; then
group="staff"
else group="benzhu"
fi
# invoke insmod with all arguments we got
# and use a pathname, as newer modutils don't look in . by default
/sbin/insmod -f ./$module.ko $* || exit 1
major=$(awk "\$2==\"$module\" {print \$1}" /proc/devices)
# Remove stale nodes and replace them, then give gid and perms
# Usually the script is shorter, it's simple that has several devices in it.
echo $major
rm -f /dev/${device}0
mknod /dev/${device}0 c $major 0
chgrp $group /dev/${device}0
chmod $mode /dev/${device}0
其中查找主设备号通过awk完成
===============================================================================================================================
测试驱动：
现在就可以通过系统调用操作设备了。猪写了C和Python的两个测试。
1.C测试
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] /* test_hello.c */ #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define READ_SIZE 10 int main(int argc, char **argv){ int fd,count; char buf[READ_SIZE+1]; if( argc<2 ){ printf( "[Usage: test device_name ]\n" );
exit(0);
}
if(( fd = open(argv[1],O_RDWR ))<0){
printf( "Error:can not open the device: %s\n",argv[1] );
exit(1);
}
printf("%s has been opened: (fd:%d).\n",argv[1],fd );
if( (count = read(fd,buf,READ_SIZE ))<0 ){
perror("read error.\n");
exit(1);
}
printf( "read %d bytes from %s:%s\n",count,argv[1],buf );
memcpy( buf,"Hello",6 );
if( (count = write( fd, buf ,6 ))<0 ){
perror("write error.\n");
exit(1);
}
printf( "write %d bytes to %s:%s\n",count,argv[1],buf );
close(fd);
printf("close device %s\n",argv[1] );
return 0;
}
2.Python 测试
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] #!/usr/bin/python
import sys,getopt
def usage():
print "[Usage: python_test dev_name]"
def getopts():
try:
opts,args = getopt.getopt(sys.argv[1:],"ho:",["help","output="])
except getopt.GetoptError:
print "Bad options."
usage()
sys.exit()
for o,a in opts:
if o in ("-h","--help"):
usage()
sys.exit()
if o in ("-o","--output"):
output = a
def test_read(filename):
#open the given file
try:
file = open(filename,"r")
except IOError,message:
print >> sys.stderr, "File could not be opened",message
sys.exit(1)
print "file opened."
msg = file.read(10);
print "get message from:",filename,":",msg
file.close()
print "file closed."
def test_write(filename):
#open the given file
try:
file = open(filename,"w")
except IOError,message:
print >> sys.stderr, "File could not be opened",message
sys.exit(1)
print "file opened."
msg = "Hello!I am tomsheep!\0"
file.write(msg)
print "wrote to device:",filename , ":",msg
file.close()
print "file closed."
def main():
if len(sys.argv) < 2:
usage()
sys.exit()
#deal with the options
getopts()
filename = sys.argv[1]
#test I/O
test_read(filename)
test_write(filename)
#main routine
main()
通过控制台和系统日志中的信息，就可以知道驱动是不是工作正常了
===============================================================================================================================
卸载模块&移除设备
通过rmmod卸载模块， rm移除设备文件节点
同样可以写一个一劳永逸的脚本
Example Source Code [http://www.cnblogs.com/xiaobenzhu/] #!/bin/sh
module="hello"
device="hello"
# invoke rmmod with all arguments we got
/sbin/rmmod $module $* || exit 1
# Remove stale nodes
rm -f /dev/${device}0
===============================================================================================================================
这就是这个无聊驱动的全部内容，打完收工
这么好的天气。。。不如睡觉吧。。。
