添加字符设备ioctl

左手的ㄟ右手 2022-08-04 12:00 85阅读 0赞

ioctl 中幻数使用 范围文件kernel\\linux-3.0.y\\Documentation\\ioctl\\ioctl-number.txt

**功能：实现简单的字符操作（从用户空间向内核空间写入一串字符；从内核空间读一个字符到内核空间）**  
        众所周知，字符设备是linux下最基本，也是最常用到的设备，它是学习Linux驱动入门最好的选择，计算机的东西很多都是相通的，掌握了其中一块，其他就可以触类旁通了。在写驱动前，必须先搞清楚字符设备的框架大概是怎样的，弄清楚了流程，才开始动手，不要一开始就动手写代码！  
        这里所说的框架是参考LLD3上介绍的，内核是基于Linux 2.6，3.0以上的有些地方会不一样（主要是file\_operations中的ioctl修改了），但基本上适用，因为我就是在3.0的内核上实现的！字符设备驱动的初始化流程大概如下所示：

定义相关的设备文件结构体（如file\_operation()中的相关成员函数的定义）->向内核申请主设备号（建议采用动态方式） ->申请成功后，调用MAJOR()获取主设备号 ->初始化cdev的结构体，调用cdev\_init() ->调用cdev\_add()，注册cdev到kernel ->注册设备模块：module\_init()、module\_exit()。

======================================================================================================

**编写代码**

======================================================================================================

首先定义两个全局变量（主设备号和字符设备hellow）：

**                                                           static int hello\_major = 0;        /\* major device number \*/  
  
                                                           static struct cdev hellow;    /\* hello device structure \*/**

然后来看看file\_operations()，它的定义可以在../include/linux/fs.h下找到，这里只用到了其中的几个成员函数：

**/\* file operations for hello device \*/  
static struct file\_operations hello\_ops = \{  
    .owner = THIS\_MODULE,  /\*owner为所有者字段，防止在使用时模块被卸载。一边都设为THIS\_MODULE\*/  
    .open = hello\_open,  
    .read = hello\_read,  
    .write = hello\_write,  
    .release = hello\_release,**

**\};**

不同于windows驱动程序，Linux设备驱动程序在与硬件设备之间建立了标准的抽象接口。通过这个接口，用户可以像处理普通文件一样，通过open，close，read，write等系统调用对设备进行操作，如此一来也大大简化了linux驱动程序的开发。通过file\_operations这个结构体（实际上是一个函数指针的集合），把驱动的操作和设备号联系起来，程序员所要做的工作只是通过file\_operations挂接自己的系统调用函数。

![0_1321493164r020.gif][]

接下来就是实现open,close,read,write操作了，这个驱动什么都没干，所以很好理解，用户请求read系统调用时，这个虚拟设备反回相应长度的“A”字符串，用户write时，将内容显示到日志中。这里要注意的是，内核空间中不能使用用户态的malloc，而是使用kmalloc/kfree。而且，用户read/write提供的buf地址也是用户态的，内核自然不能直接访问，需要通过copy\_to\_user/copy\_from\_user 进行数据拷贝，具体如下：

**/\* Open the device \*/  
static int hello\_open( struct inode \*inode, struct file \*filp )\{  
    printk( KERN\_NOTICE"Hello device open!\\n" );  
    return 0;  
\}**

**/\* Close hello\_device \*/  
static int hello\_release( struct inode \*inode, struct file \*filp )\{  
    printk( KERN\_NOTICE"Hello device close!\\n" );  
    return 0;  
\}**

**/\* user read from hello device\*/  
ssize\_t hello\_read( struct file \*flip, char \_\_user \*buf, size\_t count,loff\_t  
                    \*f\_pos)\{  
    ssize\_t retval = 0;  
    char \*bank;  
    bank = kmalloc(count+1, GFP\_KERNEL );  
    if( bank == NULL )  
        return -1;  
    memset( bank, 'A',count );  
    if( copy\_to\_user( buf, bank, count ) )\{  
        retval = -EFAULT;  
        goto out;  
    \}  
    retval += count;  
    \*(bank+count)=0;  
    printk( KERN\_NOTICE"hello: user read %d bytes from me. %s\\n",count,bank );  
  out:  
    kfree(bank);  
    return retval;  
\}  
  
