Nginx upstream原理分析【1】upstream和FastCGI前篇

在前一篇文章“Nginx upstream原理分析【1】新连接的处理过程”中我们介绍了一个连接从accept到ngx_http_core_run_phases过程处理所发生的事情，后面剩下的就是FCGI的相关处理了，留在这里进行介绍。

0、写在前面的话
ngx_http_core_run_phases函数会不断调用cmcf->phase_engine.handlers上面的checker，从而调用rewrite模块，find_config模块等的函数进行相应的处理，对于我们今天要介绍的FCGI模块的处理，其checker调用的是ngx_http_core_content_phase，后者调用了ngx_http_fastcgi_handler进行相关的处理。

这个ngx_http_fastcgi_handler是在nginx 解析配置的时候，解析到了ngx_string(“fastcgi_pass”),指令的时候会调用ngx_http_fastcgi_pass（）进行指令解析，里面就设置了clcf->handler = ngx_http_fastcgi_handler;，也就是设置到了location conf的handler上面；

当nginx进行rewrite，配置更新的时候，会调用到ngx_http_update_location_config函数，去更新各个成员的配置，从而将刚才的handler设置到了请求的r->content_handler 句柄上面，在调用ngx_http_core_content_phase里面，就会处理这个content_handler。下面看一下代码，了解一下ngx_http_fastcgi_handler的来源：

ngx_int_t
ngx_http_core_content_phase(ngx_http_request_t *r,   ngx_http_phase_handler_t *ph)
{
    size_t     root;
    ngx_int_t  rc;
    ngx_str_t  path;

    if (r->content_handler) {
//如果有content_handler,就直接调用就行了.比如如果是FCGI，在遇到配置fastcgi_pass   127.0.0.1:8777;的时候
//会调用ngx_http_fastcgi_pass函数，注册本location的处理hander为ngx_http_fastcgi_handler。
//从而在ngx_http_update_location_config里面会更新content_handler指针为当前loc所对应的指针。
        r->write_event_handler = ngx_http_request_empty_handler;
        ngx_http_finalize_request(r, r->content_handler(r));
        return NGX_OK;
    }
//······

}

static char *
ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{//nginx 解析到fastcgi_pass指令的时候调用这里.比如fastcgi_pass   127.0.0.1:8777;
    ngx_http_fastcgi_loc_conf_t *flcf = conf;
    clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
    //设置句柄，会在ngx_http_update_location_config里面设置为content_handle的，从而在content phase中被调用
    clcf->handler = ngx_http_fastcgi_handler;
//`````
}
void ngx_http_update_location_config(ngx_http_request_t *r)
29
{//更新各种配置。根据loc_conf的配置，将对应的所需数据设置到r请求结构体上面去。
//主要的还有 r->content_handler = clcf->handler;，设置回调。
    if (clcf->handler) {//如果配置模块设置了其handler，那么将其设置到content_handler指针上面，以备待会在处理phase的时候，调用之。
//ngx_http_fastcgi_handler就在这里设置了，于是在ngx_http_core_content_phase就会调用这个FCGI函数，然后请求就交给对应的处理了
//····
//proxy 模块为ngx_http_proxy_handler。
        r->content_handler = clcf->handler;
    }
}
1、ngx_http_fastcgi_handler内容处理入口:
ngx_http_fastcgi_handler函数作为nginx读取请求的header头部后,就会调用ngx_http_core_content_phase进一步调用到这里，可以看到upstream还没有到，其实upstream是由这些fastcgi模块或者proxy模块使用的。或者说互相使用：fastcgi启动upstream，设置相关的回调，然后upstream会调用这些回调完成功能。下面看看这个函数。

