當前位置：首頁 > 运维知识 > linux >内容正文

linux

Linux 阻塞和非阻塞IO 实验

發(fā)布時間：2023/12/10 linux 20 豆豆

生活随笔收集整理的這篇文章主要介紹了 Linux 阻塞和非阻塞IO 实验小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

阻塞和非阻塞IO 是Linux 驅(qū)動開發(fā)里面很常見的兩種設(shè)備訪問模式，在編寫驅(qū)動的時候一定要考慮到阻塞和非阻塞。本章我們就來學習一下阻塞和非阻塞IO，以及如何在驅(qū)動程序中處理阻塞與非阻塞，如何在驅(qū)動程序使用等待隊列和poll 機制。

阻塞和非阻塞IO

阻塞和非阻塞簡介

這里的“IO”并不是我們學習STM32 或者其他單片機的時候所說的“GPIO”(也就是引腳)。這里的IO 指的是Input/Output，也就是輸入/輸出，是應(yīng)用程序?qū)︱?qū)動設(shè)備的輸入/輸出操作。

阻塞：當應(yīng)用程序?qū)υO(shè)備驅(qū)動進行操作的時候，如果不能獲取到設(shè)備資源，那么阻塞式IO 就會將應(yīng)用程序?qū)?yīng)的線程掛起，直到設(shè)備資源可以獲取為止。

線程的掛起操作實質(zhì)上就是線程進入"非可執(zhí)行"狀態(tài)下，在這個狀態(tài)下CPU不會分給線程時間片，進入這個狀態(tài)可以用來暫停一個線程的運行。線程掛起后，可以通過重新喚醒線程來使之恢復(fù)運行。cpu分配的線程片非常的短、同時也非常珍貴。避免資源的浪費。

非阻塞：對于非阻塞IO，應(yīng)用程序?qū)?yīng)的線程不會掛起，它要么一直輪詢等待，直到設(shè)備資源可以使用，要么就直接放棄。阻塞式IO 如圖52.1.1.1所示：

圖52.1.1.1 中應(yīng)用程序調(diào)用read 函數(shù)從設(shè)備中讀取數(shù)據(jù)，當設(shè)備不可用或數(shù)據(jù)未準備好的時候就會進入到休眠態(tài)。等設(shè)備可用的時候就會從休眠態(tài)喚醒，然后從設(shè)備中讀取數(shù)據(jù)返回給應(yīng)用程序。非阻塞IO 如圖52.1.2 所示：

從圖52.1.1.2 可以看出，應(yīng)用程序使用非阻塞訪問方式從設(shè)備讀取數(shù)據(jù)，當設(shè)備不可用或數(shù)據(jù)未準備好的時候會立即向內(nèi)核返回一個錯誤碼，表示數(shù)據(jù)讀取失敗。應(yīng)用程序會再次重新讀取數(shù)據(jù)，這樣一直往復(fù)循環(huán)，直到數(shù)據(jù)讀取成功。

應(yīng)用程序可以使用如下所示示例代碼來實現(xiàn)阻塞訪問：

1 int fd; 2 int data = 0; 3 4 fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打開*/ 5 ret = read(fd, &data, sizeof(data)); /* 讀取數(shù)據(jù)*/

從示例代碼52.1.1.1 可以看出，對于設(shè)備驅(qū)動文件的默認讀取方式就是阻塞式的，所以我們前面所有的例程測試APP 都是采用阻塞IO。
如果應(yīng)用程序要采用非阻塞的方式來訪問驅(qū)動設(shè)備文件，可以使用如下所示代碼：

1 int fd; 2 int data = 0; 3 4 fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打開*/ 5 ret = read(fd, &data, sizeof(data)); /* 讀取數(shù)據(jù)*/

第4 行使用open 函數(shù)打開“/dev/xxx_dev”設(shè)備文件的時候添加了參數(shù)“O_NONBLOCK”，表示以非阻塞方式打開設(shè)備，這樣從設(shè)備中讀取數(shù)據(jù)的時候就是非阻塞方式的了。

等待隊列

1、等待隊列頭

阻塞訪問最大的好處就是當設(shè)備文件不可操作的時候進程可以進入休眠態(tài)，這樣可以將CPU 資源讓出來。但是，當設(shè)備文件可以操作的時候就必須喚醒進程，一般在中斷函數(shù)里面完成喚醒工作。Linux 內(nèi)核提供了等待隊列(wait queue)來實現(xiàn)阻塞進程的喚醒工作，如果我們要在驅(qū)動中使用等待隊列，必須創(chuàng)建并初始化一個等待隊列頭，等待隊列頭使用結(jié)構(gòu)體
wait_queue_head_t 表示，wait_queue_head_t 結(jié)構(gòu)體定義在文件include/linux/wait.h 中，結(jié)構(gòu)體內(nèi)容如下所示：

39 struct __wait_queue_head { 40 spinlock_t lock; 41 struct list_head task_list; 42 }; 43 typedef struct __wait_queue_head wait_queue_head_t;

定義好等待隊列頭以后需要初始化，使用init_waitqueue_head 函數(shù)初始化等待隊列頭，函數(shù)原型如下：

void init_waitqueue_head(wait_queue_head_t *q)

參數(shù)q 就是要初始化的等待隊列頭。
也可以使用宏DECLARE_WAIT_QUEUE_HEAD 來一次性完成等待隊列頭的定義的初始化。

2、等待隊列項
等待隊列頭就是一個等待隊列的頭部，每個訪問設(shè)備的進程都是一個隊列項，當設(shè)備不可用的時候就要將這些進程對應(yīng)的等待隊列項添加到等待隊列里面。結(jié)構(gòu)體wait_queue_t 表示等待隊列項，結(jié)構(gòu)體內(nèi)容如下：

struct __wait_queue { unsigned int flags; void *private; wait_queue_func_t func; struct list_head task_list; }; typedef struct __wait_queue wait_queue_t;

使用宏DECLARE_WAITQUEUE 定義并初始化一個等待隊列項，宏的內(nèi)容如下：

DECLARE_WAITQUEUE(name, tsk)

name 就是等待隊列項的名字，tsk 表示這個等待隊列項屬于哪個任務(wù)(進程)，一般設(shè)置為current ，在Linux 內(nèi)核中current 相當于一個全局變量，表示當前進程。因此宏DECLARE_WAITQUEUE 就是給當前正在運行的進程創(chuàng)建并初始化了一個等待隊列項。

3、將隊列項添加/移除等待隊列頭
當設(shè)備不可訪問的時候就需要將進程對應(yīng)的等待隊列項添加到前面創(chuàng)建的等待隊列頭中，只有添加到等待隊列頭中以后進程才能進入休眠態(tài)。當設(shè)備可以訪問以后再將進程對應(yīng)的等待隊列項從等待隊列頭中移除即可，等待隊列項添加API 函數(shù)如下：

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

函數(shù)參數(shù)和返回值含義如下：
q：等待隊列項要加入的等待隊列頭。
wait：要加入的等待隊列項。
返回值：無。
等待隊列項移除API 函數(shù)如下：

void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

函數(shù)參數(shù)和返回值含義如下：
q：要刪除的等待隊列項所處的等待隊列頭。
wait：要刪除的等待隊列項。
返回值：無。
4、等待喚醒
當設(shè)備可以使用的時候就要喚醒進入休眠態(tài)的進程，喚醒可以使用如下兩個函數(shù)：

void wake_up(wait_queue_head_t *q) void wake_up_interruptible(wait_queue_head_t *q)

