网络通讯 --> IO多路复用之select、poll、epoll详解

IO多路复用之select、poll、epoll详解

1、使用场景

2、select、poll、epoll简介

一、select

　　select目前几乎在全部的平台上支持， 其良好跨平台支持也是它的一个优势。select的一个缺点在于单个进程可以监视的文件描述符的数量存在最大限制，在Linux上通常为1024，能够经过修改宏定义甚至从新编译内核的方式提高这一限制，可是这样也会形成效率的下降。

 

select本质上是经过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是：

一、select最大的缺陷就是单个进程所打开的FD是有必定限制的，它由FD_SETSIZE设置，默认值是1024。

　　通常来讲这个数目和系统内存关系很大，具体数目能够cat /proc/sys/fs/file-max察看。32位机默认是1024个。64位机默认是2048.

二、对socket进行扫描时是线性扫描，即采用轮询的方法，效率较低。

　　当套接字比较多的时候，每次select()都要经过遍历FD_SETSIZE个Socket来完成调度，无论哪一个Socket是活跃的，都遍历一遍。这会浪费不少CPU时间。若是能给套接字注册某个回调函数，当他们活跃时，自动完成相关操做，那就避免了轮询，这正是epoll与kqueue作的。

三、须要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大。

 

二、poll

基本原理： poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，而后查询每一个fd对应的设备状态，若是设备就绪则在设备等待队列中加入一项并继续遍历，若是遍历完全部fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后它又要再次遍历fd。这个过程经历了屡次无谓的遍历。

 

它没有最大链接数的限制，缘由是它是基于链表来存储的，可是一样有一个缺点：

1）大量的fd的数组被总体复制于用户态和内核地址空间之间，而无论这样的复制是否是有意义。

2）poll还有一个特色是“水平触发”，若是报告了fd后，没有被处理，那么下次poll时会再次报告该fd。

 

注意：从上面看，select和poll都须要在返回后， 经过遍历文件描述符来获取已经就绪的socket。事实上， 同时链接的大量客户端在一时刻可能只有不多的处于就绪状态，所以随着监视的描述符数量的增加，其效率也会线性降低。

 

三、epoll

　　epoll是在2.6内核中提出的，是以前的select和poll的加强版本。相对于select和poll来讲，epoll更加灵活，没有描述符限制。 epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

 

基本原理： epoll支持水平触发和边缘触发，最大的特色在于边缘触发，它只告诉进程哪些fd刚刚变为就绪态，而且只会通知一次。还有一个特色是， epoll使用“事件”的就绪通知方式，经过epoll_ctl注册fd， 一旦该fd就绪，内核就会采用相似callback的回调机制来激活该fd，epoll_wait即可以收到通知。

 

epoll的优势：

一、没有最大并发链接的限制，能打开的FD的上限远大于1024（1G的内存上能监听约10万个端口）。

二、效率提高，不是轮询的方式，不会随着FD数目的增长效率降低。

　　只有活跃可用的FD才会调用callback函数； 即Epoll最大的优势就在于它只管你“活跃”的链接，而跟链接总数无关，所以在实际的网络环境中，Epoll的效率就会远远高于select和poll。

三、内存拷贝，利用mmap()文件映射内存加速与内核空间的消息传递；即epoll使用mmap减小复制开销。

 

epoll对文件描述符的操做有两种模式： LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别以下：

LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序， 应用程序能够不当即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序， 应用程序必须当即处理该事件。若是不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

一、LT模式

　　LT(level triggered)是缺省的工做方式，而且同时支持block和no-block socket。在这种作法中，内核告诉你一个文件描述符是否就绪了，而后你能够对这个就绪的fd进行IO操做。 若是你不做任何操做，内核仍是会继续通知你的。

二、ET模式

　　ET(edge-triggered)是高速工做方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核经过epoll告诉你。而后它会假设你知道文件描述符已经就绪，而且不会再为那个文件描述符发送更多的就绪通知，直到你作了某些操做致使那个文件描述符再也不为就绪状态了(好比，你在发送，接收或者接收请求，或者发送接收的数据少于必定量时致使了一个EWOULDBLOCK 错误）。 可是请注意，若是一直不对这个fd做IO操做(从而致使它再次变成未就绪)，内核不会发送更多的通知(only once)。

　　ET模式在很大程度上减小了epoll事件被重复触发的次数，所以效率要比LT模式高。epoll工做在ET模式的时候， 必须使用非阻塞套接口，以免因为一个文件句柄的阻塞读/阻塞写操做把处理多个文件描述符的任务饿死。

三、在select/poll中， 进程只有在调用必定的方法后，内核才对全部监视的文件描述符进行扫描，而epoll事先经过epoll_ctl()来注册一个文件描述符， 一旦基于某个文件描述符就绪时，内核会采用相似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便获得通知。( 此处去掉了遍历文件描述符，而是经过监听回调的的机制。这正是epoll的魅力所在。)

注意：若是没有大量的idle-connection或者dead-connection，epoll的效率并不会比select/poll高不少，可是当遇到大量的idle-connection，就会发现epoll的效率大大高于select/poll。

 

3、select、poll、epoll区别

一、支持一个进程所能打开的最大链接数

 

二、FD剧增后带来的IO效率问题

 

三、消息传递方式

 

详述socket编程之select()和poll()函数

select()函数和poll()函数均是主要用来处理多路I/O复用的状况。好比一个服务器既想等待输入终端到来，又想等待若干个套接字有客户请求到达，这时候就须要借助select或者poll函数了。

（一）select()函数

原型以下：

css

各个参数含义以下：html

• int fdsp1:最大描述符值 + 1
• fd_set *readfds:对可读感兴趣的描述符集
• fd_set *writefds:对可写感兴趣的描述符集
• fd_set *errorfds:对出错感兴趣的描述符集
• struct timeval *timeout:超时时间（注意：对于linux系统，此参数没有const限制，每次select调用完毕timeout的值都被修改成剩余时间，而unix系统则不会改变timeout值）

select函数会在发生如下状况时返回：node

1. readfds集合中有描述符可读
2. writefds集合中有描述符可写
3. errorfds集合中有描述符遇到错误条件
4. 指定的超时时间timeout到了

当select返回时，描述符集合将被修改以指示哪些个描述符正处于可读、可写或有错误状态。能够用FD_ISSET宏对描述符进行测试以找到状态变化的描述符。若是select由于超时而返回的话，全部的描述符集合都将被清空。
select函数返回状态发生变化的描述符总数。返回0意味着超时。失败则返回-1并设置errno。可能出现的错误有：EBADF（无效描述符）、EINTR（因终端而返回）、EINVAL（nfds或timeout取值错误）。
设置描述符集合一般用以下几个宏定义：

linux

如:

ios

当select返回的时候，rset位都将被置0，除了那些有变化的fd位。
当发生以下状况时认为是可读的：程序员

1. socket的receive buffer中的字节数大于socket的receive buffer的low-water mark属性值。（low-water mark值相似于分水岭，当receive buffer中的字节数小于low-water mark值的时候，认为socket还不可读，只有当receive buffer中的字节数达到必定量的时候才认为socket可读）
2. 链接半关闭（读关闭，即收到对端发来的FIN包）
3. 发生变化的描述符是被动套接字，而链接的三路握手完成的数量大于0，即有新的TCP链接创建
4. 描述符发生错误，若是调用read系统调用读套接字的话会返回-1。

当发生以下状况时认为是可写的：web

1. socket的send buffer中的字节数大于socket的send buffer的low-water mark属性值以及socket已经链接或者不须要链接（如UDP）。
2. 写半链接关闭，调用write函数将产生SIGPIPE
3. 描述符发生错误，若是调用write系统调用写套接字的话会返回-1。

注意：
select默认能处理的描述符数量是有上限的，为FD_SETSIZE的大小。
对于timeout参数，若是置为NULL，则表示wait forever；若timeout->tv_sec = timeout->tv_usec = 0，则表示do not wait at all；不然指定等待时间。
若是使用select处理多个套接字，那么须要使用一个数组（也能够是其余结构）来记录各个描述符的状态。而使用poll则不须要，下面看poll函数。

（二）poll()函数

原型以下：

算法

各参数含义以下：sql

• struct pollfd *fdarray:一个结构体，用来保存各个描述符的相关状态。
• unsigned long nfds:fdarray数组的大小，即里面包含有效成员的数量。
• int timeout:设定的超时时间。（以毫秒为单位）

poll函数返回值及含义以下：编程

• -1：有错误产生
• 0：超时时间到，并且没有描述符有状态变化
• >0：有状态变化的描述符个数

着重讲fdarray数组，由于这是它和select()函数主要的不一样的地方：
pollfd的结构以下：

其实poll()和select()函数要处理的问题是相同的，只不过是不一样组织在几乎相同时刻同时推出的，所以才同时保留了下来。select()函数把可读描述符、可写描述符、错误描述符分在了三个集合里，这三个集合都是用bit位来标记一个描述符，一旦有若干个描述符状态发生变化，那么它将被置位，而其余没有发生变化的描述符的bit位将被clear，也就是说select()的readset、writeset、errorset是一个value-result类型，经过它们传值，而也经过它们返回结果。这样的一个坏处是每次从新select 的时候对集合必须从新赋值。而poll()函数则与select()采用的方式不一样，它经过一个结构数组保存各个描述符的状态，每一个结构体第一项fd表明描述符，第二项表明要监听的事件，也就是感兴趣的事件，而第三项表明poll()返回时描述符的返回状态。合法状态以下：

• POLLIN:                有普通数据或者优先数据可读
• POLLRDNORM:    有普通数据可读
• POLLRDBAND:    有优先数据可读
• POLLPRI:              有紧急数据可读
• POLLOUT:            有普通数据可写
• POLLWRNORM:   有普通数据可写
• POLLWRBAND:    有紧急数据可写
• POLLERR:            有错误发生
• POLLHUP:            有描述符挂起事件发生
• POLLNVAL:          描述符非法

对于POLLIN | POLLPRI等价与select()的可读事件；POLLOUT | POLLWRBAND等价与select()的可写事件；POLLIN 等价与POLLRDNORM | POLLRDBAND，而POLLOUT等价于POLLWRBAND。若是你对一个描述符的可读事件和可写事件以及错误等事件均感兴趣那么你应该都进行相应的设置。
对于timeout的设置以下：

• INFTIM:   wait forever
• 0:            return immediately, do not block
• >0:         wait specified number of milliseconds

Linux IO模式及 select、poll、epoll详解

同步IO和异步IO，阻塞IO和非阻塞IO分别是什么，到底有什么区别？不一样的人在不一样的上下文下给出的答案是不一样的。因此先限定一下本文的上下文。

本文讨论的背景是Linux环境下的network IO。

一 概念说明

在进行解释以前，首先要说明几个概念：
- 用户空间和内核空间
- 进程切换
- 进程的阻塞
- 文件描述符
- 缓存 I/O

用户空间与内核空间

如今操做系统都是采用虚拟存储器，那么对32位操做系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。操做系统的核心是内核，独立于普通的应用程序，能够访问受保护的内存空间，也有访问底层硬件设备的全部权限。为了保证用户进程不能直接操做内核（kernel），保证内核的安全，操心系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间。针对linux操做系统而言，将最高的1G字节（从虚拟地址0xC0000000到0xFFFFFFFF），供内核使用，称为内核空间，而将较低的3G字节（从虚拟地址0x00000000到0xBFFFFFFF），供各个进程使用，称为用户空间。

进程切换

为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复之前挂起的某个进程的执行。这种行为被称为进程切换。所以能够说，任何进程都是在操做系统内核的支持下运行的，是与内核紧密相关的。

从一个进程的运行转到另外一个进程上运行，这个过程当中通过下面这些变化：
1. 保存处理机上下文，包括程序计数器和其余寄存器。
2. 更新PCB信息。
3. 把进程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。
4. 选择另外一个进程执行，并更新其PCB。
5. 更新内存管理的数据结构。
6. 恢复处理机上下文。

注：总而言之就是很耗资源，具体的能够参考这篇文章：进程切换

进程的阻塞

正在执行的进程，因为期待的某些事件未发生，如请求系统资源失败、等待某种操做的完成、新数据还没有到达或无新工做作等，则由系统自动执行阻塞原语(Block)，使本身由运行状态变为阻塞状态。可见，进程的阻塞是进程自身的一种主动行为，也所以只有处于运行态的进程（得到CPU），才可能将其转为阻塞状态。当进程进入阻塞状态，是不占用CPU资源的。

文件描述符fd

文件描述符（File descriptor）是计算机科学中的一个术语，是一个用于表述指向文件的引用的抽象化概念。

文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者建立一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写每每会围绕着文件描述符展开。可是文件描述符这一律念每每只适用于UNIX、Linux这样的操做系统。

缓存 I/O

缓存 I/O 又被称做标准 I/O，大多数文件系统的默认 I/O 操做都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操做系统会将 I/O 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操做系统内核的缓冲区中，而后才会从操做系统内核的缓冲区拷贝到应用程序的地址空间。

缓存 I/O 的缺点：
数据在传输过程当中须要在应用程序地址空间和内核进行屡次数据拷贝操做，这些数据拷贝操做所带来的 CPU 以及内存开销是很是大的。

二 IO模式

刚才说了，对于一次IO访问（以read举例），数据会先被拷贝到操做系统内核的缓冲区中，而后才会从操做系统内核的缓冲区拷贝到应用程序的地址空间。因此说，当一个read操做发生时，它会经历两个阶段：
1. 等待数据准备 (Waiting for the data to be ready)
2. 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)

正式由于这两个阶段，linux系统产生了下面五种网络模式的方案。
- 阻塞 I/O（blocking IO）
- 非阻塞 I/O（nonblocking IO）
- I/O 多路复用（ IO multiplexing）
- 信号驱动 I/O（ signal driven IO）
- 异步 I/O（asynchronous IO）

注：因为signal driven IO在实际中并不经常使用，因此我这只说起剩下的四种IO Model。

阻塞 I/O（blocking IO）

在linux中，默认状况下全部的socket都是blocking，一个典型的读操做流程大概是这样：

当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来讲，不少时候数据在一开始尚未到达。好比，尚未收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来）。这个过程须要等待，也就是说数据被拷贝到操做系统内核的缓冲区中是须要一个过程的。而在用户进程这边，整个进程会被阻塞（固然，是进程本身选择的阻塞）。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，而后kernel返回结果，用户进程才解除block的状态，从新运行起来。

因此，blocking IO的特色就是在IO执行的两个阶段都被block了。

非阻塞 I/O（nonblocking IO）

linux下，能够经过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操做时，流程是这个样子：

当用户进程发出read操做时，若是kernel中的数据尚未准备好，那么它并不会block用户进程，而是马上返回一个error。从用户进程角度讲 ，它发起一个read操做后，并不须要等待，而是立刻就获得了一个结果。用户进程判断结果是一个error时，它就知道数据尚未准备好，因而它能够再次发送read操做。一旦kernel中的数据准备好了，而且又再次收到了用户进程的system call，那么它立刻就将数据拷贝到了用户内存，而后返回。

因此，nonblocking IO的特色是用户进程须要不断的主动询问kernel数据好了没有。

I/O 多路复用（ IO multiplexing）

IO multiplexing就是咱们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。select/epoll的好处就在于单个process就能够同时处理多个网络链接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的全部socket，当某个socket有数据到达了，就通知用户进程。

当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”全部select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操做，将数据从kernel拷贝到用户进程。

因此，I/O 多路复用的特色是经过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select()函数就能够返回。

这个图和blocking IO的图其实并无太大的不一样，事实上，还更差一些。由于这里须要使用两个system call (select 和 recvfrom)，而blocking IO只调用了一个system call (recvfrom)。可是，用select的优点在于它能够同时处理多个connection。

因此，若是处理的链接数不是很高的话，使用select/epoll的web server不必定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优点并非对于单个链接能处理得更快，而是在于能处理更多的链接。）

在IO multiplexing Model中，实际中，对于每个socket，通常都设置成为non-blocking，可是，如上图所示，整个用户的process实际上是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

异步 I/O（asynchronous IO）

inux下的asynchronous IO其实用得不多。先看一下它的流程：

用户进程发起read操做以后，马上就能够开始去作其它的事。而另外一方面，从kernel的角度，当它受到一个asynchronous read以后，首先它会马上返回，因此不会对用户进程产生任何block。而后，kernel会等待数据准备完成，而后将数据拷贝到用户内存，当这一切都完成以后，kernel会给用户进程发送一个signal，告诉它read操做完成了。

总结

blocking和non-blocking的区别

调用blocking IO会一直block住对应的进程直到操做完成，而non-blocking IO在kernel还准备数据的状况下会马上返回。

synchronous IO和asynchronous IO的区别

在说明synchronous IO和asynchronous IO的区别以前，须要先给出二者的定义。POSIX的定义是这样子的：
- A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;
- An asynchronous I/O operation does not cause the requesting process to be blocked;

二者的区别就在于synchronous IO作”IO operation”的时候会将process阻塞。按照这个定义，以前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO。

有人会说，non-blocking IO并无被block啊。这里有个很是“狡猾”的地方，定义中所指的”IO operation”是指真实的IO操做，就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候，若是kernel的数据没有准备好，这时候不会block进程。可是，当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，这个时候进程是被block了，在这段时间内，进程是被block的。

而asynchronous IO则不同，当进程发起IO 操做以后，就直接返回不再理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程当中，进程彻底没有被block。

各个IO Model的比较如图所示：

经过上面的图片，能够发现non-blocking IO和asynchronous IO的区别仍是很明显的。在non-blocking IO中，虽然进程大部分时间都不会被block，可是它仍然要求进程去主动的check，而且当数据准备完成之后，也须要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则彻底不一样。它就像是用户进程将整个IO操做交给了他人（kernel）完成，而后他人作完后发信号通知。在此期间，用户进程不须要去检查IO操做的状态，也不须要主动的去拷贝数据。

三 I/O 多路复用之select、poll、epoll详解

select，poll，epoll都是IO多路复用的机制。I/O多路复用就是经过一种机制，一个进程能够监视多个描述符，一旦某个描述符就绪（通常是读就绪或者写就绪），可以通知程序进行相应的读写操做。但select，poll，epoll本质上都是同步I/O，由于他们都须要在读写事件就绪后本身负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需本身负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。（这里啰嗦下）

select

int select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

select 函数监视的文件描述符分3类，分别是writefds、readfds、和exceptfds。调用后select函数会阻塞，直到有描述副就绪（有数据 可读、可写、或者有except），或者超时（timeout指定等待时间，若是当即返回设为null便可），函数返回。当select函数返回后，能够 经过遍历fdset，来找到就绪的描述符。

select目前几乎在全部的平台上支持，其良好跨平台支持也是它的一个优势。select的一 个缺点在于单个进程可以监视的文件描述符的数量存在最大限制，在Linux上通常为1024，能够经过修改宏定义甚至从新编译内核的方式提高这一限制，但 是这样也会形成效率的下降。

poll

int poll (struct pollfd *fds, unsigned int nfds, int timeout); 

不一样与select使用三个位图来表示三个fdset的方式，poll使用一个 pollfd的指针实现。

struct pollfd {
    int fd; /* file descriptor */
    short events; /* requested events to watch */ short revents; /* returned events witnessed */ }; 

pollfd结构包含了要监视的event和发生的event，再也不使用select“参数-值”传递的方式。同时，pollfd并无最大数量限制（可是数量过大后性能也是会降低）。 和select函数同样，poll返回后，须要轮询pollfd来获取就绪的描述符。

从上面看，select和poll都须要在返回后，经过遍历文件描述符来获取已经就绪的socket。事实上，同时链接的大量客户端在一时刻可能只有不多的处于就绪状态，所以随着监视的描述符数量的增加，其效率也会线性降低。

epoll

epoll是在2.6内核中提出的，是以前的select和poll的加强版本。相对于select和poll来讲，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

一 epoll操做过程

epoll操做过程须要三个接口，分别以下：

int epoll_create(int size)；//建立一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)； int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout); 

