天天看點
傳回

IOCTL接口函數解析什麼是IOCTLIOCTL參數指令工程執行個體

什麼是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|

裝置類型 序列号 方向 資料尺寸
8bit 8bit 2bit 13/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 = ;
static int minor = ;
const  int count = ;

#define DEVNAME "demo"

static struct cdev *demop = NULL;

#define KMAX 1024
static int counter = ;
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, , KMAX);
    counter = ;

    return ;
}

//關閉裝置
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 ;
}

//讀裝置
//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 = ;

    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 = ,
        .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 ;
}

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

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

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

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

    //. 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 ;

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( != num){
        printf("Usage: %s /dev/devfile\n", argv[]);
        return -;
    }

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

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

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

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

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

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

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

    close(fd);

    return ;
}
linux_kernel 函數 IOCTL
上一篇: linux 系統運作的時間函數,Linux下面time類 時間函數總結
下一篇: rhel6.3yum源的幾種配置解析

繼續閱讀