字符设备驱动程序(ioctl)——开发步骤(6)

最新推荐文章于 2023-03-27 13:07:08 发布
最新推荐文章于 2023-03-27 13:07:08 发布
阅读量1.2k 收藏 4
点赞数 3
分类专栏： linux 驱动开发 文章标签： 字符设备驱动ioctl 应用程序调用ioctl linux内核驱动编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bruce_4/article/details/107860486
版权

字符设备驱动程序(ioctl)

  • ioctl函数模型
    int (*ioctl)(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg){}
    返回值：

    • ioctl函数的实现通常是根据命令执行的switch语句，
    • 但是命令号不能匹配到任何一个设备时，通常返回-EINVAL(非法参数)

    使用参数：

    • 参数如果是一个整数，可以直接使用，
    • 如果是一个指针，需要先确保用户地址的有效性，使用前需要做正确检查
    • 需要检测的函数：__get_user 和 __put_user
    • 不需要检测的函数：copy_from_user & copy_to_user & get_user & put_user

    参数检查：
    int access_ok(int type,const void *addr,unsigned long size){}

    • 第一个参数：VERIFY_READ or VERIFY_WRITE
      • 用来表示读用户内存或者写用户内存
    • 第二个参数：addr是要操作的用户内存地址
    • 第三个参数：size是操作的长度，如果ioctl需要从用户空间读一个整数，size=sizeof(int)
    • 返回值：access_ok返回一个布尔值，1是成功，0是失败，如果返回失败，ioctl应当返回-EFAULT
    //ioctl读取数据，需要向用户空间写入数据
if(_IOC_DIR(cmd) & _IOC_READ){
	err = !access_ok(VERIFY_WRITE,(void __user *)arg,_IOC_SIZE(cmd));
}
//ioctl设置数据，需要向用户空间读取数据
else if(_IOC_DIR(cmd) & _IOC_WRITE){
	err = !access_ok(VERIFY_READ,(void __user *)arg,_IOC_SIZE(cmd));
}
if(err){
	return -EFAULT;
}

定义命令

#define MEM_IOC_MAGIC 	'm'			//定义幻数
#define MEM_IOCSET		_IOW(MEM_IOC_MAGIC,o,int)			//set数据到驱动中
#define MEM_IOCGQSET 	_IOR(MEM_IOC_MAGIC,1,int)			//从驱动中读数据

关于ioctl函数模型

  • 在2.6.36以后ioctl函数已经不存在了，用unlocked_ioctl和compat_ioctl两个函数代替。参数去除了原来ioctl中的struct inode参数，返回值也发生了改变。

  • 在应用程序设计中还是采用ioctl实现访问，而并不是unlocked_ioctl函数，因此我们还可以称之为ioctl函数的实现。

    • 操作集定义
      在这里插入图片描述
    • 函数原型
      在这里插入图片描述
    • 应用程序调用
      在这里插入图片描述

详细步骤

  • 编译Makefile
    在这里插入图片描述

  • 将字符设备驱动模块加载到内核中
    在这里插入图片描述

  • 查看主设备号
    cat /proc/devices
    在这里插入图片描述

  • 去到/dev目录下，创建设备文件memdev_ioctl0
    cd /dev

  • 关于创建设备文件参数解释见上一篇博客（连接：创建设备文件参数解释)
    sudo mknod memdev_ioctl0 c 240 0
    在这里插入图片描述

  • 编译应用程序文件
    gcc memdev_ioctl_app.c -o memdev_ioctl_app
    在这里插入图片描述

  • 执行可执行文件
    sudo ./memdev_ioctl_app
    在这里插入图片描述

执行成功！！！！！！！！！

ioctl源码资源！！！！！！！

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/unistd.h>
 

#define BASEMINOR 0
#define COUNT     3
#define NAME      "memdev_ioctl"
#define MEMDEV_SIZE		4096

#define MEMDEV_IOC_MAGIC 'j'			//定义幻数
#define MEMDEV_IOCPRTDATA _IO(MEMDEV_IOC_MAGIC,1)			//控制驱动打印数据
#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC,3,int)			//set数据到驱动中
#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC,2,int)			//从驱动中读数据
#define MEMDEV_IOCMAXNR 3

dev_t devno;

struct memdev{
	char *data;
	unsigned long size;
};