1. int epoll_create(int size);
建立一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大，这个参数不一样于select()中的第一个参数，给出最大监听的fd+1的值，参数size并非限制了epoll所能监听的描述符最大个数，只是对内核初始分配内部数据结构的一个建议。
当建立好epoll句柄后，它就会占用一个fd值，在linux下若是查看/proc/进程id/fd/，是可以看到这个fd的，因此在使用完epoll后，必须调用close()关闭，不然可能致使fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
函数是对指定描述符fd执行op操做。
- epfd：是epoll_create()的返回值。
- op：表示op操做，用三个宏来表示：添加EPOLL_CTL_ADD，删除EPOLL_CTL_DEL，修改EPOLL_CTL_MOD。分别添加、删除和修改对fd的监听事件。
- fd：是须要监听的fd（文件描述符）
- epoll_event：是告诉内核须要监听什么事，struct epoll_event结构以下：

struct epoll_event {
  __uint32_t events;  /* Epoll events */
  epoll_data_t data;  /* User data variable */ }; //events能够是如下几个宏的集合： EPOLLIN ：表示对应的文件描述符能够读（包括对端SOCKET正常关闭）； EPOLLOUT：表示对应的文件描述符能够写； EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）； EPOLLERR：表示对应的文件描述符发生错误； EPOLLHUP：表示对应的文件描述符被挂断； EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来讲的。 EPOLLONESHOT：只监听一次事件，当监听完此次事件以后，若是还须要继续监听这个socket的话，须要再次把这个socket加入到EPOLL队列里 

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待epfd上的io事件，最多返回maxevents个事件。
参数events用来从内核获得事件的集合，maxevents告以内核这个events有多大，这个maxevents的值不能大于建立epoll_create()时的size，参数timeout是超时时间（毫秒，0会当即返回，-1将不肯定，也有说法说是永久阻塞）。该函数返回须要处理的事件数目，如返回0表示已超时。

二 工做模式

　epoll对文件描述符的操做有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别以下：
　　LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序能够不当即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。
　　ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须当即处理该事件。若是不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

1. LT模式

LT(level triggered)是缺省的工做方式，而且同时支持block和no-block socket.在这种作法中，内核告诉你一个文件描述符是否就绪了，而后你能够对这个就绪的fd进行IO操做。若是你不做任何操做，内核仍是会继续通知你的。

2. ET模式

ET(edge-triggered)是高速工做方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核经过epoll告诉你。而后它会假设你知道文件描述符已经就绪，而且不会再为那个文件描述符发送更多的就绪通知，直到你作了某些操做致使那个文件描述符再也不为就绪状态了(好比，你在发送，接收或者接收请求，或者发送接收的数据少于必定量时致使了一个EWOULDBLOCK 错误）。可是请注意，若是一直不对这个fd做IO操做(从而致使它再次变成未就绪)，内核不会发送更多的通知(only once)

ET模式在很大程度上减小了epoll事件被重复触发的次数，所以效率要比LT模式高。epoll工做在ET模式的时候，必须使用非阻塞套接口，以免因为一个文件句柄的阻塞读/阻塞写操做把处理多个文件描述符的任务饿死。

3. 总结

假若有这样一个例子：
1. 咱们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符
2. 这个时候从管道的另外一端被写入了2KB的数据
3. 调用epoll_wait(2)，而且它会返回RFD，说明它已经准备好读取操做
4. 而后咱们读取了1KB的数据
5. 调用epoll_wait(2)......

LT模式：
若是是LT模式，那么在第5步调用epoll_wait(2)以后，仍然能受到通知。

ET模式：
若是咱们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志，那么在第5步调用epoll_wait(2)以后将有可能会挂起，由于剩余的数据还存在于文件的输入缓冲区内，并且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工做模式才会汇报事件。所以在第5步的时候，调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。

当使用epoll的ET模型来工做时，当产生了一个EPOLLIN事件后，
读数据的时候须要考虑的是当recv()返回的大小若是等于请求的大小，那么颇有多是缓冲区还有数据未读完，也意味着该次事件尚未处理完，因此还须要再次读取：

while(rs){
  buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
  if(buflen < 0){ // 因为是非阻塞的模式,因此当errno为EAGAIN时,表示当前缓冲区已无数据可读 // 在这里就看成是该次事件已处理处. if(errno == EAGAIN){ break; } else{ return; } } else if(buflen == 0){ // 这里表示对端的socket已正常关闭. } if(buflen == sizeof(buf){ rs = 1; // 须要再次读取 } else{ rs = 0; } } 

Linux中的EAGAIN含义

Linux环境下开发常常会碰到不少错误(设置errno)，其中EAGAIN是其中比较常见的一个错误(好比用在非阻塞操做中)。
从字面上来看，是提示再试一次。这个错误常常出如今当应用程序进行一些非阻塞(non-blocking)操做(对文件或socket)的时候。

例如，以 O_NONBLOCK的标志打开文件/socket/FIFO，若是你连续作read操做而没有数据可读。此时程序不会阻塞起来等待数据准备就绪返回，read函数会返回一个错误EAGAIN，提示你的应用程序如今没有数据可读请稍后再试。
又例如，当一个系统调用(好比fork)由于没有足够的资源(好比虚拟内存)而执行失败，返回EAGAIN提示其再调用一次(也许下次就能成功)。

三 代码演示

下面是一段不完整的代码且格式不对，意在表述上面的过程，去掉了一些模板代码。

#define IPADDRESS   "127.0.0.1"
#define PORT 8787 #define MAXSIZE 1024 #define LISTENQ 5 #define FDSIZE 1000 #define EPOLLEVENTS 100 listenfd = socket_bind(IPADDRESS,PORT); struct epoll_event events[EPOLLEVENTS]; //建立一个描述符 epollfd = epoll_create(FDSIZE); //添加监听描述符事件 add_event(epollfd,listenfd,EPOLLIN); //循环等待 for ( ; ; ){ //该函数返回已经准备好的描述符事件数目 ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1); //处理接收到的链接 handle_events(epollfd,events,ret,listenfd,buf); } //事件处理函数 static void handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf) { int i; int fd; //进行遍历;这里只要遍历已经准备好的io事件。num并非当初epoll_create时的FDSIZE。 for (i = 0;i < num;i++) { fd = events[i].data.fd; //根据描述符的类型和事件类型进行处理 if ((fd == listenfd) &&(events[i].events & EPOLLIN)) handle_accpet(epollfd,listenfd); else if (events[i].events & EPOLLIN) do_read(epollfd,fd,buf); else if (events[i].events & EPOLLOUT) do_write(epollfd,fd,buf); } } //添加事件 static void add_event(int epollfd,int fd,int state){ struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev); } //处理接收到的链接 static void handle_accpet(int epollfd,int listenfd){ int clifd; struct sockaddr_in cliaddr; socklen_t cliaddrlen; clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen); if (clifd == -1) perror("accpet error:"); else { printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port); //添加一个客户描述符和事件 add_event(epollfd,clifd,EPOLLIN); } } //读处理 static void do_read(int epollfd,int fd,char *buf){ int nread; nread = read(fd,buf,MAXSIZE); if (nread == -1) { perror("read error:"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLIN); //删除监听 } else if (nread == 0) { fprintf(stderr,"client close.\n"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLIN); //删除监听 } else { printf("read message is : %s",buf); //修改描述符对应的事件，由读改成写 modify_event(epollfd,fd,EPOLLOUT); } } //写处理 static void do_write(int epollfd,int fd,char *buf) { int nwrite; nwrite = write(fd,buf,strlen(buf)); if (nwrite == -1){ perror("write error:"); close(fd); //记住close fd delete_event(epollfd,fd,EPOLLOUT); //删除监听 }else{ modify_event(epollfd,fd,EPOLLIN); } memset(buf,0,MAXSIZE); } //删除事件 static void delete_event(int epollfd,int fd,int state) { struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev); } //修改事件 static void modify_event(int epollfd,int fd,int state){ struct epoll_event ev; ev.events = state; ev.data.fd = fd; epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev); } //注：另一端我就省了 

四 epoll总结

在 select/poll中，进程只有在调用必定的方法后，内核才对全部监视的文件描述符进行扫描，而epoll事先经过epoll_ctl()来注册一 个文件描述符，一旦基于某个文件描述符就绪时，内核会采用相似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait() 时便获得通知。(此处去掉了遍历文件描述符，而是经过监听回调的的机制。这正是epoll的魅力所在。)

epoll的优势主要是一下几个方面：
1. 监视的描述符数量不受限制，它所支持的FD上限是最大能够打开文件的数目，这个数字通常远大于2048,举个例子,在1GB内存的机器上大约是10万左 右，具体数目能够cat /proc/sys/fs/file-max察看,通常来讲这个数目和系统内存关系很大。select的最大缺点就是进程打开的fd是有数量限制的。这对 于链接数量比较大的服务器来讲根本不能知足。虽然也能够选择多进程的解决方案( Apache就是这样实现的)，不过虽然linux上面建立进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，因此也不是一种完美的方案。

1. IO的效率不会随着监视fd的数量的增加而降低。epoll不一样于select和poll轮询的方式，而是经过每一个fd定义的回调函数来实现的。只有就绪的fd才会执行回调函数。

若是没有大量的idle -connection或者dead-connection，epoll的效率并不会比select/poll高不少，可是当遇到大量的idle- connection，就会发现epoll的效率大大高于select/poll。

参考

用户空间与内核空间，进程上下文与中断上下文[总结]
进程切换
维基百科-文件描述符
Linux 中直接 I/O 机制的介绍
IO - 同步，异步，阻塞，非阻塞 （亡羊补牢篇）
Linux中select poll和epoll的区别
IO多路复用之select总结
IO多路复用之poll总结
IO多路复用之epoll总结

select、poll、epoll之间的区别总结[整理]

Linux I/O复用中select poll epoll模型的介绍及其优缺点的比较

关于I/O多路复用：

I/O多路复用(又被称为“事件驱动”)，首先要理解的是，操做系统为你提供了一个功能，当你的某个socket可读或者可写的时候，它能够给你一个通知。这样当配合非阻塞的socket使用时，只有当系统通知我哪一个描述符可读了，我才去执行read操做，能够保证每次read都能读到有效数据而不作纯返回-1和EAGAIN的无用功。写操做相似。操做系统的这个功能经过select/poll/epoll之类的系统调用来实现，这些函数均可以同时监视多个描述符的读写就绪情况，这样，**多个描述符的I/O操做都能在一个线程内并发交替地顺序完成，这就叫I/O多路复用，这里的“复用”指的是复用同一个线程。

1、I/O复用之select

一、介绍：
select系统调用的目的是：在一段指定时间内，监听用户感兴趣的文件描述符上的可读、可写和异常事件。poll和select应该被归类为这样的系统调用，它们能够阻塞地同时探测一组支持非阻塞的IO设备，直至某一个设备触发了事件或者超过了指定的等待时间——也就是说它们的职责不是作IO，而是帮助调用者寻找当前就绪的设备。
下面是select的原理图：

二、select系统调用API以下：

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

fd_set结构体是文件描述符集，该结构体其实是一个整型数组，数组中的每一个元素的每一位标记一个文件描述符。fd_set能容纳的文件描述符数量由FD_SETSIZE指定，通常状况下，FD_SETSIZE等于1024，这就限制了select能同时处理的文件描述符的总量。

三、下面介绍一下各个参数的含义：
1）nfds参数指定被监听的文件描述符的总数。一般被设置为select监听的全部文件描述符中最大值加1；
2）readfds、writefds、exceptfds分别指向可读、可写和异常等事件对应的文件描述符集合。这三个参数都是传入传出型参数，指的是在调用select以前，用户把关心的可读、可写、或异常的文件描述符经过FD_SET（下面介绍）函数分别添加进readfds、writefds、exceptfds文件描述符集，select将对这些文件描述符集中的文件描述符进行监听，若是有就绪文件描述符，select会重置readfds、writefds、exceptfds文件描述符集来通知应用程序哪些文件描述符就绪。这个特性将致使select函数返回后，再次调用select以前，必须重置咱们关心的文件描述符，也就是三个文件描述符集已经不是咱们以前传入 的了。
3）timeout参数用来指定select函数的超时时间（下面讲select返回值时还会谈及）。

struct timeval
{
    long tv_sec;        //秒数
    long tv_usec;       //微秒数 };

四、下面几个函数（宏实现）用来操纵文件描述符集：

void FD_SET(int fd, fd_set *set);   //在set中设置文件描述符fd
void FD_CLR(int fd, fd_set *set); //清除set中的fd位 int FD_ISSET(int fd, fd_set *set); //判断set中是否设置了文件描述符fd void FD_ZERO(fd_set *set); //清空set中的全部位（在使用文件描述符集前，应该先清空一下） //（注意FD_CLR和FD_ZERO的区别，一个是清除某一位，一个是清除全部位）

五、select的返回状况：
1）若是指定timeout为NULL，select会永远等待下去，直到有一个文件描述符就绪，select返回；
2）若是timeout的指定时间为0，select根本不等待，当即返回；
3）若是指定一段固定时间，则在这一段时间内，若是有指定的文件描述符就绪，select函数返回，若是超过指定时间，select一样返回。
4）返回值状况：
a)超时时间内，若是文件描述符就绪，select返回就绪的文件描述符总数（包括可读、可写和异常），若是没有文件描述符就绪，select返回0；
b)select调用失败时，返回 -1并设置errno，若是收到信号，select返回 -1并设置errno为EINTR。

六、文件描述符的就绪条件：
在网络编程中，
1）下列状况下socket可读：
a) socket内核接收缓冲区的字节数大于或等于其低水位标记SO_RCVLOWAT；
b) socket通讯的对方关闭链接，此时该socket可读，可是一旦读该socket，会当即返回0（能够用这个方法判断client端是否断开链接）；
c) 监听socket上有新的链接请求；
d) socket上有未处理的错误。
2）下列状况下socket可写：
a) socket内核发送缓冲区的可用字节数大于或等于其低水位标记SO_SNDLOWAT；
b) socket的读端关闭，此时该socket可写，一旦对该socket进行操做，该进程会收到SIGPIPE信号；
c) socket使用connect链接成功以后；
d) socket上有未处理的错误。

2、I/O复用之poll

一、poll系统调用的原理与原型和select基本相似，也是在指定时间内轮询必定数量的文件描述符，以测试其中是否有就绪者。

二、poll系统调用API以下：

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

三、下面介绍一下各个参数的含义：
1）第一个参数是指向一个结构数组的第一个元素的指针，每一个元素都是一个pollfd结构，用于指定测试某个给定描述符的条件。