首先调用ngx_http_upstream_create创建一个upstream结构，设置到r->upstream上面去，以后就可以根据请求结构获取到upstream了；
然后设置upstream上面的回调函数create_request，process_header，finalize_request等；
再设置u->pipe->input_filter为ngx_http_fastcgi_input_filter，这个是用来解析FCGI协议数据的句柄，用在event_pipe方式接收数据，解析的，在“Nginx upstream原理分析【2】-带buffering读取upstream数据”里面会看到其用处；
之后就是调用ngx_http_read_client_request_body函数，读取客户端发送过来的BODY，并且设置第二个参数为ngx_http_upstream_init，这样读取客户端BODY完成后，就好调用ngx_http_upstream_init函数去初始化upstream数据，准备发送数据到后端的FCGI，比如PHP。
关于upstream上面的几个回调函数，下面说一下主要的：

u->create_request = ngx_http_fastcgi_create_request;//这个回调主要生成发送到上游服务器的请求缓冲（或者一条缓冲链），存放在u->request_bufs链接表里面。

u->reinit_request = ngx_http_fastcgi_reinit_request;//在后端服务器被重置的情况下（在create_request被第二次调用之前）被调用

u->process_header = ngx_http_fastcgi_process_header;//处理上游服务器回复的第一个bit，时常是保存一个指向上游回复负载的指针

u->finalize_request = ngx_http_fastcgi_finalize_request;//在Nginx完成从上游服务器读入回复以后被调用

下面简单看一下代码：

static ngx_int_t
ngx_http_fastcgi_handler(ngx_http_request_t *r)
{//FCGI处理入口,ngx_http_core_run_phases里面当做一个内容处理模块调用的。
//ngx_http_core_find_config_phase里面的ngx_http_update_location_config设置
    ngx_int_t                     rc;
    ngx_http_upstream_t          *u;
    ngx_http_fastcgi_ctx_t       *f;
    ngx_http_fastcgi_loc_conf_t  *flcf;
 
    if (r->subrequest_in_memory) {
        ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, "ngx_http_fastcgi_module does not support subrequest in memory");
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }

    if (ngx_http_upstream_create(r) != NGX_OK) {//创建一个ngx_http_upstream_t结构，放到r->upstream里面去。
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }
    f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));

    if (f == NULL) {
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }
    ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);//r->ctx[module.ctx_index] = c;也就是将申请的fcgi_ctx_t放到这个请求的ctx里面
    flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);//得到fcgi的配置。(r)->loc_conf[module.ctx_index]

    if (flcf->fastcgi_lengths) {//如果这个fcgi有变量，那么久需要解析一下变量。
        if (ngx_http_fastcgi_eval(r, flcf) != NGX_OK) {//计算fastcgi_pass   127.0.0.1:9000;后面的URL的内容。也就是域名解析；
            return NGX_HTTP_INTERNAL_SERVER_ERROR;
        }
    }

    u = r->upstream;
    ngx_str_set(&u->schema, "fastcgi://");//用fcgi协议。
    u->output.tag = (ngx_buf_tag_t) &ngx_http_fastcgi_module;
    u->conf = &flcf->upstream;
#if (NGX_HTTP_CACHE)
    u->create_key = ngx_http_fastcgi_create_key;//根据flcf->cache_key里面的复杂表达式计算 scgi_cache_key line;指令后面的复杂表达式line;
#endif
    u->create_request = ngx_http_fastcgi_create_request;
    u->reinit_request = ngx_http_fastcgi_reinit_request;
    u->process_header = ngx_http_fastcgi_process_header;
    u->abort_request = ngx_http_fastcgi_abort_request;
    u->finalize_request = ngx_http_fastcgi_finalize_request;
    //下面的数据结构是给event_pipe用的，用来对FCGI的数据进行buffering处理的。FCGI写死为buffering
    u->buffering = 1;
    u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));

    if (u->pipe == NULL) {
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }
    //设置读取fcgi协议格式数据的回调，当解析完带有\r\n\r\n的头部的FCGI包后，后面的包解析都由这个函数进行处理。
    u->pipe->input_filter = ngx_http_fastcgi_input_filter;
    u->pipe->input_ctx = r;
    rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

    if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
        return rc;
    }
    return NGX_DONE;
}
2、读取客户端请求体ngx_http_read_client_request_body：
ngx_http_read_client_request_body用来读取客户端的BODY，存放在2个地方：