struct cdev *cdevp = NULL;
struct memdev *memdevp = NULL;

int mem_open (struct inode *inode,struct file *filp){
	//printk(KERN_INFO "---%s---%s---%d---\n",__FILE__,__func__,__LINE__);
	struct memdev *mdev = NULL;
	
	int num = MINOR(inode->i_rdev);
	if(num >= COUNT){
		return -ENODEV;
	}
	mdev = &memdevp[num];          
	filp->private_data = mdev;
	
	return 0;
}
int mem_release (struct inode *inode,struct file *filp){
	printk(KERN_INFO "---%s---%s---%d---\n",__FILE__,__func__,__LINE__);
	return 0;
}

static long mem_ioctl(struct file *filp,unsigned int cmd,unsigned long arg){
	
	long ret = 0;
	int err = 0;
	int ioarg = 0;
	
	//第一步验证命令cmd参数的有效性
	if(_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC){
	return -EINVAL;}
	if(_IOC_NR(cmd) > MEMDEV_IOCMAXNR){
	return -EINVAL;}
	
	//检测参数空间是否可以正确访问
	//ioctl读取数据，需要向用户空间写入数据
	if(_IOC_DIR(cmd) & _IOC_READ){
		err = !access_ok(VERIFY_WRITE,(void *)arg,_IOC_SIZE(cmd));
	}
	//ioctl设置数据，需要向用户空间读取数据
	else if(_IOC_DIR(cmd) & _IOC_WRITE){
		err = !access_ok(VERIFY_READ,(void *)arg,_IOC_SIZE(cmd));
	}
	if(err){
		return -EFAULT;
	}
	
	switch(cmd){
		case MEMDEV_IOCPRTDATA:
			printk("CMD MEMDEV_IOCPRTDATA DONE!!!!!\n");
			break;
		case MEMDEV_IOCSETDATA:
			ret = __get_user(ioarg,(int *)arg);
			printk("CMD MEMDEV_IOCGETDATA IS %d!!!!!\n",ioarg);
			break;
		case MEMDEV_IOCGETDATA:
			ioarg = 1101;
			ret = __put_user(ioarg,(int *)arg);
			break;
		default:
			return -EINVAL;
	}
	return ret;
}

static const struct file_operations fops = {
	.owner = THIS_MODULE,
	.open = mem_open,
	.release = mem_release,
	.unlocked_ioctl = mem_ioctl
};

static int __init mem_init(void)
{
	int ret;
	int i;
/***********************************************************************/
	ret = alloc_chrdev_region(&devno,BASEMINOR,COUNT,NAME);
	if(ret < 0){
		printk(KERN_ERR "alloc_chrdev_region failed...\n");
		goto err1;
	}
	//设备号申请成功打印出来
	printk(KERN_INFO "major = %d \n",MAJOR(devno));
/***********************************************************************/
	cdevp = cdev_alloc();
	if(NULL == cdevp){
		printk(KERN_ERR "cdev_alloc failed...\n");
		ret = -ENOMEM;
		goto err2;
		//cdev结构体申请失败需要将上一步申请到的设备号资源释放。
	}
/***********************************************************************/	
	cdev_init(cdevp,&fops);
/***********************************************************************/	
	ret = cdev_add(cdevp,devno,COUNT);
	if(ret < 0){
		printk(KERN_ERR "cdev_add failed...\n");
		goto err2;
	}
/***********************************************************************/
	//为memdev设备结构体分配内存
	memdevp = kmalloc(COUNT * sizeof(struct memdev),GFP_KERNEL);
	if(NULL == memdevp){
			printk(KERN_ERR "memdevp kmalloc failed...\n");
			ret = -ENOMEM;
			goto err2;
		}
	memset(memdevp,0,sizeof(struct memdev));

	//上一步申请的是一片空间，这一片空间里是COUNT个设备的总空间，需要为每一个设备分配空间
	for(i = 0;i<COUNT;i++){
		memdevp[i].data = kmalloc(MEMDEV_SIZE,GFP_KERNEL);
		memdevp[i].size = MEMDEV_SIZE;
		memset(memdevp[i].data,0,MEMDEV_SIZE);
	}

/***********************************************************************/
	printk(KERN_INFO "---%s---%s---%d---\n",__FILE__,__func__,__LINE__);
	return 0;
err2:
	unregister_chrdev_region(devno,COUNT);			//释放申请到的设备号资源
err1:
	return ret;
}

