ldd3 chapter3 字符驱动简单记录

动态分配节点号：

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
const char *name)

删除节点号：

void unregister_chrdev_region(dev_t from, unsigned count)

动态分配cdev：

struct cdev *cdev_alloc(void)

初始化cdev，并绑定file_operations：

void cdev_init(struct cdev *cdev, const struct file_operations *fops)

将cdev和节点号绑定：

int cdev_add(struct cdev *, dev_t, unsigned);

删除cdev：

void cdev_del(struct cdev *p)

代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <asm/uaccess.h>
#include <linux/semaphore.h>

loff_t scull_llseek(struct file *filp, loff_t f_ops, int flag);

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

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

int scull_ioctl(struct inode *p_inode, struct file *filp, unsigned int cmd, unsigned long args);

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

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

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,
};

struct scull_qset
{
struct list_head qset_node;
void **data;
};

struct scull_dev
{
struct list_head qset_head;
int quantum;
int qset;
unsigned long size;

dev_t dev_t;
struct cdev cdev;
struct semaphore sem;
};

struct scull_dev g_scull_dev;

//根据index 返回p_qset结构，如果没有就创建一个
struct scull_qset *scull_follow(struct scull_dev* dev, int index)
{
int i = 0;
struct list_head * p_qset_node;
struct scull_qset *p_qset;

list_for_each(p_qset_node, &dev->qset_head)
{
if((i++) == index)
{
return container_of(p_qset_node, struct scull_qset, qset_node);
}
}

p_qset = (struct scull_qset *)kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
if (p_qset == NULL)
return NULL;
memset(p_qset, 0, sizeof(struct scull_qset));

p_qset->data = kmalloc(dev->qset * sizeof(char *), GFP_KERNEL);
if (p_qset->data == NULL)
{
kfree(p_qset);
return NULL;
}
memset(p_qset->data, 0, dev->qset * sizeof(char *));

list_add_tail(&p_qset->qset_node, &dev->qset_head);

return p_qset;
}

int scull_trim(struct scull_dev *dev)
{
struct list_head *p_qset_node = NULL;
struct scull_qset *p_qset;
int i;

while(!list_empty(&dev->qset_head))
{
p_qset_node = dev->qset_head.next;
p_qset = container_of(p_qset_node, struct scull_qset, qset_node);
for (i = 0; i < dev->qset; i++)
{
kfree(p_qset->data[i]);
}

list_del(p_qset_node);
kfree(p_qset);
}

dev->size = 0;

return 0;
}

loff_t scull_llseek(struct file *filp, loff_t f_ops, int flag)
{
printk(KERN_ERR"llseek\n");
return 0;
}

ssize_t scull_read(struct file *filp, char __user * buf, size_t count, loff_t *f_ops)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *p_qset;

int qset_size = dev->quantum * dev->qset;
int qset_index,qset_rest;
int quan_index,quan_rest;
ssize_t retval = 0;

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

qset_index = (long)*f_ops / qset_size;
qset_rest = (long)*f_ops % qset_size;

quan_index = qset_rest / dev->quantum;
quan_rest = qset_rest % dev->quantum;

if (*f_ops > dev->size)
goto out;

if ((*f_ops + count) > dev->size)
{
count = dev->size - *f_ops;
}

p_qset = scull_follow(dev, qset_index);

if (p_qset == NULL || p_qset->data == NULL || p_qset->data[quan_index] == NULL)
{
goto out;
}

if (count > (dev->quantum - quan_rest))
{
count = dev->quantum - quan_rest;
}

if (copy_to_user(buf, p_qset->data[quan_index] + quan_rest, count))
{
retval = -EFAULT;
goto out;
}

*f_ops += 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_ops)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *p_qset = NULL;

int qset_size = dev->quantum * dev->qset;
int qset_index,qset_rest;
int quan_index,quan_rest;
ssize_t retval = -ENOMEM;

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

qset_index = (long)*f_ops / qset_size;
qset_rest  = (long)*f_ops % qset_size;

quan_index = qset_rest / dev->quantum;
quan_rest = qset_rest % dev->quantum;

p_qset = scull_follow(dev, qset_index);
if (p_qset == NULL)
goto out;

if (p_qset->data[quan_index] == NULL)
{
p_qset->data[quan_index] = kmalloc(dev->quantum, GFP_KERNEL);
if (p_qset->data[quan_index] == NULL)
goto out;
}

if (count > (dev->quantum - quan_rest))
{
count = dev->quantum - quan_rest;
}

if (copy_from_user(p_qset->data[quan_index] + quan_rest, buf, count))
{
retval = -EFAULT;
goto out;
}

*f_ops += count;
retval = count;

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

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

int scull_ioctl(struct inode *p_inode, struct file *filp, unsigned int cmd, unsigned long args)
{
printk(KERN_ERR"ioctl\n");
return 0;
}

int scull_open(struct inode *p_inode, struct file *filp)
{
struct scull_dev *dev = NULL;
dev = container_of(p_inode->i_cdev, struct scull_dev, cdev);

filp->private_data = dev;
//如果以append模式打开，则文件指针指向末尾
if (filp->f_flags & O_APPEND)
{
filp->f_pos = p_inode->i_size;
}
//如果以trunc模式打开，则将dev内容清除
if (filp->f_flags & O_TRUNC)
{
scull_trim(dev);
p_inode->i_size = dev->size;
}

printk(KERN_ERR"file size = %ld\n",dev->size);
return 0;
}

int scull_release(struct inode *p_inode, struct file *filp)
{
struct scull_dev *dev = filp->private_data;

if(down_interruptible(&dev->sem))
return -ERESTARTSYS;
//更新文件大小
p_inode->i_size = dev->size;

up(&dev->sem);

return 0;
}

static int scull_init(void)
{
int result = 0;
//分配节点号
if ((result = alloc_chrdev_region(&g_scull_dev.dev_t, 0, 4, "scull")) < 0)
{
printk(KERN_ERR"alloc_chrdev_region error!\n");
return result;
}
//初始化cdev结构，并绑定file_operations和节点号
cdev_init(&g_scull_dev.cdev, &scull_fops);
cdev_add(&g_scull_dev.cdev, g_scull_dev.dev_t, 4);
printk(KERN_ERR"major = %d,minor = %d\n",MAJOR(g_scull_dev.dev_t),MINOR(g_scull_dev.dev_t));

//初始化设备结构体
g_scull_dev.qset = 4096;
g_scull_dev.quantum = 4096;
INIT_LIST_HEAD(&g_scull_dev.qset_head);
sema_init(&g_scull_dev.sem, 1);

return 0;
}

static void scull_exit(void)
{
cdev_del(&g_scull_dev.cdev);
unregister_chrdev_region(g_scull_dev.dev_t, 1);
scull_trim(&g_scull_dev);
return;
}

module_init(scull_init);
module_exit(scull_exit);

MODULE_LICENSE("Dual BSD/GPL");

Makfile:

obj-m += scull.o
KDIR := /home/linux-2.6.32.2
PWD = $(shell pwd)
all:
make -C $(KDIR) M=$(PWD) modules

clean:
rm -rf *.o

测试：
[root@FriendlyARM /nfs]# insmod scull.ko

major = 253,minor = 0

[root@FriendlyARM /nfs]# mknod /dev/scull0 c 253 0