设备Ioctl控制

来源：互联网发布：js的形参和实参编辑：程序博客网时间：2024/04/28 20:16

1.ioctl的功能

大部分驱动除了需要具备读写设备的能力外,还需要具备对硬件控制的能力。例如,要求设备报告错误信息,改变波特率,这些操作常常通过ioctl方法来实现。

用户使用方法

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

int ioctl(int fd,unsigned long cmd,...)

原型中的点表示这是一个可选的参数，存在与否依赖于控制命令(第 2 个参数 )是否涉及到与设备的数据交互。

驱动ioctl方法

ioctl 驱动方法有和用户空间版本不同的原型:

int(*ioctl)(struct inode*inode,struct file *filp,unsignedint cmd,unsignedlong arg)

cmd参数从用户空间传下来,可选的参数 arg 以一个unsigned long 的形式传递,不管它是一个整数或一个指针。如果cmd命令不涉及数据传输，则第 3 个参数arg的值无任何意义。

2. Ioctl实现

如何实现Ioctl方法?

步骤: 1.定义命令 2.实现命令

2.1定义命令

在编写ioctl代码之前，首先需要定义命令。为了防止对错误的设备使用正确的命令，命令号应该在系统范围内是唯一的。ioctl 命令编码被划分为几个位段，include/asm/ioctl.h中定义了这些位字段：类型（幻数），序号，传送方向，参数的大小。Documentation/ioctl-number.txt文件中罗列了在内核中已经使用了的幻数。

定义 ioctl 命令的正确方法是使用 4 个位段, 这个列表中介绍的符号定义在<linux/ioctl.h>中:

vType : 幻数(类型): 表明哪个设备的命令,在参考了 ioctl-number.txt之后选出，8 位宽。

vNumber: 序号，表明设备命令中的第几个,8 位宽。

vDirection: 数据传送的方向，可能的值是 _IOC_NONE(没有数据传输), _IOC_READ, _IOC_WRITE。数据传送是从应用程序的观点来看待的，_IOC_READ意思是从设备读。

vSize: 用户数据的大小。（13/14位宽，视处理器而定）

内核提供了下列宏来帮助定义命令:

v_IO(type，nr) 没有参数的命令

v_IOR(type，nr，datatype) 从驱动中读数据

v_IOW(type，nr，datatype) 写数据到驱动

v_IOWR(type，nr，datatype) 双向传送，type 和 number 成员作为参数被传递。

范例：

#define MEM_IOC_MAGIC ‘m’ //定义幻数

#define MEM_IOCSET _IOW(MEM_IOC_MAGIC,0, int)

#define MEM_IOCGQSET _IOR(MEM_IOC_MAGIC,1, int)

2.2Ioctl函数实现

定义好了命令,下一步就是要实现Ioctl函数了，Ioctl函数的实现包括如下3个技术环节:

1. 返回值 2. 参数使用 3. 命令操作

2.2.1 Ioctl函数实现(返回值)

Ioctl函数的实现通常是根据命令执行的一个switch语句。但是，当命令号不能匹配任何一个设备所支持的命令时，通常返回- EINVAL（“非法参数”）。

2.2.2 Ioctl函数实现(参数)

如何使用Ioctl中的参数?

如果是一个整数，可以直接使用。如果是指针，我们必须确保这个用户地址是有效的,因此使用前需进行正确的检查。

Ioctl函数实现(参数检查)

不需要检测：

v copy_from_user

v copy_to_user

v get_user

v put_user

需要检测：

v __get_user

v __put_user

int access_ok(int type, const void *addr, unsigned long size)

第一个参数是 VERIFY_READ 或者 VERIFY_WRITE，用来表明是读用户内存还是写用户内存。addr 参数是要操作的用户内存地址，size 是操作的长度。如果 ioctl 需要从用户空间读一个整数，那么size参数等于 sizeof(int)。access_ok 返回一个布尔值:1 是成功(存取没问题)和0 是失败(存取有问题),如果该函数返回失败, 则Ioctl应当返回–EFAULT 。

范例：

if (_IOC_DIR(cmd) &_IOC_READ)

err = !access_ok(VERIFY_WRITE, (void __user *)arg,_IOC_SIZE(cmd));

//why_IOC_READ 对应VERIFY_WRITE ???

else if (_IOC_DIR(cmd) & _IOC_WRITE)

err = !access_ok(VERIFY_READ, (void __user *)arg,

_IOC_SIZE(cmd));

if (err)

return -EFAULT;

2.2.3Ioctl函数实现(命令操作)

switch(cmd)

{

case MEM_IOCSQUANTUM: /* Set: arg points to the value */

retval = __get_user(scull_quantum, (int *)arg);

break;

case MEM_IOCGQUANTUM: /* Get: arg is pointer to result */

retval = __put_user(scull_quantum, (int *)arg);

break;

default:

return –EINVAL;

}

3.范例

#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_ */

#include <linux/slab.h>#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 "unlocked_ioctl.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 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,  .unlocked_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, MEMDEV_NR_DEVS *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("ly");MODULE_LICENSE("GPL");module_init(memdev_init);module_exit(memdev_exit);

测试代码

#include <stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include "unlocked_ioctl.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;printf("MEMDEV_IOCPRINT=%c %d\n",MEMDEV_IOCPRINT,MEMDEV_IOCPRINT);printf("cmd=%c %d\n",cmd,cmd);    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;    }