IOCTL接口函数解析

最新推荐文章于 2025-07-26 13:17:43 发布
最新推荐文章于 2025-07-26 13:17:43 发布
阅读量621 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Linux_kernel 文章标签： 函数 IOCTL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jianwen_hi/article/details/53465804
IOCTL接口用于控制I/O设备，如设置串口波特率、马达转速等。它提供了一种获取设备信息和发送控制参数的方法，处理设备的Out-of-band数据。命令码由type、nr、dir和size组成，可以通过如_IOW等宏定义。文章包含IOCTL参数详解及工程实例，包括头文件、内核模块和用户层代码的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

什么是IOCTL

IOCTL是设备驱动程序中对设备的I/O通道进行管理的函数。所谓的I/O通道管理即设备参数读写、设备状态读、以及控制设备。

例如：控制串口传输的波特率、马达的转速等等。
功能：控制I/O设备 ，提供了一种获得设备信息和向设备发送控制参数的手段。用于向设备发控制和配置命令 ，有些命令需要控制参数，这些数据是不能用read / write 读写的,称为Out-of-band数据。也就是说,read / write 读写的数据是in-band数据,是I/O操作的主体，而ioctl 命令传送的是控制信息,其中的数据是辅助的数据。

IOCTL参数命令

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

struct file *filp
由fd得到的file结构体

unsigned int cmd
命令码，设备驱动定义的，区分具体工作的编号

unsigned long arg
输入/出参数（可能是值，也可能是地址；如果要输出，必须是地址）

命令码的格式（即cmd的格式）
|type|nr|dir|size|

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

type：类型
nr：命令编号
dir：方向，读/写
size：参数大小
如何得到上面的命令码呢？
内核定义了 _IO() _OR() _IOW() _IOWR()几个宏命令来帮助生成命令，这几个宏如下：
函数定义在：/linux/asm/ioctl.h

_IO(type,nr)            定制控制命令码
_IOR(type,nr,size )     定制读参数命令
_IOW(type,nr,size )     定制写参数命令
_IOWR(type,nr,size )    定制读写参数命令

还可以通过命令来提取相对应的参数

IOC_DIR(cmd)            提取读写方向
IOC_TYPE(cmd)           提取类型
IOC_NR(cmd)             提取命令码编号
IOC_SIZE(cmd)           提取读写参数的大小

工程实例

头文件

#ifndef MYCMD_H
#define MYCMD_H

#include <asm/ioctl.h>

#define CMDT 'A'

#define KARGL 36

struct karg{
    int kval;
    char kbuf[KARGL];
};

#define CMDOFF  _IO(CMDT,0)
#define CMDON   _IO(CMDT,1)
#define CMDR    _IOR(CMDT,2,struct karg)
#define CMDW    _IOW(CMDT,3,struct karg)

#endif

内核模块代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/errno.h>

#include <asm/current.h>
#include <linux/sched.h>

#include <linux/uaccess.h>

#include <linux/device.h>
static struct class *cls = NULL;

#include "mycmd.h"

static int major = 0;
static int minor = 0;
const  int count = 6;

#define DEVNAME "demo"

static struct cdev *demop = NULL;

#define KMAX 1024
static int counter = 0;
static char kbuf[KMAX];

//打开设备
static int demo_open(struct inode *inode, struct file *filp)
{
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    memset(kbuf, 0, KMAX);
    counter = 0;

    return 0;
}

//关闭设备
static int demo_release(struct inode *inode, struct file *filp)
{
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    return 0;
}

//读设备
//ssize_t read(int fd, void *buf, size_t count)
static ssize_t demo_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    struct inode *inode = filp->f_path.dentry->d_inode;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

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

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

    counter = 0;

    return size;
}

//写设备
static ssize_t demo_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    struct inode *inode = filp->f_path.dentry->d_inode;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    if(size > KMAX){
        return -ENOMEM;
    }

    if(copy_from_user(kbuf, buf, size)){
        return -EAGAIN;
    }

    counter = size;

    return counter;
}

/*
 * read/write param
 * read status
 * contrl device
 */