參數(shù)q 就是要喚醒的等待隊列頭，這兩個函數(shù)會將這個等待隊列頭中的所有進程都喚醒。
wake_up 函數(shù)可以喚醒處于TASK_INTERRUPTIBLE 和TASK_UNINTERRUPTIBLE 狀態(tài)的進程，而wake_up_interruptible 函數(shù)只能喚醒處于TASK_INTERRUPTIBLE 狀態(tài)的進程。

5、等待事件
除了主動喚醒以外，也可以設(shè)置等待隊列等待某個事件，當這個事件滿足以后就自動喚醒等待隊列中的進程，和等待事件有關(guān)的API 函數(shù)如表52.1.2.1 所示：

函數(shù)描述

wait_event(wq, condition)	等待以wq 為等待隊列頭的等待隊列被喚醒，前提是condition 條件必須滿足(為真)，否則一直阻塞。此函數(shù)會將進程設(shè)置為TASK_UNINTERRUPTIBLE 狀態(tài)
wait_event_timeout(wq, condition, timeout)	功能和wait_event 類似，但是此函數(shù)可以添加超時時間，以jiffies 為單位。此函數(shù)有返回值，如果返回0 的話表示超時時間到，而且condition為假。為1 的話表示condition 為真，也就是條件滿足了。
wait_event_interruptible(wq, condition)	與wait_event 函數(shù)類似，但是此函數(shù)將進程設(shè)置為TASK_INTERRUPTIBLE，就是可以被信號打斷。
wait_event_interruptible_timeout(wq, condition, timeout)	與wait_event_timeout 函數(shù)類似，此函數(shù)也將進程設(shè)置為TASK_INTERRUPTIBLE，可以被信號打斷。

輪詢

如果用戶應(yīng)用程序以非阻塞的方式訪問設(shè)備，設(shè)備驅(qū)動程序就要提供非阻塞的處理方式，也就是輪詢。poll、epoll 和select 可以用于處理輪詢，應(yīng)用程序通過select、epoll 或poll 函數(shù)來查詢設(shè)備是否可以操作，如果可以操作的話就從設(shè)備讀取或者向設(shè)備寫入數(shù)據(jù)。當應(yīng)用程序調(diào)用select、epoll 或poll 函數(shù)的時候設(shè)備驅(qū)動程序中的poll 函數(shù)就會執(zhí)行，因此需要在設(shè)備驅(qū)動程序中編寫poll 函數(shù)。我們先來看一下應(yīng)用程序中使用的select、poll 和epoll 這三個函數(shù)。

1、select 函數(shù)
select 函數(shù)原型如下：

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

函數(shù)參數(shù)和返回值含義如下：
nfds：所要監(jiān)視的這三類文件描述集合中，最大文件描述符加1。
readfds、writefds 和exceptfds：這三個指針指向描述符集合，這三個參數(shù)指明了關(guān)心哪些描述符、需要滿足哪些條件等等，這三個參數(shù)都是fd_set 類型的，fd_set 類型變量的每一個位都代表了一個文件描述符。readfds 用于監(jiān)視指定描述符集的讀變化，也就是監(jiān)視這些文件是否可以讀取，只要這些集合里面有一個文件可以讀取那么seclect 就會返回一個大于0 的值表示文件可以讀取。如果沒有文件可以讀取，那么就會根據(jù)timeout 參數(shù)來判斷是否超時。可以將readfs設(shè)置為NULL，表示不關(guān)心任何文件的讀變化。writefds 和readfs 類似，只是writefs 用于監(jiān)視這些文件是否可以進行寫操作。exceptfds 用于監(jiān)視這些文件的異常。

比如我們現(xiàn)在要從一個設(shè)備文件中讀取數(shù)據(jù)，那么就可以定義一個fd_set 變量，這個變量要傳遞給參數(shù)readfds。當我們定義好一個fd_set 變量以后可以使用如下所示幾個宏進行操作：

void FD_ZERO(fd_set *set) void FD_SET(int fd, fd_set *set) void FD_CLR(int fd, fd_set *set) int FD_ISSET(int fd, fd_set *set)

FD_ZERO 用于將fd_set 變量的所有位都清零，FD_SET 用于將fd_set 變量的某個位置1，也就是向fd_set 添加一個文件描述符，參數(shù)fd 就是要加入的文件描述符。FD_CLR 用于將fd_set變量的某個位清零，也就是將一個文件描述符從fd_set 中刪除，參數(shù)fd 就是要刪除的文件描述
符。FD_ISSET 用于測試一個文件是否屬于某個集合，參數(shù)fd 就是要判斷的文件描述符。
timeout:超時時間，當我們調(diào)用select 函數(shù)等待某些文件描述符可以設(shè)置超時時間，超時時間使用結(jié)構(gòu)體timeval 表示，結(jié)構(gòu)體定義如下所示：

struct timeval { long tv_sec; /* 秒*/ long tv_usec; /* 微妙*/ };

當timeout 為NULL 的時候就表示無限期的等待。

返回值：0，表示的話就表示超時發(fā)生，但是沒有任何文件描述符可以進行操作；-1，發(fā)生錯誤；其他值，可以進行操作的文件描述符個數(shù)。
使用select 函數(shù)對某個設(shè)備驅(qū)動文件進行讀非阻塞訪問的操作示例如下所示：

1 void main(void) 2 { 3 int ret, fd; /* 要監(jiān)視的文件描述符*/ 4 fd_set readfds; /* 讀操作文件描述符集*/ 5 struct timeval timeout; /* 超時結(jié)構(gòu)體*/ 6 7 fd = open("dev_xxx", O_RDWR | O_NONBLOCK); /* 非阻塞式訪問*/ 8 9 FD_ZERO(&readfds); /* 清除readfds */ 10 FD_SET(fd, &readfds); /* 將fd添加到readfds里面*/ 11 12 /* 構(gòu)造超時時間*/ 13 timeout.tv_sec = 0; 14 timeout.tv_usec = 500000; /* 500ms */ 15 16 ret = select(fd + 1, &readfds, NULL, NULL, &timeout); 17 switch (ret) { 18 case 0: /* 超時*/ 19 printf("timeout!\r\n"); 20 break; 21 case -1: /* 錯誤*/ 22 printf("error!\r\n"); 23 break; 24 default: /* 可以讀取數(shù)據(jù)*/ 25 if(FD_ISSET(fd, &readfds)) { /* 判斷是否為fd文件描述符*/ 26 /* 使用read函數(shù)讀取數(shù)據(jù)*/ 27 } 28 break; 29 } 30 }

2、poll 函數(shù)
在單個線程中，select 函數(shù)能夠監(jiān)視的文件描述符數(shù)量有最大的限制，一般為1024，可以修改內(nèi)核將監(jiān)視的文件描述符數(shù)量改大，但是這樣會降低效率！這個時候就可以使用poll 函數(shù)，poll 函數(shù)本質(zhì)上和select 沒有太大的差別，但是poll 函數(shù)沒有最大文件描述符限制，Linux 應(yīng)用程序中poll 函數(shù)原型如下所示：

int poll(struct pollfd *fds, nfds_t nfds, int timeout)

函數(shù)參數(shù)和返回值含義如下：
fds：要監(jiān)視的文件描述符集合以及要監(jiān)視的事件,為一個數(shù)組，數(shù)組元素都是結(jié)構(gòu)體pollfd類型的，pollfd 結(jié)構(gòu)體如下所示：

