盒子
盒子
文章目录
  1. 先决条件
  2. 用户空间和内核空间
  3. 用户空间和内核空间接口函数
  4. 内核空间和硬件设备之间的接口函数
  5. 第一个驱动:在用户空间加载和卸载驱动
  6. “Hello world”驱动:加载和移除内核空间的驱动
  7. 完整的memory驱动:驱动的初始部分
  8. memory驱动:连接设备和它的文件
  9. memory驱动:移除驱动
  10. memory驱动:把设备作为文件打开
  11. memory驱动:把设备作为文件关闭
  12. memory驱动:读设备
  13. memory驱动:写入设备
  14. 完整的memory驱动
  15. Footnotes

Writing Drivers in Linux:A Brief Tutorial

未完成,因为选的一门课的大作业而翻译,这个简单例子作为一个完整的内核驱动写法展示还行。大概某天会把后面的坑填上。

翻译自http://www.freesoftwaremagazine.com/articles/drivers_linux

你是否渴望有minix 1.1相伴的美好日子?那时男人只是男人,并为自己的设备写驱动程序。

—-Linus Torvalds

先决条件

为了开发Linux设备驱动,需要理解以下知识^1

  • C程序。稍微深入理解C编程,比如指针的使用,位操作函数等等。
  • 微处理器编程。需要理解微处理器内部如何工作:内存地址,终端等等。所有这些概念对一个汇编程序员都应该很熟悉。

在Linux中有多种设备。为了简洁,这篇教程仅仅涉及以模块加载的char(字符)设备,2.6.x内核将被使用(准确地说是Debian
Sarge下的2.6.8内核[^2], 当前的Debian Stable)

用户空间和内核空间

当你写设备驱动时,区分“用户空间”和“内核空间”非常重要:

  • 内核空间:Linux(一个内核)以一种简单有效的方式管理机器的硬件,为用户提供一个简单一致的程序接口。同样内核特别是它的设备驱动,组成了一个终端用户/程序员和硬件之间沟通的桥梁。组成内核(例如模块和设备驱动)一部分的任何子程序或函数都被认为是内核空间的一部分。
  • 用户空间:终端用户程序,像UNIX
    shell或其它基于GUI的应用(比如kpresenter^3)都是用户空间的一部分。显然,这些应用需要和系统硬件交互。然而,它们不直接交互,而是通过内核支持的函数。
    一切如图一所示。

图一

用户空间和内核空间接口函数

内核在用户空间提供一些子程序和函数,允许最终用户应用程序员和硬件交互。通常,在UNIX或Linux系统中,这个对话通过子程序或函数按顺序读写文件实现。这样做的原因是Unix设备从用户角度来看作为文件可见。

另一方面,在内核空间,Linux也提供了一些函数和子程序执行和硬件直接交互的低级操作,并且允许从内核空间向用户空间传递信息。

通常,对用户空间(允许使用设备或文件)的每个函数,存在一个内核空间(允许从内核想用户空间传递信息,反之亦然)的等价。这在表一中显示了,当前是空表。它将在不同设备驱动概念介绍时填满。

事件 用户空间函数 内核空间函数
加载模块
打开设备
读取设备
写入设备
关闭设备
移除模块

表一:设备驱动事件和它们对应在内核和用户空间的接口函数

内核空间和硬件设备之间的接口函数

在内核空间中也有控制设备或者在内核和硬件之间交换信息的函数。表二展示了这些概念。这个表也在相关概念引入时填满。

事件 内核空间函数
读取数据
写入数据

表二:设备驱动事件和它们在内核空间与硬件之间交互的函数

第一个驱动:在用户空间加载和卸载驱动

我将向你展示如何开发第一个设备驱动,这个驱动将作为一个模块引入。

我们在nothing.c文件中写入以下程序。

#include <linux/module.h>

MODULE_LICENSE("Dual BSD/GPL");

自从kernel2.6.x版本以来,编译模块变得有点复杂。首先,你必须有一个完整的编译内核源码树。如果你有个Debian
Sarge系统^4,你可以参照附录B(在文末),本文中我假设你们使用3.12.5版内核。