static void __exit mem_exit(void)
{
	cdev_del(cdevp);
	unregister_chrdev_region(devno,COUNT);			//释放申请到的设备号资源
	printk(KERN_INFO "---%s---%s---%d---\n",__FILE__,__func__,__LINE__);
}

module_init(mem_init);
module_exit(mem_exit);
MODULE_LICENSE("GPL");

ioctl_app源码资源！！！！！！！

#include <stdio.h>
#include <string.h>
#include <linux/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>

int main()
{
	int fd = 0;
	char buf[4096];
	int cmd;
	int arg = 0;
	
	fd = open("/dev/memdev_ioctl0",O_RDWR);
	if(fd < 0){
		printf("open memdev0 failed!!!\n");
		return -1;
	}
	
	//调用MEMDEV_IOCPRTDATA
	printf("调用MEMDEV_IOCPRTDATA   ing！！！！\n");
	cmd = _IO('j',1);
	if(ioctl(fd,cmd,&arg) < 0){
		printf("调用MEMDEV_IOCPRTDATA    failed！！！！\n");
		return -1;
	}
	
	//调用MEMDEV_IOCSETDATA
	printf("调用MEMDEV_IOCSETDATA   ing！！！！\n");
	cmd = _IOW('j',3,int);
	arg = 2007;
	if(ioctl(fd,cmd,&arg) < 0){
		printf("调用MEMDEV_IOCSETDATA    failed！！！！\n");
		return -1;
	}
	
	//调用MEMDEV_IOCGETDATA
	printf("调用MEMDEV_IOCGETDATA   ing！！！！\n");
	cmd = _IOR('j',2,int);
	if(ioctl(fd,cmd,&arg) < 0){
		printf("调用MEMDEV_IOCGETDATA    failed！！！！\n");
		return -1;
	}
	printf("调用MEMDEV_IOCGETDATA  is %d！！！！\n",arg);
	
	close(fd);
	
	return 0;
}

Makefile源码资源！！！！！！！


KERNDIR = /lib/modules/4.15.0-107-generic/build
PWD = $(shell pwd)

obj-m:=memdev_ioctl.o

all:
	make -C $(KERNDIR) M=$(PWD) modules
	
clean:
	make -C $(KERNDIR) M=$(PWD) clean