/\* write to hello device \*/  
ssize\_t hello\_write( struct file \*filp, const char \_\_user \*buf, size\_t count,  
                     loff\_t \*f\_pos )\{  
    ssize\_t retval = 0;  
    char \*bank = kmalloc( count ,GFP\_KERNEL );  
    if( bank == NULL )  
        return retval;  
    if( copy\_from\_user(bank, buf, count ) )\{  
        retval = -EFAULT;  
        printk( KERN\_NOTICE"hello: write error\\n" );  
        goto out;  
    \}  
    retval += count;  
    printk( KERN\_NOTICE"hello: user has written %d bytes to me: %s\\n",count,  
            bank );  
  out:  
    kfree(bank );  
    return retval;  
\}**

**      ** 你可能会注意到open和release函数头中的file和inode结构体，inode是内核内部文件的表示，当其指向一个字符设备时，其中的i\_cdev成员既包含了指向cdev结构的指针。而file表示打开的文件描述符，对一个文件，若打开多次，则会有多个file结构，但只有一个inode与之对应。

因为驱动工作在内核空间，不能使用用户空间的libc函数，所以程序中打印语句为内核提供的printk，而非printf，KERN\_NOTICE宏其实标记的是日志级别（共有八个）不同级别的消息会记录到不同的地方。如果你运行本模块，可能会发现printk语句并没有输出到控制台，这是正常的，控制台只显示一定级别的消息。当日志级别小于console\_loglevel时，消息才能显示出来。你可以通过dmsg命令看到这些信息，也可以通过修改日志级别使之输出到你的虚拟终端。

作好以上准备工作后，接下来就可以开始进行向内核申请主设备号了。设备号是干什么吃的？据LDD记载，对字符设备的访问是通过文件系统内的设备名称进行的。那些被称为特殊文件、设备文件的节点，通常位于/dev目录，如果ls -l 查看该目录，第一列中带有c标志的即为字符设备，有b标志的为块设备。而第5、6列所示的两个数字分别为设备的主、次设备号。通常，主设备号标识设备所用的驱动程序（现在大多设备仍然采用“一个主设备号对应一个驱动程序”的规则），次设备号用于确定设备，比如你有两块网卡，使用同一驱动，主设备号相同，那么他们将由次设备号区分。  
**/\* Module housekeeping \*/  
static int hello\_init(void)\{  
    int result;  
    dev\_t dev = MKDEV( hello\_major, 0 );/\*to transfer major as dev\_t type\*/  
  
    /\* alloc the major    device number dynamicly \*/  
    result = alloc\_chrdev\_region(&dev, 0 ,1, "hello" );  
    if( result < 0 )\{  
        printk( KERN\_NOTICE"Hello: unable to get major %d\\n",hello\_major );  
        return result;  
    \}  
    hello\_major = MAJOR(dev);  
    /\* set up devices, in this case, there is only one device \*/  
    printk( KERN\_NOTICE"hello init. major:%d, minor:%d\\n",hello\_major,0 );  
    //printk( KERN\_ALERT"hello init: %d, %d\\n",hello\_major,0 );  
    hello\_setup\_cdev(&hellow, 0 , &hello\_ops );  
      
    return 0;  
      
\}  
  
/\* Exit routine \*/  
static void hello\_exit(void)\{  
    /\* remove the cdev from kernel \*/  
    cdev\_del(&hellow );  
    /\* release the device numble alloced earlier \*/  
    unregister\_chrdev\_region( MKDEV( hello\_major, 0 ), 1 );  
    printk( KERN\_NOTICE"hello exit. major:%d,minor %d\\n",hello\_major,0 );  
\}**

这里主设备号的分配由alloc\_chrdev\_region（第一个参数为dev\_t 指针，用来存放设备编号，第二个参数为要使用的第一个次设备号，通常为0，第三个参数为请求的连续设备编号个数）动态分配，当然也可以静态指定一个未被使用的主设备号，相应函数为register\_chrdev\_region,但不推荐这样做。在模块被卸载时（hello\_exit）,通过unregister\_chrdev\_region释放设备号。MKDEV宏将给出的主、次设备号转换成dev\_t类型，MAJOR，MINOR分别从dev\_t中析取主次设备号。

这里几个函数的原型为：

**int register\_chrdev\_region(dev\_t first, unsigned int count, char \*name);**

**int alloc\_chrdev\_region(dev\_t \*dev, unsigned int firstminor, unsigned int count, char \*name);**

**void unregister\_chrdev\_region(dev\_t first, unsigned int count);**

