nginx中的output chain的处理(一)

sszxf

这里我们详细来看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;