[宏]_IO, _IOR, _IOW, _IOWR 宏的用法与解析

在驱动程序里， ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值。cmd除了可区别数字外，还包含有助于处理的几种相应信息。 cmd的大小为 32位，共分 4 个域：

bit31~bit30 2位为 “区别读写” 区，作用是区分是读取命令还是写入命令。

bit29~bit15 14位为 "数据大小" 区，表示 ioctl() 中的 arg 变量传送的内存大小。

bit20~bit08 8位为 “魔数"(也称为"幻数")区，这个值用以与其它设备驱动程序的 ioctl 命令进行区别。

bit07~bit00 8位为 "区别序号" 区，是区分命令的命令顺序序号。

像命令码中的 “区分读写区” 里的值可能是 _IOC_NONE （0值）表示无数据传输，_IOC_READ (读)， _IOC_WRITE (写) ， _IOC_READ|_IOC_WRITE (双向)。

内核定义了 _IO() , _IOR() , IOW() 和 _IOWR() 这 4 个宏来辅助生成上面的 cmd 。下面分析 _IO() 的实现，其它的类似。

在 asm-generic/ioctl.h 里可以看到 _IO() 的定义：

#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)

再看 _IOC() 的定义：

#define _IOC(dir,type,nr,size) \
    (((dir) << _IOC_DIRSHIFT) | \
     ((type) << _IOC_TYPESHIFT) | \
     ((nr)   << _IOC_NRSHIFT) | \
     ((size) << _IOC_SIZESHIFT))

可见，_IO() 的最后结果由 _IOC() 中的 4 个参数移位组合而成。

再看 _IOC_DIRSHIT 的定义：

#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)

_IOC_SIZESHIFT 的定义：

#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)

_IOC_TYPESHIF 的定义：

#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)

_IOC_NRSHIFT 的定义：

#define _IOC_NRSHIFT 0

_IOC_NRBITS 的定义：

#define _IOC_NRBITS 8

_IOC_TYPEBITS 的定义：

#define _IOC_TYPEBITS 8

由上面的定义，往上推得到：

_IOC_TYPESHIFT = 8
_IOC_SIZESHIFT = 16
_IOC_DIRSHIFT = 30

所以， (dir) << _IOC_DIRSHIFT) 表是 dir 往左移 30 位，即移到 bit31~bit30 两位上，得到方向(读写)的属性；
             (size) << _IOC_SIZESHIFT) 位左移 16 位得到“数据大小”区；
             (type) << _IOC_TYPESHIFT) 左移 8位得到"魔数区" ；
            (nr)   << _IOC_NRSHIFT)       左移 0 位( bit7~bit0) 。

这样，就得到了 _IO() 的宏值.

这几个宏的使用格式为：

_IO (魔数，基数);
_IOR (魔数，基数，变量型)
_IOW (魔数，基数，变量型)

_IOWR (魔数，基数，变量型 )
魔数 (magic number)
魔数范围为 0~255 。通常，用英文字符 "A" ~ "Z" 或者 "a" ~ "z" 来表示。设备驱动程序从传递进来的命令获取魔数，然后与自身处理的魔数想比较，如果相同则处理，不同则不处理。魔数是拒绝误使用的初步辅助状态。设备驱动程序可以通过 _IOC_TYPE (cmd) 来获取魔数。不同的设备驱动程序最好设置不同的魔数，但并不是要求绝对，也是可以使用其他设备驱动程序已用过的魔数。

基(序列号)数
基数用于区别各种命令。通常，从 0开始递增，相同设备驱动程序上可以重复使用该值。例如，读取和写入命令中使用了相同的基数，设备驱动程序也能分辨出来，原因在于设备驱动程序区分命令时使用 switch ，且直接使用命令变量 cmd值。创建命令的宏生成的值由多个域组合而成，所以即使是相同的基数，也会判断为不同的命令。设备驱动程序想要从命令中获取该基数，就使用下面的宏：
_IOC_NR (cmd)
通常，switch 中的 case 值使用的是命令的本身。
变量型
变量型使用 arg 变量指定传送的数据大小，但是不直接代入输入，而是代入变量或者是变量的类型，原因是在使用宏创建命令，已经包含了 sizeof() 编译命令。比如 _IOR() 宏的定义是：
引用
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
而 _IOC_TYPECHECK() 的定义正是：
引用
#define _IOC_TYPECHECK(t) (sizeof(t))

设备驱动程序想要从传送的命令获取相应的值，就要使用下列宏函数：
_IOC_SIZE(cmd)

_IO 宏
该宏函数没有可传送的变量，只是用于传送命令。例如如下约定：

引用
#define TEST_DRV_RESET _IO ('Q', 0)

此时，省略由应用程序传送的 arg 变量或者代入 0 。在应用程序中使用该宏时，比如：

ioctl (dev, TEST_DEV_RESET, 0) 或者 ioctl (dev, TEST_DRV_RESET) 。

这是因为变量的有效因素是可变因素。只作为命令使用时，没有必要判断出设备上数据的输出或输入。因此，设备驱动程序没有必要执行设备文件大开选项的相关处理。

