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