【转载】Nginx的HTTP请求处理

最近需要研究Nginx HTTP请求处理的流程，找到一篇细节文章

原文地址：http://bollaxu.iteye.com/blog/855482

Nginx在7层负载交换、反向代理服务领域使用比较广泛。Nginx的结构也比较简单，除了底层几个核心的模块(如ngx_core_module，ngx_event_core_module，ngx_errlog_module等)之外，其它的主要是基于上述核心模块的http和mail的模块组，负责处理相关服务。而这些模块也可以在编译的时候被enable/disable，取决于对实际功能的需求。在这里，我来分析一下Nginx用的最多的功能，即处理http请求的工作流程。

在事件处理的分析中，提到过当有http请求过来时事件的触发和处理过程。我们知道，在一个子进程accept()请求之后，会调用ngx_http_init_connection()函数。这个函数会添加一个读事件，并设置其handler为ngx_http_init_request()。但是，对于http模块的载入以及初始化，却是要从http_block()开始。在父进程(master process)调用ngx_init_cycle()的时候，会调用一次ngx_conf_parse()函数(先不在这里分析)，这个时候(解析到了"http {...}" block)，ngx_http_module模块的set()函数即ngx_http_block()就被调用。

static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    /* the main http context */
    //它里面只有三个成员：(void**)main_conf，(void**)srv_conf和(void**)loc_conf，注意它们是双层指针
    //每个NGX_HTTP_MODULE模块都有一个main_conf[i]，srv_conf[i]和loc_conf[i]指向相应的上下文，但不是每个都会用到。
    ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
    *(ngx_http_conf_ctx_t **) conf = ctx;
    /* 清点NGX_HTTP_MODULE类型模块个数并给每个模块设定索引(index) */
    ngx_http_max_module = 0;
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
        ngx_modules[m]->ctx_index = ngx_http_max_module++;
    }
    //main_conf在http{...}里面的所有上下文中都是一致的
    //分配内存，个数为http模块的个数
    ctx->main_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    //用来合并server{...}里面的srv_conf
    //分配内存，个数为http模块的个数
    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    //用来合并 /loc {...} 里面的loc_conf
    //分配内存，个数为http模块的个数
    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    //如有定义的话，调用每个http模块里面的create_main_conf()，create_srv_conf()和create_loc_conf()
    for (;;) {
        //如果是NGX_HTTP_MODULE模块
        module = ngx_modules[m]->ctx;//module的上下文，为ngx_http_module_t类型
        mi = ngx_modules[m]->ctx_index;//在http模块组里的索引
        //如有的话，就调用每个模块的下列函数，并存入ctx相应的索引位
        //一般在 http {...}里面而不在 server {...}里面有命令的模块有create_main_conf()
        //一般在 server {...}里面而不在 /loc {...}里面有命令的模块有create_srv_conf()
        //一般在 /loc {...}里面有命令的模块有create_loc_conf()
        ctx->main_conf[mi] = module->create_main_conf(cf);//创建模块自定的上下文，存入相应位置
        ctx->srv_conf[mi] = module->create_srv_conf(cf);//创建模块自定的srv上下文，存入相应位置
        ctx->loc_conf[mi] = module->create_loc_conf(cf);//创建模块自定的loc上下文，存入相应位置
    }
    pcf = *cf;
    cf->ctx = ctx;//把ctx放入cf
    for (;;) {
        //调用每个NGX_HTTP_MODULE模块的preconfiguration()函数
        //一般模块的preconfiguration()作用是添加一些模块要用的变量到ngx_http_core_main_conf_t的hash表variables_keys
        module->preconfiguration(cf);
    }
    /* parse inside the http{} block */
    cf->module_type = NGX_HTTP_MODULE;
    cf->cmd_type = NGX_HTTP_MAIN_CONF;
    rv = ngx_conf_parse(cf, NULL);//会调用指令的set()函数，如果有嵌套的block会继续调用ngx_conf_parse()。大部分的http{}（但在server{}外）的指令都是给ngx_http_core_loc_conf_t的成员赋值。
    //获取ngx_http_core_module(定义一些http公用的命令和变量)的main_conf
    cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
    cscfp = cmcf->servers.elts;//cmcf->servers在ngx_http_core_create_main_conf里面初始化并分配内存，并在server{} block里面读取配置并设置相关变量
    for (;;) {
        //调用每个NGX_HTTP_MODULE模块的init_main_conf()，调用ngx_http_merge_servers()
        rv = module->init_main_conf(cf, ctx->main_conf[mi]);//对main_conf上下文的一些成员变量做初始化
        rv = ngx_http_merge_servers(cf, cmcf, module, mi);//每个server{} block都有一个srv_conf（继承ngx_http_core_module的srv_conf），且其ctx变量指向一组main_conf[]，srv_conf[]和loc_conf[]，储存了各个模块的main_conf，srv_conf，loc_conf（但是只有在server{}中调用模块的指令，才会用到这些xxx_conf）
    }
    /* create location trees */
    //给每个server创建location tree
    for (s = 0; s < cmcf->servers.nelts; s++) {
        clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];//每个srv（虚拟主机）的ngx_http_core_loc_conf_t
        //location根据字母顺序排序
        ngx_http_init_locations(cf, cscfp[s], clcf);
        //建立静态location树(三叉树)
        //在http://blog.csdn.net/benbendy1984/archive/2010/11/18/6019336.aspx有简单介绍
        ngx_http_init_static_location_trees(cf, clcf);
    }
    //初始化几个phase的handler(分配内存)
    if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    //初始化header的hash table
    if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    for (;;) {
        //注册每个模块对应phase的处理函数
        //这儿的处理函数是通用的(如http模块的所有location)
        //特定location的处理函数在指令(directive)的set()里面设置
        module->postconfiguration(cf);
    }
    //设置pre-defined variables的get_handler等，并放入hash table里
    if (ngx_http_variables_init_vars(cf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    //注册各http模块phase的checker，并把postconfiguration注册的handler都放到cmcf的phase_engine，phase_engine把cheker和对应的handler一同放入数组，并通过next变量链接，供之后处理请求的时候按phase顺序调用。
    //在http://simohayha.iteye.com/blog/670326有比较详细的介绍
    if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    //把server_name储存在hash table里，最后给每个listening socket注册ls->handler=ngx_http_init_connection；
    //详见http://blog.csdn.net/ccdd14/archive/2010/09/12/5878459.aspx
    if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
    return NGX_CONF_OK;
}

 

当nginx收到请求的时候，就会调用(1)ngx_http_init_request，开始了对请求的处理过程。

static void ngx_http_init_request(ngx_event_t *rev)
{
    //获取event的connection
    c = rev->data;
    //如果事件超时
    //...

    hc = c->data;
    //给这个ngx_http_connection_t类型的指针分配内存
    //...

    r = hc->request;
    //创建(re-init)一个新的request
    //...

    c->data = r;
    r->http_connection = hc;
    c->sent = 0;
    r->signature = NGX_HTTP_MODULE;

    /* find the server configuration for the address:port */
    port = c->listening->servers;//在http_block()的时候就已经设置完成（在"listen"指令和ngx_http_optimize_servers函数里）
    r->connection = c;

    //如果有多个监听的addr
    if (port->naddrs > 1) {
        /*
        * there are several addresses on this port and one of them
        * is an "*:port" wildcard so getsockname() in ngx_http_server_addr()
        * is required to determine a server address
        */
        if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
            ngx_http_close_connection(c);
            return;
        }
        switch (c->local_sockaddr->sa_family) {
            default: /* AF_INET */
                sin = (struct sockaddr_in *) c->local_sockaddr;
                addr = port->addrs;
                /* the last address is "*" */
                for (i = 0; i < port->naddrs - 1; i++) {
                    if (addr[i].addr == sin->sin_addr.s_addr) {
                        break;
                    }
                }
                addr_conf = &addr[i].conf;
                break;
        }
    }
    else {
        switch (c->local_sockaddr->sa_family) {
            default: /* AF_INET */
                addr = port->addrs;
                addr_conf = &addr[0].conf;
                break;
        }
    }
    r->virtual_names = addr_conf->virtual_names;
    /* the default server configuration for the address:port */
    cscf = addr_conf->core_srv_conf;
    r->main_conf = cscf->ctx->main_conf;
    r->srv_conf = cscf->ctx->srv_conf;
    r->loc_conf = cscf->ctx->loc_conf;
    //event的handler设为ngx_http_process_request_line
    rev->handler = ngx_http_process_request_line;
    //设置request的读事件
    r->read_event_handler = ngx_http_block_reading;
    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
    c->log->file = clcf->error_log->file;

    r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);
    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
    //分配内存给variables
    r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts *
                    sizeof(ngx_http_variable_value_t));
    c->single_connection = 1;
    c->destroyed = 0;

    //对r的其它的初始化
    r->main = r;//主请求
    r->method = NGX_HTTP_UNKNOWN;
    r->headers_in.content_length_n = -1;
    r->headers_in.keep_alive_n = -1;
    r->headers_out.content_length_n = -1;
    r->headers_out.last_modified_time = -1;
    r->uri_changes = NGX_HTTP_MAX_URI_CHANGES + 1;
    r->subrequests = NGX_HTTP_MAX_SUBREQUESTS + 1;
    r->http_state = NGX_HTTP_READING_REQUEST_STATE;
    ctx = c->log->data;
    ctx->request = r;
    ctx->current_request = r;
    r->log_handler = ngx_http_log_error_handler;
    rev->handler(rev); //ngx_http_process_request_line
}

 