然后进入hello\_setup\_cdev函数，对设备进行初始化这里cdev结构体是内核内部使用来表示字符设备的。在内核调用设备操作之前，必须分配并注册一个或多个这样的结构。为了方便，没有动态使用cdev\_alloc函数分配空间，而是定义了一个全局静态cdev变量。通常你可以将你的cdev嵌入到自定义的结构体中（这个驱动很naive，没有这么做），通过cdev\_init 函数初始化。最后调用cdev\_add()，注册cdev到内核。

**         /\* set up the cdev stucture for a device \*/  
static void hello\_setup\_cdev( struct cdev \*dev, int minor, struct  
file\_operations \*fops )\{  
    int err;  
    int devno = MKDEV( hello\_major, minor );  
    /\* initialize the cdev struct \*/  
    cdev\_init( dev,fops );  
    dev->owner = THIS\_MODULE;  
    err = cdev\_add( dev, devno, 1 ); /\* register the cdev in the kernel \*/  
    if( err )  
        printk( KERN\_NOTICE"Error %d adding hello%d\\n",err ,minor );  
\}**

最后module\_init( hello\_init ); module\_exit( hello\_exit );指定了模块初始化和关闭函数。MODULE\_LICENSE( "Dual BSD/GPL" );  指定模块使用的许可证能被内核识别的许可证有GPL、GPL v2、 Dual BSD/GPL、 Dual MPL/GPL、Proprietary（专有）等，如果模块没有显式标记许可证，则会被认定为“专有”，内核加载这样的模块会被“污染”。

**/\* register the init and exit routine of the module \*/  
module\_init( hello\_init );  
module\_exit( hello\_exit );**

**MODULE\_AUTHOR( "jabenwang" );  
MODULE\_LICENSE( "Dual BSD/GPL" );**

到这里，这个字符设备驱动已经完成，接下来就是编译它。

======================================================================================================

**编译代码**

======================================================================================================

这个是我写的makefile文件，在我台机上我没把这个模块加入到内核源码的字符设备目录下，而是放在了用户目录下面。但这个makefile文件对以上两种情况都支持：

\#wjb add 2011-10-21  
  
ifneq ($(KERNELRELEASE), )  
obj-m := hellow.o  
  
else  
  
KERNELDIR =/lib/modules/$(shell uname -r)/build  
PWD :=$(shell pwd)  
  
.PHONY: modules modules\_install clean  
  
modules:  
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules  
  
modules\_install:  
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules\_install  
  
clean:  
    $(MAKE) -C $(KERNELDIR) M=$(PWD) clean  
endif

======================================================================================================

**模块加载&设备文件节点构造：**

======================================================================================================

1. 编译成功后，会得到hellow.ko, 这时你就可以通过insmod命令加载模块

\# insmod hellow.ko

这时你的日志控制台中会出现hello\_init中的打印信息，如果你使用lsmod列出当前已加载模块，会发现hellow模块赫然在目:

**root@ubuntu:~/share/hellow\# ls  
a.out      hellow.ko     hellow.o  Makefile       Module.symvers  
hellow.c   hellow.mod.c  main.c    Makefile~  
hellow.c~  hellow.mod.o  main.c~   modules.order  
root@ubuntu:~/share/hellow\# insmod hellow.ko  
root@ubuntu:~/share/hellow\# dmesg | tail   
\[ 3711.851658\] hello init. major:251, minor:0**

2.要想使用驱动，你需要在/dev 目录下建立设备文件节点，语法是

**mknod \[***options***\]***name*** \{bc\} ***major minor*

这里需要知道设备的主、次设备号，何以知之？使用cat /proc/devices | grep hello 你就会得到其主设备号

比如我这里得知hellow的主设备号为251

那么就用下面的命令：

**root@ubuntu:~/share/hellow\# mknod /dev/hellow c 251 0**

c表示字符设备，这样就可以通过该设备文件操作设备了。

======================================================================================================

**测试程序：**

======================================================================================================

现在就可以通过系统调用操作设备了，我写了一个测试程序来调用：

\#include <stdio.h>    
\#include <fcntl.h>    
\#include <stdlib.h>    
\#include <string.h>    
\#include <sys/types.h>    
\#include <sys/stat.h>  
\#include <unistd.h>  
\#include <sys/ioctl.h>  
  
  
      int main(void)  
