linux 混杂设备miscdevice

#miscdevice混杂设备

miscdevice混杂设备是字符设备的一种，它们共享一个主设备号（10)，但次设备号不同，所有混杂设备形成一个链表，对设备发给你问时内核根据次设备号查找到相应的miscdevice设备。这样做的好处，节约主设备号，将某些设备用链表的形式链接在一起，最后通过查找次设备区分。
miscdevice混杂设备用主设备号无法匹配出设备驱动，只能找到链表，再通过次设备号，才能找到设备驱动，而一般字符设备，通过主设备号，就能找到设备驱动了。

通过代码,我们简单了解一下miscdevice混杂设备(只截取有关内容)

include/linux/miscdevice.h:

#define MISC_DYNAMIC_MINOR 255

struct device;

struct miscdevice  {
int minor; //次设备号
const char *name;//设备名称，即/dev创建的设备文件名称
const struct file_operations *fops;//对应设备文件的一组操作
struct list_head list;//最终会链接到内核维持的misc_list链表中，方便查找。
struct device *parent;
struct device *this_device;//指向当前创建的设备文件
const char *nodename;
umode_t mode;
};

extern int misc_register(struct miscdevice * misc);//混杂设备注册
extern int misc_deregister(struct miscdevice *misc);//混杂设备注销


drivers/char/misc.c

static int misc_open(struct inode * inode, struct file * file)
{
	int minor = iminor(inode);
	struct miscdevice *c;
	int err = -ENODEV;
	const struct file_operations *new_fops = NULL;

	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) {
	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;
	replace_fops(file, new_fops);
	if (file->f_op->open) {
	/* 
     * file->private_data 在混杂设备中 保存的是混杂设备的数据结构。
     * 在一般字符设备中，保存的是 自定义的包含struct cdev结构的数据结构
     */ 
		file->private_data = c;
		err = file->f_op->open(inode,file);
	}
fail:
	mutex_unlock(&misc_mtx);
	return err;
}

/* 包含一组设备驱动操作的结构体 */
static const struct file_operations misc_proc_fops = {
	.owner	 = THIS_MODULE,
	.open    = misc_seq_open, //在之后的定义操作，无须对open赋值，而一般字符设备必须初始化open操作
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
};

/* 混杂设备注册 */
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) {
		int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);
		if (i >= DYNAMIC_MINORS) {
			err = -EBUSY;
			goto out;
		}
		misc->minor = DYNAMIC_MINORS - i - 1;
		set_bit(i, misc_minors);
	} else {
		struct miscdevice *c;

		list_for_each_entry(c, &misc_list, list) {
			if (c->minor == misc->minor) {
				err = -EBUSY;
				goto out;
			}
		}
	}


	dev = MKDEV(MISC_MAJOR, misc->minor);
	/*
     * device_create() : 在/dev/目录下建立设备文件
     * 所以在混杂设备中不需要用mknod命令显式建立设备文件
     * 但device_create() 依赖 /sys/class 下的文件，因此在此之前得调用class_create()
     */
	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;
}


/* 混杂设备卸载 */
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);
	list_del(&misc->list);
    /*
     * device_destroy : 会删除原先在/dev目录下创建的设备文件。
     * 在一般字符设备卸载时，并没有删除在/dev目录下创建的设备文件。
     */
	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 int __init misc_init(void)
{
	int err;

	#ifdef CONFIG_PROC_FS
	proc_create("misc", 0, NULL, &misc_proc_fops);
	#endif
    /*
     * class_create() : 在/sys/class/目录下 创建 misc 目录
     * /sys/class 包含了在内核中已经注册的设备类，每个设备类描述了一种设备的作用类型
     */
	misc_class = class_create(THIS_MODULE, "misc");
	err = PTR_ERR(misc_class);
	if (IS_ERR(misc_class))
		goto fail_remove;

	err = -EIO;
    /*
     * register_chrdev() ： 注册一个字符设备驱动
     */
	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);

参考源码：linux-4.4
然后，简单的介绍一下主要的数据结构：

struct file_operations : 采用面向对象的思想，将一组系统调用封装到一个结构体中。在写设备驱动时，将自定义的操作赋值相应的系统调用。当对该设备文件操作时，内核自动选择相应的系统调用。
struct inode : 在内部表示文件。在设备驱动中，一般只使用dev_t i_rdev和struct cdev *i_cdev。
struct file ：表示打开的文件。它是由内核open时创建，并传递给在该文件上进行操作的所有函数，直到最后的close函数。

各自成员请参考《linux设备驱动程序》第三章。

接下来，比较混杂设备和一般字符设备