下面，分别调用了下列函数，在这里不一一详细分析：

-->(2)ngx_http_process_request_line()//读取、解析请求行，并存入r的相应成员(如uri,args相关的重要指针)。

-->(3)ngx_http_process_request_headers()//把header line逐行解析并以key-value形式存入r。

-->(4)ngx_http_process_request()

-->(5)ngx_http_handler()

-->(6)ngx_http_core_run_phases()

void ngx_http_core_run_phases(ngx_http_request_t *r)
{
    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
    ph = cmcf->phase_engine.handlers;//拿到phase_engine里存放所有handler的数组

    //如果不是内部定向(rewrite)的话，r->phase_handler = 0;
    //每个phase的checker在ngx_http_init_phase_handlers设置
    //每个phase的handler在ngx_http_init_phase_handlers设置
    //ph(ngx_http_phase_handler_s类型)的顺序：越早在postconfiguration()时注册handler的模块，它的handler在ph里面就越靠后被调用。
    while (ph[r->phase_handler].checker) {
        //ngx_http_init_phase_handlers里面注册每个phase的checker和handler
        rc = ph[r->phase_handler].checker(r, &ph[r->phase_handler]);
        if (rc == NGX_OK) {
            return;
        }
    }
}

 

关于ngx_http_core_main_conf_t，它里面有两个成员，phase_engine和phases。其中phases是一个存放所有模块的在postconfiguration()函数里面注册的相关phase的handler。比如，ngx_http_index_module里面，就push了一个NGX_HTTP_CONTENT_PHASE的handler：ngx_http_index_handler。这个handler就被存放在ngx_http_core_main_conf_t的phases[NGX_HTTP_CONTENT_PHASE]这个数组里面。而phase_engine里面的handlers(ngx_http_phase_handler_s类型)则是一个checker和handler的函数对，next指向下一个phase在phase_engine里面的index。