\{  
    int fd, ret;  
    char \*buf = " Hello world !";  
    char temp\[10\] = "0";  
    fd = open ( "/dev/hellow" , O\_RDWR);  
    if ( fd == -1 )  
    \{  
      perror("open");  
      exit(0);  
        \}  
  
        ret = write( fd, buf,strlen(buf));  
  
    if ( ret == -1 )  
    \{  
      perror("write");  
      exit(0);  
    \}  
      
        ret = read ( fd ,temp, strlen(temp) );  
    if ( ret == -1)  
    \{  
      perror("read");  
      exit(0);  
    \}  
  
    close(fd);  
    return 0;  
\}

编译之：

**root@ubuntu:~/share/hellow\# gcc main.c**

**生成的目标文件为a.out**

**运行之：**

root@ubuntu:~/share/hellow\# ./a.outroot@ubuntu:~/share/hellow\# dmesg | tail

**结果：**

**\[ 4082.930492\] Hello device open!  
\[ 4082.930520\] hello: user has written 14 bytes to me:  Hello world !  
\[ 4082.930524\] hello: user read 1 bytes from me. A**

**\[ 4082.930829\] Hello device close!**

当然，如果你想移除这个字符设备，可以输入如下命令：

**root@ubuntu:~/share/hellow\# rmmod hellow  
root@ubuntu:~/share/hellow\# dmesg | tail **

结果显示如下信息，说明已经移除：

**\[ 4344.602407\] hello exit. major:251,minor 0**

**平台：VMware 7.0 + Linux ubuntu 3.0.0-12-generic**

**编译器：gcc**

**参考资料：LDD 3**

**功能：实现ioctl功能**

在Linux字符设备驱动入门（一）中，我们实现了字符设备的简单读写字符功能，接下来我们要在这个基础上加入ioctl功能。首先，我们先来看看3.0内核下../include/linux/fs.h中file\_operations结构体的定义：

struct file\_operations \{  
    struct module \*owner;  
    loff\_t (\*llseek) (struct file \*, loff\_t, int);  
    ssize\_t (\*read) (struct file \*, char \_\_user \*, size\_t, loff\_t \*);  
    ssize\_t (\*write) (struct file \*, const char \_\_user \*, size\_t, loff\_t \*);  
    ssize\_t (\*aio\_read) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t);  
    ssize\_t (\*aio\_write) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t);  
    int (\*readdir) (struct file \*, void \*, filldir\_t);  
    unsigned int (\*poll) (struct file \*, struct poll\_table\_struct \*);  
 **   long (\*unlocked\_ioctl) (struct file \*, unsigned int, unsigned long);  
    long (\*compat\_ioctl) (struct file \*, unsigned int, unsigned long);**  
    int (\*mmap) (struct file \*, struct vm\_area\_struct \*);  
    int (\*open) (struct inode \*, struct file \*);  
    int (\*flush) (struct file \*, fl\_owner\_t id);  
    int (\*release) (struct inode \*, struct file \*);  
    int (\*fsync) (struct file \*, int datasync);  
    int (\*aio\_fsync) (struct kiocb \*, int datasync);  
    int (\*fasync) (int, struct file \*, int);  
    int (\*lock) (struct file \*, int, struct file\_lock \*);  
    ssize\_t (\*sendpage) (struct file \*, struct page \*, int, size\_t, loff\_t \*, int);  
    unsigned long (\*get\_unmapped\_area)(struct file \*, unsigned long, unsigned long, unsigned long, unsigned long);  
    int (\*check\_flags)(int);  
    int (\*flock) (struct file \*, int, struct file\_lock \*);  
    ssize\_t (\*splice\_write)(struct pipe\_inode\_info \*, struct file \*, loff\_t \*, size\_t, unsigned int);  
    ssize\_t (\*splice\_read)(struct file \*, loff\_t \*, struct pipe\_inode\_info \*, size\_t, unsigned int);  
    int (\*setlease)(struct file \*, long, struct file\_lock \*\*);  
    long (\*fallocate)(struct file \*file, int mode, loff\_t offset,  
              loff\_t len);  
\};

红色字体已经标出在kernel 3.0中已经完全删除了struct file\_operations 中的ioctl 函数指针，剩下**unlocked\_ioctl**和**compat\_ioctl**，取而代之的是unlocked\_ioctl,主要改进就是不再需要上大内核锁 （调用之前不再先调用lock\_kernel()然后再unlock\_kernel()）。

