菜鸟nginx源码剖析数据结构篇（八）缓冲区链表ngx_chain_t[转]

菜鸟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: }

posted on 2014-12-03 21:13 小光zfg 阅读(770) 评论(0) 编辑收藏举报

菜鸟nginx源码剖析数据结构篇（八） 缓冲区链表ngx_chain_t[转]

1.缓冲区链表结构ngx_chain_t和ngx_buf_t

2.源代码位置

3.数据结构定义

4.临时buffer创建ngx_create_tmp_buf

5.创建缓冲区链表ngx_alloc_chain_link

6.缓冲区链表构建ngx_create_chain_of_bufs

7.将其它缓冲区拷贝增加到已有缓冲区末尾ngx_chain_add_copy

8.从空闲缓冲区列表中获取一个未使用的buf ngx_get_free_buf

9. buf释放 ngx_chain_update_chains

菜鸟nginx源码剖析数据结构篇（八）缓冲区链表ngx_chain_t[转]