struct pollfd { int fd; /* 文件描述符*/ short events; /* 請求的事件*/ short revents; /* 返回的事件*/ };

fd 是要監(jiān)視的文件描述符，如果fd 無效的話那么events 監(jiān)視事件也就無效，并且revents返回0。events 是要監(jiān)視的事件，可監(jiān)視的事件類型如下所示：

POLLIN 有數(shù)據(jù)可以讀取。 POLLPRI 有緊急的數(shù)據(jù)需要讀取。 POLLOUT 可以寫數(shù)據(jù)。 POLLERR 指定的文件描述符發(fā)生錯誤。 POLLHUP 指定的文件描述符掛起。 POLLNVAL 無效的請求。 POLLRDNORM 等同于POLLIN

revents 是返回參數(shù)，也就是返回的事件，由Linux 內(nèi)核設(shè)置具體的返回事件。
nfds：poll 函數(shù)要監(jiān)視的文件描述符數(shù)量。
timeout：超時時間，單位為ms。
返回值：返回revents 域中不為0 的pollfd 結(jié)構(gòu)體個數(shù)，也就是發(fā)生事件或錯誤的文件描述符數(shù)量；0，超時；-1，發(fā)生錯誤，并且設(shè)置errno 為錯誤類型。

使用poll 函數(shù)對某個設(shè)備驅(qū)動文件進行讀非阻塞訪問的操作示例如下所示：

1 void main(void) 2 { 3 int ret; 4 int fd; /* 要監(jiān)視的文件描述符*/ 5 struct pollfd fds; 6 7 fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式訪問*/ 8 9 /* 構(gòu)造結(jié)構(gòu)體*/ 10 fds.fd = fd; 11 fds.events = POLLIN; /* 監(jiān)視數(shù)據(jù)是否可以讀取*/ 12 13 ret = poll(&fds, 1, 500); /* 輪詢文件是否可操作，超時500ms */ 14 if (ret) { /* 數(shù)據(jù)有效*/ 15 ...... 16 /* 讀取數(shù)據(jù)*/ 17 ...... 18 } else if (ret == 0) { /* 超時*/ 19 ...... 20 } else if (ret < 0) { /* 錯誤*/ 21 ...... 22 } 23 }

3、epoll 函數(shù)
傳統(tǒng)的selcet 和poll 函數(shù)都會隨著所監(jiān)聽的fd 數(shù)量的增加，出現(xiàn)效率低下的問題，而且poll 函數(shù)每次必須遍歷所有的描述符來檢查就緒的描述符，這個過程很浪費時間。為此，epoll應(yīng)運而生，epoll 就是為處理大并發(fā)而準備的，一般常常在網(wǎng)絡(luò)編程中使用epoll 函數(shù)。應(yīng)用程序需要先使用epoll_create 函數(shù)創(chuàng)建一個epoll 句柄，epoll_create 函數(shù)原型如下：

int epoll_create(int size)

函數(shù)參數(shù)和返回值含義如下：
size：從Linux2.6.8 開始此參數(shù)已經(jīng)沒有意義了，隨便填寫一個大于0 的值就可以。
返回值：epoll 句柄，如果為-1 的話表示創(chuàng)建失敗。
epoll 句柄創(chuàng)建成功以后使用epoll_ctl 函數(shù)向其中添加要監(jiān)視的文件描述符以及監(jiān)視的事件，epoll_ctl 函數(shù)原型如下所示：

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

函數(shù)參數(shù)和返回值含義如下：
epfd：要操作的epoll 句柄，也就是使用epoll_create 函數(shù)創(chuàng)建的epoll 句柄。
op：表示要對epfd(epoll 句柄)進行的操作，可以設(shè)置為：

EPOLL_CTL_ADD 向epfd 添加文件參數(shù)fd 表示的描述符。 EPOLL_CTL_MOD 修改參數(shù)fd 的event 事件。 EPOLL_CTL_DEL 從epfd 中刪除fd 描述符。

fd：要監(jiān)視的文件描述符。
event：要監(jiān)視的事件類型，為epoll_event 結(jié)構(gòu)體類型指針，epoll_event 結(jié)構(gòu)體類型如下所示：

struct epoll_event { uint32_t events; /* epoll 事件*/ epoll_data_t data; /* 用戶數(shù)據(jù)*/ };

結(jié)構(gòu)體epoll_event 的events 成員變量表示要監(jiān)視的事件，可選的事件如下所示：

EPOLLIN 有數(shù)據(jù)可以讀取。 EPOLLOUT 可以寫數(shù)據(jù)。 EPOLLPRI 有緊急的數(shù)據(jù)需要讀取。 EPOLLERR 指定的文件描述符發(fā)生錯誤。 EPOLLHUP 指定的文件描述符掛起。 EPOLLET 設(shè)置epoll 為邊沿觸發(fā)，默認觸發(fā)模式為水平觸發(fā)。 EPOLLONESHOT 一次性的監(jiān)視，當監(jiān)視完成以后還需要再次監(jiān)視某個fd，那么就需要將 fd 重新添加到epoll 里面。

上面這些事件可以進行“或”操作，也就是說可以設(shè)置監(jiān)視多個事件。
返回值：0，成功；-1，失敗，并且設(shè)置errno 的值為相應(yīng)的錯誤碼。
一切都設(shè)置好以后應(yīng)用程序就可以通過epoll_wait 函數(shù)來等待事件的發(fā)生，類似select 函數(shù)。epoll_wait 函數(shù)原型如下所示：

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)

函數(shù)參數(shù)和返回值含義如下：
epfd：要等待的epoll。
events：指向epoll_event 結(jié)構(gòu)體的數(shù)組，當有事件發(fā)生的時候Linux 內(nèi)核會填寫events，調(diào)用者可以根據(jù)events 判斷發(fā)生了哪些事件。
maxevents：events 數(shù)組大小，必須大于0。
timeout：超時時間，單位為ms。
返回值：0，超時；-1，錯誤；其他值，準備就緒的文件描述符數(shù)量。
epoll 更多的是用在大規(guī)模的并發(fā)服務(wù)器上，因為在這種場合下select 和poll 并不適合。當設(shè)計到的文件描述符(fd)比較少的時候就適合用selcet 和poll，本章我們就使用sellect 和poll 這兩個函數(shù)。

Linux 驅(qū)動下的poll 操作函數(shù)

當應(yīng)用程序調(diào)用select 或poll 函數(shù)來對驅(qū)動程序進行非阻塞訪問的時候，驅(qū)動程序file_operations 操作集中的poll 函數(shù)就會執(zhí)行。所以驅(qū)動程序的編寫者需要提供對應(yīng)的poll 函數(shù)，poll 函數(shù)原型如下所示：

unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)

函數(shù)參數(shù)和返回值含義如下：
filp：要打開的設(shè)備文件(文件描述符)。
wait：結(jié)構(gòu)體poll_table_struct 類型指針，由應(yīng)用程序傳遞進來的。一般將此參數(shù)傳遞給poll_wait 函數(shù)。
返回值:向應(yīng)用程序返回設(shè)備或者資源狀態(tài)，可以返回的資源狀態(tài)如下：

POLLIN 有數(shù)據(jù)可以讀取。 POLLPRI 有緊急的數(shù)據(jù)需要讀取。 POLLOUT 可以寫數(shù)據(jù)。 POLLERR 指定的文件描述符發(fā)生錯誤。 POLLHUP 指定的文件描述符掛起。 POLLNVAL 無效的請求。 POLLRDNORM 等同于POLLIN，普通數(shù)據(jù)可讀

