多Linux字符设备驱动是否可以共享同一个主设备号?

本文详细探讨了Linux字符设备驱动如何共享同一个主设备号,通过实例展示了如何创建并管理这些设备。文章介绍了设备名的决定因素、内核中的设备创建流程、设备号的查看方法以及手动创建字符设备的过程。通过分析内核源码,解释了设备节点创建、设备号管理以及ioctl命令的使用。最后,总结了字符设备驱动框架的关键特性。
摘要由CSDN通过智能技术生成

答案是可以,不但多字符设备驱动可以共享同一个主设备号,同一个驱动的不同子设备还可以跨多个主设备号。可以看下面的例子,思路是开发两个字符设备模块,第一个模块动态分配设备号,安装完毕后,查看设备号数值,并将此主设备号静态分配给第二个设备驱动,并注册第二个设备驱动模块。最后开发用户程序,打开两类设备驱动代表的设备节点,打开成功,证明确实可以如此做.  

模块1代码demo.c:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/stat.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>

MODULE_AUTHOR("czl");
MODULE_LICENSE("GPL");

#define DEVICE_NAME "char_demo"
#define DRIVER_NAME "char_demo"

#define DEVICE_MAJOR 	0
#define DRIVER_MINOR 	0
#define DEVICE_NUM 	2
#define DEVICE_SIZE 	3000

int major_num = DEVICE_MAJOR;
int minor_num = DRIVER_MINOR;

module_param(major_num, int , 0664);
module_param(minor_num, int, 0664);

static struct class *myclass;
struct reg_dev 
{
	char *data; // 设备数据 
	unsigned long size; //设备占用空间大小
	struct cdev cdev; //设备结构体
};

struct reg_dev *my_devices;
static int char_demo_open(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_open is success!imajor %d, iminor %d.\n", imajor(inode), iminor(inode));
	return 0;
}

static int char_demo_close(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_release is success!\n");
	return 0;
}

static long char_demo_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
	printk(KERN_EMERG "chardevnode_ioctl is success! cmd is %d,arg is %ld \n",cmd,arg);
	return 0;
}

ssize_t char_demo_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

ssize_t char_demo_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

loff_t char_demo_llseek(struct file *file, loff_t offset, int ence){
	return 0;
}

struct file_operations  char_demo_ops = {
	.owner = THIS_MODULE,
	.open  = char_demo_open,
	.release = char_demo_close,
	.unlocked_ioctl = char_demo_ioctl,
	.read = char_demo_read,
	.write = char_demo_write,
	.llseek = char_demo_llseek,
};

static int char_demo_init(void)
{
	int ret = 0, i; //返回结果和for变量
	dev_t num_dev;  // 设备号

	printk(KERN_INFO"char_demo_exit\n");
	printk(KERN_INFO"major is %d \n",major_num);
	printk(KERN_INFO"minor is %d \n",minor_num);

	/* 如果主设备号不为零,静态注册设备,否则动态注册 */
	if(major_num){
		num_dev = MKDEV(major_num, minor_num);
		ret = register_chrdev_region(num_dev,DEVICE_NUM, DEVICE_NAME);
		if(ret != 0) {
			printk(KERN_EMERG"register chrdev region failure.\n");
			return -1;
		}
	} else {
		ret = alloc_chrdev_region(&num_dev, minor_num, DEVICE_NUM, DEVICE_NAME);
		major_num = MAJOR(num_dev); //得到主设备号
		minor_num = MINOR(num_dev); //得到次设备号
		printk(KERN_INFO"alloc_char_demo , the major is %d ,the minor is %d.\n",major_num,minor_num);
	}

	if(ret < 0){
		printk(KERN_EMERG"char_demo failed\n");
		return -1;
	}

	/* 创建一个类 */
	myclass = class_create(THIS_MODULE, DEVICE_NAME);

	/* 申请设备空间 */
	my_devices = kmalloc(sizeof(struct reg_dev) * DEVICE_NUM, GFP_KERNEL);
	if(!my_devices){
		ret = -ENOMEM;
		goto fail;
	}

	memset(my_devices, 0, DEVICE_NUM * sizeof(struct reg_dev));

	/* 对设备依次初始化 */
	for( i = 0 ; i < DEVICE_NUM ; i++){
		my_devices[i].data = kmalloc(DEVICE_SIZE, GFP_KERNEL);
		memset(my_devices[i].data, 0, sizeof(char) * DEVICE_SIZE);

		/* 设备注册到系统 */
		cdev_init(&my_devices[i].cdev, &char_demo_ops);
		my_devices[i].cdev.owner = THIS_MODULE;
		my_devices[i].cdev.ops = &char_demo_ops;
		ret = cdev_add(&my_devices[i].cdev, MKDEV(major_num, minor_num +i), 1);
		if(ret) {
			printk(KERN_EMERG"char_demo %d is fail ! %d\n",i,ret);
		} else {
			printk(KERN_EMERG"char_demo add %d is success !\n",minor_num + i);
		}

		/* 创建设备节点 */
		device_create(myclass, NULL, MKDEV(major_num, minor_num +i), NULL, DEVICE_NAME"%d",i);
	}

	printk(KERN_EMERG"char_demo init ok !\n");
	return 0;

fail:
	/* 注销设备号 */
	unregister_chrdev_region(MKDEV(major_num,minor_num),DEVICE_NUM);
	printk(KERN_EMERG "kmalloc is fail!\n");
	return ret;
}