接着,你需要生成一个makefile文件,这个makefile文件命名为Makefile:

obj-m := nothing.o

与早先版本内核不同,现在必须使用你想要加载和使用模块的同一内核编译模块。为了编译它,键入:

$ make -C /usr/src/linux M=`pwd` modules

这个极简单的模块属于内核空间,一旦加载就是内核空间的一部分。

在用户空间,你可以作为root用户键入以下命令加载模块:

# insmod nothing.ko

insmod命令允许内核中模块的安装,然而,这个特别的模块没啥用。

可以通过查看所有安装的模块来检查模块有没有正确安装:

# lsmod | grep nothing

最后,可以从内核空间中移除内核:

# rmmod nothing

通过lsmod命令,你可以确认模块不在内核中了。

所有这些在表三中总结:

事件 用户空间函数 内核空间函数
加载模块 insmod
打开设备
读取设备
写入设备
关闭设备
移除模块

表三:设备驱动事件和它们对应在内核和用户空间的接口函数

“Hello world”驱动:加载和移除内核空间的驱动

当一个模块载入内核时,通常一些初始任务比如执行如重置设备、准备RAM,准备中断,准备输入/输出端口等等将被执行。

这些任务在内核空间执行,通过必须出现的两个函数(并且显示声明):module_initmodule_exit;它们应答用户空间内当加载和移除模块时使用的insmodrmmod命令。总之,用户命令insmodrmmod使用内核空间函数module_initmodule_exit

让我们看看经典程序Hello world的实际例子(hello.c):

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

MODULE_LICENSE("Dual BSD/GPL");

static int hello_init(void) {
  printk("<1> Hello world!\n");
  return 0;
}

static void hello_exit(void) {
  printk("<1> Bye, cruel world\n");
}

module_init(hello_init);
module_exit(hello_exit);

事实上函数hello_inithello_exit可以是任何想要的名字。然而,为了把它们作为相应的加载卸载函数,它们必须被作为module_initmodule_exit的参数。

printk函数已经介绍过。非常接近著名的printf除了它在内核中起作用。<1>表示消息的高优先级(低数字)。通过这样,除了在内核系统日志文件中得到消息,也能在系统控制台上收到消息。

这个模块可以用之前同样的命令编译,把它的名字加入Makefile。

obj-m := nothing.o hello.o

剩下的文章中,我们将Makefile文件作为读者的联系。完整的包含编译内核模块的Makefile文件在附录A中

当模块加载或卸载时,消息将通过printk命令呈现在系统控制台上。如果这些消息不再出现在控制台中,你可以通过dmesg命令查看,或者通过cat /var/log/syslog^5查看系统日志文件

表四展示了两个新函数。

事件 用户空间函数 内核空间函数
加载模块 insmod module_init
打开设备
读取设备
写入设备
关闭设备
移除模块 rmmod module_exit

表四:设备驱动事件和它们对应在内核和用户空间的接口函数

完整的memory驱动:驱动的初始部分

我现在展示如何构建一个完整的设备驱动:memory.c。这个设备讲允许字符从设备读取读取或写入设备。这个设备,尽管没啥用,却提供了一个展示的示例,因为这是一个完整的驱动。
它也非常容易实现,因为它不和一个真正的硬件设备交互(除了计算机自身)。

为了开发这个驱动,一些新的#include语句将被添加添加,这些语句频繁出现在设备驱动中。

memory initial=

/* 设备驱动必要的includes块 */
#include <linux/init.h>
// #include <linux/config.h>  // 2.6.19之后不再有
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
// #include <asm/system.h> /* cli(), *_flags */ // 不再需要
#include <asm/uaccess.h> /* copy_from/to_user */

MODULE_LICENSE("Dual BSD/GPL");

/* memory.c 中函数声明 */
int memory_open(struct inode *inode, struct file *filp);
int memory_release(struct inode *inode, struct file *filp);
ssize_t memory_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t memory_write(struct file *filp, char *buf, size_t count, loff_t *f_pos);
void memory_exit(void);
int memory_init(void);