我們需要在驅(qū)動程序的poll 函數(shù)中調(diào)用poll_wait 函數(shù)，poll_wait 函數(shù)不會引起阻塞，只是將應(yīng)用程序添加到poll_table 中，poll_wait 函數(shù)原型如下：

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)

參數(shù)wait_address 是要添加到poll_table 中的等待隊列頭，參數(shù)p 就是poll_table，就是file_operations 中poll 函數(shù)的wait 參數(shù)。

阻塞IO 實驗

在上一章Linux 中斷實驗中，我們直接在應(yīng)用程序中通過read 函數(shù)不斷的讀取按鍵狀態(tài)，當按鍵有效的時候就打印出按鍵值。這種方法有個缺點，那就是imx6uirqApp 這個測試應(yīng)用程序擁有很高的CPU 占用率，大家可以在開發(fā)板中加載上一章的驅(qū)動程序模塊imx6uirq.ko，然后以后臺運行模式打開imx6uirqApp 這個測試軟件，命令如下：

./imx6uirqApp /dev/imx6uirq &

測試驅(qū)動是否正常工作，如果驅(qū)動工作正常的話輸入“top”命令查看imx6uirqApp 這個應(yīng)用程序的CPU 使用率，結(jié)果如圖52.2.1 所示：

從圖52.2.1 可以看出，imx6uirqApp 這個應(yīng)用程序的CPU 使用率竟然高達99.6%，這僅僅是一個讀取按鍵值的應(yīng)用程序，這么高的CPU 使用率顯然是有問題的！原因就在于我們是直接在while 循環(huán)中通過read 函數(shù)讀取按鍵值，因此imx6uirqApp 這個軟件會一直運行，一直讀取按鍵值，CPU 使用率肯定就會很高。最好的方法就是在沒有有效的按鍵事件發(fā)生的時候，
imx6uirqApp 這個應(yīng)用程序應(yīng)該處于休眠狀態(tài)，當有按鍵事件發(fā)生以后imx6uirqApp 這個應(yīng)用程序才運行，打印出按鍵值，這樣就會降低CPU 使用率，本小節(jié)我們就使用阻塞IO 來實現(xiàn)此功能。

硬件原理圖分析

本章實驗硬件原理圖參考15.2 小節(jié)即可。

實驗程序編寫

1、驅(qū)動程序編寫
本實驗對應(yīng)的例程路徑為：開發(fā)板光盤-> 2、Linux 驅(qū)動例程-> 14_blockio。
本章實驗我們在上一章的“13_irq”實驗的基礎(chǔ)上完成，主要是對其添加阻塞訪問相關(guān)的代碼。新建名為“14_blockio”的文件夾，然后在14_blockio 文件夾里面創(chuàng)建vscode 工程，工作區(qū)命名為“blockio”。將“13_irq”實驗中的imx6uirq.c 復(fù)制到14_blockio 文件夾中，并重命名為blockio.c。接下來我們就修改blockio.c 這個文件，在其中添加阻塞相關(guān)的代碼，完成以后的
blockio.c 內(nèi)容如下所示(因為是在上一章實驗的imx6uirq.c 文件的基礎(chǔ)上修改的，為了減少篇幅，下面的代碼有省略)：