struct pollfd
{
    int fd;             //指定要监听的文件描述符
    short events;       //指定监听fd上的什么事件 short revents; //fd上事件就绪后，用于保存实际发生的时间 }；

待监听的事件由events成员指定，函数在相应的revents成员中返回该描述符的状态（每一个文件描述符都有两个事件，一个是传入型的events，一个是传出型的revents，从而避免使用传入传出型参数，注意与select的区别），从而告知应用程序fd上实际发生了哪些事件。events和revents均可以是多个事件的按位或。
2）第二个参数是要监听的文件描述符的个数，也就是数组fds的元素个数；
3）第三个参数意义与select相同。

四、poll的事件类型：

在使用POLLRDHUP时，要在代码开始处定义_GNU_SOURCE

五、poll的返回状况：
与select相同。

3、I/O复用之epoll

一、介绍：
epoll 与select和poll在使用和实现上有很大区别。首先，epoll使用一组函数来完成，而不是单独的一个函数；其次，epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，无须向select和poll那样每次调用都要重复传入文件描述符集合事件集。

二、建立一个文件描述符，指定内核中的事件表：

#include<sys/epoll.h>
int epoll_create(int size);
    //调用成功返回一个文件描述符，失败返回-1并设置errno。

size参数并不起做用，只是给内核一个提示，告诉它事件表须要多大。该函数返回的文件描述符指定要访问的内核事件表，是其余全部epoll系统调用的句柄。

三、操做内核事件表：

#include<sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); //调用成功返回0，调用失败返回-1并设置errno。

epfd是epoll_create返回的文件句柄，标识事件表，op指定操做类型。操做类型有如下3种：

a）EPOLL_CTL_ADD， 往事件表中注册fd上的事件；
b）EPOLL_CTL_MOD， 修改fd上注册的事件；
c）EPOLL_CTL_DEL， 删除fd上注册的事件。

event参数指定事件，epoll_event的定义以下：

struct epoll_event
{
    __int32_t events;       //epoll事件
    epoll_data_t data;      //用户数据
};

typedef union epoll_data { void *ptr; int fd; uint32_t u32; uint64_t u64; }epoll_data;

在使用epoll_ctl时，是把fd添加、修改到内核事件表中，或从内核事件表中删除fd的事件。若是是添加事件到事件表中，能够往data中的fd上添加事件events，或者不用data中的fd，而把fd放到用户数据ptr所指的内存中（由于epoll_data是一个联合体，只能使用其中一个数据）,再设置events。

三、epoll_wait函数
epoll系统调用的最关键的一个函数epoll_wait，它在一段时间内等待一个组文件描述符上的事件。

#include<sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); //函数调用成功返回就绪文件描述符个数，失败返回-1并设置errno。

timeout参数和select与poll相同，指定一个超时时间；maxevents指定最多监听多少个事件；events是一个传出型参数，epoll_wait函数若是检测到事件就绪，就将全部就绪的事件从内核事件表（epfd所指的文件）中复制到events指定的数组中。这个数组用来输出epoll_wait检测到的就绪事件，而不像select与poll那样，这也是epoll与前者最大的区别，下文在比较三者之间的区别时还会说到。

4、三组I/O复用函数的比较

相同点：
1）三者都须要在fd上注册用户关心的事件；
2）三者都要一个timeout参数指定超时时间；
不一样点：
1）select：
a）select指定三个文件描述符集，分别是可读、可写和异常事件，因此不能更加细致地区分全部可能发生的事件；
b）select若是检测到就绪事件，会在原来的文件描述符上改动，以告知应用程序，文件描述符上发生了什么时间，因此再次调用select时，必须先重置文件描述符；
c）select采用对全部注册的文件描述符集轮询的方式，会返回整个用户注册的事件集合，因此应用程序索引就绪文件的时间复杂度为O(n)；
d）select容许监听的最大文件描述符个数一般有限制，通常是1024，若是大于1024，select的性能会急剧降低；
e）只能工做在LT模式。

2）poll：
a）poll把文件描述符和事件绑定，事件不但能够单独指定，并且能够是多个事件的按位或，这样更加细化了事件的注册，并且poll单独采用一个元素用来保存就绪返回时的结果，这样在下次调用poll时，就不用重置以前注册的事件；
b）poll采用对全部注册的文件描述符集轮询的方式，会返回整个用户注册的事件集合，因此应用程序索引就绪文件的时间复杂度为O(n)。
c）poll用nfds参数指定最多监听多少个文件描述符和事件，这个数能达到系统容许打开的最大文件描述符数目，即65535。
d）只能工做在LT模式。

3）epoll：
a）epoll把用户注册的文件描述符和事件放到内核当中的事件表中，提供了一个独立的系统调用epoll_ctl来管理用户的事件，并且epoll采用回调的方式，一旦有注册的文件描述符就绪，讲触发回调函数，该回调函数将就绪的文件描述符和事件拷贝到用户空间events所管理的内存，这样应用程序索引就绪文件的时间复杂度达到O(1)。
b）epoll_wait使用maxevents来制定最多监听多少个文件描述符和事件，这个数能达到系统容许打开的最大文件描述符数目，即65535；
c）不只能工做在LT模式，并且还支持ET高效模式（即EPOLLONESHOT事件，读者能够本身查一下这个事件类型，对于epoll的线程安全有很好的帮助）。

select/poll/epoll总结：

深度理解select、poll和epoll

在linux 没有实现epoll事件驱动机制以前，咱们通常选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱得火热之年代，select和poll的用武之地愈来愈有限，风头已经被epoll占尽。

本文便来介绍epoll的实现机制，并附带讲解一下select和poll。经过对比其不一样的实现机制，真正理解为什么epoll能实现高并发。

select()和poll() IO多路复用模型

select的缺点：

1. 单个进程可以监视的文件描述符的数量存在最大限制，一般是1024，固然能够更改数量，但因为select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；(在linux内核头文件中，有这样的定义：#define __FD_SETSIZE    1024)
2. 内核 / 用户空间内存拷贝问题，select须要复制大量的句柄数据结构，产生巨大的开销；
3. select返回的是含有整个句柄的数组，应用程序须要遍历整个数组才能发现哪些句柄发生了事件；
4. select的触发方式是水平触发，应用程序若是没有完成对一个已经就绪的文件描述符进行IO操做，那么以后每次select调用仍是会将这些文件描述符通知进程。

相比select模型，poll使用链表保存文件描述符，所以没有了监视文件数量的限制，但其余三个缺点依然存在。

拿select模型为例，假设咱们的服务器须要支持100万的并发链接，则在__FD_SETSIZE 为1024的状况下，则咱们至少须要开辟1k个进程才能实现100万的并发链接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以承受的。所以，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。

所以，该epoll上场了。

epoll IO多路复用模型实现机制

因为epoll的实现机制与select/poll机制彻底不一样，上面所说的 select的缺点在epoll上不复存在。

设想一下以下场景：有100万个客户端同时与一个服务器进程保持着TCP链接。而每一时刻，一般只有几百上千个TCP链接是活跃的(事实上大部分场景都是这种状况)。如何实现这样的高并发？

在select/poll时代，服务器进程每次都把这100万个链接告诉操做系统(从用户态复制句柄数据结构到内核态)，让操做系统内核去查询这些套接字上是否有事件发生，轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，所以，select/poll通常只能处理几千的并发链接。

epoll的设计和实现与select彻底不一样。epoll经过在Linux内核中申请一个简易的文件系统(文件系统通常用什么数据结构实现？B+树)。把原先的select/poll调用分红了3个部分：

1）调用epoll_create()创建一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)

2）调用epoll_ctl向epoll对象中添加这100万个链接的套接字

3）调用epoll_wait收集发生的事件的链接

如此一来，要实现上面说是的场景，只须要在进程启动时创建一个epoll对象，而后在须要的时候向这个epoll对象中添加或者删除链接。同时，epoll_wait的效率也很是高，由于调用epoll_wait时，并无一股脑的向操做系统复制这100万个链接的句柄数据，内核也不须要去遍历所有的链接。

下面来看看Linux内核具体的epoll机制实现思路。

当某一进程调用epoll_create方法时，Linux内核会建立一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切相关。eventpoll结构体以下所示：

每个epoll对象都有一个独立的eventpoll结构体，用于存放经过epoll_ctl方法向epoll对象中添加进来的事件。这些事件都会挂载在红黑树中，如此，重复添加的事件就能够经过红黑树而高效的识别出来(红黑树的插入时间效率是lgn，其中n为树的高度)。

而全部添加到epoll中的事件都会与设备(网卡)驱动程序创建回调关系，也就是说，当相应的事件发生时会调用这个回调方法。这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表中。

在epoll中，对于每个事件，都会创建一个epitem结构体，以下所示：

当调用epoll_wait检查是否有事件发生时，只须要检查eventpoll对象中的rdlist双链表中是否有epitem元素便可。若是rdlist不为空，则把发生的事件复制到用户态，同时将事件数量返回给用户。

epoll数据结构示意图

从上面的讲解可知：经过红黑树和双链表数据结构，并结合回调机制，造就了epoll的高效。

OK，讲解完了Epoll的机理，咱们便能很容易掌握epoll的用法了。一句话描述就是：三步曲。

第一步：epoll_create()系统调用。此调用返回一个句柄，以后全部的使用都依靠这个句柄来标识。

第二步：epoll_ctl()系统调用。经过此调用向epoll对象中添加、删除、修改感兴趣的事件，返回0标识成功，返回-1表示失败。

第三部：epoll_wait()系统调用。经过此调用收集收集在epoll监控中已经发生的事件。

最后，附上一个epoll编程实例。(做者为sparkliang)

Mmap的实现原理和应用

不少文章分析了mmap的实现原理。从代码的逻辑来分析，老是觉没有把mmap后读写映射区域和普通的read/write联系起来。不得不产生疑问：

1，普通的read/write和mmap后的映射区域的读写到底有什么区别。

2， 为何有时候会选择mmap而放弃普通的read/write。

3，若是文章中的内容有不对是或者是不妥的地方，欢迎你们指正。

围绕着这两个问题分析一下，其实在考虑这些问题的同时难免和其余的不少系统机制产生交互。虽然是讲解mmap，可是不少知识仍是为了阐明问题作必要的铺垫。这些知识也正是linux的繁琐所在。一个应用每每和系统中的多种机制交互。这篇文章中尽可能减小对源代码的引用和分析。把这样的工做留到之后的细节分析中。可是不少分析的理论依据仍是来自于源代码。可见源代码的重要地位。

基础知识：

1， 进程每次切换后，都会在tlb base寄存器中从新load属于每个进程本身的地址转换基地址。在cpu当前运行的进程中都会有current宏来表示当前的进程的信息。应为这个代码实现涉及到硬件架构的问题，为了不差别的存在在文章中用到硬件知识的时候仍是指明是x86的架构，毕竟x86的资料和分析的研究人员也比较多。其实arm还有其余相似的RISC的芯片，只要有mmu支持的，都会有相似的基地址寄存器。

2， 在系统运行进程以前都会为每个进程分配属于它本身的运行空间。而且这个空间的有效性依赖于tlb base中的内容。32位的系统中访问的空间大小为4G。在这个空间中进程是“自由”的。所谓“自由”不是说对于4G的任何一个地址或者一段空间均可以访问。若是要访问，仍是要遵循地址有效性，就是tlb base中所指向的任何页表转换后的物理地址。其中的有效性有越界，权限等等检查。

3， 任何一个用户进程的运行在系统分配的空间中。这个空间能够有

vma：struct vm_area_struct来表示。全部的运行空间能够有这个结构体描述。用户进程能够分为text data 段。这些段的具体在4G中的位置有不一样的vma来描述。Vma的管理又有其余机制保证，这些机制涉及到了算法和物理内存管理等。请看一下两个图片：

图 一：

图 二：

系统调用中的write和read：

 这里没有指定确切的文件系统类型做为分析的对象。找到系统调用号，而后肯定具体的文件系统所带的file operation。在特定的file operation中有属于每一种文件系统本身的操做函数集合。其中就有read和write。

图 三：

在真正的把用户数据读写到磁盘或者是存储设备前，内核还会在page cache中管理这些数据。这些page的存在有效的管理了用户数据和读写的效率。用户数据不是直接来自于应用层，读(read)或者是写入(write)磁盘和存储介质，而是被一层一层的应用所划分，在每一层次中都会有不一样的功能对应。最后发生交互时，在最恰当的时机触发磁盘的操做。经过IO驱动写入磁盘和存储介质。这里主要强调page cache的管理。应为page的管理设计到了缓存，这些缓存以page的单位管理。在没有IO操做以前，暂时存放在系统空间中，而并未直接写入磁盘或者存贮介质。

系统调用中的mmap：

当建立一个或者切换一个进程的同时，会把属于这个当前进程的系统信息载入。这些系统信息中包含了当前进程的运行空间。当用户程序调用mmap后。函数会在当前进程的空间中找到适合的vma来描述本身将要映射的区域。这个区域的做用就是将mmap函数中文件描述符所指向的具体文件中内容映射过来。

原理是：mmap的执行，仅仅是在内核中创建了文件与虚拟内存空间的对应关系。用户访问这些虚拟内存空间时，页面表里面是没有这些空间的表项的。当用户程序试图访问这些映射的空间时，因而产生缺页异常。内核捕捉这些异常，逐渐将文件载入。所谓的载入过程，具体的操做就是read和write在管理pagecache。Vma的结构体中有很文件操做集。vma操做集中会有本身关于page cache的操做集合。这样，虽然是两种不一样的系统调用，因为操做和调用触发的路径不一样。可是最后仍是落实到了page cache的管理。实现了文件内容的操做。

Ps：

文件的page cache管理也是很好的内容。涉及到了address space的操做。其中不少的内容和文件操做相关。

效率对比：

    这里应用了网上一篇文章。发现较好的分析，着这里引用一下。

Mmap：

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <sys/mman.h>

void main()

{

int fd = open("test.file", 0);

struct stat statbuf;

char *start;

char buf[2] = {0};

int ret = 0;

fstat(fd, &statbuf);

start = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

do {

*buf = start[ret++];

}while(ret < statbuf.st_size);

}  

Read：

#include <stdio.h>

#include <stdlib.h>

void main()

{

FILE *pf = fopen("test.file", "r");

char buf[2] = {0};

int ret = 0;

do {

ret = fread(buf, 1, 1, pf);

}while(ret);

}   

运行结果：

[xiangy@compiling-server test_read]$ time ./fread

real    0m0.901s

user    0m0.892s

sys     0m0.010s

[xiangy@compiling-server test_read]$ time ./mmap

real    0m0.112s

user    0m0.106s

sys     0m0.006s

[xiangy@compiling-server test_read]$ time ./read

real    0m15.549s

user    0m3.933s

sys     0m11.566s

[xiangy@compiling-server test_read]$ ll test.file

-rw-r--r-- 1 xiangy svx8004 23955531 Sep 24 17:17 test.file   

能够看出使用mmap后发现，系统调用所消耗的时间远远比普通的read少不少。

共享内存:mmap函数实现

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); void *mmap64(void *addr, size_t length, int prot, int flags, int fd, off64_t offset); int munmap(void *addr, size_t length); int msync(void *addr, size_t length, int flags);

/*-------------map_normalfile1.c-----------*/
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h> #include <fcntl.h> #include <unistd.h> typedef struct{ char name[4]; int age; }people; int main(int argc, char** argv) // map a normal file as shared mem: { int fd,i; people *p_map; char temp[2] = {'\0'}; fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777); lseek(fd,sizeof(people)*5-1,SEEK_SET); write(fd,"",1); p_map = (people*) mmap( NULL,sizeof(people)*10,PROT_READ|PROT_WRITE, MAP_SHARED,fd,0 ); close( fd ); temp[0] = 'a'; for(i=0; i<15; i++) { temp[0] += 1; memcpy( ( *(p_map+i) ).name, &temp[0],2 ); ( *(p_map+i) ).age = 20+i; } printf("initialize over\n"); sleep(10); munmap( p_map, sizeof(people)*10 ); printf( "umap ok \n" ); return 0; }

/*-------------map_normalfile2.c-----------*/
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h> #include <fcntl.h> #include <unistd.h> typedef struct{ char name[4]; int age; }people; int main(int argc, char** argv) // map a normal file as shared mem: { int fd,i; people *p_map; char temp[2] = {'\0'}; fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777); lseek(fd,sizeof(people)*5-1,SEEK_SET); write(fd,"",1); p_map = (people*) mmap( NULL,sizeof(people)*10,PROT_READ|PROT_WRITE, MAP_SHARED,fd,0 ); close( fd ); temp[0] = 'a'; for(i=0; i<15; i++) { temp[0] += 1; memcpy( ( *(p_map+i) ).name, &temp[0],2 ); ( *(p_map+i) ).age = 20+i; } printf("initialize over\n"); sleep(10); munmap( p_map, sizeof(people)*10 ); printf( "umap ok \n" ); return 0; }

/*第一种方法*/
fd = open(PATHNAME, O_RDWR | O_CREAT | O_TRUNC, FILE_MODE);
lseek(fd, filesize-1, SEEK_SET);
write(fd, "", 1); /*第二种方法*/ ftruncate(fd, filesize);

#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct{ char name[4]; int age; }people; main(int argc, char** argv) { int i; people *p_map; char temp; p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS,-1,0); if(fork() == 0) { sleep(2); for(i = 0;i<5;i++) printf("child read: the %d people's age is %d\n",i+1,(*(p_map+i)).age); (*p_map).age = 100; munmap(p_map,sizeof(people)*10); //实际上，进程终止时，会自动解除映射。 exit(); } temp = 'a'; for(i = 0;i<5;i++) { temp += 1; memcpy((*(p_map+i)).name, &temp,2); (*(p_map+i)).age=20+i; } sleep(5); printf( "parent read: the first people,s age is %d\n",(*p_map).age ); printf("umap\n"); munmap( p_map,sizeof(people)*10 ); printf( "umap ok\n" ); }

驱动总结之mmap函数实现

mmap做为struct file_operations的重要一个元素，mmap主要是实现物理内存到虚拟内存的映射关系，这样能够实现直接访问虚拟内存，而不用使用设备相关的read、write操做，mmap的基本过程是将文件映射到虚拟内存中。在以前的一篇博客中谈到了mmap实现文件复制的操做。

1. vma->vm_flags |= VM_IO;
   
2. vma->vm_flags |= VM_RESERVED;

上面的两个保护机制就说明了被映射的这段区域具备映射IO的类似性，同时保证这段区域不能随便的换出。就是创建一个物理页与虚拟页之间的关联性。具体原理是虚拟页和物理页之间是以页表的方式关联起来，虚拟内存一般大于物理内存，在使用过程当中虚拟页经过页表关联一切对应的物理页，当物理页不够时，会选择性的牺牲一些页，也就是将物理页与虚拟页之间切断，重现关联其余的虚拟页，保证物理内存够用。在设备驱动中应该具体的虚拟页和物理页之间的关系应该是长期的，应该保护起来，不能随便被别的虚拟页所替换。具体也可参看关于虚拟存储器的文章。

接下来就是创建物理页与虚拟页之间的关系，即采用函数remap_pfn_range(),具体的参数以下：

int remap_pfn_range(structvm_area_struct *vma, unsigned long addr,unsigned long pfn, unsigned long size, pgprot_t prot)

一、struct vm_area_struct是一个虚拟内存区域结构体，表示虚拟存储器中的一个内存区域。其中的元素vm_start是指虚拟存储器中的起始地址。

二、addr也就是虚拟存储器中的起始地址，一般能够选择addr = vma->vm_start。

三、pfn是指物理存储器的具体页号，一般经过物理地址获得对应的物理页号，具体采用virt_to_phys(dev->data)>>PAGE_SHIFT.首先将虚拟内存转换到物理内存，而后获得页号。>>PAGE_SHIFT一般为12，这是由于每一页的大小恰好是4K,这样右移12至关于除以4096，获得页号。

四、size区域大小

五、区域保护机制。

返回值，若是成功返回0，不然正数。

测试代码能够直接经过对虚拟内存区域操做，实现不一样的操做，以下：

通过测试，成功获得了驱动。

Linux 内存映射函数 mmap（）函数详解

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，若是文件的大小不是全部页的大小之和，最后一个页不被使用的空间将会清零。mmap在用户空间映射调用系统中做用很大。
头文件 <sys/mman.h>
函数原型
void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);

int munmap(void* start,size_t length);

mmap()[1] 必须以PAGE_SIZE为单位进行映射，而内存也只能以页为单位进行映射，若要映射非PAGE_SIZE整数倍的地址范围，要先进行内存对齐，强行以PAGE_SIZE的倍数大小进行映射。

用法:

下面说一下内存映射的步骤:
用open系统调用打开文件, 并返回描述符fd.
用mmap创建内存映射, 并返回映射首地址指针start.
对映射(文件)进行各类操做, 显示(printf), 修改(sprintf).
用munmap(void *start, size_t lenght)关闭内存映射.
用close系统调用关闭文件fd.

UNIX网络编程第二卷进程间通讯对mmap函数进行了说明。该函数主要用途有三个：
一、将一个普通文件映射到内存中，一般在须要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以得到较高的性能；
二、将特殊文件进行匿名内存映射，能够为关联进程提供共享内存空间；
三、为无关联的进程提供共享内存空间，通常也是将一个普通文件映射到内存中。

函数：void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);
参数start：指向欲映射的内存起始地址，一般设为 NULL，表明让系统自动选定地址，映射成功后返回该地址。

参数length：表明将文件中多大的部分映射到内存。

参数prot：映射区域的保护方式。能够为如下几种方式的组合：
PROT_EXEC 映射区域可被执行
PROT_READ 映射区域可被读取
PROT_WRITE 映射区域可被写入
PROT_NONE 映射区域不能存取

参数flags：影响映射区域的各类特性。在调用mmap()时必需要指定MAP_SHARED 或MAP_PRIVATE。
MAP_FIXED 若是参数start所指的地址没法成功创建映射时，则放弃映射，不对地址作修正。一般不鼓励用此旗标。
MAP_SHARED对映射区域的写入数据会复制回文件内，并且容许其余映射该文件的进程共享。
MAP_PRIVATE 对映射区域的写入操做会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域做的任何修改都不会写回原来的文件内容。
MAP_ANONYMOUS创建匿名映射。此时会忽略参数fd，不涉及文件，并且映射区域没法和其余进程共享。
MAP_DENYWRITE只容许对映射区域的写入操做，其余对文件直接写入的操做将会被拒绝。
MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。

参数fd：要映射到内存中的文件描述符。若是使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。有些系统不支持匿名内存映射，则能够使用fopen打开/dev/zero文件，而后对该文件进行映射，能够一样达到匿名内存映射的效果。

参数offset：文件映射的偏移量，一般设置为0，表明从文件最前方开始对应，offset必须是分页大小的整数倍。

返回值：

若映射成功则返回映射区的内存起始地址，不然返回MAP_FAILED(－1)，错误缘由存于errno 中。

错误代码：

EBADF 参数fd 不是有效的文件描述词
EACCES 存取权限有误。若是是MAP_PRIVATE 状况下文件必须可读，使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
EINVAL 参数start、length 或offset有一个不合法。
EAGAIN 文件被锁住，或是有太多内存被锁住。
ENOMEM 内存不足。

系统调用mmap()用于共享内存的两种方式：
（1）使用普通文件提供的内存映射：

适用于任何进程之间。此时，须要打开或建立一个文件，而后再调用mmap()

典型调用代码以下：

fd=open(name, flag, mode); if(fd<0) ...

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);

经过mmap()实现共享内存的通讯方式有许多特色和要注意的地方，能够参看UNIX网络编程第二卷。

（2）使用特殊文件提供匿名内存映射：

适用于具备亲缘关系的进程之间。因为父子进程特殊的亲缘关系，在父进程中先调用mmap()，而后调用 fork()。那么在调用fork()以后，子进程继承父进程匿名映射后的地址空间，一样也继承mmap()返回的地址，这样，父子进程就能够经过映射区 域进行通讯了。注意，这里不是通常的继承关系。通常来讲，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。 对于具备亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，没必要指定具体的文件，只要设置相应的标志便可。

1、概述
内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改能够直接反映到内核空间，一样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间二者之间须要大量数据传输等操做的话效率是很是高的。
如下是一个把广泛文件映射到用户空间的内存区域的示意图。
图一：

2、基本函数
mmap函数是unix/linux下的系统调用，详细内容可参考《Unix Netword programming》卷二12.2节。
mmap系统调用并非彻底为了用于共享内存而设计的。它自己提供了不一样于通常对普通文件的访问方式，进程能够像读写内存同样对普通文件的操做。而Posix或系统V的共享内存IPC则纯粹用于共享目的，固然mmap()实现共享内存也是其主要应用之一。
mmap系统调用使得进程之间经过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程能够像访问普通内存同样对文件进行访问，没必要再调用read()，write（）等操做。mmap并不分配空间, 只是将文件映射到调用进程的地址空间里（可是会占掉你的 virutal memory）, 而后你就能够用memcpy等操做写文件, 而不用write()了.写完后，内存中的内容并不会当即更新到文件中，而是有一段时间的延迟，你能够调用msync()来显式同步一下, 这样你所写的内容就能当即保存到文件里了.这点应该和驱动相关。 不过经过mmap来写文件这种方式没办法增长文件的长度, 由于要映射的长度在调用mmap()的时候就决定了.若是想取消内存映射，能够调用munmap()来取消内存映射

