lighttpd代码分析

watcher,worker模型

lighttpd是目前非常流行的web服务器,很多流量非常大的网站(如youtube)使用的就是lighttpd,它的代码量不多,但是设计巧妙,效率高,功能完备(这是它将来能取代Apache的重要因素),编码风格优美, 是学习网络编程,熟悉http服务器编写的良好范例.在我初学网络编程的时候,就是看的lighttpd的源码进行学习,在其中学到了不少的技巧.我打算将这些写出来与别人分享,可能开始比较杂乱,也不会作完全的分析,因为很多部分的代码我也没有看过,写一点是一点吧.我进行阅读和分析的lighttpd版本是1.4.18.

lighttpd采用的是多进程+多路复用(如select,epoll)的网络模型,它对多路复用IO操作的封装将作为下一个专题的内容,本次将讲解它所采用的多进程模型.

lighttpd中的配置文件有一项server.max-worker配置的是服务器生成的工作进城数.在lighttpd中, 服务器主进程被称为watcher(监控者),而由这个主进程创建出来的子进程被称为woker(工作者),而woker的数量正是由上面提到的配置项进行配置的.watcher创建并且监控woker的代码如下所示,我觉得这是一段很巧妙的代码,在我阅读了这段代码之后,到目前为止,我所写的所有服务器采用的都是类似lighttpd的watcher-woker多进程模型,这段代码在src目录中server.c文件的main函数中:

#ifdef HAVE_FORK

    /* start watcher and workers */

    num_childs = srv->srvconf.max_worker;

    if (num_childs > 0) {

        int child = 0;

        while (!child && !srv_shutdown && !graceful_shutdown) {

            if (num_childs > 0) {

                switch (fork()) {

                case -1:

                    return -1;

                case 0:

                    child = 1;

                    break;

                default:

                    num_childs--;

                    break;

                }

            } else {

                int status;



                if (-1 != wait(&status)) {

                    /** 

                     * one of our workers went away 

                     */

                    num_childs++;

                } else {

                    switch (errno) {

                    case EINTR:

                        /**

                         * if we receive a SIGHUP we have to close our logs ourself as we don't 

                         * have the mainloop who can help us here

                         */

                        if (handle_sig_hup) {

                            handle_sig_hup = 0;



                            log_error_cycle(srv);



                            /**

                             * forward to all procs in the process-group

                             * 

                             * we also send it ourself

                             */

                            if (!forwarded_sig_hup) {

                                forwarded_sig_hup = 1;

                                kill(0, SIGHUP);

                            }

                        }

                        break;

                    default:

                        break;

                    }

                }

            }

        }



        /**

         * for the parent this is the exit-point 

         */

        if (!child) {

            /** 

             * kill all children too 

             */

            if (graceful_shutdown) {

                kill(0, SIGINT);

            } else if (srv_shutdown) {

                kill(0, SIGTERM);

            }



            log_error_close(srv);

            network_close(srv);

            connections_free(srv);

            plugins_free(srv);

            server_free(srv);

            return 0;

        }

    }

#endif

(二)--fdevents结构体解析

(三)--网络IO事件处理器的使用

上一节已经对lighttpd中的fdevent结构体进行了分析,前面提过,fdevent结构体是网络IO事件处理器的"虚拟基类",提供了网络IO事件处理器的公共成员,私有成员以及对外接口,这一节将对这个事件处理器的实现和使用进行解析.与这些相关的文件有这些:fdevent.h提供了fdevent结构体的定义, 在这个头文件中声明的函数可以看作是fdevent这个结构体对外暴露的接口, 也就是OO中所谓的类public函数, fdevent.c则是这些函数的实现,而以fdevent_为开头的几个C文件则是不同的网络IO模型的实现,比如fdevent_select.c文件是select模型的实现.我不打算对各种类型的网络IO模型做详细的介绍,事实上,所有这里用到的网络IO模型,我只用过select和epoll,所以我打算以select模型为例展开这里的讨论,因为select是相对而言用的最多也是大多数人在学习多路复用IO的时候学到的第一个模型,即使在epoll横行的今天,select模型仍然有着它的一席之地.

