One Level Up Top Level

src/os/unix/ngx_writev_chain.c - nginx-1.7.10

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. ngx_chain_t *
  14. ‌ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  15. {
  16.     ssize_t        n, sent;
  17.     off_t          send, prev_send;
  18.     ngx_chain_t   *cl;
  19.     ngx_event_t   *wev;
  20.     ngx_iovec_t    vec;
  21.     struct iovec   iovs[NGX_IOVS_PREALLOCATE];

  23.     wev = c->write;

  25.     if (!wev->ready) {
  26.         return in;
  27.     }

  29. #if (NGX_HAVE_KQUEUE)

  31.     if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
  32.         (void) ngx_connection_error(c, wev->kq_errno,
  33.                                "kevent() reported about an closed connection");
  34.         wev->error = 1;
  35.         return NGX_CHAIN_ERROR;
  36.     }

  38. #endif

  40.     /* the maximum limit size is the maximum size_t value - the page size */

  42.     if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
  43.         limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
  44.     }

  46.     send = 0;

  48.     vec.iovs = iovs;
  49.     vec.nalloc = NGX_IOVS_PREALLOCATE;

  51.     for ( ;; ) {
  52.         prev_send = send;

  54.         /* create the iovec and coalesce the neighbouring bufs */

  56.         cl = ngx_output_chain_to_iovec(&vec, in, limit - send, c->log);

  58.         if (cl == NGX_CHAIN_ERROR) {
  59.             return NGX_CHAIN_ERROR;
  60.         }

  62.         if (cl && cl->buf->in_file) {
  63.             ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  64.                           "file buf in writev "
  65.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  66.                           cl->buf->temporary,
  67.                           cl->buf->recycled,
  68.                           cl->buf->in_file,
  69.                           cl->buf->start,
  70.                           cl->buf->pos,
  71.                           cl->buf->last,
  72.                           cl->buf->file,
  73.                           cl->buf->file_pos,
  74.                           cl->buf->file_last);

  76.             ngx_debug_point();

  78.             return NGX_CHAIN_ERROR;
  79.         }

  81.         send += vec.size;

  83.         n = ngx_writev(c, &vec);

  85.         if (n == NGX_ERROR) {
  86.             return NGX_CHAIN_ERROR;
  87.         }

  89.         sent = (n == NGX_AGAIN) ? 0 : n;

  91.         c->sent += sent;

  93.         in = ngx_chain_update_sent(in, sent);

  95.         if (send - prev_send != sent) {
  96.             wev->ready = 0;
  97.             return in;
  98.         }

  100.         if (send >= limit || in == NULL) {
  101.             return in;
  102.         }
  103.     }
  104. }


  107. ngx_chain_t *
  108. ‌ngx_output_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *in, size_t limit,
  109.     ngx_log_t *log)
  110. {
  111.     size_t         total, size;
  112.     u_char        *prev;
  113.     ngx_uint_t     n;
  114.     struct iovec  *iov;

  116.     iov = NULL;
  117.     prev = NULL;
  118.     total = 0;
  119.     n = 0;

  121.     for ( /* void */ ; in && total < limit; in = in->next) {

  123.         if (ngx_buf_special(in->buf)) {
  124.             continue;
  125.         }

  127.         if (in->buf->in_file) {
  128.             break;
  129.         }

  131.         if (!ngx_buf_in_memory(in->buf)) {
  132.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  133.                           "bad buf in output chain "
  134.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  135.                           in->buf->temporary,
  136.                           in->buf->recycled,
  137.                           in->buf->in_file,
  138.                           in->buf->start,
  139.                           in->buf->pos,
  140.                           in->buf->last,
  141.                           in->buf->file,
  142.                           in->buf->file_pos,
  143.                           in->buf->file_last);

  145.             ngx_debug_point();

  147.             return NGX_CHAIN_ERROR;
  148.         }

  150.         size = in->buf->last - in->buf->pos;

  152.         if (size > limit - total) {
  153.             size = limit - total;
  154.         }

  156.         if (prev == in->buf->pos) {
  157.             iov->iov_len += size;

  159.         } else {
  160.             if (n == vec->nalloc) {
  161.                 break;
  162.             }

  164.             iov = &vec->iovs[n++];

  166.             iov->iov_base = (void *) in->buf->pos;
  167.             iov->iov_len = size;
  168.         }

  170.         prev = in->buf->pos + size;
  171.         total += size;
  172.     }

  174.     vec->count = n;
  175.     vec->size = total;

  177.     return in;
  178. }


  181. ssize_t
  182. ‌ngx_writev(ngx_connection_t *c, ngx_iovec_t *vec)
  183. {
  184.     ssize_t    n;
  185.     ngx_err_t  err;

  187. eintr:

  189.     n = writev(c->fd, vec->iovs, vec->count);

  191.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  192.                    "writev: %z of %uz", n, vec->size);

  194.     if (n == -1) {
  195.         err = ngx_errno;

  197.         switch (err) {
  198.         case NGX_EAGAIN:
  199.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  200.                            "writev() not ready");
  201.             return NGX_AGAIN;

  203.         case NGX_EINTR:
  204.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  205.                            "writev() was interrupted");
  206.             goto eintr;

  208.         default:
  209.             c->write->error = 1;
  210.             ngx_connection_error(c, err, "writev() failed");
  211.             return NGX_ERROR;
  212.         }
  213.     }

  215.     return n;
  216. }

One Level Up Top Level