One Level Up Top Level

src/os/unix/ngx_readv_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. ssize_t
  14. ‌ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain, off_t limit)
  15. {
  16.     u_char        *prev;
  17.     ssize_t        n, size;
  18.     ngx_err_t      err;
  19.     ngx_array_t    vec;
  20.     ngx_event_t   *rev;
  21.     struct iovec  *iov, iovs[NGX_IOVS_PREALLOCATE];

  23.     rev = c->read;

  25. #if (NGX_HAVE_KQUEUE)

  27.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  28.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  29.                        "readv: eof:%d, avail:%d, err:%d",
  30.                        rev->pending_eof, rev->available, rev->kq_errno);

  32.         if (rev->available == 0) {
  33.             if (rev->pending_eof) {
  34.                 rev->ready = 0;
  35.                 rev->eof = 1;

  37.                 ngx_log_error(NGX_LOG_INFO, c->log, rev->kq_errno,
  38.                               "kevent() reported about an closed connection");

  40.                 if (rev->kq_errno) {
  41.                     rev->error = 1;
  42.                     ngx_set_socket_errno(rev->kq_errno);
  43.                     return NGX_ERROR;
  44.                 }

  46.                 return 0;

  48.             } else {
  49.                 return NGX_AGAIN;
  50.             }
  51.         }
  52.     }

  54. #endif

  56.     prev = NULL;
  57.     iov = NULL;
  58.     size = 0;

  60.     vec.elts = iovs;
  61.     vec.nelts = 0;
  62.     vec.size = sizeof(struct iovec);
  63.     vec.nalloc = NGX_IOVS_PREALLOCATE;
  64.     vec.pool = c->pool;

  66.     /* coalesce the neighbouring bufs */

  68.     while (chain) {
  69.         n = chain->buf->end - chain->buf->last;

  71.         if (limit) {
  72.             if (size >= limit) {
  73.                 break;
  74.             }

  76.             if (size + n > limit) {
  77.                 n = (ssize_t) (limit - size);
  78.             }
  79.         }

  81.         if (prev == chain->buf->last) {
  82.             iov->iov_len += n;

  84.         } else {
  85.             if (vec.nelts >= IOV_MAX) {
  86.                 break;
  87.             }

  89.             iov = ngx_array_push(&vec);
  90.             if (iov == NULL) {
  91.                 return NGX_ERROR;
  92.             }

  94.             iov->iov_base = (void *) chain->buf->last;
  95.             iov->iov_len = n;
  96.         }

  98.         size += n;
  99.         prev = chain->buf->end;
  100.         chain = chain->next;
  101.     }

  103.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  104.                    "readv: %d, last:%d", vec.nelts, iov->iov_len);

  106.     do {
  107.         n = readv(c->fd, (struct iovec *) vec.elts, vec.nelts);

  109.         if (n >= 0) {

  111. #if (NGX_HAVE_KQUEUE)

  113.             if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  114.                 rev->available -= n;

  116.                 /*
  117.                  * rev->available may be negative here because some additional
  118.                  * bytes may be received between kevent() and recv()
  119.                  */

  121.                 if (rev->available <= 0) {
  122.                     if (!rev->pending_eof) {
  123.                         rev->ready = 0;
  124.                     }

  126.                     if (rev->available < 0) {
  127.                         rev->available = 0;
  128.                     }
  129.                 }

  131.                 if (n == 0) {

  133.                     /*
  134.                      * on FreeBSD recv() may return 0 on closed socket
  135.                      * even if kqueue reported about available data
  136.                      */

  138. #if 0
  139.                     ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  140.                                   "readv() returned 0 while kevent() reported "
  141.                                   "%d available bytes", rev->available);
  142. #endif

  144.                     rev->ready = 0;
  145.                     rev->eof = 1;
  146.                     rev->available = 0;
  147.                 }

  149.                 return n;
  150.             }

  152. #endif /* NGX_HAVE_KQUEUE */

  154.             if (n < size && !(ngx_event_flags & NGX_USE_GREEDY_EVENT)) {
  155.                 rev->ready = 0;
  156.             }

  158.             if (n == 0) {
  159.                 rev->eof = 1;
  160.             }

  162.             return n;
  163.         }

  165.         err = ngx_socket_errno;

  167.         if (err == NGX_EAGAIN || err == NGX_EINTR) {
  168.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  169.                            "readv() not ready");
  170.             n = NGX_AGAIN;

  172.         } else {
  173.             n = ngx_connection_error(c, err, "readv() failed");
  174.             break;
  175.         }

  177.     } while (err == NGX_EINTR);

  179.     rev->ready = 0;

  181.     if (n == NGX_ERROR) {
  182.         c->read->error = 1;
  183.     }

  185.     return n;
  186. }

One Level Up Top Level