r->header_in;如果在读取请求头的时候已经读入了一部分数据，则放入这里
没有预读的数据部分新分配一块内存存放。
上面2种方式读取的数据都是存放在ngx_http_request_body_t结构上面的，这个结果由r->request_body = rb;填充。下面看一下这个结构：

typedef struct {
 //如果请求的POST数据需要写入文件，则此处记录文件

 ngx_temp_file_t                  *temp_file;


 //请求BODY的BUFFER链接表，如果在解析HEADER的时候预读了数据，则会分2块存放在这里

 ngx_chain_t                      *bufs;

 //指向所POST的，可以写入的缓冲区

 ngx_buf_t                        *buf;

 //r->headers_in.content_length_n - preread;计算还有多少数据需要读取，减去刚才预读的部分。不断减少

 off_t                             rest;

 //数据将要写入所指向的这个链接表的位置。

 ngx_chain_t                      *to_write;

 //POST数据读取完毕后需要调用的HANDLER函数，也就是ngx_http_upstream_init

 ngx_http_client_body_handler_pt   post_handler;

} ngx_http_request_body_t;
下面函数分2部分进行处理，也就是客户端有没有BODY。

一、没有发送body：

函数首先判断是否已经读取完了请求体，或者是否配置可以丢掉请求体discard_body，如果是就直接调用ngx_http_upstream_init去初始化upstream相关数据；
然后调用ngx_http_test_expect检查是否需要发送HTTP/1.1 100 Continue；
申请一个ngx_http_request_body_t结构用来存储客户端的请求体，并设置到r->request_body = rb;
如果content_length_n等于0，也就是客户端不会发送BODY，那OK，直接调用ngx_http_upstream_init就行了。

看看这部分的代码：

/*
 * on completion ngx_http_read_client_request_body() adds to
 * r->request_body->bufs one or two bufs:
 *    *) one memory buf that was preread in r->header_in;如果在读取请求头的时候已经读入了一部分数据，则放入这里
 *    *) one memory or file buf that contains the rest of the body 没有预读的数据部分放入这里
 */
ngx_int_t ngx_http_read_client_request_body(ngx_http_request_t *r, ngx_http_client_body_handler_pt post_handler)
{//post_handler = ngx_http_upstream_init。NGINX会等到请求的BODY全部读取完毕后才进行upstream的初始化，GOOD
    size_t                     preread;
    ssize_t                    size;
    ngx_buf_t                 *b;
    ngx_chain_t               *cl, **next;
    ngx_temp_file_t           *tf;
    ngx_http_request_body_t   *rb;
    ngx_http_core_loc_conf_t  *clcf;
    r->main->count++;

    if (r->request_body || r->discard_body) {//discard_body是否需要丢弃请求内容部分。或者已经有请求体了。则直接回调
        post_handler(r);//不需要请求体，直接调用ngx_http_upstream_init
        return NGX_OK;
    }
 
    if (ngx_http_test_expect(r) != NGX_OK) {//检查是否需要发送HTTP/1.1 100 Continue
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }

    rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));

    if (rb == NULL) {
        return NGX_HTTP_INTERNAL_SERVER_ERROR;
    }


    r->request_body = rb;//分配请求体结构，下面进行按需填充。

    if (r->headers_in.content_length_n < 0) {
        post_handler(r);//如果不需要读取body部分，长度小于0
        return NGX_OK;
    }
 
    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

    if (r->headers_in.content_length_n == 0) {//如果没有设置content_length_n
        if (r->request_body_in_file_only) {//client_body_in_file_only这个指令始终存储一个连接请求实体到一个文件即使它只有0字节。
            tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));

            if (tf == NULL) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
            }
            tf->file.fd = NGX_INVALID_FILE;
            tf->file.log = r->connection->log;
            tf->path = clcf->client_body_temp_path;
            tf->pool = r->pool;
            tf->warn = "a client request body is buffered to a temporary file";
            tf->log_level = r->request_body_file_log_level;
            tf->persistent = r->request_body_in_persistent_file;
            tf->clean = r->request_body_in_clean_file;

            if (r->request_body_file_group_access) {
                tf->access = 0660;
            }
            rb->temp_file = tf;//创建一个临时文件用来存储POST过来的body。虽然这个只有0字节，啥东西都没有。
            if (ngx_create_temp_file(&tf->file, tf->path, tf->pool, tf->persistent, tf->clean, tf->access) != NGX_OK) {
                return NGX_HTTP_INTERNAL_SERVER_ERROR;
            }
        }
    //由于实际的content_length_n长度为0，也就不需要进行读取了。直接到init
        post_handler(r);//一般GET请求直接到这里了
        return NGX_OK;
    }
