前言

在linux驱动中，需要提供主设备号和次设备号号，通常使用的主设备号是从
0到 255之间的数，仅仅使用主设备号，还是不叫紧张的，因此需要利用次设备号。

linux中，提供了miscdevice这种杂项设备，指定主设备号为10，次设备号可以设置为
系统动态分配。

在具体分析miscdevice之前，先给出miscdevice的核心设计思想。

应用层，打开/dev/xxx 节点，会得到文件描述符 fd，通过fd,可以执行 read()、
wriete()、ioctl()、mmap()等对这个文件的操作。

应用层调用 open()函数，经过系统调用后，会调用驱动程序的 open()函数。在前边分析
调用过程时，分析过这个open()的调用过程。

驱动程序中，调用file_opeartions的open()的时候，此时，调用到另外一个 file_operations的
open()，此时应用层会得到这个open()时的文件描述符fd,此时应用层 read()、write()等操作，
就调用到了这个file_operations。故在cdev_init时的 fops 充当一个中转的作用，转到具体的
fops 来操作。

给出在linux驱动开发之字符设备–自动创建设备节点
代码上的一个 diff

@@ -134,6 +135,19 @@ static struct file_operations fops ={
     .unlocked_ioctl = cdev_demo_ioctl,
 };

+static int misc_open(struct inode * inode, struct file * file)
+{
+    printk("%s,%d\n",__func__,__LINE__);
+   
+   file->f_op = &fops;
+   return file->f_op->open(inode,file) ;
+}
+
+static struct file_operations misc_fops = {
+   .owner = THIS_MODULE;
+   .open = misc_open,
+};
+
char cdev_buf[2] = "a";

static ssize_t cdev_demo_show(struct device *dev,struct device_attribute *attr,    char *buf)  
@@ -171,7 +185,7 @@ static int __init cdev_demo_init(void)
return -ENOMEM;
     }

-    cdev_init(pdev,&fops);
+    cdev_init(pdev,&misc_fops);

     ret = alloc_chrdev_region(&dev,minor,count,DEVICE_NAME);
if(ret){

关键的代码是

    file->f_op = &fops;
return file->f_op->open(inode,file) ;

将变量 fops 赋值给了 file 的 f_op (const struct file_operations *f_op;)

在返回的时候，调用这个file->f_op-open，其实质是调用到 fops的open()。

这样的一种方式，实现了中转的作用。利用这种中转，可以进行代码的分层，在通用层中
实现抽象的open(),在具体的设备中，实现具体的open()、read()、write()。

miscdevice分析

miscdevice 结构体

struct miscdevice  {
int minor;            //次设备号 通常为MISC_DYNAMIC_MINOR 动态分配
const char *name;     //设备为的名字
const struct file_operations *fops;//函数操作集
struct list_head list;
struct device *parent;
struct device *this_device;
const char *nodename;
    umode_t mode;
};

通常 miscdevice的 minor 、name 和 fops是需要实现的。

int misc_register(struct miscdevice * misc)

misc 注册函数，成功返回0 ，失败返回负数

int misc_deregister(struct miscdevice *misc)

misc 注销函数，成功返回0 ，失败返回负数

/*
 * Head entry for the doubly linked miscdevice list
 */
static LIST_HEAD(misc_list);
static DEFINE_MUTEX(misc_mtx);

/*
 * Assigned numbers, used for dynamic minors
 */
#define DYNAMIC_MINORS 64 /* like dynamic majors */
static DECLARE_BITMAP(misc_minors, DYNAMIC_MINORS);
static int misc_open(struct inode * inode, struct file * file)
{
//取出次设备号
    int minor = iminor(inode);
    struct miscdevice *c;
    int err = -ENODEV;
    const struct file_operations *old_fops, *new_fops = NULL;

    mutex_lock(&misc_mtx);
//misc_list中，取出具体设备的misc_device来，得到fops
    list_for_each_entry(c, &misc_list, list) {
if (c->minor == minor) {
            new_fops = fops_get(c->fops);       
            break;
        }
    }

if (!new_fops) {
        mutex_unlock(&misc_mtx);
        request_module("char-major-%d-%d", MISC_MAJOR, minor);
        mutex_lock(&misc_mtx);

        list_for_each_entry(c, &misc_list, list) {
if (c->minor == minor) {    
                new_fops = fops_get(c->fops);
                break;
            }
        }
if (!new_fops)
            goto fail;
    }

    err = 0;
//保存原有的fops
    old_fops = file->f_op;
//赋值新的fops
    file->f_op = new_fops;
//如果设备实现了open函数
if (file->f_op->open) {


/*
 * FIXME: this is a workaround for pmem
 * PMEM need private_data to be NULL for an unmapped file.
 * The private_data is used to store PMEM internal data strucutre.
 * Leakage may happen if we just override this field in pmem_open function
 */
if (strcmp(c->name, "pmem_multimedia") != 0 && strcmp(c->name, "vmem_multimedia") != 0)
            file->private_data = c;

//调用open函数
        err=file->f_op->open(inode,file);
if (err) {
//调用失败，恢复fops为保存old_fops
            fops_put(file->f_op);
            file->f_op = fops_get(old_fops);
        }
    }
    fops_put(old_fops);
fail:
    mutex_unlock(&misc_mtx);
return err;
}

static struct class *misc_class;

static const struct file_operations misc_fops = {
.owner      = THIS_MODULE,
.open       = misc_open,
.llseek     = noop_llseek,
};

/**
 * misc_register - register a miscellaneous device
 * @misc: device structure
 * 
 * Register a miscellaneous device with the kernel. If the minor
 * number is set to %MISC_DYNAMIC_MINOR a minor number is assigned
 * and placed in the minor field of the structure. For other cases
 * the minor number requested is used.
 *
 * The structure passed is linked into the kernel and may not be
 * destroyed until it has been unregistered.
 *
 * A zero is returned on success and a negative errno code for
 * failure.
 */

int misc_register(struct miscdevice * misc)
{
    dev_t dev;
    int err = 0;

    INIT_LIST_HEAD(&misc->list);

    mutex_lock(&misc_mtx);
//动态分配次设备号
if (misc->minor == MISC_DYNAMIC_MINOR) {
//从位图中，从 misc_minors 开始，查找最小的 zero位，做多查找64次
        int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);
if (i >= DYNAMIC_MINORS) {
            mutex_unlock(&misc_mtx);
//没有次设备号，可以分配
return -EBUSY;
        }
//赋值次设备号 
        misc->minor = DYNAMIC_MINORS - i - 1;
//设置位图
        set_bit(i, misc_minors);
    } else {
//指定次设备号
        struct miscdevice *c;
//从 misc_list中，查看是否制定的这个 minor是否已经注册 
        list_for_each_entry(c, &misc_list, list) {
if (c->minor == misc->minor) {
                mutex_unlock(&misc_mtx);
return -EBUSY;
            }
        }
    }
//使用MKDEV创建设备号
    dev = MKDEV(MISC_MAJOR, misc->minor);
//创建设备
    misc->this_device = device_create(misc_class, misc->parent, dev,
                      misc, "%s", misc->name);
//判断设备是否创建成功，不成功，则销毁 次设备号
if (IS_ERR(misc->this_device)) {
        int i = DYNAMIC_MINORS - misc->minor - 1;
if (i < DYNAMIC_MINORS && i >= 0)
            clear_bit(i, misc_minors);
        err = PTR_ERR(misc->this_device);
        goto out;
    }

/*
 * Add it to the front, so that later devices can "override"
 * earlier defaults
 */
//将设备添加到misc_list的头部
    list_add(&misc->list, &misc_list);
 out:
    mutex_unlock(&misc_mtx);
return err;
}