static long demo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    static struct karg karg = {
        .kval = 0,
        .kbuf = {0},
    };
    struct karg *usrarg;

    switch(cmd){
    case CMDON:
        printk(KERN_INFO "CMDON: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        break;

    case CMDOFF:
        printk(KERN_INFO "CMDOFF: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        break;

    case CMDR:
        printk(KERN_INFO "CMDR: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        if(_IOC_SIZE(cmd) != sizeof(karg)){
            return -EINVAL;
        }

        usrarg = (struct karg *)arg;
        if(copy_to_user(usrarg, &karg, sizeof(karg))){
            return -EAGAIN;
        }
        printk(KERN_INFO "CMDR: %s : %s : %d ---done.\n", __FILE__, __func__, __LINE__);
        break;

    case CMDW:
        printk(KERN_INFO "CMDW: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        if(_IOC_SIZE(cmd) != sizeof(karg)){
            return -EINVAL;
        }

        usrarg = (struct karg *)arg;
        if(copy_from_user(&karg, usrarg, sizeof(karg))){
            return -EAGAIN;
        }

        printk(KERN_INFO "CMDW: %d : %s\n", karg.kval, karg.kbuf);
        break;

    default:
        ;
    };


    return 0;
}

static struct file_operations fops = {
    .owner  = THIS_MODULE,
    .open   = demo_open,
    .release= demo_release,
    .read   = demo_read,
    .write  = demo_write,
    .unlocked_ioctl = demo_ioctl,
};

static int __init demo_init(void)
{
    dev_t devnum;
    int ret, i;

    struct device *devp = NULL;

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);

    //1. alloc cdev obj
    demop = cdev_alloc();
    if(NULL == demop){
        return -ENOMEM;
    }

    //2. init cdev obj
    cdev_init(demop, &fops);

    ret = alloc_chrdev_region(&devnum, minor, count, DEVNAME);
    if(ret){
        goto ERR_STEP;
    }
    major = MAJOR(devnum);

    //3. register cdev obj
    ret = cdev_add(demop, devnum, count);
    if(ret){
        goto ERR_STEP1;
    }

    cls = class_create(THIS_MODULE, DEVNAME);
    if(IS_ERR(cls)){
        ret = PTR_ERR(cls);
        goto ERR_STEP1;
    }

    for(i = minor; i < (count+minor); i++){
        devp = device_create(cls, NULL, MKDEV(major, i), NULL, "%s%d", DEVNAME, i);
        if(IS_ERR(devp)){
            ret = PTR_ERR(devp);
            goto ERR_STEP2;
        }
    }

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - ok.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    return 0;

ERR_STEP2:
    for(--i; i >= minor; i--){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);

ERR_STEP1:
    unregister_chrdev_region(devnum, count);

ERR_STEP:
    cdev_del(demop);

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - fail.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    return ret;
}

static void __exit demo_exit(void)
{
    int i;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - leave.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);

    for(i=minor; i < (count+minor); i++){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);

    unregister_chrdev_region(MKDEV(major, minor), count);

    cdev_del(demop);
}

