ldd（linux设备驱动程序）实验2：scull
按照ldd第三版书上的网址，下载下来的代码是最终版的，没有按章节剥离，不方便读者自己实验。
以下是我手把手敲下的书上第二个实验scull的代码以及安装和测试的步骤。
按上篇搭建linux驱动开发环境（配合LDD阅读）做完实验1后，scull的安装很简单了，在任意位置保存下面两个源文件Makefile，scull.c，执行make，生成目标模块scull.ko，然后insmod scull.ko。
lsmod, 看到第一个就是scull，且会生成这个文件夹/sys/module/scull，可以进去看看里面有什么。cat /proc/devices 可以看到"xxx scull"。因为我的scull驱动（源码贴在下面）是随机生成设备号，所以要进去看。
下面，我们就可以用mknod命令来申请设备文件了。
mkdir /dev/scull
mknod /dev/scull/scull0 c xxx 0
xxx必须是刚才在proc里看到的主设备号，此设备号是0。主、次设备号如果不符的话，这个命令不会执行失败，但是生成的设备在将来使用时会出这个错：scull0：No such device or address
然后ls -li，看下新设备的主次设备号。
到这步之后要注意力，如果你的驱动写得有问题，而编译时没有检测到的话，很可能在执行下面的步骤时使整个linux系统挂起，那只能切断虚拟机电源重新来过了。由于书上的scull代码极简，而官网下载的scull源码相对繁杂，我想用最简的来测试，书上的代码却不全，我只好半用书半用网上的源码，改了非常久。
然后依据书上的“试试新设备”这一节来测试这个设备。可以用的命令有：cp, dd, 重新输入输出, free；还可以在驱动里写printk来跟踪测试。还可以用strace命令来监视系统调用。
解释下，mknod 的标准形式为: mknod DEVNAME {b | c} MAJOR MINOR
1，DEVNAME是要创建的设备文件名，如果想将设备文件放在一个特定的文件夹下，就需要先用mkdir在dev目录下新建一个目录；
2， b和c 分别表示块设备和字符设备：
b表示系统从块设备中读取数据的时候，直接从内存的buffer中读取数据，而不经过磁盘；
c表示字符设备文件与设备传送数据的时候是以字符的形式传送，一次传送一个字符，比如打印机、终端都是以字符的形式传送数据；
3，MAJOR和MINOR分别表示主设备号和次设备号：
为了管理设备，系统为每个设备分配一个编号，一个设备号由主设备号和次设备号组成。主设备号标示某一种类的设备，次设备号用来区分同一类型的设备。 linux操作系统中为设备文件编号分配了32位无符号整数，其中前12位是主设备号，后20位为次设备号，所以在向系统申请设备文件时主设备号不好超过 4095，次设备号不好超过2^20 -1。
模块装好后，书本自带的代码中有个scull/scull_load用以装载，但这也是混装了全书的架构，而我们要的是剥离出来的第三章的实验，如果想试一试，可以在实验完毕后（因为这会造成难以估计的混乱）运行它。
Makefile
ifneq ($(KERNELRELEASE),)
obj-m := scull.o
else
PWD := $(shell pwd)
KVER ?= $(shell uname -r)
KDIR := /lib/modules/$(KVER)/build
all:
$(MAKE) -C $(KDIR) M=$(PWD)
clean:
rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions *.symvers *.order
endif
scull.c
/*
* main.c -- the bare scull char module
*
* Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
* Copyright (C) 2001 O'Reilly & Associates
*
* The source code in this file can be freely used, adapted,
* and redistributed in source or binary form, so long as an
* acknowledgment appears in derived source files. The citation
* should list that the code comes from the book "Linux Device
* Drivers" by Alessandro Rubini and Jonathan Corbet, published
* by O'Reilly & Associates. No warranty is attached;
* we cannot take responsibility for errors or fitness for use.
*
*/
#ifndef __KERNEL__
# define __KERNEL__
#endif
#ifndef MODULE
# define MODULE
#endif
//#include <linux/config.h>
#include <linux/slab.h> /* kmalloc() */
#include <asm/uaccess.h>
#include <linux/module.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 "scull.h" /* local definitions */
int scull_major;
int scull_nr_devs;
int scull_quantum;
int scull_qset;
// struct file_operations *scull_fop_array[]={
// &scull_fops, /* type 0 */
// &scull_priv_fops, /* type 1 */
// &scull_pipe_fops, type 2
// &scull_sngl_fops, /* type 3 */
// &scull_user_fops, /* type 4 */
// &scull_wusr_fops /* type 5 */
// };
// #define SCULL_MAX_TYPE 5
// static void scull_setup_cdev(struct scull_dev *dev, int index){
// int err, devno = MKDEV(scull_major, scull_minor + index);
// cdev_init(&dev->cdev, &scull_fops):
// dev->cdev.owner = THIS_MODULE;
// dev->cdev.ops = &scull_fops;
// err = cdev_add (&dev->cdev, devno, 1);
// if(err)
// printk(KERN_NOTICE "Error %d adding scull%d", err, index);
// }
struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
dev_t dev;
unsigned int count;
};
struct scull_dev{
struct scull_qset *data;
int quantum;
int qset;
unsigned long size;
unsigned int access_key;
struct semaphore sem;
struct cdev cdev;
struct scull_dev* next;
}scull_dev;
/* memory management */
struct scull_qset{
void **data;
struct scull_qset* next;
};
int scull_trim(struct scull_dev* dev){
struct scull_qset *next, *dptr;
int qset = dev->qset;
int i;
for(dptr = dev->data; dptr; dptr = next){
if(dptr->data){
for(i=0; i<qset; i++){
kfree(dptr->data[i]);
}
kfree(dptr->data);
dptr->data = NULL;
}
next = dptr->next;
kfree(dptr);
}
dev->size = 0;
dev->quantum = scull_quantum;
dev->qset = scull_qset;
dev->data = NULL;
return 0;
}
/*
* Open and close
*/
int scull_open(struct inode *inode, struct file *filp){
struct scull_dev *dev; /* device information */
dev = container_of(inode->i_cdev, struct scull_dev, cdev);
filp->private_data = dev; /* for other methods */
/* now trim to 0 the length of the device if open was write-only */
if( (filp->f_flags & O_ACCMODE) == O_WRONLY){
scull_trim(dev); /* ignore errors */
}
return 0; /* success */
}
int scull_release(struct inode *inode, struct file *filp)
{
return 0;
}
/*
* Follow the list
*/
struct scull_dev *scull_follow(struct scull_dev *dev, int n)
{
while (n--) {
if (!dev->next) {
dev->next = kmalloc(sizeof(scull_dev), GFP_KERNEL);
memset(dev->next, 0, sizeof(scull_dev));
}
dev = dev->next;
continue;
}
return dev;
}
/*
* Data management: read and write
*/
ssize_t scull_read(struct file *filp, char *buf, size_t count,
loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data; /* the first listitem */
struct scull_qset *dptr;
int quantum = dev->quantum;
int qset = dev->qset;
int itemsize = quantum * qset; /* how many bytes in the listitem */
int item, s_pos, q_pos, rest;
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;
/* find listitem, qset index, and offset in the quantum */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum; q_pos = rest % quantum;
/* follow the list up to the right position (defined elsewhere) */
dptr = scull_follow(dev, item);
if (!dptr->data)
goto out; /* don't fill holes */
if (!dptr->data[s_pos])
goto out;
/* read only up to the end of this quantum */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (copy_to_user(buf, dptr->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)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum;
int qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t ret = -ENOMEM; /* value used in "goto out" statements */
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
/* find listitem, qset index and offset in the quantum */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum; q_pos = rest % quantum;
/* follow the list up to the right position */
dptr = scull_follow(dev, item);
if (!dptr->data) {
dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
if (!dptr->data)
goto out;
memset(dptr->data, 0, qset * sizeof(char *));
}
if (!dptr->data[s_pos]) {
dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
if (!dptr->data[s_pos])
goto out;
}
/* write only up to the end of this quantum */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {
ret = -EFAULT;
goto out;
}
*f_pos += count;
ret = count;
/* update the size */
if (dev->size < *f_pos)
dev-> size = *f_pos;
out:
up(&dev->sem);
return ret;
}
/*
* The cleanup function is used to handle initialization failures as well.
* Thefore, it must be careful to work correctly even if some of the items
* have not been initialized
*/
static void scull_cleanup_module(void){
// int i;
// #ifndef CONFIG_DEVFS_FS
// /* cleanup_module is never called if registering failed */
// unregister_chrdev(scull_major, "scull");
// #endif
// #ifdef SCULL_DEBUG /* use proc only if debugging */
// scull_remove_proc();
// #endif
// if (scull_devices) {
// for (i=0; i<scull_nr_devs; i++) {
// scull_trim(scull_devices+i);
// /* the following line is only used for devfs */
// devfs_unregister(scull_devices[i].handle);
// }
// kfree(scull_devices);
// }
// /* and call the cleanup functions for friend devices */
// scull_p_cleanup();
// scull_access_cleanup();
// /* once again, only for devfs */
// devfs_unregister(scull_devfs_dir);
}
static int scull_init_module(void){
// int result, i;
// SET_MODULE_OWNER(&scull_fops);
// #ifdef CONFIG_DEVFS_FS
// /* If we have devfs, create /dev/scull to put files in there */
// scull_devfs_dir = devfs_mk_dir(NULL, "scull", NULL);
// if (!scull_devfs_dir) return -EBUSY; /* problem */
// #else /* no devfs, do it the "classic" way */
// /*
// * Register your major, and accept a dynamic number. This is the
// * first thing to do, in order to avoid releasing other module's
// * fops in scull_cleanup_module()
// */
// result = register_chrdev(scull_major, "scull", &scull_fops);
// if (result < 0) {
// printk(KERN_WARNING "scull: can't get major %d\n",scull_major);
// return result;
// }
// if (scull_major == 0) scull_major = result; /* dynamic */
// #endif /* CONFIG_DEVFS_FS */
// /*
// * allocate the devices -- we can't have them static, as the number
// * can be specified at load time
// */
// scull_devices = kmalloc(scull_nr_devs * sizeof(scull_dev), GFP_KERNEL);
// if (!scull_devices) {
// result = -ENOMEM;
// goto fail;
// }
// memset(scull_devices, 0, scull_nr_devs * sizeof(scull_dev));
// for (i=0; i < scull_nr_devs; i++) {
// scull_devices[i].quantum = scull_quantum;
// scull_devices[i].qset = scull_qset;
// sema_init(&scull_devices[i].sem, 1);
// #ifdef CONFIG_DEVFS_FS
// sprintf(devname, "%i", i);
// devfs_register(scull_devfs_dir, devname,
// DEVFS_FL_AUTO_DEVNUM,
// 0, 0, S_IFCHR | S_IRUGO | S_IWUGO,
// &scull_fops,
// scull_devices+i);
// #endif
// }
// /* At this point call the init function for any friend device */
// if ( (result = scull_p_init()) )
// goto fail;
// if ( (result = scull_access_init()) )
// goto fail;
// /* ... */
// #ifndef SCULL_DEBUG
// EXPORT_NO_SYMBOLS; /* otherwise, leave global symbols visible */
// #endif
// #ifdef SCULL_DEBUG /* only when debugging */
// scull_create_proc();
// #endif
struct file_operations scull_fops;
register_chrdev(scull_major, "scull", &scull_fops);
return 0; /* succeed */
// fail:
// scull_cleanup_module();
// return result;
}
module_init(scull_init_module);
module_exit(scull_cleanup_module);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("DYYR");