/**
 * misc_deregister - unregister a miscellaneous device
 * @misc: device to unregister
 *
 * Unregister a miscellaneous device that was previously
 * successfully registered with misc_register(). Success
 * is indicated by a zero return, a negative errno code
 * indicates an error.
 */

int misc_deregister(struct miscdevice *misc)
{
    int i = DYNAMIC_MINORS - misc->minor - 1;

if (WARN_ON(list_empty(&misc->list)))
return -EINVAL;

    mutex_lock(&misc_mtx);
//删除链表 misc->list,相当于同时在misc_list 中删除了这个 misc
    list_del(&misc->list);
//销毁设备
    device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
//清理次设备号
if (i < DYNAMIC_MINORS && i >= 0)
        clear_bit(i, misc_minors);
    mutex_unlock(&misc_mtx);
return 0;
}

EXPORT_SYMBOL(misc_register);
EXPORT_SYMBOL(misc_deregister);

static char *misc_devnode(struct device *dev, umode_t *mode)
{
    struct miscdevice *c = dev_get_drvdata(dev);

if (mode && c->mode)
*mode = c->mode;
if (c->nodename)
return kstrdup(c->nodename, GFP_KERNEL);
return NULL;
}

static int __init misc_init(void)
{
    int err;
//创建proc 文件系统
#ifdef CONFIG_PROC_FS
    proc_create("misc", 0, NULL, &misc_proc_fops);
#endif
    misc_class = class_create(THIS_MODULE, "misc");
    err = PTR_ERR(misc_class);
if (IS_ERR(misc_class))
        goto fail_remove;

    err = -EIO;
if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
        goto fail_printk;
    misc_class->devnode = misc_devnode;
return 0;

fail_printk:
    printk("unable to get major %d for misc devices\n", MISC_MAJOR);
    class_destroy(misc_class);
fail_remove:
    remove_proc_entry("misc", NULL);
return err;
}
subsys_initcall(misc_init);

1.利用链表，进行存储具体的设备
2.使用open时的中转功能
3.通用层: miscdevice，提供结构体、创建类，提供创建设备的核心函数
具体设备层: 填充结构题，实现具体功能；利用提供的核心函数实现注册设备。

秒客网

linux驱动开发 --miscdevice

前言

miscdevice分析

参考文献

相关文章