mmap用于把文件映射到内存空间中，简单说mmap就是把一个文件的内容在内存里面作一个映像。映射成功后，用户对这段内存区域的修改能够直接反映到内核空间，一样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间二者之间须要大量数据传输等操做的话效率是很是高的。
start：要映射到的内存区域的起始地址，一般都是用NULL（NULL即为0）。NULL表示由内核来指定该内存地址

length：要映射的内存区域的大小
prot：指望的内存保护标志，不能与文件的打开模式冲突。是如下的某个值，能够经过or运算合理地组合在一块儿
PROT_EXEC //页内容能够被执行
PROT_READ //页内容能够被读取
PROT_WRITE //页能够被写入
PROT_NONE //页不可访问
flags：指定映射对象的类型，映射选项和映射页是否能够共享。它的值能够是一个或者多个如下位的组合体
MAP_FIXED ：使用指定的映射起始地址，若是由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。若是指定的起始地址不可用，操做将会失败。而且起始地址必须落在页的边界上。
MAP_SHARED ：对映射区域的写入数据会复制回文件内, 并且容许其余映射该文件的进程共享。
MAP_PRIVATE ：创建一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
MAP_DENYWRITE ：这个标志被忽略。
MAP_EXECUTABLE ：同上
MAP_NORESERVE ：不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会获得保证。当交换空间不被保留，同时内存不足，对映射区的修改会引发段违例信号。
MAP_LOCKED ：锁定映射区的页面，从而防止页面被交换出内存。
MAP_GROWSDOWN ：用于堆栈，告诉内核VM系统，映射区能够向下扩展。
MAP_ANONYMOUS ：匿名映射，映射区不与任何文件关联。
MAP_ANON ：MAP_ANONYMOUS的别称，再也不被使用。
MAP_FILE ：兼容标志，被忽略。
MAP_32BIT ：将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上获得支持。
MAP_POPULATE ：为文件映射经过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
MAP_NONBLOCK ：仅和MAP_POPULATE一块儿使用时才有意义。不执行预读，只为已存在于内存中的页面创建页表入口。

fd：文件描述符（由open函数返回）

offset：表示被映射对象（即文件）从那里开始对映，一般都是用0。 该值应该为大小为PAGE_SIZE的整数倍

返回说明
成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，munmap返回-1。errno被设为如下的某个值
EACCES：访问出错
EAGAIN：文件已被锁定，或者太多的内存已被锁定
EBADF：fd不是有效的文件描述词
EINVAL：一个或者多个参数无效
ENFILE：已达到系统对打开文件的限制
ENODEV：指定文件所在的文件系统不支持内存映射
ENOMEM：内存不足，或者进程已超出最大内存映射数量
EPERM：权能不足，操做不容许
ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
SIGSEGV：试着向只读区写入
SIGBUS：试着访问不属于进程的内存区

start：要取消映射的内存区域的起始地址
length：要取消映射的内存区域的大小。
返回说明
成功执行时munmap()返回0。失败时munmap返回-1.
int msync(const void *start, size_t length, int flags);

对映射内存的内容的更改并不会当即更新到文件中，而是有一段时间的延迟，你能够调用msync()来显式同步一下, 这样你内存的更新就能当即保存到文件里
start：要进行同步的映射的内存区域的起始地址。
length：要同步的内存区域的大小
flag:flags能够为如下三个值之一：
MS_ASYNC : 请Kernel快将资料写入。
MS_SYNC : 在msync结束返回前，将资料写入。
MS_INVALIDATE : 让核心自行决定是否写入，仅在特殊情况下使用

3、用户空间和驱动程序的内存映射
3.一、基本过程
首先，驱动程序先分配好一段内存，接着用户进程经过库函数mmap()来告诉内核要将多大的内存映射到内核空间，内核通过一系列函数调用后调用对应的驱动程序的file_operation中指定的mmap函数，在该函数中调用remap_pfn_range()来创建映射关系。
3.二、映射的实现
首先在驱动程序分配一页大小的内存，而后用户进程经过mmap()将用户空间中大小也为一页的内存映射到内核空间这页内存上。映射完成后，驱动程序往这段内存写10个字节数据，用户进程将这些数据显示出来。
驱动程序：

应用程序：

先加载驱动后执行应用程序，用户空间打印以下：

linux内存映射mmap原理分析

Linux的mmap内存映射机制解析

       在讲述文件映射的概念时,不可避免的要牵涉到虚存(SVR 4的VM).实际上,文件映射是虚存的中心概念, 文件映射一方面给用户提供了一组措施,好似用户将文件映射到本身地址空间的某个部分,使用简单的内存访问指令读写文件；另外一方面,它也能够用于内核的基本组织模式,在这种模式种,内核将整个地址空间视为诸如文件之类的一组不一样对象的映射.中的传统文件访问方式是,首先用open系统调用打开文件,而后使用read, write以及lseek等调用进行顺序或者随即的I/O.这种方式是很是低效的,每一次I/O操做都须要一次系统调用.另外,若是若干个进程访问同一个文件,每一个进程都要在本身的地址空间维护一个副本,浪费了内存空间.而若是可以经过必定的机制将页面映射到进程的地址空间中,也就是说首先经过简单的产生某些内存管理数据结构完成映射的建立.当进程访问页面时产生一个缺页中断,内核将页面读入内存而且更新页表指向该页面.并且这种方式很是方便于同一副本的共享.

     VM是面向对象的方法设计的,这里的对象是指内存对象:内存对象是一个软件抽象的概念,它描述内存区与后备存储之间的映射.系统能够使用多种类型的后备存储,好比交换空间,本地或者远程文件以及帧缓存等等. VM系统对它们统一处理,采用同一操做集操做,好比读取页面或者回写页面等.每种不一样的后备存储均可以用不一样的方法实现这些操做.这样,系统定义了一套统一的接口,每种后备存储给出本身的实现方法.这样,进程的地址空间就被视为一组映射到不一样数据对象上的的映射组成.全部的有效地址就是那些映射到数据对象上的地址.这些对象为映射它的页面提供了持久性的后备存储.映射使得用户能够直接寻址这些对象.

    值得提出的是, VM体系结构独立于Unix系统,全部的Unix系统语义,如正文,数据及堆栈区均可以建构在基本VM系统之上.同时, VM体系结构也是独立于存储管理的,存储管理是由操做系统实施的,如:究竟采起什么样的对换和请求调页算法,到底是采起分段仍是分页机制进行存储管理,到底是如何将虚拟地址转换成为物理地址等等(Linux中是一种叫Three Level Page Table的机制),这些都与内存对象的概念无关.

1、Linux中VM的实现.

      一个进程应该包括一个mm_struct(memory manage struct), 该结构是进程虚拟地址空间的抽象描述,里面包括了进程虚拟空间的一些管理信息: start_code, end_code, start_data, end_data, start_brk, end_brk等等信息.另外,也有一个指向进程虚存区表(vm_area_struct: virtual memory area)的指针,该链是按照虚拟地址的增加顺序排列的.在Linux进程的地址空间被分做许多区(vma),每一个区(vma)都对应虚拟地址空间上一段连续的区域, vma是能够被共享和保护的独立实体,这里的vma就是前面提到的内存对象. 

  下面是vm_area_struct的结构,其中,前半部分是公共的,与类型无关的一些数据成员,如:指向mm_struct的指针,地址范围等等,后半部分则是与类型相关的成员,其中最重要的是一个指向vm_operation_struct向量表的指针vm_ops, vm_pos向量表是一组虚函数,定义了与vma类型无关的接口.每个特定的子类,即每种vma类型都必须在向量表中实现这些操做.这里包括了: open, close, unmap, protect, sync, nopage, wppage, swapout这些操做. 

vm_ops: open, close, no_page, swapin, swapout……

2、驱动中的mmap()函数解析

       设备驱动的mmap实现主要是将一个物理设备的可操做区域（设备空间）映射到一个进程的虚拟地址空间。这样就能够直接采用指针的方式像访问内存的方式访问设备。在驱动中的mmap实现主要是完成一件事，就是实际物理设备的操做区域到进程虚拟空间地址的映射过程。同时也须要保证这段映射的虚拟存储器区域不会被进程当作通常的空间使用，所以须要添加一系列的保护方式。

具体的实现分析以下：

vma->vm_flags |= VM_IO;
vma->vm_flags |= VM_RESERVED;

上面的两个保护机制就说明了被映射的这段区域具备映射IO的类似性，同时保证这段区域不能随便的换出。就是创建一个物理页与虚拟页之间的关联性。具体原理是虚拟页和物理页之间是以页表的方式关联起来，虚拟内存一般大于物理内存，在使用过程当中虚拟页经过页表关联一切对应的物理页，当物理页不够时，会选择性的牺牲一些页，也就是将物理页与虚拟页之间切断，重现关联其余的虚拟页，保证物理内存够用。在设备驱动中应该具体的虚拟页和物理页之间的关系应该是长期的，应该保护起来，不能随便被别的虚拟页所替换。具体也可参看关于虚拟存储器的文章。

接下来就是创建物理页与虚拟页之间的关系，即采用函数remap_pfn_range(),具体的参数以下：

int remap_pfn_range(structvm_area_struct *vma, unsigned long addr,unsigned long pfn, unsigned long size, pgprot_t prot)

一、struct vm_area_struct是一个虚拟内存区域结构体，表示虚拟存储器中的一个内存区域。其中的元素vm_start是指虚拟存储器中的起始地址。
二、addr也就是虚拟存储器中的起始地址，一般能够选择addr = vma->vm_start。
三、pfn是指物理存储器的具体页号，一般经过物理地址获得对应的物理页号，具体采用virt_to_phys(dev->data)>>PAGE_SHIFT.首先将虚拟内存转换到物理内存，而后获得页号。>>PAGE_SHIFT一般为12，这是由于每一页的大小恰好是4K,这样右移12至关于除以4096，获得页号。
四、size区域大小
五、区域保护机制。
返回值，若是成功返回0，不然正数。

3、系统调用mmap函数解析

        介绍完VM的基本概念后,咱们能够讲述mmap和munmap系统调用了.mmap调用实际上就是一个内存对象vma的建立过程,

一、mmap函数

       Linux提供了内存映射函数mmap,它把文件内容映射到一段内存上(准确说是虚拟内存上),经过对这段内存的读取和修改,实现对文件的读取和修改 。普通文件被映射到进程地址空间后，进程能够向访问普通内存同样对文件进行访问，没必要再调用read()，write（）等操做。

先来看一下mmap的函数声明:

mmap的做用是映射文件描述符fd指定文件的 [off,off + len]区域至调用进程的[addr, addr + len]的内存区域, 以下图所示:

mmap系统调用的实现过程是

1.先经过文件系统定位要映射的文件；

2.权限检查,映射的权限不会超过文件打开的方式,也就是说若是文件是以只读方式打开,那么则不容许创建一个可写映射； 

3.建立一个vma对象,并对之进行初始化； 

4.调用映射文件的mmap函数,其主要工做是给vm_ops向量表赋值；

5.把该vma链入该进程的vma链表中,若是能够和先后的vma合并则合并；

6.若是是要求VM_LOCKED(映射区不被换出)方式映射,则发出缺页请求,把映射页面读入内存中.

二、munmap函数

      munmap(void * start, size_t length):

      该调用能够看做是mmap的一个逆过程.它将进程中从start开始length长度的一段区域的映射关闭,若是该区域不是刚好对应一个vma,则有可能会分割几个或几个vma.

      msync(void * start, size_t length, int flags):

     把映射区域的修改回写到后备存储中.由于munmap时并不保证页面回写,若是不调用msync,那么有可能在munmap后丢失对映射区的修改.其中flags能够是MS_SYNC, MS_ASYNC, MS_INVALIDATE, MS_SYNC要求回写完成后才返回, MS_ASYNC发出回写请求后当即返回, MS_INVALIDATE使用回写的内容更新该文件的其它映射.该系统调用是经过调用映射文件的sync函数来完成工做的.

     brk(void * end_data_segement):

将进程的数据段扩展到end_data_segement指定的地址,该系统调用和mmap的实现方式十分类似,一样是产生一个vma,而后指定其属性.不过在此以前须要作一些合法性检查,好比该地址是否大于mm->end_code, end_data_segement和mm->brk之间是否还存在其它vma等等.经过brk产生的vma映射的文件为空,这和匿名映射产生的vma类似,关于匿名映射不作进一步介绍.库函数malloc就是经过brk实现的.

4、实例解析

       下面这个例子显示了把文件映射到内存的方法，源代码是：

编译运行此程序：

gcc -Wall mmap.c
./a.out text_filename

上面的方法由于用了PROT_READ，因此只能读取文件里的内容，不能修改，若是换成PROT_WRITE就能够修改文件的内容了。又因为 用了MAAP_PRIVATE因此只能此进程使用此内存区域，若是换成MAP_SHARED，则能够被其它进程访问，好比下面的

5、mmap和共享内存对比

      共享内存容许两个或多个进程共享一给定的存储区，由于数据不须要来回复制，因此是最快的一种进程间通讯机制。共享内存能够经过mmap()映射普通文件（特殊状况下还能够采用匿名映射）机制实现，也能够经过系统V共享内存机制实现。应用接口和原理很简单，内部机制复杂。为了实现更安全通讯，每每还与信号灯等同步机制共同使用。

对好比下：

      mmap机制：就是在磁盘上创建一个文件，每一个进程存储器里面，单独开辟一个空间来进行映射。若是多进程的话，那么不会对实际的物理存储器（主存）消耗太大。

      shm机制：每一个进程的共享内存都直接映射到实际物理存储器里面。

一、mmap保存到实际硬盘，实际存储并无反映到主存上。优势：储存量能够很大（多于主存）；缺点：进程间读取和写入速度要比主存的要慢。

二、shm保存到物理存储器（主存），实际的储存量直接反映到主存上。优势，进程间访问速度（读写）比磁盘要快；缺点，储存量不能很是大（多于主存）

使用上看：若是分配的存储量不大，那么使用shm；若是存储量大，那么使用mmap。

mmap - 用户空间与内核空间

mmap概述

共享内存能够说是最有用的进程间通讯方式，也是最快的IPC形式, 由于进程能够直接读写内存，而不须要任何数据的拷贝。对于像管道和消息队列等通讯方式，则须要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据: 一次从输入文件到共享内存区，另外一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不老是读写少许数据后就解除映射，有新的通讯时，再从新创建共享内存区域。而是保持共享区域，直到通讯完毕为止，这样，数据内容一直保存在共享内存中，并无写回文件。共享内存中的内容每每是在解除映射时才写回文件的。所以，采用共享内存的通讯方式效率是很是高的。

传统文件访问
UNIX访问文件的传统方法是用open打开它们, 若是有多个进程访问同一个文件, 则每个进程在本身的地址空间都包含有该文件的副本,这没必要要地浪费了存储空间. 下图说明了两个进程同时读一个文件的同一页的情形. 系统要将该页从磁盘读到高速缓冲区中, 每一个进程再执行一个存储器内的复制操做将数据从高速缓冲区读到本身的地址空间.

共享存储映射
如今考虑另外一种处理方法:　进程A和进程B都将该页映射到本身的地址空间, 当进程A第一次访问该页中的数据时, 它生成一个缺页中断. 内核此时读入这一页到内存并更新页表使之指向它.之后, 当进程B访问同一页面而出现缺页中断时, 该页已经在内存, 内核只须要将进程B的页表登记项指向次页便可. 以下图所示:

mmap系统调用使得进程之间经过映射同一个普通文件实现共享内存，普通文件被映射到进程地址空间后，进程能够像访问普通内存同样对文件进行访问，没必要再调用read和write等。

mmap用户空间

用户空间mmap函数原型

头文件 sys/mman.h
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *start, size_t length);
int msync ( void * addr , size_t len, int flags) 经过调用msync()实现磁盘上文件内容与共享内存区的内容一致

做用：
mmap将一个文件或者其余对象映射进内存，当文件映射到进程后，就能够直接操做这段虚拟地址进行文件的读写等操做。

参数说明：
start：映射区的开始地址
length：映射区的长度
prot：指望的内存保护标志
—-PROT_EXEC //页内容能够被执行
—-PROT_READ //页内容能够被读取
—-PROT_WRITE //页能够被写入
—-PROT_NONE //页不可访问
flags：指定映射对象的类型
—-MAP_FIXED
—-MAP_SHARED 与其它全部映射这个对象的进程共享映射空间
—-MAP_PRIVATE 创建一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件
—-MAP_ANONYMOUS 匿名映射，映射区不与任何文件关联
fd：若是MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1
offset：被映射对象内容的起点

经过共享映射的方式修改文件

系统调用mmap能够将文件映射至内存(进程空间)，如此能够把对文件的操做转为对内存的操做，以此避免更多的lseek()、read()、write()等系统调用，这点对于大文件或者频繁访问的文件尤为有用，提升了I/O效率。
下面例子中测试所需的data.txt文件内容以下：

aaaaaaaaa
bbbbbbbbb
ccccccccc
ddddddddd

/*
 * mmap file to memory
 * ./mmap1 data.txt
 */
#include <stdio.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h> #include <stdlib.h> int main(int argc, char *argv[]) { int fd = -1; struct stat sb; char *mmaped = NULL; fd = open(argv[1], O_RDWR); if (fd < 0) { fprintf(stderr, "open %s fail\n", argv[1]); exit(-1); } if (stat(argv[1], &sb) < 0) { fprintf(stderr, "stat %s fail\n", argv[1]); goto err; } /* 将文件映射至进程的地址空间 */ mmaped = (char *)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (mmaped == (char *)-1) { fprintf(stderr, "mmap fail\n"); goto err; } /* 映射完后, 关闭文件也能够操纵内存 */ close(fd); printf("%s", mmaped); mmaped[5] = '$'; if (msync(mmaped, sb.st_size, MS_SYNC) < 0) { fprintf(stderr, "msync fail\n"); goto err; } return 0; err: if (fd > 0) close(fd); if (mmaped != (char *)-1) munmap(mmaped, sb.st_size); return -1; }

经过共享映射实现两个进程之间的通讯

两个程序映射同一个文件到本身的地址空间, 进程A先运行, 每隔两秒读取映射区域, 看是否发生变化.
进程B后运行, 它修改映射区域, 而后推出, 此时进程A可以观察到存储映射区的变化
进程A的代码：

    #include <sys/mman.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <stdio.h>  
    #include <stdlib.h> #include <unistd.h> #include <error.h> #define BUF_SIZE 100 int main(int argc, char **argv) { int fd, nread, i; struct stat sb; char *mapped, buf[BUF_SIZE]; for (i = 0; i < BUF_SIZE; i++) { buf[i] = '#'; } /* 打开文件 */ if ((fd = open(argv[1], O_RDWR)) < 0) { perror("open"); } /* 获取文件的属性 */ if ((fstat(fd, &sb)) == -1) { perror("fstat"); } /* 将文件映射至进程的地址空间 */ if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) { perror("mmap"); } /* 文件已在内存, 关闭文件也能够操纵内存 */ close(fd); /* 每隔两秒查看存储映射区是否被修改 */ while (1) { printf("%s\n", mapped); sleep(2); } return 0; } 

进程B的代码：

    #include <sys/mman.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <stdio.h>  
    #include <stdlib.h> #include <unistd.h> #include <error.h> #define BUF_SIZE 100 int main(int argc, char **argv) { int fd, nread, i; struct stat sb; char *mapped, buf[BUF_SIZE]; for (i = 0; i < BUF_SIZE; i++) { buf[i] = '#'; } /* 打开文件 */ if ((fd = open(argv[1], O_RDWR)) < 0) { perror("open"); } /* 获取文件的属性 */ if ((fstat(fd, &sb)) == -1) { perror("fstat"); } /* 私有文件映射将没法修改文件 */ if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) { perror("mmap"); } /* 映射完后, 关闭文件也能够操纵内存 */ close(fd); /* 修改一个字符 */ mapped[20] = '9'; return 0; } 

经过匿名映射实现父子进程通讯

    #include <sys/mman.h>  
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <unistd.h>  

    #define BUF_SIZE 100 int main(int argc, char** argv) { char *p_map; /* 匿名映射,建立一块内存供父子进程通讯 */ p_map = (char *)mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); if(fork() == 0) { sleep(1); printf("child got a message: %s\n", p_map); sprintf(p_map, "%s", "hi, dad, this is son"); munmap(p_map, BUF_SIZE); //实际上，进程终止时，会自动解除映射。 exit(0); } sprintf(p_map, "%s", "hi, this is father"); sleep(2); printf("parent got a message: %s\n", p_map); return 0; } 

