重要参考：
http://bbs.chinaunix.net/thread-1251434-2-1.html
http://bbs.chinaunix.net/thread-1251434-4-1.html
http://www.cnblogs.com/kernel_hcy/archive/2010/03/22/1691951.html
lighttpd对网络的I/O事件进行了封装，并且实现了几种事件处理器。可以通过配置文件来选择使用哪种事件处理器。可以使用的事件处理器有：select、poll、epoll等。
对网络I/O事件的封装
使用fdnode表示一个文件描述符相关的处理器、关心的事件等。当关心的事件events发生时，就使用相应的处理器handler来处理。
typedef struct _fdnode {
fdevent_handler handler; // 该描述符对应的处理器，回调函数，事件触发时进行回调
void *ctx; // context，上下文相关
void *handler_ctx;
int fd; // file descriptor ： 文件描述符， 是socket fd, 可能是服务器监听的所有的fd（监听套接字）, 也可能是accept之后与client相关的fd（已连接套接字）
int events; // 对该fd的所关心的事件
} fdnode;如果该fd是服务器监听客户端连接的fd, 那么handler = network_server_handle_fdevent(在network.c文件中), ctx保存的就是server指针;如果该fd是accapt客户端连接之后的fd, 那么handler = connection_handle_fdevent(在connections.c文件中), ctx保存的就是connection指针.
对网络的I/O事件进行了封装，使用结构体 fdevents表示。
参考文章中的讲解非常到位，这里再次体现了面向对象思想。fdevents相当于一个虚基类，它包含了一些”public”成员：srv、type、fdarray、maxfds。派生类继承该虚基类后，都会包含这些public成员。
此外，根据编译时的预编译宏, 该结构体还能包含其它的成员, 这些成员就相当于OO中派生类自己私有的成员.
在这个结构体的最后, 是一组函数指针, 也就是OO中的纯虚函数, 每个派生类都要根据这些接口自己进行实现
typedef struct fdevents {
struct server *srv;
fdevent_handler_t type; // 事件处理器的类型
fdnode **fdarray; // 需要处理的“文件描述符”的数组
size_t maxfds; // fdarray最大大小
#ifdef USE_LINUX_EPOLL
int epoll_fd;
struct epoll_event *epoll_events;
#endif
#ifdef USE_POLL
struct pollfd *pollfds;
size_t size;
size_t used;
buffer_int unused;
#endif
#ifdef USE_SELECT
fd_set select_read;
fd_set select_write;
fd_set select_error;
fd_set select_set_read;
fd_set select_set_write;
fd_set select_set_error;
int select_max_fd;
#endif
#ifdef USE_SOLARIS_DEVPOLL
int devpoll_fd;
struct pollfd *devpollfds;
#endif
#ifdef USE_SOLARIS_PORT
port_event_t *port_events;
#endif
#ifdef USE_FREEBSD_KQUEUE
int kq_fd;
struct kevent *kq_results;
#endif
#ifdef USE_SOLARIS_PORT
int port_fd;
#endif
#ifdef USE_LIBEV
struct ev_loop *libev_loop;
#endif
int (*reset)(struct fdevents *ev);
void (*free)(struct fdevents *ev);
int (*event_set)(struct fdevents *ev, int fde_ndx, int fd, int events);
int (*event_del)(struct fdevents *ev, int fde_ndx, int fd);
int (*event_get_revent)(struct fdevents *ev, size_t ndx);
int (*event_get_fd)(struct fdevents *ev, size_t ndx);
int (*event_next_fdndx)(struct fdevents *ev, int ndx);
int (*poll)(struct fdevents *ev, int timeout_ms);
int (*fcntl_set)(struct fdevents *ev, int fd);
} fdevents;
事件处理器 :Event Handler
I/O多路复用技术有：select, poll, epoll (下面称为事件处理器，event-handler)。lighttpd可以通过配置文件来选择使用某种event handler， 例如：
server.event-handler = “linux-sysepoll”
表示事件处理器为 epoll。
lighttpd支持的事件处理器如下表所示：
============ ========== ===============
OS Method Config Value
============ ========== ===============
all select select
Unix poll poll
Linux 2.4+ rt-signals linux-rtsig
Linux 2.6+ epoll linux-sysepoll
Solaris /dev/poll solaris-devpoll
FreeBSD, ... kqueue freebsd-kqueue
============ ========== ===============fdevent_handler_t表示事件处理器的类型：
typedef enum { FDEVENT_HANDLER_UNSET,
FDEVENT_HANDLER_SELECT, // select
FDEVENT_HANDLER_POLL, // poll
FDEVENT_HANDLER_LINUX_SYSEPOLL, // epoll
FDEVENT_HANDLER_SOLARIS_DEVPOLL,
FDEVENT_HANDLER_SOLARIS_PORT,
FDEVENT_HANDLER_FREEBSD_KQUEUE,
FDEVENT_HANDLER_LIBEV
} fdevent_handler_t;- 初始化
worker被创建好之后，就进入了I/O事件的处理过程。
首先是初始化一个fdevents结构体，通过函数fdevent_init完成。其中srv->event_handler表示handler的类型，如上所述，这是通过读取配置文件来获得的。fdevents创建好之后保存在srv->ev中。
srv->ev = fdevent_init(srv, srv->max_fds + 1, srv->event_handler)如果我们选择的是select，那么最终会调用fdevent_select_init()来完成初始化操作。初始化的过程其实就是给函数指针赋值的过程（体现了多态），让函数指针指向select的相关函数（通过宏SET(X)，使得代码更简洁，清晰）
int fdevent_select_init(fdevents *ev) {
ev->type = FDEVENT_HANDLER_SELECT;
#define SET(x) \
ev->x = fdevent_select_##x;
SET(reset);
SET(poll);
SET(event_del);
SET(event_set);
SET(event_next_fdndx);
SET(event_get_fd);
SET(event_get_revent);
return 0;
}
- 注册
在服务器创建一个socket fd并且进行监听后, 要将该fd注册到fdevent中, 这样才能使用使用这个事件处理机制.在server.c文件的main函数中, 调用network_register_fdevents函数将所有监听的fd注册到事件处理器中。
当有客户端请求连接时，监听套接字的FDEVENT_IN事件发生，函数network_server_handle_fdevent被调用，该函数会accept此连接，然后将连接后的socket fd再次注册到fdevent中（connection_accept调用fdevent_register），处理器为connection_handle_fdevent
// network.c
// 将worker的监听套接字注册到fdevent中，handler为network_server_handle_fdevent，关心的事件event为FDEVENT_IN，即：有客户端连接时，触发该事件，进而调用handler进行处理（这里就是network_server_handle_fdevent）
int network_register_fdevents(server *srv) {
size_t i;
if (-1 == fdevent_reset(srv->ev)) {
return -1;
}
/* register fdevents after reset */
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_register(srv->ev, srv_socket->fd, network_server_handle_fdevent, srv_socket); // 注册fd
fdevent_event_set(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN); // 设置关心的事件
}
return 0;
}
// 服务器监听套接字的handler，当有客户端请求连接时被调用
static handler_t network_server_handle_fdevent(server *srv, void *context, int revents) {
...
if (0 == (revents & FDEVENT_IN)) { // 判断事件是否发生了
...
return HANDLER_ERROR;
}
/* accept()s at most 100 connections directly
*
* we jump out after 100 to give the waiting connections a chance */
for (loops = 0; loops < 100 && NULL != (con = connection_accept(srv, srv_socket)); loops++) { // 接收该请求，并注册到fdevent中(srv->ev),handler为connection_handle_fdevent
handler_t r;
connection_state_machine(srv, con);
switch(r = plugins_call_handle_joblist(srv, con)) {
case HANDLER_FINISHED:
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
}
return HANDLER_GO_ON;
}// fdevent.c
// 给描述符fd创建一个fdnode，然后加入到ev中
int fdevent_register(fdevents *ev, int fd, fdevent_handler handler, void *ctx) {
fdnode *fdn;
fdn = fdnode_init();
fdn->handler = handler;
fdn->fd = fd;
fdn->ctx = ctx;
fdn->handler_ctx = NULL;
fdn->events = 0;
ev->fdarray[fd] = fdn; // 使用fd作为下标进行索引
return 0;
}
int fdevent_event_set(fdevents *ev, int *fde_ndx, int fd, int events) {
int fde = fde_ndx ? *fde_ndx : -1;
if (ev->event_set) fde = ev->event_set(ev, fde, fd, events);
ev->fdarray[fd]->events = events;
if (fde_ndx) *fde_ndx = fde;
return 0;
}
- 事件处理
在将服务器监听fd注册到网络IO事件处理器中之后, 这个处理器就要开始循环处理了, 在server.c中的main.c函数中是这个轮询的主过程:
if ((n = fdevent_poll(srv->ev, 1000)) > 0) { // 会调用前面设置好的srv->ev->poll进行处理（体现了“多态”）。其中n是事件个数
/* n is the number of events */
int revents;
int fd_ndx;
#if 0
if (n > 0) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"polls:", n);
}
#endif
// 循环处理n个事件
fd_ndx = -1;
do {
fdevent_handler handler;
void *context;
handler_t r;
fd_ndx = fdevent_event_next_fdndx (srv->ev, fd_ndx); // 返回需要处理的fd的索引fd_ndx
if (-1 == fd_ndx) break; /* not all fdevent handlers know how many fds got an event */
// 通过该索引，得到事件revents，fd，handler，context
// 最终掉用 (*handler)(srv, context, revents)进行处理
revents = fdevent_event_get_revent (srv->ev, fd_ndx);
fd = fdevent_event_get_fd (srv->ev, fd_ndx);
handler = fdevent_get_handler(srv->ev, fd);
context = fdevent_get_context(srv->ev, fd);
/* connection_handle_fdevent needs a joblist_append */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sdd",
"event for", fd, revents);
#endif
switch (r = (*handler)(srv, context, revents)) {
case HANDLER_FINISHED:
case HANDLER_GO_ON:
case HANDLER_WAIT_FOR_EVENT:
case HANDLER_WAIT_FOR_FD:
break;
case HANDLER_ERROR:
/* should never happen */
SEGFAULT();
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
} while (--n > 0);简单的说, 这个过程就是:首先调用poll函数指针获取相关网络IO被触发的事件数, 保存在整型变量n中, 然后根据这个n值进行以下循环, 每次处理完n值减一, 为0之后退出, 这个循环的大致过程是: 首先获取下一个被触发的网络事件在fdnode数组中的索引, 接着根据该索引获取相关的事件类型, fd, 回调函数, contex, ,接着根据这些调用回调函数(也就是我们上面提到的函数 network_server_handle_fdevent和connection_handle_fdevent), 请注意, 在本节的最开始部分曾经提到过fdevent.h中声明的函数都是对外暴露的fdevent结构体”public函数”, 在上面这个轮询的过程中使用的正是这些”public函数”, 在这些”public函数”中再根据曾经初始化的函数指针进行调用, 实现了OO中所谓的”多态”.
以上就是通过fdevent结构体实现的网络IO处理器模型, 在这里体现如何使用C实现OO面向对象编程的种种常用技巧,不放在本节最后做一个总结:
1) fdevent结构体是一个虚拟基类, 其中的函数指针就是虚拟基类中的纯虚函数, 由具体实现去初始化之.fdevent结构体中的对象为所有派生类的公共成员, 而用各个预编译宏包围的成员则是各个派生类的私有成员.
2) 在fdevent.h中声明的函数可以理解为虚拟基类对外暴露的接口, 也就是public函数.
3) 各个具体的实现分别是各个实现C文件中的静态函数, 也就是派生类的private函数.
如果阅读到这里仍然对lighttpd中网络IO处理器模型有疑问, 可以具体参看前面提到的fdevent.h/c文件, 以及以fdevent_为前缀的c文件.
扫一扫
1642
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
