linux 高级字符设备驱动 ioctl操作介绍 例程分析实现

最新推荐文章于 2023-03-25 21:28:28 发布
最新推荐文章于 2023-03-25 21:28:28 发布
阅读量161 收藏
点赞数
原文链接：https://my.oschina.net/u/274829/blog/285014
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1，ioctl介绍

ioctl控制设备读写数据以及关闭等。

用户空间函数原型：int ioctl(int fd,unsinged long cmd,...)

  • fd-文件描述符

  • cmd-对设备的发出的控制命令

  • ...表示这是一个可选的参数，存在与否依赖‍‍于cmd，如cmd为修改波特率，那么....就表示波特率的值。如果cmd表示关闭，则不需要参数

内核函数原型‍‍

file_operations结构体里面long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);


ioctl命令段分为：类型，序号，传递方向，参数大小

  • Type 类型：表明哪个设备的命令，在参考了ioctl-number.txt之后选出，8位宽

  • Number 序号：表明设备命令中的第几个，8位宽

  • Direction 传送方向：可能的值是

    _IOC_NONE(没数据传输)

    _IOC_READ(从设备读)

    _IOC_WRITE

  • Size 用户参数大小:（13/14位宽，视处理器而定）

内核提供了一些宏来帮助定义命令：

  • _IO(type, nr )    type为命令类型  如int， nr为序号

    没有参数的命令

  • _IOR(type, nr, datatype)  

        从驱动中读数据，datatype 读的数据参数的类型

  • _IOW(type, nr, datatype)

        写数据到驱动

  • _IOWR(type,nr, datatype)

        读写数据

定义命令例子  #define MEM_IOC_MAGIC 'm'   //定义幻数，因为命令类型type是8位的所以找个字符代替

#define MEM_IOCSET

_IOW(MEM_IOC_MAGIC,0,int)   //命令 去写 一个 int型的数据

#define MEM_IOCGQSET

_IOR(MEM_IOC_MAGIC, 1, int)


2，ioctl命令使用时注意事项

用户使用int ioctl(int fd,unsinged long cmd,...)时，...就是要传递的参数

再通过long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long arg);中的arg传递,如果arg是一个整形，可以直接使用，如果是指针，我们必须确保这个用户地址是有效的，因此，使用之前需要进行正解的检查。

内部有检查的，不需要检测的：

Copy_from_user

Copy_to_user

Get_user

Put_user

需要检测的：

__get_user

__put_user

使用int access_ok(int type, const void *addr, unsigned long size)检测

Type 是VERIFY_READ 或者VERIFY_WRITE用来表明是读用户内存还是写用户内存。

Addr参数是要操作的用户内存地址，size是操作的长度。如果ioctl需要从用户空间读一个整数，那么size参数就等于sizeof(int)

172959_l0fp_274829.png

内核读，写入用户空间，所以用户空间使用VERIFY_WRITE写验证用户内存是否可用。

Access_ok返回一个布尔值：1，是成功（存取没问题），失败，ioctr返回-EFAULT 


3，ioctl实现例程

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#include "memdev.h"

static int mem_major = MEMDEV_MAJOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp; /*设备结构体指针*/

struct cdev cdev; 

/*文件打开函数*/
int mem_open(struct inode *inode, struct file *filp)
{
    struct mem_dev *dev;
    
    /*获取次设备号*/
    int num = MINOR(inode->i_rdev);

    if (num >= MEMDEV_NR_DEVS) 
            return -ENODEV;
    dev = &mem_devp[num];
    
    /*将设备描述结构指针赋值给文件私有数据指针*/
    filp->private_data = dev;
    
    return 0; 
}

/*文件释放函数*/
int mem_release(struct inode *inode, struct file *filp)
{
  return 0;
}