对mmap返回地址的访问

linux采用的是页式管理机制。对于用mmap()映射普通文件来讲，进程会在本身的地址空间新增一块空间，空间大
小由mmap()的len参数指定，注意，进程并不必定可以对所有新增空间都能进行有效访问。进程可以访问的有效地址大小取决于文件被映射部分的大小。简单的说，可以容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，可以有效访问的地址空间大小。超过这个空间大小，内核会根据超过的严重程度返回发送不一样的信号给进程。可用以下图示说明：

总结一下就是, 文件大小, mmap的参数 len 都不能决定进程能访问的大小, 而是容纳文件被映射部分的最小页面数决定进程能访问的大小. 下面看一个实例：

    #include <sys/mman.h>  
    #include <sys/types.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <unistd.h> #include <stdio.h> int main(int argc, char** argv) { int fd,i; int pagesize,offset; char *p_map; struct stat sb; /* 取得page size */ pagesize = sysconf(_SC_PAGESIZE); printf("pagesize is %d\n",pagesize); /* 打开文件 */ fd = open(argv[1], O_RDWR, 00777); fstat(fd, &sb); printf("file size is %zd\n", (size_t)sb.st_size); offset = 0; p_map = (char *)mmap(NULL, pagesize * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset); close(fd); p_map[sb.st_size] = '9'; /* 致使总线错误 */ p_map[pagesize] = '9'; /* 致使段错误 */ munmap(p_map, pagesize * 2); return 0; } 

mmap内核空间

内核空间mmap函数原型

内核空间的mmap函数原型为：int (*map)(struct file *filp, struct vm_area_struct *vma);
做用是实现用户进程中的地址与内核中物理页面的映射

mmap函数实现步骤

内核空间mmap函数具体实现步骤以下：
1. 经过kmalloc, get_free_pages, vmalloc等分配一段虚拟地址
2. 若是是使用kmalloc, get_free_pages分配的虚拟地址，那么使用virt_to_phys()将其转化为物理地址，再将获得的物理地址经过”phys>>PAGE_SHIFT”获取其对应的物理页面帧号。或者直接使用virt_to_page从虚拟地址获取获得对应的物理页面帧号。
若是是使用vmalloc分配的虚拟地址，那么使用vmalloc_to_pfn获取虚拟地址对应的物理页面的帧号。
3. 对每一个页面调用SetPageReserved()标记为保留才能够。
4. 经过remap_pfn_range为物理页面的帧号创建页表，并映射到用户空间。
说明：kmalloc, get_free_pages, vmalloc分配的物理内存页面最好仍是不要用remap_pfn_range，建议使用VMA的nopage方法。

说明：
若共享小块连续内存，上面所说的get_free_pages就能够分配多达几M的连续空间，
若共享大块连续内存，就得靠uboot帮忙，给linux kernel传递参数的时候指定”mem=”，而后在内核中使用下面两个函数来预留和释放内存。
void *alloc_bootmem(unsigned long size);
void free_bootmem(unsigned long addr, unsigned long size);

mmap函数实现例子

在字符设备驱动中，有一个struct file_operation结构提，其中fops->mmap指向你本身的mmap钩子函数，用户空间对一个字符设备文件进行mmap系统调用后，最终会调用驱动模块里的mmap钩子函数。在mmap钩子函数中须要调用下面这个API：

int remap_pfn_range(struct vm_area_struct *vma, //这个结构很重要！！后面讲
                    unsigned long virt_addr, //要映射的范围的首地址 unsigned long pfn, //要映射的范围对应的物理内存的页帧号！！重要 unsigned long size, //要映射的范围的大小 pgprot_t prot); //PROTECT属性，mmap()中来的

在mmap钩子函数中，像下面这样就能够了

    int my_mmap(struct file *filp, struct vm_area_struct *vma){
       //......省略，page很重要,其余的参数通常照下面就能够了
       remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start), vma->vm_page_prot); //......省略 }

来看一个例子：
内核空间代码mymap.c

#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h> #include <linux/mm.h> #include <linux/fs.h> #include <linux/types.h> #include <linux/delay.h> #include <linux/moduleparam.h> #include <linux/slab.h> #include <linux/errno.h> #include <linux/ioctl.h> #include <linux/cdev.h> #include <linux/string.h> #include <linux/list.h> #include <linux/pci.h> #include <linux/gpio.h> #define DEVICE_NAME "mymap" static unsigned char array[10]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; static unsigned char *buffer; static int my_open(struct inode *inode, struct file *file) { return 0; } static int my_map(struct file *filp, struct vm_area_struct *vma) { unsigned long phys; //获得物理地址 phys = virt_to_phys(buffer); //将用户空间的一个vma虚拟内存区映射到以page开始的一段连续物理页面上 if(remap_pfn_range(vma, vma->vm_start, phys >> PAGE_SHIFT,//第三个参数是页帧号，由物理地址右移PAGE_SHIFT得>到 vma->vm_end - vma->vm_start, vma->vm_page_prot)) return -1; return 0; } static struct file_operations dev_fops = { .owner = THIS_MODULE, .open = my_open, .mmap = my_map, }; static struct miscdevice misc = { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &dev_fops, }; static ssize_t hwrng_attr_current_show(struct device *dev, struct device_attribute *attr, char *buf) { int i; for(i = 0; i < 10 ; i++){ printk("%d\n", buffer[i]); } return 0; } static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR, hwrng_attr_current_show, NULL); static int __init dev_init(void) { int ret; unsigned char i; //内存分配 buffer = (unsigned char *)kmalloc(PAGE_SIZE,GFP_KERNEL); //driver起来时初始化内存前10个字节数据 for(i = 0;i < 10;i++) buffer[i] = array[i]; //将该段内存设置为保留 SetPageReserved(virt_to_page(buffer)); //注册混杂设备 ret = misc_register(&misc); ret = device_create_file(misc.this_device, &dev_attr_rng_current); return ret; } static void __exit dev_exit(void) { device_remove_file(misc.this_device, &dev_attr_rng_current); //注销设备 misc_deregister(&misc); //清除保留 ClearPageReserved(virt_to_page(buffer)); //释放内存 kfree(buffer); } module_init(dev_init); module_exit(dev_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("LKN@SCUT");

用户空间代码mymap_app.c

/*
 * /home/lei_wang/xxx/xxx_linux/toolchain/xxx/bin/xxx-linux-gcc mymap_app.c -o mymap_app
 */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <fcntl.h> #include <linux/fb.h> #include <sys/mman.h> #include <sys/ioctl.h> #include <errno.h> #define PAGE_SIZE 4096 int main(int argc , char *argv[]) { int fd; int i; unsigned char *p_map; //打开设备 fd = open("/dev/mymap",O_RDWR); if(fd < 0) { printf("open fail\n"); exit(1); } //内存映射 p_map = (unsigned char *)mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(p_map == (void *)-1) { printf("mmap fail\n"); goto here; } close(fd); //打印映射后的内存中的前10个字节内容, //并将前10个字节中的内容都加上10，写入内存中 //经过cat cat /sys/devices/virtual/misc/mymap/rng_current查看内存是否被修改 for(i = 0;i < 10;i++) { printf("%d\n",p_map[i]); p_map[i] = p_map[i] + 10; } here: munmap(p_map, PAGE_SIZE); return 0; }

 
从上面这张图能够看出：
当系统开机，driver起来的时候会将内存前10个字节初始化，经过cat /sys/devices/virtual/misc/mymap/rng_current，能够看出此时内存中的值。
当执行mymap_app时会将前10个字节的内容加上10再写进内存，再经过cat /sys/devices/virtual/misc/mymap/rng_current，能够看出修改后的内存中的值。

参考文章

1. linux 内存映射 remap_pfn_range操做
2. mmap详解

资源下载

1. mmap内核驱动与应用程序

Linux设备驱动之mmap设备操做

1.mmap系统调用

void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);

功能：负责把文件内容映射到进程的虚拟地址空间，经过对这段内存的读取和修改来实现对文件的读取和修改，而不须要再调用read和write；
参数：addr：映射的起始地址，设为NULL由系统指定；
len：映射到内存的文件长度；
prot：指望的内存保护标志，不能与文件的打开模式冲突。PROT_EXEC,PROT_READ,PROT_WRITE等；
flags：指定映射对象的类型，映射选项和映射页是否能够共享。MAP_SHARED，MAP_PRIVATE等；
fd：由open返回的文件描述符，表明要映射的文件；
offset：开始映射的文件的偏移。
返回值：成功执行时，mmap()返回被映射区的指针。失败时，mmap()返回MAP_FAILED。

mmap映射图：

2.解除映射：
　int munmap(void *start, size_t length); 

3.虚拟内存区域：
虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具备一样特性的连续地址范围。一个进程的内存映象由下面几个部分组成：程序代码、数据、BSS和栈区域，以及内存映射的区域。
linux内核使用vm_area_struct结构来描述虚拟内存区。其主要成员：

unsigned long vm_start; /* Our start address within vm_mm. */
unsigned long vm_end; /* The first byte after our end address within vm_mm. */ unsigned long vm_flags; /* Flags, see mm.h. 该区域的标记。如VM_IO（该VMA标记为内存映射的IO区域,会阻止系统将该区域包含在进程的存放转存中）和VM_RESERVED（标志内存区域不能被换出）。*/

4.mmap设备操做：
映射一个设备是指把用户空间的一段地址（虚拟地址区间）关联到设备内存上，当程序读写这段用户空间的地址时，它其实是在访问设备。
mmap方法是file_operations结构的成员，在mmap系统调用的发出时被调用。在此以前，内核已经完成了不少工做。
mmap设备方法所须要作的就是创建虚拟地址到物理地址的页表（虚拟地址和设备的物理地址的关联经过页表）。

static int mmap(struct file *file, struct vm_area_struct *vma)；

mmap如何完成页表的创建？（两种方法）
（1）使用remap_pfn_range一次创建全部页表。

int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr, unsigned long pfn, unsigned long size, pgprot_t prot)；
/** * remap_pfn_range - remap kernel memory to userspace * @vma: user vma to map to：内核找到的虚拟地址区间 * @addr: target user address to start at：要关联的虚拟地址 * @pfn: physical address of kernel memory：要关联的设备的物理地址，也即要映射的物理地址所在的物理帧号，可将物理地址>>PAGE_SHIFT * @size: size of map area * @prot: page protection flags for this mapping * * Note: this is only safe if the mm semaphore is held when called. */

（2）使用nopage VMA方法每次创建一个页表；

5.源码分析：

（1）memdev.h

View Code

/*mem设备描述结构体*/
struct mem_dev                                     
{                                                        
  char *data;                      
  unsigned long size; }; #endif /* _MEMDEV_H_ */

（2）memdev.c

View Code

static int mem_major = MEMDEV_MAJOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp; /*设备结构体指针*/ struct cdev cdev; /*文件打开函数*/ int mem_open(struct inode *inode, struct file *filp) { struct mem_dev *dev; /*获取次设备号*/ int num = MINOR(inode->i_rdev); if (num >= MEMDEV_NR_DEVS) return -ENODEV; dev = &mem_devp[num]; /*将设备描述结构指针赋值给文件私有数据指针*/ filp->private_data = dev; return 0; } /*文件释放函数*/ int mem_release(struct inode *inode, struct file *filp) { return 0; } static int memdev_mmap(struct file*filp, struct vm_area_struct *vma) { struct mem_dev *dev = filp->private_data; /*得到设备结构体指针*/ vma->vm_flags |= VM_IO; vma->vm_flags |= VM_RESERVED; if (remap_pfn_range(vma,vma->vm_start,virt_to_phys(dev->data)>>PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) return -EAGAIN; return 0; } /*文件操做结构体*/ static const struct file_operations mem_fops = { .owner = THIS_MODULE, .open = mem_open, .release = mem_release, .mmap = memdev_mmap, }; /*设备驱动模块加载函数*/ static int memdev_init(void) { int result; int i; dev_t devno = MKDEV(mem_major, 0); /* 静态申请设备号*/ if (mem_major) result = register_chrdev_region(devno, 2, "memdev"); else /* 动态分配设备号 */ { result = alloc_chrdev_region(&devno, 0, 2, "memdev"); mem_major = MAJOR(devno); } if (result < 0) return result; /*初始化cdev结构*/ cdev_init(&cdev, &mem_fops); cdev.owner = THIS_MODULE; cdev.ops = &mem_fops; /* 注册字符设备 */ cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS); /* 为设备描述结构分配内存*/ mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL); if (!mem_devp) /*申请失败*/ { result = - ENOMEM; goto fail_malloc; } memset(mem_devp, 0, sizeof(struct mem_dev)); /*为设备分配内存*/ for (i=0; i < MEMDEV_NR_DEVS; i++) { mem_devp[i].size = MEMDEV_SIZE; mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL); memset(mem_devp[i].data, 0, MEMDEV_SIZE); } return 0; fail_malloc: unregister_chrdev_region(devno, 1); return result; } /*模块卸载函数*/ static void memdev_exit(void) { cdev_del(&cdev); /*注销设备*/ kfree(mem_devp); /*释放设备结构体内存*/ unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/ } MODULE_AUTHOR("David Xie"); MODULE_LICENSE("GPL"); module_init(memdev_init); module_exit(memdev_exit);

（3）app-mmap.c

#include <stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/mman.h>

