One Level Up Top Level

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

Functions defined

Macros 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. /*
  14. * On Linux up to 2.4.21 sendfile() (syscall #187) works with 32-bit
  15. * offsets only, and the including <sys/sendfile.h> breaks the compiling,
  16. * if off_t is 64 bit wide.  So we use own sendfile() definition, where offset
  17. * parameter is int32_t, and use sendfile() for the file parts below 2G only,
  18. * see src/os/unix/ngx_linux_config.h
  19. *
  20. * Linux 2.4.21 has the new sendfile64() syscall #239.
  21. *
  22. * On Linux up to 2.6.16 sendfile() does not allow to pass the count parameter
  23. * more than 2G-1 bytes even on 64-bit platforms: it returns EINVAL,
  24. * so we limit it to 2G-1 bytes.
  25. */

  27. ‌#define NGX_SENDFILE_MAXSIZE  2147483647L


  30. ngx_chain_t *
  31. ‌ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  32. {
  33.     int            tcp_nodelay;
  34.     off_t          send, prev_send, sent;
  35.     size_t         file_size;
  36.     ssize_t        n;
  37.     ngx_err_t      err;
  38.     ngx_buf_t     *file;
  39.     ngx_uint_t     eintr;
  40.     ngx_event_t   *wev;
  41.     ngx_chain_t   *cl;
  42.     ngx_iovec_t    header;
  43.     struct iovec   headers[NGX_IOVS_PREALLOCATE];
  44. #if (NGX_HAVE_SENDFILE64)
  45.     off_t          offset;
  46. #else
  47.     int32_t        offset;
  48. #endif

  50.     wev = c->write;

  52.     if (!wev->ready) {
  53.         return in;
  54.     }


  57.     /* the maximum limit size is 2G-1 - the page size */

  59.     if (limit == 0 || limit > (off_t) (NGX_SENDFILE_MAXSIZE - ngx_pagesize)) {
  60.         limit = NGX_SENDFILE_MAXSIZE - ngx_pagesize;
  61.     }


  64.     send = 0;

  66.     header.iovs = headers;
  67.     header.nalloc = NGX_IOVS_PREALLOCATE;

  69.     for ( ;; ) {
  70.         eintr = 0;
  71.         prev_send = send;

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

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

  77.         if (cl == NGX_CHAIN_ERROR) {
  78.             return NGX_CHAIN_ERROR;
  79.         }

  81.         send += header.size;

  83.         /* set TCP_CORK if there is a header before a file */

  85.         if (c->tcp_nopush == NGX_TCP_NOPUSH_UNSET
  86.             && header.count != 0
  87.             && cl
  88.             && cl->buf->in_file)
  89.         {
  90.             /* the TCP_CORK and TCP_NODELAY are mutually exclusive */

  92.             if (c->tcp_nodelay == NGX_TCP_NODELAY_SET) {

  94.                 tcp_nodelay = 0;

  96.                 if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  97.                                (const void *) &tcp_nodelay, sizeof(int)) == -1)
  98.                 {
  99.                     err = ngx_socket_errno;

  101.                     /*
  102.                      * there is a tiny chance to be interrupted, however,
  103.                      * we continue a processing with the TCP_NODELAY
  104.                      * and without the TCP_CORK
  105.                      */

  107.                     if (err != NGX_EINTR) {
  108.                         wev->error = 1;
  109.                         ngx_connection_error(c, err,
  110.                                              "setsockopt(TCP_NODELAY) failed");
  111.                         return NGX_CHAIN_ERROR;
  112.                     }

  114.                 } else {
  115.                     c->tcp_nodelay = NGX_TCP_NODELAY_UNSET;

  117.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  118.                                    "no tcp_nodelay");
  119.                 }
  120.             }

  122.             if (c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {

  124.                 if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
  125.                     err = ngx_socket_errno;

  127.                     /*
  128.                      * there is a tiny chance to be interrupted, however,
  129.                      * we continue a processing without the TCP_CORK
  130.                      */

  132.                     if (err != NGX_EINTR) {
  133.                         wev->error = 1;
  134.                         ngx_connection_error(c, err,
  135.                                              ngx_tcp_nopush_n " failed");
  136.                         return NGX_CHAIN_ERROR;
  137.                     }

  139.                 } else {
  140.                     c->tcp_nopush = NGX_TCP_NOPUSH_SET;

  142.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  143.                                    "tcp_nopush");
  144.                 }
  145.             }
  146.         }

  148.         /* get the file buf */

  150.         if (header.count == 0 && cl && cl->buf->in_file && send < limit) {
  151.             file = cl->buf;

  153.             /* coalesce the neighbouring file bufs */

  155.             file_size = (size_t) ngx_chain_coalesce_file(&cl, limit - send);

  157.             send += file_size;
  158. #if 1
  159.             if (file_size == 0) {
  160.                 ngx_debug_point();
  161.                 return NGX_CHAIN_ERROR;
  162.             }
  163. #endif
  164. #if (NGX_HAVE_SENDFILE64)
  165.             offset = file->file_pos;
  166. #else
  167.             offset = (int32_t) file->file_pos;
  168. #endif

  170.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  171.                            "sendfile: @%O %uz", file->file_pos, file_size);

  173.             n = sendfile(c->fd, file->file->fd, &offset, file_size);

  175.             if (n == -1) {
  176.                 err = ngx_errno;

  178.                 switch (err) {
  179.                 case NGX_EAGAIN:
  180.                     break;

  182.                 case NGX_EINTR:
  183.                     eintr = 1;
  184.                     break;

  186.                 default:
  187.                     wev->error = 1;
  188.                     ngx_connection_error(c, err, "sendfile() failed");
  189.                     return NGX_CHAIN_ERROR;
  190.                 }

  192.                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  193.                                "sendfile() is not ready");
  194.             }

  196.             sent = n > 0 ? n : 0;

  198.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
  199.                            "sendfile: %z, @%O %O:%uz",
  200.                            n, file->file_pos, sent, file_size);

  202.         } else {
  203.             n = ngx_writev(c, &header);

  205.             if (n == NGX_ERROR) {
  206.                 return NGX_CHAIN_ERROR;
  207.             }

  209.             sent = (n == NGX_AGAIN) ? 0 : n;
  210.         }

  212.         c->sent += sent;

  214.         in = ngx_chain_update_sent(in, sent);

  216.         if (eintr) {
  217.             send = prev_send;
  218.             continue;
  219.         }

  221.         if (send - prev_send != sent) {
  222.             wev->ready = 0;
  223.             return in;
  224.         }

  226.         if (send >= limit || in == NULL) {
  227.             return in;
  228.         }
  229.     }
  230. }

One Level Up Top Level