Return to ngx_writev_chain.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / os / unix

Annotation of embedaddon/nginx/src/os/unix/ngx_writev_chain.c, revision 1.1.1.1

1.1       misho       1: 
                      2: /*
                      3:  * Copyright (C) Igor Sysoev
                      4:  * Copyright (C) Nginx, Inc.
                      5:  */
                      6: 
                      7: 
                      8: #include <ngx_config.h>
                      9: #include <ngx_core.h>
                     10: #include <ngx_event.h>
                     11: 
                     12: 
                     13: #if (IOV_MAX > 64)
                     14: #define NGX_IOVS  64
                     15: #else
                     16: #define NGX_IOVS  IOV_MAX
                     17: #endif
                     18: 
                     19: 
                     20: ngx_chain_t *
                     21: ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
                     22: {
                     23:     u_char        *prev;
                     24:     ssize_t        n, size, sent;
                     25:     off_t          send, prev_send;
                     26:     ngx_uint_t     eintr, complete;
                     27:     ngx_err_t      err;
                     28:     ngx_array_t    vec;
                     29:     ngx_chain_t   *cl;
                     30:     ngx_event_t   *wev;
                     31:     struct iovec  *iov, iovs[NGX_IOVS];
                     32: 
                     33:     wev = c->write;
                     34: 
                     35:     if (!wev->ready) {
                     36:         return in;
                     37:     }
                     38: 
                     39: #if (NGX_HAVE_KQUEUE)
                     40: 
                     41:     if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
                     42:         (void) ngx_connection_error(c, wev->kq_errno,
                     43:                                "kevent() reported about an closed connection");
                     44:         wev->error = 1;
                     45:         return NGX_CHAIN_ERROR;
                     46:     }
                     47: 
                     48: #endif
                     49: 
                     50:     /* the maximum limit size is the maximum size_t value - the page size */
                     51: 
                     52:     if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
                     53:         limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
                     54:     }
                     55: 
                     56:     send = 0;
                     57: 
                     58:     vec.elts = iovs;
                     59:     vec.size = sizeof(struct iovec);
                     60:     vec.nalloc = NGX_IOVS;
                     61:     vec.pool = c->pool;
                     62: 
                     63:     for ( ;; ) {
                     64:         prev = NULL;
                     65:         iov = NULL;
                     66:         eintr = 0;
                     67:         complete = 0;
                     68:         prev_send = send;
                     69: 
                     70:         vec.nelts = 0;
                     71: 
                     72:         /* create the iovec and coalesce the neighbouring bufs */
                     73: 
                     74:         for (cl = in; cl && send < limit; cl = cl->next) {
                     75: 
                     76:             if (ngx_buf_special(cl->buf)) {
                     77:                 continue;
                     78:             }
                     79: 
                     80: #if 1
                     81:             if (!ngx_buf_in_memory(cl->buf)) {
                     82:                 ngx_debug_point();
                     83:             }
                     84: #endif
                     85: 
                     86:             size = cl->buf->last - cl->buf->pos;
                     87: 
                     88:             if (send + size > limit) {
                     89:                 size = (ssize_t) (limit - send);
                     90:             }
                     91: 
                     92:             if (prev == cl->buf->pos) {
                     93:                 iov->iov_len += size;
                     94: 
                     95:             } else {
                     96:                 if (vec.nelts >= IOV_MAX) {
                     97:                     break;
                     98:                 }
                     99: 
                    100:                 iov = ngx_array_push(&vec);
                    101:                 if (iov == NULL) {
                    102:                     return NGX_CHAIN_ERROR;
                    103:                 }
                    104: 
                    105:                 iov->iov_base = (void *) cl->buf->pos;
                    106:                 iov->iov_len = size;
                    107:             }
                    108: 
                    109:             prev = cl->buf->pos + size;
                    110:             send += size;
                    111:         }
                    112: 
                    113:         n = writev(c->fd, vec.elts, vec.nelts);
                    114: 
                    115:         if (n == -1) {
                    116:             err = ngx_errno;
                    117: 
                    118:             switch (err) {
                    119:             case NGX_EAGAIN:
                    120:                 break;
                    121: 
                    122:             case NGX_EINTR:
                    123:                 eintr = 1;
                    124:                 break;
                    125: 
                    126:             default:
                    127:                 wev->error = 1;
                    128:                 (void) ngx_connection_error(c, err, "writev() failed");
                    129:                 return NGX_CHAIN_ERROR;
                    130:             }
                    131: 
                    132:             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
                    133:                            "writev() not ready");
                    134:         }
                    135: 
                    136:         sent = n > 0 ? n : 0;
                    137: 
                    138:         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "writev: %z", sent);
                    139: 
                    140:         if (send - prev_send == sent) {
                    141:             complete = 1;
                    142:         }
                    143: 
                    144:         c->sent += sent;
                    145: 
                    146:         for (cl = in; cl; cl = cl->next) {
                    147: 
                    148:             if (ngx_buf_special(cl->buf)) {
                    149:                 continue;
                    150:             }
                    151: 
                    152:             if (sent == 0) {
                    153:                 break;
                    154:             }
                    155: 
                    156:             size = cl->buf->last - cl->buf->pos;
                    157: 
                    158:             if (sent >= size) {
                    159:                 sent -= size;
                    160:                 cl->buf->pos = cl->buf->last;
                    161: 
                    162:                 continue;
                    163:             }
                    164: 
                    165:             cl->buf->pos += sent;
                    166: 
                    167:             break;
                    168:         }
                    169: 
                    170:         if (eintr) {
                    171:             continue;
                    172:         }
                    173: 
                    174:         if (!complete) {
                    175:             wev->ready = 0;
                    176:             return cl;
                    177:         }
                    178: 
                    179:         if (send >= limit || cl == NULL) {
                    180:             return cl;
                    181:         }
                    182: 
                    183:         in = cl;
                    184:     }
                    185: }