#include <linux/types.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/ide.h> #include <linux/init.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/gpio.h> #include <linux/cdev.h> #include <linux/device.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/of_gpio.h> #include <linux/semaphore.h> #include <linux/timer.h> #include <linux/of_irq.h> #include <linux/irq.h> #include <asm/mach/map.h> #include <asm/uaccess.h> #include <asm/io.h> /*************************************************************** Copyright ? ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 文件名 : block.c 作者 : 左忠凱版本 : V1.0 描述 : 阻塞IO訪問其他 : 無論壇 : www.openedv.com 日志 : 初版V1.0 2019/7/26 左忠凱創(chuàng)建 ***************************************************************/ #define IMX6UIRQ_CNT 1 /* 設(shè)備號個數(shù) */ #define IMX6UIRQ_NAME "blockio" /* 名字 */ #define KEY0VALUE 0X01 /* KEY0按鍵值 */ #define INVAKEY 0XFF /* 無效的按鍵值 */ #define KEY_NUM 1 /* 按鍵數(shù)量 *//* 中斷IO描述結(jié)構(gòu)體 */ struct irq_keydesc {int gpio; /* gpio */int irqnum; /* 中斷號 */unsigned char value; /* 按鍵對應(yīng)的鍵值 */char name[10]; /* 名字 */irqreturn_t (*handler)(int, void *); /* 中斷服務(wù)函數(shù) */ };/* imx6uirq設(shè)備結(jié)構(gòu)體 */ struct imx6uirq_dev{dev_t devid; /* 設(shè)備號 */ struct cdev cdev; /* cdev */ struct class *class; /* 類 */struct device *device; /* 設(shè)備 */int major; /* 主設(shè)備號 */int minor; /* 次設(shè)備號 */struct device_node *nd; /* 設(shè)備節(jié)點 */ atomic_t keyvalue; /* 有效的按鍵鍵值 */atomic_t releasekey; /* 標記是否完成一次完成的按鍵，包括按下和釋放 */struct timer_list timer;/* 定義一個定時器*/struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按鍵init述數(shù)組 */unsigned char curkeynum; /* 當前init按鍵號 */wait_queue_head_t r_wait; /* 讀等待隊列頭 */ };struct imx6uirq_dev imx6uirq; /* irq設(shè)備 *//* @description : 中斷服務(wù)函數(shù)，開啟定時器 * 定時器用于按鍵消抖。* @param - irq : 中斷號 * @param - dev_id : 設(shè)備結(jié)構(gòu)。* @return : 中斷執(zhí)行結(jié)果*/ static irqreturn_t key0_handler(int irq, void *dev_id) {struct imx6uirq_dev *dev = (struct imx6uirq_dev*)dev_id;dev->curkeynum = 0;dev->timer.data = (volatile long)dev_id;mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10)); /* 10ms定時 */return IRQ_RETVAL(IRQ_HANDLED); }/* @description : 定時器服務(wù)函數(shù)，用于按鍵消抖，定時器到了以后* 再次讀取按鍵值，如果按鍵還是處于按下狀態(tài)就表示按鍵有效。* @param - arg : 設(shè)備結(jié)構(gòu)變量* @return : 無*/ void timer_function(unsigned long arg) {unsigned char value;unsigned char num;struct irq_keydesc *keydesc;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;num = dev->curkeynum;keydesc = &dev->irqkeydesc[num];value = gpio_get_value(keydesc->gpio); /* 讀取IO值 */if(value == 0){ /* 按下按鍵 */atomic_set(&dev->keyvalue, keydesc->value);}else{ /* 按鍵松開 */atomic_set(&dev->keyvalue, 0x80 | keydesc->value);atomic_set(&dev->releasekey, 1); /* 標記松開按鍵，即完成一次完整的按鍵過程 */} /* 喚醒進程 */if(atomic_read(&dev->releasekey)) { /* 完成一次按鍵過程 *//* wake_up(&dev->r_wait); */wake_up_interruptible(&dev->r_wait);} }/** @description : 按鍵IO初始化* @param : 無* @return : 無*/ static int keyio_init(void) {unsigned char i = 0;char name[10];int ret = 0;imx6uirq.nd = of_find_node_by_path("/key");if (imx6uirq.nd== NULL){printk("key node not find!\r\n");return -EINVAL;} /* 提取GPIO */for (i = 0; i < KEY_NUM; i++) {imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd ,"key-gpio", i);if (imx6uirq.irqkeydesc[i].gpio < 0) {printk("can't get key%d\r\n", i);}}/* 初始化key所使用的IO，并且設(shè)置成中斷模式 */for (i = 0; i < KEY_NUM; i++) {memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(name)); /* 緩沖區(qū)清零 */sprintf(imx6uirq.irqkeydesc[i].name, "KEY%d", i); /* 組合名字 */gpio_request(imx6uirq.irqkeydesc[i].gpio, name);gpio_direction_input(imx6uirq.irqkeydesc[i].gpio); imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i); #if 0imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio); #endif}/* 申請中斷 */imx6uirq.irqkeydesc[0].handler = key0_handler;imx6uirq.irqkeydesc[0].value = KEY0VALUE;for (i = 0; i < KEY_NUM; i++) {ret = request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc[i].name, &imx6uirq);if(ret < 0){printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);return -EFAULT;}}/* 創(chuàng)建定時器 */init_timer(&imx6uirq.timer);imx6uirq.timer.function = timer_function;/* 初始化等待隊列頭 */init_waitqueue_head(&imx6uirq.r_wait);return 0; }/** @description : 打開設(shè)備* @param - inode : 傳遞給驅(qū)動的inode* @param - filp : 設(shè)備文件，file結(jié)構(gòu)體有個叫做private_data的成員變量* 一般在open的時候?qū)rivate_data指向設(shè)備結(jié)構(gòu)體。* @return : 0 成功;其他失敗*/ static int imx6uirq_open(struct inode *inode, struct file *filp) {filp->private_data = &imx6uirq; /* 設(shè)置私有數(shù)據(jù) */return 0; }/** @description : 從設(shè)備讀取數(shù)據(jù) * @param - filp : 要打開的設(shè)備文件(文件描述符)* @param - buf : 返回給用戶空間的數(shù)據(jù)緩沖區(qū)* @param - cnt : 要讀取的數(shù)據(jù)長度* @param - offt : 相對于文件首地址的偏移* @return : 讀取的字節(jié)數(shù)，如果為負值，表示讀取失敗*/ static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {int ret = 0;unsigned char keyvalue = 0;unsigned char releasekey = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;#if 0/* 加入等待隊列，等待被喚醒,也就是有按鍵按下 */ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); if (ret) {goto wait_error;} #endifDECLARE_WAITQUEUE(wait, current); /* 定義一個等待隊列 */if(atomic_read(&dev->releasekey) == 0) { /* 沒有按鍵按下 */add_wait_queue(&dev->r_wait, &wait); /* 將等待隊列添加到等待隊列頭 */__set_current_state(TASK_INTERRUPTIBLE);/* 設(shè)置任務(wù)狀態(tài) */schedule(); /* 進行一次任務(wù)切換 */if(signal_pending(current)) { /* 判斷是否為信號引起的喚醒 */ret = -ERESTARTSYS;goto wait_error;}__set_current_state(TASK_RUNNING); /* 將當前任務(wù)設(shè)置為運行狀態(tài) */remove_wait_queue(&dev->r_wait, &wait); /* 將對應(yīng)的隊列項從等待隊列頭刪除 */}keyvalue = atomic_read(&dev->keyvalue);releasekey = atomic_read(&dev->releasekey);if (releasekey) { /* 有按鍵按下 */ if (keyvalue & 0x80) {keyvalue &= ~0x80;ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(&dev->releasekey, 0);/* 按下標志清零 */} else {goto data_error;}return 0;wait_error:set_current_state(TASK_RUNNING); /* 設(shè)置任務(wù)為運行態(tài) */remove_wait_queue(&dev->r_wait, &wait); /* 將等待隊列移除 */return ret;data_error:return -EINVAL; }/* 設(shè)備操作函數(shù) */ static struct file_operations imx6uirq_fops = {.owner = THIS_MODULE,.open = imx6uirq_open,.read = imx6uirq_read, };/** @description : 驅(qū)動入口函數(shù)* @param : 無* @return : 無*/ static int __init imx6uirq_init(void) {/* 1、構(gòu)建設(shè)備號 */if (imx6uirq.major) {imx6uirq.devid = MKDEV(imx6uirq.major, 0);register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);} else {alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);imx6uirq.major = MAJOR(imx6uirq.devid);imx6uirq.minor = MINOR(imx6uirq.devid);}/* 2、注冊字符設(shè)備 */cdev_init(&imx6uirq.cdev, &imx6uirq_fops);cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);/* 3、創(chuàng)建類 */imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.class)) { return PTR_ERR(imx6uirq.class);}/* 4、創(chuàng)建設(shè)備 */imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.device)) {return PTR_ERR(imx6uirq.device);}/* 5、始化按鍵 */atomic_set(&imx6uirq.keyvalue, INVAKEY);atomic_set(&imx6uirq.releasekey, 0);keyio_init();return 0; }/** @description : 驅(qū)動出口函數(shù)* @param : 無* @return : 無*/ static void __exit imx6uirq_exit(void) {unsigned i = 0;/* 刪除定時器 */del_timer_sync(&imx6uirq.timer); /* 刪除定時器 *//* 釋放中斷 */ for (i = 0; i < KEY_NUM; i++) {free_irq(imx6uirq.irqkeydesc[i].irqnum, &imx6uirq);}cdev_del(&imx6uirq.cdev);unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);device_destroy(imx6uirq.class, imx6uirq.devid);class_destroy(imx6uirq.class); }module_init(imx6uirq_init); module_exit(imx6uirq_exit); MODULE_LICENSE("GPL");

第32 行，修改設(shè)備文件名字為“blockio”，當驅(qū)動程序加載成功以后就會在根文件系統(tǒng)中出現(xiàn)一個名為“/dev/blockio”的文件。

第61 行，在設(shè)備結(jié)構(gòu)體中添加一個等待隊列頭r_wait，因為在Linux 驅(qū)動中處理阻塞IO需要用到等待隊列。

第107~110 行，定時器中斷處理函數(shù)執(zhí)行，表示有按鍵按下，先在107 行判斷一下是否是一次有效的按鍵，如果是的話就通過wake_up 或者wake_up_interruptible 函數(shù)來喚醒等待隊列r_wait。

第168 行，調(diào)用init_waitqueue_head 函數(shù)初始化等待隊列頭r_wait。

第200~206 行，采用等待事件來處理read 的阻塞訪問，wait_event_interruptible 函數(shù)等待releasekey 有效，也就是有按鍵按下。如果按鍵沒有按下的話進程就會進入休眠狀態(tài)，因為采用了wait_event_interruptible 函數(shù)，因此進入休眠態(tài)的進程可以被信號打斷。

第208~218 行，首先使用DECLARE_WAITQUEUE 宏定義一個等待隊列，如果沒有按鍵按下的話就使用add_wait_queue 函數(shù)將當前任務(wù)的等待隊列添加到等待隊列頭r_wait 中。隨后調(diào)用__set_current_state 函數(shù)設(shè)置當前進程的狀態(tài)為TASK_INTERRUPTIBLE，也就是可以被信號打斷。接下來調(diào)用schedule 函數(shù)進行一次任務(wù)切換，當前進程就會進入到休眠態(tài)。如果有按
鍵按下，那么進入休眠態(tài)的進程就會喚醒，然后接著從休眠點開始運行。在這里也就是從第213行開始運行，首先通過signal_pending 函數(shù)判斷一下進程是不是由信號喚醒的，如果是由信號喚醒的話就直接返回-ERESTARTSYS 這個錯誤碼。如果不是由信號喚醒的(也就是被按鍵喚醒的)那么就在217 行調(diào)用__set_current_state 函數(shù)將任務(wù)狀態(tài)設(shè)置為TASK_RUNNING，然后在
218 行調(diào)用remove_wait_queue 函數(shù)將進程從等待隊列中刪除。

