應用程序如果想要設置/獲取驅(qū)動層的數(shù)據(jù)，一般是驅(qū)動提供一個ioclt接口，然后應用層調(diào)用。因此，學會在驅(qū)動中實現(xiàn)ioctl接口是必要的一項技能。

ioctl命令編碼規(guī)則

想要定義一個自己的ioctl命令，必須要遵從ioctl的編碼規(guī)則 。

一個ioctl命令由32比特位表示，每個比特位都有不同的含義，不同版本的內(nèi)核定義可能有些差異，具體參考文檔“Documentation/ioctl/ioctl-deconding.txt”.

在內(nèi)核include/uapi/asm-generic/ioctl.h頭文件中提供了一組宏來定義、提取命令中的字符信息：

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

#ifndef __KERNEL__
#define _IOC_TYPECHECK(t) (sizeof(t))
#endif

/* used to create numbers */
#define _IO(type,nr)  _IOC(_IOC_NONE,(type),(nr),0)
#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)))
#define _IOR_BAD(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW_BAD(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR_BAD(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))

/* used to decode ioctl numbers.. */
#define _IOC_DIR(nr)  (((nr) > > _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr)  (((nr) > > _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr)  (((nr) > > _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr)  (((nr) > > _IOC_SIZESHIFT) & _IOC_SIZEMASK)

構造ioctl命令 ：

• _IO(type,nr):用于構造無參數(shù)的命令號
• _IOR(type,nr,datetype):用于構造從驅(qū)動程序中讀取數(shù)據(jù)的命令號
• _IOW(type,nr,datatype):用于構造向驅(qū)動程序?qū)懭霐?shù)據(jù)的命令號
• _IORW(type,nr,datatype):用于構造雙向傳輸?shù)拿钐?/li>

解析ioctl命令 ：

• _IOC_DIR(cmd):獲得傳輸方向位段的值
• _IOC_TYPE(cmd):獲得類型的值
• _IOC_NR(cmd):獲得編號的值
• _IOC_SIZE(cmd):獲得大小的值

具體示例 ：

向驅(qū)動寫入數(shù)據(jù)，假設定義幻數(shù)為'a'，命令碼為0，傳入的數(shù)據(jù)為結構體struct option：

#define VS_MAGIC 's'//幻數(shù)

#define VS_SET_FFMT _IOW(VS_MAGIC, 0, struct option)

從驅(qū)動獲得數(shù)據(jù)，將命令碼修改為1，_IOW換成_IOR：

#define VS_MAGIC 's'//幻數(shù)

#define VS_GET_FFMT _IOR(VS_MAGIC, 1, struct option)

這里要注意，理想情況下定義的幻數(shù)在一種體系結構下應該是全局唯一的，雖然很難做到，但我們還是應該遵從內(nèi)核所規(guī)定的這種定義形式。

ioctl系統(tǒng)調(diào)用過程

ioctl本質(zhì)是一個系統(tǒng)調(diào)用 ，在應用層使用ioctl函數(shù)時，會使得系統(tǒng)從用戶態(tài)trap到內(nèi)核態(tài)，即調(diào)用到內(nèi)核態(tài)的sys_ioctl函數(shù)。

sys_ioctl函數(shù)的定義位于內(nèi)核源碼fs/ioctl.c中：

SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
{
 int error;
 struct fd f = fdget(fd);

 if (!f.file)
  return -EBADF;
 error = security_file_ioctl(f.file, cmd, arg);
 if (!error)
  error = do_vfs_ioctl(f.file, fd, cmd, arg);
 fdput(f);
 return error;
}

SYSCALL_DEFINE3是一個系統(tǒng)調(diào)用宏，3代表這個系統(tǒng)調(diào)用需要3個參數(shù)，具體的SYSCALL_DEFINE宏定義可以參考include/linux/syscalls.h。這里不對系統(tǒng)調(diào)用展開討論，只需要知道ioctl是一個系統(tǒng)調(diào)用就可以了。

展開之后，這個函數(shù)名字其實就是sys_ioctl，sys_ioctl函數(shù)首先調(diào)用了security_file_ioctl，然后調(diào)用了do_vfs_ioctl。

do_vfs_ioctl函數(shù)是需要關注的，定義如下：

