Linux系统中,存在一类字符设备,他们共享一个主设备号(10),但此设备号不同,我们称这类设备为混杂设备(miscdeivce),查看/proc/device中可以看到一个名为misc的主设备号为10.所有的混杂设备形成一个链表,对设备访问时内核根据次设备号找到对应的miscdevice设备。相对于普通字符设备驱动,它不需要自己去生成设备文件。

Linux内核使用struct miscdeivce来描述一个混杂设备

struct miscdevice  {

    int minor;

    const char *name;

    const struct file_operations *fops;

    struct list_head list;

    struct device *parent;

    struct device *this_device;

    const char *nodename;

    mode_t mode;

};

scull 设备驱动只实现最重要的设备方法. 它的 file_operations 结构是如下初始化的:

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

minor是这个混杂设备的次设备号,若由系统自动配置,则可以设置为MISC_DYNANIC_MINOR,name是设备名.使用时只需填写minor次设备号,*name设备名,*fops文件操作函数集即可。

Linux内核使用misc_register函数注册一个混杂设备,使用misc_deregister移除一个混杂设备。注册成功后,linux内核为自动为该设备创建设备节点,在/dev/下会产生相应的节点。

 注册函数:

int misc_register(struct miscdevice * misc)

输入参数:struct miscdevice

返回值:

0   表示注册成功。

负数 表示未成功。

卸载函数:

int  misc_deregister(struct miscdevice *misc)

0  表示成功。

负数 表示失败。


在Linux驱动中把无法归类的五花八门的设备定义为混杂设备(用miscdevice结构体表述)。miscdevice共享一个主设备号MISC_MAJOR(即10),但次设备号不同。 所有的miscdevice设备形成了一个链表,对设备访问时内核根据次设备号查找对应的miscdevice设备,然后调用其file_operations结构中注册的文件操作接口进行操作。 在内核中用struct miscdevice表示miscdevice设备,然后调用其file_operations结构中注册的文件操作接口进行操作。miscdevice的API实现在drivers/char/misc.c中。

下边是描述这个设备的结构体:

  1. struct miscdevice  {      
  2.     int minor;                               //次设备号   
  3.     const char *name;                        //设备的名称      
  4.     const struct file_operations *fops;     //文件操作    
  5.     struct list_head list;                  //misc_list的链表头  
  6.     struct device *parent;                  //父设备(Linux设备模型中的东东了,哈哈)      
  7.     struct device *this_device;             //当前设备,是device_create的返回值,下边会看到  
  8. };  

然后来看看misc子系统的初始化函数:

  1. static int __init misc_init(void)   
  2. {   
  3.     int err;   
  4.   
  5. #ifdef CONFIG_PROC_FS   
  6.     /*创建一个proc入口项*/  
  7.     proc_create("misc", 0, NULL, &misc_proc_fops);                   
  8. #endif   
  9.     /*在/sys/class/目录下创建一个名为misc的类*/  
  10.     misc_class = class_create(THIS_MODULE, "misc");   
  11.     err = PTR_ERR(misc_class);   
  12.     if (IS_ERR(misc_class))   
  13.         goto fail_remove;   
  14.    
  15.     err = -EIO;  
  16.     /*注册设备,其中设备的主设备号为MISC_MAJOR,为10。设备名为misc,misc_fops是操作函数的集合;包含了open方法*/   
  17.     if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
  18.         goto fail_printk;   
  19.     return 0;   
  20.    
  21. fail_printk:   
  22.     printk("unable to get major %d for misc devices/n", MISC_MAJOR);   
  23.     class_destroy(misc_class);   
  24. fail_remove:   
  25.     remove_proc_entry("misc", NULL);   
  26.     return err;   
  27. }   
  28. /*misc作为一个子系统被注册到linux内核中*/  
  29. subsys_initcall(misc_init);   