int main()
{
    int fd;
    char *start;
    //char buf[100]; char *buf; /*打开文件*/ fd = open("/dev/memdev0",O_RDWR); buf = (char *)malloc(100); memset(buf, 0, 100); start=mmap(NULL,100,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); /* 读出数据 */ strcpy(buf,start); sleep (1); printf("buf 1 = %s\n",buf); /* 写入数据 */ strcpy(start,"Buf Is Not Null!"); memset(buf, 0, 100); strcpy(buf,start); sleep (1); printf("buf 2 = %s\n",buf); munmap(start,100); /*解除映射*/ free(buf); close(fd); return 0; }

测试步骤：

（1）编译安装内核模块：insmod memdev.ko

（2）查看设备名、主设备号：cat /proc/devices

（3）手工建立设备节点：mknod  /dev/memdev0  c  ***  0

　　查看设备文件是否存在：ls -l /dev/* | grep memdev

（4）编译下载运行应用程序：./app-mmap

　　结果：buf 1 = 

　　　　　buf 2 = Buf Is Not Null!

　　总结：mmap设备方法实现将用户空间的一段内存关联到设备内存上，对用户空间的读写就至关于对字符设备的读写；不是全部的设备都能进行mmap抽象，好比像串口和其余面向流的设备就不能作mmap抽象。

细说linux IPC（三）：mmap系统调用共享内存

       前面讲到socket的进程间通讯方式，这种方式在进程间传递数据时首先须要从进程1地址空间中把数据拷贝到内核，内核再将数据拷贝到进程2的地址空间中，也就是数据传递须要通过内核传递。这样在处理较多数据时效率不是很高，而让多个进程共享一片内存区则解决了以前socket进程通讯的问题。共享内存是最快的进程间通讯 ，将一片内存映射到多个进程地址空间中，那么进程间的数据传递将不在涉及内核。
        共享内存并非从某一进程拥有的内存中划分出来的；进程的内存老是私有的。共享内存是从系统的空闲内存池中分配的，但愿访问它的每一个进程链接它。这个链接过程称为映射，它给共享内存段分配每一个进程的地址空间中的本地地址。
    mmap()系统调用使得进程之间经过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程能够向访问普通内存同样对文件进行访问，没必要再调用read()，write()等操做。函数原型为：

        其中参数addr为描述符fd应该被映射到进程空间的起始地址，当指定为NULL时内核将本身去选择起始地址，不管addr是为NULL，函数返回值都是fd所映射到内存的起始地址；
        len是映射到调用进程地址空间的字节数，它 从被映射文件开头offset个字节开始算起，offset一般设置为0；
        prot 参数指定共享内存的访问权限。可取以下几个值的或：PROT_READ（可读） , PROT_WRITE （可写）, PROT_EXEC （可执行）, PROT_NONE（不可访问），该值常设置为PROT_READ | PROT_WRITE 。
        flags由如下几个常值指定：MAP_SHARED , MAP_PRIVATE , MAP_FIXED，其中，MAP_SHARED（变更是共享的，对共享内存的修改全部进程可见） , MAP_PRIVATE（变更是私有的，对共享内存修改只对该进程可见）   必选其一，而MAP_FIXED则不推荐使用 。

    munmp() 删除地址映射关系，函数原型以下：

        参数addr是由mmap返回的地址，len是映射区大小。

        进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，每每在调用munmap（）后才执行该操做。能够经过调用msync()实现磁盘上文件内容与共享内存区的内容一致。 msync()函数原型为：

        参数addr和len表明内存区，flags有如下值指定，MS_ASYNC（执行异步写）， MS_SYNC（执行同步写），MS_INVALIDATE（使高速缓存失效）。其中MS_ASYNC和MS_SYNC两个值必须且只能指定一个，一旦写操做排入内核，MS_ASYNC当即返回，MS_SYNC要等到写操做完成后才返回。若是还指定了MS_INVALIDATE，那么与其最终拷贝不一致的文件数据的全部内存中拷贝都失效。

        在使用open函数打开一个文件以后调用mmap把文件内容映射到调用进程的地址空间，这样咱们操做文件内容只须要对映射的地址空间进行操做，而无需再使用open，write等函数。

        使用共享内存的步骤基本是：
open()建立内存段；
用 ftruncate()设置它的大小；
用mmap() 把它映射到进程内存，执行其余参与者须要的操做；
当使用完时，原来的进程调用 munmap()而后退出。
下面来看一个实现：
server程序建立内存并向共享内存写入数据：

client程序映射共享内存并读取其中数据：

先执行server程序向共享内存写入数据，再运行客户程序，运行结果以下：

共享内存不像socket那样自己具备同步机制，它须要经过增长其余同步操做来实现同步，好比信号量等。同步相关操做在后面会有相关专栏详细叙述。

存储器结构、cache、DMA架构分析

 

 

 

 

直接内存访问(DMA)

DMA原理

DMA原理：DMA 是全部现代电脑的重要特点，他容许不一样速度的硬件装置来沟通，而不须要依于 CPU 的大量 中断 负载。不然，CPU 须要从 来源 把每一片断的资料复制到 暂存器，而后把他们再次写回到新的地方。在这个时间中，CPU 对于其余的工做来讲就没法使用。 DMA 传输重要地将一个内存区从一个装置复制到另一个。当 CPU 初始化这个传输动做，传输动做自己是由 DMA 控制器 来实行和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存去。像是这样的操做并无让处理器工做拖延，反而能够被从新排程去处理其余的工做。DMA 传输对于高效能 嵌入式系统 算法和网络是很重要的。　
　　在实现DMA传输时，是由DMA控制器直接掌管总线，所以，存在着一个总线控制权转移问题。即DMA传输前，CPU要把总线控制权交给DMA控制器，而在结束DMA传输后，DMA控制器应当即把总线控制权再交回给CPU。

DMA
一个完整的DMA传输过程必须通过下面的4个步骤。
1.DMA请求
　　CPU对DMA控制器初始化，并向I/O接口发出操做命令，I/O接口提出DMA请求。
2.DMA响应
　　DMA控制器对DMA请求判别优先级及屏蔽，向总线裁决逻辑提出总线请求。当CPU执行完当前总线周期便可释放总线控制权。此时，总线裁决逻辑输出总线应答，表示DMA已经响应，经过DMA控制器通知I/O接口开始DMA传输。
3.DMA传输
　　DMA控制器得到总线控制权后，CPU即刻挂起或只执行内部操做，由DMA控制器输出读写命令，直接控制RAM与I/O接口进行DMA传输。
4.DMA结束
　　当完成规定的成批数据传送后，DMA控制器即释放总线控制权，并向I/O接口发出结束信号。当I/O接口收到结束信号后，一方面停 止I/O设备的工做，另外一方面向CPU提出中断请求，使CPU从不介入的状态解脱，并执行一段检查本次DMA传输操做正确性的代码。最后，带着本次操做结果及状态继续执行原来的程序。
　　因而可知，DMA传输方式无需CPU直接控制传输，也没有中断处理方式那样保留现场和恢复现场的过程，经过硬件为RAM与I/O设备开辟一条直接传送数据的通路，使CPU的效率大为提升。

DMA操做模式
    DMA用于无需CPU的介入而直接由专用控制器创建源与目的传输的应用，所以，在大量数据传输中解放了CPU。PIC32微控制器中的DMA可用于映射到内存空间中的不一样外设，如从存储区到SPI,UART或I2C等设备。DMA特性详见器件参考手册，这里仅对一些基本原理与功能作一个简析。
    PIC32中DMA的传输涉及到几个基本的术语。
    Event:事件，触发控制器启动或中止DMA传输的操做；
    Transaction:事务，单字传输(最多能够到4个字节)，由读/写组成；
    Cell transfer:元传输，单次共DCHXCSIZE个字节的数据传输。元传输由单个或多个事务组成。
    Block transfer：块传输，块传输总的字节数由DCHXSSIZ或DCHXDSIZ决定。块传输由单个或多个元传输组成。
    事件是触发DMA控制器产生动做的方式，分为，START EVENT->启动传输；ABORT EVENT->取消传输；STOP EVENT->中止传输；为了有一个完整的概念认识，能够把用户软件的操做，如置位启动传输位等也包含在事件范围内。由此，能够看出，任何一个DMA动做都是由事件触发完成的。用户在使用DMA控制器时只需设计好事件与DMA操做的关联便可。要充分的使用DMA控制器，熟悉DMA各类工做模式的原理是颇有必要的。
         传输模式二：字符匹配终止模式
    字符匹配模式用于传输不定长字节，而又有传输终止标识字节的应用环境中，Uart是这种模式的应用案例。

     DMA通道的自动使能模式
    DMA每一个通道在正常的块传输、终结字符匹配后或者因异常ABORT后，通道自动禁能。若是该通道有屡次的块传输，须要手动的使能通道；为了省却该操做，DCHXCON寄存器提供了容许自动使能通道的位CHAEN(channel auto enable)。通道使能位CHEN在取消传输或ABORT事件发生时会被置为0。
注：
一、通道起始/终止/中止中断事件独立于中断控制器，所以相应的中断无需使能，也无需在DMA传输后清除相应的位；
二、通道优先级和选择
    DMA控制器每一个通道有一个天然的优先级，CH0默认为最高，CH4默认为最低；通道寄存器DCHXCON中提供了修改优先级的控制位。优先级控制了通道的传输顺序。
 
三、DMA传输中的字节对齐
    PIC32采用的数据总线是32位，4字节；无疑访问地址为4字节对齐的访问效率最高，可是，若是把全部的常量或变量存储地址都限制在4字节对齐显然是不可能的；DMA中在处理这个问题上采用的字节对齐方法（存储方式为LSB）。举例来讲，若是当前物理地址与4的模为0，则取4字节；模为1，则取高3字节；模为2，则取高2字节；模为3，则取高1字节。
    物理地址为0x1230，模为0，则取从0x1230处4字节数据；
    物理地址为0x1231，模为1，则取从0x1231处3字节数据；
    物理地址为0x1232，模为2，则取从0x1232处2字节数据；
    物理地址为0x1233，模为3，则取从0x1233处1字节数据；
    读/写过程均采起相同的字节对齐机制。DMA传输中的字节对齐过程如图2.

     直接存储器存取(DMA)控制器是一种在系统内部转移数据的独特外设，能够将其视为一种可以经过一组专用总线将内部和外部存储器与每一个具备DMA能力的外设链接起来的控制器。它之因此属于外设，是由于它是在处理器的编程控制下来执行传输的。值得注意的是，一般只有数据流量较大(kBps或者更高)的外设才须要支持DMA能力，这些应用方面典型的例子包括视频、音频和网络接口。

通常而言，DMA控制器将包括一条地址总线、一条数据总线和控制寄存器。高效率的DMA控制器将具备访问其所须要的任意资源的能力，而无须处理器自己的介入，它必须能产生中断。最后，它必须能在控制器内部计算出地址。

一个处理器能够包含多个DMA控制器。每一个控制器有多个DMA通道，以及多条直接与存储器站(memory bank)和外设链接的总线，如图1所示。在不少高性能处理器中集成了两种类型的DMA控制器。第一类一般称为“系统DMA控制器”，能够实现对任何资源(外设和存储器)的访问，对于这种类型的控制器来讲，信号周期数是以系统时钟(SCLK)来计数的，以ADI的Blackfin处理器为例，频率最高可达133MHz。第二类称为内部存储器DMA控制器(IMDMA)，专门用于内部存储器所处位置之间的相互存取操做。由于存取都发生在内部(L1－L一、L1－L2，或者L2－L2)，周期数的计数则以内核时钟(CCLK)为基准来进行，该时钟的速度能够超过600MHz。

每一个DMA控制器有一组FIFO，起到DMA子系统和外设或存储器之间的缓冲器的做用。对于MemDMA(Memory DMA)来讲，传输的源端和目标端都有一组FIFO存在。当资源紧张而不能完成数据传输的话，则FIFO能够提供数据的暂存区，从而提升性能。

由于一般会在代码初始化过程当中对DMA控制器进行配置，内核就只须要在数据传输完成后对中断作出响应便可。你能够对DMA控制进行编程，让其与内核并行地移动数据，而同时让内核执行其基本的处理任务—那些应该让它专一完成的工做。

图1：系统和存储器DMA架构。

在一个优化的应用中，内核永远不用参与任何数据的移动，而仅仅对L1存储器中的数据进行读写。因而，内核不须要等待数据的到来，由于DMA引擎会在内核准备读取数据以前将数据准备好。图2给出了处理器和DMA控制器间的交互关系。由处理器完成的操做步骤包括：创建传输，启用中断，生成中断时执行代码。返回处处理器的中断输入能够用来指示“数据已经准备好，可进行处理”。

图2：DMA控制器。

数据除了往来外设以外，还须要从一个存储器空间转移到另外一个空间中。例如，视频源能够从一个视频端口直接流入L3存储器，由于工做缓冲区规模太大，没法放入到存储器中。咱们并不但愿让处理器在每次须要执行计算时都从外部存储读取像素信息，所以为了提升存取的效率，能够用一个存储器到存储器的DMA(MemDMA)来将像素转移到L1或者L2存储器中。

到目前为之，咱们还仅专一于数据的移动，可是DMA的传送能力并不老是用来移动数据。  

 在最简单的MemDMA状况中，咱们须要告诉DMA控制器源端地址、目标端地址和待传送的字的个数。每次传输的字的大小能够是八、16或者12位。  咱们只须要改变数据传输每次的数据大小，就能够简单地增长DMA的灵活性。例如，采用非单一大小的传输方式时，咱们以传输数据块的大小的倍数来做为地址增量。也就是说，若规定32位的传输和4个采样的跨度，则每次传输结束后，地址的增量为16字节(4个32位字)。

DMA的设置

目前有两类主要的DMA传输结构：寄存器模式和描述符模式。不管属于哪一类DMA，表1所描述的几类信息都会在DMA控制器中出现。当DMA以寄存器模式工做时，DMA控制器只是简单地利用寄存器中所存储的参数值。在描述符模式中，DMA控制器在存储器中查找本身的配置参数。

表1：DMA寄存器

基于寄存器的DMA

在基于寄存器的DMA内部，处理器直接对DMA控制寄存器进行编程，来启动传输。基于寄存器的DMA提供了最佳的DMA控制器性能，由于寄存器并不须要不断地从存储器中的描述符上载入数据，而内核也不须要保持描述符。

基于寄存器的DMA由两种子模式组成：自动缓冲(Autobuffer)模式和中止模式。在自动缓冲DMA中，当一个传输块传输完毕，控制寄存器就自动从新载入其最初的设定值，同一个DMA进程从新启动，开销为零。

正如咱们在图3中所看到的那样，若是将一个自动缓冲DMA设定为从外设传输必定数量的字到L1数据存储器的缓冲器上，则DMA控制器将会在最后一个字传输完成的时刻就迅速从新载入初始的参数。这构成了一个“循环缓冲器”，由于当一个量值被写入到缓冲器的最后一个位置上时，下一个值将被写入到缓冲器的第一个位置上。

图3：用DMA实现循环缓冲器。

自动缓冲DMA特别适合于对性能敏感的、存在持续数据流的应用。DMA控制器能够在独立于处理器其余活动的状况下读入数据流，而后在每次传输结束时，向内核发出中断。

中止模式的工做方式与自动缓冲DMA相似，区别在于各寄存器在DMA结束后不会从新载入，所以整个DMA传输只发生一次。中止模式对于基于某种事件的一次性传输来讲十分有用。例如，非按期地将数据块从一个位置转移到另外一个位置。当你须要对事件进行同步时，这种模式也很是有用。例如，若是一个任务必须在下一次传输前完成的话，则中止模式能够确保各事件发生的前后顺序。此外，中止模式对于缓冲器的初始化来讲很是有用。

描述符模型

基于描述符(descriptor)的DMA要求在存储器中存入一组参数，以启动DMA的系列操做。该描述符所包含的参数与那些一般经过编程写入DMA控制寄存器组的全部参数相同。不过，描述符还能够允许多个DMA操做序列串在一块儿。在基于描述符的DMA操做中，咱们能够对一个DMA通道进行编程，在当前的操做序列完成后，自动设置并启动另外一次DMA传输。基于描述符的方式为管理系统中的DMA传输提供了最大的灵活性。

ADI 的Blackfin处理器上有两种主要的描述符方式—描述符阵列和描述符列表，这两种操做方式所要实现的目标是在灵活性和性能之间实现一种折中平衡。

 DMA 方式， 即外设在专用的接口电路DMA 控制器的控制下直接和存储器进行高速数据传送。采用DMA 方式时，如外设
须要进行数据传输， 首先向DMA 控制器发出请求，DMA 再向CPU 发出总线请求，要求控制系统总线。CPU 响应DMA 控制器
的总线请求并把总线控制权交给DMA， 而后在DMA 的控制下开始利用系统总线进行数据传输。数据传输结束后，DMA 并回
总线控制权。DMA 操做步骤：
（1） DMA 控制器的初始化
（2） DMA 数据传送
（3） DMA 结束
DMA 初始化预置以下信息：一是指定I/O 设备对外设"读"仍是"写"，即指定其控制/状态寄存器中相应的控制位；二是数据应传送至何处，指定其地址的首地址；三是有多少数据字须要传送。

DMA原理解析

DMA概念

DMA(Direct Memory Access，直接内存存取) ，DMA 传输将数据从一个地址空间复制到另一个地址空间。采用CPU来初始化这个传输动做，可是传输动做自己是由 DMA 控制器来实行和完成，不须要占用CPU。

DMA控制器（以2440为例）

2440芯片手册第8章为DMA控制器。
2440的DMA控制器支持4个通道。

请求源：

上图是2440中DMA控制器支持的请求源。

基本时序

在请求信号有效以后，通过2个周期DACK信号有效，再通过3个周期，DMA控制器才可得到总线的控制权，开始读写操做。

工做模式
Demond模式：
若是DMA完成一次请求后若是Request仍然有效，那么DMA就认为这是下一次DMA请求，并当即开始下一次的传输。

Handshake模式：
DMA完成一次请求后等待Request信号无效，若是Request 无效，DMA会无效ACK两个时钟周期，再等待下一次Request。

6410芯片的DMA控制器在芯片手册的第11章。

DMA程序设计（2440芯片）

char *buf = "Hello World!";

#define DISRC0     (*(volatile unsigned long*)0x4B000000)
#define DISRCC0 (*(volatile unsigned long*)0x4B000004) #define DIDST0 (*(volatile unsigned long*)0x4B000008) #define DIDSTC0 (*(volatile unsigned long*)0x4B00000C) #define DCON0 (*(volatile unsigned long*)0x4B000010) #define DMASKTRIG0 (*(volatile unsigned long*)0x4B000020) #define UTXH0 (volatile unsigned long*)0x50000020 void dma_init() { //初始化源地址 DISRC0 = (unsigned int)buf; //向寄存器中填写源地址 DISRCC0 = (0<<1)| (0<<0); //内存使用的是AHB总线，源地址须要增加 //初始化目的地址 DIDST0 = UTXH0; //向串口中传送数据 DIDSTC0 = (1<<1)| (1<<0); //串口使用的是APB总线，目的地址老是一个寄存器不增加 DCON0 = (1<<24)| (1<<23)| (1<<22)| (12<<0); //控制寄存器，选择DMA源，硬件，是否屡次发送，数据个数 } void dma_start() { DMASKTRIG0 = (1<<1);//启动传输 }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

DMA程序设计（6410芯片）

/*
S3C6410中DMA操做步骤：
一、决定使用安全DMAC(SDMAC)仍是通用DMAC(DMAC)；
二、开启DMAC控制，设置DMAC_Configuration寄存器；
三、清除传输结束中断寄存器和错误中断寄存器；
四、选择合适的优先级通道；
五、设置通道的源数据地址和目的数据地址（设置DMACC_SrcAddr和DMACC_DestAddr）；
六、设置通道控制寄存器0（设置DMACC_Control0）；
七、设置通道控制寄存器1,（传输大小，设置DMACC_Control1）；
八、设置通道配置寄存器；（设置DMACC_Configuration）
九、使能相应通道（设置DMACC_Configuratoin）；
*/

#define SDMA_SEL            (*((volatile unsigned long *)0x7E00F110))
#define DMACIntTCClear (*((volatile unsigned long *)0x7DB00008)) #define DMACIntErrClr (*((volatile unsigned long *)0x7DB00010)) #define DMACConfiguration (*((volatile unsigned long *)0x7DB00030)) #define DMACSync (*((volatile unsigned long *)0x7DB00034)) #define DMACC0SrcAddr (*((volatile unsigned long *)0x7DB00100)) #define DMACC0DestAddr (*((volatile unsigned long *)0x7DB00104)) #define DMACC0Control0 (*((volatile unsigned long *)0x7DB0010c)) #define DMACC0Control1 (*((volatile unsigned long *)0x7DB00110)) #define DMACC0Configuration (*((volatile unsigned long *)0x7DB00114)) #define UTXH0 (volatile unsigned long *)0x7F005020 char src[100] = "\n\rHello World-> This is a test!\n\r"; void dma_init() { //DMA控制器的选择（SDMAC0） SDMA_SEL = 0; //DMA控制器使能 DMACConfiguration = 1; //初始化源地址 DMACC0SrcAddr = (unsigned int)src; //初始化目的地址 DMACC0DestAddr = (unsigned int)UTXH0; //对控制寄存器进行配置 /* 源地址自增 目的地址固定、 目标主机选择AHB主机2 源主机选择AHB主机1 */ DMACC0Control0 =(1<<25) | (1 << 26)| (1<<31); DMACC0Control1 = 0x64; //传输的大小 /* 流控制和传输类型：MTP 为 001 目标外设：DMA_UART0_1，源外设：DMA_MEM 通道有效: 1 */ DMACC0Configuration = (1<<6) | (1<<11) | (1<<14) | (1<<15); } void dma_start() { //开启channel0 DMA DMACC0Configuration = 1; }

Linux内核DMA机制

DMA控制器硬件结构

DMA容许外围设备和主内存之间直接传输 I/O 数据， DMA 依赖于系统。每一种体系结构DMA传输不一样，编程接口也不一样。

数据传输能够以两种方式触发：一种软件请求数据，另外一种由硬件异步传输。

在第一种状况下，调用的步骤能够归纳以下（以read为例）：

（1）在进程调用 read 时，驱动程序的方法分配一个 DMA 缓冲区，随后指示硬件传送它的数据。进程进入睡眠。

（2）硬件将数据写入 DMA 缓冲区并在完成时产生一个中断。

（3）中断处理程序得到输入数据，应答中断，最后唤醒进程，该进程如今能够读取数据了。

第二种情形是在 DMA 被异步使用时发生的。以数据采集设备为例：

（1）硬件发出中断来通知新的数据已经到达。

（2）中断处理程序分配一个DMA缓冲区。

（3）外围设备将数据写入缓冲区，而后在完成时发出另外一个中断。

（4）处理程序利用DMA分发新的数据，唤醒任何相关进程。

网卡传输也是如此，网卡有一个循环缓冲区（一般叫作 DMA 环形缓冲区）创建在与处理器共享的内存中。每个输入数据包被放置在环形缓冲区中下一个可用缓冲区，而且发出中断。而后驱动程序将网络数据包传给内核的其它部分处理，并在环形缓冲区中放置一个新的 DMA 缓冲区。

驱动程序在初始化时分配DMA缓冲区，并使用它们直到中止运行。

DMA控制器依赖于平台硬件，这里只对i386的8237 DMA控制器作简单的说明，它有两个控制器，8个通道，具体说明以下：

控制器1: 通道0-3，字节操做, 端口为 00-1F

控制器2: 通道 4-7, 字操做, 端口咪 C0-DF

- 全部寄存器是8 bit，与传输大小无关。

　 - 通道 4 被用来将控制器1与控制器2级联起来。

- 通道 0-3 是字节操做，地址/计数都是字节的。

- 通道 5-7 是字操做，地址/计数都是以字为单位的。

- 传输器对于（0-3通道）必须不超过64K的物理边界，对于5-7必须不超过128K边界。

- 对于5-7通道page registers 不用数据 bit 0, 表明128K页

- 对于0-3通道page registers 使用 bit 0, 表示 64K页

DMA 传输器限制在低于16M物理内存里。装入寄存器的地址必须是物理地址，而不是逻辑地址。

　对于0-3通道来讲地址对寄存器的映射以下：

A23 ... A16 A15 ... A8  A7 ... A0    (物理地址)
     |  ...  |   |  ... | | ... | | ... | | ... | | ... | | ... | | ... | | ... | P7 ... P0 A7 ... A0 A7 ... A0 | Page | Addr MSB | Addr LSB | (DMA 地址寄存器)

对于5-7通道来讲地址对寄存器的映射以下：

A23 ... A17 A16 A15 ... A9 A8 A7 ... A1 A0    (物理地址)

    |  ...  |   \   \   ... \  \  \  ... \  \
    |  ...  |    \   \   ... \  \  \  ... \  (没用) | ... | \ \ ... \ \ \ ... \ P7 ... P1 (0) A7 A6 ... A0 A7 A6 ... A0 

通道 5-7 传输以字为单位, 地址和计数都必须是以字对齐的。

在include/asm-i386/dma.h中有i386平台的8237 DMA控制器的各处寄存器的地址及寄存器的定义，这里只对控制寄存器加以说明：

DMA Channel Control/Status Register (DCSRX)

第31位 代表是否开始

第30位 选定Descriptor和Non-Descriptor模式

第29位 判断有无中断

第8位 请求处理 （Request Pending）

第3位 Channel是否运行

第2位 当前数据交换是否完成

第1位 是否由Descriptor产生中断

第0位 是否由总线错误引发中断

struct dma_chan {
	int  lock;
	const char *device_id; }; static struct dma_chan dma_chan_busy[MAX_DMA_CHANNELS] = { [4] = { 1, "cascade" }, };

dmabuf = ioremap( 0x1F00000 /* 31M */, 0x100000 /* 1M */);

int request_dma(unsigned int channel, const char *name); void free_dma(unsigned int channel);

static inline void *pci_alloc_consistent(struct pci_dev *hwdev, 　　　　　　　　　　　　　　　　　size_t size, dma_addr_t *dma_handle) { return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC); }