二、客户端发送了body，需要读取：

后面就需要读取body了，nginx首先将ngx_http_upstream_init设置到rb->post_handler上面，以备读取完成body后调用。接着nginx根据r->header_in判断一下是否之前在读取头部数据的时候多读取了一部分BODY，如果是，就申请一块buf链表，指向这块内存并且存到rb->bufs指针上面。如果预读的数据已经足够了，也就是包含了整个body，那就可以调用ngx_http_upstream_init，否则还需要进行后面的数据读取。下面看看有预读数据的情况下，代码是如何处理的，具体看代码注释：

//好吧，这回content_length_n大于0 了，也就是个POST请求。这里先记录一下，待会POST数据读取完毕后，需要调用到这个ngx_http_upstream_init

 rb->post_handler = post_handler;



 preread = r->header_in->last - r->header_in->pos;//使用之前读入的剩余数据，如果之前预读了数据的话。

 if (preread) {//如果之前预读了多余的请求体

     /* there is the pre-read part of the request body */
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http client request body preread %uz", preread);
     b = ngx_calloc_buf(r->pool);//分配ngx_buf_t结构，用于存储预读的数据

     if (b == NULL) {
         return NGX_HTTP_INTERNAL_SERVER_ERROR;
	 }

     b->temporary = 1;
     b->start = r->header_in->pos;//直接指向已经预读的数据的开头。这个POS已经在外面就设置好了的。读取请求头，HEADERS后就移位了。

     b->pos = r->header_in->pos;
     b->last = r->header_in->last;
     b->end = r->header_in->end;

     rb->bufs = ngx_alloc_chain_link(r->pool);//申请一个buf链接表。用来存储2个BODY部分

     if (rb->bufs == NULL) {
         return NGX_HTTP_INTERNAL_SERVER_ERROR;
     }



     rb->bufs->buf = b;//预读的BODY部分放在这里
     rb->bufs->next = NULL;//其余部分待会读取的时候放在这里
     rb->buf = b;//ngx_http_request_body_t 的buf指向这块新的buf

     if ((off_t) preread >= r->headers_in.content_length_n) {//OK，我已经读了足够的BODY了，可以想到，下面可以直接去ngx_http_upstream_init了

         /* the whole request body was pre-read */
         r->header_in->pos += (size_t) r->headers_in.content_length_n;
         r->request_length += r->headers_in.content_length_n;//统计请求的总长度

         if (r->request_body_in_file_only) {//如果需要记录到文件，则写入文件

             if (ngx_http_write_request_body(r, rb->bufs) != NGX_OK) {
                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
             }
         }

         post_handler(r);//进行处理
         return NGX_OK;
     }

     //如果预读的数据还不够，还有部分数据没有读入进来。

     /*
      * to not consider the body as pipelined request in
      * ngx_http_set_keepalive()
      */

     r->header_in->pos = r->header_in->last;//后移，待会从这里写入，也就是追加吧
     r->request_length += preread;//统计总长度
     rb->rest = r->headers_in.content_length_n - preread;//计算还有多少数据需要读取，减去刚才预读的部分。

     if (rb->rest <= (off_t) (b->end - b->last)) {//如果还要读取的数据大小足够容纳到现在的预读BUFFER里面，那就干脆放入其中吧。

         /* the whole request body may be placed in r->header_in */
         rb->to_write = rb->bufs;//可以写入第一个位置rb->bufs->buf = b;
         r->read_event_handler = ngx_http_read_client_request_body_handler;//设置为读取客户端的请求体
         return ngx_http_do_read_client_request_body(r);//果断的去开始读取剩余数据了
     }

     //如果预读的BUFFER容不下所有的。那就需要分配一个新的了。

     next = &rb->bufs->next;//设置要读取的数据为第二个buf



 } else {

     b = NULL;//没有预读数据
     rb->rest = r->headers_in.content_length_n;//设置所需读取的数据为所有的。
     next = &rb->bufs;//然后设置要读取的数据所存放的位置为bufs的开头

    }
