One Level Up Top Level

src/core/ngx_output_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. #if 0
  14. #define NGX_SENDFILE_LIMIT  4096
  15. #endif

  17. /*
  18. * When DIRECTIO is enabled FreeBSD, Solaris, and MacOSX read directly
  19. * to an application memory from a device if parameters are aligned
  20. * to device sector boundary (512 bytes).  They fallback to usual read
  21. * operation if the parameters are not aligned.
  22. * Linux allows DIRECTIO only if the parameters are aligned to a filesystem
  23. * sector boundary, otherwise it returns EINVAL.  The sector size is
  24. * usually 512 bytes, however, on XFS it may be 4096 bytes.
  25. */

  27. ‌#define NGX_NONE            1


  30. static ngx_inline ngx_int_t
  31.     ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf);
  32. static ngx_int_t ngx_output_chain_add_copy(ngx_pool_t *pool,
  33.     ngx_chain_t **chain, ngx_chain_t *in);
  34. static ngx_int_t ngx_output_chain_align_file_buf(ngx_output_chain_ctx_t *ctx,
  35.     off_t bsize);
  36. static ngx_int_t ngx_output_chain_get_buf(ngx_output_chain_ctx_t *ctx,
  37.     off_t bsize);
  38. static ngx_int_t ngx_output_chain_copy_buf(ngx_output_chain_ctx_t *ctx);


  41. ngx_int_t
  42. ‌ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
  43. {
  44.     off_t         bsize;
  45.     ngx_int_t     rc, last;
  46.     ngx_chain_t  *cl, *out, **last_out;

  48.     if (ctx->in == NULL && ctx->busy == NULL
  49. #if (NGX_HAVE_FILE_AIO)
  50.         && !ctx->aio
  51. #endif
  52.        )
  53.     {
  54.         /*
  55.          * the short path for the case when the ctx->in and ctx->busy chains
  56.          * are empty, the incoming chain is empty too or has the single buf
  57.          * that does not require the copy
  58.          */

  60.         if (in == NULL) {
  61.             return ctx->output_filter(ctx->filter_ctx, in);
  62.         }

  64.         if (in->next == NULL
  65. #if (NGX_SENDFILE_LIMIT)
  66.             && !(in->buf->in_file && in->buf->file_last > NGX_SENDFILE_LIMIT)
  67. #endif
  68.             && ngx_output_chain_as_is(ctx, in->buf))
  69.         {
  70.             return ctx->output_filter(ctx->filter_ctx, in);
  71.         }
  72.     }

  74.     /* add the incoming buf to the chain ctx->in */

  76.     if (in) {
  77.         if (ngx_output_chain_add_copy(ctx->pool, &ctx->in, in) == NGX_ERROR) {
  78.             return NGX_ERROR;
  79.         }
  80.     }

  82.     out = NULL;
  83.     last_out = &out;
  84.     last = NGX_NONE;

  86.     for ( ;; ) {

  88. #if (NGX_HAVE_FILE_AIO)
  89.         if (ctx->aio) {
  90.             return NGX_AGAIN;
  91.         }
  92. #endif

  94.         while (ctx->in) {

  96.             /*
  97.              * cycle while there are the ctx->in bufs
  98.              * and there are the free output bufs to copy in
  99.              */

  101.             bsize = ngx_buf_size(ctx->in->buf);

  103.             if (bsize == 0 && !ngx_buf_special(ctx->in->buf)) {

  105.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  106.                               "zero size buf in output "
  107.                               "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  108.                               ctx->in->buf->temporary,
  109.                               ctx->in->buf->recycled,
  110.                               ctx->in->buf->in_file,
  111.                               ctx->in->buf->start,
  112.                               ctx->in->buf->pos,
  113.                               ctx->in->buf->last,
  114.                               ctx->in->buf->file,
  115.                               ctx->in->buf->file_pos,
  116.                               ctx->in->buf->file_last);

  118.                 ngx_debug_point();

  120.                 ctx->in = ctx->in->next;

  122.                 continue;
  123.             }

  125.             if (ngx_output_chain_as_is(ctx, ctx->in->buf)) {

  127.                 /* move the chain link to the output chain */

  129.                 cl = ctx->in;
  130.                 ctx->in = cl->next;

  132.                 *last_out = cl;
  133.                 last_out = &cl->next;
  134.                 cl->next = NULL;

  136.                 continue;
  137.             }

  139.             if (ctx->buf == NULL) {

  141.                 rc = ngx_output_chain_align_file_buf(ctx, bsize);

  143.                 if (rc == NGX_ERROR) {
  144.                     return NGX_ERROR;
  145.                 }

  147.                 if (rc != NGX_OK) {

  149.                     if (ctx->free) {

  151.                         /* get the free buf */

  153.                         cl = ctx->free;
  154.                         ctx->buf = cl->buf;
  155.                         ctx->free = cl->next;

  157.                         ngx_free_chain(ctx->pool, cl);

  159.                     } else if (out || ctx->allocated == ctx->bufs.num) {

  161.                         break;

  163.                     } else if (ngx_output_chain_get_buf(ctx, bsize) != NGX_OK) {
  164.                         return NGX_ERROR;
  165.                     }
  166.                 }
  167.             }

  169.             rc = ngx_output_chain_copy_buf(ctx);

  171.             if (rc == NGX_ERROR) {
  172.                 return rc;
  173.             }

  175.             if (rc == NGX_AGAIN) {
  176.                 if (out) {
  177.                     break;
  178.                 }

  180.                 return rc;
  181.             }

  183.             /* delete the completed buf from the ctx->in chain */

  185.             if (ngx_buf_size(ctx->in->buf) == 0) {
  186.                 ctx->in = ctx->in->next;
  187.             }

  189.             cl = ngx_alloc_chain_link(ctx->pool);
  190.             if (cl == NULL) {
  191.                 return NGX_ERROR;
  192.             }

  194.             cl->buf = ctx->buf;
  195.             cl->next = NULL;
  196.             *last_out = cl;
  197.             last_out = &cl->next;
  198.             ctx->buf = NULL;
  199.         }

  201.         if (out == NULL && last != NGX_NONE) {

  203.             if (ctx->in) {
  204.                 return NGX_AGAIN;
  205.             }

  207.             return last;
  208.         }

  210.         last = ctx->output_filter(ctx->filter_ctx, out);

  212.         if (last == NGX_ERROR || last == NGX_DONE) {
  213.             return last;
  214.         }

  216.         ngx_chain_update_chains(ctx->pool, &ctx->free, &ctx->busy, &out,
  217.                                 ctx->tag);
  218.         last_out = &out;
  219.     }
  220. }


  223. static ngx_inline ngx_int_t
  224. ‌ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
  225. {
  226.     ngx_uint_t  sendfile;

  228.     if (ngx_buf_special(buf)) {
  229.         return 1;
  230.     }

  232.     if (buf->in_file && buf->file->directio) {
  233.         return 0;
  234.     }

  236.     sendfile = ctx->sendfile;

  238. #if (NGX_SENDFILE_LIMIT)

  240.     if (buf->in_file && buf->file_pos >= NGX_SENDFILE_LIMIT) {
  241.         sendfile = 0;
  242.     }

  244. #endif

  246.     if (!sendfile) {

  248.         if (!ngx_buf_in_memory(buf)) {
  249.             return 0;
  250.         }

  252.         buf->in_file = 0;
  253.     }

  255.     if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {
  256.         return 0;
  257.     }

  259.     if (ctx->need_in_temp && (buf->memory || buf->mmap)) {
  260.         return 0;
  261.     }

  263.     return 1;
  264. }


  267. static ngx_int_t
  268. ‌ngx_output_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain,
  269.     ngx_chain_t *in)
  270. {
  271.     ngx_chain_t  *cl, **ll;
  272. #if (NGX_SENDFILE_LIMIT)
  273.     ngx_buf_t    *b, *buf;
  274. #endif

  276.     ll = chain;

  278.     for (cl = *chain; cl; cl = cl->next) {
  279.         ll = &cl->next;
  280.     }

  282.     while (in) {

  284.         cl = ngx_alloc_chain_link(pool);
  285.         if (cl == NULL) {
  286.             return NGX_ERROR;
  287.         }

  289. #if (NGX_SENDFILE_LIMIT)

  291.         buf = in->buf;

  293.         if (buf->in_file
  294.             && buf->file_pos < NGX_SENDFILE_LIMIT
  295.             && buf->file_last > NGX_SENDFILE_LIMIT)
  296.         {
  297.             /* split a file buf on two bufs by the sendfile limit */

  299.             b = ngx_calloc_buf(pool);
  300.             if (b == NULL) {
  301.                 return NGX_ERROR;
  302.             }

  304.             ngx_memcpy(b, buf, sizeof(ngx_buf_t));

  306.             if (ngx_buf_in_memory(buf)) {
  307.                 buf->pos += (ssize_t) (NGX_SENDFILE_LIMIT - buf->file_pos);
  308.                 b->last = buf->pos;
  309.             }

  311.             buf->file_pos = NGX_SENDFILE_LIMIT;
  312.             b->file_last = NGX_SENDFILE_LIMIT;

  314.             cl->buf = b;

  316.         } else {
  317.             cl->buf = buf;
  318.             in = in->next;
  319.         }

  321. #else
  322.         cl->buf = in->buf;
  323.         in = in->next;

  325. #endif

  327.         cl->next = NULL;
  328.         *ll = cl;
  329.         ll = &cl->next;
  330.     }

  332.     return NGX_OK;
  333. }


  336. static ngx_int_t
  337. ‌ngx_output_chain_align_file_buf(ngx_output_chain_ctx_t *ctx, off_t bsize)
  338. {
  339.     size_t      size;
  340.     ngx_buf_t  *in;

  342.     in = ctx->in->buf;

  344.     if (in->file == NULL || !in->file->directio) {
  345.         return NGX_DECLINED;
  346.     }

  348.     ctx->directio = 1;

  350.     size = (size_t) (in->file_pos - (in->file_pos & ~(ctx->alignment - 1)));

  352.     if (size == 0) {

  354.         if (bsize >= (off_t) ctx->bufs.size) {
  355.             return NGX_DECLINED;
  356.         }

  358.         size = (size_t) bsize;

  360.     } else {
  361.         size = (size_t) ctx->alignment - size;

  363.         if ((off_t) size > bsize) {
  364.             size = (size_t) bsize;
  365.         }
  366.     }

  368.     ctx->buf = ngx_create_temp_buf(ctx->pool, size);
  369.     if (ctx->buf == NULL) {
  370.         return NGX_ERROR;
  371.     }

  373.     /*
  374.      * we do not set ctx->buf->tag, because we do not want
  375.      * to reuse the buf via ctx->free list
  376.      */

  378. #if (NGX_HAVE_ALIGNED_DIRECTIO)
  379.     ctx->unaligned = 1;
  380. #endif

  382.     return NGX_OK;
  383. }


  386. static ngx_int_t
  387. ‌ngx_output_chain_get_buf(ngx_output_chain_ctx_t *ctx, off_t bsize)
  388. {
  389.     size_t       size;
  390.     ngx_buf_t   *b, *in;
  391.     ngx_uint_t   recycled;

  393.     in = ctx->in->buf;
  394.     size = ctx->bufs.size;
  395.     recycled = 1;

  397.     if (in->last_in_chain) {

  399.         if (bsize < (off_t) size) {

  401.             /*
  402.              * allocate a small temp buf for a small last buf
  403.              * or its small last part
  404.              */

  406.             size = (size_t) bsize;
  407.             recycled = 0;

  409.         } else if (!ctx->directio
  410.                    && ctx->bufs.num == 1
  411.                    && (bsize < (off_t) (size + size / 4)))
  412.         {
  413.             /*
  414.              * allocate a temp buf that equals to a last buf,
  415.              * if there is no directio, the last buf size is lesser
  416.              * than 1.25 of bufs.size and the temp buf is single
  417.              */

  419.             size = (size_t) bsize;
  420.             recycled = 0;
  421.         }
  422.     }

  424.     b = ngx_calloc_buf(ctx->pool);
  425.     if (b == NULL) {
  426.         return NGX_ERROR;
  427.     }

  429.     if (ctx->directio) {

  431.         /*
  432.          * allocate block aligned to a disk sector size to enable
  433.          * userland buffer direct usage conjunctly with directio
  434.          */

  436.         b->start = ngx_pmemalign(ctx->pool, size, (size_t) ctx->alignment);
  437.         if (b->start == NULL) {
  438.             return NGX_ERROR;
  439.         }

  441.     } else {
  442.         b->start = ngx_palloc(ctx->pool, size);
  443.         if (b->start == NULL) {
  444.             return NGX_ERROR;
  445.         }
  446.     }

  448.     b->pos = b->start;
  449.     b->last = b->start;
  450.     b->end = b->last + size;
  451.     b->temporary = 1;
  452.     b->tag = ctx->tag;
  453.     b->recycled = recycled;

  455.     ctx->buf = b;
  456.     ctx->allocated++;

  458.     return NGX_OK;
  459. }


  462. static ngx_int_t
  463. ‌ngx_output_chain_copy_buf(ngx_output_chain_ctx_t *ctx)
  464. {
  465.     off_t        size;
  466.     ssize_t      n;
  467.     ngx_buf_t   *src, *dst;
  468.     ngx_uint_t   sendfile;

  470.     src = ctx->in->buf;
  471.     dst = ctx->buf;

  473.     size = ngx_buf_size(src);
  474.     size = ngx_min(size, dst->end - dst->pos);

  476.     sendfile = ctx->sendfile & !ctx->directio;

  478. #if (NGX_SENDFILE_LIMIT)

  480.     if (src->in_file && src->file_pos >= NGX_SENDFILE_LIMIT) {
  481.         sendfile = 0;
  482.     }

  484. #endif

  486.     if (ngx_buf_in_memory(src)) {
  487.         ngx_memcpy(dst->pos, src->pos, (size_t) size);
  488.         src->pos += (size_t) size;
  489.         dst->last += (size_t) size;

  491.         if (src->in_file) {

  493.             if (sendfile) {
  494.                 dst->in_file = 1;
  495.                 dst->file = src->file;
  496.                 dst->file_pos = src->file_pos;
  497.                 dst->file_last = src->file_pos + size;

  499.             } else {
  500.                 dst->in_file = 0;
  501.             }

  503.             src->file_pos += size;

  505.         } else {
  506.             dst->in_file = 0;
  507.         }

  509.         if (src->pos == src->last) {
  510.             dst->flush = src->flush;
  511.             dst->last_buf = src->last_buf;
  512.             dst->last_in_chain = src->last_in_chain;
  513.         }

  515.     } else {

  517. #if (NGX_HAVE_ALIGNED_DIRECTIO)

  519.         if (ctx->unaligned) {
  520.             if (ngx_directio_off(src->file->fd) == NGX_FILE_ERROR) {
  521.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, ngx_errno,
  522.                               ngx_directio_off_n " \"%s\" failed",
  523.                               src->file->name.data);
  524.             }
  525.         }

  527. #endif

  529. #if (NGX_HAVE_FILE_AIO)

  531.         if (ctx->aio_handler) {
  532.             n = ngx_file_aio_read(src->file, dst->pos, (size_t) size,
  533.                                   src->file_pos, ctx->pool);
  534.             if (n == NGX_AGAIN) {
  535.                 ctx->aio_handler(ctx, src->file);
  536.                 return NGX_AGAIN;
  537.             }

  539.         } else {
  540.             n = ngx_read_file(src->file, dst->pos, (size_t) size,
  541.                               src->file_pos);
  542.         }
  543. #else

  545.         n = ngx_read_file(src->file, dst->pos, (size_t) size, src->file_pos);

  547. #endif

  549. #if (NGX_HAVE_ALIGNED_DIRECTIO)

  551.         if (ctx->unaligned) {
  552.             ngx_err_t  err;

  554.             err = ngx_errno;

  556.             if (ngx_directio_on(src->file->fd) == NGX_FILE_ERROR) {
  557.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, ngx_errno,
  558.                               ngx_directio_on_n " \"%s\" failed",
  559.                               src->file->name.data);
  560.             }

  562.             ngx_set_errno(err);

  564.             ctx->unaligned = 0;
  565.         }

  567. #endif

  569.         if (n == NGX_ERROR) {
  570.             return (ngx_int_t) n;
  571.         }

  573.         if (n != size) {
  574.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  575.                           ngx_read_file_n " read only %z of %O from \"%s\"",
  576.                           n, size, src->file->name.data);
  577.             return NGX_ERROR;
  578.         }

  580.         dst->last += n;

  582.         if (sendfile) {
  583.             dst->in_file = 1;
  584.             dst->file = src->file;
  585.             dst->file_pos = src->file_pos;
  586.             dst->file_last = src->file_pos + n;

  588.         } else {
  589.             dst->in_file = 0;
  590.         }

  592.         src->file_pos += n;

  594.         if (src->file_pos == src->file_last) {
  595.             dst->flush = src->flush;
  596.             dst->last_buf = src->last_buf;
  597.             dst->last_in_chain = src->last_in_chain;
  598.         }
  599.     }

  601.     return NGX_OK;
  602. }


  605. ngx_int_t
  606. ‌ngx_chain_writer(void *data, ngx_chain_t *in)
  607. {
  608.     ngx_chain_writer_ctx_t *ctx = data;

  610.     off_t              size;
  611.     ngx_chain_t       *cl;
  612.     ngx_connection_t  *c;

  614.     c = ctx->connection;

  616.     for (size = 0; in; in = in->next) {

  618. #if 1
  619.         if (ngx_buf_size(in->buf) == 0 && !ngx_buf_special(in->buf)) {
  620.             ngx_debug_point();
  621.         }
  622. #endif

  624.         size += ngx_buf_size(in->buf);

  626.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, c->log, 0,
  627.                        "chain writer buf fl:%d s:%uO",
  628.                        in->buf->flush, ngx_buf_size(in->buf));

  630.         cl = ngx_alloc_chain_link(ctx->pool);
  631.         if (cl == NULL) {
  632.             return NGX_ERROR;
  633.         }

  635.         cl->buf = in->buf;
  636.         cl->next = NULL;
  637.         *ctx->last = cl;
  638.         ctx->last = &cl->next;
  639.     }

  641.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  642.                    "chain writer in: %p", ctx->out);

  644.     for (cl = ctx->out; cl; cl = cl->next) {

  646. #if 1
  647.         if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {
  648.             ngx_debug_point();
  649.         }

  651. #endif

  653.         size += ngx_buf_size(cl->buf);
  654.     }

  656.     if (size == 0 && !c->buffered) {
  657.         return NGX_OK;
  658.     }

  660.     ctx->out = c->send_chain(c, ctx->out, ctx->limit);

  662.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  663.                    "chain writer out: %p", ctx->out);

  665.     if (ctx->out == NGX_CHAIN_ERROR) {
  666.         return NGX_ERROR;
  667.     }

  669.     if (ctx->out == NULL) {
  670.         ctx->last = &ctx->out;

  672.         if (!c->buffered) {
  673.             return NGX_OK;
  674.         }
  675.     }

  677.     return NGX_AGAIN;
  678. }

One Level Up Top Level