1)初始化
如何配置使用的是哪种网络IO模型?在配置文件中有一项server.event-handler就是配置需要使用的网络IO的,比如server.event-handler="select"就是选择select, 其它的配置字符串参见前一节最开始提到的那些类型.服务器在初始化的时候读取该配置项, 将网络IO事件类型存放在结构体server的成员event_handler中.
接着, 在server.c的main函数中服务器调用fdevent_init(size_t maxfds, fdevent_handler_t type)初始化一个fdevents指针, 返回的结果存放在server结构体中的ev成员中.
在这个函数中, 根据type参数进行初始化, 生成具体各种不同类型的fdevents指针, 这些初始化的函数都是以init为后缀的, 而所有具体实现的文件名为
fdevent_***.c(如fdevent_select.c是select模型的实现), 对外暴露的仅仅是那个以init为后缀的函数, 而上面那些函数接口的实现全都是这些文件中
静态函数, 很好的限制了它们的使用范围, 做到了信息隐藏, 这些函数可以看作是类中的私有函数, 以select模型为例:
对外暴露的初始化函数是fdevent_select_init, 它在fdevent.h中声明, 也就是说这个函数是对外暴露的, 而这个函数在fdevent_select.c被定义:

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_add);

    SET(event_next_fdndx);
    SET(event_get_fd);
    SET(event_get_revent);

    return 0 ;
}

查看fdevent_secelt.c文件,可以看到,名为fdevent_select_***的函数都是这个文件的静态函数, 再从面向对象的观点出发,这些函数属于采用select模型实现的fdevent的"私有函数", 如此做法, 很好的满足了所谓的"信息隐藏".

2) 使用
在服务器创建一个socket fd并且进行监听后, 要将该fd注册到fdevent中, 这样才能使用使用这个事件处理机制.
在server.c文件的main函数中, 调用network_register_fdevents函数将所有监听的fd注册到事件处理器中:

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);
        fdevent_event_add(srv -> ev, & (srv_socket -> fde_ndx), srv_socket -> fd, FDEVENT_IN);
    }
    return 0 ;
}

关键是在循环体中的两个函数, fdevent_register的第三个参数是一个回调函数, 就是fdevents的成员fdarray中每个fdnode的成员handler:

int fdevent_register(fdevents * ev, int fd, fdevent_handler handler, void * ctx) {
    fdnode * fdn;

    // 分配一个fdnode指针
    fdn = fdnode_init();

    // 保存回调函数
    fdn -> handler = handler;
    // 保存fd
    fdn -> fd      = fd;
    // 保存context 对server是server为socket指针, 对client是connection指针
    fdn -> ctx     = ctx;

    // 以fd为索引在fdarray中保存这个fdnode
    ev -> fdarray[fd] = fdn;

    return 0 ;
}

这里有一个小技巧, 函数中的倒数第二行, 以fd为索引保存fdnode, 因为这里的fdarray是一个数组, 因此这个方法可以以O(1)的速度找到与该fd相关的fdnode指针.但是, 因为0,1,2这三个fd已经提前预留给了标准输入输出错误这三个IO, 所以采用这样的算法将会至少浪费三个fdnode指针.

现在, 可以对fdnode结构体中两个成员进一步进行解析了:
fdevent_handler handler;
void *ctx;
其中, 如果该fd是服务器监听客户端连接的fd, 那么handler = network_server_handle_fdevent(在network.c文件中), ctx保存的就是server指针;
如果该fd是accapt客户端连接之后的fd, 那么handler = connection_handle_fdevent(在connections.c文件中), ctx保存的就是connection指针.

