Epoll
物件的建立
- 在
linux
中,最為高效的 reactor
機制就是 epoll
。swReactor
的 object
會儲存 epoll
的物件 swReactorEpoll_s
。該資料結構中 epfd
是 epoll
的 id
,events
用於在 epoll_wait
函式接受就緒的事件。
- 該函式最重要的是
epoll_create
,該函式會建立 epoll
物件
typedef struct swReactorEpoll_s swReactorEpoll;
struct swReactorEpoll_s
{
int epfd;
struct epoll_event *events;
};
int swReactorEpoll_create(swReactor *reactor, int max_event_num)
{
//create reactor object
swReactorEpoll *reactor_object = sw_malloc(sizeof(swReactorEpoll));
if (reactor_object == NULL)
{
swWarn("malloc[0] failed.");
return SW_ERR;
}
bzero(reactor_object, sizeof(swReactorEpoll));
reactor->object = reactor_object;
reactor->max_event_num = max_event_num;
reactor_object->events = sw_calloc(max_event_num, sizeof(struct epoll_event));
if (reactor_object->events == NULL)
{
swWarn("malloc[1] failed.");
sw_free(reactor_object);
return SW_ERR;
}
//epoll create
reactor_object->epfd = epoll_create(512);
if (reactor_object->epfd < 0)
{
swWarn("epoll_create failed. Error: %s[%d]", strerror(errno), errno);
sw_free(reactor_object);
return SW_ERR;
}
//binding method
reactor->add = swReactorEpoll_add;
reactor->set = swReactorEpoll_set;
reactor->del = swReactorEpoll_del;
reactor->wait = swReactorEpoll_wait;
reactor->free = swReactorEpoll_free;
return SW_OK;
}
Epoll
新增監聽
swReactorEpoll_event_set
函式用於轉化可讀(SW_EVENT_READ
)、可寫(SW_EVENT_WRITE
)的狀態為 epoll
函式可用的 EPOLLIN
、EPOLLOUT
、EPOLLERR
static sw_inline int swReactorEpoll_event_set(int fdtype)
{
uint32_t flag = 0;
if (swReactor_event_read(fdtype))
{
flag |= EPOLLIN;
}
if (swReactor_event_write(fdtype))
{
flag |= EPOLLOUT;
}
if (swReactor_event_error(fdtype))
{
//flag |= (EPOLLRDHUP);
flag |= (EPOLLRDHUP | EPOLLHUP | EPOLLERR);
}
return flag;
}
swReactorEpoll_add
函式用於為 reactor
新增新的檔案描述符進行監控
- 新增
fd
最為重要的的是利用 epoll_ctl
函式的 EPOLL_CTL_ADD
命令。為了能夠更為簡便在呼叫 epoll_wait
後獲取 fd
的型別,並不會僅僅向 epoll_ctl
函式新增 fd
,而是會新增 swFd
型別,該資料結構中包含檔案描述符和檔案型別。
swReactor_add
函式用於更新 reactor->socket_list
的 fdtype
與 events
- 最後需要自增
event_num
的數值
typedef struct _swFd
{
uint32_t fd;
uint32_t fdtype;
} swFd;
static int swReactorEpoll_add(swReactor *reactor, int fd, int fdtype)
{
swReactorEpoll *object = reactor->object;
struct epoll_event e;
swFd fd_;
bzero(&e, sizeof(struct epoll_event));
fd_.fd = fd;
fd_.fdtype = swReactor_fdtype(fdtype);
e.events = swReactorEpoll_event_set(fdtype);
swReactor_add(reactor, fd, fdtype);
memcpy(&(e.data.u64), &fd_, sizeof(fd_));
if (epoll_ctl(object->epfd, EPOLL_CTL_ADD, fd, &e) < 0)
{
swSysError("add events[fd=%d#%d, type=%d, events=%d] failed.", fd, reactor->id, fd_.fdtype, e.events);
swReactor_del(reactor, fd);
return SW_ERR;
}
swTraceLog(SW_TRACE_EVENT, "add event[reactor_id=%d, fd=%d, events=%d]", reactor->id, fd, swReactor_events(fdtype));
reactor->event_num++;
return SW_OK;
}
static sw_inline void swReactor_add(swReactor *reactor, int fd, int type)
{
swConnection *socket = swReactor_get(reactor, fd);
socket->fdtype = swReactor_fdtype(type);
socket->events = swReactor_events(type);
socket->removed = 0;
}
Epoll
修改監聽
- 修改監聽主要呼叫
epoll_ctl
的 EPOLL_CTL_MOD
命令
static int swReactorEpoll_set(swReactor *reactor, int fd, int fdtype)
{
swReactorEpoll *object = reactor->object;
swFd fd_;
struct epoll_event e;
int ret;
bzero(&e, sizeof(struct epoll_event));
e.events = swReactorEpoll_event_set(fdtype);
if (e.events & EPOLLOUT)
{
assert(fd > 2);
}
fd_.fd = fd;
fd_.fdtype = swReactor_fdtype(fdtype);
memcpy(&(e.data.u64), &fd_, sizeof(fd_));
ret = epoll_ctl(object->epfd, EPOLL_CTL_MOD, fd, &e);
if (ret < 0)
{
swSysError("reactor#%d->set(fd=%d|type=%d|events=%d) failed.", reactor->id, fd, fd_.fdtype, e.events);
return SW_ERR;
}
swTraceLog(SW_TRACE_EVENT, "set event[reactor_id=%d, fd=%d, events=%d]", reactor->id, fd, swReactor_events(fdtype));
//execute parent method
swReactor_set(reactor, fd, fdtype);
return SW_OK;
}
Epoll
刪除監聽
- 修改監聽主要呼叫
epoll_ctl
的 EPOLL_CTL_DEL
命令
- 最後需要更新
event_num
static int swReactorEpoll_del(swReactor *reactor, int fd)
{
swReactorEpoll *object = reactor->object;
if (epoll_ctl(object->epfd, EPOLL_CTL_DEL, fd, NULL) < 0)
{
swSysError("epoll remove fd[%d#%d] failed.", fd, reactor->id);
return SW_ERR;
}
swTraceLog(SW_TRACE_REACTOR, "remove event[reactor_id=%d|fd=%d]", reactor->id, fd);
reactor->event_num = reactor->event_num <= 0 ? 0 : reactor->event_num - 1;
swReactor_del(reactor, fd);
return SW_OK;
}
Epoll
監聽等待就緒
swReactorEpoll_wait
是 reactor
的核心,該函式最重要的就是呼叫 epoll_wait
- 首先需要通過
timeo
引數設定 msec
,利用 object->events
設定 events
epoll_wait
函式返回之後,如果 n<0
,那麼需要先檢查 erron
,如果是 EINTR
,那麼說明有訊號觸發,此時需要進行訊號的回撥函式,然後再繼續事件迴圈。如果不是 EINTR
,那麼就要返回錯誤,結束事件迴圈
- 如果
n == 0
,一般是由於 epoll_wait
已超時,此時需要呼叫超時回撥函式
- 如果
n > 0
,那麼就要從 events
中取出已經就緒的 swFd
物件,並利用該物件的值初始化 event
- 接下來就要檢查
events[i].events
的值,來判斷具體是讀就緒、寫就緒還是發生了錯誤,值得注意的是 EPOLLRDHUP
事件,此事件代表著對端斷開連線,這個是 linux
自從 2.6.17
的新特性
- 利用
swReactor_getHandle
函式取出對應的檔案描述符型別的事件回撥函式
- 事件迴圈的最後呼叫
onFinish
函式
- 如果設定了
once
,說明此 reactor
只會迴圈一次,立即退出;否則,繼續事件迴圈
typedef struct _swEvent
{
int fd;
int16_t from_id;
uint8_t type;
swConnection *socket;
} swEvent;
static int swReactorEpoll_wait(swReactor *reactor, struct timeval *timeo)
{
swEvent event;
swReactorEpoll *object = reactor->object;
swReactor_handle handle;
int i, n, ret, msec;
int reactor_id = reactor->id;
int epoll_fd = object->epfd;
int max_event_num = reactor->max_event_num;
struct epoll_event *events = object->events;
if (reactor->timeout_msec == 0)
{
if (timeo == NULL)
{
reactor->timeout_msec = -1;
}
else
{
reactor->timeout_msec = timeo->tv_sec * 1000 + timeo->tv_usec / 1000;
}
}
reactor->start = 1;
while (reactor->running > 0)
{
if (reactor->onBegin != NULL)
{
reactor->onBegin(reactor);
}
msec = reactor->timeout_msec;
n = epoll_wait(epoll_fd, events, max_event_num, msec);
if (n < 0)
{
if (swReactor_error(reactor) < 0)
{
swWarn("[Reactor#%d] epoll_wait failed. Error: %s[%d]", reactor_id, strerror(errno), errno);
return SW_ERR;
}
else
{
continue;
}
}
else if (n == 0)
{
if (reactor->onTimeout != NULL)
{
reactor->onTimeout(reactor);
}
continue;
}
for (i = 0; i < n; i++)
{
event.fd = events[i].data.u64;
event.from_id = reactor_id;
event.type = events[i].data.u64 >> 32;
event.socket = swReactor_get(reactor, event.fd);
//read
if ((events[i].events & EPOLLIN) && !event.socket->removed)
{
handle = swReactor_getHandle(reactor, SW_EVENT_READ, event.type);
ret = handle(reactor, &event);
if (ret < 0)
{
swSysError("EPOLLIN handle failed. fd=%d.", event.fd);
}
}
//write
if ((events[i].events & EPOLLOUT) && !event.socket->removed)
{
handle = swReactor_getHandle(reactor, SW_EVENT_WRITE, event.type);
ret = handle(reactor, &event);
if (ret < 0)
{
swSysError("EPOLLOUT handle failed. fd=%d.", event.fd);
}
}
//error
#ifndef NO_EPOLLRDHUP
if ((events[i].events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP)) && !event.socket->removed)
#else
if ((events[i].events & (EPOLLERR | EPOLLHUP)) && !event.socket->removed)
#endif
{
//ignore ERR and HUP, because event is already processed at IN and OUT handler.
if ((events[i].events & EPOLLIN) || (events[i].events & EPOLLOUT))
{
continue;
}
handle = swReactor_getHandle(reactor, SW_EVENT_ERROR, event.type);
ret = handle(reactor, &event);
if (ret < 0)
{
swSysError("EPOLLERR handle failed. fd=%d.", event.fd);
}
}
}
if (reactor->onFinish != NULL)
{
reactor->onFinish(reactor);
}
if (reactor->once)
{
break;
}
}
return 0;
}
static sw_inline int swReactor_error(swReactor *reactor)
{
switch (errno)
{
case EINTR:
if (reactor->singal_no)
{
swSignal_callback(reactor->singal_no);
reactor->singal_no = 0;
}
return SW_OK;
}
return SW_ERR;
}
static sw_inline swReactor_handle swReactor_getHandle(swReactor *reactor, int event_type, int fdtype)
{
if (event_type == SW_EVENT_WRITE)
{
return (reactor->write_handle[fdtype] != NULL) ? reactor->write_handle[fdtype] : reactor->handle[SW_FD_WRITE];
}
else if (event_type == SW_EVENT_ERROR)
{
return (reactor->error_handle[fdtype] != NULL) ? reactor->error_handle[fdtype] : reactor->handle[SW_FD_CLOSE];
}
return reactor->handle[fdtype];
}
本作品採用《CC 協議》,轉載必須註明作者和本文連結