使用等待隊列實現(xiàn)阻塞訪問重點注意兩點：
①、將任務(wù)或者進程加入到等待隊列頭，
②、在合適的點喚醒等待隊列，一般都是中斷處理函數(shù)里面。
2、編寫測試APP

本節(jié)實驗的測試APP 直接使用第51.3.3 小節(jié)所編寫的imx6uirqApp.c，將imx6uirqApp.c 復(fù)制到本節(jié)實驗文件夾下，并且重命名為blockioApp.c，不需要修改任何內(nèi)容。

運行測試

1、編譯驅(qū)動程序和測試APP
①、編譯驅(qū)動程序
編寫Makefile 文件，本章實驗的Makefile 文件和第四十章實驗基本一樣，只是將obj-m 變量的值改為blockio.o，Makefile 內(nèi)容如下所示：

KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek CURRENT_PATH := $(shell pwd)obj-m := blockio.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

第4 行，設(shè)置obj-m 變量的值為blockio.o。
輸入如下命令編譯出驅(qū)動模塊文件：

make -j32

編譯成功以后就會生成一個名為“blockio.ko”的驅(qū)動模塊文件。
②、編譯測試APP
輸入如下命令編譯測試noblockioApp.c 這個測試程序：

arm-linux-gnueabihf-gcc blockioApp.c -o blockioApp

編譯成功以后就會生成blcokioApp 這個應(yīng)用程序。

2、運行測試
將上一小節(jié)編譯出來blockio.ko 和blockioApp 這兩個文件拷貝到rootfs/lib/modules/4.1.15目錄中，重啟開發(fā)板，進入到目錄lib/modules/4.1.15 中，輸入如下命令加載blockio.ko 驅(qū)動模塊：

depmod //第一次加載驅(qū)動的時候需要運行此命令 modprobe blockio.ko //加載驅(qū)動

驅(qū)動加載成功以后使用如下命令打開blockioApp 這個測試APP，并且以后臺模式運行：

./blockioApp /dev/blockio &

按下開發(fā)板上的KEY0 按鍵，結(jié)果如圖52.2.3.1 所示：

當按下KEY0 按鍵以后blockioApp 這個測試APP 就會打印出按鍵值。輸入“top”命令，查看blockioAPP 這個應(yīng)用APP 的CPU 使用率，如圖52.2.3.2 所示：

從圖52.2.3.2 可以看出，當我們在按鍵驅(qū)動程序里面加入阻塞訪問以后，blockioApp 這個應(yīng)用程序的CPU 使用率從圖52.2.1 中的99.6%降低到了0.0%。大家注意，這里的0.0%并不是說blockioApp 這個應(yīng)用程序不使用CPU 了，只是因為使用率太小了，CPU 使用率可能為0.00001%，但是圖52.2.3.2 只能顯示出小數(shù)點后一位，因此就顯示成了0.0%。

我們可以使用“kill”命令關(guān)閉后臺運行的應(yīng)用程序，比如我們關(guān)閉掉blockioApp 這個后臺運行的應(yīng)用程序。首先輸出“Ctrl+C”關(guān)閉top 命令界面，進入到命令行模式。然后使用“ps”命令查看一下blockioApp 這個應(yīng)用程序的PID，如圖52.2.3.3 所示：

從圖圖52.2.3.3 可以看出，blockioApp 這個應(yīng)用程序的PID 為149，使用“kill -9 PID”即可“殺死”指定PID 的進程，比如我們現(xiàn)在要“殺死”PID 為149 的blockioApp 應(yīng)用程序，可是使用如下命令：

kill -9 149

輸入上述命令以后終端顯示如圖52.2.3.4 所示：

從圖52.2.3.4 可以看出，“./blockioApp /dev/blockio”這個應(yīng)用程序已經(jīng)被“殺掉”了，在此輸入“ps”命令查看當前系統(tǒng)運行的進程，會發(fā)現(xiàn)blockioApp 已經(jīng)不見了。這個就是使用kill命令“殺掉”指定進程的方法。

非阻塞IO 實驗

硬件原理圖分析

本章實驗硬件原理圖參考15.2 小節(jié)即可。

實驗程序編寫

1、驅(qū)動程序編寫
本實驗對應(yīng)的例程路徑為：開發(fā)板光盤-> 2、Linux 驅(qū)動例程-> 15_noblockio。

本章實驗我們在52.2 小節(jié)中的“14_blockio”實驗的基礎(chǔ)上完成，上一小節(jié)實驗我們已經(jīng)在驅(qū)動中添加了阻塞IO 的代碼，本小節(jié)我們繼續(xù)完善驅(qū)動，加入非阻塞IO 驅(qū)動代碼。新建名為“15_noblockio”的文件夾，然后在15_noblockio 文件夾里面創(chuàng)建vscode 工程，工作區(qū)命名為“noblockio”。將“14_blockio”實驗中的blockio.c 復(fù)制到15_noblockio 文件夾中，并重命名為noblockio.c。接下來我們就修改noblockio.c 這個文件，在其中添加非阻塞相關(guān)的代碼，完成
以后的noblockio.c 內(nèi)容如下所示(因為是在上一小節(jié)實驗的blockio.c 文件的基礎(chǔ)上修改的，為了減少篇幅，下面的代碼有省略)：

