One Level Up Top Level

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

Data types defined

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. #if (NGX_TEST_BUILD_SOLARIS_SENDFILEV)

  15. /* Solaris declarations */

  17. ‌typedef struct sendfilevec {
  18.     int     sfv_fd;
  19.     u_int   sfv_flag;
  20.     off_t   sfv_off;
  21.     size_t  sfv_len;
  22. ‌} sendfilevec_t;

  24. ‌#define SFV_FD_SELF  -2

  26. ‌static ssize_t sendfilev(int fd, const struct sendfilevec *vec,
  27.     int sfvcnt, size_t *xferred)
  28. {
  29.     return -1;
  30. }

  32. ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in,
  33.     off_t limit);

  35. #endif


  38. ‌#define NGX_SENDFILEVECS  NGX_IOVS_PREALLOCATE


  41. ngx_chain_t *
  42. ‌ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
  43. {
  44.     int             fd;
  45.     u_char         *prev;
  46.     off_t           size, send, prev_send, aligned, fprev;
  47.     size_t          sent;
  48.     ssize_t         n;
  49.     ngx_int_t       eintr;
  50.     ngx_err_t       err;
  51.     ngx_uint_t      nsfv;
  52.     sendfilevec_t  *sfv, sfvs[NGX_SENDFILEVECS];
  53.     ngx_event_t    *wev;
  54.     ngx_chain_t    *cl;

  56.     wev = c->write;

  58.     if (!wev->ready) {
  59.         return in;
  60.     }

  62.     if (!c->sendfile) {
  63.         return ngx_writev_chain(c, in, limit);
  64.     }


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

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


  74.     send = 0;

  76.     for ( ;; ) {
  77.         fd = SFV_FD_SELF;
  78.         prev = NULL;
  79.         fprev = 0;
  80.         sfv = NULL;
  81.         eintr = 0;
  82.         sent = 0;
  83.         prev_send = send;

  85.         nsfv = 0;

  87.         /* create the sendfilevec and coalesce the neighbouring bufs */

  89.         for (cl = in; cl && send < limit; cl = cl->next) {

  91.             if (ngx_buf_special(cl->buf)) {
  92.                 continue;
  93.             }

  95.             if (ngx_buf_in_memory_only(cl->buf)) {
  96.                 fd = SFV_FD_SELF;

  98.                 size = cl->buf->last - cl->buf->pos;

  100.                 if (send + size > limit) {
  101.                     size = limit - send;
  102.                 }

  104.                 if (prev == cl->buf->pos) {
  105.                     sfv->sfv_len += (size_t) size;

  107.                 } else {
  108.                     if (nsfv == NGX_SENDFILEVECS) {
  109.                         break;
  110.                     }

  112.                     sfv = &sfvs[nsfv++];

  114.                     sfv->sfv_fd = SFV_FD_SELF;
  115.                     sfv->sfv_flag = 0;
  116.                     sfv->sfv_off = (off_t) (uintptr_t) cl->buf->pos;
  117.                     sfv->sfv_len = (size_t) size;
  118.                 }

  120.                 prev = cl->buf->pos + (size_t) size;
  121.                 send += size;

  123.             } else {
  124.                 prev = NULL;

  126.                 size = cl->buf->file_last - cl->buf->file_pos;

  128.                 if (send + size > limit) {
  129.                     size = limit - send;

  131.                     aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
  132.                                & ~((off_t) ngx_pagesize - 1);

  134.                     if (aligned <= cl->buf->file_last) {
  135.                         size = aligned - cl->buf->file_pos;
  136.                     }
  137.                 }

  139.                 if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) {
  140.                     sfv->sfv_len += (size_t) size;

  142.                 } else {
  143.                     if (nsfv == NGX_SENDFILEVECS) {
  144.                         break;
  145.                     }

  147.                     sfv = &sfvs[nsfv++];

  149.                     fd = cl->buf->file->fd;
  150.                     sfv->sfv_fd = fd;
  151.                     sfv->sfv_flag = 0;
  152.                     sfv->sfv_off = cl->buf->file_pos;
  153.                     sfv->sfv_len = (size_t) size;
  154.                 }

  156.                 fprev = cl->buf->file_pos + size;
  157.                 send += size;
  158.             }
  159.         }

  161.         n = sendfilev(c->fd, sfvs, nsfv, &sent);

  163.         if (n == -1) {
  164.             err = ngx_errno;

  166.             switch (err) {
  167.             case NGX_EAGAIN:
  168.                 break;

  170.             case NGX_EINTR:
  171.                 eintr = 1;
  172.                 break;

  174.             default:
  175.                 wev->error = 1;
  176.                 ngx_connection_error(c, err, "sendfilev() failed");
  177.                 return NGX_CHAIN_ERROR;
  178.             }

  180.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
  181.                           "sendfilev() sent only %uz bytes", sent);
  182.         }

  184.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  185.                        "sendfilev: %z %z", n, sent);

  187.         c->sent += sent;

  189.         in = ngx_chain_update_sent(in, sent);

  191.         if (eintr) {
  192.             send = prev_send + sent;
  193.             continue;
  194.         }

  196.         if (send - prev_send != (off_t) sent) {
  197.             wev->ready = 0;
  198.             return in;
  199.         }

  201.         if (send >= limit || in == NULL) {
  202.             return in;
  203.         }
  204.     }
  205. }

One Level Up Top Level