数据结构：在混杂设备中自定义的数据结构不必包含miscdevice结构体，而一般字符设备中自定义的数据结构得包含cdev结构体。
设备编号：在混杂设备中主设备编号恒为10,次设备编号在调用misc_register()时分配。而在一般字符设备提供了两种分配设备编号的方法，一是当明确知道所需要的设备编号时，调用register_chrdev_region()分配次设备号，二是当不明确主设备号时，则采用alloc_chrdev_region()动态主设备号。
注册字符设备：在混杂字符设备中仅需调用misc_register()即可注册，而一般字符设备，则需要通过cdev_init()初始化包含struct cdev的数据结构和cdev_add()通知内核字符设备的信息。
自定义系统调用：混杂设备中无需自定义open系统调用，而一般字符设备中，则需要自定义open系统调用。
设备与操作数据结构相关联：在混杂设备中只需在初始化miscdevice结构赋值即可，而字符设备则需要cdev_init()相关联并且显式赋值cdev结构体中ops成员。
卸载设备：在混杂字符设备中，仅需调用misc_deregister()即可，而在一般字符设备中，需要通过cdev_del()移除字符设备和通过unregister_chrdev_region释放已分配的设备号。
实际的设备文件：在混杂设备中，自动创建实际的设备文件；卸载混杂设备模块时，自动删除实际设备文件,原因请看上述源代码。在一般字符设备中，这需要通过/proc/devices文件显式创建实际的设备文件；卸载一般字符设备模块之后，并没有删除实际的设备文件，需显式删除设备文件。

最后另附很小miscdevice驱动测试代码：

mydev.c:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/mutex.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <asm/uaccess.h>


MODULE_LICENSE("GPL");

#define MCDEV_NAME "mcdev"

DEFINE_MUTEX(mcdev_mutex);

struct struct_mcdev_buf{
	char buf[1000];
	int size;
};

/* remember requesting space for a point */
static struct struct_mcdev_buf *mcdev_buf;

ssize_t mcdev_read(struct file *filp, char __user *to_userbuf, size_t count, loff_t *ppos)
{
	ssize_t res = 0;
 	mutex_lock(&mcdev_mutex);

	printk(KERN_NOTICE "reading.....\n");
	if(count > 999)
    	count = 999;
	if(mcdev_buf->size < *ppos + count)
    	count = mcdev_buf->size - *ppos;

	if(copy_to_user(to_userbuf, mcdev_buf->buf, count)){
    	res = -EINVAL;
    	goto out;
	}
	*ppos += count;
	res = count;

 	out:
	mutex_unlock(&mcdev_mutex);
	return res;
}

ssize_t mcdev_write(struct file *filp, const char __user *from_userbuf, size_t count, loff_t *ppos)
{
 	ssize_t res = 0;
	mutex_lock(&mcdev_mutex);
 	printk(KERN_NOTICE "writing.......\n");

	if(count > 999)
    	count = 999;
	if(mcdev_buf->size < count + *ppos)
    	count = mcdev_buf->size - *ppos;

	if(copy_from_user(mcdev_buf->buf, from_userbuf, count)){
    	res = -EFAULT;
    	goto out;
	}

	*ppos += count;

	out:
	mutex_unlock(&mcdev_mutex);
	return count;
}

/* .open is initialized in driver/char/misc.c */
static struct file_operations ops = {
	.read = mcdev_read,
	.write = mcdev_write,
};

/* 
* initialization for struct miscdevice 
* but we initialize three member for it.
* 
* minor, name, fops 
*/
static struct miscdevice mcdev ={
	.minor = MISC_DYNAMIC_MINOR, 
	.name = MCDEV_NAME,
	.fops = &ops,
};

static int __init register_mcdev(void)
{
	int ret;

	printk(KERN_NOTICE "register_mcdev......\n");

	ret = misc_register(&mcdev);

	mcdev_buf = kmalloc(sizeof(struct struct_mcdev_buf), GFP_KERNEL);
	memset(mcdev_buf->buf, 0, sizeof(mcdev_buf->buf));
	mcdev_buf->size = 1000;

	printk(KERN_NOTICE "minor : %d\n", mcdev.minor);    

	if(ret)
    printk(KERN_WARNING "register fail!\n");

	return ret;
}

static void __exit deregister_mcdev(void)
{
	int ret;

	kfree(mcdev_buf);
	ret = misc_deregister(&mcdev);


	if(!ret)
	printk(KERN_NOTICE "deregister success\n");
    
}

module_init(register_mcdev);
module_exit(deregister_mcdev);

MODULE_AUTHOR("[email protected]");

Makefile文件如下:

all: module

ifndef KERNEL_DIR
	KERNEL_DIR = /lib/modules/`uname -r`/build
endif

obj-m := mydev.o

.PHONY: module
module:
	make -C $(KERNEL_DIR) M=$(PWD) modules

.PHONY: clean
clean:
	make -C $(KERNEL_DIR) M=$(PWD) clean
	rm *~ > /dev/null 2>&1

.PHONY: install
install:
	sudo insmod mydev.ko

.PHONY: uninstall
uninstall:
	sudo rmmod mydev.ko

.PHONY: reload
reload:
	sudo rmmod mydev.ko
	sudo insmod mydev.ko

linux 混杂设备miscdevice

985 硕士程序员，空窗 4 个月没有 Offer！

一文搞懂 Spring 循环依赖

赛博斗地主——使用大语言模型扮演Agent智能体玩牌类游戏。

VScode右键打开(添加到右键)

進程地址空間 find_vma()

內核編譯之使用kernel-package編譯內核imgage包

per_cpu_pageset 之一(init/main.c start_kernel初始化)

proc文件系統及初始化

linux 混雜設備miscdevice

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結