#include <linux/types.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/ide.h> #include <linux/init.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/gpio.h> #include <linux/cdev.h> #include <linux/device.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/of_gpio.h> #include <linux/semaphore.h> #include <linux/timer.h> #include <linux/of_irq.h> #include <linux/irq.h> #include <linux/wait.h> #include <linux/poll.h> #include <asm/mach/map.h> #include <asm/uaccess.h> #include <asm/io.h> /*************************************************************** Copyright ? ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 文件名 : noblock.c 作者 : 左忠凱版本 : V1.0 描述 : 非阻塞IO訪問其他 : 無論壇 : www.openedv.com 日志 : 初版V1.0 2019/7/26 左忠凱創(chuàng)建 ***************************************************************/ #define IMX6UIRQ_CNT 1 /* 設(shè)備號個數(shù) */ #define IMX6UIRQ_NAME "noblockio" /* 名字 */ #define KEY0VALUE 0X01 /* KEY0按鍵值 */ #define INVAKEY 0XFF /* 無效的按鍵值 */ #define KEY_NUM 1 /* 按鍵數(shù)量 *//* 中斷IO描述結(jié)構(gòu)體 */ struct irq_keydesc {int gpio; /* gpio */int irqnum; /* 中斷號 */unsigned char value; /* 按鍵對應(yīng)的鍵值 */char name[10]; /* 名字 */irqreturn_t (*handler)(int, void *); /* 中斷服務(wù)函數(shù) */ };/* imx6uirq設(shè)備結(jié)構(gòu)體 */ struct imx6uirq_dev{dev_t devid; /* 設(shè)備號 */ struct cdev cdev; /* cdev */ struct class *class; /* 類 */struct device *device; /* 設(shè)備 */int major; /* 主設(shè)備號 */int minor; /* 次設(shè)備號 */struct device_node *nd; /* 設(shè)備節(jié)點 */ atomic_t keyvalue; /* 有效的按鍵鍵值 */atomic_t releasekey; /* 標記是否完成一次完成的按鍵，包括按下和釋放 */struct timer_list timer;/* 定義一個定時器*/struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按鍵init述數(shù)組 */unsigned char curkeynum; /* 當前init按鍵號 */wait_queue_head_t r_wait; /* 讀等待隊列頭 */ };struct imx6uirq_dev imx6uirq; /* irq設(shè)備 *//* @description : 中斷服務(wù)函數(shù)，開啟定時器 * 定時器用于按鍵消抖。* @param - irq : 中斷號 * @param - dev_id : 設(shè)備結(jié)構(gòu)。* @return : 中斷執(zhí)行結(jié)果*/ static irqreturn_t key0_handler(int irq, void *dev_id) {struct imx6uirq_dev *dev = (struct imx6uirq_dev*)dev_id;dev->curkeynum = 0;dev->timer.data = (volatile long)dev_id;mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10)); /* 10ms定時 */return IRQ_RETVAL(IRQ_HANDLED); }/* @description : 定時器服務(wù)函數(shù)，用于按鍵消抖，定時器到了以后* 再次讀取按鍵值，如果按鍵還是處于按下狀態(tài)就表示按鍵有效。* @param - arg : 設(shè)備結(jié)構(gòu)變量* @return : 無*/ void timer_function(unsigned long arg) {unsigned char value;unsigned char num;struct irq_keydesc *keydesc;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;num = dev->curkeynum;keydesc = &dev->irqkeydesc[num];value = gpio_get_value(keydesc->gpio); /* 讀取IO值 */if(value == 0){ /* 按下按鍵 */atomic_set(&dev->keyvalue, keydesc->value);}else{ /* 按鍵松開 */atomic_set(&dev->keyvalue, 0x80 | keydesc->value);atomic_set(&dev->releasekey, 1); /* 標記松開按鍵，即完成一次完整的按鍵過程 */} /* 喚醒進程 */if(atomic_read(&dev->releasekey)) { /* 完成一次按鍵過程 *//* wake_up(&dev->r_wait); */wake_up_interruptible(&dev->r_wait);} }/** @description : 按鍵IO初始化* @param : 無* @return : 無*/ static int keyio_init(void) {unsigned char i = 0;char name[10];int ret = 0;imx6uirq.nd = of_find_node_by_path("/key");if (imx6uirq.nd== NULL){printk("key node not find!\r\n");return -EINVAL;} /* 提取GPIO */for (i = 0; i < KEY_NUM; i++) {imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd ,"key-gpio", i);if (imx6uirq.irqkeydesc[i].gpio < 0) {printk("can't get key%d\r\n", i);}}/* 初始化key所使用的IO，并且設(shè)置成中斷模式 */for (i = 0; i < KEY_NUM; i++) {memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(name)); /* 緩沖區(qū)清零 */sprintf(imx6uirq.irqkeydesc[i].name, "KEY%d", i); /* 組合名字 */gpio_request(imx6uirq.irqkeydesc[i].gpio, name);gpio_direction_input(imx6uirq.irqkeydesc[i].gpio); imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i); #if 0imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio); #endif}/* 申請中斷 */imx6uirq.irqkeydesc[0].handler = key0_handler;imx6uirq.irqkeydesc[0].value = KEY0VALUE;for (i = 0; i < KEY_NUM; i++) {ret = request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc[i].name, &imx6uirq);if(ret < 0){printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);return -EFAULT;}}/* 創(chuàng)建定時器 */init_timer(&imx6uirq.timer);imx6uirq.timer.function = timer_function;/* 初始化等待隊列頭 */init_waitqueue_head(&imx6uirq.r_wait);return 0; }/** @description : 打開設(shè)備* @param - inode : 傳遞給驅(qū)動的inode* @param - filp : 設(shè)備文件，file結(jié)構(gòu)體有個叫做private_data的成員變量* 一般在open的時候?qū)rivate_data指向設(shè)備結(jié)構(gòu)體。* @return : 0 成功;其他失敗*/ static int imx6uirq_open(struct inode *inode, struct file *filp) {filp->private_data = &imx6uirq; /* 設(shè)置私有數(shù)據(jù) */return 0; }/** @description : 從設(shè)備讀取數(shù)據(jù) * @param - filp : 要打開的設(shè)備文件(文件描述符)* @param - buf : 返回給用戶空間的數(shù)據(jù)緩沖區(qū)* @param - cnt : 要讀取的數(shù)據(jù)長度* @param - offt : 相對于文件首地址的偏移* @return : 讀取的字節(jié)數(shù)，如果為負值，表示讀取失敗*/ static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {int ret = 0;unsigned char keyvalue = 0;unsigned char releasekey = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;if (filp->f_flags & O_NONBLOCK) { /* 非阻塞訪問 */if(atomic_read(&dev->releasekey) == 0) /* 沒有按鍵按下，返回-EAGAIN */return -EAGAIN;} else { /* 阻塞訪問 *//* 加入等待隊列，等待被喚醒,也就是有按鍵按下 */ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); if (ret) {goto wait_error;}}keyvalue = atomic_read(&dev->keyvalue);releasekey = atomic_read(&dev->releasekey);if (releasekey) { /* 有按鍵按下 */ if (keyvalue & 0x80) {keyvalue &= ~0x80;ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(&dev->releasekey, 0);/* 按下標志清零 */} else {goto data_error;}return 0;wait_error:return ret; data_error:return -EINVAL; }/** @description : poll函數(shù)，用于處理非阻塞訪問* @param - filp : 要打開的設(shè)備文件(文件描述符)* @param - wait : 等待列表(poll_table)* @return : 設(shè)備或者資源狀態(tài)，*/ unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct *wait) {unsigned int mask = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;poll_wait(filp, &dev->r_wait, wait); /* 將等待隊列頭添加到poll_table中 */if(atomic_read(&dev->releasekey)) { /* 按鍵按下 */mask = POLLIN | POLLRDNORM; /* 返回PLLIN */}return mask; }/* 設(shè)備操作函數(shù) */ static struct file_operations imx6uirq_fops = {.owner = THIS_MODULE,.open = imx6uirq_open,.read = imx6uirq_read,.poll = imx6uirq_poll, };/** @description : 驅(qū)動入口函數(shù)* @param : 無* @return : 無*/ static int __init imx6uirq_init(void) {/* 1、構(gòu)建設(shè)備號 */if (imx6uirq.major) {imx6uirq.devid = MKDEV(imx6uirq.major, 0);register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);} else {alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);imx6uirq.major = MAJOR(imx6uirq.devid);imx6uirq.minor = MINOR(imx6uirq.devid);}/* 2、注冊字符設(shè)備 */cdev_init(&imx6uirq.cdev, &imx6uirq_fops);cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);/* 3、創(chuàng)建類 */imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.class)) { return PTR_ERR(imx6uirq.class);}/* 4、創(chuàng)建設(shè)備 */imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.device)) {return PTR_ERR(imx6uirq.device);}/* 5、始化按鍵 */atomic_set(&imx6uirq.keyvalue, INVAKEY);atomic_set(&imx6uirq.releasekey, 0);keyio_init();return 0; }/** @description : 驅(qū)動出口函數(shù)* @param : 無* @return : 無*/ static void __exit imx6uirq_exit(void) {unsigned i = 0;/* 刪除定時器 */del_timer_sync(&imx6uirq.timer); /* 刪除定時器 *//* 釋放中斷 */ for (i = 0; i < KEY_NUM; i++) {free_irq(imx6uirq.irqkeydesc[i].irqnum, &imx6uirq);}cdev_del(&imx6uirq.cdev);unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);device_destroy(imx6uirq.class, imx6uirq.devid);class_destroy(imx6uirq.class); } module_init(imx6uirq_init); module_exit(imx6uirq_exit); MODULE_LICENSE("GPL");

