Linux阻塞和非阻塞IO实验
阻塞和非阻塞IO是Linux驱动开发里面很常见的两种设备访问模式，在编写驱动的时候一定要考虑到阻塞和非阻塞。本章我们就来学习一下阻塞和非阻塞IO，以及如何在驱动程序中处理阻塞与非阻塞，如何在驱动程序使用等待队列和poll机制。
- D! E# P# a$ ~! P, n1 d
32.1 阻塞和非阻塞IO
8 K! u3 Y0 H3 Q2 b- `8 c, x" w32.1.1 阻塞和非阻塞简介
这里的“IO”并不是我们学习单片机的时候所说的“GPIO”(也就是引脚)。这里的IO指的是Input/Output，也就是输入/输出，是应用程序对驱动设备的输入/输出操作。当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式IO就会将应用程序对应的线程挂起，直到设备资源可以获取为止。对于非阻塞IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。阻塞式IO如图32.1.1.1所示：


( H1 c! c7 c. H9 O. b$ a
图32.1.1.1 阻塞IO访问示意图。
图32.1.1.1中应用程序调用read函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。非阻塞IO如图32.1.2所示：


: }7 a' {2 T$ F- B: [  s
图32.1.1.2 非阻塞IO访问示意图
+ D/ S, Y8 B/ \从图32.1.1.2可以看出，应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。
应用程序可以使用如下所示示例代码来实现阻塞访问：

0 C& t; _- |. B/ m2 z6 O8 ?

1. 示例代码32.1.1.1 应用程序阻塞读取数据
   
2. 1 int fd;
   . m5 h( V. v7 ~* o7 p
3. 2 int data = 0;
   1 T% Q: r0 e+ w% @  s+ z) d
4. 3
   1 }) @+ ^' H1 s
5. 4 fd = open("/dev/xxx_dev", O_RDWR);                  /* 阻塞方式打开         */
   
6. 5 ret = read(fd, &data, sizeof(data));          /* 读取数据                 */

复制代码

7 o) F% L. I$ ]' D2 ]4 i从示例代码32.1.1.1可以看出，对于设备驱动文件的默认读取方式就是阻塞式的，所以我们前面所有的例程测试APP都是采用阻塞IO。
如果应用程序要采用非阻塞的方式来访问驱动设备文件，可以使用如下所示代码：

1. 示例代码32.1.1.2 应用程序非阻塞读取数据
   
2. 1 int fd;
   
3. 2 int data = 0;
   
4. 3
     W7 K0 r3 n7 C# a# k3 A
5. 4 fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK);        /* 非阻塞方式打开 */
   
6. 5 ret = read(fd, &data, sizeof(data));                                  /* 读取数据 */

复制代码

以非阻塞方式打开设备，这样从设备中读取数据的时候就是非阻塞方式的了。
# n) a; D9 `) c% k7 Z0 q6 L
32.1.2 等待队列
3 C$ |; X7 T% |. o+ |& s- C( S1、等待队列头
" H) h& n) \' r6 Z阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU资源让出来。但是，当设备文件可以操作的时候就必须唤醒进程，一般在中断函数里面完成唤醒工作。Linux内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head表示，wait_queue_head结构体定义在文件include/linux/wait.h中，结构体内容如下所示：

1. 示例代码32.1.2.1 wait_queue_head结构体
   
2. 34 struct wait_queue_head {
   9 r' Q. G/ f6 e% p+ v
3. 35  spinlock_t                      lock;
   5 e! b( t% ^; Q1 x; Z
4. 36  struct list_head            head;
   
5. 37 };
   . v& s9 U* G+ C  }* D
6. 38 typedef struct wait_queue_head wait_queue_head_t;

复制代码

) K5 N/ [5 k9 w+ u# u$ |4 b7 g有些资料里面用wait_queue_head_t表示等待队列头，从38行可以看出，wait_queue_head_t是wait_queue_head的别名，这么做的目的是为了兼容老版本代码。最新版本的系统都用wait_queue_head表示等待队列头，如果你的代码要考虑移植到老版本linux内核中，那么最好使用wait_queue_head_t表示等待队列头。
# T* }1 B0 b) q定义好等待队列头以后需要初始化，使用init_waitqueue_head函数初始化等待队列头，函数原型如下：
, s* g4 x* J2 o$ U/ @: V' [- T# Kvoid init_waitqueue_head(struct wait_queue_head *wq_head)
参数wq_head就是要初始化的等待队列头。
也可以使用宏DECLARE_WAIT_QUEUE_HEAD来一次性完成等待队列头的定义的初始化。
2、等待队列项
( a: E/ s8 F. ?等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用的时候就要将这些进程对应的队列项添加到等待队列里面。在以前的linux版本中使用结构体wait_queue_t表示等待队列项，在5.4版本的linux内核中已经删除了wait_queue_t，取而代之的是wait_queue_entry结构体(其实只是换了个名字，结构体内的成员变量还是一样的)，wait_queue_entry结构体内容如下：

1. 示例代码32.1.2.2 wait_queue_entry结构体
   1 v5 d# f/ w" u! |, z2 i1 _" u$ ?% t
2. 27 struct wait_queue_entry {
   ; b( Y* _, w0 `  I0 _; [' f
3. 28  unsigned int                flags;
   " e, j5 K, J( E1 q
4. 29  void                            *private;
   2 x# M4 }. G# p- L0 d: K" N
5. 30  wait_queue_func_t           func;
   
6. 31  struct list_head            entry;
   
7. 32 };

复制代码

使用宏DECLARE_WAITQUEUE定义并初始化一个等待队列项，宏的内容如下：
DECLARE_WAITQUEUE(name, tsk)
" N, j& @( Q% N. kname就是等待队列项的名字，tsk表示这个等待队列项属于哪个任务(进程)，一般设置为current，在Linux内核中current相当于一个全局变量，表示当前进程。因此宏DECLARE_WAITQUEUE就是给当前正在运行的进程创建并初始化了一个等待队列项。
3、将队列项添加/移除等待队列头
2 E& U/ g& I2 e1 z0 P. Y/ j& C9 T当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。当设备可以访问以后再将进程对应的等待队列项从等待队列头中移除即可，等待队列项添加API函数如下：
. t9 [; [" C  U0 U2 r5 avoid add_wait_queue(struct wait_queue_head *wq_head,
$ H, d0 [3 x/ \; X9 U' N" Pstruct wait_queue_entry *wq_entry)
/ E# f, Y( `  w" o) g8 \函数参数和返回值含义如下：
wq_head：等待队列项要加入的等待队列头。
  o! d& B2 t4 d! c* v* v( Wwq_entry：要加入的等待队列项。
& o% ?  {: y$ e! b# ]返回值：无。
等待队列项移除API函数如下：
$ k! k6 X/ G9 y- R1 Avoid remove_wait_queue(struct wait_queue_head *wq_head,
2 @. x2 m/ Y+ o/ X6 bstruct wait_queue_entry *wq_entry)
4 X! d8 C- E/ E9 O7 U函数参数和返回值含义如下：
wq_head：要删除的等待队列项所处的等待队列头。
3 q; s& r1 W8 cwq_entry：要删除的等待队列项。
8 j8 m5 k4 f; I. _返回值：无。
4、等待唤醒
当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用如下两个函数：
! X8 @- L$ f! t7 n' {void wake_up(struct wait_queue_head *wq_head)
5 x& G* |; A8 z' X) Kvoid wake_up_interruptible(struct wait_queue_head *wq_head)
/ n& d9 \! _# o, v7 P参数wq_head就是要唤醒的等待队列头，这两个函数会将这个等待队列头中的所有进程都唤醒。wake_up函数可以唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE状态的进程，而wake_up_interruptible函数只能唤醒处于TASK_INTERRUPTIBLE状态的进程。
5、等待事件
+ w, A6 P1 u6 j除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程，和等待事件有关的API函数如表32.1.2.1所示：
" _8 I9 Z) n4 z$ _" A
) w8 y7 @  S+ b

32.1.3 轮询
7 h+ d& M+ z0 J/ C: F& e* F* b1 p如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll和select可以用于处理轮询，应用程序通过select、epoll或poll函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用select、epoll或poll函数的时候设备驱动程序中的poll函数就会执行，因此需要在设备驱动程序中编写poll函数。我们先来看一下应用程序中使用的select、poll和epoll这三个函数。
1、select函数
6 O" V# h* S2 X* \. `select函数原型如下：
, r' W7 e( _* c5 ~# nint select(int nfds,
( d$ c. O7 j: q+ U. r6 t3 o2 Z/ kfd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
+ |: c; i4 f5 Z! Istruct timeval *timeout)
函数参数和返回值含义如下：
& L, T* Y3 a( G4 M0 Ynfds：所要监视的这三类文件描述集合中，最大文件描述符加1。
readfds、writefds和exceptfds：这三个指针指向描述符集合，这三个参数指明了关心哪些描述符、需要满足哪些条件等等，这三个参数都是fd_set类型的，fd_set类型变量的每一个位都代表了一个文件描述符。readfds用于监视指定描述符集的读变化，也就是监视这些文件是否可以读取，只要这些集合里面有一个文件可以读取那么seclect就会返回一个大于0的值表示文件可以读取。如果没有文件可以读取，那么就会根据timeout参数来判断是否超时。可以将readfs设置为NULL，表示不关心任何文件的读变化。writefds和readfs类似，只是writefs用于监视这些文件是否可以进行写操作。exceptfds用于监视这些文件的异常。
! y8 m) ~0 D: R8 L2 R0 l比如我们现在要从一个设备文件中读取数据，那么就可以定义一个fd_set变量，这个变量要传递给参数readfds。当我们定义好一个fd_set变量以后可以使用如下所示几个宏进行操作：
2 E' [1 e$ U. f/ K3 Zvoid FD_ZERO(fd_set *set)
/ V. d) j' _4 D, W- h- @" fvoid FD_SET(int fd, fd_set *set)
void FD_CLR(int fd, fd_set *set)
( f0 r: ]+ m$ Y, S2 jint FD_ISSET(int fd, fd_set set)
8 }( W# o# J4 d* u1 z  YFD_ZERO用于将fd_set变量的所有位都清零，FD_SET用于将fd_set变量的某个位置1，也就是向fd_set添加一个文件描述符，参数fd就是要加入的文件描述符。FD_CLR用户将fd_set变量的某个位清零，也就是将一个文件描述符从fd_set中删除，参数fd就是要删除的文件描述符。FD_ISSET用于测试一个文件是否属于某个集合，参数fd就是要判断的文件描述符。
- F3 y6 ?0 w  Z+ F( k' Ktimeout:超时时间，当我们调用select函数等待某些文件描述符可以设置超时时间，超时时间使用结构体timeval表示，结构体定义如下所示：
struct timeval {
long tv_sec; / 秒 /
& D- e; W9 z) @7 {2 l' D( mlong tv_usec; / 微妙 */
2 k% }6 x/ i7 P% \};
当timeout为NULL的时候就表示无限期的等待。
返回值：0，表示的话就表示超时发生，但是没有任何文件描述符可以进行操作；-1，发生错误；其他值，可以进行操作的文件描述符个数。
使用select函数对某个设备驱动文件进行读非阻塞访问的操作示例如下所示：

& B7 u4 n, Z% _1 D! s0 u

1. 示例代码32.1.3.1 select函数非阻塞读访问示例
   
2. 1  void main(void)
   ) F0 `) I# e* h, Q
3. 2  {
   
4. 3           int ret, fd;                          /* 要监视的文件描述符                 */
   
5. 4           fd_set readfds;                     /* 读操作文件描述符集                 */
   
6. 5           struct timeval timeout;             /* 超时结构体                                 */
   
7. 6  
   ) `% e- w( v, c2 v; ^
8. 7           fd = open("dev_xxx", O_RDWR | O_NONBLOCK);         /* 非阻塞式访问 */
   + M2 E( Y# p* e
9. 8  
     v$ h8 I6 J- Z# C$ ^8 o3 M
10. 9           FD_ZERO(&readfds);                      /* 清除readfds                         */
    . U9 {, C9 G4 }3 M3 T
11. 10          FD_SET(fd, &readfds);                   /* 将fd添加到readfds里面 */
    " Q7 n3 ~6 J+ S% ?9 i
12. 11      
    
13. 12          /* 构造超时时间 */
    
14. 13          timeout.tv_sec = 0;
    
15. 14          timeout.tv_usec = 500000;         /* 500ms         */
    # Q2 k* B- F9 z1 J) f
16. 15      
    
17. 16          ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
    5 i! B  V/ v$ Y& j6 A& X; a! ]
18. 17          switch (ret) {
    6 J: i* @0 P& e3 u
19. 18              case 0:                                     /* 超时                 */
    
20. 19                         printf("timeout!\r\n");
    - ^2 v6 A# t! C2 R! I9 A9 Y
21. 20                          break;
    1 ~1 }  ]" d4 v$ v
22. 21              case -1:                                    /* 错误                 */
    
23. 22                          printf("error!\r\n");
    - V' u/ I. A; R( V2 q. p  p
24. 23                          break;
    # x" E# m* M4 u* S+ j7 h5 t6 F/ U
25. 24              default:            /* 可以读取数据 */
    + t$ h, X2 l+ H
26. 25                          if(FD_ISSET(fd, &readfds)) { /* 判断是否为fd文件描述符 */
    
27. 26                              /* 使用read函数读取数据 */
    
28. 27                          }
    
29. 28                          break;
    
30. 29          }   
    & J7 H: {' {9 ]5 S
31. 30 }

复制代码

- y( C% s! s: F- Z: n0 U, ~2、poll函数
在单个线程中，select函数能够监视的文件描述符数量有最大的限制，一般为1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率！这个时候就可以使用poll函数，poll函数本质上和select没有太大的差别，但是poll函数没有最大文件描述符限制，Linux应用程序中poll函数原型如下所示：
int poll(struct pollfd *fds,
nfds_t nfds,
6 ^( ^# j  L+ |4 w0 O3 f! `" cint timeout)
  I( M; m4 H; C函数参数和返回值含义如下：
fds：要监视的文件描述符集合以及要监视的事件,为一个数组，数组元素都是结构体pollfd类型的，pollfd结构体如下所示：
& ~9 }2 u+ B3 `$ }/ }, H

1. struct pollfd {
   # J/ R/ ]# c7 D' f2 t
2.         int   fd;             /* 文件描述符         */
   0 f* b4 `1 n, M3 c2 T; w2 Z( w
3.         short events;           /* 请求的事件         */
   ! H5 [9 c" {+ T" r( ?
4.           short revents;            /* 返回的事件         */
   
5. };

复制代码

; n  A0 l1 o/ I8 V% ffd是要监视的文件描述符，如果fd无效的话那么events监视事件也就无效，并且revents返回0。events是要监视的事件，可监视的事件类型如下所示：

: h3 I4 n! E4 ]+ k$ I- QPOLLIN 有数据可以读取。
. k7 [9 ^2 {9 P% y( y6 ~) cPOLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
POLLERR 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起。
POLLNVAL 无效的请求。
POLLRDNORM 等同于POLLIN
revents是返回参数，也就是返回的事件，由Linux内核设置具体的返回事件。
nfds：poll函数要监视的文件描述符数量。
; }) e5 Q, s: Itimeout：超时时间，单位为ms。
, [7 A+ e1 R8 V0 P返回值：返回revents域中不为0的pollfd结构体个数，也就是发生事件或错误的文件描述符数量；0，超时；-1，发生错误，并且设置errno为错误类型。
使用poll函数对某个设备驱动文件进行读非阻塞访问的操作示例如下所示：

' ^6 B* {( D1 y

1. 示例代码32.1.3.2 poll函数读非阻塞访问示例
   0 b1 Z1 d2 T% l/ m  _- x3 n
2. 1  void main(void)
   , Y+ y' f7 Y4 e# }8 T0 ]0 {' q
3. 2  {
   2 j; p( r! ^1 K( F
4. 3           int ret;         
   % D" ?% |/ ?: n
5. 4           int fd;                             /* 要监视的文件描述符      */
   / G) w0 l# D/ P5 X
6. 5           struct pollfd fds;  
   
7. 6   
   
8. 7           fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
   ' E6 d$ y+ Z# A( u( ^
9. 8   
   
10. 9           /* 构造结构体         */
    2 P! Q$ h: c" }& f  m. O: K- a
11. 10                  fds.fd = fd;
    5 G9 C* g) j9 `
12. 11          fds.events = POLLIN;    /* 监视数据是否可以读取 */
    ( l' g$ p* ?5 ^1 h) {
13. 12  
    ; O+ d: i6 {4 Y2 A
14. 13          ret = poll(&fds, 1, 500);         /* 轮询文件是否可操作，超时500ms */
    
15. 14          if (ret) {                              /* 数据有效                 */
    , ]2 _/ @: I8 _
16. 15              ......
    
17. 16              /* 读取数据 */
    ( ]/ K( i5 z0 E% T: l. S( b: n
18. 17              ......
    
19. 18          } else if (ret == 0) {                  /* 超时                   */
    
20. 19              ......
    
21. 20          } else if (ret < 0) {                   /* 错误                   */
    3 B+ K$ P8 a$ F3 ^; ^' P& ?4 o! B& g
22. 21              ......
    % W1 P4 ^" ^' ~4 {
23. 22          }
    
24. 23 }

复制代码

3、epoll函数
/ P9 Z7 L0 X; d, j传统的selcet和poll函数都会随着所监听的fd数量的增加，出现效率低下的问题，而且poll函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。为此，epoll应运而生，epoll就是为处理大并发而准备的，一般常常在网络编程中使用epoll函数。应用程序需要先使用epoll_create函数创建一个epoll句柄，epoll_create函数原型如下：
int epoll_create(int size)
  v+ @$ e# x2 D  Y0 @函数参数和返回值含义如下：
" `  a+ U) D5 U5 v& t4 hsize：从Linux2.6.8开始此参数已经没有意义了，随便填写一个大于0的值就可以。
返回值：epoll句柄，如果为-1的话表示创建失败。
epoll句柄创建成功以后使用epoll_ctl函数向其中添加要监视的文件描述符以及监视的事件，epoll_ctl函数原型如下所示：
( e; v- w  H2 a: J& m
8 a5 y6 X6 \7 N. H" g

1. int epoll_ctl(int                                 epfd,
   
2.                   int                                 op,
   & I% K8 v7 X- h
3.                   int                                fd,
   
4.                    struct epoll_event         *event)

复制代码

* a% C+ q. S& _* X函数参数和返回值含义如下：
epfd：要操作的epoll句柄，也就是使用epoll_create函数创建的epoll句柄。
op：表示要对epfd(epoll句柄)进行的操作，可以设置为：
EPOLL_CTL_ADD 向epfd添加文件参数fd表示的描述符。
EPOLL_CTL_MOD 修改参数fd的event事件。
EPOLL_CTL_DEL 从epfd中删除fd描述符。
fd：要监视的文件描述符。
event：要监视的事件类型，为epoll_event结构体类型指针，epoll_event结构体类型如下所示：

1. struct epoll_event {
   
2.         uint32_t     events;            /* epoll事件                 */
   
3.         epoll_data_t         data;                /* 用户数据                 */
   0 v" J7 e1 k3 _! r" ]
4. };

复制代码

结构体epoll_event的events成员变量表示要监视的事件，可选的事件如下所示：

8 a8 K/ V4 [/ O: GEPOLLIN 有数据可以读取。
EPOLLOUT 可以写数据。
EPOLLPRI 有紧急的数据需要读取。
  ?! w& a6 x* n4 k3 B' TEPOLLERR 指定的文件描述符发生错误。
EPOLLHUP 指定的文件描述符挂起。
( c" j! Q, G. J4 l! z7 _. PEPOLLET 设置epoll为边沿触发，默认触发模式为水平触发。
2 Z& {- u6 C$ L* ^! KEPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个fd，那么就需要将fd重新添加到epoll里面。
# K3 }' h( _- n& ~) b- r/ \. ~上面这些事件可以进行“或”操作，也就是说可以设置监视多个事件。
返回值：0，成功；-1，失败，并且设置errno的值为相应的错误码。
一切都设置好以后应用程序就可以通过epoll_wait函数来等待事件的发生，类似select函数。epoll_wait函数原型如下所示：
. [# [9 f5 I, ]3 l7 D. m
/ u" ]+ q. Q) ?" H  }% a- s  J

1. int epoll_wait(int                                 epfd,
   
2.                         struct epoll_event         *events,
   
3.                         int                                 maxevents,
   
4.                         int                                 timeout)

复制代码

; P' x" e. f  c# A7 {1 l函数参数和返回值含义如下：
: b+ Q* L+ c2 \+ B0 G: j! X/ Hepfd：要等待的epoll。
5 {; [& _8 _9 Y7 K# bevents：指向epoll_event结构体的数组，当有事件发生的时候Linux内核会填写events，调用者可以根据events判断发生了哪些事件。
7 t6 L0 E6 O% hmaxevents：events数组大小，必须大于0。
timeout：超时时间，单位为ms。
! ]! y' R4 A" h8 F6 p4 _0 d- ^返回值：0，超时；-1，错误；其他值，准备就绪的文件描述符数量。
epoll更多的是用在大规模的并发服务器上，因为在这种场合下select和poll并不适合。当设计到的文件描述符(fd)比较少的时候就适合用selcet和poll，本章我们就使用sellect和poll这两个函数。
- ^5 W! q, {. J  E! ?: l32.1.4 Linux驱动下的poll操作函数
5 ]; @0 V0 g6 Y/ A( ~7 Y% O当应用程序调用select或poll函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations操作集中的poll函数就会执行。所以驱动程序的编写者需要提供对应的poll函数，poll函数原型如下所示：
unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)
% ~- |" `5 V% _4 n" s5 K0 ~3 U+ `函数参数和返回值含义如下：
- i1 n  o* ]9 Ffilp：要打开的设备文件(文件描述符)。
wait：结构体poll_table_struct类型指针，由应用程序传递进来的。一般将此参数传递给poll_wait函数。
返回值:向应用程序返回设备或者资源状态，可以返回的资源状态如下：
: n: k" {; u# E& P& R7 r3 k; \. u* NPOLLIN 有数据可以读取。
POLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
/ q$ |6 }$ T! b6 JPOLLERR 指定的文件描述符发生错误。
( ^. d% S; F5 Z* y+ S' zPOLLHUP 指定的文件描述符挂起。
, ~2 w* V( t" {# j/ w, fPOLLNVAL 无效的请求。
POLLRDNORM 等同于POLLIN，普通数据可读
+ C& }9 L0 o8 s我们需要在驱动程序的poll函数中调用poll_wait函数，poll_wait函数不会引起阻塞，只是将应用程序添加到poll_table中，poll_wait函数原型如下：
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
0 `3 q4 A4 ]" Z$ O参数wait_address是要添加到poll_table中的等待队列头，参数p就是poll_table，就是file_operations中poll函数的wait参数。
32.2 阻塞IO实验
( f; ]& R4 S; L- c- J在上一章Linux中断实验中，我们直接在应用程序中通过read函数不断的读取按键状态，当按键有效的时候就打印出按键值。这种方法有个缺点，那就是keyirqApp这个测试应用程序拥有很高的CPU占用率，大家可以在开发板中加载上一章的驱动程序模块keyirq.ko，然后以后台运行模式打开keyirqApp这个测试软件，命令如下：
./keyirqApp /dev/keyirq &
9 j! L2 E9 B! A1 h: B测试驱动是否正常工作，如果驱动工作正常的话输入“top”命令查看keyirqApp这个应用程序的CPU使用率，结果如图32.2.1所示：
. c' t' K) I% i9 T& _! x

! M2 l' t: r- u" X' m# _: l
图32.2.1 CPU使用率
! A/ J1 [/ @/ C0 k* H. K从图32.2.1可以看出，keyirqApp这个应用程序的CPU使用率竟然高达50%，这仅仅是一个读取按键值的应用程序，这么高的CPU使用率显然是有问题的！原因就在于我们是直接在while循环中通过read函数读取按键值，因此keyirqApp这个软件会一直运行，一直读取按键值，CPU使用率肯定就会很高。最好的方法就是在没有有效的按键事件发生的时候，keyirqApp这个应用程序应该处于休眠状态，当有按键事件发生以后keyirqApp这个应用程序才运行，打印出按键值，这样就会降低CPU使用率，本小节我们就使用阻塞IO来实现此能。
32.2.1 硬件原理图分析
% x* B+ R+ q+ _' E本章实验硬件原理图参考29.2小节即可。
. }, R5 a3 ]( [2 |2 g32.2.2 实验程序编写
7 t" `2 r7 i% w3 Z# Q" y) S1、驱动程序编写
7 E5 w$ ^9 u7 Z% O本实验对应的例程路径为：开发板光盘-> 2、Linux驱动例程-> 14_blockio。
( J, H* W3 h  {4 @本章实验我们在上一章的“13_irq”实验的基础上完成，主要是对其添加阻塞访问相关的代码。新建名为“14_blockio”的文件夹，然后在14_blockio文件夹里面创建vscode工程，工作区命名为“blockio”。将“13_irq”实验中的keyirq.c复制到14_blockio文件夹中，并重命名为blockio.c。接下来我们就修改blockio.c这个文件，在其中添加阻塞相关的代码，完成以后的blockio.c内容如下所示(因为是在上一章实验的keyirq.c文件的基础上修改的，为了减少篇幅，下面的代码有省略)：

0 i5 y7 ?/ Z! E8 ]" }

1. 示例代码 32.2.2.1 blockio.c 文件代码(有省略)
   5 W. m& x5 N" E
2. 41  /* key设备结构体 */
   
3. 42  struct key_dev{
   
4. 43      dev_t devid;                            /* 设备号                                     */
   
5. 44      struct cdev cdev;                       /* cdev                                     */
   
6. 45      struct class *class;                    /* 类                                              */
   5 {; M0 L# ^9 u) g
7. 46      struct device *device;                  /* 设备                                            */
   / k3 q/ U) S, ?4 a% W  `$ j
8. 47      struct device_node  *nd;         /* 设备节点                                         */
   
9. 48      int key_gpio;                           /* key所使用的GPIO编号        */
   $ n( N  Z3 F. T8 ?+ ~
10. 49      struct timer_list timer;           /* 按键值                                */
    7 \* S" S# H: X1 _" M* \0 R
11. 50      int irq_num;                            /* 中断号                                */
    
12. 51      
    0 H! a, ?4 |& L, X3 \) k1 m
13. 52      atomic_t status;                        /* 按键状态                                         */
    
14. 53      wait_queue_head_t r_wait;           /* 读等待队列头                                 */
    . T1 W. C; a# Y( b# V, U- N
15. 54  };
    
16. ......
    ! r/ M' R3 M) ~; n6 G
17. 150 static void key_timer_function(struct timer_list *arg)
    
18. 151 {
    
19. 152     static int last_val = 1;
    
20. 153     int current_val;
    
21. 154
    4 d+ C/ V. h# m; ?/ ^
22. 155     /* 读取按键值并判断按键当前状态 */
    , A+ z' T( L6 R
23. 156     current_val = gpio_get_value(key.key_gpio);
    ! E  b. |* H  @! _9 n& ]2 b  n0 Z7 b' n+ \
24. 157     if (0 == current_val && last_val){
    
25. 158         atomic_set(&key.status, KEY_PRESS);         /* 按下         */
    & L* l) Z- N, w2 ~! [5 C
26. 159         wake_up_interruptible(&key.r_wait);         /* 唤醒         */
    
27. 160     }
    2 d, [) U9 W* F4 w
28. 161     else if (1 == current_val && !last_val) {
    
29. 162         atomic_set(&key.status, KEY_RELEASE);        /* 松开         */
    
30. 163         wake_up_interruptible(&key.r_wait);         /* 唤醒         */
    ' y; [6 F8 x  h& K
31. 164     }
    4 j$ J. h& I( h6 b5 `
32. 165     else
    , j/ J6 G, A2 `! i! T' C. [
33. 166         atomic_set(&key.status, KEY_KEEP);            /* 状态保持 */
    - x* p& Q- z3 [5 g; x5 y* s, e
34. 167
    6 T" h1 G! {5 T  s! _
35. 168     last_val = current_val;
    
36. 169 }
    5 q" ?8 {5 F0 T7 O4 [" x) X8 `5 \  E' [
37. 
    
38. 183 /*
    
39. 184  * @description          : 从设备读取数据
    
40. 185  * @param – filp         : 要打开的设备文件(文件描述符)
    
41. 186  * @param – buf          : 返回给用户空间的数据缓冲区
    * s# O9 w; G7 q9 X3 j
42. 187  * @param – cnt          : 要读取的数据长度
    
43. 188  * @param – offt        : 相对于文件首地址的偏移
    
44. 189  * @return                : 读取的字节数，如果为负值，表示读取失败
    
45. 190  */
    
46. 191 static ssize_t key_read(struct file *filp, char __user *buf,
    
47. 192             size_t cnt, loff_t *offt)
    
48. 193 {
    
49. 194     int ret;
    
50. 195
    ! r2 \" c) H; I+ L+ U! S: u
51. 196     /* 加入等待队列，当有按键按下或松开动作发生时，才会被唤醒 */
    7 E, W( p( `, X$ ~$ M2 k
52. 197     ret = wait_event_interruptible(key.r_wait, KEY_KEEP !=
    , P# O8 t/ o; E8 O' m+ Z
53. atomic_read(&key.status));
    
54. 198     if(ret)
    $ x6 _! m( i& D* a( L3 ?% d( N
55. 199         return ret;
    : a+ O# V' m+ e! @: R
56. 200         
    
57. 201     /* 将按键状态信息发送给应用程序 */
    5 E3 R; U7 J. X6 N
58. 202     ret = copy_to_user(buf, &key.status, sizeof(int));
    / a+ G" n5 k7 O5 x! W
59. 203     
    
60. 204     /* 状态重置                                         */
    1 X$ K1 E5 M' Z
61. 205     atomic_set(&key.status, KEY_KEEP);
    & z3 W% t) \& Y" w" H
62. 206
    7 q' T  @$ s' g- U( s$ C3 d; x
63. 207     return ret;
    
64. 208 }
    
65. ......
    4 Q1 {1 v/ {, B# P! Q
66. 242 /*
    
67. 243  * @description         : 驱动入口函数
    + u" X0 l; W0 v0 q
68. 244  * @param               : 无
    
69. 245  * @return              : 无
    
70. 246  */
    
71. 247 static int __init mykey_init(void)
    
72. 248 {
    
73. 249     int ret;
    
74. 250     
    
75. 251     /* 初始化等待队列头 */
    
76. 252     init_waitqueue_head(&key.r_wait);
    
77. 253     
    : e1 p# t% p" l4 p
78. 254     /* 初始化按键状态 */
      X7 V0 f) \  i2 j; d1 Y
79. 255     atomic_set(&key.status, KEY_KEEP);
    ' b! _- Y- |* s3 l
80. ......
    
81. 311 }
    
82. ......

复制代码

第42~54行，我们删除了设备结构体struct key_dev中的自旋锁变量，本章驱动代码我们不用自旋锁，而改成第52行的原子变量来实现对相应变量的保护操作。第53行添加了一个等待队列头r_wait，因为在Linux驱动中处理阻塞IO需要用到等待队列，而等待队列会使进程进入休眠状态，所以不能使用自旋锁！
. j" F6 a! s3 Y/ X; W8 f# O# a1 M# V第150~169行，定时器定时处理函数key_timer_function，对按键状态进行判断，如果是按下动作或是松开动作则会使用wake_up_interruptible函数唤醒等待队列，并且将status变量设置为KEY_PRESS或KEY_RELEASE；这样在key_read函数中阻塞的进程就会解除阻塞继续进行下面的操作。
第191~208行，key_read函数，在这个函数中我们会判断按键是否有按下或松开动作发生时，如果没有则调用wait_event_interruptible把它加入等待队列当中，进行阻塞。如果等待队列被唤醒并且条件“KEY_KEEP != atomic_read(&status)”成立，则解除阻塞，继续下面的操作，也就是读取按键状态数据将其发送给应用程序。因为采用了wait_event_interruptible函数，因此进入休眠态的进程可以被信号打断。在该函数中我们读取status原子变量必须要使用atomic_read函数进行操作。
第252行，在驱动入口函数中我们会调用init_waitqueue_head初始化等待队列头；第255行使用原子操作atomic_set设置按键的初始状态status为KEY_KEEP。
使用等待队列实现阻塞访问重点注意两点：
①、将任务或者进程加入到等待队列头，
②、在合适的点唤醒等待队列，一般是中断处理函数里面。
9 Y3 v  q; S9 L6 i( |' I! D2、编写测试APP
& d+ I7 n; l9 K本节实验的测试APP直接使用13_irq实验目录下的keyirqApp.c测试程序，将keyirqApp.c复制到本实验目录14_blockio中，不需要修改任何内容。
32.2.3 运行测试
/ z, S, u) t8 `( M1、编译驱动程序和测试APP
5 u) h) k/ ~6 m' p3 e5 k①、编译驱动程序
3 \3 w0 O9 ^( [9 b7 S6 @! v' d/ _编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为blockio.o，Makefile内容如下所示：
; H4 `! W% t: C( a1 M8 L- v& T- V5 m
9 y& v. E! H+ E* ^

1. 示例代码52.2.3.1 Makefile文件
   
2. 1  KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31
   
3. ......
   6 e: H, @& T6 P& P+ p2 d
4. 4  obj-m := blockio.o
   - U0 n; F* H% X' y8 ^! v
5. ......
   
6. 11 clean:
   
7. 12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

第4行，设置obj-m变量的值为blockio.o。
输入如下命令编译出驱动模块文件：
make -j32
8 }( s# p, ^, e编译成功以后就会生成一个名为“blockio.ko”的驱动模块文件。
②、编译测试APP
5 Q# t) I0 Z9 X2 G输入如下命令编译测试blockioApp.c这个测试程序：
0 F) d! R3 Q8 ~/ o9 U- \arm-none-linux-gnueabihf-gcc blockioApp.c -o blockioApp
编译成功以后就会生成blcokioApp这个应用程序。
1 Z1 P+ ^  _/ g& V' W: ]# _! \$ x2、运行测试
9 A+ n0 k% w1 S# j) _/ ?/ Z将上一小节编译出来blockio.ko和blockioApp这两个文件拷贝到rootfs/lib/modules/5.4.31目录中，重启开发板，进入到目录lib/modules/5.4.31中，输入如下命令加载blockio.ko驱动模块：
' w  v1 i7 n4 T8 T; Cdepmod //第一次加载驱动的时候需要运行此命令
modprobe blockio.ko //加载驱动
; P3 Y2 Z! C: D, i- o0 _驱动加载成功以后使用如下命令打开blockioApp这个测试APP，并且以后台模式运行：
./blockioApp /dev/key &
按下开发板上的KEY0按键，结果如图32.2.3.1所示：



$ O5 F" }- K7 P# {) z图32.2.3.1 测试APP运行测试
( ~0 a5 R4 |7 O. x当按下KEY0按键以后blockioApp这个测试APP就会打印出按键状态。输入“top”命令，查看blockioAPP这个应用APP的CPU使用率，如图32.2.3.2所示：
6 a. U: G8 ^$ I0 V


& M# E- L& O9 M! E7 R3 D0 y# [图32.2.3.2 应用程序CPU使用率
) a0 j/ s- g: o4 {1 w, ^$ C从图32.2.3.2可以看出，当我们在按键驱动程序里面加入阻塞访问以后，blockioApp这个应用程序的CPU使用率从图32.2.1中的48%降低到了0%。大家注意，这里的0%并不是说blockioApp这个应用程序不使用CPU了，只是因为使用率太小了，CPU使用率可能为0.00001%，但是图32.2.3.2是没有小数点显示的，因此就显示成了0%。
: d; q. B0 q! m9 k我们可以使用“kill”命令关闭后台运行的应用程序，比如我们关闭掉blockioApp这个后台运行的应用程序。首先输出“Ctrl+C”关闭top命令界面，进入到命令行模式。然后使用“ps”命令查看一下blockioApp这个应用程序的PID，如图32.2.3.3所示：
4 T& `. c+ V7 ^5 g* n
3 H$ x- ^3 F) D  r) S7 O5 m
9 J) y- U. ?; w* u1 \$ F+ b+ v
图32.2.3.3 当前系统所有进程的ID
0 `4 J7 }* v3 w4 @' J( C从图图32.2.3.3可以看出，blockioApp这个应用程序的PID为338，使用“kill -9 PID”即可“杀死”指定PID的进程，比如我们现在要“杀死”PID为338的blockioApp应用程序，可是使用如下命令：
kill -9 338
/ c' d; k/ `) q# K6 l输入上述命令以后终端显示如图32.2.3.4所示：
( a) C6 F% z  }2 f5 y


图32.2.3.4 kill命令输出结果
" u( C3 h  X& k2 I6 w; B( P" \从图32.2.3.4可以看出，“./blockioApp /dev/key”这个应用程序已经被“杀掉”了，在此输入“ps”命令查看当前系统运行的进程，会发现blockioApp已经不见了。这个就是使用kill命令“杀掉”指定进程的方法。

32.3 非阻塞IO实验
; _7 D! b$ C( h; U2 L32.3.1 硬件原理图分析
7 @1 a' d1 k/ N: `, z/ h! i# O本章实验硬件原理图参考29.2小节即可。
* a  z) Q  C8 L9 l# C2 L32.3.2 实验程序编写
1、驱动程序编写
本实验对应的例程路径为：开发板光盘1、程序源码2、Linux驱动例程15_noblockio。
本章实验我们在32.2小节中的“14_blockio”实验的基础上完成，上一小节实验我们已经在驱动中添加了阻塞IO的代码，本小节我们继续完善驱动，加入非阻塞IO驱动代码。新建名为“15_noblockio”的文件夹，然后在15_noblockio文件夹里面创建vscode工程，工作区命名为“noblockio”。将“14_blockio”实验中的blockio.c复制到15_noblockio文件夹中，并重命名为noblockio.c。接下来我们就修改noblockio.c这个文件，在其中添加非阻塞相关的代码，完成以后的noblockio.c内容如下所示(因为是在上一小节实验的blockio.c文件的基础上修改的，为了减少篇幅，下面的代码有省略)：

1. 示例代码52.3.3.1 noblockio.c文件(有省略)
   . ^/ H! g1 L4 N8 |3 N* [4 h! L& y$ f
2. ......
   
3. 27  #include <linux/wait.h>
   0 W) M. i! C5 [0 {3 z
4. 28  #include <linux/poll.h>
   
5. 29  #include <asm/mach/map.h>
   
6. 30  #include <asm/uaccess.h>
   9 h8 V* b2 V- Q" `. H
7. 31  #include <asm/io.h>
   
8. 32
   
9. ......
   : Z4 k% ^% s( m8 w% k% ]
10. 185 /*
    
11. 186  * @description          : 从设备读取数据
    
12. 187  * @param – filp        : 要打开的设备文件(文件描述符)
    
13. 188  * @param – buf          : 返回给用户空间的数据缓冲区
    
14. 189  * @param – cnt          : 要读取的数据长度
    
15. 190  * @param – offt         : 相对于文件首地址的偏移
    3 |  A7 B$ {, `
16. 191  * @return                : 读取的字节数，如果为负值，表示读取失败
    
17. 192  */
    6 G& m/ s0 a. c3 x" `
18. 193 static ssize_t key_read(struct file *filp, char __user *buf,
    
19. 194                            size_t cnt, loff_t *offt)
    3 {! F1 t% v! Z2 R
20. 195 {
    4 e2 ]8 K* k" O# S8 v% R# E; T
21. 196     int ret;
    
22. 197     
    ; C3 y0 q2 a) i0 J4 C* ~8 L7 B
23. 198     if (filp->f_flags & O_NONBLOCK) {   /* 非阻塞方式访问 */
    - W3 C. I6 B5 u) r6 ?1 X( n
24. 199         if(KEY_KEEP == atomic_read(&key.status))
    
25. 200             return -EAGAIN;
    ) v" s0 W: Z0 U- q
26. 201     } else {                                    /* 阻塞方式访问 */
    / O$ H9 W% W; p( Z3 o$ C9 E3 ]. Z  {
27. 202     /* 加入等待队列，当有按键按下或松开动作发生时，才会被唤醒 */
    % T+ b7 ?7 Y  K+ M3 y, p
28. 203     ret = wait_event_interruptible(key.r_wait, KEY_KEEP !=
    
29. atomic_read(&key.status));
    8 p. ^% H3 q# I' L
30. 204     if(ret)
    
31. 205         return ret;
    
32. 206     }
    7 v+ g2 q) f/ A5 l6 X
33. 207     /* 将按键状态信息发送给应用程序         */
    ( e9 k3 `- K  \' d$ J5 N
34. 208     ret = copy_to_user(buf, &key.status, sizeof(int));
    
35. 209
    
36. 210     /* 状态重置                                         */
    
37. 211     atomic_set(&key.status, KEY_KEEP);
    1 E* o7 ~, h0 h: i  \; W( E2 M
38. 212
    
39. 213     return ret;
    7 N, C# j1 L- j" a& C
40. 214 }
    
41. ......
    
42. 239 /*
    % |2 _) `8 |4 Y4 b" y+ `8 R
43. 240  * @description         : poll函数，用于处理非阻塞访问
    
44. 241  * @param - filp         : 要打开的设备文件(文件描述符)
    4 p: W/ i, M% o% G; T
45. 242  * @param - wait         : 等待列表(poll_table)
    ; k0 J) [/ c# @
46. 243  * @return               : 设备或者资源状态，
    , h. T$ K) Y  Z( c8 N3 k- x
47. 244  */
    
48. 245 static unsigned int key_poll(struct file *filp,
    , R. t& O, I1 f# u
49.                 struct poll_table_struct *wait)
    
50. 246 {
    ' w; D. V& h- Y7 w
51. 247     unsigned int mask = 0;
    * l+ o  P. {: N7 O  g5 L$ F" u
52. 248
    " {+ G9 j/ l! N6 p+ T' S+ S
53. 249     poll_wait(filp, &key.r_wait, wait);
    
54. 250
    ; E* y5 T# a4 G3 Q( y1 C, u
55. 251     if(KEY_KEEP != atomic_read(&key.status))/* 按键按下或松开动作发生 */
    
56. 252         mask = POLLIN | POLLRDNORM;                                 /* 返回PLLIN */
    , N6 i! m6 Y5 V( ?: H1 u2 c) [
57. 253
    
58. 254     return mask;
    
59. 255 }
    # O2 z2 @+ o+ i9 Q
60. 256
    6 W6 d. K; p/ u2 W
61. 257 /* 设备操作函数 */
    " ^+ B4 {; ~0 G% h1 O/ Z
62. 258 static struct file_operations key_fops = {
    
63. 259     .owner = THIS_MODULE,
    : Y8 A) T6 B7 B% p6 S
64. 260     .open = key_open,
    
65. 261     .read = key_read,
    
66. 262     .write = key_write,
    6 g. Y- x6 E/ z) _3 R5 Z2 B8 ?
67. 263     .release =  key_release,
    
68. 264     .poll = key_poll,
    
69. 265 };
    2 _; X/ U  U; B2 Q: R) ?
70. ......

复制代码

第28行，使用include将内核源码目录include/linux/poll.h头文件包含进来。
8 @% ?0 N: T3 I. A第193~214行，key_read函数中判断是否为非阻塞式读取访问，如果是的话就判断按键状态是否有效，也就是判断是否产生了按下或松开这样的动作，如果没有的话就返回-EAGAIN。
, l+ t6 Z5 [; @& R第245255行，key_poll函数就是file_operations驱动操作集中的poll函数，当应用程序调用select或者poll函数的时候key_poll函数就会执行。第249行调用poll_wait函数将等待队列头添加到poll_table中，第251252行判断按键是否有效，如果按键有效的话就向应用程序返回POLLIN这个事件，表示有数据可以读取。
+ I6 M) O+ k# {  ]3 T第264行，设置file_operations的poll成员变量为key_poll。
4 ]+ P  ^" Z0 W; m* \, t- `2、编写测试APP
7 W0 M. T8 h2 {2 ^1 n新建名为noblockioApp.c测试APP文件，然后在其中输入如下所示内容：

1. 示例代码32.3.3.2 noblockioApp.c文件代码
   3 b' z: J$ w# {6 Y
2. 12  #include <stdio.h>
   
3. 13  #include <unistd.h>
   
4. 14  #include <sys/types.h>
   ' I5 [6 M' ?; ]+ p
5. 15  #include <sys/stat.h>
   $ j9 x4 X: J. m: l
6. 16  #include <fcntl.h>
   - g5 ?' I& u% H( ^4 p
7. 17  #include <stdlib.h>
   ( T0 p! ?9 j0 l/ i! m8 ~' Z
8. 18  #include <string.h>
   2 r; e6 c- x: Z. {3 P6 E. Y5 O
9. 19  #include <poll.h>
   
10. 20
    
11. 21  /*
    
12. 22   * @description         : main主程序
    
13. 23   * @param – argc         : argv数组元素个数
    * F$ H* {  M  w; e3 w. o. P2 V  ]
14. 24   * @param – argv         : 具体参数
    $ U% D' G& h9 {& O- _+ w5 ]
15. 25   * @return              : 0 成功;其他 失败
    ( b4 S) c0 B) u
16. 26   */
    
17. 27  int main(int argc, char *argv[])
    
18. 28  {
    
19. 29      fd_set readfds;
    1 V# O: g2 D4 w' W! _+ l6 [; g* t
20. 30      int key_val;
    
21. 31      int fd;
    # R  ~& D2 d( @  b* ~( ~
22. 32      int ret;
    
23. 33
    ( \  \3 ?( ]& I# e
24. 34      /* 判断传参个数是否正确 */
    
25. 35      if(2 != argc) {
    
26. 36          printf("Usage:\n"
    . ^7 |5 X& f& M4 Q* Q0 a
27. 37                 "\t./keyApp /dev/key\n"
    1 @/ ^6 m* ?8 N$ X. }& C, \0 b
28. 38                );
    ' Z; o. j* Q# o- C% ?+ P
29. 39          return -1;
    
30. 40      }
    3 U  g0 p. W* Q5 h" f% e
31. 41
    
32. 42      /* 打开设备 */
    * r1 J: h4 f! A- p# t2 j
33. 43      fd = open(argv[1], O_RDONLY | O_NONBLOCK);
    7 s7 Q4 I4 c2 F
34. 44      if(0 > fd) {
    , w" @& i. A( r4 S. \
35. 45          printf("ERROR: %s file open failed!\n", argv[1]);
    1 h" d3 G9 D/ j6 I3 q3 H
36. 46          return -1;
    
37. 47      }
    
38. 48
    
39. 49      FD_ZERO(&readfds);
    1 k0 o5 g( P8 G! X
40. 50      FD_SET(fd, &readfds);
    
41. 51
    
42. 52      /* 循环轮训读取按键数据 */
    
43. 53      for ( ; ; ) {
    
44. 54
    8 s7 z% L; V; q- e; l" }7 M
45. 55          ret = select(fd + 1, &readfds, NULL, NULL, NULL);
    * T, O1 Z2 o. s
46. 56          switch (ret) {
    6 _: S8 y- \2 s
47. 57
    ( B: |: l, U! g& h7 i$ G
48. 58          case 0:     /* 超时 */
    3 ~! d+ ]- G  n4 S; u
49. 59              /* 用户自定义超时处理 */
    
50. 60              break;
    
51. 61
    . n) ?0 T! t: ^$ @
52. 62          case -1:         /* 错误 */
    
53. 63              /* 用户自定义错误处理 */
    
54. 64              break;
    3 O6 w1 V' e6 e6 v5 r% `  ^5 a
55. 65
    
56. 66          default:
    + h8 ?- i& x! @( a- s4 w
57. 67              if(FD_ISSET(fd, &readfds)) {
    2 B: D/ R4 I1 Y/ d
58. 68                  read(fd, &key_val, sizeof(int));
    + ]9 X# h* _3 ?8 M8 W; H# K
59. 69                  if (0 == key_val)
    
60. 70                      printf("Key Press\n");
    
61. 71                  else if (1 == key_val)
    2 D( c: R6 `* t' \# f
62. 72                      printf("Key Release\n");
    4 S0 D5 f9 _: b7 d, n; j" G0 b
63. 73              }
    
64. 74
    
65. 75              break;
    
66. 76          }
    4 P4 G2 V* |. H7 Z9 V# q. V& q
67. 77      }
    
68. 78
    4 h7 |7 ]6 a' `9 \7 {: [* }
69. 79      /* 关闭设备 */
    7 C! I# ?: f% @5 C; y5 K7 I
70. 80      close(fd);
    7 [* m* m' L4 `7 w7 z- b
71. 81      return 0;
    . ^) J& D; h+ L5 I2 D. V" L
72. 82  }

复制代码

* n7 N; }+ q* h" c: q第53~77行，在本测试程序中我们使用select函数来实现非阻塞访问，在for循环中使用select函数不断的轮询，检查驱动程序是否有数据可以读取，如果可以读取的话就调用read函数读取按键数据。大家也可以试试使用poll函数来实现！
; {+ m- i9 ]% m+ T4 O; |# Q1 M( x! Y32.3.3 运行测试
4 Y- p' ?* O9 S# H! W. s+ }9 S" M1、编译驱动程序和测试APP
7 g5 I* A6 W8 W) P  d9 A9 r+ d①、编译驱动程序
$ S2 d3 p! b$ t8 u! X( b( e1 V编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为noblockio.o，Makefile内容如下所示：

1. 示例代码52.3.3.1 Makefile文件
   
2. 1KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31
   
3. ......
   
4. 4  obj-m := noblockio.o
   8 M3 i- N% b" V) ]8 I) ^. o
5. ......
   4 A+ g3 u4 Y4 `/ N
6. 11 clean:
     E" T" I2 p% v
7. 12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

/ E6 `# h$ ], i" ]& [5 Z7 K第4行，设置obj-m变量的值为noblockio.o。
输入如下命令编译出驱动模块文件：
make -j32
编译成功以后就会生成一个名为“noblockio.ko”的驱动模块文件。
②、编译测试APP
7 Z( B; U, P# S输入如下命令编译测试noblockioApp.c这个测试程序：
arm-none-linux-gnueabihf-gcc noblockioApp.c -o noblockioApp
/ ~- l8 M+ y9 A. h# D: S8 y$ ~- K4 s% [编译成功以后就会生成noblcokioApp这个应用程序。
2 M, K2 C+ B, e: Q2、运行测试
/ |3 @! s# {2 v* [% l& ?将上一小节编译出来noblockio.ko和noblockioApp这两个文件拷贝到rootfs/lib/modules/5.4.31目录中，重启开发板，进入到目录lib/modules/5.4.31中，输入如下命令加载blockio.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe noblockio.ko //加载驱动
驱动加载成功以后使用如下命令打开noblockioApp这个测试APP，并且以后台模式运行：
./noblockioApp /dev/key &
- p7 C; y3 o. g0 E" `按下开发板上的KEY0按键，结果如图32.3.3.1所示：

+ @/ J$ c; K; |& M7 K5 i, i/ {9 X6 g
5 }3 m. Z9 J+ L, O4 J: P" @
图32.3.3.1 测试APP运行测试
5 w+ y( V! ~! ^  Z& u* C当按下KEY0按键以后noblockioApp这个测试APP就会打印出按键信息。输入“top”命令，查看noblockioAPP这个应用APP的CPU使用率，如图32.3.3.2所示：
# r/ z, ]# P0 z( }
! o. z) p, t1 ~- h6 s2 \
5 C$ T9 M7 |8 w
. t; b1 U# m6 @. L& n# |2 C+ a& P图32.3.3.2 应用程序CPU使用率

从图32.3.3.2可以看出，采用非阻塞方式读处理以后，noblockioApp的CPU占用率也低至0%，和图32.2.3.2中的blockioApp一样，这里的0%并不是说noblockioApp这个应用程序不使用CPU了，只是因为使用率太小了。
如果要“杀掉”处于后台运行模式的noblockioApp这个应用程序，可以参考32.2.3小节讲解的方法。
* r) J& l9 @( \————————————————
2 Z( h5 {5 A+ G# f; e1 d5 P# \版权声明：正点原子
! ?0 M$ d" _* ?2 o. f
8 u, e$ C4 ~0 q
# h" h) V) T& ^3 g4 m4 P4 J; _& ?& z