nginx中的output chain的处理(一)

阅读更多

这里我们详细来看ngx_linux_sendfile_chain方法，这个函数也就是nginx的发送函数。

一般来说，我们最终都会调用这个函数来发送最终的数据，因此我们来着重分析这个函数，这里主要就是对buf的一些参数的理解。

来看函数原型：

ngx_chain_t *
ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)

第一个参数是当前的连接，第二个参数是所需要发送的chain，第三个参数是所能发送的最大值。

然后来看这里的几个重要的变量：

send 表示将要发送的buf已经已经发送的大小。
sent表示已经发送的buf的大小
prev_send 表示上一次发送的大小，也就是已经发送的buf的大小。
fprev 和prev-send类似，只不过是file类型的。

complete表示是否buf被完全发送了，也就是sent是否等于send - prev_send.

header表示需要是用writev来发送的buf。也就是only in memory的buf。

struct iovec  *iov, headers[NGX_HEADERS] 这个主要是用于sendfile和writev的参数，这里注意上面header数组保存的就是iovec。

然后我们来看初始化

   

wev = c->write;

    if (!wev->ready) {
        return in;
    }

    if (limit == 0 || limit > (off_t) (NGX_SENDFILE_LIMIT - ngx_pagesize)) {
        limit = NGX_SENDFILE_LIMIT - ngx_pagesize;
    }


    send = 0;
//设置header，也就是in memory的数组
    header.elts = headers;
    header.size = sizeof(struct iovec);
    header.nalloc = NGX_HEADERS;
    header.pool = c->pool;

这里nginx的处理核心思想就是合并内存连续并相邻的buf(不管是in memory还是in file)

下面这段代码就是处理in memory的部分，然后将buf放入对应的iovec数组。

//开始遍历
for (cl = in;
             cl && header.nelts < IOV_MAX && send < limit;
             cl = cl->next)
        {
            if (ngx_buf_special(cl->buf)) {
                continue;
            }
//如果不止是在buf中，这是因为有时in file的文件我们可能需要内存中也有拷贝，所以如果一个buf同时in memoey和in file的话，nginx会认为它是in file的来处理。
            if (!ngx_buf_in_memory_only(cl->buf)) {
                break;
            }

//得到buf的大小
            size = cl->buf->last - cl->buf->pos;

//大于limit的话修改为size
            if (send + size > limit) {
                size = limit - send;
            }
//如果prev等于pos，则说明当前的buf的数据和前一个buf的数据是连续的。
            if (prev == cl->buf->pos) {
                iov->iov_len += (size_t) size;

            } else {
//否则说明是不同的buf，因此add一个iovc。
                iov = ngx_array_push(&header);
                if (iov == NULL) {
                    return NGX_CHAIN_ERROR;
                }

                iov->iov_base = (void *) cl->buf->pos;
                iov->iov_len = (size_t) size;
            }

//这里可以看到prev保存了当前buf的结尾。
            prev = cl->buf->pos + (size_t) size;
//更新发送的大小
            send += size;
        }

然后是in file的处理这里比较核心的一个判断就是fprev == cl->buf->file_pos，和上面的in memory类似，fprev保存的就是上一次处理的buf的尾部。这里如果这两个相等，那就说明当前的两个buf是连续的(文件连续).

ok.来看代码。

//可以看到如果header的大小不为0则说明前面有需要发送的buf，因此我们就跳过in file处理
if (header.nelts == 0 && cl && cl->buf->in_file && send < limit) {
//得到file
            file = cl->buf;

//开始合并。
            do {
//得到大小
                size = cl->buf->file_last - cl->buf->file_pos;

//如果太大则进行对齐处理。
                if (send + size > limit) {
                    size = limit - send;

                    aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
                               & ~((off_t) ngx_pagesize - 1);

                    if (aligned <= cl->buf->file_last) {
                        size = aligned - cl->buf->file_pos;
                    }
                }

//设置file_size.
                file_size += (size_t) size;
//设置需要发送的大小
                send += size;
//和上面的in memory处理一样就是保存这次的last
                fprev = cl->buf->file_pos + size;
                cl = cl->next;

            } while (cl
                     && cl->buf->in_file
                     && send < limit
                     && file->file->fd == cl->buf->file->fd
                     && fprev == cl->buf->file_pos);
        }

然后就是发送部分，这里in file使用sendfile,in memory使用writev.这里处理比较简单，就是发送然后判断发送的大小

if (file) {
#if 1
            if (file_size == 0) {
                ngx_debug_point();
                return NGX_CHAIN_ERROR;
            }
#endif
#if (NGX_HAVE_SENDFILE64)
            offset = file->file_pos;
#else
            offset = (int32_t) file->file_pos;
#endif

//发送数据
            rc = sendfile(c->fd, file->file->fd, &offset, file_size);
......................................................
//得到发送的字节数
            sent = rc > 0 ? rc : 0;

        } else {
            rc = writev(c->fd, header.elts, header.nelts);
.......................................................................

            sent = rc > 0 ? rc : 0;
}
        

接下来这部分就是更新标记的部分，主要是buf的标记。

这里要注意一个地方，那就是ngx_buf_size部分，这个宏很简单就是判断buf是不是在memory中，如果是的话，就用pos和last计算，否则认为是在file中。

可是这里就有个问题了，如果一个buf本来是在file中的，我们由于某种原因，在内存中也有一份拷贝，可是我们并没有修改内存中的副本，于是如果我们还需要切割这个buf，这个时候，如果last和pos也就是buf对应的指针没有设置正确的话，这里就会出现问题了。

这里我觉得应该还有个标记，那就是如果内存中的副本我只是只读的话，发送的时候不应该算它在memory中。

//如果send - prev_send == sent则说明该发送的都发完了。
if (send - prev_send == sent) {
            complete = 1;
        }
//更新congnect的sent域。
        c->sent += sent;

//开始重新遍历chain，这里是为了防止没有发送完全的情况，此时我们就需要切割buf了。
        for (cl = in; cl; cl = cl->next) {

            if (ngx_buf_special(cl->buf)) {
                continue;
            }

            if (sent == 0) {
                break;
            }
//得到buf size
            size = ngx_buf_size(cl->buf);

//如果大于当前的size，则说明这个buf的数据已经被完全发送完毕了。，因此更新它的域。
            if (sent >= size){
//更新sent域
                sent -= size;
//如果在内存则更新pos
                if (ngx_buf_in_memory(cl->buf)) {
                    cl->buf->pos = cl->buf->last;
                }
//如果在file
                if (cl->buf->in_file) {
                    cl->buf->file_pos = cl->buf->file_last;
                }

                continue;
            }

//到这里说明当前的buf只有一部分被发送出去了，因此这里我们只需要修改指针。以便于下次发送。
            if (ngx_buf_in_memory(cl->buf)) {
                cl->buf->pos += (size_t) sent;
            }
//同上。
            if (cl->buf->in_file) {
                cl->buf->file_pos += sent;
            }

            break;
        }

最后一部分就是一些是否退出循环的操作。这里要注意，nginx中如果发送未完全的话，将会直接返回的，返回的就是没有发送完毕的chain，它的buf也已经被更新。这是因为nginx是单线程的，不能有任何意义的空跑和阻塞，因此当complete为0,nginx就认为是系统负载过大，此时直接返回，然后处理其他的事情，等待和下次的chain一起发送。

if (eintr) {
            continue;
        }
//如果未完成，则返回。
        if (!complete) {
            wev->ready = 0;
            return cl;
        }

        if (send >= limit || cl == NULL) {
            return cl;
        }
//更新in，也就是开始处理下一个chain
        in = cl;