/*IO操作*/
int memdev_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{

    int err = 0;
    int ret = 0;
    int ioarg = 0;
    
    /* 检测命令的有效性 */
    if (_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC) 
        return -EINVAL;
    if (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR) 
        return -EINVAL;

    /* 根据命令类型，检测参数空间是否可以访问 */
    if (_IOC_DIR(cmd) & _IOC_READ)
        err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
    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_IOCPRINT:
      	printk("<--- CMD MEMDEV_IOCPRINT Done--->\n\n");
        break;
      
      /* 获取参数 */
      case MEMDEV_IOCGETDATA: 
        ioarg = 1101;
        ret = __put_user(ioarg, (int *)arg);
        break;
      
      /* 设置参数 */
      case MEMDEV_IOCSETDATA: 
        ret = __get_user(ioarg, (int *)arg);
        printk("<--- In Kernel MEMDEV_IOCSETDATA ioarg = %d --->\n\n",ioarg);
        break;

      default:  
        return -EINVAL;
    }
    return ret;

}

/*文件操作结构体*/
static const struct file_operations mem_fops =
{
  .owner = THIS_MODULE,
  .open = mem_open,
  .release = mem_release,
  .ioctl = memdev_ioctl,
};

/*设备驱动模块加载函数*/
static int memdev_init(void)
{
  int result;
  int i;

  dev_t devno = MKDEV(mem_major, 0);

  /* 静态申请设备号*/
  if (mem_major)
    result = register_chrdev_region(devno, 2, "memdev");
  else  /* 动态分配设备号 */
  {
    result = alloc_chrdev_region(&devno, 0, 2, "memdev");
    mem_major = MAJOR(devno);
  }  
  
  if (result < 0)
    return result;

  /*初始化cdev结构*/
  cdev_init(&cdev, &mem_fops);
  cdev.owner = THIS_MODULE;
  cdev.ops = &mem_fops;
  
  /* 注册字符设备 */
  cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
   
  /* 为设备描述结构分配内存*/
  mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
  if (!mem_devp)    /*申请失败*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  memset(mem_devp, 0, sizeof(struct mem_dev));
  
  /*为设备分配内存*/
  for (i=0; i < MEMDEV_NR_DEVS; i++) 
  {
        mem_devp[i].size = MEMDEV_SIZE;
        mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
        memset(mem_devp[i].data, 0, MEMDEV_SIZE);
  }
    
  return 0;

  fail_malloc: 
  unregister_chrdev_region(devno, 1);
  
  return result;
}

/*模块卸载函数*/
static void memdev_exit(void)
{
  cdev_del(&cdev);   /*注销设备*/
  kfree(mem_devp);     /*释放设备结构体内存*/
  unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
}

MODULE_AUTHOR("David Xie");
MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

.h

#ifndef _MEMDEV_H_
#define _MEMDEV_H_

#include <linux/ioctl.h>

#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 190   /*预设的mem的主设备号*/
#endif

#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 2    /*设备数*/
#endif

#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif

/*mem设备描述结构体*/
struct mem_dev                                     
{                                                        
  char *data;                      
  unsigned long size;       
};

/* 定义幻数 */
#define MEMDEV_IOC_MAGIC  'k'

/* 定义命令 */
#define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC, 1)
#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)
#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)

#define MEMDEV_IOC_MAXNR 3

#endif /* _MEMDEV_H_ */

Makefile

ifneq ($(KERNELRELEASE),)

obj-m := memdev.o

else
	
KDIR := /forlinux/linux-3.0.1
all:
	make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*

endif

测试程序

#include <stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

#include "memdev.h"  /* 包含命令定义 */

int main()
{
	int fd = 0;
	int cmd;
	int arg = 0;
	char Buf[4096];
	
	
	/*打开设备文件*/
	fd = open("/dev/memdev0",O_RDWR);
	if (fd < 0)
	{
		printf("Open Dev Mem0 Error!\n");
		return -1;
	}
	
	/* 调用命令MEMDEV_IOCPRINT */
	printf("<--- Call MEMDEV_IOCPRINT --->\n");
	cmd = MEMDEV_IOCPRINT;
	if (ioctl(fd, cmd, &arg) < 0)
        {
        	printf("Call cmd MEMDEV_IOCPRINT fail\n");
        	return -1;
	}
	
	
	/* 调用命令MEMDEV_IOCSETDATA */
	printf("<--- Call MEMDEV_IOCSETDATA --->\n");
	cmd = MEMDEV_IOCSETDATA;
	arg = 2007;
	if (ioctl(fd, cmd, &arg) < 0)
        {
        	printf("Call cmd MEMDEV_IOCSETDATA fail\n");
        	return -1;
	}

	
	/* 调用命令MEMDEV_IOCGETDATA */
	printf("<--- Call MEMDEV_IOCGETDATA --->\n");
	cmd = MEMDEV_IOCGETDATA;
	if (ioctl(fd, cmd, &arg) < 0)
        {
        	printf("Call cmd MEMDEV_IOCGETDATA fail\n");
        	return -1;
	}
	printf("<--- In User Space MEMDEV_IOCGETDATA Get Data is %d --->\n\n",arg);	
	
	close(fd);
	return 0;	
}