回过头来看,在将服务器监听fd注册到网络IO事件处理器中之后, 这个处理器就要开始循环处理了, 在server.c中的main.c函数中是这个轮询的主过程:

        // 轮询FD
        if ((n = fdevent_poll(srv -> ev, 1000 )) > 0 ) {
            /* n is the number of events */
            int revents;
            int fd_ndx;

            fd_ndx = - 1 ;
            do {
                fdevent_handler handler;
                void * context;
                handler_t r;

                // 获得处理这些事件的函数指针 fd等

                // 获得下一个fd在fdarray中的索引
                fd_ndx = fdevent_event_next_fdndx (srv -> ev, fd_ndx);
                // 获得这个fd要处理的事件类型
                revents = fdevent_event_get_revent (srv -> ev, fd_ndx);
                // 获取fd
                fd      = fdevent_event_get_fd     (srv -> ev, fd_ndx);
                // 获取回调函数
                handler = fdevent_get_handler(srv -> ev, fd);
                // 获取处理相关的context(对server是server_socket指针, 对client是connection指针)
                context = fdevent_get_context(srv -> ev, fd);

                /* connection_handle_fdevent needs a joblist_append */
                // 进行处理
                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文件.

(四)--处理监听fd的流程

前面介绍了lighttpd使用的watcher-worker模型, 它对IO事件处理的封装, 现在可以把这些结合起来看看这大概的流程.

首先, 服务器创建监听socket, 然后在server.c中调用函数network_register_fdevents将监听socket注册到IO事件处理器中:

在这里, 调用函数fdevent_register注册fd到IO事件处理器中, 对于服务器监听fd而言,
它在fdnode中的回调函数handler是函数network_server_handle_fdevent, 而ctx则是srv_socket.
接着调用函数fdevent_event_add, 其中传入的第三个参数是FDEVENT_IN, 也就是当该fd上有可读数据时触发调用, 对于所有监听的fd而言,
有可读事件就意味着有新的连接到达.

然后服务器创建子进程worker, 服务器父进程自己成为watcher, 自此下面的工作由子进程进行处理,
每个子进程所完成的工作都是一样的.有的书上说有多个进程在等待accept连接的时候会造成所谓的惊群现象,在lighttpd的代码中,
没有看到在accaept之前进行加锁操作, 这是否会造成惊群不得而知.

现在, 在IO事件处理器中仅有一个fd等待触发, 就是前面注册的监听fd, 我们看看当一个连接到来的时候处理的流程, 首先看我们曾经说过的
轮询fd进行处理的主循环:

当一个连接到来的时候, 调用fdevent_poll返回值是1, 因为这个函数的返回值表示的是有多少网络IO事件被触发了, 接着由于n>0, 进入循环中
获得被触发的fd, 回调函数, 以及ctx指针, 在这里由于是监听fd被触发, 那么返回的回调函数是前面提到的network_server_handle_fdevent,
接着就要调用这个函数处理IO事件了:

// 这个函数是处理server事件的函数, 与connection_handle_fdevent对应
handler_t network_server_handle_fdevent( void * s, void * context, int revents) {
    server     * srv = (server * )s;
    server_socket * srv_socket = (server_socket * )context;
    connection * con;
    int loops = 0 ;

    UNUSED(context);

    if (revents != FDEVENT_IN) {
        log_error_write(srv, __FILE__, __LINE__, " sdd " ,
                " strange event for server socket " ,
                srv_socket -> fd,
                revents);
        return HANDLER_ERROR;
    }

    /* accept()s at most 100 connections directly
     *
     * we jump out after 100 to give the waiting connections a chance */
    // 一次最多接受100个链接
    for (loops = 0 ; loops < 100 && NULL != (con = connection_accept(srv, srv_socket)); loops ++ ) {
        handler_t r;

        // 这里马上进入状态机中进行处理仅仅对应状态为CON_STATE_REQUEST_START这一段
        // 也就是保存连接的时间以及设置一些计数罢了
        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;
}

我给这段代码加了一些注释, 有几个地方做一些解释:
1)UNUSED(context)是一个宏, 扩展开来就是( (void)(context) ), 实际上是一段看似无用的代码, 因为没有起什么明显的作用, 是一句废话,
在这个函数中, 实际上没有使用到参数context, 如果在比较严格的编译器中, 这样无用的参数会产生一条警告, 说有一个参数没有使用到, 加上了
这么一句无用的语句, 就可以避免这个警告.那么, 有人就会问了, 为什么要传入这么一个无用的参数呢?回答是, 为了满足这个接口的需求,
来看看回调函数的类型定义:
typedef handler_t (*fdevent_handler)(void *srv, void *ctx, int revents);
这个函数指针要求的第二个参数是一个ctx指针, 对于监听fd的回调函数network_server_handle_fdevent而言, 它是无用的, 但是对于处理连接fd
的回调函数而言, 这个指针是有用的.

2) 在函数的前面, 首先要判断传入的event事件是否是FDEVENT_IN, 也就是说, 只可能在fd有可读数据的时候才触发该函数, 其它的情况都是错误.

3)函数在最后进入一个循环, 循环的最多次数是100次, 并且当connection_accept函数返回NULL时也终止循环, 也就是说, 当监听fd被触发时,
服务器尽量的去接收新的连接, 最多接收100个新连接, 这样有一个好处, 假如服务器监听fd是每次触发只接收一个新的连接, 那么效率是比较低的,
不如每次被触发的时候"尽力"的去接收, 一直到接收了100个新的连接或者没有可接收的连接之后才返回.接着来看看负责接收新连接的函数
connection_accept做了什么:

