在分析nginx的功能之前，首先看一下nginx使用的一些基础的数据结构及其用法，这样才能更好的理解以后的代码。

typedef struct ngx_buf_s  ngx_buf_t;

typedef void *            ngx_buf_tag_t;

struct ngx_buf_s {
    u_char          *pos;
    u_char          *last;
    off_t            file_pos;
    off_t            file_last;

    u_char          *start;         /* start of buffer */

    u_char          *end;           /* end of buffer */
    ngx_buf_tag_t    tag;           /* 表示当前缓冲区的类型，如果是哪个模块使用就为该模块的ngx_module_t变量的地址 */
    ngx_file_t      *file;
    ngx_buf_t       *shadow;

    /* the buf's content could be changed */
    /* 临时内存标志位，表示当前buf在内存中并且是可以修改的 */
    unsigned         temporary:1;

    /* buf在内存中并且是不可以修改的＊/
    unsigned         memory:1;

    /* the buf's content is mmap()ed and must not be changed*/
    /* buf的内存空间是由mmap生成的，不可以被修改*/
    unsigned         mmap:1;

    unsigned         recycled:1;
    unsigned         in_file:1;
    unsigned         flush:1;
    unsigned         sync:1;
    unsigned         last_buf:1;
    unsigned         last_in_chain:1;

    unsigned         last_shadow:1;
    unsigned         temp_file:1;

    /* STUB */ int   num;

};

typedef struct ngx_chain_s ngx_chain_t;

struct ngx_chain_s {
    ngx_buf_t    *buf;
    ngx_chain_t  *next;
};

typedef struct {
    ngx_int_t    num;
    size_t       size;
} ngx_bufs_t;

其中要注意的是shadow指针，该指针用于指向原有的内存空间从而减少了nginx的内存消耗，该技术使用起来很高端，在能力低端的时候不要使用
在结构体中了start、end表示的是该块指定的内存的开始和结束，而position和last则是提醒程序本次使用的内存空间只有这些。
而ngx_bufs_t则应该是起到一个管理的作用，用于说明当前使用的bufs的数量和每个buf的存储空间的大小

#define  NGX_ERROR      -1     // ngx_core.h

#define NGX_CHAIN_ERROR     (ngx_chain_t *) NGX_ERROR

#define ngx_buf_in_memory(b)        (b->temporary || b->memory || b->mmap)
#define ngx_buf_in_memory_only(b)   (ngx_buf_in_memory(b) && !b->in_file)

#define ngx_buf_special(b)                                                   \
    ((b->flush || b->last_buf || b->sync)                                    \
     && !ngx_buf_in_memory(b) && !b->in_file)

#define ngx_buf_sync_only(b)                                                 \
    (b->sync                                                                 \
     && !ngx_buf_in_memory(b) && !b->in_file && !b->flush && !b->last_buf)

#define ngx_buf_size(b)                                                      \
    (ngx_buf_in_memory(b) ? (off_t) (b->last - b->pos):                      \
                        (b->file_last - b->file_pos))

#define ngx_alloc_buf(pool)  ngx_palloc(pool, sizeof(ngx_buf_t))

#define ngx_calloc_buf(pool) ngx_pcalloc(pool, sizeof(ngx_buf_t))
#define ngx_free_chain(pool, cl)                                             \
    cl->next = pool->chain;                                                  \

    pool->chain = cl

ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size);
ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs);
ngx_chain_t *ngx_alloc_chain_link(ngx_pool_t *pool);

ngx_buf_t *
ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
{
    ngx_buf_t *b;

    b = ngx_calloc_buf(pool);
    if (b == NULL) {
        return NULL;
    }

    b->start = ngx_palloc(pool, size);
    if (b->start == NULL) {
        return NULL;
    }
    b->pos = b->start;
    b->last = b->start;
    b->end = b->last + size;
    b->temporary = 1;

    return b;

}

这段代码是表示怎样创建生成一个temp的buf，并且从代码中也可以看到一段buf的内存空间是怎样分配的，通过ngx_palloc这个函数来完成分配的，并且由于在初始创建buf结构体的时候使用的函数是ngx_calloc_buf，所以针对分配的内存实行了清零操作

ngx_chain_t *
ngx_alloc_chain_link(ngx_pool_t *pool)
{
    ngx_chain_t  *cl;

    cl = pool->chain;

    if (cl) {
        pool->chain = cl->next;
        return cl;
    }

    cl = ngx_palloc(pool, sizeof(ngx_chain_t));
    if (cl == NULL) {
        return NULL;
    }

    return cl;

}

而这段代码则是表明在nginx中，chain是通过pool来生成的，而且每次通过在pool的开头提取的方式来完成的

ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
{
    u_char       *p;
    ngx_int_t     i;
    ngx_buf_t    *b;
    ngx_chain_t  *chain, *cl, **ll;

    p = ngx_palloc(pool, bufs->num * bufs->size);
    if (p == NULL) {
        return NULL;
    }

    ll = &chain;

    for (i = 0; i < bufs->num; i++) {

        b = ngx_calloc_buf(pool);
        if (b == NULL) {
            return NULL;
        }
        b->pos = p;
        b->last = p;
        b->temporary = 1;

        b->start = p;
        p += bufs->size;
        b->end = p;

        cl = ngx_alloc_chain_link(pool);
        if (cl == NULL) {
            return NULL;
        }

        cl->buf = b;
        *ll = cl;
        ll = &cl->next;
    }

    *ll = NULL;／／到最后将生成的ngx_chain_t的next指针指向NULL，表明整个链表生成完毕。

    return chain;

}