下边是register_chrdev函数的实现:

  1. int register_chrdev(unsigned int major, const char *name,  
  2.             const struct file_operations *fops)  
  3. {  
  4.     struct char_device_struct *cd;  
  5.     struct cdev *cdev;  
  6.     char *s;  
  7.     int err = -ENOMEM;  
  8.     /*主设备号是10,次设备号为从0开始,分配256个设备*/  
  9.     cd = __register_chrdev_region(major, 0, 256, name);  
  10.     if (IS_ERR(cd))  
  11.         return PTR_ERR(cd);  
  12.     /*分配字符设备*/  
  13.     cdev = cdev_alloc();  
  14.     if (!cdev)  
  15.         goto out2;  
  16.   
  17.     cdev->owner = fops->owner;  
  18.     cdev->ops = fops;  
  19.     /*Linux设备模型中的,设置kobject的名字*/  
  20.     kobject_set_name(&cdev->kobj, "%s", name);  
  21.     for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))  
  22.         *s = '!';  
  23.     /*把这个字符设备注册到系统中*/     
  24.     err = cdev_add(cdev, MKDEV(cd->major, 0), 256);  
  25.     if (err)  
  26.         goto out;  
  27.   
  28.     cd->cdev = cdev;  
  29.   
  30.     return major ? 0 : cd->major;  
  31. out:  
  32.     kobject_put(&cdev->kobj);  
  33. out2:  
  34.     kfree(__unregister_chrdev_region(cd->major, 0, 256));  
  35.     return err;  
  36. }  

来看看这个设备的操作函数的集合:

  1. static const struct file_operations misc_fops = {   
  2.     .owner      = THIS_MODULE,   
  3.     .open       = misc_open,   
  4. };   

可以看到这里只有一个打开函数,用户打开miscdevice设备是通过主设备号对应的打开函数,在这个函数中找到次设备号对应的相应的具体设备的open函数。它的实现如下:

  1. static int misc_open(struct inode * inode, struct file * file)   
  2. {   
  3.     int minor = iminor(inode);   
  4.     struct miscdevice *c;   
  5.     int err = -ENODEV;   
  6.     const struct file_operations *old_fops, *new_fops = NULL;   
  7.       
  8.     lock_kernel();   
  9.     mutex_lock(&misc_mtx);   
  10.     /*找到次设备号对应的操作函数集合,让new_fops指向这个具体设备的操作函数集合*/  
  11.     list_for_each_entry(c, &misc_list, list) {   
  12.         if (c->minor == minor) {   
  13.             new_fops = fops_get(c->fops);           
  14.             break;   
  15.         }   
  16.     }   
  17.            
  18.     if (!new_fops) {   
  19.         mutex_unlock(&misc_mtx);   
  20.         /*如果没有找到,则请求加载这个次设备号对应的模块*/  
  21.         request_module("char-major-%d-%d", MISC_MAJOR, minor);   
  22.         mutex_lock(&misc_mtx);   
  23.         /*重新遍历misc_list链表,如果没有找到就退出,否则让new_fops指向这个具体设备的操作函数集合*/  
  24.         list_for_each_entry(c, &misc_list, list) {   
  25.             if (c->minor == minor) {   
  26.                 new_fops = fops_get(c->fops);   
  27.                 break;   
  28.             }   
  29.         }   
  30.         if (!new_fops)   
  31.             goto fail;   
  32.     }   
  33.    
  34.     err = 0;   
  35.     /*保存旧打开函数的地址*/  
  36.     old_fops = file->f_op;   
  37.     /*让主设备号的操作函数集合指针指向具体设备的操作函数集合*/  
  38.     file->f_op = new_fops;   
  39.     if (file->f_op->open) {  
  40.         /*使用具体设备的打开函数打开设备*/   
  41.         err=file->f_op->open(inode,file);   
  42.         if (err) {   
  43.             fops_put(file->f_op);   
  44.             file->f_op = fops_get(old_fops);   
  45.         }   
  46.     }   
  47.     fops_put(old_fops);   
  48. fail:   
  49.     mutex_unlock(&misc_mtx);   
  50.     unlock_kernel();   
  51.     return err;   
  52. }   