// 接收一个新的连接
connection * connection_accept(server * srv, server_socket * srv_socket) {
    /* accept everything */

    /* search an empty place */
    int cnt;
    sock_addr cnt_addr;
    socklen_t cnt_len;
    /* accept it and register the fd */

    /* *
     * check if we can still open a new connections
     *
     * see #1216
     */

    // 如果正在使用的连接数大于最大连接数就返回NULL
    if (srv -> conns -> used >= srv -> max_conns) {
        return NULL;
    }

    cnt_len = sizeof (cnt_addr);

    if ( - 1 == (cnt = accept(srv_socket -> fd, ( struct sockaddr * ) & cnt_addr, & cnt_len))) {
        switch (errno) {
        case EAGAIN:
#if EWOULDBLOCK != EAGAIN
        case EWOULDBLOCK:
#endif
        case EINTR:
            /* we were stopped _before_ we had a connection */
        case ECONNABORTED: /* this is a FreeBSD thingy */
            /* we were stopped _after_ we had a connection */
            break ;
        case EMFILE:
            /* out of fds */
            break ;
        default :
            log_error_write(srv, __FILE__, __LINE__, " ssd " , " accept failed: " , strerror(errno), errno);
        }
        return NULL;
    } else {
        connection * con;

        // 当前使用的fd数量+1
        srv -> cur_fds ++ ;

        /* ok, we have the connection, register it */
        // 打开的connection+1(这个成员貌似没有用)
        srv -> con_opened ++ ;

        // 获取一个新的connection
        con = connections_get_new_connection(srv);

        // 保存接收到的fd
        con -> fd = cnt;
        // 索引为-1
        con -> fde_ndx = - 1 ;
#if 0
        gettimeofday( & (con -> start_tv), NULL);
#endif
        // 注册函数指针和connection指针
        fdevent_register(srv -> ev, con -> fd, connection_handle_fdevent, con);

        // 状态为可以接收请求
        connection_set_state(srv, con, CON_STATE_REQUEST_START);

        // 保存接收连接的时间
        con -> connection_start = srv -> cur_ts;
        // 保存目标地址
        con -> dst_addr = cnt_addr;
        buffer_copy_string(con -> dst_addr_buf, inet_ntop_cache_get_ip(srv, & (con -> dst_addr)));
        // 保存server_socket指针
        con -> srv_socket = srv_socket;

        // 设置一下接收来的FD, 设置为非阻塞
        if ( - 1 == (fdevent_fcntl_set(srv -> ev, con -> fd))) {
            log_error_write(srv, __FILE__, __LINE__, " ss " , " fcntl failed: " , strerror(errno));
            return NULL;
        }
#ifdef USE_OPENSSL
        /* connect FD to SSL */
        if (srv_socket -> is_ssl) {
            if (NULL == (con -> ssl = SSL_new(srv_socket -> ssl_ctx))) {
                log_error_write(srv, __FILE__, __LINE__, " ss " , " SSL: " ,
                        ERR_error_string(ERR_get_error(), NULL));

                return NULL;
            }

            SSL_set_accept_state(con -> ssl);
            con -> conf.is_ssl = 1 ;

            if ( 1 != (SSL_set_fd(con -> ssl, cnt))) {
                log_error_write(srv, __FILE__, __LINE__, " ss " , " SSL: " ,
                        ERR_error_string(ERR_get_error(), NULL));
                return NULL;
            }
        }
#endif
        return con;
    }
}

抛开出错处理这部分不解释, 一旦出错, 就返回NULL指针, 这时可以终止上面那个循环接收新连接的过程,下面重点看看接收了一个新的连接之后需要
做哪些事情, 在上面的代码中我加了一些简单的注释, 下面加一些更加详细些的解释:
1)要将服务器已经接收的fd数量(成员cur_fds)加一, 这个数量用于判断是否可以接收新的连接的, 超过一定的数量时, 服务器就暂停接收,
等一些fd释放之后才能继续接收