第32 行，修改設(shè)備文件名字為“noblockio”，當驅(qū)動程序加載成功以后就會在根文件系統(tǒng)中出現(xiàn)一個名為“/dev/noblockio”的文件。

第202~204 行，判斷是否為非阻塞式讀取訪問，如果是的話就判斷按鍵是否有效，也就是判斷一下有沒有按鍵按下，如果沒有的話就返回-EAGAIN。

第241~ 252 行，imx6uirq_poll 函數(shù)就是file_operations 驅(qū)動操作集中的poll 函數(shù)，當應(yīng)用程序調(diào)用select 或者poll 函數(shù)的時候imx6uirq_poll 函數(shù)就會執(zhí)行。第246 行調(diào)用poll_wait 函數(shù)將等待隊列頭添加到poll_table 中，第

248~250 行判斷按鍵是否有效，如果按鍵有效的話就向應(yīng)用程序返回POLLIN 這個事件，表示有數(shù)據(jù)可以讀取。

第259 行，設(shè)置file_operations 的poll 成員變量為imx6uirq_poll。

2、編寫測試APP
新建名為noblockioApp.c 測試APP 文件，然后在其中輸入如下所示內(nèi)容：

#include "stdio.h" #include "unistd.h" #include "sys/types.h" #include "sys/stat.h" #include "fcntl.h" #include "stdlib.h" #include "string.h" #include "poll.h" #include "sys/select.h" #include "sys/time.h" #include "linux/ioctl.h" /*************************************************************** Copyright ? ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 文件名 : noblockApp.c 作者 : 左忠凱版本 : V1.0 描述 : 非阻塞訪問測試APP 其他 : 無使用方法：./blockApp /dev/blockio 打開測試App 論壇 : www.openedv.com 日志 : 初版V1.0 2019/9/8 左忠凱創(chuàng)建 ***************************************************************//** @description : main主程序* @param - argc : argv數(shù)組元素個數(shù)* @param - argv : 具體參數(shù)* @return : 0 成功;其他失敗*/ int main(int argc, char *argv[]) {int fd;int ret = 0;char *filename;struct pollfd fds;fd_set readfds;struct timeval timeout;unsigned char data;if (argc != 2) {printf("Error Usage!\r\n");return -1;}filename = argv[1];fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞訪問 */if (fd < 0) {printf("Can't open file %s\r\n", filename);return -1;}#if 0/* 構(gòu)造結(jié)構(gòu)體 */fds.fd = fd;fds.events = POLLIN;while (1) {ret = poll(&fds, 1, 500);if (ret) { /* 數(shù)據(jù)有效 */ret = read(fd, &data, sizeof(data));if(ret < 0) {/* 讀取錯誤 */} else {if(data)printf("key value = %d \r\n", data);} } else if (ret == 0) { /* 超時 *//* 用戶自定義超時處理 */} else if (ret < 0) { /* 錯誤 *//* 用戶自定義錯誤處理 */}} #endifwhile (1) { FD_ZERO(&readfds);FD_SET(fd, &readfds);/* 構(gòu)造超時時間 */timeout.tv_sec = 0;timeout.tv_usec = 500000; /* 500ms */ret = select(fd + 1, &readfds, NULL, NULL, &timeout);switch (ret) {case 0: /* 超時 *//* 用戶自定義超時處理 */break;case -1: /* 錯誤 *//* 用戶自定義錯誤處理 */break;default: /* 可以讀取數(shù)據(jù) */if(FD_ISSET(fd, &readfds)) {ret = read(fd, &data, sizeof(data));if (ret < 0) {/* 讀取錯誤 */} else {if (data)printf("key value=%d\r\n", data);}}break;} }close(fd);return ret; }

第52~73 行，這段代碼使用poll 函數(shù)來實現(xiàn)非阻塞訪問，在while 循環(huán)中使用poll 函數(shù)不斷的輪詢，檢查驅(qū)動程序是否有數(shù)據(jù)可以讀取，如果可以讀取的話就調(diào)用read 函數(shù)讀取按鍵數(shù)據(jù)。
第75~101 行，這段代碼使用select 函數(shù)來實現(xiàn)非阻塞訪問。

運行測試

1、編譯驅(qū)動程序和測試APP
①、編譯驅(qū)動程序
編寫Makefile 文件，本章實驗的Makefile 文件和第四十章實驗基本一樣，只是將obj-m 變量的值改為noblockio.o，Makefile 內(nèi)容如下所示：

1 KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek ...... 4 obj-m := noblockio.o ...... 11 clean: 12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

第4 行，設(shè)置obj-m 變量的值為noblockio.o。
輸入如下命令編譯出驅(qū)動模塊文件：

make -j32

編譯成功以后就會生成一個名為“noblockio.ko”的驅(qū)動模塊文件。
②、編譯測試APP
輸入如下命令編譯測試noblockioApp.c 這個測試程序：

arm-linux-gnueabihf-gcc noblockioApp.c -o noblockioApp

編譯成功以后就會生成noblcokioApp 這個應(yīng)用程序。
2、運行測試
將上一小節(jié)編譯出來noblockio.ko 和noblockioApp 這兩個文件拷貝到
rootfs/lib/modules/4.1.15 目錄中，重啟開發(fā)板，進入到目錄lib/modules/4.1.15 中，輸入如下命令
加載blockio.ko 驅(qū)動模塊：

depmod //第一次加載驅(qū)動的時候需要運行此命令 modprobe noblockio.ko //加載驅(qū)動

驅(qū)動加載成功以后使用如下命令打開noblockioApp 這個測試APP，并且以后臺模式運行：

./noblockioApp /dev/noblockio &

按下開發(fā)板上的KEY0 按鍵，結(jié)果如圖52.3.3.1 所示：

當按下KEY0 按鍵以后noblockioApp 這個測試APP 就會打印出按鍵值。輸入“top”命令，查看noblockioAPP 這個應(yīng)用APP 的CPU 使用率，如圖52.3.3.2 所示：

從圖52.3.3.2 可以看出，采用非阻塞方式讀處理以后，noblockioApp 的CPU 占用率也低至0.0%，和圖52.2.3.2 中的blockioApp 一樣，這里的0.0%并不是說noblockioApp 這個應(yīng)用程序不使用CPU 了，只是因為使用率太小了，而圖中只能顯示出小數(shù)點后一位，因此就顯示成了0.0%。
如果要“殺掉”處于后臺運行模式的noblockioApp 這個應(yīng)用程序，可以參考52.2.3 小節(jié)講解的方法。

總結(jié)

以上是生活随笔為你收集整理的Linux 阻塞和非阻塞IO 实验的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

linux
io

上一篇：空间矢量脉冲宽度调制（SVPWM）Sim
下一篇： matlab求出拟合曲线的方程,已知数据