scull0字符设备驱动示例(参考《Linux设备驱动程序》)

参考《Linux设备驱动程序》及其代码，写了一个简单的字符设备驱动，相比作者提供的要简单很多，我在ubuntu10.04的系统上已测试，能运行起来。因水平有限，只实现了open,release,write及read四个基本的接口，且使用测试程序运行时存在明显的bug，望志同道合的朋友一起完善。

/*头文件*/
#ifndef __SCULL_H__
#define __SCULL_H__

#ifndef SCULL_MAJOR
#define SCULL_MAJOR 0
#endif

#ifndef SCULL_MINOR
#define SCULL_MINOR 0
#endif

typedef struct _scull_dev_ {
void **data;
int quantum;
int qset;
unsigned long size;
struct semaphore sem;
struct cdev cdev;

} SCULL_DEV,pSCULL_DEV;

#endif

/*驱动程序*/
/*
* name:scull.c
* function:scull character device driver
* time:2012-2-19
*
* author:txgcwm
* mail:txgcwm@163.com
* reference:Linux设备驱动程序(第三版)
*/

#ifndef __KERNEL__
#  define __KERNEL__
#endif
#ifndef MODULE
#  define MODULE
#endif

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/kernel.h>   /* printk() */
#include <linux/fs.h>       /* everything... */
#include <linux/errno.h>    /* error codes */
#include <linux/types.h>    /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h>    /* O_ACCMODE */
#include <asm/system.h>     /* cli(), *_flags */
#include <asm/uaccess.h>

#include "scull.h"          /* local definitions */

int scull_major = SCULL_MAJOR;
int scull_minor	= SCULL_MINOR;
int scull_mn_dev = 1;
int scull_quantum = 4000;	/*每个指针所指向存储单元的大小*/
int scull_qset = 1000;	/*指针数组的大小*/
static pSCULL_DEV *pscull_dev = NULL;

int scull_trim(SCULL_DEV *dev)
{
int i = 0;
int qset = dev->qset;

if (dev->data)
{
for(i = 0; i < qset; i++)
{
if (dev->data[i])
kfree(dev->data[i]);
}

kfree(dev->data);
dev->data=NULL;
}

dev->size = 0;
dev->quantum = scull_quantum;
dev->qset = scull_qset;

return 0;
}

int scull_open(struct inode *inode, struct file *filp)
{
SCULL_DEV *dev = NULL;

dev = container_of(inode->i_cdev,pSCULL_DEV,cdev);
filp->private_data = dev;
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
{
scull_trim(dev);
}

return 0;
}

int scull_release(struct inode *inode, struct file *filp)
{
return 0;
}

ssize_t scull_read(struct file *filp, char *buf, size_t count,loff_t *f_pos)
{
SCULL_DEV *dev = filp->private_data;
int quantum = dev->quantum;
int qset = dev->qset;
int s_pos, q_pos;
ssize_t ret = 0;

if(down_interruptible(&dev->sem))
return -ERESTARTSYS;
if(*f_pos >= dev->size)
goto out;
if(*f_pos + count > dev->size)
count = dev->size - *f_pos;

s_pos = (long)*f_pos / quantum;
q_pos = (long)*f_pos % quantum;

if(s_pos > qset)
goto out;
if(!dev->data)
goto out;
if(!dev->data[s_pos])
goto out;

if(count > quantum - q_pos)
count = quantum - q_pos;

if(copy_to_user(buf, dev->data[s_pos]+q_pos, count)) /*将内核空间的数据拷贝到用户空间*/
{
ret = -EFAULT;
goto out;
}
*f_pos += count;
ret = count;

out:
up(&dev->sem);
return ret;
}

ssize_t scull_write(struct file *filp, const char *buf, size_t count,loff_t *f_pos)
{
SCULL_DEV *dev = filp->private_data;
int quantum = dev->quantum;
int qset = dev->qset;
int s_pos,q_pos;
ssize_t ret = -ENOMEM;

if(down_interruptible(&dev->sem))
return -ERESTARTSYS;

s_pos = (long)*f_pos / quantum;
q_pos = (long)*f_pos % quantum;

if(!dev->data)
{
dev->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
if (!dev->data)
goto out;
memset(dev->data, 0, qset * sizeof(char *));
}

if(!dev->data[s_pos])
{
dev->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
if (!dev->data[s_pos])
goto out;
}

if(count > quantum - q_pos)
count = quantum - q_pos;

if(copy_from_user(dev->data[s_pos]+q_pos, buf, count))	/*将用户空间的数据拷贝到内核空间*/
{
ret = -EFAULT;
goto out;
}
*f_pos += count;
ret = count;

if(dev->size < *f_pos)
dev->size = *f_pos;

out:
up(&dev->sem);
return ret;
}

