nginx http处理（write_filter响应数据发送过滤器）

        作为处理相应数据过滤器，ngx_http_write_filter_module起到了收集响应数据（包含buffer缓冲数据及本地文件 本地文件包含实际的静态文件及缓存文件）、使用定时器设置响应限速延时的功能。

        ngx_http_write_filter_module也是使用top_body_filter来挂载在body_filter链来处理的，不过write_filter通常位于处理链的最后一个，如下图的堆栈结构也能看到，write_filter是作为最后一个来处理并发送响应数据的过滤器。如下图是处理处理包体数据在经过write_filter处理时的堆栈结构。

            

        通过write_filter处理之后的buffer链中的数据（包括内存及文件）会被预先设置的send_chain函数通过网络处理来发送到请求端。write_filter处理的代码流程如下:

ngx_int_t
ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)
{
  ...
    /*取得请求的连接*/
    c = r->connection;

    if (c->error) {  /*发现连接存在错误 直接返回错误*/
        return NGX_ERROR;
    }

    size = 0;
    flush = 0;
    sync = 0;
    last = 0;
    ll = &r->out;

    /* find the size, the flush point and the last link of the saved chain */

    for (cl = r->out; cl; cl = cl->next) {  /*响应的out链*/
        ll = &cl->next;

        ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0,
                       "write old buf t:%d f:%d %p, pos %p, size: %z "
                       "file: %O, size: %O",
                       cl->buf->temporary, cl->buf->in_file,
                       cl->buf->start, cl->buf->pos,
                       cl->buf->last - cl->buf->pos,
                       cl->buf->file_pos,
                       cl->buf->file_last - cl->buf->file_pos);

#if 1   /*检查out链中的buffer chain中保存的buffer数据 */
        if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {
            ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                          "zero size buf in writer "
                          "t:%d r:%d f:%d %p %p-%p %p %O-%O",
                          cl->buf->temporary,
                          cl->buf->recycled,
                          cl->buf->in_file,
                          cl->buf->start,
                          cl->buf->pos,
                          cl->buf->last,
                          cl->buf->file,
                          cl->buf->file_pos,
                          cl->buf->file_last);

            ngx_debug_point();
            return NGX_ERROR;
        }
#endif
        /*统计总的发送的数据大小*/
        size += ngx_buf_size(cl->buf);

        if (cl->buf->flush || cl->buf->recycled) {/*buffer需要刷新或者需要进行回收*/
            flush = 1;
        }

        if (cl->buf->sync) {  /*buffer需要进行同步*/
            sync = 1;
        }

        if (cl->buf->last_buf) { /*最后一个buffer*/
            last = 1;
        }
    }
    /*此时已经遍历到了 out链的尾部 将in链加入到out链尾部*/
    /* add the new chain to the existent one */

    for (ln = in; ln; ln = ln->next) {
        cl = ngx_alloc_chain_link(r->pool);
        if (cl == NULL) {
            return NGX_ERROR;
        }

        cl->buf = ln->buf;
        *ll = cl;
        ll = &cl->next;

        ngx_log_debug7(NGX_LOG_DEBUG_EVENT, c->log, 0,
                       "write new buf t:%d f:%d %p, pos %p, size: %z "
                       "file: %O, size: %O",
                       cl->buf->temporary, cl->buf->in_file,
                       cl->buf->start, cl->buf->pos,
                       cl->buf->last - cl->buf->pos,
                       cl->buf->file_pos,
                       cl->buf->file_last - cl->buf->file_pos);

#if 1   /*检查in链中buffer数据 在buffer为空 或者buffer不符合条件情况下会进行报错并返回错误*/
        if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {
            ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                          "zero size buf in writer "
                          "t:%d r:%d f:%d %p %p-%p %p %O-%O",
                          cl->buf->temporary,
                          cl->buf->recycled,
                          cl->buf->in_file,
                          cl->buf->start,
                          cl->buf->pos,
                          cl->buf->last,
                          cl->buf->file,
                          cl->buf->file_pos,
                          cl->buf->file_last);

            ngx_debug_point();
            return NGX_ERROR;
        }