转载于:https://my.oschina.net/u/274829/blog/285014

weixin_33979745
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LINUX设备驱动第三版_588及代码.rar
08-26
第六章 高级字符驱动程序操作 ioctl 阻塞型I/O poll和select 异步通知 定位设备 设备文件的访问控制 快速参考 第七章 时间、延迟及延缓操作 度量时间差 获取当前时间 延迟执行 内核定时器 tasklet ...
（八）linux驱动之ioctl的使用
水枂的博客
04-01 2539
这篇文章给大家讲解一下ioctl的简单使用，关于ioctl更详细的教程后面有机会单独写出来 （一）什么是ioctl ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速、网卡速率等等。它的调用方式如下： //在应用调用 int ioctl(int fd, int cmd, …)； 其中fd是用户程...
Linux字符设备驱动（设备文件，用户空间与内核空间进行数据交互，ioctl接口）
qq_53221728的博客
03-25 1717
设备文件的两种创建方式，用户空间怎么与内核空间进行数据交互，字符设备驱动ioctl接口是什么，本文一键搞定。
Linux设备驱动第六篇：高级字符驱动操作之iotcl
weixin_34138377的博客
07-24 169
为什么80%的码农都做不了架构师？>>> ...
linux设备驱动之ioctl控制
lincuiting06的专栏
12-11 2984
大部分驱动除了具有读写的能力之外，还需要具有对硬件控制的能力。一。用户空间：ioctl 用户程序使用ioctl系统调用来控制设备。用户程序只是通过命令码告诉驱动程序想做什么，至于怎么解释这些命令和怎么实现这些命令，这都是驱动程序要做的事情。 函数原型：int ioctl(int fd, unsigned long cmd, …); 参数解析：fd：打开的文件描述符
高级IO操作—ioctl设备操作
Half-up的博客
05-12 2123
为了处理设备非数据的操作(这些可以通过read、write接口来实现),内核将对设备的控制操作委派给了ioctl接口，ioctl 也是一个系统调用，其函数原型如下。 int ioctl(int d,int request,...); d是要操作文件的文件描述符，request 是代表不同操作的数字值，比如驱动可以规定0x12345678表示点灯，而0x12345679表示灭灯等。但是这个操作码，更确切地说是命令，应该具有一定的编码规则，这个我们在后面会介绍。...表示C语言中实参个数可变的.但在这里表示的
Linux DeviceDrivers 3rd Edition
07-23
第六章 高级字符驱动程序操作 137 ioctl 137 阻塞型I/O 149 poll和select 163 异步通知 168 定位设备 172 设备文件的访问控制 173 快速参考 179 第七章 时间、延迟及延缓操作 183 度量时间差 183 获取当前...
内核驱动之ioctl接口的实现
做一个有技术追求的人
11-22 3086
大部分驱动需要 -- 除了读写设备的能力 -- 通过设备驱动进行各种硬件控制的能力. 大部分设备可进行超出简单的数据传输之外的操作; 用户空间必须常常能够请求, 例如, 设备锁上它的门, 弹出它的介质, 报告错误信息, 改变波特率, 或者自我销毁. 这些操作常常通过 ioctl 方法来支持, 它通过相同名子的系统调用来实现. 在用户空间, ioctl 系统调用有下面的原型: i
ioctl 的使用方法详细说明与例子
热门推荐
Java鸟
08-17 1万+
Talking To Device Files 与设备文件对话 (writes and IOCTLs) 设备文件是用来代表相对应的硬件设备。绝大多数的硬件设备是用来进行输出和输入操作的，所以在内核中肯定有内核从进程中获得发送到设备的输出的机制。这是通过打开一个设备文件然后向其中进行写操作来实现的，如同对普通文件的写操作。在下面的的例子中，这是通过 device_write实现的。 但这并
Linux之设备控制接口(ioctl)
风间琉璃的博客
09-22 2928
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。对I/O通道进行管理，就是对设备的一些特性进行控制。虽然在文件操作结构体struct file_operations中有很多对应的设备操作函数，但是有些命令是实在找不到对应的操作函数,拓展一些file_operations给出的接口中没有的自定义功能，则需要使用到ioctl()函数。如CD-ROM的驱动，想要一个弹出光驱的操作，这种操作并不是所有的字符设备都需要的，所以文件操作结构体也不会有对应的函数操作。
设备IO控制操作 之 直接内存模式IOCTL
weixin_33922670的博客
11-19 136
在调用DeviceIoControl时，应用层的输入缓冲区的内容被复制到IRP中的Irp-&gt;AssociatedIrp.SystemBuffer内存地址中。这个步骤和缓冲区模式IOCTL处理一样。   但是，对于DeviceIoControl指定的输出缓冲区的处理，操作系统将该缓冲区锁定，然后在内核模式地址空间中重新映射一段地址。   在驱动程序中，METHOD_IN_DIREC...
【深入理解IOCTL】
HardessGod的博客
02-08 2347
深入理解IOCTL 一、 什么是ioctl ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数如下： int ioctl(int fd, ind cmd, …)；其中fd就是用户程序打开设备时使用open函数返回的文件标示符，cmd就是用户程序对设备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，有或没有是和cmd的意义相关的。 ioctl函数是文件结构中的一个属性分量，就是说
ioctl设备控制
tong646591的专栏
12-13 597
ioctl方法介绍： 大部分驱动除了需要具备读写设备 的能力外,还需要具备对硬件控制的能力。例如,要求设备报告错误信息, 改变波特率,这些操作常常通过 ioctl方法来实现。 在用户空间，使用ioctl系统调用来控制设备，原型 如下: int ioctl(int fd,unsigned long cmd,...) 原型中的点表示这是一个可选的参数，存在与否依赖于控制命令(第 2个参数 )是
Linux设备驱动之Ioctl控制
XboxMicro
10-27 590
http://www.cnblogs.com/geneil/archive/2011/12/04/2275372.html
ioctl--字符设备的控制技术【转】
01-06 155
本文转载自：http://blog.csdn.net/coding__madman/article/details/51356313 字符设备的控制 1. 字符设备控制理论 1.1 作用 大部分驱动程序除了需要提供读写设备的能力外，还需要具备控制设备的能力。比如：改变波特率 1.2 应用程序接口 在用户空间，使用ioct...
ioctl控制设备
健身房
07-26 142
  memdev.c如下： #include <linux/module.h> #include <linux/types.h> #include <linux/fs.h> #include <linux/errno.h> #include <linux/mm.h> #include <linux/sched.h> #include <linux/init.h> #include <linux/cdev.h> #
Linux嵌入式驱动开发13——ioctl接口（gpio控制使用）
szembed的博客
09-19 1272
unlocked_ioctl就是ioctl接口，但是功能和对应的系统调用均没有发生变化。
Linux字符设备---ioctl详细解析
精诚所至
05-08 1855
一、 什么是ioctl ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。下面是其源代码定义： 函数名: ioctl 功 能: 控制I/O设备 用 法: int ioctl(int handle, int cmd,[int *argdx, int argcx]); 参...
Linux字符设备驱动开发步骤
最新发布
05-30
开发Linux字符设备驱动的步骤如下： 1. 确定设备的主设备号和次设备号； 2. 创建设备文件； 3. 实现 file_operations 结构体中的各个函数，如 open、read、write、ioctl 等； 4. 实现字符设备驱动的初始化函数和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值