struct dma_coherent_mem {

void *dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, int gfp) { void *ret; 　　//如果设备，获得设备的dma内存区域，即mem= dev->dma_mem struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL; int order = get_order(size);//将size转换成order，即 //忽略特定的区域，于是忽略这两个标识 gfp &= ~(__GFP_DMA | __GFP_HIGHMEM); if (mem) {//设备的DMA映射，mem= dev->dma_mem 　　　　//找到mem对应的页 int page = bitmap_find_free_region(mem->bitmap, mem->size, order); if (page >= 0) { *dma_handle = mem->device_base + (page << PAGE_SHIFT); ret = mem->virt_base + (page << PAGE_SHIFT); memset(ret, 0, size); return ret; } if (mem->flags & DMA_MEMORY_EXCLUSIVE) return NULL; } 　　//不是设备的DMA映射 if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff)) gfp |= GFP_DMA; 　　//分配空闲页 ret = (void *)__get_free_pages(gfp, order); if (ret != NULL) { memset(ret, 0, size);//清0 *dma_handle = virt_to_phys(ret);//获得物理地址 } return ret; }

static inline dma_addr_t　pci_map_single(struct pci_dev *hwdev, 　　　　　　　　　　　　　　　　void *ptr, size_t size, int direction) { return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum ma_data_direction)direction); }

static inline dma_addr_t dma_map_single(struct device *dev, void *ptr, 

                        size_t size, enum dma_data_direction direction)

