One Level Up Top Level

src/os/unix/ngx_readv_chain.c - nginx source code

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.                 rev->ready = 0;
  50.                 return NGX_AGAIN;
  51.             }
  52.         }
  53.     }

  55. #endif

  57. #if (NGX_HAVE_EPOLLRDHUP)

  59.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
  60.         && ngx_use_epoll_rdhup)
  61.     {
  62.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  63.                        "readv: eof:%d, avail:%d",
  64.                        rev->pending_eof, rev->available);

  66.         if (rev->available == 0 && !rev->pending_eof) {
  67.             rev->ready = 0;
  68.             return NGX_AGAIN;
  69.         }
  70.     }

  72. #endif

  74.     prev = NULL;
  75.     iov = NULL;
  76.     size = 0;

  78.     vec.elts = iovs;
  79.     vec.nelts = 0;
  80.     vec.size = sizeof(struct iovec);
  81.     vec.nalloc = NGX_IOVS_PREALLOCATE;
  82.     vec.pool = c->pool;

  84.     /* coalesce the neighbouring bufs */

  86.     while (chain) {
  87.         n = chain->buf->end - chain->buf->last;

  89.         if (limit) {
  90.             if (size >= limit) {
  91.                 break;
  92.             }

  94.             if (size + n > limit) {
  95.                 n = (ssize_t) (limit - size);
  96.             }
  97.         }

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

  102.         } else {
  103.             if (vec.nelts == vec.nalloc) {
  104.                 break;
  105.             }

  107.             iov = ngx_array_push(&vec);
  108.             if (iov == NULL) {
  109.                 return NGX_ERROR;
  110.             }

  112.             iov->iov_base = (void *) chain->buf->last;
  113.             iov->iov_len = n;
  114.         }

  116.         size += n;
  117.         prev = chain->buf->end;
  118.         chain = chain->next;
  119.     }

  121.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  122.                    "readv: %ui, last:%uz", vec.nelts, iov->iov_len);

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

  127.         if (n == 0) {
  128.             rev->ready = 0;
  129.             rev->eof = 1;

  131. #if (NGX_HAVE_KQUEUE)

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

  138.             if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  139.                 rev->available = 0;
  140.             }

  142. #endif

  144.             return 0;
  145.         }

  147.         if (n > 0) {

  149. #if (NGX_HAVE_KQUEUE)

  151.             if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  152.                 rev->available -= n;

  154.                 /*
  155.                  * rev->available may be negative here because some additional
  156.                  * bytes may be received between kevent() and readv()
  157.                  */

  159.                 if (rev->available <= 0) {
  160.                     if (!rev->pending_eof) {
  161.                         rev->ready = 0;
  162.                     }

  164.                     rev->available = 0;
  165.                 }

  167.                 return n;
  168.             }

  170. #endif

  172. #if (NGX_HAVE_FIONREAD)

  174.             if (rev->available >= 0) {
  175.                 rev->available -= n;

  177.                 /*
  178.                  * negative rev->available means some additional bytes
  179.                  * were received between kernel notification and readv(),
  180.                  * and therefore ev->ready can be safely reset even for
  181.                  * edge-triggered event methods
  182.                  */

  184.                 if (rev->available < 0) {
  185.                     rev->available = 0;
  186.                     rev->ready = 0;
  187.                 }

  189.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  190.                                "readv: avail:%d", rev->available);

  192.             } else if (n == size) {

  194.                 if (ngx_socket_nread(c->fd, &rev->available) == -1) {
  195.                     n = ngx_connection_error(c, ngx_socket_errno,
  196.                                              ngx_socket_nread_n " failed");
  197.                     break;
  198.                 }

  200.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  201.                                "readv: avail:%d", rev->available);
  202.             }

  204. #endif

  206. #if (NGX_HAVE_EPOLLRDHUP)

  208.             if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
  209.                 && ngx_use_epoll_rdhup)
  210.             {
  211.                 if (n < size) {
  212.                     if (!rev->pending_eof) {
  213.                         rev->ready = 0;
  214.                     }

  216.                     rev->available = 0;
  217.                 }

  219.                 return n;
  220.             }

  222. #endif

  224.             if (n < size && !(ngx_event_flags & NGX_USE_GREEDY_EVENT)) {
  225.                 rev->ready = 0;
  226.             }

  228.             return n;
  229.         }

  231.         err = ngx_socket_errno;

  233.         if (err == NGX_EAGAIN || err == NGX_EINTR) {
  234.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  235.                            "readv() not ready");
  236.             n = NGX_AGAIN;

  238.         } else {
  239.             n = ngx_connection_error(c, err, "readv() failed");
  240.             break;
  241.         }

  243.     } while (err == NGX_EINTR);

  245.     rev->ready = 0;

  247.     if (n == NGX_ERROR) {
  248.         c->read->error = 1;
  249.     }

  251.     return n;
  252. }

One Level Up Top Level