module_init(demo_init);
module_exit(demo_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Farsight");
MODULE_DESCRIPTION("Demo for kernel module");

用户层代码

#include <stdio.h>

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

#include "mycmd.h"

int main(int num, char *argv[])
{
    if(2 != num){
        printf("Usage: %s /dev/devfile\n", argv[0]);
        return -1;
    }

    int fd = open(argv[1], O_RDWR);
    if(0 > fd){
        perror("open");
        return -1;
    }

    struct karg arg = {
        .kval = 12345678,
        .kbuf = "hello world",
    };

    if(0 > ioctl(fd, CMDON)){
        perror("ioctl-CMDON");
        return -1;
    }

    if(0 > ioctl(fd, CMDOFF)){
        perror("ioctl-CMDOFF");
        return -1;
    }   

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

    struct karg rarg;
    if(0 > ioctl(fd, CMDR, (unsigned long)&rarg)){
        perror("ioctl-CMDR");
        return -1;
    }

    printf("rd: %d, %s\n", rarg.kval, rarg.kbuf);

    close(fd);

    return 0;
}
Linux·字符设备驱动实例-基于通用摸版
m0_64560763的博客
08-29 667
字符设备驱动实例
linux下ioctl函数
11-30
linux下ioctl函数,这里说的ioctl函数是在驱动程序里的
IOCTL函数说明
weixin_33894992的博客
06-18 157
当在ioctl里使用FIONREAD时,除了获得所指定的读缓存大小以外,还有清除设备准备就绪状态的作用. 当38行注释以后, 由于各个设备的状态未被清除,所以循环一直处于非阻塞的状态.不停的打印一个状态(即未清除状态)的信息. 如果不注释ioctl,那么select会自动清除未准备好的设备状态. 此时阻塞是有效地. 同样的,在socket当中使用select和ioctl时测试结果也...
IOCTL头文件说明
02-17
LINUX底层文件，关于端口（I/O)初始化等
APUE编程：18---文件I/O之（ioctl函数）
董哥的黑板报
04-01 783
#include <unistd.h> //System V #include <sys/ioctl.h> //BSD and Linux int ioctl(int d, int request, ...); 详解参见文章：http://www.baike.com/wiki/ioctl 一、函数介绍 作用：操作特殊文件的底层设备参数。特别是，字符特殊文件(如...
ioctl
eager7的专栏
11-03 1万+
概述 　　函数名: ioctl 　　头文件：#include 　　功 能: 控制I/O设备 ，提供了一种获得设备信息和向设备发送控制参数的手段。用于向设备发控制和配置命令 ，有些命令需要控制参数，这些数据是不能用read / write 读写的,称为Out-of-band数据。也就是说,read / write 读写的数据是in-band数据,是I/O操作的主体，而ioctl
Linux驱动程序中的ioctl函数解析
ioctl函数是内核提供的一种机制，使得驱动程序能够提供自定义的控制接口，用户空间程序可以通过这个接口对设备进行高级控制。 二、ioctl的必要性 如果不用ioctl，用户可能需要通过write函数发送特殊的命令序列来...
linux驱动开发(一)：ioctl()函数
DYR20010308的博客
06-03 1920
一、应用程序中的ioctl接口首先，我们需要规定一些命令码，这些命令码在应用程序和驱动程序中需要保持一致。应用程序只需向驱动程序下发一条指令码，用来通知它执行哪条命令。如何解读这条指令和怎么实现相关操作，就是驱动程序自己要做的事。应用程序的接口函数为ioctl，参考，函数原型为下面我们解释各个参数的含义。1）fd是文件描述符。当我们的设备作为特殊文件被open()函数打开后，会返回一个文件描述符，通过操作这个文件描述符达到操作设备文件的目的。
snd_ctl_ioctl这个函数解析
03-12
用户希望了解这个函数的功能和用法，特别是与ioctl接口相关的内容。首先，我需要回忆自己对这个主题的了解，并确保信息的准确性。 首先，我应该明确snd_ctl_ioctl在Linux音频驱动中的角色。Control接口在ALSA框架中...
ioctl函数详解
12-22
本文将全面解析`ioctl`函数的工作原理、如何在内核模块中实现以及其在用户空间与内核空间通信中的重要性。 #### 1. ioctl函数简介 `ioctl`函数是用于设备驱动程序的一种通用接口，它允许用户空间应用程序通过文件...
socket超时设置 之 ioctlsocket 函数全面解析
zyx_0604的博客
07-20 1894
  先看看MSDN标准解释 int ioctlsocket( SOCKET s, long cmd, u_long FAR *argp ); Parameters s  [in] Descriptor identifying a socket.  cmd  [in] Command to perform on the socket s.  argp  [in, out] Poin...
