当一个进程调用epoll_create时，内核会创建一个struct eventpoll。这个结构体有两个成员与epoll的使用方式密切相关。
struct eventpoll {
........
/* List of ready file descriptors */
//双向链表rdllist保存着通过epoll_wait返回给用户的、满足条件的事件
struct list_head rdllist;
/* RB tree root used to store monitored fd structs */
//红黑树根节点保存所有要监控的事件
struct rb_root rbr;
...........
};每一个epoll对象都有一个独立的eventpoll结构体，这个结构体会在内核空间创造独立的内存，用于存储使用epoll_ctl向epoll对象添加的事件，这些事件会挂到rbr红黑树中，重复添加的的事件就可通过红黑树识别，在epoll中每个事件都会建立一个epitem结构体，
/*
* Each file descriptor added to the eventpoll interface will
* have an entry of this type linked to the "rbr" RB tree.
*/
struct epitem {
/* RB tree node used to link this structure to the eventpoll RB tree */
struct rb_node rbn;
/* List header used to link this structure to the eventpoll ready list */
struct list_head rdllink;
/*
* Works together "struct eventpoll"->ovflist in keeping the
* single linked chain of items.
*/
struct epitem *next;
/* The file descriptor information this item refers to */
//事件句柄信息
struct epoll_filefd ffd;
/* Number of active wait queue attached to poll operations */
int nwait;
/* List containing poll wait queues */
struct list_head pwqlist;
/* The "container" of this item */
//指向所属的epoll对象
struct eventpoll *ep;
/* List header used to link this item to the "struct file" items list */
struct list_head fllink;
};此外，epoll还维护一个双链表，用于存储发生的事件，当epoll_wait调用时，仅仅观察这个list链表的eptime即可，有数据就返回，没数据就sleep，而且通常要监控百万级的句柄，大多一次返回很少量就绪的句柄，epoll_wait仅需从内核copy少量的句柄到用户态。
维护list链表：当执行epoll_ctl时，除了把socket放到epoll文件系统file对象对应的红黑树上外，还会给内核中断处理函数注册一个回调函数，告诉内核，如果这个句柄到了就调用回调函数把句柄放入list链表，所以当一个socket上有数据，内核就把socket从网卡copy到内核后就把socket插入到就绪链表里。
epoll实现需要一棵红黑树，一个准备就绪句柄链表，少量内核缓存，就能解决大并发socket问题， 执行epoll_create创建红黑树和就绪链表，执行epoll_ctl，就增加socket句柄，则检查红黑树中是否存在，存在就返回，不存在就添加到树干上，然后向内核注册回调函数，用于当数据到来中断处理来临时向准备链表插入数据，执行epoll_wait时返回就绪链表里的数据。
epoll框架：
for( ; ; )
{
ndfs = epoll_wait(efpd, events, 20, 500);
for(i = 0; i < ndfs; i++)
{
if(events[i].data.fd == listened) //遍历所有端口有新连接
{
connfd = accept(listened, (sockaddr*)&clientaddr, &clilen);//接受连接
ev.data.fd = connfd;
ev.events = EPOLLIN|EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev); //将新的描述符添加到epoll监控队列
}
else if (events[i].events & EPOLLIN) //接收数据，读socket
{
n = read(sockfd, line, MAXLINE);
ev.ptr.data = md ;
ev.events = EPOLLOUT|EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_MOD, socketfd, &ev);//修改描述符等待下次循环发送数据
}
else if(events[i].events& EPOLLOUT)
{
struct myepoll_data *md = (struct mypoll_data*)events[i].data.ptr;//取数据
sockfd = md->fd ;
send(sockfd, md->ptr, strlen((char*)md->ptr),0); //发送数据
ev.data.fd = sockfd;
ev.events = EPOLLIN|EPOLLOUT;
epoll_ctl(epfd,EPOLL_CTL_MOD, sockfd, &ev);//修改描述符等待下次接受
}
else｛
｝
}
}应用：
2. // a simple echo server using epoll in linux
3. //
4.
9. #include <sys/socket.h>
10. #include <sys/epoll.h>
11. #include <netinet/in.h>
12. #include <arpa/inet.h>
13. #include <fcntl.h>
14. #include <unistd.h>
15. #include <stdio.h>
16. #include <errno.h>
17. #include <iostream>
18. using namespace std;
19. #define MAX_EVENTS 500
20. struct myevent_s
21. {
22. int fd;
23. void (*call_back)(int fd, int events, void *arg);
24. int events;
25. void *arg;
26. int status; // 1: in epoll wait list, 0 not in
27. char buff[128]; // recv data buffer
28. int len, s_offset;
29. long last_active; // last active time
30. };
31. // set event
32. void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), voi
d *arg)
33. {
34. ev->fd = fd;
35. ev->call_back = call_back;
36. ev->events = 0;
37. ev->arg = arg;
38. ev->status = 0;
39. bzero(ev->buff, sizeof(ev->buff));
40. ev->s_offset = 0;
41. ev->len = 0;
42. ev->last_active = time(NULL);
43. }
44. // add/mod an event to epoll
45. void EventAdd(int epollFd, int events, myevent_s *ev)
46. {
47. struct epoll_event epv = {0, {0}};
48. int op;
49. epv.data.ptr = ev;
50. epv.events = ev->events = events;
51. if(ev->status == 1){
52. op = EPOLL_CTL_MOD;
53. } 54. else{
55. op = EPOLL_CTL_ADD;
56. ev->status = 1;
57. }
58. if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)
59. printf("Event Add failed[fd=%d], evnets[%d]\n", ev->fd, events);
60. else
61. printf("Event Add OK[fd=%d], op=%d, evnets[%0X]\n", ev->fd, op, even
ts);
62. }
63. // delete an event from epoll
64. void EventDel(int epollFd, myevent_s *ev)
65. {
66. struct epoll_event epv = {0, {0}};
67. if(ev->status != 1) return;
68. epv.data.ptr = ev;
69. ev->status = 0;
70. epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);
71. }
72. int g_epollFd;
73. myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen
fd
74. void RecvData(int fd, int events, void *arg);
75. void SendData(int fd, int events, void *arg);
76. // accept new connections from clients
77. void AcceptConn(int fd, int events, void *arg)
78. {
79. struct sockaddr_in sin;
80. socklen_t len = sizeof(struct sockaddr_in);
81. int nfd, i;
82. // accept
83. if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)
84. {
85. if(errno != EAGAIN && errno != EINTR)
86. {
87. }
88. printf("%s: accept, %d", __func__, errno);
89. return;
90. }
91. do
92. {
93. for(i = 0; i < MAX_EVENTS; i++)
94. {
95. if(g_Events[i].status == 0) 96. {
97. break;
98. }
99. }
100. if(i == MAX_EVENTS)
101. {
102. printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);
103. break;
104. }
105. // set nonblocking
106. int iret = 0;
107. if((iret = fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)
108. {
109. printf("%s: fcntl nonblocking failed:%d", __func__, iret);
110. break;
111. }
112. // add a read event for receive data
113. EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);
114. EventAdd(g_epollFd, EPOLLIN, &g_Events[i]);
115. }while(0);
116. printf("new conn[%s:%d][time:%d], pos[%d]\n", inet_ntoa(sin.sin_addr),
117. ntohs(sin.sin_port), g_Events[i].last_active, i);
118. }
119. // receive data
120. void RecvData(int fd, int events, void *arg)
121. {
122. struct myevent_s *ev = (struct myevent_s*)arg;
123. int len;
124. // receive data
125. len = recv(fd, ev->buff+ev->len, sizeof(ev->buff)-1-ev->len, 0);
126. EventDel(g_epollFd, ev);
127. if(len > 0)
128. {
129. ev->len += len;
130. ev->buff[len] = '\0';
131. printf("C[%d]:%s\n", fd, ev->buff);
132. // change to send event
133. EventSet(ev, fd, SendData, ev);
134. EventAdd(g_epollFd, EPOLLOUT, ev);
135. }
136. else if(len == 0)
137. { 138. close(ev->fd);
139. printf("[fd=%d] pos[%d], closed gracefully.\n", fd, ev-g_Events);
140. }
141. else
142. {
143. close(ev->fd);
144. printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
145. }
146. }
147. // send data
148. void SendData(int fd, int events, void *arg)
149. {
150. struct myevent_s *ev = (struct myevent_s*)arg;
151. int len;
152. // send data
153. len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);
154. if(len > 0)
155. {
156. printf("send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);
157. ev->s_offset += len;
158. if(ev->s_offset == ev->len)
159. {
160. // change to receive event
161. EventDel(g_epollFd, ev);
162. EventSet(ev, fd, RecvData, ev);
163. EventAdd(g_epollFd, EPOLLIN, ev);
164. }
165. }
166. else
167. {
168. close(ev->fd);
169. EventDel(g_epollFd, ev);
170. printf("send[fd=%d] error[%d]\n", fd, errno);
171. }
172. }
173. void InitListenSocket(int epollFd, short port)
174. {
175. int listenFd = socket(AF_INET, SOCK_STREAM, 0);
176. fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking
177. printf("server listen fd=%d\n", listenFd);
178. EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVE
NTS]); 179. // add listen socket
180. EventAdd(epollFd, EPOLLIN, &g_Events[MAX_EVENTS]);
181. // bind & listen
182. sockaddr_in sin;
183. bzero(&sin, sizeof(sin));
184. sin.sin_family = AF_INET;
185. sin.sin_addr.s_addr = INADDR_ANY;
186. sin.sin_port = htons(port);
187. bind(listenFd, (const sockaddr*)&sin, sizeof(sin));
188. listen(listenFd, 5);
189. }
190. int main(int argc, char **argv)
191. {
192. unsigned short port = 12345; // default port
193. if(argc == 2){
194. port = atoi(argv[1]);
195. }
196. // create epoll
197. g_epollFd = epoll_create(MAX_EVENTS);
198. if(g_epollFd <= 0) printf("create epoll failed.%d\n", g_epollFd);
199. // create & bind listen socket, and add to epoll, set non-blocking
200. InitListenSocket(g_epollFd, port);
201. // event loop
202. struct epoll_event events[MAX_EVENTS];
203. printf("server running:port[%d]\n", port);
204. int checkPos = 0;
205. while(1){
206. // a simple timeout check here, every time 100, better to use a min
i-heap, and add timer event
207. long now = time(NULL);
208. for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd
209. {
210. if(checkPos == MAX_EVENTS) checkPos = 0; // recycle
211. if(g_Events[checkPos].status != 1) continue;
212. long duration = now - g_Events[checkPos].last_active;
213. if(duration >= 60) // 60s timeout
214. {
215. close(g_Events[checkPos].fd);
216. printf("[fd=%d] timeout[%d--%d].\n", g_Events[checkPos].fd,
g_Events[checkPos].last_active, now);
217. EventDel(g_epollFd, &g_Events[checkPos]);
218. }
219. } 220. // wait for events to happen
221. int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);
222. if(fds < 0){
223. printf("epoll_wait error, exit\n");
224. break;
225. }
226. for(int i = 0; i < fds; i++){
227. myevent_s *ev = (struct myevent_s*)events[i].data.ptr;
228. if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read ev
ent
229. {
230. ev->call_back(ev->fd, events[i].events, ev->arg);
231. }
232. if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write
event
233. {
234. ev->call_back(ev->fd, events[i].events, ev->arg);
235. }
236. }
237. }
238. // free resource
239. return 0;
240. } 
扫一扫
2049
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
