One Level Up Top Level

src/core/ngx_output_chain.c - nginx source code

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 || NGX_THREADS)
  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 || NGX_THREADS)
  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.                 cl = ctx->in;
  121.                 ctx->in = cl->next;

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

  125.                 continue;
  126.             }

  128.             if (bsize < 0) {

  130.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  131.                               "negative size buf in output "
  132.                               "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  133.                               ctx->in->buf->temporary,
  134.                               ctx->in->buf->recycled,
  135.                               ctx->in->buf->in_file,
  136.                               ctx->in->buf->start,
  137.                               ctx->in->buf->pos,
  138.                               ctx->in->buf->last,
  139.                               ctx->in->buf->file,
  140.                               ctx->in->buf->file_pos,
  141.                               ctx->in->buf->file_last);

  143.                 ngx_debug_point();

  145.                 return NGX_ERROR;
  146.             }

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

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

  152.                 cl = ctx->in;
  153.                 ctx->in = cl->next;

  155.                 *last_out = cl;
  156.                 last_out = &cl->next;
  157.                 cl->next = NULL;

  159.                 continue;
  160.             }

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

  164.                 rc = ngx_output_chain_align_file_buf(ctx, bsize);

  166.                 if (rc == NGX_ERROR) {
  167.                     return NGX_ERROR;
  168.                 }

  170.                 if (rc != NGX_OK) {

  172.                     if (ctx->free) {

  174.                         /* get the free buf */

  176.                         cl = ctx->free;
  177.                         ctx->buf = cl->buf;
  178.                         ctx->free = cl->next;

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

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

  184.                         break;

  186.                     } else if (ngx_output_chain_get_buf(ctx, bsize) != NGX_OK) {
  187.                         return NGX_ERROR;
  188.                     }
  189.                 }
  190.             }

  192.             rc = ngx_output_chain_copy_buf(ctx);

  194.             if (rc == NGX_ERROR) {
  195.                 return rc;
  196.             }

  198.             if (rc == NGX_AGAIN) {
  199.                 if (out) {
  200.                     break;
  201.                 }

  203.                 return rc;
  204.             }

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

  208.             if (ngx_buf_size(ctx->in->buf) == 0) {
  209.                 cl = ctx->in;
  210.                 ctx->in = cl->next;

  212.                 ngx_free_chain(ctx->pool, cl);
  213.             }

  215.             cl = ngx_alloc_chain_link(ctx->pool);
  216.             if (cl == NULL) {
  217.                 return NGX_ERROR;
  218.             }

  220.             cl->buf = ctx->buf;
  221.             cl->next = NULL;
  222.             *last_out = cl;
  223.             last_out = &cl->next;
  224.             ctx->buf = NULL;
  225.         }

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

  229.             if (ctx->in) {
  230.                 return NGX_AGAIN;
  231.             }

  233.             return last;
  234.         }

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

  238.         if (last == NGX_ERROR || last == NGX_DONE) {
  239.             return last;
  240.         }

  242.         ngx_chain_update_chains(ctx->pool, &ctx->free, &ctx->busy, &out,
  243.                                 ctx->tag);
  244.         last_out = &out;
  245.     }
  246. }


  249. static ngx_inline ngx_int_t
  250. ‌ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
  251. {
  252.     ngx_uint_t  sendfile;

  254.     if (ngx_buf_special(buf)) {
  255.         return 1;
  256.     }

  258. #if (NGX_THREADS)
  259.     if (buf->in_file) {
  260.         buf->file->thread_handler = ctx->thread_handler;
  261.         buf->file->thread_ctx = ctx->filter_ctx;
  262.     }
  263. #endif

  265.     sendfile = ctx->sendfile;

  267. #if (NGX_SENDFILE_LIMIT)

  269.     if (buf->in_file && buf->file_pos >= NGX_SENDFILE_LIMIT) {
  270.         sendfile = 0;
  271.     }

  273. #endif

  275. #if !(NGX_HAVE_SENDFILE_NODISKIO)

  277.     /*
  278.      * With DIRECTIO, disable sendfile() unless sendfile(SF_NOCACHE)
  279.      * is available.
  280.      */

  282.     if (buf->in_file && buf->file->directio) {
  283.         sendfile = 0;
  284.     }

  286. #endif

  288.     if (!sendfile) {

  290.         if (!ngx_buf_in_memory(buf)) {
  291.             return 0;
  292.         }

  294.         buf->in_file = 0;
  295.     }

  297.     if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {
  298.         return 0;
  299.     }

  301.     if (ctx->need_in_temp && (buf->memory || buf->mmap)) {
  302.         return 0;
  303.     }

  305.     return 1;
  306. }


  309. static ngx_int_t
  310. ‌ngx_output_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain,
  311.     ngx_chain_t *in)
  312. {
  313.     ngx_chain_t  *cl, **ll;
  314. #if (NGX_SENDFILE_LIMIT)
  315.     ngx_buf_t    *b, *buf;
  316. #endif

  318.     ll = chain;

  320.     for (cl = *chain; cl; cl = cl->next) {
  321.         ll = &cl->next;
  322.     }

  324.     while (in) {

  326.         cl = ngx_alloc_chain_link(pool);
  327.         if (cl == NULL) {
  328.             return NGX_ERROR;
  329.         }

  331. #if (NGX_SENDFILE_LIMIT)

  333.         buf = in->buf;

  335.         if (buf->in_file
  336.             && buf->file_pos < NGX_SENDFILE_LIMIT
  337.             && buf->file_last > NGX_SENDFILE_LIMIT)
  338.         {
  339.             /* split a file buf on two bufs by the sendfile limit */

  341.             b = ngx_calloc_buf(pool);
  342.             if (b == NULL) {
  343.                 return NGX_ERROR;
  344.             }

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

  348.             if (ngx_buf_in_memory(buf)) {
  349.                 buf->pos += (ssize_t) (NGX_SENDFILE_LIMIT - buf->file_pos);
  350.                 b->last = buf->pos;
  351.             }

  353.             buf->file_pos = NGX_SENDFILE_LIMIT;
  354.             b->file_last = NGX_SENDFILE_LIMIT;

  356.             cl->buf = b;

  358.         } else {
  359.             cl->buf = buf;
  360.             in = in->next;
  361.         }

  363. #else
  364.         cl->buf = in->buf;
  365.         in = in->next;

  367. #endif

  369.         cl->next = NULL;
  370.         *ll = cl;
  371.         ll = &cl->next;
  372.     }

  374.     return NGX_OK;
  375. }


  378. static ngx_int_t
  379. ‌ngx_output_chain_align_file_buf(ngx_output_chain_ctx_t *ctx, off_t bsize)
  380. {
  381.     size_t      size;
  382.     ngx_buf_t  *in;

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

  386.     if (in->file == NULL || !in->file->directio) {
  387.         return NGX_DECLINED;
  388.     }

  390.     ctx->directio = 1;

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

  394.     if (size == 0) {

  396.         if (bsize >= (off_t) ctx->bufs.size) {
  397.             return NGX_DECLINED;
  398.         }

  400.         size = (size_t) bsize;

  402.     } else {
  403.         size = (size_t) ctx->alignment - size;

  405.         if ((off_t) size > bsize) {
  406.             size = (size_t) bsize;
  407.         }
  408.     }

  410.     ctx->buf = ngx_create_temp_buf(ctx->pool, size);
  411.     if (ctx->buf == NULL) {
  412.         return NGX_ERROR;
  413.     }

  415.     /*
  416.      * we do not set ctx->buf->tag, because we do not want
  417.      * to reuse the buf via ctx->free list
  418.      */

  420. #if (NGX_HAVE_ALIGNED_DIRECTIO)
  421.     ctx->unaligned = 1;
  422. #endif

  424.     return NGX_OK;
  425. }


  428. static ngx_int_t
  429. ‌ngx_output_chain_get_buf(ngx_output_chain_ctx_t *ctx, off_t bsize)
  430. {
  431.     size_t       size;
  432.     ngx_buf_t   *b, *in;
  433.     ngx_uint_t   recycled;

  435.     in = ctx->in->buf;
  436.     size = ctx->bufs.size;
  437.     recycled = 1;

  439.     if (in->last_in_chain) {

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

  443.             /*
  444.              * allocate a small temp buf for a small last buf
  445.              * or its small last part
  446.              */

  448.             size = (size_t) bsize;
  449.             recycled = 0;

  451.         } else if (!ctx->directio
  452.                    && ctx->bufs.num == 1
  453.                    && (bsize < (off_t) (size + size / 4)))
  454.         {
  455.             /*
  456.              * allocate a temp buf that equals to a last buf,
  457.              * if there is no directio, the last buf size is lesser
  458.              * than 1.25 of bufs.size and the temp buf is single
  459.              */

  461.             size = (size_t) bsize;
  462.             recycled = 0;
  463.         }
  464.     }

  466.     b = ngx_calloc_buf(ctx->pool);
  467.     if (b == NULL) {
  468.         return NGX_ERROR;
  469.     }

  471.     if (ctx->directio) {

  473.         /*
  474.          * allocate block aligned to a disk sector size to enable
  475.          * userland buffer direct usage conjunctly with directio
  476.          */

  478.         b->start = ngx_pmemalign(ctx->pool, size, (size_t) ctx->alignment);
  479.         if (b->start == NULL) {
  480.             return NGX_ERROR;
  481.         }

  483.     } else {
  484.         b->start = ngx_palloc(ctx->pool, size);
  485.         if (b->start == NULL) {
  486.             return NGX_ERROR;
  487.         }
  488.     }

  490.     b->pos = b->start;
  491.     b->last = b->start;
  492.     b->end = b->last + size;
  493.     b->temporary = 1;
  494.     b->tag = ctx->tag;
  495.     b->recycled = recycled;

  497.     ctx->buf = b;
  498.     ctx->allocated++;

  500.     return NGX_OK;
  501. }


  504. static ngx_int_t
  505. ‌ngx_output_chain_copy_buf(ngx_output_chain_ctx_t *ctx)
  506. {
  507.     off_t        size;
  508.     ssize_t      n;
  509.     ngx_buf_t   *src, *dst;
  510.     ngx_uint_t   sendfile;

  512.     src = ctx->in->buf;
  513.     dst = ctx->buf;

  515.     size = ngx_buf_size(src);
  516.     size = ngx_min(size, dst->end - dst->pos);

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

  520. #if (NGX_SENDFILE_LIMIT)

  522.     if (src->in_file && src->file_pos >= NGX_SENDFILE_LIMIT) {
  523.         sendfile = 0;
  524.     }

  526. #endif

  528.     if (ngx_buf_in_memory(src)) {
  529.         ngx_memcpy(dst->pos, src->pos, (size_t) size);
  530.         src->pos += (size_t) size;
  531.         dst->last += (size_t) size;

  533.         if (src->in_file) {

  535.             if (sendfile) {
  536.                 dst->in_file = 1;
  537.                 dst->file = src->file;
  538.                 dst->file_pos = src->file_pos;
  539.                 dst->file_last = src->file_pos + size;

  541.             } else {
  542.                 dst->in_file = 0;
  543.             }

  545.             src->file_pos += size;

  547.         } else {
  548.             dst->in_file = 0;
  549.         }

  551.         if (src->pos == src->last) {
  552.             dst->flush = src->flush;
  553.             dst->last_buf = src->last_buf;
  554.             dst->last_in_chain = src->last_in_chain;
  555.         }

  557.     } else {

  559. #if (NGX_HAVE_ALIGNED_DIRECTIO)

  561.         if (ctx->unaligned) {
  562.             if (ngx_directio_off(src->file->fd) == NGX_FILE_ERROR) {
  563.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, ngx_errno,
  564.                               ngx_directio_off_n " \"%s\" failed",
  565.                               src->file->name.data);
  566.             }
  567.         }

  569. #endif

  571. #if (NGX_HAVE_FILE_AIO)
  572.         if (ctx->aio_handler) {
  573.             n = ngx_file_aio_read(src->file, dst->pos, (size_t) size,
  574.                                   src->file_pos, ctx->pool);
  575.             if (n == NGX_AGAIN) {
  576.                 ctx->aio_handler(ctx, src->file);
  577.                 return NGX_AGAIN;
  578.             }

  580.         } else
  581. #endif
  582. #if (NGX_THREADS)
  583.         if (ctx->thread_handler) {
  584.             src->file->thread_task = ctx->thread_task;
  585.             src->file->thread_handler = ctx->thread_handler;
  586.             src->file->thread_ctx = ctx->filter_ctx;

  588.             n = ngx_thread_read(src->file, dst->pos, (size_t) size,
  589.                                 src->file_pos, ctx->pool);
  590.             if (n == NGX_AGAIN) {
  591.                 ctx->thread_task = src->file->thread_task;
  592.                 return NGX_AGAIN;
  593.             }

  595.         } else
  596. #endif
  597.         {
  598.             n = ngx_read_file(src->file, dst->pos, (size_t) size,
  599.                               src->file_pos);
  600.         }

  602. #if (NGX_HAVE_ALIGNED_DIRECTIO)

  604.         if (ctx->unaligned) {
  605.             ngx_err_t  err;

  607.             err = ngx_errno;

  609.             if (ngx_directio_on(src->file->fd) == NGX_FILE_ERROR) {
  610.                 ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, ngx_errno,
  611.                               ngx_directio_on_n " \"%s\" failed",
  612.                               src->file->name.data);
  613.             }

  615.             ngx_set_errno(err);

  617.             ctx->unaligned = 0;
  618.         }

  620. #endif

  622.         if (n == NGX_ERROR) {
  623.             return (ngx_int_t) n;
  624.         }

  626.         if (n != size) {
  627.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  628.                           ngx_read_file_n " read only %z of %O from \"%s\"",
  629.                           n, size, src->file->name.data);
  630.             return NGX_ERROR;
  631.         }

  633.         dst->last += n;

  635.         if (sendfile) {
  636.             dst->in_file = 1;
  637.             dst->file = src->file;
  638.             dst->file_pos = src->file_pos;
  639.             dst->file_last = src->file_pos + n;

  641.         } else {
  642.             dst->in_file = 0;
  643.         }

  645.         src->file_pos += n;

  647.         if (src->file_pos == src->file_last) {
  648.             dst->flush = src->flush;
  649.             dst->last_buf = src->last_buf;
  650.             dst->last_in_chain = src->last_in_chain;
  651.         }
  652.     }

  654.     return NGX_OK;
  655. }


  658. ngx_int_t
  659. ‌ngx_chain_writer(void *data, ngx_chain_t *in)
  660. {
  661.     ngx_chain_writer_ctx_t *ctx = data;

  663.     off_t              size;
  664.     ngx_chain_t       *cl, *ln, *chain;
  665.     ngx_connection_t  *c;

  667.     c = ctx->connection;

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

  671.         if (ngx_buf_size(in->buf) == 0 && !ngx_buf_special(in->buf)) {

  673.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  674.                           "zero size buf in chain writer "
  675.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  676.                           in->buf->temporary,
  677.                           in->buf->recycled,
  678.                           in->buf->in_file,
  679.                           in->buf->start,
  680.                           in->buf->pos,
  681.                           in->buf->last,
  682.                           in->buf->file,
  683.                           in->buf->file_pos,
  684.                           in->buf->file_last);

  686.             ngx_debug_point();

  688.             continue;
  689.         }

  691.         if (ngx_buf_size(in->buf) < 0) {

  693.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  694.                           "negative size buf in chain writer "
  695.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  696.                           in->buf->temporary,
  697.                           in->buf->recycled,
  698.                           in->buf->in_file,
  699.                           in->buf->start,
  700.                           in->buf->pos,
  701.                           in->buf->last,
  702.                           in->buf->file,
  703.                           in->buf->file_pos,
  704.                           in->buf->file_last);

  706.             ngx_debug_point();

  708.             return NGX_ERROR;
  709.         }

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

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

  717.         cl = ngx_alloc_chain_link(ctx->pool);
  718.         if (cl == NULL) {
  719.             return NGX_ERROR;
  720.         }

  722.         cl->buf = in->buf;
  723.         cl->next = NULL;
  724.         *ctx->last = cl;
  725.         ctx->last = &cl->next;
  726.     }

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

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

  733.         if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {

  735.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  736.                           "zero size buf in chain writer "
  737.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  738.                           cl->buf->temporary,
  739.                           cl->buf->recycled,
  740.                           cl->buf->in_file,
  741.                           cl->buf->start,
  742.                           cl->buf->pos,
  743.                           cl->buf->last,
  744.                           cl->buf->file,
  745.                           cl->buf->file_pos,
  746.                           cl->buf->file_last);

  748.             ngx_debug_point();

  750.             continue;
  751.         }

  753.         if (ngx_buf_size(cl->buf) < 0) {

  755.             ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
  756.                           "negative size buf in chain writer "
  757.                           "t:%d r:%d f:%d %p %p-%p %p %O-%O",
  758.                           cl->buf->temporary,
  759.                           cl->buf->recycled,
  760.                           cl->buf->in_file,
  761.                           cl->buf->start,
  762.                           cl->buf->pos,
  763.                           cl->buf->last,
  764.                           cl->buf->file,
  765.                           cl->buf->file_pos,
  766.                           cl->buf->file_last);

  768.             ngx_debug_point();

  770.             return NGX_ERROR;
  771.         }

  773.         size += ngx_buf_size(cl->buf);
  774.     }

  776.     if (size == 0 && !c->buffered) {
  777.         return NGX_OK;
  778.     }

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

  782.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  783.                    "chain writer out: %p", chain);

  785.     if (chain == NGX_CHAIN_ERROR) {
  786.         return NGX_ERROR;
  787.     }

  789.     if (chain && c->write->ready) {
  790.         ngx_post_event(c->write, &ngx_posted_next_events);
  791.     }

  793.     for (cl = ctx->out; cl && cl != chain; /* void */) {
  794.         ln = cl;
  795.         cl = cl->next;
  796.         ngx_free_chain(ctx->pool, ln);
  797.     }

  799.     ctx->out = chain;

  801.     if (ctx->out == NULL) {
  802.         ctx->last = &ctx->out;

  804.         if (!c->buffered) {
  805.             return NGX_OK;
  806.         }
  807.     }

  809.     return NGX_AGAIN;
  810. }

One Level Up Top Level