/* 退出模块 */
static void char_demo_exit(void)
{
	int i;

	/* 卸载字符设备 */
	for(i = 0 ; i < DEVICE_NUM ; i++) {
		cdev_del(&(my_devices[i].cdev));
		device_destroy(myclass, MKDEV(major_num, minor_num +i));
	}

	/* 卸载设备类 */
	class_destroy(myclass);
	/* 释放申请内存 */
	kfree(my_devices);
	/* 释放设备号 */
	unregister_chrdev_region(MKDEV(major_num, minor_num), DEVICE_NUM);
}

module_init(char_demo_init);
module_exit(char_demo_exit);

模块1 Makefile,模块的Makefile遵从一定的书写范式,它分成两次被加载,第一次,由命令你个行的make直接调用,KERNELRELEASE为空,所以走到下面的分支,再次调用一个make,以内核目录树TOP makefile为编译文件,接着KERNELRELEASE会在Linux内核源码的TOPmakefile中被设置,TOP makefile还会调用 script目录下的Makefile.modpost为makefile文件,最终将在Makefile.modpos中第二次将模块目录下的Makefile/Kbuild文件include进来,此时由于KERNELRELEASE已经被设置,将会走第一个分支,也就是obj-m的赋值,之后就可以编译了。

所以模块的makefile第一次作为主makefile存在,第二次则作为主makefile(Makefile.modpost)的一部分存在。

ifneq ($(KERNELRELEASE),)
obj-m:=demo.o
else
KERNELDIR:=/lib/modules/$(shell uname -r)/build

PWD:=$(shell pwd)
default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
	rm -rf *.o *.mod.c *.mod.o *.ko
endif

安装模块1

 查看主设备号:

发现设备号是240,将其设置为第二个驱动的主设备号,并且静态分配,第二份驱动由第一份简单修改而成:

module2 demo_test.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/stat.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>

/* 定义字符设备和驱动的名字 */
#define DEVICE_NAME "char_demo_test"
#define DRIVER_NAME "char_demo_test"

/* 定义设备号和设备数及大小 */
#define DEVICE_MAJOR 	238
#define DRIVER_MINOR 	6
#define DEVICE_NUM 	2
#define DEVICE_SIZE 	3000

/* 申明主设备号的次设备号 */
int major_num = DEVICE_MAJOR;
int minor_num = DRIVER_MINOR;

/* 定义模块参数 */
module_param(major_num, int , 0664);
module_param(minor_num, int, 0664);

static struct class *myclass;
struct reg_dev 
{
	char *data;
	unsigned long size;
	struct cdev cdev;
};

struct reg_dev *my_devices;


static int char_demo_open(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_open is success!imajor %d, iminor %d.\n", imajor(inode), iminor(inode));
	
	return 0;
}

static int char_demo_close(struct inode *inode, struct file *file){
	printk(KERN_EMERG "chardevnode_release is success!\n");
	
	return 0;
}

static long char_demo_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
	printk(KERN_EMERG "chardevnode_ioctl is success! cmd is %d,arg is %ld \n",cmd,arg);
	
	return 0;
}

ssize_t char_demo_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

ssize_t char_demo_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){
	return 0;
}

loff_t char_demo_llseek(struct file *file, loff_t offset, int ence){
	return 0;
}


struct file_operations  char_demo_ops = {
	.owner = THIS_MODULE,
	.open  = char_demo_open,
	.release = char_demo_close,
	.unlocked_ioctl = char_demo_ioctl,
	.read = char_demo_read,
	.write = char_demo_write,
	.llseek = char_demo_llseek,
};

static int char_demo_init(void)
{
	
  • 8
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

papaofdoudou

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值