比如说，最基本的一个处理过程：NGX_HTTP_FIND_CONFIG_PHASE --> NGX_HTTP_PREACCESS_PHASE --> NGX_HTTP_ACCESS_PHASE --> NGX_HTTP_CONTENT_PHASE。被调用的函数是：

//NGX_HTTP_FIND_CONFIG_PHASE的checker
ngx_http_core_find_config_phase()
{
    //调用ngx_http_core_find_static_location()，比较r的uri和config tree的名字，找到合适的/location，并更新r->loc_conf
    ngx_http_core_find_location();
    //基于r->loc_conf，更新r的相应成员变量
    //其中如果有一些location调用了某些模块的命令设置了特定的clcf->handler，r->content_handler = clcf->handler。在ngx_http_core_content_phase()里面就会被调用。
    ngx_http_update_location_config();
    //goto next handler即next phase
    r->phase_handler++;
}

 

NGX_HTTP_PREACCESS_PHASE的checker是ngx_http_core_generic_phase()，即调用ph->handler(r)。在默认的模块配置里，NGX_HTTP_PREACCESS_PHASE类型的有ngx_http_limit_req_module和ngx_http_limit_zone_module两个模块，那么它们的ngx_http_limit_req_handler()和ngx_http_limit_zone_handler()就会被调用。在ngx_http_core_generic_phase()里面调用ph->handler(r)之后即控制下一个被调用的函数(是到下一个phase或者是本个phase的下一个handler)。