再来看看misc子系统对外提供的两个重要的API,misc_register,misc_deregister:

  1. int misc_register(struct miscdevice * misc)   
  2. {   
  3.     struct miscdevice *c;   
  4.     dev_t dev;   
  5.     int err = 0;   
  6.     /*初始化misc_list链表*/  
  7.     INIT_LIST_HEAD(&misc->list);   
  8.     mutex_lock(&misc_mtx);   
  9.     /*遍历misc_list链表,看这个次设备号以前有没有被用过,如果次设备号已被占有则退出*/  
  10.     list_for_each_entry(c, &misc_list, list) {   
  11.         if (c->minor == misc->minor) {   
  12.             mutex_unlock(&misc_mtx);   
  13.             return -EBUSY;   
  14.         }   
  15.     }   
  16.     /*看是否是需要动态分配次设备号*/  
  17.     if (misc->minor == MISC_DYNAMIC_MINOR) {  
  18.         /* 
  19.          *#define DYNAMIC_MINORS 64 /* like dynamic majors */  
  20.          *static unsigned char misc_minors[DYNAMIC_MINORS / 8];   
  21.          *这里存在一个次设备号的位图,一共64位。下边是遍历每一位,  
  22.          *如果这位为0,表示没有被占有,可以使用,为1表示被占用。         
  23.          */  
  24.         int i = DYNAMIC_MINORS;   
  25.         while (--i >= 0)   
  26.             if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)   
  27.                 break;   
  28.         if (i<0) {   
  29.             mutex_unlock(&misc_mtx);   
  30.             return -EBUSY;   
  31.         }   
  32.         /*得到这个次设备号*/  
  33.         misc->minor = i;                                           
  34.     }   
  35.     /*设置位图中相应位为1*/  
  36.     if (misc->minor < DYNAMIC_MINORS)   
  37.         misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);   
  38.     /*计算出设备号*/  
  39.     dev = MKDEV(MISC_MAJOR, misc->minor);   
  40.     /*在/dev下创建设备节点,这就是有些驱动程序没有显式调用device_create,却出现了设备节点的原因*/  
  41.     misc->this_device = device_create(misc_class, misc->parent, dev, NULL,   
  42.                       "%s", misc->name);   
  43.     if (IS_ERR(misc->this_device)) {   
  44.         err = PTR_ERR(misc->this_device);   
  45.         goto out;   
  46.     }   
  47.    
  48.     /*  
  49.      * Add it to the front, so that later devices can "override"  
  50.      * earlier defaults  
  51.      */   
  52.     /*将这个miscdevice添加到misc_list链表中*/  
  53.     list_add(&misc->list, &misc_list);   
  54.  out:   
  55.     mutex_unlock(&misc_mtx);   
  56.     return err;   
  57. }   

这个是miscdevice的卸载函数:

  1. int misc_deregister(struct miscdevice *misc)   
  2. {   
  3.     int i = misc->minor;   
  4.    
  5.     if (list_empty(&misc->list))   
  6.         return -EINVAL;   
  7.    
  8.     mutex_lock(&misc_mtx);   
  9.     /*在misc_list链表中删除miscdevice设备*/  
  10.     list_del(&misc->list);     
  11.     /*删除设备节点*/                            
  12.     device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));             
  13.     if (i < DYNAMIC_MINORS && i>0) {  
  14.         /*释放位图相应位*/   
  15.         misc_minors[i>>3] &= ~(1 << (misc->minor & 7));   
  16.     }   
  17.     mutex_unlock(&misc_mtx);   
  18.     return 0;   
  19. }   

总结一下miscdevice驱动的注册和卸载流程:

misc_register:

匹配次设备号->找到一个没有占用的次设备号(如果需要动态分配的话)->计算设号->创建设备文-

miscdevice结构体添加到misc_list链表中。

misc_deregister:

从mist_list中删除miscdevice->删除设备文件->位图位清零。


GitHub 加速计划 / li / linux-dash
10.39 K
1.2 K
下载
A beautiful web dashboard for Linux
最近提交(Master分支:2 个月前 )
186a802e added ecosystem file for PM2 4 年前
5def40a3 Add host customization support for the NodeJS version 4 年前
Logo

旨在为数千万中国开发者提供一个无缝且高效的云端环境,以支持学习、使用和贡献开源项目。

更多推荐