int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
      unsigned long arg)
{
 int error = 0;
 int __user *argp = (int __user *)arg;
 struct inode *inode = file_inode(filp);

 switch (cmd) {
 case FIOCLEX:
  set_close_on_exec(fd, 1);
  break;

 case FIONCLEX:
  set_close_on_exec(fd, 0);
  break;

 case FIONBIO:
  error = ioctl_fionbio(filp, argp);
  break;

 case FIOASYNC:
  error = ioctl_fioasync(fd, filp, argp);
  break;

 case FIOQSIZE:
  if (S_ISDIR(inode- >i_mode) || S_ISREG(inode- >i_mode) ||
      S_ISLNK(inode- >i_mode)) {
   loff_t res = inode_get_bytes(inode);
   error = copy_to_user(argp, &res, sizeof(res)) ?
     -EFAULT : 0;
  } else
   error = -ENOTTY;
  break;

 case FIFREEZE:
  error = ioctl_fsfreeze(filp);
  break;

 case FITHAW:
  error = ioctl_fsthaw(filp);
  break;

 case FS_IOC_FIEMAP:
  return ioctl_fiemap(filp, arg);

 case FIGETBSZ:
  return put_user(inode- >i_sb- >s_blocksize, argp);

 case FICLONE:
  return ioctl_file_clone(filp, arg, 0, 0, 0);

 case FICLONERANGE:
  return ioctl_file_clone_range(filp, argp);

 case FIDEDUPERANGE:
  return ioctl_file_dedupe_range(filp, argp);

 default:
  if (S_ISREG(inode- >i_mode))
   error = file_ioctl(filp, cmd, arg);
  else
   error = vfs_ioctl(filp, cmd, arg);
  break;
 }
 return error;
}

可以看到，do_vfs_ioctl函數(shù)會對一些特殊的命令進行處理，因此， 我們在定義自己的ioctl命令時，要避免和這些已有的命令沖突 。

只有非特殊命令的情況，才會進入switch的default，vfs_ioctl函數(shù)最終會調(diào)用驅(qū)動中實現(xiàn)的unlocked_ioctl函數(shù)：

long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
 int error = -ENOTTY;

 if (!filp- >f_op- >unlocked_ioctl)
  goto out;

 error = filp- >f_op- >unlocked_ioctl(filp, cmd, arg);
 if (error == -ENOIOCTLCMD)
  error = -ENOTTY;
 out:
 return error;
}

驅(qū)動層實現(xiàn)

在驅(qū)動中，我們只需要實現(xiàn)struct file_operations結構體里的unlocked_ioctl函數(shù)即可，這個函數(shù)用于處理ioctl命令，基本結構如下：

static long vser_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    switch(cmd) {
        case VS_SET_BAUD:
             vsdev.baud = arg;
             break;
        case VS_SET_FFMT:
             if (copy_from_user(&vsdev.opt, (struct option __user *)arg, sizeof(struct option)))
                    return -EFAULT; 
             break;
        default:
             break;
 };
   
 return 0;
}

static struct file_operations vser_ops = {
 .owner = THIS_MODULE,
    .unlocked_ioctl = vser_ioctl,
};

cmd就是傳入ioctl命令，一般在unlocked_ioctl函數(shù)的實現(xiàn)中，通過switch語句判斷不同ioctl命令。第三個參數(shù)arg代表輸入的數(shù)據(jù)，如果傳入的是一個指針，可以 對arg進行強制類型轉(zhuǎn)換 。

vser.c

#include < linux/init.h >
#include < linux/kernel.h >
#include < linux/module.h >
#include < linux/fs.h >
#include < linux/cdev.h >
#include < linux/kfifo.h >
#include < linux/ioctl.h >
#include < linux/uaccess.h >
#include < linux/device.h >

static struct class *class;

struct option{
 unsigned int datab;
    unsigned int parity;
    unsigned int stopb;
};

#define VS_MAGIC 's'

#define VS_SET_BAUD _IOW(VS_MAGIC, 0, unsigned int)
#define VS_GET_BAUD _IOR(VS_MAGIC, 1, unsigned int)
#define VS_SET_FFMT _IOW(VS_MAGIC, 2, struct option)
#define VS_GET_FFMT _IOR(VS_MAGIC, 3, struct option)

#define VSER_MAJOR 256
#define VSER_MINOR 0
#define VSER_DEV_CNT 1
#define VSER_DEV_NAME "vser"

struct vser_dev{
 unsigned int baud;
    struct option opt;
    struct cdev cdev;
};

DEFINE_KFIFO(vsfifo, char, 32);
static struct vser_dev vsdev;

static int vser_open(struct inode *inode, struct file *filp)
{
 return 0;
}

static int vser_release(struct inode *inode, struct file *flip)
{
 return 0;
}

