蛻變成蝶~Linux設備驅動之異步通知和異步I/O

　　在設備驅動中使用異步通知可使得對設備的訪問可進行時，由驅動主動通知應用程序進行訪問。所以，使用無阻塞I/O的應用程序無需輪詢設備是否可訪問，而阻塞訪問也能夠被相似「中斷」的異步通知所取代。異步通知相似於硬件上的「中斷」概念，比較準確的稱謂是「信號驅動的異步I/O"。

一、異步通知的概念和做用

影響：阻塞--應用程序無需輪詢設備是否能夠訪問

非阻塞--中斷進行通知

即：由驅動發起，主動通知應用程序

 

二、linux異步通知編程

2.1 linux信號

做用：linux系統中，異步通知使用信號來實現

函數原型爲：

void (*signal(int signum,void (*handler))(int)))(int)

　　

原型比較難理解能夠分解爲

typedef void(*sighandler_t)(int);

sighandler_t signal(int signum,sighandler_t handler);

　　

第一個參數是指定信號的值，第二個參數是指定針對前面信號的處理函數

2.2 信號的處理函數（在應用程序端捕獲信號）

signal()函數

例子：

//啓動信號機制

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);

和其餘結構體指針放到設備結構體中，模板以下

struct xxx_dev{
struct cdev cdev;
...
struct fasync_struct *async_queue;//異步結構體指針

};

　　

2.4 在設備驅動中的fasync()函數中，只需簡單地將該函數的3個參數以及fasync_struct結構體指針的指針做爲第四個參數傳入fasync_helper()函數就能夠了，模板以下

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，模板以下

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 最後在文件關閉時，要將文件從異步通知列表中刪除

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

{
xxx_fasync(-1,filp,0);

...
return 0;

}

　　

三、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.一、AIO系列API：

aio_read--異步讀

aio_read 函數的原型以下： 

int aio_read( struct aiocb *aiocbp ); 

aio_read()函數在請求進行排隊以後會當即返回。若是執行成功，返回值就爲 0；若是出現錯誤，返回值就爲−1，並設置 errno 的值。 

 

aio_write--異步寫

aio_write()函數用來請求一個異步寫操做，其函數原型以下： 

int aio_write( struct aiocb *aiocbp ); 

aio_write()函數會當即返回，說明請求已經進行排隊（成功時返回值爲 0，失敗時返回值爲−1，並相應地設置 errno。 

 

aio_error--肯定請求的狀態

aio_error 函數被用來肯定請求的狀態，其原型以下： 

int aio_error( struct aiocb *aiocbp ); 

這個函數能夠返回如下內容。 

EINPROGRESS：說明請求還沒有完成。 

ECANCELLED：說明請求被應用程序取消了。 

-1：說明發生了錯誤，具體錯誤緣由由 errno 記錄。 

 

aio_return--得到異步操做的返回值

　　異步 I/O 和標準塊 I/O 之間的另一個區別是不能當即訪問這個函數的返回狀態，由於並無阻塞在 read()調用上。在標準的 read()調用中，返回狀態是在該函數返回時提供的。可是在異步 I/O 中，咱們要使用 aio_return()函數。這個函數的原型以下：

ssize_t aio_return( struct aiocb *aiocbp ); 

只有在 aio_error()調用肯定請求已經完成（可能成功，也可能發生了錯誤）以後，纔會調用這個函數。aio_return()的返回值就等價於同步狀況中 read 或 write 系統調用的返回值（所傳輸的字節數，若是發生錯誤，返回值就爲−1）。 

 

aio_suspend--掛起異步操做，知道異步請求完成爲止

 aio_suspend()函數來掛起（或阻塞）調用進程，直到異步請求完成爲止，此時會產生一個信號，或者發生其餘超時操做。調用者提供了一個 aiocb 引用列表，其中任何一個完成都會致使 aio_suspend()返回。aio_suspend 的函數原型以下： 

int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout ); 

　　

aio_cancel--取消異步請求

aio_cancel()函數容許用戶取消對某個文件描述符執行的一個或全部 I/O 請求。其原型以下： 

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 函數的原型以下： 

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.二、使用信號做爲AIO的通知

　　信號做爲異步通知的機制在AIO中依然使用，爲了使用信號，使用AIO的應用程序一樣須要定義信號處理程序，在指定的信號被觸發時，調用這個處理程序，做爲信號上下文的一部分，特定的 aiocb 請求被提供給信號處理函數用來區分 AIO 請求。 下面代碼清單給出了使用信號做爲 AIO 異步 I/O 通知機制的例子。

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  /*設置異步 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 相關的成員函數，以下所示： 

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~

 

　　版權全部，轉載請註明轉載地址：http://www.cnblogs.com/lihuidashen/p/4455393.html