晩风与她
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Linux 字符设备驱动框架详细介绍
01-10
Linux 字符设备驱动框架 字符设备是Linux三大设备之一(另外两种是块设备，网络设备)，字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备，常见的字符设备包括鼠标、键盘、显示器、串口等等，当我们执行ls -l /dev的时候，就能看到大量的设备文件，c就是字符设备，b就是块设备，网络设备没有对应的设备文件。编写一个外部模块的字符设备驱动，除了要实现编写一个模块所需要的代码之外，还需要编写作为一个字符设备的代码。 驱动模型 Linux一切皆文件，那么作为一个设备文件，它的操作方法接口封装在struct file_operations，当我们写一个驱动的时候，一定要实现相应的
Linux内核设备驱动之高级字符设备驱动笔记整理
01-10
/****************** * 高级字符设备驱动 ******************/ (1)ioctl 除了读取和写入设备外，大部分驱动程序还需要另外一种能力，即通过设备驱动程序执行各种类型的硬件控制。比如弹出介质，改变波特率等等。这些操作通过ioctl方法支持，该方法实现了同名的系统调用。 在用户空间，ioctl系统调用的原型是： int ioctl(int fd, unsigned long cmd, …); fd: 打开的设备文件描述符 cmd: 命令 第三个参数：根据不同的命令，可以是整数或指针，也可以没有。 采用”…”的方式只是用于避免编译器报
ioctl_driver:有关如何编写Linux驱动程序的示例
05-13
IOCTL驱动程序 关于如何为Linux创建IOCTL驱动程序的简单示例。 这可以用于简单的测试目的： 从内核模式访问特殊寄存器以在用户模式下获得结果。 例如，CP15处理器的Arm寄存器。 访问某些内存映射区域 ... 此仓库包含以下文件夹： dev /：驱动程序源代码 ioctl_interface.c是驱动程序的源代码。 应该修改以添加更多IOCTL的功能 ioctl_dev.h是头文件 ioctl.h包含IOCTL代码列表。 该列表也包含在应用程序中 Makefile构建驱动程序。 如果驱动程序是交叉编译的，则应调整变量KDEV app /：应用程序源代码 ioctl_app.c显示了访问驱动程序并获取返回值的示例 Makefile来构建应用程序 load_driver.sh 加载驱动程序ioctl 。 这可能需要sudo权限！
简单的linux字符设备驱动代码
12-31
根据终端输入字符进行回显，可以通过ioctl来控制是否进行大小写转换！
linux 内核 - ioctl 函数详解
JCfyw的博客
05-02 2710
linux 内核 - ioctl 函数详解 1. 概念 ioctl 是设备驱动程序中设备控制接口函数，一个字符设备驱动通常会实现设备打开、关闭、读、写等功能，在一些需要细分的情境下，如果需要扩展新的功能，通常以增设 ioctl() 命令的方式实现。 在文件 I/O 中，ioctl 扮演着重要角色，本文将以驱动开发为侧重点，从用户空间到内核空间纵向分析 ioctl 函数。 2. 用户空间 ioctl #include <sys/ioctl.h> int ioctl(int fd, int cm
Linux设备驱动程序学习（五）——高级字符设备驱动程序
Alex_wu的博客
07-08 632
在前面我们学习了字符设备驱动程序的实现，但是不知道你们有没有注意到，在前面，我们只学习了open、close、read和write的方法实现，而对于iotctl和llseek并没有讲解，而这一部分，将讲解这两个方法的实现以及阻塞和非阻塞型I/O的一些相关知识。 定位设备 定位设备的方法：llseek llseek 方法实现了 lseek 和 llseek 系统调用，主要用来确定读写数据的位置。 ...
access_ok和get_user和put_user简介
wangkai6666的博客
06-27 609
access_ok access_ok() 用来代替老版本的 verify_area() 检查用户空间指针是否可用 函数原型： access_ok (type, addr, size); 变量说明： type : 访问类型，其值可为 VERIFY_READ 或 VERIFY_WRITE 。 addr : 用户空间的指针变量，指向一个要检查的内存块开始处。 size : 要检查内存块大小 注意： VERIFY_WRITE 是 VERIFY_READ 的超集 如果可以安全写内存块，那么
设备驱动与 ioctl 函数详细分析
个人笔记
03-14 1976
类 UNIX 操作系统将所有设备都看成文件 每个设备都对应一个文件，在内核中也有一个相应的索引结点 对文件操作的系统调用也适用于对设备文件的操作，例如 open() 设备文件逻辑空间是一个线性空间 ioctl 是设备驱动程序中对设备的 I/O 通道进行管理的函数，简言之就是对设备的一些特性进行管理，例如传感器的数据采集、串口波特率等等。 上图1清晰的表明了 ioctl 在各个层之间的调用关系...
access_ok函数
nullzxy的专栏
08-01 4502
access_ok | 检查用户空间内存块是否可用 access_ok() 函数是用来代替老版本的 verify_area() 函数的。它的作用也是检查用户空间指针是否可用。 函数原型： access_ok (type, addr, size); 变量说明： type  :   访问类型，其值可为 VERIFY_READ 或者 VERIFY_WRITE 。注意，V
chdev:Linux 字符设备驱动程序
06-27
Linux 字符设备驱动程序。 该驱动程序允许您使用固定大小的循环缓冲区。 chdev存储项目，例如，可以是字符串或任何其他类型的信息，以字节序列形式呈现。 尽管该驱动程序是为教育目的而编写的，但仍触及了 Linux ...
access_ok()
jrzero的专栏
07-28 1033
函数原型：access_ok (type, addr, size);变量说明：type   :   访问类型，其值可为 VERIFY_READ 或者 VERIFY_WRITE 。注意，VERIFY_WRITE 是 VERIFY_READ 的超集 -- 如果可以安全的写内存块，那么
Linux虚拟文件系统剖析： 文件打开、读、写逻辑
badman250的专栏
07-24 2500
                        Linux虚拟文件系统剖析： 文件打开、读、写逻辑 [email protected]   Linux文件系统剖析:文件打开操作 本文主要通过分析linux系统中的文件打开逻辑，来掌握linux虚拟文件系统相关的数据结构、函数等知识点，将之前的各个点的知识串联成一个整体。 系统中给所有文件系统不但依赖VFS,而且...