这段代码则表明了ngx_bufs_t类型是怎样运用的，利用num 和 size来创建一段缓冲区，该缓冲区用于表示ngx_chain_t中的所有的节点中的buf都是从该段缓冲区中分配出来的，但是所有的cl都是从pool中的chain中分配下来重新利用的或者是重新创建的（详细情况查看ngx_alloc_chain_link函数。

从这里我们可以看到nginx的内存分配管理其实本质上或者说基础的方法和手段是利用ngx_pool_t结构体。所以说下一步需要对这个nginx中重要的内存分配管理的部分进行查看和分析。
然后还存在多个针对ngx_buf_t类型的基本操作（其实应该说是针对ngx_chain_t类型的基本操作
ngx_chain_add_copy

ngx_int_t
ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
{
    ngx_chain_t  *cl, **ll;

    ll = chain;
    /* 遍历chain，查找到chain的最后结尾 */
    for (cl = *chain; cl; cl = cl->next) {
        ll = &cl->next;

    }
    /* 遍历in，并且创建分配chain的基本节点，并将其buf指向in的部分 */
    while (in) {
        cl = ngx_alloc_chain_link(pool);
        if (cl == NULL) {
            return NGX_ERROR;
        }

        cl->buf = in->buf;
        *ll = cl;
        ll = &cl->next;
        in = in->next;
    }

    *ll = NULL;//最后将最后一个chain节点的next指向一个NULL指针

    return NGX_OK;

}

该函数是在现有的chain的基础上将一个链表“复制”连接到该chain后面，但是从操作中我们可以看到，这个过程虽然说是“复制”，但是针对buf中实际的内存的操作仅仅是将针对连接上罢了。

ngx_chain_t *
ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)
{
    ngx_chain_t  *cl;

    if (*free) {
        cl = *free;
        *free = cl->next;
        cl->next = NULL;
        return cl;
    }

    cl = ngx_alloc_chain_link(p);
    if (cl == NULL) {
        return NULL;
    }

    cl->buf = ngx_calloc_buf(p);
    if (cl->buf == NULL) {
        return NULL;
    }

    cl->next = NULL;

    return cl;

}

这段代码从名字上来看是获得一个free的buf，实际上是从一个free的链表中获得一个chain节点或者是重新分配一个chain节点
nginx中的链表操作很多都是头链表操作，即如果需要添加链表元素的话通常都将该元素添加到头上

void
ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
    ngx_chain_t **out, ngx_buf_tag_t tag)
{
    ngx_chain_t  *cl;

    if (*busy == NULL) {
        *busy = *out;

    } else {
        for (cl = *busy; cl->next; cl = cl->next) { /* void */ }

        cl->next = *out;
    }

    *out = NULL;

    while (*busy) {
        cl = *busy;

        if (ngx_buf_size(cl->buf) != 0) {
            break;
        }

        if (cl->buf->tag != tag) {
            *busy = cl->next;
            ngx_free_chain(p, cl);
            continue;
        }

        cl->buf->pos = cl->buf->start;
        cl->buf->last = cl->buf->start;

        *busy = cl->next;
        cl->next = *free;
        *free = cl;
    }

}

需要处理的链表是out指针指向的链表，而free指向的应该就是当前存在的free链表，而busy链表则是当前存在的busy链表，该链表也是待处理的链表
所以开始的时候需要判断将out应该放到哪一个位置，如果busy当前就存在的话，那么就应该将out放置到busy的最后，如果当前busy链表不存在，那么处理就是
将其作为busy链表进行处理
而后面的操作则是说明从头对busy链表实行检查，如果busy链表中的buf还存在需要处理的内存空间，那么就需要停止处理，否则就将其置为空（即对last和pos进行处理）

ngx_chain_t *
ngx_chain_update_sent(ngx_chain_t *in, off_t sent)
{
    off_t  size;

    for ( /* void */ ; in; in = in->next) {

        if (ngx_buf_special(in->buf)) {
            continue;
        }

        if (sent == 0) {
            break;
        }

        size = ngx_buf_size(in->buf);

        if (sent >= size) {
            sent -= size;

            if (ngx_buf_in_memory(in->buf)) {
                in->buf->pos = in->buf->last;
            }

            if (in->buf->in_file) {
                in->buf->file_pos = in->buf->file_last;
            }

            continue;
        }

        if (ngx_buf_in_memory(in->buf)) {
            in->buf->pos += (size_t) sent;
        }

        if (in->buf->in_file) {
            in->buf->file_pos += sent;
        }

        break;
    }

    return in;

}

该函数处理的情况就更加的容易理解了，就是说当发送了sent字节之后需要对当前使用的缓冲区做处理，并返回当前仍未处理过的缓冲区指针。