#endif
       /*增加in链中数据的大小*/
        size += ngx_buf_size(cl->buf);

        if (cl->buf->flush || cl->buf->recycled) { /*同上述的out链判断处理*/
            flush = 1;
        }

        if (cl->buf->sync) {
            sync = 1;
        }

        if (cl->buf->last_buf) {
            last = 1;
        }
    }

    *ll = NULL;

    ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http write filter: l:%ui f:%ui s:%O", last, flush, size);
   /*得到http core模块的location域的配置*/
    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

    /*
     * avoid the output if there are no last buf, no flush point,
     * there are the incoming bufs and the size of all bufs
     * is smaller than "postpone_output" directive
     */
   /*在不是最后一个buffer并且不需要进行flush刷新同时要发送的数据量小于postpone_ouput配置的数据量(字节数) 就不会立即将数据提交到网络处理部分发送*/
    if (!last && !flush && in && size < (off_t) clcf->postpone_output) {
        return NGX_OK;
    }

    if (c->write->delayed) { /*连接的写事件需要进行延时 增加写事件缓冲mask标记 并且返回again*/
        c->buffered |= NGX_HTTP_WRITE_BUFFERED;
        return NGX_AGAIN;
    }

    if (size == 0
        && !(c->buffered & NGX_LOWLEVEL_BUFFERED)
        && !(last && c->need_last_buf))
    { /*发现需发送的字节数为0 同时连接的buffered标记不是lowlevel的 并且不满足 last与need_last_buf两个标记同时成立*/
        if (last || flush || sync) {  /*满足last或flush 或者sync标记*/
            for (cl = r->out; cl; /* void */) { /*释放整个out链*/
                ln = cl;
                cl = cl->next;
                ngx_free_chain(r->pool, ln);
            }

            r->out = NULL;
            c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;  /*清除掉buffered的mask标记 这是不需要进行后续的处理了 直接返回即可*/

            return NGX_OK;
        }

        ngx_log_error(NGX_LOG_ALERT, c->log, 0,
                      "the http output chain is empty");

        ngx_debug_point();

        return NGX_ERROR;
    }

    if (r->limit_rate) {  /*配置了限速*/
        if (r->limit_rate_after == 0) {  /*limit_rate_after为0 会从core module的配置获取 limit_rate_after意思是在超过这个值之后 限速会生效*/
            r->limit_rate_after = clcf->limit_rate_after;
        }
        /*限制值的大小由我们设置的limit_rate与处理时间差值 和 已经发送的字节数与配置的limit_rate_after值 之差计算得出 发送的值及sent过多了 limt会为负值*/
        limit = (off_t) r->limit_rate * (ngx_time() - r->start_sec + 1)
                - (c->sent - r->limit_rate_after);

        if (limit <= 0) { /*如果limit为负值 说明发送的速度快了 超过了配置的限速值 这是就会配置连接写事件延时*/
            c->write->delayed = 1;
            delay = (ngx_msec_t) (- limit * 1000 / r->limit_rate + 1);  /*由limit值和limit_rate商计算得到 乘以1000是因为定时器的单位是毫秒 +1避免delay为0*/
            ngx_add_timer(c->write, delay);  /*将连接的写事件处理加入到定时器处理 时间到了 由定时器作用*/

            c->buffered |= NGX_HTTP_WRITE_BUFFERED;  /*增加buffered的mask设置*/

            return NGX_AGAIN;
        }

        if (clcf->sendfile_max_chunk
            && (off_t) clcf->sendfile_max_chunk < limit)
        {/*发送的限制值超过了 sendfile_max_chunk 配置的值 会优先使用max_chunk配置的值而不是计算得到的值*/
            limit = clcf->sendfile_max_chunk;
        }

    } else { /*没有配置限速 直接用max_chunk 作为发送的大小*/
        limit = clcf->sendfile_max_chunk;
    }

    sent = c->sent;

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http write filter limit %O", limit);
    /*将计算得到的limit值大小的数据交由网络处理部分处理 chain是返回的处理到out链中的哪一个 可以理解遍历到了out链的哪一个元素*/
    chain = c->send_chain(c, r->out, limit);

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                   "http write filter %p", chain);

    if (chain == NGX_CHAIN_ERROR) {  /*返回的chain为CHAIN_ERROR 说明发送过程出现错误 标记连接错误 并且返回错误*/
        c->error = 1;
        return NGX_ERROR;
    }

    if (r->limit_rate) {  /*配置了限速*/

        nsent = c->sent; //已经发送的字节数

        if (r->limit_rate_after) {
            /*配置了limit_rate_after 减去 这里的sent是由send_chain处理前的也就是上一次处理的sent值*/
            sent -= r->limit_rate_after;
            if (sent < 0) { /*不得小于0*/
                sent = 0;
            }
            
            nsent -= r->limit_rate_after;  /*经过这次send_chain处理得到的sent已发送字节数*/
            if (nsent < 0) { /*同样不得小于0*/
                nsent = 0;
            }
        }
        /*比较前后两次sent值之差 计算得到写事件延时所需的时间*/
        delay = (ngx_msec_t) ((nsent - sent) * 1000 / r->limit_rate);

        if (delay > 0) { /*需要进行延时 加入到定时器*/
            limit = 0;
            c->write->delayed = 1;
            ngx_add_timer(c->write, delay);
        }
    }

    if (limit
        && c->write->ready
        && c->sent - sent >= limit - (off_t) (2 * ngx_pagesize))
    {  /*前后两次发送字节数之差超过了 计算出的limit值与 2倍的pagesize之差,pagesize是内存页的大小 这也是为了避免发送过快的处理*/
        c->write->delayed = 1;  
        ngx_add_timer(c->write, 1); /*加入到定时器*/
    }

    for (cl = r->out; cl && cl != chain; /* void */) { /*释放已经发送的chain*/
        ln = cl;
        cl = cl->next;
        ngx_free_chain(r->pool, ln);
    }

    r->out = chain;  /*更新当前需发送的响应chain的位置 （在链表中的位置 这里是修改了链表头）*/

    if (chain) { /*数据还没发完 mask标记并发挥again again会在事件触发后再次进行write_fiter 处理*/
        c->buffered |= NGX_HTTP_WRITE_BUFFERED;
        return NGX_AGAIN;
    }

    c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;  /*清理掉 mask标记*/
    /*连接的buffer缓冲标记为lowlevel_buffered 同时请求不需要postponed即延迟处理 返回again */
    if ((c->buffered & NGX_LOWLEVEL_BUFFERED) && r->postponed == NULL) {
          return NGX_AGAIN;
    }

    return NGX_OK;
}