织梦CMS - 轻松建站从此开始!

罗索

Epoll在LT和ET模式下的读写方式

落鹤生 发布于 2013-01-05 10:34 点击:次 
二者的差异在于level-trigger模式下只要某个socket处于readable/writable状态,无论什么时候进行 epoll_wait都会返回该socket;而edge-trigger模式下只有某个socket从unreadable变为readable或从 unwritable变为writable时,epoll_wait才会返回该socket。
TAG:

在一个非阻塞的socket上调用read/write函数, 返回EAGAIN或者EWOULDBLOCK(注: EAGAIN就是EWOULDBLOCK)
从字面上看, 意思是:EAGAIN: 再试一次,EWOULDBLOCK: 如果这是一个阻塞socket, 操作将被block,perror输出: Resource temporarily unavailable

总结:
这个错误表示资源暂时不够,能read时,读缓冲区没有数据,或者write时,写缓冲区满了。遇到这种情况,如果是阻塞 socket,read/write就要阻塞掉。而如果是非阻塞socket,read/write立即返回-1, 同时errno设置为EAGAIN。
所以,对于阻塞socket,read/write返回-1代表网络出错了。但对于非阻塞socket,read/write返回-1不一定网络真的出错 了。可能是Resource temporarily unavailable。这时你应该再试,直到Resource available。

综上,对于non-blocking的socket,正确的读写操作为:
读:忽略掉errno = EAGAIN的错误,下次继续读
写:忽略掉errno = EAGAIN的错误,下次继续写

对于select和epoll的LT模式,这种读写方式是没有问题的。但对于epoll的ET模式,这种方式还有漏洞。

epoll的两种模式LT和ET
二者的差异在于level-trigger模式下只要某个socket处于readable/writable状态,无论什么时候进行 epoll_wait都会返回该socket;而edge-trigger模式下只有某个socket从unreadable变为readable或从 unwritable变为writable时,epoll_wait才会返回该socket。

所以,在epoll的ET模式下,正确的读写方式为:
读:只要可读,就一直读,直到返回0,或者 errno = EAGAIN
写:只要可写,就一直写,直到数据发送完,或者 errno = EAGAIN

