linux驱动开发之字符设备--内核和用户空间数据的交换（ioctl）

最新推荐文章于 2023-12-14 16:27:40 发布
最新推荐文章于 2023-12-14 16:27:40 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： Linux驱动开发 文章标签： linux驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013377887/article/details/72629941
版权

前言

在驱动中，除了需要具备读写能力外，还需要对硬件设备进行控制。ioctl就常用户底层的一些操作。

正文

linux中，建议使用下边的方式，进行进行ioctl命令

设备类型序列号方向数据尺寸
8bit8bit2bit13/14bit

命令码的设备类型为一个 “幻数”，可以是在 0 ~0xff 之间值，内核中的 ioctl-number.txt 给出了一些推荐的和已经被使用的 “幻数”。

命令码列号也是 8 位宽 。

命令码的方向字节也是 2 位宽，该字端表示出具传送的方向，可能的值是 _IO_NONE(无数据传输)、_IOC_READ(读)、_IOC_WRITE(写)、_IOC_READ|_IOC_WRITE(双向)。数据传输的方向是从应用程序的角度来看的。

命令码的数据长度字节表示涉及的用户数据的大小，这个成员的宽度依赖于体系结构，通常为 13 或 14 位。

内核中定义了 _IO()、_IOR()、_IOW()、_IOWR()这4个宏来辅助生成命令。

#define _IOC(dir,type,nr,size) \
        (((dir)  << _IOC_DIRSHIFT) | \
         ((type) << _IOC_TYPESHIFT) | \
         ((nr)   << _IOC_NRSHIFT) | \
         ((size) << _IOC_SIZESHIFT))
#define _IO(type,nr)        _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))

以上宏的作用是根据输入的type（设备类型）、nr(序列号)、size(数据长度) 和宏中的位移来生成相应的 命令码。