/* 声明常用文件的结构体 */
/* 结构体file_operations在头文件
linux/fs.h中定义,用来存储驱动内核模块提供的对
设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的
事务的函数的地址。*/
/* 存取函数 */
struct file_operations memory_fops = {
  read: memory_read,
  write: memory_write,
  open: memory_open,
  release: memory_release
};

/* 声明初始和退出函数 */
module_init(memory_init);
module_exit(memory_exit);

/* 驱动全局变量声明 */
/* Major number */
int memory_major = 60;
/* 存储数据的缓冲区 */
char *memory_buffer;

#include文件之后,先声明之后要定义的函数。操作文件的通用函数一般在file_operations结构体中定义中声明。这些将在下文详细解释。

接着,初始化和退出函数——当加载和卸载模块时使用的函数——像内核声明。

最后,声明驱动的全局变量:一条是驱动的major number,另一条是指向内存一段区域的指针memory_buffer,这个用来存储驱动数据。

memory驱动:连接设备和它的文件

在UNIX和Linux中,用户空间设备的存取和文件存取完全一样。这些设备文件通常是目录/dev下的子目录。

为了连接正常文件到内核模块需要两个数:major numberminor numbermajor number是内核用来链接文件和它的驱动的。minor number是设备内部使用的,简单起见,本文不讨论它。

为了实现这个,必须创建一个文件(将用来存取设备驱动),通过在root权限下键入:

# mknod /dev/memory c 60 0

其中c代表创建char设备,60major number0minor number

在驱动内,为了在内核空间中链接它相应的/dev文件,使用register_chrdev函数。传递给它三个参数:major number,一个显示模块名的字符串和一个file_operations结构体。这个结构体将把它定义的文件函数链接到调用。
当安装模块时以这种方式调用。

memory init module

int memory_init(void) {
    int result;

    /* Registering device */
    result = register_chrdev(memory_major, "memory", &memory_fops);
    if (result < 0) {
        printk(
                "<1>memory: cannot obtain major number %d\n", memory_major);
        return result;
    }

    /* Allocating memory for the buffer */
    memory_buffer = kmalloc(1, GFP_KERNEL);
    if (!memory_buffer) {
        result = -ENOMEM;  // 内存耗尽
        goto fail;
    }
    memset(memory_buffer, 0, 1);

    printk("<1>Inserting memory module\n");
    return 0;

fail:
    memory_exit();
    return result;
}

注意kmalloc函数,这个函数用来在内核空间中的设备驱动分配缓冲区内存。它的用法非常类似知名的malloc函数。
最后,如果注册major number或者分配内存失败,模块做出相应反应。

memory驱动:移除驱动

为了在memory_exit函数中移除模块,函数unregister_chrdev需要出现,来为内核释放major number

<memory exit module>=

void memory_exit(void) {
    /* Freeing the major number */
    unregister_chrdev(memory_major, "memory");

    /* Freeing buffer memory */
    if (memory_buffer) {
        kfree(memory_buffer);
    }
    printk("<1>Removing memory module\n");
}

为了当移除设备驱动时留下一个干净的内核。在这个函数中同时释放了缓冲区内存。

memory驱动:把设备作为文件打开

内核空间函数,对应于在用户空间打开文件的fopen,是register_chrdev调用的file_operationsopen:的一个成员,这个例子中是memory_open函数。它以inode结构体做参数,这个参数参照major numberminor number向内核传递信息;
一个带各种能执行到文件上的各种不同操作相关信息的file结构体。任意这些函数都不会在本文中深入讲解。

当文件打开时,通常必须初始化驱动变量或者重置设备,在这个简单的例子中,尽管如此,不会执行这些操作。

memory_open函数如下所示:

<memory open>=

int memory_open(struct inode *inode, struct file *filp) {

  /* Success */
  return 0;
}

这些新的函数现在展示在表五中。

事件 用户空间函数 内核空间函数
加载模块 insmod module_init
打开设备 fopen file_operations:open
读取设备
写入设备
关闭设备
移除模块 rmmod module_exit