正确的读

  1. n = 0; 
  2. while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) { 
  3. n += nread; 
  4. if (nread == -1 && errno != EAGAIN) { 
  5. perror("read error"); 

正确的写

  1. int nwrite, data_size = strlen(buf); 
  2. n = data_size; 
  3. while (n > 0) { 
  4. nwrite = write(fd, buf + data_size - n, n); 
  5. if (nwrite < n) { 
  6. if (nwrite == -1 && errno != EAGAIN) { 
  7. perror("write error"); 
  8. break
  9. n -= nwrite; 

正确的accept,accept 要考虑 2 个问题
(1) 阻塞模式 accept 存在的问题
考虑这种情况:TCP连接被客户端夭折,即在服务器调用accept之前,客户端主动发送RST终止连接,导致刚刚建立的连接从就绪队列中移出,如果套接 口被设置成阻塞模式,服务器就会一直阻塞在accept调用上,直到其他某个客户建立一个新的连接为止。但是在此期间,服务器单纯地阻塞在accept调 用上,就绪队列中的其他描述符都得不到处理。

解决办法是把监听套接口设置为非阻塞,当客户在服务器调用accept之前中止某个连接时,accept调用可以立即返回-1,这时源自 Berkeley的实现会在内核中处理该事件,并不会将该事件通知给epool,而其他实现把errno设置为ECONNABORTED或者EPROTO 错误,我们应该忽略这两个错误。

(2)ET模式下accept存在的问题
考虑这种情况:多个连接同时到达,服务器的TCP就绪队列瞬间积累多个就绪连接,由于是边缘触发模式,epoll只会通知一次,accept只处理一个连接,导致TCP就绪队列中剩下的连接都得不到处理。

解决办法是用while循环抱住accept调用,处理完TCP就绪队列中的所有连接后再退出循环。如何知道是否处理完就绪队列中的所有连接呢?accept返回-1并且errno设置为EAGAIN就表示所有连接都处理完。

综合以上两种情况,服务器应该使用非阻塞地accept,accept在ET模式下的正确使用方式为:

  1. while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote
  2. , (size_t *)&addrlen)) > 0) { 
  3. handle_client(conn_sock); 
  4. if (conn_sock == -1) { 
  5. if (errno != EAGAIN && errno != ECONNABORTED && errno != EPROTO && errno != EINTR) 
  6. perror("accept"); 

一道腾讯后台开发的面试题
使用Linuxepoll模型,水平触发模式;当socket可写时,会不停的触发socket可写的事件,如何处理?

第一种最普遍的方式:
需要向socket写数据的时候才把socket加入epoll,等待可写事件。
接受到可写事件后,调用write或者send发送数据。
当所有数据都写完后,把socket移出epoll。

这种方式的缺点是,即使发送很少的数据,也要把socket加入epoll,写完后在移出epoll,有一定操作代价。

一种改进的方式:
开始不把socket加入epoll,需要向socket写数据的时候,直接调用write或者send发送数据。如果返回EAGAIN,把socket加入epoll,在epoll的驱动下写数据,全部数据发送完毕后,再移出epoll。

这种方式的优点是:数据不多的时候可以避免epoll的事件处理,提高效率。

最后贴一个使用epoll,ET模式的简单HTTP服务器代码:

  1. #include <sys/socket.h> 
  2. #include <sys/wait.h> 
  3. #include <netinet/in.h> 
  4. #include <netinet/tcp.h> 
  5. #include <sys/epoll.h> 
  6. #include <sys/sendfile.h> 
  7. #include <sys/stat.h> 
  8. #include <unistd.h> 
  9. #include <stdio.h> 
  10. #include <stdlib.h> 
  11. #include <string.h> 
  12. #include <strings.h> 
  13. #include <fcntl.h> 
  14. #include <errno.h> 
  15.   
  16. #define MAX_EVENTS 10 
  17. #define PORT 8080 
  18.   
  19. //设置socket连接为非阻塞模式 
  20. void setnonblocking(int sockfd) { 
  21. int opts; 
  22.   
  23. opts = fcntl(sockfd, F_GETFL); 
  24. if(opts < 0) { 
  25. perror("fcntl(F_GETFL)n"); 
  26. exit(1); 
  27. opts = (opts | O_NONBLOCK); 
  28. if(fcntl(sockfd, F_SETFL, opts) < 0) { 
  29. perror("fcntl(F_SETFL)n"); 
  30. exit(1); 
  31.   
  32. int main(){ 
  33. struct epoll_event ev, events[MAX_EVENTS]; 
  34. int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n; 
  35. struct sockaddr_in local, remote; 
  36. char buf[BUFSIZ]; 
  37.   
  38. //创建listen socket 
  39. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 
  40. perror("sockfdn"); 
  41. exit(1); 
  42. setnonblocking(listenfd); 
  43. bzero(&local, sizeof(local)); 
  44. local.sin_family = AF_INET; 
  45. local.sin_addr.s_addr = htonl(INADDR_ANY);; 
  46. local.sin_port = htons(PORT); 
  47. if( bind(listenfd,(struct sockaddr*)&local, sizeof(local)) < 0) { 
  48. perror("bindn"); 
  49. exit(1); 
  50. listen(listenfd, 20); 
  51.   
  52. epfd = epoll_create(MAX_EVENTS); 
  53. if (epfd == -1) { 
  54. perror("epoll_create"); 
  55. exit(EXIT_FAILURE); 
  56.   
  57. ev.events = EPOLLIN; 
  58. ev.data.fd = listenfd; 
  59. if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) { 
  60. perror("epoll_ctl: listen_sock"); 
  61. exit(EXIT_FAILURE); 
  62.   
  63. for (;;) { 
  64. nfds = epoll_wait(epfd, events, MAX_EVENTS, -1); 
  65. if (nfds == -1) { 
  66. perror("epoll_pwait"); 
  67. exit(EXIT_FAILURE); 
  68.   
  69. for (i = 0; i < nfds; ++i) { 
  70. fd = events[i].data.fd; 
  71. if (fd == listenfd) { 
  72. while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote, 
  73. (size_t *)&addrlen)) > 0) { 
  74. setnonblocking(conn_sock); 
  75. ev.events = EPOLLIN | EPOLLET; 
  76. ev.data.fd = conn_sock; 
  77. if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock, 
  78. &ev) == -1) { 
  79. perror("epoll_ctl: add"); 
  80. exit(EXIT_FAILURE); 
  81. if (conn_sock == -1) { 
  82. if (errno != EAGAIN && errno != ECONNABORTED 
  83. && errno != EPROTO && errno != EINTR) 
  84. perror("accept"); 
  85. continue
  86. if (events[i].events & EPOLLIN) { 
  87. n = 0; 
  88. while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) { 
  89. n += nread; 
  90. if (nread == -1 && errno != EAGAIN) { 
  91. perror("read error"); 
  92. ev.data.fd = fd; 
  93. ev.events = events[i].events | EPOLLOUT; 
  94. if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) { 
  95. perror("epoll_ctl: mod"); 
  96. if (events[i].events & EPOLLOUT) { 
  97. sprintf(buf, "HTTP/1.1 200 OKrnContent-Length: %drnrnHello World", 11); 
  98. int nwrite, data_size = strlen(buf); 
  99. n = data_size; 
  100. while (n > 0) { 
  101. nwrite = write(fd, buf + data_size - n, n); 
  102. if (nwrite < n) { 
  103. if (nwrite == -1 && errno != EAGAIN) { 
  104. perror("write error"); 
  105. break
  106. n -= nwrite; 
  107. close(fd); 
  108.   
  109. return 0; 

 

(秩名)
本站文章除注明转载外,均为本站原创或编译欢迎任何形式的转载,但请务必注明出处,尊重他人劳动,同学习共成长。转载请注明:文章转载自:罗索实验室 [http://www.rosoo.net/a/201301/16446.html]
本文出处:酷勤网 作者:秩名
顶一下
(0)
0%
踩一下
(0)
0%
------分隔线----------------------------
发表评论
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
栏目列表
将本文分享到微信
织梦二维码生成器
推荐内容