#define _IOC_SIZE(nr)   \
 ((((((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK) & (_IOC_WRITE|_IOC_READ)) == 0)?    \
                         0: (((nr) >> _IOC_SIZESHIFT) & _IOC_XSIZEMASK))

获得数据域的大小。

应用API

  #include <sys/ioctl.h>
  int ioctl(int d, int request, ...)

参数:fd : 打开的文件描述符
request:命令码
可变参数：可以用来表示，写时用来传入驱动的数据，读时用来接收驱动的数据

内核

    long (*unlocked_ioctl) (struct file *filp , unsigned int, cmd .unsigned long arg);

参数:filp 应用打开的文件在内核的表示
cmd: 对应应用程序传入的命令码
arg ： 对于应用程序 传入或者接收的数据

实例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

#include <linux/cdev.h>
#include <linux/fs.h>

#include <linux/uaccess.h>
//幻数
#define IOCTL_TYPE 'b'

#define COUNT   32

struct  ioctl_arg {
    int val;
    char buf[COUNT];
};
//定义的命令码
#define CMDCTL  _IO(IOCTL_TYPE,0)
#define CMDR    _IOR(IOCTL_TYPE,1,struct ioctl_arg)
#define CMDW    _IOW(IOCTL_TYPE,2,struct ioctl_arg)

#define DEVICE_NAME "cdev_demo"

static struct cdev *pdev = NULL;
static int major = 0;
static int minor = 0;
static int count = 2;


#define BUF_SIZE        (1024)
static char kbuf[BUF_SIZE];
static int  buf_count = 0;

static int cdev_demo_open(struct inode * inode, struct file * file)
{
    printk("%s,%d\n",__func__,__LINE__);
    return 0;
}
static int cdev_demo_release(struct inode *inode, struct file * file)
{
    printk("%s,%d\n",__func__,__LINE__);
    return 0;
}
static ssize_t cdev_demo_read(struct file * file, char __user * buffer, size_t size, loff_t * loff)
{
    printk("%s,%d\n",__func__,__LINE__);

    if(0 == buf_count){
        return -EAGAIN;
    }

    if(buf_count < size){
        size = buf_count;
    }

    if(size == copy_to_user(buffer,kbuf,size)){
        return -EAGAIN;
    }

    buf_count  = 0;

    return size;

}

static ssize_t cdev_demo_write(struct file * file, const char __user * buffer, size_t size, loff_t * loff)
{
    printk("%s,%d\n",__func__,__LINE__);
    printk("buffer=%s   size=%d\n",buffer,size);
    if(size >BUF_SIZE){
        return -ENOMEM;
    }
    if(size == copy_from_user(kbuf,buffer,size)){
        return -EAGAIN;
    }

    buf_count = size;
    return size;
}
//ioctl
static long cdev_demo_ioctl (struct file *filep, unsigned int cmd, unsigned long arg)
{
    static struct ioctl_arg buf;
    printk("%s,%d\n",__func__,__LINE__);
    //分辨不同命令码
    switch(cmd){
        case CMDCTL:
                printk("do CMDCTL\n");
                break;
        case CMDR:
            //使用 _IOC_SIZE()获得命令码中的数据长度
            if(sizeof(buf) != _IOC_SIZE(cmd)){
                return -EINVAL;
            }

            if(sizeof(buf) == copy_to_user((struct ioctl_arg*)arg,&buf,sizeof(struct ioctl_arg))){
                return -EAGAIN;
            }
            printk("do CMDR\n");
            break;
        case CMDW:
            if(sizeof(buf)!= _IOC_SIZE(cmd)){
                 return -EINVAL;
            }

            if(sizeof(buf) == copy_from_user(&buf,(struct ioctl_arg*)arg,sizeof(buf))){
                return -EAGAIN;
            }
            printk("do CMDW\n");
            printk("%d,%s \n",buf.val,buf.buf);
            break;

        default:
            break;

    }

    return 0;
}
static struct file_operations fops ={
    .owner   = THIS_MODULE,
    .open    = cdev_demo_open,
    .release = cdev_demo_release,
    .read    = cdev_demo_read,
    .write   = cdev_demo_write,
    .unlocked_ioctl = cdev_demo_ioctl,
};

static int __init cdev_demo_init(void)
{
    dev_t dev;
    int ret;

    printk("%s,%d\n",__func__,__LINE__);

    pdev = cdev_alloc();
    if(NULL == pdev){
        printk("cdev_alloc failed.\n");
        return -ENOMEM;
    }

    cdev_init(pdev,&fops);

    ret = alloc_chrdev_region(&dev,minor,count,DEVICE_NAME);
    if(ret){
        printk("alloc_chrdev_region failed.\n");
        goto ERROR_CDEV;
    }
    major = MAJOR(dev);
    ret = cdev_add(pdev, dev,count);
    if(ret) {
        printk("cdev_add failed.\n");
        goto  ERROR_ADD;
    }

    return 0;
ERROR_ADD:
    unregister_chrdev_region(dev,count);
ERROR_CDEV:
    cdev_del(pdev);
    return ret;
}
static void __exit cdev_demo_exit(void)
{
    printk("%s,%d\n",__func__,__LINE__);
    unregister_chrdev_region(MKDEV(major,minor),count);

    cdev_del(pdev);
}

module_init(cdev_demo_init);
module_exit(cdev_demo_exit);
MODULE_LICENSE("GPL");

APP:

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

#include <errno.h>

#include <sys/ioctl.h>


#define IOCTL_TYPE 'b'

#define COUNT   32

struct  ioctl_arg {
    int val;
    char buf[COUNT];
};

#define CMDCTL  _IO(IOCTL_TYPE,0)
#define CMDR    _IOR(IOCTL_TYPE,1,struct ioctl_arg)
#define CMDW    _IOW(IOCTL_TYPE,2,struct ioctl_arg)




#define BUFFER_SIZE  (1024)
int main(int argc,char* argv[])
{
    char *dev = "/dev/cdev_demo";
    int fd = open(dev,O_RDWR);
    if(0 > fd){
        perror("open\n");
        return -1;
    }
    //先构造数据，然后调用ioctl进行写操作
        printf("begin write\n");
        struct ioctl_arg arg = {
            .val = 123,
            .buf = "address",
        };

        if( 0 > ioctl(fd,CMDW,&arg)){
            perror(" write ");
            return -1;
        }

        //调用ioctl进行读取内核数据
        printf("begin read\n");
        struct ioctl_arg args;
        if(0 > ioctl(fd,CMDR,&args)){
            perror("read");
            return -1;
        }
        printf("read args.val = %d args.buf = %s\n",args.val,args.buf);

    close(fd);
    return  0;
}

运行结果：

shell@tiny4412:/mnt # ./test                                                
[  777.455766] cdev_demo_open,39
[  777.457120] do CMDW
[  777.457192] 123,address 
[  777.457238] cdev_demo_ioctl,87
[  777.457334] do CMDR
[  777.457441] cdev_demo_release,44
begin write
begin read
read args.val = 123 args.buf = address

注： [ xx] 表示tiny4412打印的信息，不带的表示app 打印出的信息。

总结

在ioctl中，可以根据命令码对硬件进行功能的操作，即可以进行写操作也可以进行读操作。这样就比read()、write()更加灵活。

Sunnie_ge
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux编程从入门到精通
09-21
linux内核编程 目 录 雷蒙序 简介 Linux文档工程小组“公告” 译者序 第一部分 Linux内核 前言 第1章 硬件基础与软件基础 6 1.1 硬件基础 6 1.1.1 CPU 7 1.1.2 存储器 8 1.1.3 总线 8 1.1.4 控制器和外设 8 ...
linux编程白皮书
07-18
本书对Linux操作系统及其编程作了整体的介绍，以支持用于开发软件的公开源码模型。对内存管理、进程及其通信机制、PCI、内核模块编程及内核系统结构作了详细的解释，且附有很多程序代码实例。对深入研究Linux下的...
linux_ioctl与内核交换数据
Wenleon
05-21 1123
1. 前言   使用ioctl系统调用是用户空间向内核交换数据的常用方法之一，从ioctl这个名称上看，本意是针对I/O设备进行的控制操作， 但实际并不限制是真正的I/O设备，可以是任何一个内核设备即可。 2. 基本过程   在内核空间中ioctl是很多内核操作结构的一个成员函数，如文件操作结构struct file_operations(include/linux/fs.h)、 协
linux kernel and user space通信机制,Linux内核与用户空间通信机制研究
weixin_34342860的博客
05-14 351
摘要：Linux内核采用单内核架构，具有简单、高效、安全的优点。Linux各子系统包含在内核中，而系统配置及管理工具运行于用户空间。开发人员需要采用一种合适的在内核与用户空间之间通信的方法。该文总结了几种常用的通信方法：设备节点适合于驱动程序开发，但创建过程比较复杂；/proc文件易于创建，但是不支持大量数据的传输；netlink具有高可扩展性，越来越多的系统工具采用这种方式，而其传输速度较慢；内...
Linux字符设备驱动（设备文件，用户空间与内核空间进行数据交互，ioctl接口）
qq_53221728的博客
03-25 1766
设备文件的两种创建方式，用户空间怎么与内核空间进行数据交互，字符设备驱动ioctl接口是什么，本文一键搞定。
linux中应用与驱动之间的数据交换方法
rannar的博客
09-03 2256
static struct file_operations char_leds_fops = { .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */ .open = char_leds_open, .read = char_leds_read, .write = ch...
linux 驱动copy_to_user() - 驱动与应用层数据交互（一）
生活需要深度
08-23 374
实现驱动层将数据拷贝到用户态。
LINUX编程白皮书
04-07
本书对Linux操作系统及其编程作了整体的介绍，以支持用于开发软件的公开源码模型。对内存管理、进程及其通信机制、PCI、内核模块编程及内核系统结构作了详细的解释，且附有很多程序代码实例。对深入研究Linux下的...
LINUX编程白皮书 （全集）
07-23
6.2.4 设备驱动程序与内核的接口 66 6.2.5 硬盘 69 6.2.6 网络设备 74 第7章 文件系统 77 7.1 第二个扩展文件系统EXT2 78 7.1.1 EXT2系统的inode节点 79 7.1.2 EXT2系统的超级块 80 7.1.3 EXT2系统的组描述符 80 ...
12.【linux驱动】内核空间用户空间数据传递
柏鑫的博客
06-18 520
linux分为用户空间和内核空间，两者的虚拟地址空间分布不一样。内核占用高地址，应用程序占有低地址空间，每个进程的内核虚拟地址都是一样的，区别在于进程的用户控件映射不同，所以内核也可以直接使用用户空间的指针读写数据，但是用户空间的内存可能被换出去，所以还是需要借助内核函数去读写。 主要有这几个函数：access_ok()，copy_to_user()，copy_from_user,put_user,get_user 1.access_ok() 函数原型： int access_ok(int type,uns
linux驱动开发之字符设备--内核和用户空间数据的交换（read write）
Android 系统开发
05-20 1557
前边给出了字符设备的框架，内核和用户空间进行交流的时候，离不来数据的交换；内核实现read、wriet 、ioctl是常用的交互手段。
内核与用户空间的通信实现——ioctl（驱动+用户程序）
ljl113的博客
09-24 4536
本文主要介绍内核空间与用户空间通信的一种方式----ioctl，用户程序可以通过调用ioctl函数来实现将一个cmd传给内核，而内核驱动根据switch case来实现预先设定好cmd对应执行的相关程序。学习ioctl是一个字符设备，所以在我们学习ioctl之前需要先了解一下linux设备驱动中的字符设备。
Linux用户与内核空间交互—ioctl
10-10 1250
用户空间与内核的交互方式，使用copy_from_user(), copy_to_user().除了这两种交互方式，内核还提供了其他高级的方式，对于写驱动来说很重要。有proc、sysfs、debugfs、netlink、ioctl。本文学习ioctlprocfssysfsdebugfsnetlinkioctl容易开发容易开发与使用相对容易学习与使用非常容易学习与使用困难，必须用户空间和内核空间同步编程相对困难，必须写用户空间程序适合场景仅仅内核，旧内核使用，避免驱动使用。
驱动开发 内核与用户层使用ioctl
weixin_66861497的博客
11-17 223
华清远见上海中心22071班 内核与用户层使用ioctl
用户空间与内核的交互---IOCTL
u010154760的专栏
03-30 1378
在procfs一节中我们提到过ioctl，它的作用编写过驱动和从事过网络编程的人，一定不会陌生. 就是由于它架构的思路的精妙之处，屏蔽了大量抽象的东西.这里我们就分析下它的使用和架构，当然这里不会分析ioctl系统调用的实现.这里参考资料有《linux设备驱动程序》，《深入理解linux网络技术内幕》 ，当然也少不了网上好的文章和帖子.        或许我们最熟悉就是文件的操作，文件有re
【通过ioctl从用户空间传输数据到内核空间】
qq_37780521的博客
08-08 760
通过ioctl从用户空间传输数据到内核空间
Linux内核中_IO,_IOR,_IOW,_IOWR宏的用法与解析
好久都没有更新博客喽，工作原因只能总结在内部机上：-（
02-24 4199
原文出处：http://blog.csdn.net/hzn407487204/article/details/7995041 在驱动程序里， ioctl() 函数上传送的变量 cmd 是应用程序用于区别设备驱动程序请求处理内容的值。cmd除了可区别数字外，还包含有助于处理的几种相应信息。 cmd的大小为 32位，共分 4 个域：      bit31~bit30 2位为 “区别读写” 区，作用
linux驱动开发(四)：ioctl()函数
热门推荐
baidu_38797690的博客
03-24 2万+
Linux驱动程序中的ioctl接口，描述了内核空间和用户空间中分别对ioctl接口的定义和用法，介绍了两者间的传输协议，并通过举了一个简单的实例。
快速了解[IOCTL][IO][IOR][IOW][IOWR][幻数]的概念
最新发布
weixin_41796265的博客
12-14 667
以下内容为个人学习笔记，不保证正确。
驱动使用ioctl将内核空间信息传递到用户空间
06-07
驱动使用ioctl将内核空间信息传递到用户空间的流程如下： 1. 在驱动程序中定义ioctl命令，其中包含需要传递的信息。例如： ```c #define IOCTL_GET_INFO _IOR('x', 1, struct my_info) ``` 其中，_IOR代表是从设备中读取信息，'x'代表一个唯一的驱动程序标识符，1代表命令号，struct my_info代表需要传递的信息结构体。 2. 在驱动程序中实现ioctl函数，处理用户空间传来的ioctl命令。例如： ```c static long my_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) { struct my_info info; switch (cmd) { case IOCTL_GET_INFO: /* 将内核空间信息保存到info结构体中 */ info.value1 = kernel_value1; info.value2 = kernel_value2; /* 将info结构体传递给用户空间 */ if (copy_to_user((void __user *)arg, &info, sizeof(struct my_info))) return -EFAULT; break; default: return -ENOTTY; } return 0; } ``` 3. 在用户空间中使用ioctl命令读取内核空间信息。例如： ```c int fd; struct my_info info; fd = open("/dev/my_device", O_RDONLY); /* 读取内核空间信息 */ if (ioctl(fd, IOCTL_GET_INFO, &info)) return -1; /* 使用读取到的信息 */ printf("value1: %d, value2: %d\n", info.value1, info.value2); close(fd); ``` 其中，fd是设备文件描述符，/dev/my_device是设备节点路径，IOCTL_GET_INFO是ioctl命令，&info是接收信息的结构体。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值