static ssize_t vser_read(struct file *filp, char __user *buf, size_t count, loff_t *pos)
{
 int ret;
    unsigned int copied = 0;
    ret = kfifo_to_user(&vsfifo, buf, count, &copied);
    
    return ret == 0 ? copied : ret;
}

static ssize_t vser_write(struct file *filp, const char __user *buf, size_t count, loff_t *pos)
{
 int ret;
    unsigned int copied = 0;
    
    ret = kfifo_from_user(&vsfifo, buf, count, &copied);
    
    return ret == 0? copied : ret;
}

static long vser_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    if (_IOC_TYPE(cmd) != VS_MAGIC)
        return -ENOTTY;
 
    switch(cmd) {
        case VS_SET_BAUD:
             vsdev.baud = arg;
             break;
        case VS_GET_BAUD:
             arg = vsdev.baud;
             break;
        case VS_SET_FFMT:
             if (copy_from_user(&vsdev.opt, (struct option __user *)arg, sizeof(struct option)))
                    return -EFAULT; 
             break;
        case VS_GET_FFMT:
             if (copy_to_user((struct option __user *)arg, &vsdev.opt, sizeof(struct option)))
     return -EFAULT;
             break;
        default:
             break;

 };
    
 return 0;
}

static struct file_operations vser_ops = {
 .owner = THIS_MODULE,
    .open = vser_open,
    .release = vser_release,
    .read = vser_read,
    .write = vser_write,
    .unlocked_ioctl = vser_ioctl,
};

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

    dev = MKDEV(VSER_MAJOR, VSER_MINOR);
    ret = register_chrdev_region(dev, VSER_DEV_CNT, VSER_DEV_NAME);
    if (ret)
         goto reg_err;
    
    cdev_init(&vsdev.cdev, &vser_ops);
    vsdev.cdev.owner = THIS_MODULE;
    vsdev.baud = 115200;
    vsdev.opt.datab = 8;
    vsdev.opt.parity = 0;
    vsdev.opt.stopb = 1;
    
    ret = cdev_add(&vsdev.cdev, dev, VSER_DEV_CNT);
    if (ret)
        goto add_err;

    /* 自動創(chuàng)建設備節(jié)點 */
    class = class_create(THIS_MODULE, "my_ioctl");  /* /sys/class/my_ioctl */
 device_create(class, NULL, dev, NULL, "vser0"); /* /dev/vser0 */

    return 0;
    
add_err:
    unregister_chrdev_region(dev, VSER_DEV_CNT);
reg_err:
    return ret;
}

static void __exit vser_exit(void)
{
 dev_t dev;
 dev = MKDEV(VSER_MAJOR, VSER_MINOR);
    
    cdev_del(&vsdev.cdev);

    device_destroy(class, dev);
 class_destroy(class);


    unregister_chrdev_region(dev, VSER_DEV_CNT);
}

module_init(vser_init);
module_exit(vser_exit);
MODULE_LICENSE("GPL");

應用層示例

test.c

#include < stdio.h >
#include < stdlib.h >
#include < sys/types.h >
#include < sys/stat.h >
#include < sys/ioctl.h >
#include < fcntl.h >
#include < errno.h >

struct option{
 unsigned int datab;
    unsigned int parity;
    unsigned int stopb;
};

#define VS_MAGIC 's'

#define VS_SET_BAUD _IOW(VS_MAGIC, 0, unsigned int)
#define VS_GET_BAUD _IOR(VS_MAGIC, 1, unsigned int)
#define VS_SET_FFMT _IOW(VS_MAGIC, 2, struct option)
#define VS_GET_FFMT _IOR(VS_MAGIC, 3, struct option)

int main(int argc, char *argv[])
{
 int fd;
    int ret;
    unsigned int baud;
    struct option opt = {8,1,1};
    
    fd = open("/dev/vser0", O_RDWR);
    if (fd == -1)
        goto fail;
    
    baud = 9600;
    ret = ioctl(fd, VS_SET_BAUD, baud);
    if (ret == -1)
        goto fail;
    
    ret = ioctl(fd, VS_GET_BAUD, baud);
    if (ret == -1)
        goto fail;
    
    ret = ioctl(fd, VS_SET_FFMT, &opt);
    if (ret == -1)
        goto fail;
    
 ret = ioctl(fd, VS_GET_FFMT, &opt);
    if (ret == -1)
        goto fail;
    
    printf("baud rate:%d
", baud);
    printf("frame format: %d%d%d
", opt.datab, opt.parity, opt.stopb);

 close(fd);
    exit(EXIT_SUCCESS);
    
fail:
     perror("ioctl test");
     exit(EXIT_FAILURE);
}

運行結果：