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_tfile_pos; off_tfile_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 = clngx_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_tngx_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中的链表操作很多都是头链表操作，即如果需要添加链表元素的话通常都将该元素添加到头上
voidngx_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字节之后需要对当前使用的缓冲区做处理，并返回当前仍未处理过的缓冲区指针。