2) 调用函数connections_get_new_connection返回一个connection指针, 用于保存新到的连接, 获得这个指针之后要保存接收这个连接的时间
(成员connection_start中), 保存新到连接的地址(成员dst_addr和dst_addr_buf中), 此外还要保存一个server指针, 并且调用函数fdevent_fcntl_set
将该fd设置为非阻塞的, 最后别忘了要调用fdevent_register函数将该fd注册到IO事件处理器中, 另外该fd当前的状态通过connection_set_state设置为
CON_STATE_REQUEST_START, 这是后面进入状态机处理连接的基础.

了解了这个函数的处理过程, 回头看看上面的循环:

    for (loops = 0 ; loops < 100 && NULL != (con = connection_accept(srv, srv_socket)); loops ++ ) {
        handler_t r;

        // 这里马上进入状态机中进行处理仅仅对应状态为CON_STATE_REQUEST_START这一段
        // 也就是保存连接的时间以及设置一些计数罢了
        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 ;
        }
    }

我们已经分析完了函数connection_accept, 当一个新的连接调用这个函数成功返回的时候, 这个循环执行函数connection_state_machine
进行处理.这是一个非常关键的函数, 可以说, 我们后面讲解lighttpd的很多笔墨都将花费在这个函数上, 这也是我认为lighttpd实现中最精妙的
地方之一, 在这里我们先不进行讲解, 你所需要知道的是, 在这里, connection_state_machine调用了函数fdevent_event_add, 传入的事件参数仍然是
FDEVENT_IN, 也就是说, 对于新加入的fd, 它所首先关注的IO事件也是可读事件.

我们大体理一理上面的流程, 省略去对watcher-worker模型的描述:
创建服务器监听fd-->
调用fdevent_register函数将监听fd注册到IO事件处理器中-->
调用fdevent_event_add函数添加FDEVENT_IN到监听fd所关注的事件中-->

当一个新的连接到来时:
IO事件处理器轮询返回一个>0的值-->
IO事件处理返回被触发的fd, 回调函数, ctx指针,在这里就是监听fd,回调函数则是network_server_handle_fdevent->
调用监听fd注册的回调函数network_server_handle_fdevent-->
network_server_handle_fdevent函数尽力接收新的连接, 除非已经接收了100个新连接, 或者没有新连接到来-->
对于新到来的连接, 同样是调用fdevent_register函数将它注册到IO事件处理器中, 同样调用fdevent_event_add函数添加该fd所关注的事件是FDEVENT_IN

以上, 就是lighttpd监听fd处理新连接的大体流程.
我们知道, fd分为两种:一种是服务器自己创建的监听fd, 负责监听端口, 接收新到来的连接;
另一种, 就是由监听fd调用accept函数返回的连接fd, 这两种fd在处理时都会注册到IO事件处理器中(调用fdevent_register函数),
同时添加它们所关注的IO事件(可读/可写等)(调用fdevent_event_add函数).

也就是说,对IO事件处理器而言, 它并不关注所处理的fd是什么类型的, 你要使用它, 那么就把你的fd以及它的回调函数注册到其中, 同时添加你所关注的IO事件是什么, 当一个fd所关注的IO事件被触发时, IO事件处理器自动会根据你所注册的回调函数进行回调处理, 这是关键点, 如果你没有明白, 请回头看看前面提到的IO事件处理器.

这些的基础就是我们前面提到IO事件处理器, 前面我们提到过, lighttpd对IO事件处理的封装很漂亮, 每个具体实现都按照接口的规范进行处理.
我们在讲解时, 也没有涉及到任何一个具体实现的细节, 这也是因为lighttpd的封装很好, 以至于我们只需要了解它们对外的接口不需要深入细节就
可以明白其运行的原理.在本节中, 我们结合IO事件处理器, 对上面提到的第一种fd也就是监听fd的处理流程做了介绍, 在后面的内容中, 将重点讲解对
连接fd的处理.

lighttpd代码分析

原文链接

watcher,worker模型

(二)--fdevents结构体解析

(三)--网络IO事件处理器的使用

(四)--处理监听fd的流程

你可能感兴趣的:(lighttpd)