本文主要是介绍菜鸟nginx源码剖析数据结构篇（八） 缓冲区链表ngx_chain_t，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
分类： Server - 菜鸟nginx源码剖析 2014-11-06 19:54 10195人阅读 评论(7) 收藏 举报
nginx 数据结构 缓冲区 源码
目录(?)[+]
菜鸟nginx源码剖析数据结构篇（八） 缓冲区链表 ngx_chain_t
-
Author：Echo Chen（陈斌）
-
Email：chenb19870707@gmail.com
-
Blog：Blog.csdn.net/chen19870707
-
Date：Nov 6th, 2014
1.缓冲区链表结构ngx_chain_t和ngx_buf_t
nginx的缓冲区链表如下图所示，ngx_chain_t为链表，ngx_buf_t为缓冲区结点：
2.源代码位置
头文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_buf.h
源文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_buf.c
3.数据结构定义
ngx_buf_t为缓冲区结点，其定义如下：
1: typedef struct ngx_buf_s ngx_buf_t;
2: typedef void *ngx_buf_tag_t;
3: struct ngx_buf_s {
4: /*
5: * pos通常是用来告诉使用者本次应该从pos这个位置开始处理内存中的数据，这样设置是因为同一个
6: * ngx_buf_t可能被多次反复处理。当然，pos的含义是由使用它的模板定义的
7: */
8: u_char *pos;9:10: /* last通常表示有效的内容到此为止，注意，pos与last之间的内存是希望nginx处理的内容 */
11: u_char *last;12:13: /*
14: * 处理文件时，file_pos与file_last的含义与处理内存时的pos与last相同，
15: * file_pos表示将要处理的文件位置，file_last表示截至的文件位置。
16: */
17: off_t file_pos;18: off_t file_last;19:20: /* 如果ngx_buf_t缓冲区用于内存，那么start指向这段内存的起始地址 */
21: u_char *start;22:23: /* 与start成员对应，指向缓冲区内存的末尾 */
24: u_char *end;25:26: /* 表示当前缓冲区的类型，例如由哪个模块使用就指向这个模块ngx_module_t变量的地址 */
27: ngx_buf_tag_t tag;28:29: /* 引用的文件 */
30: ngx_file_t *file;31:32: /*
33: * 当前缓冲区的影子缓冲区，该成员很少用到。当缓冲区转发上游服务器的响应时才使用了shadow成员，
34: * 这是因为nginx太节约内存了，分配一块内存并使用ngx_buf_t表示接收到的上游服务器响应后，
35: * 在向下游客户端转发时可能会把这块内存存储到文件中，也可能直接向下游发送，此时nginx绝对不会
36: * 重新复制一份内存用于新的目的，而是再次建立一个ngx_buf_t结构体指向原内存，这样多个ngx_buf_t
37: * 结构体指向了同一份内存，它们之间的关系就通过shadow成员来引用，一般不建议使用。
38: */
39: ngx_buf_t *shadow;40:41: /* 临时内存标志位，为1时表示数据在内存中且这段内存可以修改 */
42: unsigned temporay:1;
43:44: /* 标志位，为1时表示数据在内存中且这段内存不可以修改 */
45: unsigned memory:1;
46:47: /* 标志位，为1时表示这段内存是用nmap系统调用映射过来的，不可以修改 */
48: unsigned mmap:1;
49:50: /* 标志位，为1时表示可回收 */
51: unsigned recycled:1;
52:53: /* 标志位，为1时表示这段缓冲区处理的是文件而不是内存 */
54: unsigned in_file:1;
55:56: /* 标志位，为1时表示需要执行flush操作 */
57: unsigned flush:1;
58:59: /*
60: * 标志位，对于操作这块缓冲区时是否使用同步方式，需谨慎考虑，这可能会阻塞nginx进程，nginx中所有
61: * 操作几乎都是异步的，这是它支持高并发的关键。有些框架代码在sync为1时可能会有阻塞的方式进行I/O
62: * 操作，它的意义视使用它的nginx模块而定。
63: */
64: unsigned sync:1;
65:66: /*
67: * 标志位，表示是否是最后一块缓冲区，因为ngx_buf_t可以由ngx_chain_t链表串联起来，因此为1时，
68: * 表示当前是最后一块待处理的缓冲区。
69: */
70: unsigned last_buf:1;
71:72: /* 标志位，表示是否是ngx_chain_t中的最后一块缓冲区 */
73: unsigned last_in_chain:1;
74:75: /* 标志位，表示是否是最后一个影子缓冲区，与shadow域配合使用。通常不建议使用它 */
76: unsigned last_shadow:1;
77:78: /* 标志位，表示当前缓冲区是否属于临时文件 */
79: unsigned temp_file:1;
80: }ngx_chain_t为缓冲区链表，其结构如下：
1: typedef struct ngx_chain_s ngx_chain_t;
2: struct ngx_chain_s {
3: ngx_buf_t *buf; //buf指向当前的ngx_buf_t缓冲区
4: ngx_chain_t *next; //next则用来指向下一个ngx_chain_t，如果这是最后一个ngx_chain_t，则需要把next置为NULL。
5: };4.临时buffer创建ngx_create_tmp_buf
1: ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size)2: {3: ngx_buf_t *b;4:5: b = ngx_calloc_buf(pool); //分配ngx_buf_t
6: if (b == NULL) {
7: return NULL;
8: }9:10: b->start = ngx_palloc(pool, size); //给ngx_buf_t分配buffer
11: if (b->start == NULL) {
12: return NULL;
13: }14:15: /*
16: * set by ngx_calloc_buf():
17: *
18: * b->file_pos = 0;
19: * b->file_last = 0;
20: * b->file = NULL;
21: * b->shadow = NULL;
22: * b->tag = 0;
23: * and flags
24: */
25:26: //设置起始位置pos和结束位置last,end指向缓冲区的末尾，临时标志设置为1
27: b->pos = b->start;28: b->last = b->start;29: b->end = b->last + size;30: b->temporary = 1;31:32: return b;
33: }5.创建缓冲区链表ngx_alloc_chain_link
1: ngx_chain_t *ngx_alloc_chain_link(ngx_pool_t *pool)2: {3: ngx_chain_t *cl;4:5: cl = pool->chain;6:7: if (cl)
8: {9: pool->chain = cl->next;10: return cl;
11: }12:13: cl = ngx_palloc(pool, sizeof(ngx_chain_t));
14: if (cl == NULL)
15: {16: return NULL;
17: }18:19: return cl;
20: }6.缓冲区链表构建ngx_create_chain_of_bufs
构建如下的缓冲区链表，代码比较简单，很容易理解：
1: ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)2: {3: u_char *p;4: ngx_int_t i;5: ngx_buf_t *b;6: ngx_chain_t *chain, *cl, **ll;7:8: //分配buf内存
9: p = ngx_palloc(pool, bufs->num * bufs->size);10: if (p == NULL)
11: {12: return NULL;
13: }14:15: ll = &chain;16:17: for (i = 0; i < bufs->num; i++)
18: {19: //分配ngx_buf_t内存
20: b = ngx_calloc_buf(pool);21: if (b == NULL)
22: {23: return NULL;
24: }25:26: /*
27: * set by ngx_calloc_buf():
28: *
29: * b->file_pos = 0;
30: * b->file_last = 0;
31: * b->file = NULL;
32: * b->shadow = NULL;
33: * b->tag = 0;
34: * and flags
35: *
36: */
37:38: b->pos = p;39: b->last = p;40: b->temporary = 1;41:42: b->start = p;43: p += bufs->size;44: b->end = p;45:46: //分配ngx_chain_t
47: cl = ngx_alloc_chain_link(pool);48: if (cl == NULL)
49: {50: return NULL;
51: }52:53: //
54: cl->buf = b;55: *ll = cl;56: ll = &cl->next;57: }58:59: //最后一个结点指向NULL
60: *ll = NULL;61:62: return chain;
63: }7.将其它缓冲区拷贝增加到已有缓冲区末尾ngx_chain_add_copy
1: ngx_int_t ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)2: {3: ngx_chain_t *cl, **ll;4:5: ll = chain;6:7: //找到缓冲区末尾，即为NULL
8: for (cl = *chain; cl; cl = cl->next)
9: {10: ll = &cl->next;11: }12:13: while (in)
14: {15: //遍历in，依次拷贝每一个结点
16: cl = ngx_alloc_chain_link(pool);17: if (cl == NULL)
18: {19: return NGX_ERROR;
20: }21:22: cl->buf = in->buf;23: *ll = cl;24: ll = &cl->next;25: in = in->next;26: }27:28: //缓冲区末尾赋值为NULL
29: *ll = NULL;30:31: return NGX_OK;
32: }8.从空闲缓冲区列表中获取一个未使用的buf ngx_get_free_buf
ngx_chain_get_free_buf 得到链表中未使用的buf，如果没有，则分配一个。1: ngx_chain_t *ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)2: {3: ngx_chain_t *cl;4:5: //若空闲链表中有结点，直接返回
6: if (*free)
7: {8: cl = *free;9: *free = cl->next;10: cl->next = NULL;11: return cl;
12: }13:14: //否则分配ngx_chain_t
15: cl = ngx_alloc_chain_link(p);16: if (cl == NULL) {
17: return NULL;
18: }19:20: //并给ngx_chain_t分配buf
21: cl->buf = ngx_calloc_buf(p);22: if (cl->buf == NULL)
23: {24: return NULL;
25: }26:27: cl->next = NULL;28:29: return cl;
30: }9. buf释放 ngx_chain_update_chains
1:2: void ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
3: ngx_chain_t **out, ngx_buf_tag_t tag)4: {5: ngx_chain_t *cl;6:7: //让busy指向out
8: if (*busy == NULL)
9: {10: *busy = *out;11:12: }13: else
14: {15: for (cl = *busy; cl->next; cl = cl->next) { /* void */ }
16:17: cl->next = *out;18: }19:20: *out = NULL;21:22: while (*busy)
23: {24: cl = *busy;25:26: //这个结点内存有占用，不满足释放条件，跳出
27: if (ngx_buf_size(cl->buf) != 0)
28: {29: break;
30: }31:32: //缓冲区类型不同，直接释放
33: if (cl->buf->tag != tag)
34: {35: *busy = cl->next;36: ngx_free_chain(p, cl);37: continue;
38: }39:40: //将该结点放入free
41: cl->buf->pos = cl->buf->start;42: cl->buf->last = cl->buf->start;43:44: *busy = cl->next;45: cl->next = *free;46: *free = cl;47: }48: }-
Echo Chen：Blog.csdn.net/chen19870707
这篇关于菜鸟nginx源码剖析数据结构篇（八） 缓冲区链表ngx_chain_t的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
