linux epoll机制详解

struct eventpoll{
 ....
 /*红黑树的根节点，这颗树中存储着所有添加到epoll中的需要监控的事件*/
 struct rb_root rbr;
 /*双链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件*/
 struct list_head rdlist;
 ....
};

struct epitem{
 struct rb_node rbn;//红黑树节点
 struct list_head rdllink;//双向链表节点
 struct epoll_filefd ffd; //事件句柄信息
 struct eventpoll *ep; //指向其所属的eventpoll对象
 struct epoll_event event; //期待发生的事件类型
}

typedef union epoll_data { 
void *ptr; 
int fd; 
__uint32_t u32; 
__uint64_t u64; 
} epoll_data_t; 

struct epoll_event { 
__uint32_t events; /* Epoll events */ 
epoll_data_t data; /* User data variable */ 
}; 

struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

/*
* file epollTest.c
*/
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <errno.h> 
#include <sys/socket.h> 
#include <netdb.h> 
#include <fcntl.h> 
#include <sys/epoll.h> 
#include <string.h> 
#define MAXEVENTS 64 
//函数: 
//功能:创建和绑定一个TCP socket 
//参数:端口 
//返回值:创建的socket 
static int 
create_and_bind (char *port) 
{ 
struct addrinfo hints; 
struct addrinfo *result, *rp; 
int s, sfd; 
memset (&hints, 0, sizeof (struct addrinfo)); 
hints.ai_family = AF_UNSPEC;  /* Return IPv4 and IPv6 choices */ 
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */ 
hints.ai_flags = AI_PASSIVE;  /* All interfaces */ 
s = getaddrinfo (NULL, port, &hints, &result); 
if (s != 0) 
{ 
fprintf (stderr, "getaddrinfo: %sn", gai_strerror (s)); 
return -1; 
} 
for (rp = result; rp != NULL; rp = rp->ai_next) 
{ 
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol); 
if (sfd == -1) 
continue; 
s = bind (sfd, rp->ai_addr, rp->ai_addrlen); 
if (s == 0) 
{ 
/* We managed to bind successfully! */ 
break; 
} 
close (sfd); 
} 
if (rp == NULL) 
{ 
fprintf (stderr, "Could not bindn"); 
return -1; 
} 
freeaddrinfo (result); 
return sfd; 
} 
//函数 
//功能:设置socket为非阻塞的 
static int 
make_socket_non_blocking (int sfd) 
{ 
int flags, s; 
//得到文件状态标志 
flags = fcntl (sfd, F_GETFL, 0); 
if (flags == -1) 
{ 
perror ("fcntl"); 
return -1; 
} 
//设置文件状态标志 
flags |= O_NONBLOCK; 
s = fcntl (sfd, F_SETFL, flags); 
if (s == -1) 
{ 
perror ("fcntl"); 
return -1; 
} 
return 0; 
} 
//端口由参数argv[1]指定 
int 
main (int argc, char *argv[]) 
{ 
int sfd, s; 
int efd; 
struct epoll_event event; 
struct epoll_event *events; 
if (argc != 2) 
{ 
fprintf (stderr, "Usage: %s [port]n", argv[0]); 
exit (EXIT_FAILURE); 
} 
sfd = create_and_bind (argv[1]); 
if (sfd == -1) 
abort (); 
s = make_socket_non_blocking (sfd); 
if (s == -1) 
abort (); 
s = listen (sfd, SOMAXCONN); 
if (s == -1) 
{ 
perror ("listen"); 
abort (); 
} 
//除了参数size被忽略外,此函数和epoll_create完全相同 
efd = epoll_create1 (0); 
if (efd == -1) 
{ 
perror ("epoll_create"); 
abort (); 
} 
event.data.fd = sfd; 
event.events = EPOLLIN | EPOLLET;//读入,边缘触发方式 
s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event); 
if (s == -1) 
{ 
perror ("epoll_ctl"); 
abort (); 
} 
/* Buffer where events are returned */ 
events = calloc (MAXEVENTS, sizeof event); 
/* The event loop */ 
while (1) 
{ 
int n, i; 
n = epoll_wait (efd, events, MAXEVENTS, -1); 
for (i = 0; i < n; i++) 
{ 
if ((events[i].events & EPOLLERR) || 
(events[i].events & EPOLLHUP) || 
(!(events[i].events & EPOLLIN))) 
{ 
/* An error has occured on this fd, or the socket is not 
ready for reading (why were we notified then?) */ 
fprintf (stderr, "epoll errorn"); 
close (events[i].data.fd); 
continue; 
} 
else if (sfd == events[i].data.fd) 
{ 
/* We have a notification on the listening socket, which 
means one or more incoming connections. */ 
while (1) 
{ 
struct sockaddr in_addr; 
socklen_t in_len; 
int infd; 
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV]; 
in_len = sizeof in_addr; 
infd = accept (sfd, &in_addr, &in_len); 
if (infd == -1) 
{ 
if ((errno == EAGAIN) || 
(errno == EWOULDBLOCK)) 
{ 
/* We have processed all incoming 
connections. */ 
break; 
} 
else 
{ 
perror ("accept"); 
break; 
} 
} 
//将地址转化为主机名或者服务名 
s = getnameinfo (&in_addr, in_len, 
hbuf, sizeof hbuf, 
sbuf, sizeof sbuf, 
NI_NUMERICHOST | NI_NUMERICSERV);//flag参数:以数字名返回 
//主机地址和服务地址 
if (s == 0) 
{ 
printf("Accepted connection on descriptor %d " 
"(host=%s, port=%s)n", infd, hbuf, sbuf); 
} 
/* Make the incoming socket non-blocking and add it to the 
list of fds to monitor. */ 
s = make_socket_non_blocking (infd); 
if (s == -1) 
abort (); 
event.data.fd = infd; 
event.events = EPOLLIN | EPOLLET; 
s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event); 
if (s == -1) 
{ 
perror ("epoll_ctl"); 
abort (); 
} 
} 
continue; 
} 
else 
{ 
/* We have data on the fd waiting to be read. Read and 
display it. We must read whatever data is available 
completely, as we are running in edge-triggered mode 
and won't get a notification again for the same 
data. */ 
int done = 0; 
while (1) 
{ 
ssize_t count; 
char buf[512]; 
count = read (events[i].data.fd, buf, sizeof(buf)); 
if (count == -1) 
{ 
/* If errno == EAGAIN, that means we have read all 
data. So go back to the main loop. */ 
if (errno != EAGAIN) 
{ 
perror ("read"); 
done = 1; 
} 
break; 
} 
else if (count == 0) 
{ 
/* End of file. The remote has closed the 
connection. */ 
done = 1; 
break; 
} 
/* Write the buffer to standard output */ 
s = write (1, buf, count); 
if (s == -1) 
{ 
perror ("write"); 
abort (); 
} 
} 
if (done) 
{ 
printf ("Closed connection on descriptor %dn", 
events[i].data.fd); 
/* Closing the descriptor will make epoll remove it 
from the set of descriptors which are monitored. */ 
close (events[i].data.fd); 
} 
} 
} 
} 
free (events); 
close (sfd); 
return EXIT_SUCCESS; 
}