struct scatterlist {
    struct page		*page;
    unsigned int offset; dma_addr_t dma_address; //用在分散/集中操做中的缓冲区地址 unsigned int length;//该缓冲区的长度 };

//从该分散表项中返回总线地址

static inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction) { return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction); } include/asm-i386/dma-mapping.h static inline int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) { int i; BUG_ON(direction == DMA_NONE); for (i = 0; i < nents; i++ ) { BUG_ON(!sg[i].page); 　　　　//将页及页偏移地址转化为物理地址 sg[i].dma_address = page_to_phys(sg[i].page) + sg[i].offset; } //可能有些数据还会保留在处理器的高速缓冲存储器中，所以必须显式刷新 flush_write_buffers(); return nents; }

struct dma_pool {	/* the pool */
	struct list_head	page_list;//页链表 spinlock_t lock; size_t blocks_per_page;　//每页的块数 size_t size; //DMA池里的一致内存块的大小 struct device *dev; //将作DMA的设备 size_t allocation; //分配的没有跨越边界的块数，是size的整数倍 char name [32];　//池的名字 wait_queue_head_t waitq; //等待队列 struct list_head pools; };

struct dma_pool *dma_pool_create (const char *name, struct device *dev, 　　　　　　　　　　size_t size, size_t align, size_t allocation) { struct dma_pool *retval; if (align == 0) align = 1; if (size == 0) return NULL; else if (size < align) size = align; else if ((size % align) != 0) {//对齐处理 size += align + 1; size &= ~(align - 1); } 　　//若是一致内存块比页大，是分配为一致内存块大小，不然，分配为页大小 if (allocation == 0) { if (PAGE_SIZE < size)//页比一致内存块小 allocation = size; else allocation = PAGE_SIZE;//页大小 // FIXME: round up for less fragmentation } else if (allocation < size) return NULL; 　　//分配dma_pool结构对象空间 if (!(retval = kmalloc (sizeof *retval, SLAB_KERNEL))) return retval; strlcpy (retval->name, name, sizeof retval->name); retval->dev = dev; 　　//初始化dma_pool结构对象retval INIT_LIST_HEAD (&retval->page_list);//初始化页链表 spin_lock_init (&retval->lock); retval->size = size; retval->allocation = allocation; retval->blocks_per_page = allocation / size; init_waitqueue_head (&retval->waitq);//初始化等待队列 if (dev) {//设备存在时 down (&pools_lock); if (list_empty (&dev->dma_pools)) 　　　　　　//给设备建立sysfs文件系统属性文件 device_create_file (dev, &dev_attr_pools); /* note: not currently insisting "name" be unique */ list_add (&retval->pools, &dev->dma_pools);　//将DMA池加到dev中 up (&pools_lock); } else INIT_LIST_HEAD (&retval->pools); return retval; }

void *dma_pool_alloc (struct dma_pool *pool, int mem_flags, dma_addr_t *handle) { unsigned long flags; struct dma_page *page; int map, block; size_t offset; void *retval; restart: spin_lock_irqsave (&pool->lock, flags); list_for_each_entry(page, &pool->page_list, page_list) { int i; /* only cachable accesses here ... */ //遍历一页的每块，而每块又以32字节递增 for (map = 0, i = 0; i < pool->blocks_per_page;　//每页的块数 i += BITS_PER_LONG, map++) {　// BITS_PER_LONG定义为32 if (page->bitmap [map] == 0) continue; block = ffz (~ page->bitmap [map]);//找出第一个0 if ((i + block) < pool->blocks_per_page) { clear_bit (block, &page->bitmap [map]); 　　　　　　　//获得相对于页边界的偏移 offset = (BITS_PER_LONG * map) + block; offset *= pool->size; goto ready; } } } //给DMA池分配dma_page结构空间，加入到pool->page_list链表， //并做DMA一致映射，它包括分配给DMA池一页。 // SLAB_ATOMIC表示调用 kmalloc（GFP_ATOMIC） 直到失败为止， //而后它等待内核释放若干页面，接下来再一次进行分配。 if (!(page = pool_alloc_page (pool, SLAB_ATOMIC))) { if (mem_flags & __GFP_WAIT) { DECLARE_WAITQUEUE (wait, current); current->state = TASK_INTERRUPTIBLE; add_wait_queue (&pool->waitq, &wait); spin_unlock_irqrestore (&pool->lock, flags); schedule_timeout (POOL_TIMEOUT_JIFFIES); remove_wait_queue (&pool->waitq, &wait); goto restart; } retval = NULL; goto done; } clear_bit (0, &page->bitmap [0]); offset = 0; ready: page->in_use++; retval = offset + page->vaddr;　//返回虚拟地址 *handle = offset + page->dma;　//相对DMA地址 #ifdef CONFIG_DEBUG_SLAB memset (retval, POOL_POISON_ALLOCATED, pool->size); #endif done: spin_unlock_irqrestore (&pool->lock, flags); return retval; }

int dad_transfer(struct dad_dev *dev, int write, void *buffer, size_t count) { dma_addr_t bus_addr; unsigned long flags; /* Map the buffer for DMA */ dev->dma_dir = (write ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE); dev->dma_size = count; 　 //流式映射，将buffer的虚拟地址转化成物理地址 bus_addr = pci_map_single(dev->pci_dev, buffer, count, dev->dma_dir); dev->dma_addr = bus_addr; //DMA传送的buffer物理地址 //将操做控制写入到DMA控制器寄存器，从而创建起设备 writeb(dev->registers.command, DAD_CMD_DISABLEDMA); 　//设置传输方向--读仍是写 writeb(dev->registers.command, write ? DAD_CMD_WR : DAD_CMD_RD);　 writel(dev->registers.addr, cpu_to_le32(bus_addr));//buffer物理地址 writel(dev->registers.len, cpu_to_le32(count)); //传输的字节数 //开始激活DMA进行数据传输操做 writeb(dev->registers.command, DAD_CMD_ENABLEDMA); return 0; }

void dad_interrupt(int irq, void *dev_id, struct pt_regs *regs) 

  struct dad_dev *dev = (struct dad_dev *) dev_id; 

  /* Make sure it's really our device interrupting */ 

  /* Unmap the DMA buffer */ 
  pci_unmap_single(dev->pci_dev, dev->dma_addr, dev->dma_size, dev->dma_dir); 

  /* Only now is it safe to access the buffer, copy to user, etc. */ 
  ... 

int dad_open (struct inode *inode, struct file *filp) 

  struct dad_device *my_device; 

  // SA_INTERRUPT表示快速中断处理且不支持共享 IRQ 信号线
  if ( (error = request_irq(my_device.irq, dad_interrupt, SA_INTERRUPT, "dad", NULL)) ) return error; /* or implement blocking open */ 

  if ( (error = request_dma(my_device.dma, "dad")) ) { free_irq(my_device.irq, NULL); return error; /* or implement blocking open */ } 

  return 0; 

void dad_close (struct inode *inode, struct file *filp) 

  struct dad_device *my_device; 
  free_dma(my_device.dma); free_irq(my_device.irq, NULL); …… 

int dad_dma_prepare(int channel, int mode, unsigned int buf, 

                  unsigned int count) 

  unsigned long flags; 

  flags = claim_dma_lock(); 
  disable_dma(channel); clear_dma_ff(channel); set_dma_mode(channel, mode); set_dma_addr(channel, virt_to_bus(buf)); set_dma_count(channel, count); enable_dma(channel); release_dma_lock(flags); 

  return 0; 

int dad_dma_isdone(int channel) 
{ 
   int residue; unsigned long flags = claim_dma_lock (); residue = get_dma_residue(channel); release_dma_lock(flags); return (residue == 0); }

Linux 内核DMA机制

DMA控制器硬件结构

DMA容许外围设备和主内存之间直接传输 I/O 数据， DMA 依赖于系统。每一种体系结构DMA传输不一样，编程接口也不一样。

数据传输能够以两种方式触发：一种软件请求数据，另外一种由硬件异步传输。

在第一种状况下，调用的步骤能够归纳以下（以read为例）：

（1）在进程调用 read 时，驱动程序的方法分配一个 DMA 缓冲区，随后指示硬件传送它的数据。进程进入睡眠。

（2）硬件将数据写入 DMA 缓冲区并在完成时产生一个中断。

（3）中断处理程序得到输入数据，应答中断，最后唤醒进程，该进程如今能够读取数据了。

第二种情形是在 DMA 被异步使用时发生的。以数据采集设备为例：

（1）硬件发出中断来通知新的数据已经到达。

（2）中断处理程序分配一个DMA缓冲区。

（3）外围设备将数据写入缓冲区，而后在完成时发出另外一个中断。

（4）处理程序利用DMA分发新的数据，唤醒任何相关进程。

网卡传输也是如此，网卡有一个循环缓冲区（一般叫作 DMA 环形缓冲区）创建在与处理器共享的内存中。每个输入数据包被放置在环形缓冲区中下一个可用缓冲区，而且发出中断。而后驱动程序将网络数据包传给内核的其它部分处理，并在环形缓冲区中放置一个新的 DMA 缓冲区。

驱动程序在初始化时分配DMA缓冲区，并使用它们直到中止运行。

DMA控制器依赖于平台硬件，这里只对i386的8237 DMA控制器作简单的说明，它有两个控制器，8个通道，具体说明以下：

控制器1: 通道0-3，字节操做, 端口为 00-1F

控制器2: 通道 4-7, 字操做, 端口咪 C0-DF

- 全部寄存器是8 bit，与传输大小无关。

- 通道 4 被用来将控制器1与控制器2级联起来。

- 通道 0-3 是字节操做，地址/计数都是字节的。

- 通道 5-7 是字操做，地址/计数都是以字为单位的。

- 传输器对于（0-3通道）必须不超过64K的物理边界，对于5-7必须不超过128K边界。

- 对于5-7通道page registers 不用数据 bit 0, 表明128K页

- 对于0-3通道page registers 使用 bit 0, 表示 64K页

DMA 传输器限制在低于16M物理内存里。装入寄存器的地址必须是物理地址，而不是逻辑地址。

在include/asm-i386/dma.h中有i386平台的8237 DMA控制器的各处寄存器的地址及寄存器的定义，这里只对控制寄存器加以说明：

DMA Channel Control/Status Register (DCSRX)

第31位 代表是否开始

第30位选定Descriptor和Non-Descriptor模式

第29位 判断有无中断

第8位 请求处理 （Request Pending）

第3位 Channel是否运行

第2位 当前数据交换是否完成

第1位是否由Descriptor产生中断

第0位 是否由总线错误引发中断

DMA通道使用的地址

DMA通道用dma_chan结构数组表示，这个结构在kernel/dma.c中，列出以下：

若是dma_chan_busy[n].lock != 0表示忙，DMA0保留为DRAM更新用，DMA4用做级联。DMA 缓冲区的主要问题是，当它大于一页时，它必须占据物理内存中的连续页。

因为DMA须要连续的内存，于是在引导时分配内存或者为缓冲区保留物理 RAM 的顶部。在引导时给内核传递一个"mem="参数能够保留 RAM 的顶部。例如，若是系统有 32MB 内存，参数"mem=31M"阻止内核使用最顶部的一兆字节。稍后，模块能够使用下面的代码来访问这些保留的内存：

分配 DMA 空间的方法，代码调用 kmalloc（GFP_ATOMIC） 直到失败为止，而后它等待内核释放若干页面，接下来再一次进行分配。最终会发现由连续页面组成的DMA 缓冲区的出现。

一个使用 DMA 的设备驱动程序一般会与链接到接口总线上的硬件通信，这些硬件使用物理地址，而程序代码使用虚拟地址。基于 DMA 的硬件使用总线地址而不是物理地址，有时，接口总线是经过将 I/O 地址映射到不一样物理地址的桥接电路链接的。甚至某些系统有一个页面映射方案，可以使任意页面在外围总线上表现为连续的。

当驱动程序须要向一个 I/O 设备（例如扩展板或者DMA控制器）发送地址信息时，必须使用 virt_to_bus 转换，在接受到来自链接到总线上硬件的地址信息时，必须使用 bus_to_virt 了。

DMA操做函数

由于 DMA 控制器是一个系统级的资源，因此内核协助处理这一资源。内核使用 DMA 注册表为 DMA 通道提供了请求/释放机制，而且提供了一组函数在 DMA 控制器中配置通道信息。

DMA 控制器使用函数request_dma和free_dma来获取和释放 DMA 通道的全部权，请求 DMA 通道应在请求了中断线以后，而且在释放中断线以前释放它。每个使用 DMA 的设备也必须使用中断信号线，不然就没法发出数据传输完成的通知。这两个函数的声明列出以下（在kernel/dma.c中）：

DMA 控制器被dma_spin_lock 的自旋锁所保护。使用函数claim_dma_lock和release_dma_lock对得到和释放自旋锁。这两个函数的声明列出以下（在kernel/dma.c中）：

unsigned long claim_dma_lock(); 获取 DMA 自旋锁，该函数会阻塞本地处理器上的中断，所以，其返回值是"标志"值，在从新打开中断时必须使用该值。

void release_dma_lock(unsigned long flags); 释放 DMA 自旋锁，而且恢复之前的中断状态。

DMA 控制器的控制设置信息由RAM 地址、传输的数据（以字节或字为单位），以及传输的方向三部分组成。下面是i386平台的8237 DMA控制器的操做函数说明（在include/asm-i386/dma.h中），使用这些函数设置DMA控制器时，应该持有自旋锁。但在驱动程序作I/O 操做时，不能持有自旋锁。

void set_dma_mode(unsigned int channel, char mode); 该函数指出通道从设备读（DMA_MODE_WRITE）或写（DMA_MODE_READ）数据方式，当mode设置为 DMA_MODE_CASCADE时，表示释放对总线的控制。

void set_dma_addr(unsigned int channel, unsigned int addr); 函数给 DMA 缓冲区的地址赋值。该函数将 addr 的最低 24 位存储到控制器中。参数 addr 是总线地址。

void set_dma_count(unsigned int channel, unsigned int count);该函数对传输的字节数赋值。参数 count 也表明 16 位通道的字节数，在此状况下，这个数字必须是偶数。

除了这些操做函数外，还有些对DMA状态进行控制的工具函数：

void disable_dma(unsigned int channel); 该函数设置禁止使用DMA 通道。这应该在配置 DMA 控制器以前设置。

void enable_dma(unsigned int channel); 在DMA 通道中包含了合法的数据时，该函数激活DMA 控制器。

int get_dma_residue(unsigned int channel); 该函数查询一个 DMA 传输还有多少字节还没传输完。函数返回没传完的字节数。当传输成功时，函数返回值是0。

void clear_dma_ff(unsigned int channel) 该函数清除 DMA 触发器（flip-flop），该触发器用来控制对 16 位寄存器的访问。能够经过两个连续的 8 位操做来访问这些寄存器，触发器被清除时用来选择低字节，触发器被置位时用来选择高字节。在传输 8 位后，触发器会自动反转；在访问 DMA 寄存器以前，程序员必须清除触发器（将它设置为某个已知状态）。

DMA映射

一个DMA映射就是分配一个 DMA 缓冲区并为该缓冲区生成一个可以被设备访问的地址的组合操做。通常状况下，简单地调用函数virt_to_bus 就设备总线上的地址，但有些硬件映射寄存器也被设置在总线硬件中。映射寄存器（mapping register）是一个相似于外围设备的虚拟内存等价物。在使用这些寄存器的系统上，外围设备有一个相对较小的、专用的地址区段，能够在此区段执行 DMA。经过映射寄存器，这些地址被重映射到系统 RAM。映射寄存器具备一些好的特性，包括使分散的页面在设备地址空间看起来是连续的。但不是全部的体系结构都有映射寄存器，特别地，PC 平台没有映射寄存器。

在某些状况下，为设备设置有用的地址也意味着须要构造一个反弹（bounce）缓冲区。例如，当驱动程序试图在一个不能被外围设备访问的地址（一个高端内存地址）上执行 DMA 时，反弹缓冲区被建立。而后，按照须要，数据被复制到反弹缓冲区，或者从反弹缓冲区复制。

根据 DMA 缓冲区指望保留的时间长短，PCI 代码区分两种类型的 DMA 映射：

一致 DMA 映射 它们存在于驱动程序的生命周期内。一个被一致映射的缓冲区必须同时可被 CPU 和外围设备访问，这个缓冲区被处理器写时，可当即被设备读取而没有cache效应，反之亦然，使用函数pci_alloc_consistent创建一致映射。

流式 DMA映射 流式DMA映射是为单个操做进行的设置。它映射处理器虚拟空间的一块地址，以至它能被设备访问。应尽量使用流式映射，而不是一致映射。这是由于在支持一致映射的系统上，每一个 DMA 映射会使用总线上一个或多个映射寄存器。具备较长生命周期的一致映射，会独占这些寄存器很长时间――即便它们没有被使用。使用函数dma_map_single创建流式映射。

（1）创建一致 DMA 映射

函数pci_alloc_consistent处理缓冲区的分配和映射，函数分析以下（在include/asm-generic/pci-dma-compat.h中）：

结构dma_coherent_mem定义了DMA一致性映射的内存的地址、大小和标识等。结构dma_coherent_mem列出以下（在arch/i386/kernel/pci-dma.c中）：

函数dma_alloc_coherent分配size字节的区域的一致内存，获得的dma_handle是指向分配的区域的地址指针，这个地址做为区域的物理基地址。dma_handle是与总线同样的位宽的无符号整数。 函数dma_alloc_coherent分析以下（在arch/i386/kernel/pci-dma.c中）：

当再也不须要缓冲区时（一般在模块卸载时），应该调用函数 pci_free_consitent 将它返还给系统。

（2）创建流式 DMA 映射

在流式 DMA 映射的操做中，缓冲区传送方向应匹配于映射时给定的方向值。缓冲区被映射后，它就属于设备而再也不属于处理器了。在缓冲区调用函数pci_unmap_single撤销映射以前，驱动程序不该该触及其内容。

在缓冲区为 DMA 映射时，内核必须确保缓冲区中全部的数据已经被实际写到内存。可能有些数据还会保留在处理器的高速缓冲存储器中，所以必须显式刷新。在刷新以后，由处理器写入缓冲区的数据对设备来讲也许是不可见的。

若是欲映射的缓冲区位于设备不能访问的内存区段时，某些体系结构仅仅会操做失败，而其它的体系结构会建立一个反弹缓冲区。反弹缓冲区是被设备访问的独立内存区域，反弹缓冲区复制原始缓冲区的内容。

函数pci_map_single映射单个用于传送的缓冲区，返回值是能够传递给设备的总线地址，若是出错的话就为 NULL。一旦传送完成，应该使用函数pci_unmap_single 删除映射。其中，参数direction为传输的方向，取值以下：

PCI_DMA_TODEVICE 数据被发送到设备。

PCI_DMA_FROMDEVICE若是数据将发送到 CPU。

PCI_DMA_BIDIRECTIONAL数据进行两个方向的移动。

PCI_DMA_NONE 这个符号只是为帮助调试而提供。

函数pci_map_single分析以下（在arch/i386/kernel/pci-dma.c中）：

函数dma_map_single映射一块处理器虚拟内存，这块虚拟内存能被设备访问，返回内存的物理地址，函数dma_map_single分析以下（在include/asm-i386/dma-mapping.h中）：

（3）分散/集中映射

分散/集中映射是流式 DMA 映射的一个特例。它将几个缓冲区集中到一块儿进行一次映射，并在一个 DMA 操做中传送全部数据。这些分散的缓冲区由分散表结构scatterlist来描述，多个分散的缓冲区的分散表结构组成缓冲区的struct scatterlist数组。

分散表结构列出以下（在include/asm-i386/scatterlist.h）：

每个缓冲区的地址和长度会被存储在 struct scatterlist 项中，但在不一样的体系结构中它们在结构中的位置是不一样的。下面的两个宏定义来解决平台移植性问题，这些宏定义应该在一个pci_map_sg 被调用后使用：

函数pci_map_sg完成分散/集中映射，其返回值是要传送的 DMA 缓冲区数；它可能会小于 nents（也就是传入的分散表项的数量），由于可能有的缓冲区地址上是相邻的。一旦传输完成，分散/集中映射经过调用函数pci_unmap_sg 来撤销映射。 函数pci_map_sg分析以下（在include/asm-generic/pci-dma-compat.h中）：

DMA池

许多驱动程序须要又多又小的一致映射内存区域给DMA描述子或I/O缓存buffer，这使用DMA池比用dma_alloc_coherent分配的一页或多页内存区域好，DMA池用函数dma_pool_create建立，用函数dma_pool_alloc从DMA池中分配一块一致内存，用函数dmp_pool_free放内存回到DMA池中，使用函数dma_pool_destory释放DMA池的资源。

结构dma_pool是DMA池描述结构，列出以下：

函数dma_pool_create给DMA建立一个一致内存块池，其参数name是DMA池的名字，用于诊断用，参数dev是将作DMA的设备，参数size是DMA池里的块的大小，参数align是块的对齐要求，是2的幂，参数allocation返回没有跨越边界的块数（或0）。

函数dma_pool_create返回建立的带有要求字符串的DMA池，若建立失败返回null。对被给的DMA池，函数dma_pool_alloc被用来分配内存，这些内存都是一致DMA映射，可被设备访问，且没有使用缓存刷新机制，由于对齐缘由，分配的块的实际尺寸比请求的大。若是分配非0的内存，从函数dma_pool_alloc返回的对象将不跨越size边界（如不跨越4K字节边界）。这对在个体的DMA传输上有地址限制的设备来讲是有利的。

函数dma_pool_create分析以下（在drivers/base/dmapool.c中）：

函数dma_pool_alloc从DMA池中分配一块一致内存，其参数pool是将产生块的DMA池，参数mem_flags是GFP_*位掩码，参数handle是指向块的DMA地址，函数dma_pool_alloc返回当前没用的块的内核虚拟地址，并经过handle给出它的DMA地址，若是内存块不能被分配，返回null。

函数dma_pool_alloc包裹了dma_alloc_coherent页分配器，这样小块更容易被总线的主控制器使用。这可能共享slab分配器的内容。

函数dma_pool_alloc分析以下（在drivers/base/dmapool.c中）：

一个简单的使用DMA 例子

示例：下面是一个简单的使用DMA进行传输的驱动程序，它是一个假想的设备，只列出DMA相关的部分来讲明驱动程序中如何使用DMA的。

函数dad_transfer是设置DMA对内存buffer的传输操做函数，它使用流式映射将buffer的虚拟地址转换到物理地址，设置好DMA控制器，而后开始传输数据。

Linux 中断详解 【转】

方法之三：以数据结构为基点，举一反三

　　结构化程序设计思想认为：程序 ＝数据结构 ＋算法。数据结构体现了整个系统的构架，因此数据结构一般都是代码分析的很好的着手点，对Linux内核分析尤为如此。好比，把进程控制块结构分析清楚 了，就对进程有了基本的把握；再好比，把页目录结构和页表结构弄懂了，两级虚存映射和内存管理也就掌握得差很少了。为了体现按部就班的思想，在这我就以 Linux对中断机制的处理来介绍这种方法。

　　首先，必须指出的是：在此处，中断指广义的中断概义，它指全部经过idt进行的控制转移的机制和处理；它覆盖如下几个经常使用的概义：中断、异常、可屏蔽中断、不可屏蔽中断、硬中断、软中断 … … …

I、硬件提供的中断机制和约定

一.中断向量寻址：

　　硬件提供可供256个服务程序中断进入的入口，即中断向量；

　　中断向量在保护模式下的实现机制是中断描述符表idt，idt的位置由idtr肯定,idtr是个48位的寄存器，高32位是idt的基址，低16位为idt的界限(一般为2k=256*8)；

　　idt中包含256个中断描述符，对应256个中断向量；每一个中断描述符8位，其结构如图一：

　　中断进入过程如图二所示。

　　当中断是由低特权级转到高特权级(即当前特权级CPL>DPL)时，将进行堆栈的转移；内层堆栈的选择由当前tss的相应字段肯定，并且内层堆栈将依次被压入以下数据：外层SS,外层ESP,EFLAGS,外层CS,外层EIP； 中断返回过程为一逆过程；

二.异常处理机制：

　　Intel公司保留0-31号中断向量用来处理异常事件：当产生一个异常时，处理机就会自动把控制转移到相应的处理程序的入口，异常的处理程序由操做系统提供，中断向量和异常事件对应如表一：

三.可编程中断控制器8259A：

　　为更好的处理外部设备，x86微机提供了两片可编程中断控制器，用来辅助cpu接受外部的中断信号；对于中断，cpu只提供两个外接引线：NMI和INTR；

　　NMI只能经过端口操做来屏蔽，它一般用于：电源掉电和物理存储器奇偶验错；

　　INTR可经过直接设置中断屏蔽位来屏蔽，它可用来接受外部中断信号，但只有一个引线，不够用；因此它经过外接两片级链了的8259A,以接受更多的外部中断信号。8259A主要完成这样一些任务：

1. 中断优先级排队管理，
2. 接受外部中断请求
3. 向cpu提供中断类型号

　　外部设备产生的中断信号在IRQ（中断请求）管脚上首先由中断控制器处理。中断控制器可 以响应多个中断输入，它的输出链接到 CPU 的 INT 管脚，信号可经过INT 管脚，通知处理器产生了中断。若是 CPU 这时能够处理中断，CPU 会经过 INTA（中断确认）管脚上的信号通知中断控制器已接受中断，这时，中断控制器可将一个 8 位数据放置在数据总线上，这一 8 位数据也称为中断向量号，CPU 依据中断向量号和中断描述符表（IDT）中的信息自动调用相应的中断服务程序。图三中，两个中断控制器级联了起来，从属中断控制器的输出链接到了主中断控 制器的第 3 个中断信号输入，这样，该系统可处理的外部中断数量最多可达 15 个，图的右边是 i386 PC 中各中断输入管脚的通常分配。可经过对8259A的初始化，使这15个外接引脚对应256个中断向量的任何15个连续的向量；因为intel公司保留0- 31号中断向量用来处理异常事件(而默认状况下，IBM bios把硬中断设在0x08-0x0f)，因此，硬中断必须设在31之后，linux则在实模式下初始化时把其设在0x20-0x2F，对此下面还将具 体说明。

图3、i386 PC 可编程中断控制器8259A级链示意图

II、Linux的中断处理

　　硬件中断机制提供了256个入口，即idt中包含的256个中断描述符（对应256个中断向量）。

　　而0-31号中断向量被intel公司保留用来处理异常事件，不能另做它用。对这 0-31号中断向量，操做系统只需提供异常的处理程序，当产生一个异常时，处理机就会自动把控制转移到相应的处理程序的入口，运行相应的处理程序；而事实 上，对于这32个处理异常的中断向量，此版本（2.2.5）的 Linux只提供了0-17号中断向量的处理程序，其对应处理程序参见表1、中断向量和异常事件对应表；也就是说，17-31号中断向量是空着未用的。

　　既然0-31号中断向量已被保留，那么，就是剩下32-255共224个中断向量可用。 这224个中断向量又是怎么分配的呢？在此版本（2.2.5）的Linux中，除了0x80 (SYSCALL_VECTOR)用做系统调用总入口以外，其余都用在外部硬件中断源上，其中包括可编程中断控制器8259A的15个irq；事实上，当 没有定义CONFIG_X86_IO_APIC时，其余223(除0x80外)个中断向量，只利用了从32号开始的15个，其它208个空着未用。

　　这些中断服务程序入口的设置将在下面有详细说明。

一．相关数据结构

1. 中断描述符表idt： 也就是中断向量表，至关如一个数组，保存着各中断服务例程的入口。（详细描述参见图1、中断描述符格式）
2. 与硬中断相关数据结构:

与硬中断相关数据结构主要有三个：

一：定义在/arch/i386/kernel/irq.h中的

struct hw_interrupt_type {

const char * typename；

void (*startup)(unsigned int irq)；

void (*shutdown)(unsigned int irq)；

void (*handle)(unsigned int irq, struct pt_regs * regs)；

void (*enable)(unsigned int irq)；

void (*disable)(unsigned int irq)；

}；

二：定义在/arch/i386/kernel/irq.h中的

typedef struct {

unsigned int status； /* IRQ status - IRQ_INPROGRESS, IRQ_DISABLED */

struct hw_interrupt_type *handler； /* handle/enable/disable functions */

struct irqaction *action； /* IRQ action list */

unsigned int depth； /* Disable depth for nested irq disables */

} irq_desc_t；

三：定义在include/linux/ interrupt.h中的

struct irqaction {

void (*handler)(int, void *, struct pt_regs *)；

unsigned long flags；

unsigned long mask；

const char *name；

void *dev_id；

struct irqaction *next；

}；

三者关系以下：

图4、与硬中断相关的几个数据结构各关系

各结构成员详述以下：

1. struct irqaction结构,它包含了内核接收到特定IRQ以后应该采起的操做，其成员以下：

• handler：是一指向某个函数的指针。该函数就是所在结构对相应中断的处理函数。
• flags：取值只有SA_INTERRUPT（中断可嵌套），SA_SAMPLE_RANDOM（这个中断是源于物理随机性的），和SA_SHIRQ（这个IRQ和其它struct irqaction共享）。
• mask：在x86或者体系结构无关的代码中不会使用（除非将其设置为0）；只有在SPARC64的移植版本中要跟踪有关软盘的信息时才会使用它。
• name：产生中断的硬件设备的名字。由于不止一个硬件能够共享一个IRQ。
• dev_id：标识硬件类型的一个惟一的ID。Linux支持的全部硬件设备的每一种类型，都有一个由制造厂商定义的在此成员中记录的设备ID。
• next：若是IRQ是共享的，那么这就是指向队列中下一个struct irqaction结构的指针。一般状况下，IRQ不是共享的，所以这个成员就为空。

1. struct hw_interrupt_type结构，它是一个抽象的中断控制器。这包含一系列的指向函数的指针，这些函数处理控制器特有的操做：

• typename：控制器的名字。
• startup：容许从给定的控制器的IRQ所产生的事件。
• shutdown：禁止从给定的控制器的IRQ所产生的事件。
• handle：根据提供给该函数的IRQ，处理惟一的中断。
• enable和disable：这两个函数基本上和startup和shutdown相同；

   

  1. 另一个数据结构是irq_desc_t，它具备以下成员：

• status：一个整数。表明IRQ的状态：IRQ是否被禁止了，有关IRQ的设备当前是否正被自动检测，等等。
• handler：指向hw_interrupt_type的指针。
• action：指向irqaction结构组成的队列的头。正常状况下每一个IRQ只有一个操做，所以连接列表的正常长度是1（或者0）。可是，若是IRQ被两个或者多个设备所共享，那么这个队列中就有多个操做。
• depth：irq_desc_t的当前用户的个数。主要是用来保证在中断处理过程当中IRQ不会被禁止。
• irq_desc是irq_desc_t 类型的数组。对于每个IRQ都有一个数组入口，即数组把每个IRQ映射到和它相关的处理程序和irq_desc_t中的其它信息。

1. 与Bottom_half相关的数据结构:

图5、底半处理数据结构示意图

• bh_mask_count：计数器。对每一个enable/disable请求嵌套对进行计数。这些请求经过调用enable_bh和 disable_bh实现。每一个禁止请求都增长计数器；每一个使能请求都减少计数器。当计数器达到0时，全部未完成的禁止语句都已经被使能语句所匹配了，因 此下半部分最终被从新使能。（定义在kernel/softirq.c中）
• bh_mask和bh_active：它们共同决定下半部分是否运行。它们两个都有32位，而每个下半部分都占用一位。当一个上半部 分（或者一些其它代码）决定其下半部分须要运行时，就经过设置bh_active中的一位来标记下半部分。无论是否作这样的标记，下半部分均可以经过清空 bh_mask中的相关位来使之失效。所以，对bh_mask和bh_active进行位AND运算就可以代表应该运行哪个下半部分。特别是若是位与运 算的结果是0，就没有下半部分须要运行。
• bh_base：是一组简单的指向下半部分处理函数的指针。

　　bh_base表明的指针数组中可包含 32 个不一样的底半处理程序。bh_mask 和 bh_active 的数据位分别表明对应的底半处理过程是否安装和激活。若是 bh_mask 的第 N 位为 1，则说明 bh_base 数组的第 N 个元素包含某个底半处理过程的地址；若是 bh_active 的第 N 位为 1，则说明必须由调度程序在适当的时候调用第 N 个底半处理过程。　

二. 向量的设置和相关数据的初始化：

• 在实模式下的初始化过程当中，经过对中断控制器8259A-1,9259A-2从新编程，把硬中断设到0x20-0x2F。即把IRQ0& #0；IRQ15分别与0x20-0x2F号中断向量对应起来；当对应的IRQ发生了时，处理机就会经过相应的中断向量，把控制转到对应的中断服务例 程。（源码在Arch/i386/boot/setup.S文件中；相关内容可参见 实模式下的初始化 部分）
• 在保护模式下的初始化过程当中，设置并初始化idt,共256个入口，服务程序均为ignore_int, 该服务程序仅打印“Unknown interruptn”。（源码参见Arch/i386/KERNEL/head.S文件；相关内容可参见 保护模式下的初始化 部分）
• 在系统初始化完成后运行的第一个内核程序asmlinkage void __init start_kernel(void) (源码在文件init/main.c中) 中，经过调用void __init trap_init(void)函数，把各自陷和中断服务程序的入口地址设置到 idt 表中，即将表一中对应的处理程序入口设置到相应的中断向量表项中；在此版本（2.2.5）的Linux只设置0-17号中断向量。（trap_init (void)函数定义在arch/i386/kernel/traps.c 中； 相关内容可参见 详解系统调用 部分）
• 在同一个函数void __init trap_init(void)中，经过调用函数set_system_gate(SYSCALL_VECTOR,&system_call)； 把系统调用总控程序的入口挂在中断0x80上。其中SYSCALL_VECTOR是定义在 linux/arch/i386/kernel/irq.h中的一个常量0x80； 而 system_call 即为中断总控程序的入口地址；中断总控程序用汇编语言定义在arch/i386/kernel/entry.S中。（相关内容可参见 详解系统调用 部分）
• 在系统初始化完成后运行的第一个内核程序asmlinkage void __init start_kernel(void) (源码在文件init/main.c中) 中，经过调用void init_IRQ(void)函数，把地址标号interrupt[i]（i从1-223）设置到 idt 表中的的32-255号中断向量（0x80除外），外部硬件IRQ的触发，将经过这些地址标号最终进入到各自相应的处理程序。（init_IRQ (void)函数定义在arch/i386/kernel/IRQ.c 中；）
• interrupt[i](i从1-223)，是在arch/i386/kernel/IRQ.c文件中,经过一系列嵌套的相似如 BUILD_16_IRQS(0x0)的宏，定义的一系列地址标号；（这些定义interrupt[i]的宏，所有定义在文件 arch/i386/kernel/IRQ.c和arch/i386/kernel/IRQ.H中。这些嵌套的宏的使用，原理很简单，但很烦，限于篇幅， 在此省略）
• 各以interrupt[i]为入口的代码，在进行一些简单的处理后，最后都会调用函数asmlinkage void do_IRQ(struct pt_regs regs),do_IRQ函数调用static void do_8259A_IRQ(unsigned int irq, struct pt_regs * regs) 而do_8259A_IRQ在进行必要的处理后，将调用已与此IRQ创建联系irqaction中的处理函数，以进行相应的中断处理。最后处理机将跳转到 ret_from_intr进行必要处理后，整个中断处理结束返回。(相关源码都在文件arch/i386/kernel/IRQ.c和 arch/i386/kernel/IRQ.H中。Irqaction结构参见上面的数据结构说明)

三. Bottom_half处理机制

　　在此版本(2.2.5)的Linux中，中断处理程序从概念上被分为上半部分（top half）和下半部分（bottom half）；在中断发生时上半部分的处理过程当即执行，可是下半部分（若是有的话）却推迟执行。内核把上半部分和下半部分做为独立的函数来处理，上半部分 决定其相关的下半部分是否须要执行。必须当即执行的部分必须位于上半部分，而能够推迟的部分可能属于下半部分。

　　那么为何这样划分红两个部分呢？

• 一个缘由是要把中断的总延迟时间最小化。Linux内核定义了两种类型的中断，快速的和慢速的，这二者之间的一个区别是慢速中断自身还能够被中 断，而快速中断则不能。所以，当处理快速中断时，若是有其它中断到达；无论是快速中断仍是慢速中断，它们都必须等待。为了尽量快地处理这些其它的中断， 内核就须要尽量地将处理延迟到下半部分执行。
• 另一个缘由是，当内核执行上半部分时，正在服务的这个特殊IRQ将会被可编程中断控制器禁止，因而，链接在同一个IRQ上的其它设备 就只有等到该该中断处理被处理完毕后果才能发出IRQ请求。而采用Bottom_half机制后，不须要当即处理的部分就能够放在下半部分处理，从而，加 快了处理机对外部设备的中断请求的响应速度。
• 还有一个缘由就是，处理程序的下半部分还能够包含一些并不是每次中断都必须处理的操做；对这些操做，内核能够在一系列设备中断以后集中处 理一次就能够了。即在这种状况下，每次都执行并不是必要的操做彻底是一种浪费，而采用Bottom_half机制后，能够稍稍延迟并在后来只执行一次就行 了。

　　因而可知，没有必要每次中断都调用下半部分；只有bh_mask 和 bh_active的对应位的与为1时，才必须执行下半部分(do_botoom_half)。因此，若是在上半部分中（也可能在其余地方）决定必须执行 对应的半部分，那么能够经过设置bh_active的对应位，来指明下半部分必须执行。固然，若是bh_active的对应位被置位，也不必定会立刻执行 下半部分，由于还必须具有另外两个条件：首先是bh_mask的相应位也必须被置位，另外，就是处理的时机，若是下半部分已经标记过须要执行了，如今又再 次标记，那么内核就简单地保持这个标记；当状况容许的时候，内核就对它进行处理。若是在内核有机会运行其下半部分以前给定的设备就已经发生了100次中 断，那么内核的上半部分就运行100次，下半部分运行1次。

　　bh_base数组的索引是静态定义的，定时器底半处理过程的地址保存在第 0 个元素中，控制台底半处理过程的地址保存在第 1 个元素中,等等。当 bh_mask 和 bh_active 代表第 N 个底半处理过程已被安装且处于活动状态，则调度程序会调用第 N 个底半处理过程，该底半处理过程最终会处理与之相关的任务队列中的各个任务。由于调度程序从第 0 个元素开始依次检查每一个底半处理过程，所以，第 0 个底半处理过程具备最高的优先级，第 31 个底半处理过程的优先级最低。

　　内核中的某些底半处理过程是和特定设备相关的，而其余一些则更通常一些。表二列出了内核中通用的底半处理过程。

表2、Linux 中通用的底半处理过程