如果没有预读的数据，并且BODY大小部位0，或者已经有预读数据了但是还不够，并且预读数据块后面剩下的空间不多了，不够容纳下后续读入的body，那就用rb->rest 记住还有多少BODY要读取，并且next指针指向&rb->bufs->next;也就是ngx_http_request_body_t的第一块内存的next指针地址。
后面就是申请一个新的缓冲区，并且挂入next指向的指针地址，也就是上面的&rb->bufs->next或者 &rb->bufs;就是说申请一个新的缓存及诶单，放入rb->bufs的最后面。然后就调用ngx_http_do_read_client_request_body去进行数据读取，其里面也就是一个大的循环，循环里面调用c->recv(c, rb->buf->last, size);//使劲读数据。等于ngx_unix_recv，就光读数据，不改变epoll属性。

ngx_http_do_read_client_request_body采用readv的方式读取客户端发送过来的BODY，这里就不详细介绍啦，其读取剩余的POST数据，存放在r->request_body里面，如果读完了，回调post_handler，其实就是ngx_http_upstream_init。


  size = clcf->client_body_buffer_size;//配置的最大缓冲区大小。

  size += size >> 2;//设置大小为size + 1/4*size,剩余的内容不超过缓冲区大小的1.25倍，一次读完（1.25可能是经验值吧），否则，按缓冲区大小读取。



  if (rb->rest < size) {//如果剩下的比1.25倍最大缓冲区大小要小的话

      size = (ssize_t) rb->rest;//记录所需剩余读入字节数

      if (r->request_body_in_single_buf) {//如果指定只用一个buffer则要加上预读的。
          size += preread;
      }



  } else {//如果1.25倍最大缓冲区大小不足以容纳POST数据，那我们也只读取最大POST数据了。

      size = clcf->client_body_buffer_size;
      /* disable copying buffer for r->request_body_in_single_buf */
      b = NULL;
  }



  rb->buf = ngx_create_temp_buf(r->pool, size);//分配这么多临时内存

  if (rb->buf == NULL) {
      return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  cl = ngx_alloc_chain_link(r->pool);//分配一个链接表

  if (cl == NULL) {
      return NGX_HTTP_INTERNAL_SERVER_ERROR;
  }

  cl->buf = rb->buf;//记录一下刚才申请的内存，待会数据就存放在这了。
  cl->next = NULL;//没有下一个了。

  if (b && r->request_body_in_single_buf) {//如果指定只用一个buffer则要加上预读的,那就需要把之前的数据拷贝过来

      size = b->last - b->pos;
      ngx_memcpy(rb->buf->pos, b->pos, size);
      rb->buf->last += size;
      next = &rb->bufs;//待会链接在头部。

  }

  *next = cl;//GOOD，链接起来。如果有预读数据，且可以放多个buffer,就链接在第二个位置，否则链接在第一个位置。

  if (r->request_body_in_file_only || r->request_body_in_single_buf) {
      rb->to_write = rb->bufs;//设置一下待会需要写入的位置。如果一个buffer，就头部
  } else {//否则如果已经设置了第二个位置，也就是有预读数据且有2份BUFFER，那就存在第二个里面，否则头部。
      rb->to_write = rb->bufs->next ? rb->bufs->next : rb->bufs;
  }

    r->read_event_handler = ngx_http_read_client_request_body_handler;//设置为读取客户端的请求体读取函数，其实就等于下面的，只是进行了超时判断 
    return ngx_http_do_read_client_request_body(r);//果断的去开始读取剩余数据了
}
ngx_http_do_read_client_request_body函数如果读取完了客户端发送的BODY，那么会调用rb->post_handler(r);也就是ngx_http_upstream_init函数。

