Nginx关键数据结构分析（一） ngx_buf_t

摘要：在分析的功能之前，首先看一下使用的一些基础的数据结构及其用法，这样才能更好的理解以后的代码。从这里我们可以看到的内存分配管理其实本质上或者说基础的方法和手段是利用结构体。所以说下一步需要对这个中重要的内存分配管理的部分进行查看和分析。

在分析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字节之后需要对当前使用的缓冲区做处理，并返回当前仍未处理过的缓冲区指针。