One Level Up Top Level

src/os/unix/ngx_freebsd_sendfile_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. /*
  14. * Although FreeBSD sendfile() allows to pass a header and a trailer,
  15. * it cannot send a header with a part of the file in one packet until
  16. * FreeBSD 5.3.  Besides, over the fast ethernet connection sendfile()
  17. * may send the partially filled packets, i.e. the 8 file pages may be sent
  18. * as the 11 full 1460-bytes packets, then one incomplete 324-bytes packet,
  19. * and then again the 11 full 1460-bytes packets.
  20. *
  21. * Therefore we use the TCP_NOPUSH option (similar to Linux's TCP_CORK)
  22. * to postpone the sending - it not only sends a header and the first part of
  23. * the file in one packet, but also sends the file pages in the full packets.
  24. *
  25. * But until FreeBSD 4.5 turning TCP_NOPUSH off does not flush a pending
  26. * data that less than MSS, so that data may be sent with 5 second delay.
  27. * So we do not use TCP_NOPUSH on FreeBSD prior to 4.5, although it can be used
  28. * for non-keepalive HTTP connections.
  29. */


  32. ngx_chain_t *
  33. ‌ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  34. {
  35.     int              rc, flags;
  36.     off_t            send, prev_send, sent;
  37.     size_t           file_size;
  38.     ssize_t          n;
  39.     ngx_uint_t       eintr, eagain;
  40.     ngx_err_t        err;
  41.     ngx_buf_t       *file;
  42.     ngx_event_t     *wev;
  43.     ngx_chain_t     *cl;
  44.     ngx_iovec_t      header, trailer;
  45.     struct sf_hdtr   hdtr;
  46.     struct iovec     headers[NGX_IOVS_PREALLOCATE];
  47.     struct iovec     trailers[NGX_IOVS_PREALLOCATE];

  49.     wev = c->write;

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

  55. #if (NGX_HAVE_KQUEUE)

  57.     if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
  58.         (void) ngx_connection_error(c, wev->kq_errno,
  59.                                "kevent() reported about an closed connection");
  60.         wev->error = 1;
  61.         return NGX_CHAIN_ERROR;
  62.     }

  64. #endif

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

  68.     if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
  69.         limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
  70.     }

  72.     send = 0;
  73.     eagain = 0;
  74.     flags = 0;

  76.     header.iovs = headers;
  77.     header.nalloc = NGX_IOVS_PREALLOCATE;

  79.     trailer.iovs = trailers;
  80.     trailer.nalloc = NGX_IOVS_PREALLOCATE;

  82.     for ( ;; ) {
  83.         eintr = 0;
  84.         prev_send = send;

  86.         /* create the header iovec and coalesce the neighbouring bufs */

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

  90.         if (cl == NGX_CHAIN_ERROR) {
  91.             return NGX_CHAIN_ERROR;
  92.         }

  94.         send += header.size;

  96.         if (cl && cl->buf->in_file && send < limit) {
  97.             file = cl->buf;

  99.             /* coalesce the neighbouring file bufs */

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

  103.             send += file_size;

  105.             /* create the trailer iovec and coalesce the neighbouring bufs */

  107.             cl = ngx_output_chain_to_iovec(&trailer, cl, limit - send, c->log);

  109.             if (cl == NGX_CHAIN_ERROR) {
  110.                 return NGX_CHAIN_ERROR;
  111.             }

  113.             send += trailer.size;

  115.             if (ngx_freebsd_use_tcp_nopush
  116.                 && c->tcp_nopush == NGX_TCP_NOPUSH_UNSET)
  117.             {
  118.                 if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
  119.                     err = ngx_socket_errno;

  121.                     /*
  122.                      * there is a tiny chance to be interrupted, however,
  123.                      * we continue a processing without the TCP_NOPUSH
  124.                      */

  126.                     if (err != NGX_EINTR) {
  127.                         wev->error = 1;
  128.                         (void) ngx_connection_error(c, err,
  129.                                                     ngx_tcp_nopush_n " failed");
  130.                         return NGX_CHAIN_ERROR;
  131.                     }

  133.                 } else {
  134.                     c->tcp_nopush = NGX_TCP_NOPUSH_SET;

  136.                     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  137.                                    "tcp_nopush");
  138.                 }
  139.             }

  141.             /*
  142.              * sendfile() does unneeded work if sf_hdtr's count is 0,
  143.              * but corresponding pointer is not NULL
  144.              */

  146.             hdtr.headers = header.count ? header.iovs : NULL;
  147.             hdtr.hdr_cnt = header.count;
  148.             hdtr.trailers = trailer.count ? trailer.iovs : NULL;
  149.             hdtr.trl_cnt = trailer.count;

  151.             /*
  152.              * the "nbytes bug" of the old sendfile() syscall:
  153.              * http://bugs.freebsd.org/33771
  154.              */

  156.             if (!ngx_freebsd_sendfile_nbytes_bug) {
  157.                 header.size = 0;
  158.             }

  160.             sent = 0;

  162. #if (NGX_HAVE_AIO_SENDFILE)
  163.             flags = c->aio_sendfile ? SF_NODISKIO : 0;
  164. #endif

  166.             rc = sendfile(file->file->fd, c->fd, file->file_pos,
  167.                           file_size + header.size, &hdtr, &sent, flags);

  169.             if (rc == -1) {
  170.                 err = ngx_errno;

  172.                 switch (err) {
  173.                 case NGX_EAGAIN:
  174.                     eagain = 1;
  175.                     break;

  177.                 case NGX_EINTR:
  178.                     eintr = 1;
  179.                     break;

  181. #if (NGX_HAVE_AIO_SENDFILE)
  182.                 case NGX_EBUSY:
  183.                     c->busy_sendfile = file;
  184.                     break;
  185. #endif

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

  193.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
  194.                                "sendfile() sent only %O bytes", sent);

  196.             /*
  197.              * sendfile() in FreeBSD 3.x-4.x may return value >= 0
  198.              * on success, although only 0 is documented
  199.              */

  201.             } else if (rc >= 0 && sent == 0) {

  203.                 /*
  204.                  * if rc is OK and sent equal to zero, then someone
  205.                  * has truncated the file, so the offset became beyond
  206.                  * the end of the file
  207.                  */

  209.                 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  210.                          "sendfile() reported that \"%s\" was truncated at %O",
  211.                          file->file->name.data, file->file_pos);

  213.                 return NGX_CHAIN_ERROR;
  214.             }

  216.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
  217.                            "sendfile: %d, @%O %O:%uz",
  218.                            rc, file->file_pos, sent, file_size + header.size);

  220.         } else {
  221.             n = ngx_writev(c, &header);

  223.             if (n == NGX_ERROR) {
  224.                 return NGX_CHAIN_ERROR;
  225.             }

  227.             sent = (n == NGX_AGAIN) ? 0 : n;
  228.         }

  230.         c->sent += sent;

  232.         in = ngx_chain_update_sent(in, sent);

  234. #if (NGX_HAVE_AIO_SENDFILE)
  235.         if (c->busy_sendfile) {
  236.             return in;
  237.         }
  238. #endif

  240.         if (eagain) {

  242.             /*
  243.              * sendfile() may return EAGAIN, even if it has sent a whole file
  244.              * part, it indicates that the successive sendfile() call would
  245.              * return EAGAIN right away and would not send anything.
  246.              * We use it as a hint.
  247.              */

  249.             wev->ready = 0;
  250.             return in;
  251.         }

  253.         if (eintr) {
  254.             send = prev_send + sent;
  255.             continue;
  256.         }

  258.         if (send - prev_send != sent) {
  259.             wev->ready = 0;
  260.             return in;
  261.         }

  263.         if (send >= limit || in == NULL) {
  264.             return in;
  265.         }
  266.     }
  267. }

One Level Up Top Level