3、ngx_http_upstream_init_request请求初始化：
ngx_http_upstream_init函数判断一下超时，然后设置了个EVENT标志，然后就调用ngx_http_upstream_init_request进行实质的初始化。
该函数完成2个主要功能：

1. 调用create_request创建fcgi或者proxy的数据结构。
2. 调用ngx_http_upstream_connect连接下游服务器。
下面一步步看，我们这里不考虑有cache的情况。函数签名部分调用u->create_request(r)，讲保存在r->request_body->bufs就是u->request_bufs 上面的数据解析为FastCGI的包，然后保存到u->request_bufs链接表里面。这个create_request指针我们再上面碰到过，对于FCGI为ngx_http_fastcgi_create_request，proxy为ngx_http_proxy_create_request函数，后者相对简单一些。

然后就是简单的设置了一下u->output的输出数据的结构，里面存有要发送的数据，以及发送的output_filter指针。

static void ngx_http_upstream_init_request(ngx_http_request_t *r)
{
  //ngx_http_upstream_init调用这里，此时客户端发送的数据都已经接收完毕了。
  /*
  1. 调用create_request创建fcgi或者proxy的数据结构。
  2. 调用ngx_http_upstream_connect连接下游服务器。
  */
    ngx_str_t                      *host;
    ngx_uint_t                      i;
    ngx_resolver_ctx_t             *ctx, temp;
    ngx_http_cleanup_t             *cln;
    ngx_http_upstream_t            *u;
    ngx_http_core_loc_conf_t       *clcf;
    ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
    ngx_http_upstream_main_conf_t  *umcf;
 
    u = r->upstream;//ngx_http_upstream_create里面设置的
    u->store = (u->conf->store || u->conf->store_lengths);

    if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {//ignore_client_abort忽略客户端提前断开连接。这里指不忽略客户端提前断开。
        r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;//设置回调需要检测连接是否有问题。
        r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
    }
    if (r->request_body) {//客户端发送过来的POST数据存放在此,ngx_http_read_client_request_body放的
        u->request_bufs = r->request_body->bufs;//记录客户端发送的数据，下面在create_request的时候拷贝到发送缓冲链接表里面的。
    }
    //如果是FCGI。下面组建好FCGI的各种头部，包括请求开始头，请求参数头，请求STDIN头。存放在u->request_bufs链接表里面。
    //如果是Proxy模块，ngx_http_proxy_create_request组件反向代理的头部啥的,放到u->request_bufs里面
    if (u->create_request(r) != NGX_OK) {//ngx_http_fastcgi_create_request
        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
    }
    u->peer.local = u->conf->local;
    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 
    u->output.alignment = clcf->directio_alignment;
    u->output.pool = r->pool;
    u->output.bufs.num = 1;
    u->output.bufs.size = clcf->client_body_buffer_size;
    //设置过滤模块的开始过滤函数为writer。也就是output_filter。在ngx_output_chain被调用已进行数据的过滤

    u->output.output_filter = ngx_chain_writer;
    u->output.filter_ctx = &u->writer;//参考ngx_chain_writer，里面会将输出buf一个个连接到这里。
 

    u->writer.pool = r->pool;

    if (r->upstream_states == NULL) {//数组upstream_states，保留upstream的状态信息。
        r->upstream_states = ngx_array_create(r->pool, 1, sizeof(ngx_http_upstream_state_t));

        if (r->upstream_states == NULL) {
            ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
            return;
        }

    } else {//如果已经有了，新加一个。

        u->state = ngx_array_push(r->upstream_states);

        if (u->state == NULL) {
            ngx_http_upstream_finalize_request(r, u,  NGX_HTTP_INTERNAL_SERVER_ERROR);
            return;
        }
        ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));

    }

    //挂在清理回调函数，干嘛的暂不清楚

    cln = ngx_http_cleanup_add(r, 0);//环形链表，申请一个新的元素。

    if (cln == NULL) {
        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
        return;
    }
    cln->handler = ngx_http_upstream_cleanup;//干嘛的
    cln->data = r;//指向所指的请求结构体。
    u->cleanup = &cln->handler;