所以，在hellow.c中，我们在file\_operations中加入成员函数hello\_ioctl(红色字体部分）：

/\* file operations for hello device \*/  
static struct file\_operations hello\_ops = \{  
    .owner = THIS\_MODULE,  
**    .unlocked\_ioctl = hello\_ioctl,**  
    .open = hello\_open,  
    .read = hello\_read,  
    .write = hello\_write,  
    .release = hello\_release,  
\};

**hello\_ioctl()的定义如下：**

static int hello\_ioctl( struct file \*file,  
            unsigned int cmd, unsigned long arg)  
\{    int temp = 0;  
    switch(cmd)  
    \{  
      case HELLO\_CMD1:  
               \{  
            temp = 1;  
            if(copy\_to\_user( (int \*)arg, &temp, sizeof(int))) return -EFAULT;  
            break;  
               \}  
      case HELLO\_CMD2:  
            \{  
            temp = 2;  
            if(copy\_to\_user( (int \*)arg, &temp, sizeof(int))) return -EFAULT;  
            break;  
            \}  
    \}  
    printk( KERN\_NOTICE"ioctl CMD%d done!\\n",temp);      
  
return 0;  
  
\}

这里强调一下**cmd**的定义：

**\#define HELLO\_MAGIC 'k'  
\#define HELLO\_CMD1    \_IO(HELLO\_MAGIC,0x1a)  
\#define HELLO\_CMD2    \_IO(HELLO\_MAGIC,0x1b)**  
            其中'k'为幻数，要按照Linux内核的约定方法为驱动程序选择ioctl编号，应该首先看看include/asm/ioctl.h和Documentation/ioctl-number.txt这两个文件，下面是ioctl.h的部分内容，也是比较重要的：

\_IO(type, nr)  
       用于构造无参数的命令编号；  
\_IOR(type, nr, datatype)  
       用于构造从驱动程序中读取数据的命令编号；  
\_IOW(type, nr, datatype)  
       用于写入数据的命令；  
\_IOWR(type, nr, datatype)  
       用于双向传输。注意千万不能重复定义。

**注意**对幻数的编号千万不能重复定义，如ioctl-number.txt已经说明‘k'的编号已经被占用的范围为：

'k'    00-0F    linux/spi/spidev.h    conflict!  
'k'    00-05    video/kyro.h        conflict!

所以我们在这里分别编号为0x1a和0x1b，到这里，我们已经完成了对ioctl功能的编写，接下来就是在测试程序中利用系统调用来测试它。

=============================================================

ioctl测试程序

=============================================================  
\#include <stdio.h>    
\#include <fcntl.h>    
\#include <stdlib.h>    
\#include <string.h>    
\#include <sys/types.h>    
\#include <sys/stat.h>  
\#include <unistd.h>  
\#include <sys/ioctl.h>  
  
\#define HELLO\_MAGIC 'k'  //当然我们也可以定义一个相应的头文件，把ioctl的cmd放进里面，然后再include进 来  
\#define HELLO\_CMD1    \_IO(HELLO\_MAGIC,0x1a)  
\#define HELLO\_CMD2    \_IO(HELLO\_MAGIC,0x1b)  
  
      int main(void)  
\{  
    int ioctl\_rdata;  
    int fd, ret;

fd = open ( "/dev/hellow" , O\_RDWR);  
    if ( fd == -1 )  
    \{  
      perror("open");  
      exit(0);  
        \}

ret = ioctl( fd, HELLO\_CMD2,&ioctl\_rdata);  
    if ( ret == -1)  
    \{  
     perror("ioctl");  
     exit(0);  
    \}  
    printf("ioctl\_rdata= %d \\n",ioctl\_rdata);  
  
    close(fd);  
    return 0;  
\}  
=============================================================

运行结果

=============================================================

root@ubuntu:~/share/hellow\# insmod hellow.ko  
root@ubuntu:~/share/hellow\# mknod /dev/hellow c 251 0  
root@ubuntu:~/share/hellow\# ./a.out  
ioctl\_rdata= 2   
root@ubuntu:~/share/hellow\# dmesg | tail  
  
\[ 2431.126532\] hello init. major:251, minor:0  
\[ 2453.326022\] Hello device open!

\[ 2453.326047\] ioctl CMD2 done!  
\[ 2453.326487\] Hello device close!

转载自http://blog.csdn.net/coolkids\_2008/article/details/6982305

[0_1321493164r020.gif]: /images/20220731/9ab10b0ebb53417d8e8b5a7707dca349.png