使用cat读取和echo写内核文件节点的一些问题
weixin_34161083的博客
12-09 868
作者 [email protected] 彭东林   平台 busybox-1.24.2 Linux-4.10.17 Qemu+vexpress-ca9   概述 在写驱动的时候，我们经常会向用户空间导出一些文件，然后用户空间使用cat命令去读取该节点，从而完成kernel跟user的通信。但是有时会发现，如果节点对应的read回调函数写的有问题的话，使用ca...
操作系统学习-3.Linux文件系统学习1-初始化和read、write过程分析
djhsws的专栏
10-21 518
初始化和read、write过程分析整体框架图vfs系统类关系图vfs层次关系通初始化过程文件read流程分析文件read和BIO调度分析文件write过程分析 整体框架图 vfs系统类关系图 vfs层次关系通 初始化过程 在内核启动的主函数中 start_kernel() { vfs_caches_init_early(); vfs_caches_init(); rest_init(); } rest_init() { kernel_init(); } kernel_init() {
linux 2.6.11内核文件IO的系统调用实现分析(read,write)（转载）
alanqk7的专栏
08-19 651
<br />6.         read 函数<br /> 6.1.         原型与参数<br /><br /> ssize_t read(unsigned int fd, char * buf, size_t count)<br />          read函数是从打开的文件中读取数据。如read成功，则返回读到的字节数。如已到达文件的尾端，则返回0。如果失败，则返回－1。有多种情况可使实际读到的字节数少于要求读字节数：<br /> • 读普通文件时，在读到要求字节数之前已到达了文件
access_ok()函数介绍
weixin_42031299的博客
05-05 1482
access_ok()函数 //函数原型 int access_ok(int type, const void __user *addr, unsigned long size)； (1)返回值：布尔值，1表示成功，0表示失败； (2)type:检查用户空间地址的权限；VERIFY_READ或者VERIFY_WRITE； <1>VERIFY_READ：驱动是否可以读取用户空间的指定地址； <2>VERIFY_WRITE：驱动是否可以读取用户空间的指定地址； <3>VE
嵌入式Linux 字符设备驱动标准ioctl接口
Lushengshi的博客
03-27 1345
write:往设备写中写数据，单独这个接口并不能满足现实设备的全部控制需求。一个lcd控制器：主要作用就是驱动lcd屏，要显示就是通过write接口把显示数据发给lcd控制器指定的显存。而参数设置类通过write接口设置就可能会和普通的显示数据弄混乱了。为了解决这个问题，内核提供了ioctl接口专门对设备控制（参数设置，参数查询等功能）。ioctl主要用于实现对硬件设备控制类操作，使用write和read不太好实现的功能。
字符设备ioctl接口详解
weixin_42031299的博客
05-04 1743
1、为什么要引入ioctl接口? (1)读写操作只是很基础的功能，有的设备需要支持另外的命令去控制；比如串口需要提供设置波特率、数据位、终止位等操作； (2)如果不同的命令操作，都在write和read中去做判断，对于支持命令比较多的设备，那write和read函数就会很大，不利于维护； (3）ioctl函数是专门用来处理上层发给驱动程序的命令，设备有需要就去实现，如果没有需要就不实现这个函数，将函数指针赋值为NULL； 2、应用层系统调用 #include <sys/ioctl.h> /
Linux字符设备驱动开发步骤
最新发布
05-30
开发Linux字符设备驱动的步骤如下： 1. 确定设备的主设备号和次设备号； 2. 创建设备文件； 3. 实现 file_operations 结构体中的各个函数，如 open、read、write、ioctl 等； 4. 实现字符设备驱动的初始化函数和卸载函数； 5. 在驱动初始化函数中调用 register_chrdev 或者 alloc_chrdev_region 函数注册字符设备驱动； 6. 在驱动卸载函数中调用 unregister_chrdev 或者 unregister_chrdev_region 函数注销字符设备驱动； 7. 在驱动初始化函数中创建设备类和设备节点； 8. 在驱动卸载函数中销毁设备节点和设备类； 9. 在驱动中实现对设备的控制和管理。 以上是开发Linux字符设备驱动的基本步骤，具体实现方式和细节视具体情况而定。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值