ldd（linux设备驱动程序）scull驱动

1. 下载源代码：http://download.csdn.net/detail/wjf201003050643/9494265

2. 参考书中第三章：linux设备驱动程序

3. 下面将附上驱动源代码。（该驱动使用内存模拟出4个硬盘，可以实现对其读写操作）

4. 调试过程出现的问题：

      执行命令#  ls –l > /dev/scull0   ：该命令将输出重定向到设备节点scull0

   #  cat /dev/scull0        ：该命令最终调用驱动程序的操作函数scull_read 对scull0硬盘中的数据进行读取

大家看90行代码，书中的代码并没有将Kmalloc得到的内存地址保存到dev->data中，因此当执行ls –l > /dev/scull0时，虽然数据写入成功，但是当cat /dev/scull0 读取数据的时候，scull_read函数找不到之前分配的dev->data 地址，这将导致内核发生段错误。

加上第90行代码，编译加载内核，运行正确，可以正确的写入和读取。

附程序：

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define SCULL_QUANTUM 4000    //16*1024

#define SCULL_QSET      1000    //4*1024

int scull_major = 0; //动态分配主设备号

int scull_minor = 0;

typedef struct scull_qset Scull_Qset;

struct scull_qset {

void **data;

Scull_Qset *next;

};

struct scull_dev {

struct scull_qset *data;

struct cdev cdev;     

int quantum;     

int qset;                 

unsigned long size;  

struct semaphore sem;

};

struct scull_dev* scull_devs;

static int scull_trim(struct scull_dev *dev)

{

int i;

struct scull_qset *next, *dptr;

int qset = dev->qset;

for(dptr = dev->data; dptr; dptr=next) //

{

if(dptr->data) {

for(i=0; 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;

}

//long sign;

Scull_Qset *scull_flow(struct scull_dev *dev, int count)

{

Scull_Qset *qset = dev->data; 

if(!qset) 

{

qset = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);

if(qset == NULL)

return NULL;

memset(qset, 0, sizeof(struct scull_qset));

dev->data = qset;

}

while(count--) 

{

if(!qset->next) 

{

qset->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);

if(qset->next == NULL)

return NULL;

memset(qset->next, 0, sizeof(struct scull_qset));

}

qset = qset->next;

continue;

}

// sign = qset;

printk("the addr %x\n", qset);

return qset;

}

int scull_open(struct inode *inode, struct file *filp)

{

struct scull_dev *dev;

dev = container_of(inode->i_cdev, struct scull_dev, cdev);

filp->private_data = dev;

 

if((filp->f_flags & O_ACCMODE) == O_WRONLY)

{

if (down_interruptible(&dev->sem))

return -ERESTARTSYS;

scull_trim(dev);

up(&dev->sem);

}

return 0;

}

int scull_release(struct inode *inode, struct file *filp)

{

return 0;

}

ssize_t scull_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)

{

struct scull_dev *dev = filp->private_data;

struct scull_qset *dptr;

int quantum = dev->quantum, qset = dev->qset;

int itemsize = quantum*qset;

int item, s_pos, q_pos, rest;

ssize_t retval = 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;

item = (long)*f_pos / itemsize;

rest = (long)*f_pos % itemsize;

s_pos = rest / quantum; q_pos = rest % quantum;

dptr = scull_flow(dev, item);

      printk("the addr %x\n", dptr);

// dptr = sign;

if(dptr == NULL || !dptr->data || !dptr->data[s_pos])

goto out;

if(count > quantum - q_pos)

count = quantum - q_pos;

if(copy_to_user(buf, dptr->data[s_pos]+q_pos, count)) {

retval = -EFAULT;

goto out;

}

*f_pos += count;

retval = count;

out:

up(&dev->sem);

return retval;

}

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)

{

struct scull_dev *dev = filp->private_data;

struct scull_qset *dptr;

int quantum = dev->quantum, qset = dev->qset;

int itemsize = quantum*qset;

int item, s_pos, q_pos, rest;

ssize_t retval = -ENOMEM;

if(down_interruptible(&dev->sem))

return -ERESTARTSYS;

item = (long)*f_pos / itemsize;

rest = (long)*f_pos % itemsize;

s_pos = rest / quantum; q_pos = rest % quantum;

dptr = scull_flow(dev, item);

if(dptr == NULL)

goto out;

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;

memset(dptr->data[s_pos], 0, quantum);

}

if(count > quantum - q_pos)

count = quantum - q_pos;

if(copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {

retval = -EFAULT;

goto out;

}

*f_pos += count;

retval = count;

if(dev->size < *f_pos)

dev->size = *f_pos;

out:

up(&dev->sem);

return retval;

}

struct file_operations scull_fops = {

.owner    = THIS_MODULE,

.open      = scull_open,

.release = scull_release,

.read      = scull_read,

.write    = scull_write,

};

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);

}

static      struct       class *scull_class;

static      struct    device   *scull_class_dev[4];

int scull_init_module(void)

{

int result, i;

dev_t dev = 0; //保存设备编号

result = alloc_chrdev_region(&dev, scull_minor, 4, "scull");

scull_major = MAJOR(dev);

scull_devs = kmalloc(4*sizeof(struct scull_dev), GFP_KERNEL);

memset(scull_devs, 0, 4*sizeof(struct scull_dev));

for(i=0; i<4; i++)

{

scull_devs[i].quantum = SCULL_QUANTUM;

scull_devs[i].qset      = SCULL_QSET;

init_MUTEX(&scull_devs[i].sem);

scull_setup_cdev(&scull_devs[i], i);

}

//创建类

scull_class = class_create(THIS_MODULE, "SCULL");

//创建设备节点

for(i=0; i<4; i++)

{

scull_class_dev[i] = device_create(scull_class, NULL, MKDEV(scull_major, scull_minor+i), NULL, "scull%d", i); // "/dev/xyz"

}

return 0;

}

void scull_exit_module(void)

{

int i;

dev_t devno = MKDEV(scull_major, scull_minor);

if(scull_devs){

for(i=0; i<4; i++)

{

scull_trim(scull_devs + i);

cdev_del(&scull_devs[i].cdev);

}

}

kfree(scull_devs);

unregister_chrdev_region(devno, 4);

for(i=0; i<4; i++)

device_unregister(scull_class_dev[i]);

class_destroy(scull_class);

}

module_init(scull_init_module);

module_exit(scull_exit_module);

MODULE_LICENSE("GPL")