ioctl()函数
weixin_59454731的博客
03-08 1693
ioctl()函数获取本机IP、MAC
linux下ioctl函数学习
热门推荐
Jerry的专栏
11-03 1万+
一、 什么是ioctl。ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数如下：int ioctl(int fd, ind cmd, …)；其中fd就是用户程序打开设备时使用open函数返回的文件标示符，cmd就是用户程序对设备的控制命令，至于后面的省略号，那是一些补充参数，一般最多一个，有或没有是和cmd的意义相关的。ioctl函数是文件结构中的一个属性分量，就是说如果你的驱动程序提供了对i
linux设备驱动归纳总结（三）：4.ioctl的实现
fh400的专栏
11-02 8530
CU首页 ┊ fh265>>博客 微博 相册 个人中心 好友 消息 [退出] ┊ 随便看看   博文 博主 相册  投票 活动 发博文 公告：缅怀Dennis Ritchie活动开赛啦！ 小白的博客——提升自已，分享别人 xiaobai.blog.chinaunix.net 好的女人可以不共享。好的技术绝对要共享！
Linux之设备控制接口(ioctl)
风间琉璃的博客
09-22 3957
ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。对I/O通道进行管理，就是对设备的一些特性进行控制。虽然在文件操作结构体struct file_operations中有很多对应的设备操作函数，但是有些命令是实在找不到对应的操作函数,拓展一些file_operations给出的接口中没有的自定义功能，则需要使用到ioctl()函数。如CD-ROM的驱动，想要一个弹出光驱的操作，这种操作并不是所有的字符设备都需要的，所以文件操作结构体也不会有对应的函数操作。
linux驱动开发(五)：ioctl()函数使用实例——地址传参
baidu_38797690的博客
03-24 6069
介绍了Linux系统设备驱动中ioctl接口的进一步使用方法，这一次我们使用ioctl传递复杂的参数，因此只能传递参数的地址，同时借用copy_from_user和copy_to_user两个函数完成用户空间与内核空间之间的数据拷贝。
ioctl系统调用及示例
悟空看八戒烤熟了没的专栏c)4Upqt4SeVk
07-26 779
这次我们介绍 函数，它是一个通用的设备输入/输出控制接口，允许程序对各种设备（如终端、文件系统、网络接口、USB 设备等）执行特定的控制操作，这些操作通常超出了基本的 和 范用范围。（Input/Output Control）是一个非常通用且强大的 Linux 系统调用。它的设计目的是为设备驱动程序提供一个标准的接口，以便用户空间程序可以向内核中的设备驱动发送特定的控制命令。你可以将 想象成一个“万能遥控器”，它可以对不同类型的“电器”（设备）执行特定的“功能”（命令），比如调整电视的音量、切换电视
驱动学习（六）ioctl
a834605978的博客
07-12 1948
如何看待应用程序与与底层设备之间的关系，又是什么原因让应用程序可以号令底层设备，欢迎观看“我的ioctl”，让我们解开这一段迷惑的关系。
linux 内核 - ioctl 函数详解
JCfyw的博客
05-02 4719
linux 内核 - ioctl 函数详解 1. 概念 ioctl 是设备驱动程序中设备控制接口函数，一个字符设备驱动通常会实现设备打开、关闭、读、写等功能，在一些需要细分的情境下，如果需要扩展新的功能，通常以增设 ioctl() 命令的方式实现。 在文件 I/O 中，ioctl 扮演着重要角色，本文将以驱动开发为侧重点，从用户空间到内核空间纵向分析 ioctl 函数。 2. 用户空间 ioctl #include <sys/ioctl.h> int ioctl(int fd, int cm
Ioctl
最新发布
08-16
<think>我们正在讨论Ioctl，这是一个在Unix-like系统（如Linux）中用于设备输入/输出控制和配置的系统调用。用户可能希望了解其基本概念、用途以及编程示例。 根据系统指令，我们需要使用中文回答，并正确使用LaTeX格式。同时，在回答末尾生成相关问题，并在引用处添加引用标识。 回答结构： 1. 解释Ioctl是什么 2. 说明其用途 3. 提供编程示例（例如C语言） 4. 生成相关问题 注意：由于这是一个系统级调用，示例代码将使用C语言，并假设在Linux环境下。 参考：在Unix/Linux系统中，Ioctl（Input/Output Control）是一个用于设备特定操作的系统调用，它允许用户空间程序与设备驱动程序进行交互，执行无法通过标准文件I/O操作（如read/write）完成的操作[^1]。</think>### Ioctl 技术解析 Ioctl（Input/Output Control）是 Unix/Linux 系统中的核心系统调用，用于设备驱动与用户空间程序的交互。其函数原型为： ```c int ioctl(int fd, unsigned long request, ...); ``` - `fd`：已打开的设备文件描述符 - `request`：设备控制请求码 - 可变参数：指向内存的指针（传递数据或接收结果） #### 核心用途 1. **设备控制**：配置串口波特率、设置网络接口参数等 2. **特性查询**：获取设备能力信息（如摄像头支持的分辨率） 3. **专用操作**：执行设备特有功能（如调整键盘背光亮度） 4. **内核通信**：用户空间与内核模块的数据交换通道 #### 工作流程 1. 用户程序打开设备文件获取 `fd` 2. 构造包含请求码和数据缓冲区的 `ioctl` 调用 3. 内核路由请求到对应设备驱动 4. 驱动解析请求并执行操作 5. 结果通过缓冲区或返回值传回用户空间 #### 编程示例（C语言） ```c #include <sys/ioctl.h> #include <fcntl.h> // 获取串口控制信号状态 int get_serial_status() { int fd = open("/dev/ttyS0", O_RDWR); // 打开串口设备 int status; // TIOCMGET: 获取调制解调器状态 if (ioctl(fd, TIOCMGET, &status) < 0) { perror("ioctl failed"); return -1; } close(fd); return status; // 返回状态字（包含DSR/DTR等信号状态） } ``` #### 关键特性 - **请求码结构**：高位包含方向标志（\_IOC\_READ/\_IOC\_WRITE），如： ```c #define MY_DEV_READ _IOR('X', 1, int) // 定义读请求 ``` - **安全性**：需CAP_SYS_ADMIN权限执行特权操作[^1] - **跨平台差异**：Windows通过DeviceIoControl实现类似功能 > ⚠️ 注意：滥用 ioctl 可能导致内核崩溃，需严格验证用户空间传入参数[^2]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值