_IOR 宏
该函数用于创建从设备读取数据的命令，例如可如下约定：
引用
#define TEST_DEV_READ _IRQ('Q', 1, int)
这说明应用程序从设备读取数据的大小为 int 。下面宏用于判断传送到设备驱动程序的 cmd 命令的读写状态：
_IOC_DIR (cmd)

运行该宏时，返回值的类型如下：

_IOC_NONE : 无属性
_IOC_READ : 可读属性
_IOC_WRITE : 可写属性
_IOC_READ | _IOC_WRITE : 可读，可写属性
使用该命令时，应用程序的 ioctl() 的 arg 变量值指定设备驱动程序上读取数据时的缓存(结构体)地址。

_IOW 宏
用于创建设备上写入数据的命令，其余内容与 _IOR 相同。通常，使用该命令时，ioctl() 的 arg 变量值指定设备驱动程序上写入数据时的缓存(结构体)地址。

_IOWR 宏
用于创建设备上读写数据的命令。其余内容与 _IOR 相同。通常，使用该命令时，ioctl() 的 arg 变量值指定设备驱动程序上写入或读取数据时的缓存 (结构体) 地址。

_IOR() , _IOW(), IORW() 的定义：
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))

这几个宏的使用格式为：

_IO (魔数，基数);
_IOR (魔数，基数，变量型)
_IOW (魔数，基数，变量型)

变量型
变量型使用 arg 变量指定传送的数据大小，但是不直接代入输入，而是代入变量或者是变量的类型，原因是在使用宏创建命令，已经包含了 sizeof() 编译命令。比如 _IOR() 宏的定义是：

引用
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))

而 _IOC_TYPECHECK() 的定义正是：

引用
#define _IOC_TYPECHECK(t) (sizeof(t))

设备驱动程序想要从传送的命令获取相应的值，就要使用下列宏函数：
_IOC_SIZE(cmd)

--------------------------------------------------------------------------------

_IO 宏
该宏函数没有可传送的变量，只是用于传送命令。例如如下约定：

引用
#define TEST_DRV_RESET _IO ('Q', 0)

此时，省略由应用程序传送的 arg 变量或者代入 0 。在应用程序中使用该宏时，比如：

ioctl (dev, TEST_DEV_RESET, 0) 或者 ioctl (dev, TEST_DRV_RESET) 。

_IOR 宏
该函数用于创建从设备读取数据的命令，例如可如下约定：

引用
#define TEST_DEV_READ _IRQ('Q', 1, int)

这说明应用程序从设备读取数据的大小为 int 。下面宏用于判断传送到设备驱动程序的 cmd 命令的读写状态：
_IOC_DIR (cmd)

运行该宏时，返回值的类型如下：

大部分驱动除了需要具备读写设备的能力之外，还需要具备对硬件控制的能力。

　一、在用户空间，使用ioctl系统调用来控制设备，原型如下：

int ioctl(int fd,unsigned long cmd,...);
/*
fd:文件描述符
cmd:控制命令
...:可选参数:插入*argp，具体内容依赖于cmd
*/

　　用户程序所作的只是通过命令码告诉驱动程序它想做什么，至于怎么解释这些命令和怎么实现这些命令，这都是驱动程序要做的事情。

二、驱动ioctl方法：

int (*ioctl) (struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg);
/*
inode与filp两个指针对应于应用程序传递的文件描述符fd，这和传递open方法的参数一样。
cmd 由用户空间直接不经修改的传递给驱动程序
arg 可选。
*/

　　在驱动程序中实现的ioctl函数体内，实际上是有一个switch {case}结构，每一个case对应一个命令码，做出一些相应的操作。怎么实现这些操作，这是每一个程序员自己的事情，因为设备都是特定的。关键在于怎么样组织命令码，因为在ioctl中命令码是唯一联系用户程序命令和驱动程序支持的途径。

　　在Linux核心中是这样定义一个命令码的：
____________________________________

| 设备类型 | 序列号 | 方向 | 数据尺寸 |

|----------|--------|------|-------- |

| 8 bit　　 | 8 bit | 2 bit |8~14 bit|

|----------|--------|------|-------- |

　　这样一来，一个命令就变成了一个整数形式的命令码。但是命令码非常的不直观，所以linuxKernel中提供了一些宏，这些宏可根据便于理解的字符串生成命令码，或者是从命令码得到一些用户可以理解的字符串以标明这个命令对应的设备类型、设备序列号、数据传送方向和数据传输尺寸。

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

//nr为序号，datatype为数据类型,如int
_IO(type, nr ) //没有参数的命令
_IOR(type, nr, datatype) //从驱动中读数据
_IOW(type, nr, datatype) //写数据到驱动
_IOWR(type,nr, datatype) //双向传送

　　定义命令例子:

#define MEM_IOC_MAGIC 'm' //定义类型
#define MEM_IOCSET _IOW(MEM_IOC_MAGIC,0,int)
#define MEM_IOCGQSET _IOR(MEM_IOC_MAGIC, 1, int)

