在裝置驅動中使用非同步通知可以使得對裝置的訪問可進行時，由驅動主動通知應用程式進行訪問。因此，使用無阻塞I/O的應用程式無需輪詢裝置是否可訪問，而阻塞訪問也可以被類似“中斷”的非同步通知所取代。非同步通知類似於硬體上的“中斷”概念，比較準確的稱謂是“訊號驅動的非同步I/O”。
1、非同步通知的概念和作用
影響：阻塞–應用程式無需輪詢裝置是否可以訪問
非阻塞–中斷進行通知
即：由驅動發起，主動通知應用程式
2、linux非同步通知程式設計
2.1 linux訊號
作用：linux系統中，非同步通知使用訊號來實現
函式原型為：
|
1 |
void (*signal(int signum,void (*handler))(int)))(int) |
原型比較難理解可以分解為
|
1 2 3 |
typedef void(*sighandler_t)(int); sighandler_t signal(int signum,sighandler_t handler); |
第一個引數是指定訊號的值，第二個引數是指定針對前面訊號的處理函式
2.2 訊號的處理函式（在應用程式端捕獲訊號）
signal()函式
例子：
|
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 29 30 31 |
//啟動訊號機制 void sigterm_handler(int sigo) { char data[MAX_LEN]; int len; len = read(STDIN_FILENO,&data,MAX_LEN); data[len] = 0; printf("Input available:%s\n",data); exit(0); } int main(void) { int oflags; //啟動訊號驅動機制 signal(SIGIO,sigterm_handler); fcntl(STDIN_FILENO,F_SETOWN,getpid()); oflags = fcntl(STDIN_FILENO,F_GETFL); fctcl(STDIN_FILENO,F_SETFL,oflags | FASYNC); //建立一個死迴圈，防止程式結束 whlie(1); return 0; } |
2.3 訊號的釋放 (在裝置驅動端釋放訊號)
為了是裝置支援非同步通知機制，驅動程式中涉及以下3項工作
（1）、支援F_SETOWN命令，能在這個控制命令處理中設定filp->f_owner為對應的程式ID。不過此項工作已由核心完成，裝置驅動無須處理。
（2）、支援F_SETFL命令處理，每當FASYNC標誌改變時，驅動函式中的fasync()函式得以執行。因此，驅動中應該實現fasync()函式
（3）、在裝置資源中可獲得，呼叫kill_fasync（）函式激發相應的訊號
裝置驅動中非同步通知程式設計：
（1）、fasync_struct加入裝置結構體模板中
（2）、兩個函式
處理FASYNC標誌的兩個函式： int fasync_helper(int fd,struct file *filp,int mode,struct fasync_struct **fa);
釋放訊號的函式： void kill_fasync(struct fasync_struct **fa,int sig,int band);
和其他結構體指標放到裝置結構體中，模板如下
|
1 2 3 4 5 6 |
struct xxx_dev{ struct cdev cdev; ... struct fasync_struct *async_queue;//非同步結構體指標 }; |
2.4 在裝置驅動中的fasync()函式中，只需簡單地將該函式的3個引數以及fasync_struct結構體指標的指標作為第四個引數傳入fasync_helper()函式就可以了，模板如下
|
1 2 3 4 5 |
static int xxx_fasync(int fd,struct file *filp, int mode) { struct xxx_dev *dev = filp->private_data; return fasync_helper(fd, filp, mode, &dev->async_queue); } |
2.5 在裝置資源可獲得時應該呼叫kill_fasync()函式釋放SIGIO訊號，可讀時第三個引數為POLL_IN，可寫時第三個引數為POLL_OUT，模板如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
static ssize_t xxx_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos) { struct xxx_dev *dev = filp->private_data; ... if(dev->async_queue) kill_fasync(&dev->async_queue,GIGIO,POLL_IN); ... } |
2.6 最後在檔案關閉時，要將檔案從非同步通知列表中刪除
|
1 2 3 4 5 6 7 8 9 |
int xxx_release(struct inode *inode,struct file *filp) { xxx_fasync(-1,filp,0); ... return 0; } |
3、linux2.6非同步I/O
同步I/O：linux系統中最常用的輸入輸出（I/O）模型是同步I/O，在這個模型中，當請求發出後，應用程式就會阻塞，知道請求滿足
非同步I/O：I/O請求可能需要與其它程式產生交疊
Linux 系統中最常用的輸入/輸出（I/O）模型是同步 I/O。在這個模型中，當請求發出之後，應用程式就會阻塞，直到請求滿足為止。這是很好的一種解決方案，因為呼叫應用程式在等待 I/O 請求完成時不需要使用任何中央處理單元（CPU）。但是在某
些情況下，I/O 請求可能需要與其他程式產生交疊。可移植作業系統介面（POSIX）非同步 I/O（AIO）應用程式介面（API）就提供了這種功能
4.1、AIO系列API：
aio_read–非同步讀
aio_read 函式的原型如下：
|
1 |
int aio_read( struct aiocb *aiocbp ); |
aio_read()函式在請求進行排隊之後會立即返回。如果執行成功，返回值就為 0；如果出現錯誤，返回值就為−1，並設定 errno 的值。
aio_write–非同步寫
aio_write()函式用來請求一個非同步寫操作，其函式原型如下：
|
1 |
int aio_write( struct aiocb *aiocbp ); |
aio_write()函式會立即返回，說明請求已經進行排隊（成功時返回值為 0，失敗時返回值為−1，並相應地設定 errno。
aio_error–確定請求的狀態
aio_error 函式被用來確定請求的狀態，其原型如下：
|
1 |
int aio_error( struct aiocb *aiocbp ); |
這個函式可以返回以下內容。
EINPROGRESS：說明請求尚未完成。
ECANCELLED：說明請求被應用程式取消了。
-1：說明發生了錯誤，具體錯誤原因由 errno 記錄。
aio_return–獲得非同步操作的返回值
非同步 I/O 和標準塊 I/O 之間的另外一個區別是不能立即訪問這個函式的返回狀態，因為並沒有阻塞在 read()呼叫上。在標準的 read()呼叫中，返回狀態是在該函式返回時提供的。但是在非同步 I/O 中，我們要使用 aio_return()函式。這個函式的原型如下：
|
1 |
ssize_t aio_return( struct aiocb *aiocbp ); |
只有在 aio_error()呼叫確定請求已經完成（可能成功，也可能發生了錯誤）之後，才會呼叫這個函式。aio_return()的返回值就等價於同步情況中 read 或 write 系統呼叫的返回值（所傳輸的位元組數，如果發生錯誤，返回值就為−1）。
aio_suspend–掛起非同步操作，知道非同步請求完成為止
aio_suspend()函式來掛起（或阻塞）呼叫程式，直到非同步請求完成為止，此時會產生一個訊號，或者發生其他超時操作。呼叫者提供了一個 aiocb 引用列表，其中任何一個完成都會導致 aio_suspend()返回。aio_suspend 的函式原型如下：
|
1 |
int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout ); |
aio_cancel–取消非同步請求
aio_cancel()函式允許使用者取消對某個檔案描述符執行的一個或所有 I/O 請求。其原型如下：
|
1 |
int aio_cancel( int fd, struct aiocb *aiocbp ); |
如果要取消一個請求，使用者需提供檔案描述符和 aiocb 引用。如果這個請求被成功取消了，那麼這個函式就會返回 AIO_CANCELED。如果請求完成了，這個函式就會返回AIO_NOTCANCELED。 如果要取消對某個給定檔案描述符的所有請求，使用者需要提供這個檔案的描述符以及一個對 aiocbp 的 NULL 引用。如果所有的請求都取消了，這個函式就會返回AIO_CANCELED ；如果至少有一個請求沒有被取消，那麼這個函式就會返回AIO_NOT_CANCELED；如果沒有一個請求可以被取消，那麼這個函式就會返回AIO_ALLDONE。然後，可以使用 aio_error()來驗證每個 AIO 請求，如果某請求已經被取消了，那麼 aio_error()就會返回−1，並且 errno 會被設定為 ECANCELED。
lio_listio–同時發起多個傳輸（一次系統呼叫可以啟動大量的I/O操作）
lio_listio()函式可用於同時發起多個傳輸。這個函式非常重要，它使得使用者可以在一個系統呼叫（一次核心上下文切換）中啟動大量的 I/O 操作。lio_listio API 函式的原型如下：
|
1 |
int lio_listio( int mode, struct aiocb *list[], int nent, struct sigevent *sig ); |
mode 引數可以是 LIO_WAIT 或 LIO_NOWAIT。LIO_WAIT 會阻塞這個呼叫，直到所有的 I/O 都完成為止。在操作進行排隊之後，LIO_NOWAIT 就會返回。list 是一個 aiocb 引用的列表，最大元素的個數是由 nent 定義的。如果 list 的元素為 NULL，lio_listio()會將其忽略。
3.2、使用訊號作為AIO的通知
訊號作為非同步通知的機制在AIO中依然使用，為了使用訊號，使用AIO的應用程式同樣需要定義訊號處理程式，在指定的訊號被觸發時，呼叫這個處理程式，作為訊號上下文的一部分，特定的 aiocb 請求被提供給訊號處理函式用來區分 AIO 請求。 下面程式碼清單給出了使用訊號作為 AIO 非同步 I/O 通知機制的例子。
|
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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
1 /*設定非同步 I/O 請求*/ 2 void setup_io(...) 3 { 4 int fd; 5 struct sigaction sig_act; 6 struct aiocb my_aiocb; 7 ... 8 /* 設定訊號處理函式 */ 9 sigemptyset(&sig_act.sa_mask); 10 sig_act.sa_flags = SA_SIGINFO; 11 sig_act.sa_sigaction = aio_completion_handler; 12 13 /* 設定 AIO 請求 */ 14 bzero((char*) &my_aiocb, sizeof(struct aiocb)); 15 my_aiocb.aio_fildes = fd; 16 my_aiocb.aio_buf = malloc(BUF_SIZE + 1); 17 my_aiocb.aio_nbytes = BUF_SIZE; 18 my_aiocb.aio_offset = next_offset; 19 20 /* 連線 AIO 請求和訊號處理函式 */ 21 my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL; 22 my_aiocb.aio_sigevent.sigev_signo = SIGIO; 23 my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb; 24 25 /* 將訊號與訊號處理函式繫結 */ 26 ret = sigaction(SIGIO, &sig_act, NULL); 27 ... 28 ret = aio_read(&my_aiocb); /*發出非同步讀請求*/ 29 } 30 31 /*訊號處理函式*/ 32 void aio_completion_handler(int signo, siginfo_t *info, void *context) 33 { 34 struct aiocb *req; 35 36 /* 確定是我們需要的訊號*/ 37 if (info->si_signo == SIGIO) 38 { 39 req = (struct aiocb*)info->si_value.sival_ptr; /*獲得 aiocb*/ 40 41 /* 請求的操作完成了嗎? */ 42 if (aio_error(req) == 0) 43 { 44 /* 請求的操作完成，獲取返回值 */ 45 ret = aio_return(req); 46 } 47 } 48 return ; 49 } |
3.3 使用回撥函式作為AIO的通知
程式碼清單給出了使用回撥函式作為 AIO 非同步 I/O 請求完成的通知機制的例子
|
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 29 30 31 32 33 34 35 36 37 |
1 /*設定非同步 I/O 請求*/ 2 void setup_io(...) 3 { 4 int fd; 5 struct aiocb my_aiocb; 6 ... 7 /* 設定 AIO 請求 */ 8 bzero((char*) &my_aiocb, sizeof(struct aiocb)); 9 my_aiocb.aio_fildes = fd; 10 my_aiocb.aio_buf = malloc(BUF_SIZE + 1); 11 my_aiocb.aio_nbytes = BUF_SIZE; 12 my_aiocb.aio_offset = next_offset; 13 14 /* 連線 AIO 請求和執行緒回撥函式 */ 15 my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD; 16 my_aiocb.aio_sigevent.notify_function = aio_completion_handler; 17 /*設定回撥函式*/ 18 my_aiocb.aio_sigevent.notify_attributes = NULL; 19 my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb; 20 ... ret = aio_read(&my_aiocb); //發起 AIO 請求 21 } 22 23 /* 非同步 I/O 完成回撥函式 */ 24 void aio_completion_handler(sigval_t sigval) 25 { 26 struct aiocb *req; 27 req = (struct aiocb*)sigval.sival_ptr; 28 29 /* AIO 請求完成? */ 30 if (aio_error(req) == 0) 31 { 32 /* 請求完成，獲得返回值 */ 33 ret = aio_return(req); 34 } 35 36 return ; 37 } |
3.4 AIO與裝置驅動
在核心中，每個I/O請求都對應一個kiocb結構體，其ki_filp成員只想對應的file指標，通過is_sync_kiocb判斷某kiocb是否為同步I/O請求，如果是返回真，表示為非同步I/O請求。
塊裝置和網路裝置：本身是非同步的
字元裝置：必須明確應支援AIO（極少數是非同步I/O操作）
字元裝置驅動程式中file_operations 包含 3 個與 AIO 相關的成員函式，如下所示：
|
1 2 3 4 5 |
ssize_t (*aio_read) (struct kiocb *iocb, char *buffer, size_t count, loff_t offset); ssize_t (*aio_write) (struct kiocb *iocb, const char *buffer, size_t count, loff_t offset); int (*aio_fsync) (struct kiocb *iocb, int datasync); |
over~