然后进行fastcgi_pass 后面的URL的简析，解析出unix域，或者socket.这个在ngx_http_fastcgi_handler也会做这个操作的，如果解析完了，那在这里就不需要解析。这里不是重点，简单过了，具体可以参考褚霸的博客：http://www.pagefault.info/?p=251。

ngx_http_upstream_init_request创建FCGI格式的数据包后，就调用ngx_http_upstream_connect去连接后端的FCGI。

4、ngx_http_upstream_connect 连接后端FastCGI:
ngx_http_upstream_connect函数完成跟后端FCGI的连接，如果连接成功就进入发送请求阶段。设置各个回调。

调用socket,connect连接一个后端的peer,然后设置读写事件回调函数，进入发送数据的ngx_http_upstream_send_request里面。这里负责连接后端服务，然后设置各个读写事件回调。最后如果连接建立成功，会调用ngx_http_upstream_send_request进行数据发送。

函数首先调用ngx_event_connect_peer，获取一个peer，然后socket(),connect(),add_event之注册相关事件结构。下面看一下其简单的摘要代码：


ngx_int_t ngx_event_connect_peer(ngx_peer_connection_t *pc)

{//获取一个可用的peer,然后连接它.并注册可读，可写事件

    rc = pc->get(pc, pc->data);//ngx_http_upstream_get_round_robin_peer获取一个peer
    s = ngx_socket(pc->sockaddr->sa_family, SOCK_STREAM, 0);//新建一个SOCK
//在ngx_cycle->free_connections里面找一个空闲的位置存放这个连接，然后初始化相关成员
 c = ngx_get_connection(s, pc->log);

 //设置为非阻塞模式。

 if (ngx_nonblocking(s) == -1) {}

 //下面设置这个连接的读写回调函数。

 c->recv = ngx_recv;
 c->send = ngx_send;
 c->recv_chain = ngx_recv_chain;
 c->send_chain = ngx_send_chain;
 rc = connect(s, pc->sockaddr, pc->socklen);//然后连接它

 if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {//设置读事件}

 if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {//设置写事件}

}
ngx_http_upstream_connect的第一部分代码也就是跟后端建立连接的代码比较简单：

static void ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
{
//调用socket,connect连接一个后端的peer,然后设置读写事件回调函数，进入发送数据的ngx_http_upstream_send_request里面

//这里负责连接后端服务，然后设置各个读写事件回调。最后如果连接建立成功，会调用ngx_http_upstream_send_request进行数据发送。

 ngx_int_t          rc;

 ngx_time_t        *tp;

 ngx_connection_t  *c;
 r->connection->log->action = "connecting to upstream";
 r->connection->single_connection = 0;

 if (u->state && u->state->response_sec) {
     tp = ngx_timeofday();//获取缓存的时间
     u->state->response_sec = tp->sec - u->state->response_sec;//记录时间状态。
     u->state->response_msec = tp->msec - u->state->response_msec;
 }

 //更新一下状态数据
 u->state = ngx_array_push(r->upstream_states);//增加一个上游模块的状态

 if (u->state == NULL) {
     ngx_http_upstream_finalize_request(r, u, NGX_HTTP_INTERNAL_SERVER_ERROR);
     return;
 }

 ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
 tp = ngx_timeofday();
 u->state->response_sec = tp->sec;
 u->state->response_msec = tp->msec;

 //下面连接后的那模块，然后设置读写回调。

 rc = ngx_event_connect_peer(&u->peer);//获取一个peer，然后socket(),connect(),add_event之注册相关事件结构
 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http upstream connect: %i", rc);

 if (rc == NGX_ERROR) {
     ngx_http_upstream_finalize_request(r, u,  NGX_HTTP_INTERNAL_SERVER_ERROR);
     return;
 }

 u->state->peer = u->peer.name;

 if (rc == NGX_BUSY) {//如果这个peer被设置为忙碌状态，则尝试下一个，会递归回来的。
     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);//尝试恢复一些上游模块，然后递归调用ngx_http_upstream_connect进行连接。
     return;

 }

 if (rc == NGX_DECLINED) {
     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);//试试其他的。
     return;
    }
跟后端建立连接后，就需要设置这个连接的相关读写事件回调函数了。

/* rc == NGX_OK || rc == NGX_AGAIN */
c = u->peer.connection;//得到这个peer新建立的连接结构。
c->data = r;//记住我这个连接属于哪个请求。
c->write->handler = ngx_http_upstream_handler;//设置这个连接的读写事件结构。这是真正的读写事件回调。里面会调用write_event_handler。
c->read->handler = ngx_http_upstream_handler;//这个是读写事件的统一回调函数，不过自己会根据读还是写调用对应的write_event_handler等
//一个upstream的读写回调，专门做跟upstream有关的事情。上面的基本读写事件回调ngx_http_upstream_handler会调用下面的函数完成upstream对应的事情。
u->write_event_handler = ngx_http_upstream_send_request_handler;//设置写事件的处理函数。
u->read_event_handler = ngx_http_upstream_process_header;//读回调
c->sendfile &= r->connection->sendfile;
u->output.sendfile = c->sendfile;
c->pool = r->pool;
c->log = r->connection->log;
c->read->log = c->log;
c->write->log = c->log;
/* init or reinit the ngx_output_chain() and ngx_chain_writer() contexts */
u->writer.out = NULL;//这是i用来给ngx_chain_write函数记录发送缓冲区的。
u->writer.last = &u->writer.out;//指向自己的头部。形成循环的结构。
u->writer.connection = c;
u->writer.limit = 0;
接下来，如果客户端发送了请求的BODY，并且其写入到了临时文件里面，那就将这块r->request_body->buf存放到u->output->free空闲内存列表中去以备复用，回收。
最后调用ngx_http_upstream_send_request将客户端数据发送出去。


 if (u->request_sent) {//如果是已经发送了请求。却还需要连接，得重新初始化一下

     if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_INTERNAL_SERVER_ERROR);
         return;
     }
 }

 if (r->request_body //客户端发送过来的POST数据存放在此,ngx_http_read_client_request_body放的

     && r->request_body->buf && r->request_body->temp_file && r == r->main)

 {//request_body是FCGI结构的数据。如果客户端发送了BODY，并且这个BODY存在临时文件里面，那么我们可以立即复用 r->request_body->buf了。

     /*

      * the r->request_body->buf can be reused for one request only,

      * the subrequests should allocate their own temporay bufs

      */

     u->output.free = ngx_alloc_chain_link(r->pool);

     if (u->output.free == NULL) {
         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_INTERNAL_SERVER_ERROR);
         return;

     }//待会需要释放的东西。
     //指向请求的BODY数据部分，啥意思?把数据放到output变量里面，待会到send_request里面会拷贝到输出链表进行发送
     u->output.free->buf = r->request_body->buf;
     u->output.free->next = NULL;
     u->output.allocated = 1;
     //清空这块内存，干嘛呢?因为请求的FCGI数据已经拷贝到了ngx_http_upstream_s的request_bufs链接表里面
     r->request_body->buf->pos = r->request_body->buf->start;
     r->request_body->buf->last = r->request_body->buf->start;
     r->request_body->buf->tag = u->output.tag;
 }



 u->request_sent = 0;//还没发送请求体呢。

 if (rc == NGX_AGAIN) {//如果刚才的rc表示连接尚未建立，则设置连接超时时间。
     ngx_add_timer(c->write, u->conf->connect_timeout);
     return;
 }

#if (NGX_HTTP_SSL)

 if (u->ssl && c->ssl == NULL) {
     ngx_http_upstream_ssl_init_connection(r, u, c);
     return;
 }

#endif
    ngx_http_upstream_send_request(r, u);//已经连接成功后端，下面进行数据发送。
}
5、ngx_http_upstream_send_request发送FCGI格式数据给PHP：
下面就是ngx_http_upstream_send_request函数了，它用来发送客户端数据；限于篇幅，这部分下一篇文章介绍。电脑没电了