int scull_ioctl(struct inode *inode, struct file *filp,unsigned int cmd, unsigned long arg)
{
return 0;
}

loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
return 0;
}

struct file_operations scull_fops = {
.owner 	=	THIS_MODULE,
.llseek	=	scull_llseek,
.read	=	scull_read,
.write	=	scull_write,
.ioctl	=	scull_ioctl,
.open	=	scull_open,
.release =	scull_release,
};

static void scull_cleanup_module(void)
{
dev_t dev;

dev = MKDEV(scull_major,scull_minor);
cdev_del(&pscull_dev->cdev);
unregister_chrdev_region(dev,scull_mn_dev);
scull_trim(pscull_dev);
kfree(pscull_dev);
pscull_dev = NULL;
printk(KERN_EMERG"Leave World!\n");

return;
}

static int scull_init_module(void)
{
dev_t dev;
int result = -1;

pscull_dev = kmalloc(sizeof(SCULL_DEV),GFP_KERNEL);
if(pscull_dev == NULL)
{
printk(KERN_WARNING"scull: can't kmalloc memory\n");
result = -ENOMEM;
return result;
}
memset(pscull_dev,0,sizeof(SCULL_DEV));
pscull_dev->data = NULL;
pscull_dev->quantum = scull_quantum;
pscull_dev->qset = scull_qset;
sema_init(&pscull_dev->sem, 1);

if(scull_major)
{
dev = MKDEV(scull_major,scull_minor);
result = register_chrdev_region(dev,scull_mn_dev,"scull");
}
else
{
result = alloc_chrdev_region(&dev,scull_minor,scull_mn_dev,"scull");
scull_major = MAJOR(dev);
}

if(result < 0)
{
printk(KERN_WARNING"scull: can't get major %d\n",scull_major);
return result;
}

cdev_init(&pscull_dev->cdev,&scull_fops);
pscull_dev->cdev.owner = THIS_MODULE;
pscull_dev->cdev.ops = &scull_fops;
result = cdev_add(&pscull_dev->cdev,dev,1);
if(result)
{
printk(KERN_NOTICE"Error %d add scull device\n",result);
goto fail;
}
printk(KERN_EMERG"Hello World!\n");
return 0;

fail:
scull_cleanup_module();

return result;
}

module_init(scull_init_module);
module_exit(scull_cleanup_module);

MODULE_AUTHOR("txgcwm");
MODULE_VERSION("scull_v1.0");
MODULE_LICENSE("GPL");

/*Makefile*/
ifneq ($(KERNELRELEASE),)
obj-m := scull.o
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
all:
make -C $(KERNELDIR) M=$(PWD) modules
clean:
rm -f *.ko *.o *.mod.o *.mod.c *.symvers
endif

/*加载脚本*/
#!/bin/sh
module="scull"
device="scull"
mode="664"

if grep '^staff:' /etc/group > /dev/null; then    #并非所有的发行版本都有staff组，有些有wheel组
group="staff"
else
group="wheel"
fi

/sbin/insmod -f ./$module.ko $* || exit 1    #调用insmod，并将所有传入该脚本的参数传给模块，同时使用路径名来指定模块的位置，因为新的modutils默认不会在当前的目录中查找模块

major=`cat /proc/devices | awk "\\$2==\"$module\" {print \\$1}"`

rm -f /dev/${device}[0-3]    #删除原有节点

mknod /dev/${device}0 c $major 0    #创建新的节点
mknod /dev/${device}1 c $major 1
mknod /dev/${device}2 c $major 2
mknod /dev/${device}3 c $major 3
#ln -sf ${device}0 /dev/${device}

chgrp $group /dev/${device}[0-3]    #给定适当的组属性及许可，并修改属组
chmod $mode  /dev/${device}[0-3]

/*卸载脚本*/
#!/bin/sh
module="scull"
device="scull"

/sbin/rmmod $module $* || exit 1

rm -f /dev/${device} /dev/${device}[0-3]

/*测试程序*/
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc,char **argv)
{
int fd = -1;
int count = 0;
char buf[30];
char *data = "it just for test scull0 ";

fd = open("/dev/scull0",O_RDWR);
if(fd < 0)
{
printf("error %d:can't open device scull0\n",fd);
return -1;
}
else
printf("fd:%d\n",fd);

while(1)
{
memset(buf,'\0',sizeof(buf));
count = write(fd,data,strlen(data));
if(count < 0)
{
printf("error%d,can't write data to device scull0\n",count);
continue;
}

count = read(fd,buf,strlen(data));
if(count < 0)
{
printf("can't read data from device scull0,count:%d\n",count);
}
else
{
printf("num:%d,read data:%s \n",count,buf);
}

sleep(1);
}
}