//NGX_HTTP_ACCESS_PHASE的checker
ngx_http_core_access_phase()
{
    rc = ph->handler(r);
    //根据rc来判断选择是下一个phase或者是本个phase的下一个handler
    //...
}

 

在模块的默认配置里，NGX_HTTP_ACCESS_PHASE类型的是ngx_http_access_module和ngx_http_auth_basic_module，即ph->handler(r)调用了ngx_http_access_handler()和ngx_http_auth_basic_handler()

//NGX_HTTP_CONTENT_PHASE的checker
ngx_http_core_content_phase()
{
    //如果location有特定的handler
    //e.g. ngx_http_proxy_module的"proxy_pass"命令就会设置location的handler "ngx_http_proxy_handler"
    if (r->content_handler) {
        r->write_event_handler = ngx_http_request_empty_handler;
        ngx_http_finalize_request(r, r->content_handler(r));
        return NGX_OK;
    }
    //没有location没有特定的handler
    rc = ph->handler(r);
    ph++;
    //跳到下一个NGX_HTTP_CONTENT_PHASE的handler或者下一个phase的checker
    if (ph->checker) {
        r->phase_handler++;
        return NGX_AGAIN;
    }
    //...
}

 

默认的配置里有3个NGX_HTTP_CONTENT_PHASE类型的模块有ngx_http_static_module，ngx_http_index_module和ngx_http_autoindex_module，调用它们的ngx_http_static_handler()，ngx_http_index_handler()和ngx_http_autoindex_handler()。

通过实际运行的的debug信息，可以看到每个phase的checker被调用时候的handler的r->phase_handler(即index)。根据实际的情况(如根据不同location配置)，不一定每个handler都会被调用(通过设置r->phase_handler = ph->next)，甚至有时候会直接跳到另外一个phase(比如在ngx_http_index_handler()里面调用ngx_http_internal_redirect()，重新进入ngx_http_handler()，即重新把phase走一遍)。这些都是根据每个phase的handler的实现以及实际的请求来决定的。

关于每个phase的具体功能：

typedef enum {
    //0读取请求phase
    NGX_HTTP_POST_READ_PHASE = 0,
    //1这个阶段主要是处理全局的(server block)的rewrite。
    NGX_HTTP_SERVER_REWRITE_PHASE,
    //2这个阶段主要是通过uri来查找对应的location，然后根据loc_conf设置r的相应变量
    //e.g. 根据location内配置的具体命令设置r->content_handler，到NGX_HTTP_CONTENT_PHASE调用
    NGX_HTTP_FIND_CONFIG_PHASE,
    //3这个主要处理location的rewrite
    NGX_HTTP_REWRITE_PHASE,
    //4post rewrite，这个主要是进行一些校验以及收尾工作，以便于交给后面的模块。
    NGX_HTTP_POST_REWRITE_PHASE,
    //5比如流控这种类型的access就放在这个phase，也就是说它主要是进行一些比较粗粒度的access。
    NGX_HTTP_PREACCESS_PHASE,
    //6这个比如存取控制，权限验证就放在这个phase，一般来说处理动作是交给下面的模块做的.这个主要是做一些细粒度的access
    NGX_HTTP_ACCESS_PHASE,
    //7一般来说当上面的access模块得到access_code之后就会由这个模块根据access_code来进行操作
    NGX_HTTP_POST_ACCESS_PHASE,
    //8try_file模块，也就是对应配置文件中的try_files指令，可接收多个路径作为参数，当前一个路径的资源无法找到，则自动查找下一个路径
    NGX_HTTP_TRY_FILES_PHASE,
    //9内容处理模块
    NGX_HTTP_CONTENT_PHASE,
    //10log模块
    NGX_HTTP_LOG_PHASE
} ngx_http_phases;

 

Nginx的http上下文（在读取配置的时候设置）：