请教个linux下aio的问题

wishel

aio的异步完成通知有2种形式：
1）异步信号
2）系统回调函数

我想知道的是，当采用2）系统回调函数时，执行该函数的线程是内核线程么？应该不是发起aio的那个用户线程。

1. 
   
2. void setup_io( ... )
   
3. {
   
4.   int fd;
   
5.   struct aiocb my_aiocb;
   
6.   ...
   
7.   
   
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.   my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
    
15.   my_aiocb.aio_sigevent.notify_function = aio_completion_handler;
    
16.   my_aiocb.aio_sigevent.notify_attributes = NULL;
    
17.   my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
    
18.   ...
    
19.   ret = aio_read( &my_aiocb );
    
20. }
    
21. 
    
22. void aio_completion_handler( sigval_t sigval )
    
23. {
    
24.   struct aiocb *req;
    
25.   req = (struct aiocb *)sigval.sival_ptr;
    
26.   
    
27.   if (aio_error( req ) == 0) {
    
28.      
    
29.      ret = aio_return( req );
    
30.   }
    
31.   return;
    
32. }
    

复制代码

也就是说，内核通知线程会执行aio_completion_handler？

naihe2010

往底层一点儿说，回调函数，就是代码执行到一个地方，那里保存了一个函数的指针，然后直接就调用了那个函数指针了。跟你在那里直接调用一个函数是完全一样的效果。
所以，调用的地方是什么线程，函数执行时就是什么线程，任何回调函数，都与线程切换无关。

cookis

不是内核线程，就是 pthread_create 创建的普通线程

cookis

回复 1# wishel


  你在gnu 上下个glibc的代码，  aio的实现就在  glibc-2.9/sysdeps/pthread/

wishel

回复 4# cookis


  ok，多谢！

cugb_cat

从/proc/PID/status中可以看到执行这个函数时，是有两个线程的。

aaaaa5aa

用sleep，然后查看PS -AUXF

wishel

郁闷...inux下的aio是不是问题很多？
大家帮我看下这段程序：

1. 
   
2. #include <sys/epoll.h>
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <fcntl.h>
   
6. #include <stdlib.h>
   
7. #include <unistd.h>
   
8. #include <aio.h>
   
9. 
   
10. static const size_t BUF_SIZE = 512 * 1024;
    
11. volatile int ret;
    
12. int fds[2];
    
13. 
    
14. void aio_completion_handler( sigval_t sigval ) {
    
15.   struct aiocb *req;
    
16. 
    
17.   req = (struct aiocb *)sigval.sival_ptr;
    
18. 
    
19.   printf("begin ret in handler: %d\n", ret);
    
20. 
    
21.   if (aio_error( req ) == 0) {
    
22.     ret = aio_return( req );
    
23.   } else {
    
24.           perror("read error");
    
25.   }
    
26. 
    
27.   printf("end ret in handler: %d\n", ret);
    
28.   write(fds[1], "hello world!\n", 13);
    
29.   return;
    
30. }
    
31. 
    
32. void setup_io() {
    
33.        char INPUTFILE[] = "inputfile";
    
34.        int fin = open(INPUTFILE, O_RDONLY);
    
35.        if (fin == -1)
    
36.                perror("open file error");
    
37.        int fd = fin;
    
38. 
    
39.    int ret;
    
40.    struct aiocb my_aiocb;
    
41. 
    
42.    bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
    
43. 
    
44.   my_aiocb.aio_fildes = fd;
    
45.   my_aiocb.aio_buf = malloc(BUF_SIZE+1);
    
46.   my_aiocb.aio_nbytes = BUF_SIZE;
    
47.   my_aiocb.aio_offset = 0;
    
48.   my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
    
49.   my_aiocb.aio_sigevent.sigev_notify_function = aio_completion_handler;
    
50.   my_aiocb.aio_sigevent.sigev_notify_attributes = NULL;
    
51.   my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
    
52. 
    
53.   ret = aio_read( &my_aiocb );
    
54. }
    
55. 
    
56. int main () {
    
57.         if (pipe(fds) == -1)
    
58.                 return -1;
    
59. 
    
60.         int epollfd = epoll_create(10);
    
61.         struct epoll_event* event = new epoll_event;
    
62.         event->events = EPOLLIN;
    
63.         event->data.fd = fds[0];
    
64.         int n;
    
65.         n = epoll_ctl(epollfd, EPOLL_CTL_ADD, fds[0], event);
    
66.         printf("n= %d\n", n);
    
67. 
    
68.         setup_io();
    
69.         //sleep(1);
    
70. 
    
71.                 epoll_event events[10];
    
72.                 int nfds = epoll_wait(epollfd, events, 10 , -1);
    
73.                 printf("nfds= %d\n", nfds);
    
74.                 for (int i = 0; i < nfds; ++i) {
    
75.                         epoll_event ev = events[i];
    
76.                         if (ev.events & EPOLLIN) {
    
77.                                 printf("fd %d, event EPOLLIN\n", ev.data.fd);
    
78.                         }
    
79.                         if (ev.events & EPOLLOUT) {
    
80.                                 printf("fd %d, event EPOLLOUT\n", ev.data.fd);
    
81.                         }
    
82.                         if (ev.events & EPOLLHUP)
    
83.                                 printf("fd %d, event EPOLLHUP\n", ev.data.fd);
    
84.                         if (ev.events & EPOLLERR)
    
85.                                 printf("fd %d, event EPOLLERR\n", ev.data.fd);
    
86.                 }
    
87. 
    
88.         //sleep(1);
    
89.         printf("ret = %d!!!\n", ret);
    
90. 
    
91.         return 0;
    
92. }
    

复制代码

连续运行几次的结果：
wang@ubuntu:~/workspace/test/Debug$ ./test
n= 0
begin ret in handler: 0
end ret in handler: 8104
nfds= 1
fd 3, event EPOLLIN
ret = 8104!!!
wang@ubuntu:~/workspace/test/Debug$ ./test
n= 0
begin ret in handler: 0
end ret in handler: -1208869936
nfds= 1
fd 3, event EPOLLIN
ret = -1208869936!!!
wang@ubuntu:~/workspace/test/Debug$ ./test
n= 0
begin ret in handler: 0
end ret in handler: 8104
nfds= 1
fd 3, event EPOLLIN
ret = 8104!!!
wang@ubuntu:~/workspace/test/Debug$ ./test
n= 0
begin ret in handler: 0
end ret in handler: -1210160176
nfds= 1
fd 3, event EPOLLIN
ret = -1210160176!!!

wishel

打开第68行的sleep后，基本上不出现ret为大负数的情况，但是有时候aio_completion_handler不会执行
程序卡住了，不知道是aio一直没完成还是完成后没能成功call aio_completion_handler

系统是ubuntu 8.10，明天去公司换个系统试试看。