表五:设备驱动事件和它们对应在内核和用户空间的接口函数

memory驱动:把设备作为文件关闭

与用户空间内(fclose)对应的关闭文件函数是register_chrdev调用的file_operations结构体的release:成员。
针对本例,是memory_release函数,这个函数有一个inode结构体参数和一个file结构体参数,就像先前一样。

当一个文件被关闭时,通常必须释放使用的内存和任何有关打开设备的变量。但是,再次,为了简单起见,这些操作不执行。

memory_release函数如下所示:

<memory release>=

int memory_release(struct inode *inode, struct file *filp) {

    /* Success */
    return 0;
}

新的函数在表六中展示。

事件 用户空间函数 内核空间函数
加载模块 insmod module_init
打开设备 fopen file_operations:open
读取设备
写入设备
关闭设备 fclose file_operations:release
移除模块 rmmod module_exit

表六:设备驱动事件和它们对应在内核和用户空间的接口函数

memory驱动:读设备

类似使用用户函数fread读设备,内核空间是register_chrdev函数调用的file_operations结构体的read:成员。这次是函数memory_read。它的参数是file结构、一个用户空间函数(fread)用来读的缓冲区(buf)、一个记着要传输多少字节,和用户空间函数(fread)中计数器有相同值的的计数器(count)、最后,开始读文件的位置(f_pos)。

在这个简单的例子中,memory_read函数通过函数copy_to_user从驱动缓冲区(memory_buffer)传输单个字节给用户空间:

<memory read>=

ssize_t memory_read(struct file *filp, char *buf,
        size_t count, loff_t *f_pos) {

    /* Transfering data to user space */
    copy_to_user(buf,memory_buffer,1);

    /* Changing reading position as best suits */
    if (*f_pos == 0) {
        *f_pos+=1;
        return 1;
    } else {
        return 0;
    }
}

表七展示了这些新函数。

事件 用户空间函数 内核空间函数
加载模块 insmod module_init
打开设备 fopen file_operations:open
读取设备 fread file_operations:read
写入设备
关闭设备 fclose file_operations:release
移除模块 rmmod module_exit

表七:设备驱动事件和它们对应在内核和用户空间的接口函数

memory驱动:写入设备

类似在用户空间函数fwrite写入设备,内核空间中使用register_chrdev函数调用的file_operations结构体中write:成员。
这个例子中是memory_write,拥有以下参数:一个file结构,一个用户空间函数fwrite用来写入的缓冲区(buf)、一个就像用户空间函数(fwrite)中计数器相同的值的计算传输字节数的计数器(count)、最后,是一个从文件何处开始的位置参数f_pos

<memory write>=

ssize_t memory_write( struct file *filp, char *buf,
        size_t count, loff_t *f_pos) {

    char *tmp;

    tmp=buf+count-1;
    copy_from_user(memory_buffer,tmp,1);
    return 1;
}

在本例中,函数copy_from_user从用户空间向内核空间传输数据。

表八显示了这个新函数

事件 用户空间函数 内核空间函数
加载模块 insmod module_init
打开设备 fopen file_operations:open
读取设备 fread file_operations:read
写入设备 fwrite file_operations:write
关闭设备 fclose file_operations:release
移除模块 rmmod module_exit

表八:设备驱动事件和它们对应在内核和用户空间的接口函数

完整的memory驱动

把先前展示的代码结合起来,就是完整的代码:

<memory.c>=

<memory initial>
<memory init module>
<memory exit module>
<memory open>
<memory release>
<memory read>
<memory write>

在设备能使用之前,你必须像上文所述一样编译模块,然后装载:

# insmod memory.ko

更改设备权限:

# chmod 666 /dev/memory

如果一切安好,你将有一个/dev/memory的设备,你可以写入字符串并且它将存储最后一个。你可以执行像这样的操作:

$ echo -n abcdef >/dev/memory

使用cat检查设备中的内容:

$ cat /dev/memory

存储的值不会变化,直到它被覆盖或者模块被移除。

Footnotes

[^2]:我是gentoo linux下的3.12.5-ck,现在debian stable已经7 wheezy了