2、实现命令：
　　定义好了命令，下一步就是要实现ioctl函数了，ioctl的实现包括三个技术环节：
1）返回值；
　　ioctl函数的实现是根据命令执行的一个switch语句，但是，当命令不能匹配任何一个设备所支持的命令时，通常返回-EINVAL(非法参数)；
2）参数使用；
　　用户使用　　int ioctl(int fd,unsinged long cmd,...)　　时，...就是要传递的参数；
　　再通过　　int (*ioctl)(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)　　中的arg传递；
　　如果arg是一个整数，可以直接使用；
　　如果是指针，我们必须确保这个用户地址是有效的，因此，使用之前需要进行正确检查。
　　内部有检查的，不需要检测的：

copy_from_user
copy_to_user
get_user
put_user

　　需要检测的：

__get_user
__put_user

　检测函数access_ok（）:

static inline int access_ok(int type, const void *addr, unsigned long size)
/*
type :是VERIFY_READ 或者VERIFY_WRITE用来表明是读用户内存还是写用户内存;
addr:是要操作的用户内存地址;
size:是操作的长度。如果ioctl需要从用户空间读一个整数，那么size参数就等于sizeof(int)；返回值：Access_ok返回一个布尔值：1，是成功（存取没问题）；0，是失败，ioctl返回-EFAULT；*/

3）命令操作；

switch(cmd)
{case:... ...
}

三、ioctl实例分析：

（1）memdev.h：

View Code

#ifndef _MEMDEV_H_
#define _MEMDEV_H_#include <linux/ioctl.h>#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 0   /*预设的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_ */

（2）memdev.c：（驱动程序）

View Code

#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);

(3)app-ioctl.c（应用程序）

#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;
}------------------------------------------------------------------------------------------
需要root權限
Makefile:
ifneq ($(KERNELRELEASE),)
obj -m := memdev.o
else
KERNELDIR := /lib/modules/$(shell uname -r)/build
PWD :=$(shell pwd)
default:make -C $(KERNELDIR) SUBDIRS=$(PWD) modules
.PHONY : clean
clean:rm -f *.ko *mod* *.o *.symvers *.orer
endif
---------------------------------------------------------------------------------------------
測試(sudo)
insmod memdev.ko
mknod /dev/memdev0 c yourmajor youminor  可以在驅動中用宏MAJOR來打印

1.传入指针需要检查安全性。memcpy函数尽量不要在内核中使用。

2.copy_to_user.copy_from_user.get_user.put_user函数会再拷贝数据前检测指针的安全性。不需要access_ok。

3.如果在ioctl函数开头使用了accsee_ok检验数据，接下来的代码可以使用__put_user或__get_user这些不需要检测的函数（书上有例子）

文章来自：http://blog.csdn.net/luobin1984/article/details/8601859

[宏]_IO, _IOR, _IOW, _IOWR 宏的用法与解析相关推荐

驱动中有关ioctl[宏]_IO, _IOR, _IOW, _IOWR 宏的用法与解析
在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有助于处理的几种相应信息. cmd的大小为 32位,共分 4 个 ...
_IO, _IOR, _IOW, _IOWR 宏用法解析
_IO, _IOR, _IOW, _IOWR 宏的用法与解析在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有 ...
linux 内核驱动编程简单例子与_IO, _IOR, _IOW, _IOWR 宏解析
一._IO, _IOR, _IOW, _IOWR 宏的用法与解析在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包 ...
转：linux内核驱动中_IO, _IOR, _IOW, _IOWR 宏的用法与解析
在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有助于处理的几种相应信息. cmd的大小为 32位,共分 4 个 ...
Linux内核中_IO,_IOR,_IOW,_IOWR宏的用法与解析
在驱动程序里, ioctl()函数上传送的变量 cmd是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有助于处理的几种相应信息. cmd的大小为 32位,共分 4 个域: ...
linux内核驱动中_IO, _IOR, _IOW, _IOWR 宏的用法与解析
在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有助于处理的几种相应信息. cmd的大小为 32位,共分 4 个 ...
Linux中_IO,_IOR,_IOW,_IOWR宏的使用
在驱动程序里, ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.cmd除了可区别数字外,还包含有助于处理的几种相应信息. cmd的大小为 32位,共分 4 个 ...
_IO(), _IOR(), _IOW(), _IOWR() 宏的用法与解析
在Linux驱动程序里, ioctl() 函数上传送的 cmd 是应用程序用于区别设备驱动程序请求处理内容的值.在Linux里面应用了很多宏来定义,我在这里只是翻译成简单易懂的,直接用数字代替宏. 这 ...
_IO, _IOR, _IOW, _IOWR 宏的用法
_IO (魔数, 基数); _IOR (魔数, 基数, 变量型) _IOW (魔数, 基数, 变量型) _IOWR (魔数, 基数,变量型 ) 魔数 (magic number) 魔数范围为 0~25 ...

[宏]_IO, _IOR, _IOW, _IOWR 宏的用法与解析

[宏]_IO, _IOR, _IOW, _IOWR 宏的用法与解析相关推荐

最新文章

热门文章