One Level Up Top Level

src/http/ngx_http_file_cache.c - nginx source code

Global variables defined

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_http.h>
  11. #include <ngx_md5.h>


  14. static ngx_int_t ngx_http_file_cache_lock(ngx_http_request_t *r,
  15.     ngx_http_cache_t *c);
  16. static void ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev);
  17. static ngx_int_t ngx_http_file_cache_lock_wait(ngx_http_request_t *r,
  18.     ngx_http_cache_t *c);
  19. static ngx_int_t ngx_http_file_cache_read(ngx_http_request_t *r,
  20.     ngx_http_cache_t *c);
  21. static ssize_t ngx_http_file_cache_aio_read(ngx_http_request_t *r,
  22.     ngx_http_cache_t *c);
  23. #if (NGX_HAVE_FILE_AIO)
  24. static void ngx_http_cache_aio_event_handler(ngx_event_t *ev);
  25. #endif
  26. #if (NGX_THREADS)
  27. static ngx_int_t ngx_http_cache_thread_handler(ngx_thread_task_t *task,
  28.     ngx_file_t *file);
  29. static void ngx_http_cache_thread_event_handler(ngx_event_t *ev);
  30. #endif
  31. static ngx_int_t ngx_http_file_cache_exists(ngx_http_file_cache_t *cache,
  32.     ngx_http_cache_t *c);
  33. static ngx_int_t ngx_http_file_cache_name(ngx_http_request_t *r,
  34.     ngx_path_t *path);
  35. static ngx_http_file_cache_node_t *
  36.     ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key);
  37. static void ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  38.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  39. static void ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary,
  40.     size_t len, u_char *hash);
  41. static void ngx_http_file_cache_vary_header(ngx_http_request_t *r,
  42.     ngx_md5_t *md5, ngx_str_t *name);
  43. static ngx_int_t ngx_http_file_cache_reopen(ngx_http_request_t *r,
  44.     ngx_http_cache_t *c);
  45. static ngx_int_t ngx_http_file_cache_update_variant(ngx_http_request_t *r,
  46.     ngx_http_cache_t *c);
  47. static void ngx_http_file_cache_cleanup(void *data);
  48. static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache);
  49. static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache);
  50. static void ngx_http_file_cache_delete(ngx_http_file_cache_t *cache,
  51.     ngx_queue_t *q, u_char *name);
  52. static void ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache);
  53. static ngx_int_t ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx,
  54.     ngx_str_t *path);
  55. static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx,
  56.     ngx_str_t *path);
  57. static ngx_int_t ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx,
  58.     ngx_str_t *path);
  59. static ngx_int_t ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx,
  60.     ngx_str_t *path);
  61. static ngx_int_t ngx_http_file_cache_add(ngx_http_file_cache_t *cache,
  62.     ngx_http_cache_t *c);
  63. static ngx_int_t ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx,
  64.     ngx_str_t *path);
  65. static void ngx_http_file_cache_set_watermark(ngx_http_file_cache_t *cache);


  68. ‌ngx_str_t  ngx_http_cache_status[] = {
  69.     ngx_string("MISS"),
  70.     ngx_string("BYPASS"),
  71.     ngx_string("EXPIRED"),
  72.     ngx_string("STALE"),
  73.     ngx_string("UPDATING"),
  74.     ngx_string("REVALIDATED"),
  75.     ngx_string("HIT")
  76. };


  79. ‌static u_char  ngx_http_file_cache_key[] = { LF, 'K', 'E', 'Y', ':', ' ' };


  82. static ngx_int_t
  83. ‌ngx_http_file_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  84. {
  85.     ngx_http_file_cache_t  *ocache = data;

  87.     size_t                  len;
  88.     ngx_uint_t              n;
  89.     ngx_http_file_cache_t  *cache;

  91.     cache = shm_zone->data;

  93.     if (ocache) {
  94.         if (ngx_strcmp(cache->path->name.data, ocache->path->name.data) != 0) {
  95.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  96.                           "cache \"%V\" uses the \"%V\" cache path "
  97.                           "while previously it used the \"%V\" cache path",
  98.                           &shm_zone->shm.name, &cache->path->name,
  99.                           &ocache->path->name);

  101.             return NGX_ERROR;
  102.         }

  104.         for (n = 0; n < NGX_MAX_PATH_LEVEL; n++) {
  105.             if (cache->path->level[n] != ocache->path->level[n]) {
  106.                 ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  107.                               "cache \"%V\" had previously different levels",
  108.                               &shm_zone->shm.name);
  109.                 return NGX_ERROR;
  110.             }
  111.         }

  113.         cache->sh = ocache->sh;

  115.         cache->shpool = ocache->shpool;
  116.         cache->bsize = ocache->bsize;

  118.         cache->max_size /= cache->bsize;

  120.         if (!cache->sh->cold || cache->sh->loading) {
  121.             cache->path->loader = NULL;
  122.         }

  124.         return NGX_OK;
  125.     }

  127.     cache->shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  129.     if (shm_zone->shm.exists) {
  130.         cache->sh = cache->shpool->data;
  131.         cache->bsize = ngx_fs_bsize(cache->path->name.data);
  132.         cache->max_size /= cache->bsize;

  134.         return NGX_OK;
  135.     }

  137.     cache->sh = ngx_slab_alloc(cache->shpool, sizeof(ngx_http_file_cache_sh_t));
  138.     if (cache->sh == NULL) {
  139.         return NGX_ERROR;
  140.     }

  142.     cache->shpool->data = cache->sh;

  144.     ngx_rbtree_init(&cache->sh->rbtree, &cache->sh->sentinel,
  145.                     ngx_http_file_cache_rbtree_insert_value);

  147.     ngx_queue_init(&cache->sh->queue);

  149.     cache->sh->cold = 1;
  150.     cache->sh->loading = 0;
  151.     cache->sh->size = 0;
  152.     cache->sh->count = 0;
  153.     cache->sh->watermark = (ngx_uint_t) -1;

  155.     cache->bsize = ngx_fs_bsize(cache->path->name.data);

  157.     cache->max_size /= cache->bsize;

  159.     len = sizeof(" in cache keys zone \"\"") + shm_zone->shm.name.len;

  161.     cache->shpool->log_ctx = ngx_slab_alloc(cache->shpool, len);
  162.     if (cache->shpool->log_ctx == NULL) {
  163.         return NGX_ERROR;
  164.     }

  166.     ngx_sprintf(cache->shpool->log_ctx, " in cache keys zone \"%V\"%Z",
  167.                 &shm_zone->shm.name);

  169.     cache->shpool->log_nomem = 0;

  171.     return NGX_OK;
  172. }


  175. ngx_int_t
  176. ‌ngx_http_file_cache_new(ngx_http_request_t *r)
  177. {
  178.     ngx_http_cache_t  *c;

  180.     c = ngx_pcalloc(r->pool, sizeof(ngx_http_cache_t));
  181.     if (c == NULL) {
  182.         return NGX_ERROR;
  183.     }

  185.     if (ngx_array_init(&c->keys, r->pool, 4, sizeof(ngx_str_t)) != NGX_OK) {
  186.         return NGX_ERROR;
  187.     }

  189.     r->cache = c;
  190.     c->file.log = r->connection->log;
  191.     c->file.fd = NGX_INVALID_FILE;

  193.     return NGX_OK;
  194. }


  197. ngx_int_t
  198. ‌ngx_http_file_cache_create(ngx_http_request_t *r)
  199. {
  200.     ngx_http_cache_t       *c;
  201.     ngx_pool_cleanup_t     *cln;
  202.     ngx_http_file_cache_t  *cache;

  204.     c = r->cache;
  205.     cache = c->file_cache;

  207.     cln = ngx_pool_cleanup_add(r->pool, 0);
  208.     if (cln == NULL) {
  209.         return NGX_ERROR;
  210.     }

  212.     cln->handler = ngx_http_file_cache_cleanup;
  213.     cln->data = c;

  215.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  216.         return NGX_ERROR;
  217.     }

  219.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  220.         return NGX_ERROR;
  221.     }

  223.     return NGX_OK;
  224. }


  227. void
  228. ‌ngx_http_file_cache_create_key(ngx_http_request_t *r)
  229. {
  230.     size_t             len;
  231.     ngx_str_t         *key;
  232.     ngx_uint_t         i;
  233.     ngx_md5_t          md5;
  234.     ngx_http_cache_t  *c;

  236.     c = r->cache;

  238.     len = 0;

  240.     ngx_crc32_init(c->crc32);
  241.     ngx_md5_init(&md5);

  243.     key = c->keys.elts;
  244.     for (i = 0; i < c->keys.nelts; i++) {
  245.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  246.                        "http cache key: \"%V\"", &key[i]);

  248.         len += key[i].len;

  250.         ngx_crc32_update(&c->crc32, key[i].data, key[i].len);
  251.         ngx_md5_update(&md5, key[i].data, key[i].len);
  252.     }

  254.     c->header_start = sizeof(ngx_http_file_cache_header_t)
  255.                       + sizeof(ngx_http_file_cache_key) + len + 1;

  257.     ngx_crc32_final(c->crc32);
  258.     ngx_md5_final(c->key, &md5);

  260.     ngx_memcpy(c->main, c->key, NGX_HTTP_CACHE_KEY_LEN);
  261. }


  264. ngx_int_t
  265. ‌ngx_http_file_cache_open(ngx_http_request_t *r)
  266. {
  267.     ngx_int_t                  rc, rv;
  268.     ngx_uint_t                 test;
  269.     ngx_http_cache_t          *c;
  270.     ngx_pool_cleanup_t        *cln;
  271.     ngx_open_file_info_t       of;
  272.     ngx_http_file_cache_t     *cache;
  273.     ngx_http_core_loc_conf_t  *clcf;

  275.     c = r->cache;

  277.     if (c->waiting) {
  278.         return NGX_AGAIN;
  279.     }

  281.     if (c->reading) {
  282.         return ngx_http_file_cache_read(r, c);
  283.     }

  285.     cache = c->file_cache;

  287.     if (c->node == NULL) {
  288.         cln = ngx_pool_cleanup_add(r->pool, 0);
  289.         if (cln == NULL) {
  290.             return NGX_ERROR;
  291.         }

  293.         cln->handler = ngx_http_file_cache_cleanup;
  294.         cln->data = c;
  295.     }

  297.     c->buffer_size = c->body_start;

  299.     rc = ngx_http_file_cache_exists(cache, c);

  301.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  302.                    "http file cache exists: %i e:%d", rc, c->exists);

  304.     if (rc == NGX_ERROR) {
  305.         return rc;
  306.     }

  308.     if (rc == NGX_AGAIN) {
  309.         return NGX_HTTP_CACHE_SCARCE;
  310.     }

  312.     if (rc == NGX_OK) {

  314.         if (c->error) {
  315.             return c->error;
  316.         }

  318.         c->temp_file = 1;
  319.         test = c->exists ? 1 : 0;
  320.         rv = NGX_DECLINED;

  322.     } else { /* rc == NGX_DECLINED */

  324.         test = cache->sh->cold ? 1 : 0;

  326.         if (c->min_uses > 1) {

  328.             if (!test) {
  329.                 return NGX_HTTP_CACHE_SCARCE;
  330.             }

  332.             rv = NGX_HTTP_CACHE_SCARCE;

  334.         } else {
  335.             c->temp_file = 1;
  336.             rv = NGX_DECLINED;
  337.         }
  338.     }

  340.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  341.         return NGX_ERROR;
  342.     }

  344.     if (!test) {
  345.         goto done;
  346.     }

  348.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  350.     ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  352.     of.uniq = c->uniq;
  353.     of.valid = clcf->open_file_cache_valid;
  354.     of.min_uses = clcf->open_file_cache_min_uses;
  355.     of.events = clcf->open_file_cache_events;
  356.     of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  357.     of.read_ahead = clcf->read_ahead;

  359.     if (ngx_open_cached_file(clcf->open_file_cache, &c->file.name, &of, r->pool)
  360.         != NGX_OK)
  361.     {
  362.         switch (of.err) {

  364.         case 0:
  365.             return NGX_ERROR;

  367.         case NGX_ENOENT:
  368.         case NGX_ENOTDIR:
  369.             goto done;

  371.         default:
  372.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  373.                           ngx_open_file_n " \"%s\" failed", c->file.name.data);
  374.             return NGX_ERROR;
  375.         }
  376.     }

  378.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  379.                    "http file cache fd: %d", of.fd);

  381.     c->file.fd = of.fd;
  382.     c->file.log = r->connection->log;
  383.     c->uniq = of.uniq;
  384.     c->length = of.size;
  385.     c->fs_size = (of.fs_size + cache->bsize - 1) / cache->bsize;

  387.     c->buf = ngx_create_temp_buf(r->pool, c->body_start);
  388.     if (c->buf == NULL) {
  389.         return NGX_ERROR;
  390.     }

  392.     return ngx_http_file_cache_read(r, c);

  394. done:

  396.     if (rv == NGX_DECLINED) {
  397.         return ngx_http_file_cache_lock(r, c);
  398.     }

  400.     return rv;
  401. }


  404. static ngx_int_t
  405. ‌ngx_http_file_cache_lock(ngx_http_request_t *r, ngx_http_cache_t *c)
  406. {
  407.     ngx_msec_t                 now, timer;
  408.     ngx_http_file_cache_t     *cache;

  410.     if (!c->lock) {
  411.         return NGX_DECLINED;
  412.     }

  414.     now = ngx_current_msec;

  416.     cache = c->file_cache;

  418.     ngx_shmtx_lock(&cache->shpool->mutex);

  420.     timer = c->node->lock_time - now;

  422.     if (!c->node->updating || (ngx_msec_int_t) timer <= 0) {
  423.         c->node->updating = 1;
  424.         c->node->lock_time = now + c->lock_age;
  425.         c->updating = 1;
  426.         c->lock_time = c->node->lock_time;
  427.     }

  429.     ngx_shmtx_unlock(&cache->shpool->mutex);

  431.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  432.                    "http file cache lock u:%d wt:%M",
  433.                    c->updating, c->wait_time);

  435.     if (c->updating) {
  436.         return NGX_DECLINED;
  437.     }

  439.     if (c->lock_timeout == 0) {
  440.         return NGX_HTTP_CACHE_SCARCE;
  441.     }

  443.     c->waiting = 1;

  445.     if (c->wait_time == 0) {
  446.         c->wait_time = now + c->lock_timeout;

  448.         c->wait_event.handler = ngx_http_file_cache_lock_wait_handler;
  449.         c->wait_event.data = r;
  450.         c->wait_event.log = r->connection->log;
  451.     }

  453.     timer = c->wait_time - now;

  455.     ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);

  457.     r->main->blocked++;

  459.     return NGX_AGAIN;
  460. }


  463. static void
  464. ‌ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev)
  465. {
  466.     ngx_int_t            rc;
  467.     ngx_connection_t    *c;
  468.     ngx_http_request_t  *r;

  470.     r = ev->data;
  471.     c = r->connection;

  473.     ngx_http_set_log_request(c->log, r);

  475.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  476.                    "http file cache wait: \"%V?%V\"", &r->uri, &r->args);

  478.     rc = ngx_http_file_cache_lock_wait(r, r->cache);

  480.     if (rc == NGX_AGAIN) {
  481.         return;
  482.     }

  484.     r->cache->waiting = 0;
  485.     r->main->blocked--;

  487.     if (r->main->terminated) {
  488.         /*
  489.          * trigger connection event handler if the request was
  490.          * terminated
  491.          */

  493.         c->write->handler(c->write);

  495.     } else {
  496.         r->write_event_handler(r);
  497.         ngx_http_run_posted_requests(c);
  498.     }
  499. }


  502. static ngx_int_t
  503. ‌ngx_http_file_cache_lock_wait(ngx_http_request_t *r, ngx_http_cache_t *c)
  504. {
  505.     ngx_uint_t              wait;
  506.     ngx_msec_t              now, timer;
  507.     ngx_http_file_cache_t  *cache;

  509.     now = ngx_current_msec;

  511.     timer = c->wait_time - now;

  513.     if ((ngx_msec_int_t) timer <= 0) {
  514.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  515.                       "cache lock timeout");
  516.         c->lock_timeout = 0;
  517.         return NGX_OK;
  518.     }

  520.     cache = c->file_cache;
  521.     wait = 0;

  523.     ngx_shmtx_lock(&cache->shpool->mutex);

  525.     timer = c->node->lock_time - now;

  527.     if (c->node->updating && (ngx_msec_int_t) timer > 0) {
  528.         wait = 1;
  529.     }

  531.     ngx_shmtx_unlock(&cache->shpool->mutex);

  533.     if (wait) {
  534.         ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);
  535.         return NGX_AGAIN;
  536.     }

  538.     return NGX_OK;
  539. }


  542. static ngx_int_t
  543. ‌ngx_http_file_cache_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  544. {
  545.     u_char                        *p;
  546.     time_t                         now;
  547.     ssize_t                        n;
  548.     ngx_str_t                     *key;
  549.     ngx_int_t                      rc;
  550.     ngx_uint_t                     i;
  551.     ngx_http_file_cache_t         *cache;
  552.     ngx_http_file_cache_header_t  *h;

  554.     n = ngx_http_file_cache_aio_read(r, c);

  556.     if (n < 0) {
  557.         return n;
  558.     }

  560.     if ((size_t) n < c->header_start) {
  561.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  562.                       "cache file \"%s\" is too small", c->file.name.data);
  563.         return NGX_DECLINED;
  564.     }

  566.     h = (ngx_http_file_cache_header_t *) c->buf->pos;

  568.     if (h->version != NGX_HTTP_CACHE_VERSION) {
  569.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  570.                       "cache file \"%s\" version mismatch", c->file.name.data);
  571.         return NGX_DECLINED;
  572.     }

  574.     if (h->crc32 != c->crc32 || (size_t) h->header_start != c->header_start) {
  575.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  576.                       "cache file \"%s\" has md5 collision", c->file.name.data);
  577.         return NGX_DECLINED;
  578.     }

  580.     p = c->buf->pos + sizeof(ngx_http_file_cache_header_t)
  581.         + sizeof(ngx_http_file_cache_key);

  583.     key = c->keys.elts;
  584.     for (i = 0; i < c->keys.nelts; i++) {
  585.         if (ngx_memcmp(p, key[i].data, key[i].len) != 0) {
  586.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  587.                           "cache file \"%s\" has md5 collision",
  588.                           c->file.name.data);
  589.             return NGX_DECLINED;
  590.         }

  592.         p += key[i].len;
  593.     }

  595.     if ((size_t) h->body_start > c->body_start) {
  596.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  597.                       "cache file \"%s\" has too long header",
  598.                       c->file.name.data);
  599.         return NGX_DECLINED;
  600.     }

  602.     if (h->vary_len > NGX_HTTP_CACHE_VARY_LEN) {
  603.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  604.                       "cache file \"%s\" has incorrect vary length",
  605.                       c->file.name.data);
  606.         return NGX_DECLINED;
  607.     }

  609.     if (h->vary_len) {
  610.         ngx_http_file_cache_vary(r, h->vary, h->vary_len, c->variant);

  612.         if (ngx_memcmp(c->variant, h->variant, NGX_HTTP_CACHE_KEY_LEN) != 0) {
  613.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  614.                            "http file cache vary mismatch");
  615.             return ngx_http_file_cache_reopen(r, c);
  616.         }
  617.     }

  619.     c->buf->last += n;

  621.     c->valid_sec = h->valid_sec;
  622.     c->updating_sec = h->updating_sec;
  623.     c->error_sec = h->error_sec;
  624.     c->last_modified = h->last_modified;
  625.     c->date = h->date;
  626.     c->valid_msec = h->valid_msec;
  627.     c->body_start = h->body_start;
  628.     c->etag.len = h->etag_len;
  629.     c->etag.data = h->etag;

  631.     r->cached = 1;

  633.     cache = c->file_cache;

  635.     if (cache->sh->cold) {

  637.         ngx_shmtx_lock(&cache->shpool->mutex);

  639.         if (!c->node->exists) {
  640.             c->node->uses = 1;
  641.             c->node->body_start = c->body_start;
  642.             c->node->exists = 1;
  643.             c->node->uniq = c->uniq;
  644.             c->node->fs_size = c->fs_size;

  646.             cache->sh->size += c->fs_size;
  647.         }

  649.         ngx_shmtx_unlock(&cache->shpool->mutex);
  650.     }

  652.     now = ngx_time();

  654.     if (c->valid_sec < now) {
  655.         c->stale_updating = c->valid_sec + c->updating_sec >= now;
  656.         c->stale_error = c->valid_sec + c->error_sec >= now;

  658.         ngx_shmtx_lock(&cache->shpool->mutex);

  660.         if (c->node->updating) {
  661.             rc = NGX_HTTP_CACHE_UPDATING;

  663.         } else {
  664.             c->node->updating = 1;
  665.             c->updating = 1;
  666.             c->lock_time = c->node->lock_time;
  667.             rc = NGX_HTTP_CACHE_STALE;
  668.         }

  670.         ngx_shmtx_unlock(&cache->shpool->mutex);

  672.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  673.                        "http file cache expired: %i %T %T",
  674.                        rc, c->valid_sec, now);

  676.         return rc;
  677.     }

  679.     return NGX_OK;
  680. }


  683. static ssize_t
  684. ‌ngx_http_file_cache_aio_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  685. {
  686. #if (NGX_HAVE_FILE_AIO || NGX_THREADS)
  687.     ssize_t                    n;
  688.     ngx_http_core_loc_conf_t  *clcf;

  690.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  691. #endif

  693. #if (NGX_HAVE_FILE_AIO)

  695.     if (clcf->aio == NGX_HTTP_AIO_ON && ngx_file_aio) {
  696.         n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);

  698.         if (n != NGX_AGAIN) {
  699.             c->reading = 0;
  700.             return n;
  701.         }

  703.         c->reading = 1;

  705.         c->file.aio->data = r;
  706.         c->file.aio->handler = ngx_http_cache_aio_event_handler;

  708.         ngx_add_timer(&c->file.aio->event, 60000);

  710.         r->main->blocked++;
  711.         r->aio = 1;

  713.         return NGX_AGAIN;
  714.     }

  716. #endif

  718. #if (NGX_THREADS)

  720.     if (clcf->aio == NGX_HTTP_AIO_THREADS) {
  721.         c->file.thread_task = c->thread_task;
  722.         c->file.thread_handler = ngx_http_cache_thread_handler;
  723.         c->file.thread_ctx = r;

  725.         n = ngx_thread_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);

  727.         c->thread_task = c->file.thread_task;
  728.         c->reading = (n == NGX_AGAIN);

  730.         return n;
  731.     }

  733. #endif

  735.     return ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
  736. }


  739. #if (NGX_HAVE_FILE_AIO)

  741. static void
  742. ‌ngx_http_cache_aio_event_handler(ngx_event_t *ev)
  743. {
  744.     ngx_event_aio_t     *aio;
  745.     ngx_connection_t    *c;
  746.     ngx_http_request_t  *r;

  748.     aio = ev->data;
  749.     r = aio->data;
  750.     c = r->connection;

  752.     ngx_http_set_log_request(c->log, r);

  754.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  755.                    "http file cache aio: \"%V?%V\"", &r->uri, &r->args);

  757.     if (ev->timedout) {
  758.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  759.                       "aio operation took too long");
  760.         ev->timedout = 0;
  761.         return;
  762.     }

  764.     if (ev->timer_set) {
  765.         ngx_del_timer(ev);
  766.     }

  768.     r->main->blocked--;
  769.     r->aio = 0;

  771.     if (r->main->terminated) {
  772.         /*
  773.          * trigger connection event handler if the request was
  774.          * terminated
  775.          */

  777.         c->write->handler(c->write);

  779.     } else {
  780.         r->write_event_handler(r);
  781.         ngx_http_run_posted_requests(c);
  782.     }
  783. }

  785. #endif


  788. #if (NGX_THREADS)

  790. static ngx_int_t
  791. ‌ngx_http_cache_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  792. {
  793.     ngx_str_t                  name;
  794.     ngx_thread_pool_t         *tp;
  795.     ngx_http_request_t        *r;
  796.     ngx_http_core_loc_conf_t  *clcf;

  798.     r = file->thread_ctx;

  800.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  801.     tp = clcf->thread_pool;

  803.     if (tp == NULL) {
  804.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  805.             != NGX_OK)
  806.         {
  807.             return NGX_ERROR;
  808.         }

  810.         tp = ngx_thread_pool_get((ngx_cycle_t *) ngx_cycle, &name);

  812.         if (tp == NULL) {
  813.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  814.                           "thread pool \"%V\" not found", &name);
  815.             return NGX_ERROR;
  816.         }
  817.     }

  819.     task->event.data = r;
  820.     task->event.handler = ngx_http_cache_thread_event_handler;

  822.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  823.         return NGX_ERROR;
  824.     }

  826.     ngx_add_timer(&task->event, 60000);

  828.     r->main->blocked++;
  829.     r->aio = 1;

  831.     return NGX_OK;
  832. }


  835. static void
  836. ‌ngx_http_cache_thread_event_handler(ngx_event_t *ev)
  837. {
  838.     ngx_connection_t    *c;
  839.     ngx_http_request_t  *r;

  841.     r = ev->data;
  842.     c = r->connection;

  844.     ngx_http_set_log_request(c->log, r);

  846.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  847.                    "http file cache thread: \"%V?%V\"", &r->uri, &r->args);

  849.     if (ev->timedout) {
  850.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  851.                       "thread operation took too long");
  852.         ev->timedout = 0;
  853.         return;
  854.     }

  856.     if (ev->timer_set) {
  857.         ngx_del_timer(ev);
  858.     }

  860.     r->main->blocked--;
  861.     r->aio = 0;

  863.     if (r->main->terminated) {
  864.         /*
  865.          * trigger connection event handler if the request was
  866.          * terminated
  867.          */

  869.         c->write->handler(c->write);

  871.     } else {
  872.         r->write_event_handler(r);
  873.         ngx_http_run_posted_requests(c);
  874.     }
  875. }

  877. #endif


  880. static ngx_int_t
  881. ‌ngx_http_file_cache_exists(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  882. {
  883.     ngx_int_t                    rc;
  884.     ngx_http_file_cache_node_t  *fcn;

  886.     ngx_shmtx_lock(&cache->shpool->mutex);

  888.     fcn = c->node;

  890.     if (fcn == NULL) {
  891.         fcn = ngx_http_file_cache_lookup(cache, c->key);
  892.     }

  894.     if (fcn) {
  895.         ngx_queue_remove(&fcn->queue);

  897.         if (c->node == NULL) {
  898.             fcn->uses++;
  899.             fcn->count++;
  900.         }

  902.         if (fcn->error) {

  904.             if (fcn->valid_sec < ngx_time()) {
  905.                 goto renew;
  906.             }

  908.             rc = NGX_OK;

  910.             goto done;
  911.         }

  913.         if (fcn->exists || fcn->uses >= c->min_uses) {

  915.             c->exists = fcn->exists;
  916.             if (fcn->body_start && !c->update_variant) {
  917.                 c->body_start = fcn->body_start;
  918.             }

  920.             rc = NGX_OK;

  922.             goto done;
  923.         }

  925.         rc = NGX_AGAIN;

  927.         goto done;
  928.     }

  930.     fcn = ngx_slab_calloc_locked(cache->shpool,
  931.                                  sizeof(ngx_http_file_cache_node_t));
  932.     if (fcn == NULL) {
  933.         ngx_http_file_cache_set_watermark(cache);

  935.         ngx_shmtx_unlock(&cache->shpool->mutex);

  937.         (void) ngx_http_file_cache_forced_expire(cache);

  939.         ngx_shmtx_lock(&cache->shpool->mutex);

  941.         fcn = ngx_slab_calloc_locked(cache->shpool,
  942.                                      sizeof(ngx_http_file_cache_node_t));
  943.         if (fcn == NULL) {
  944.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  945.                           "could not allocate node%s", cache->shpool->log_ctx);
  946.             rc = NGX_ERROR;
  947.             goto failed;
  948.         }
  949.     }

  951.     cache->sh->count++;

  953.     ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));

  955.     ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
  956.                NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  958.     ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);

  960.     fcn->uses = 1;
  961.     fcn->count = 1;

  963. renew:

  965.     rc = NGX_DECLINED;

  967.     fcn->valid_msec = 0;
  968.     fcn->error = 0;
  969.     fcn->exists = 0;
  970.     fcn->valid_sec = 0;
  971.     fcn->uniq = 0;
  972.     fcn->body_start = 0;
  973.     fcn->fs_size = 0;

  975. done:

  977.     fcn->expire = ngx_time() + cache->inactive;

  979.     ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  981.     c->uniq = fcn->uniq;
  982.     c->error = fcn->error;
  983.     c->node = fcn;

  985. failed:

  987.     ngx_shmtx_unlock(&cache->shpool->mutex);

  989.     return rc;
  990. }


  993. static ngx_int_t
  994. ‌ngx_http_file_cache_name(ngx_http_request_t *r, ngx_path_t *path)
  995. {
  996.     u_char            *p;
  997.     ngx_http_cache_t  *c;

  999.     c = r->cache;

  1001.     if (c->file.name.len) {
  1002.         return NGX_OK;
  1003.     }

  1005.     c->file.name.len = path->name.len + 1 + path->len
  1006.                        + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1008.     c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
  1009.     if (c->file.name.data == NULL) {
  1010.         return NGX_ERROR;
  1011.     }

  1013.     ngx_memcpy(c->file.name.data, path->name.data, path->name.len);

  1015.     p = c->file.name.data + path->name.len + 1 + path->len;
  1016.     p = ngx_hex_dump(p, c->key, NGX_HTTP_CACHE_KEY_LEN);
  1017.     *p = '\0';

  1019.     ngx_create_hashed_filename(path, c->file.name.data, c->file.name.len);

  1021.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1022.                    "cache file: \"%s\"", c->file.name.data);

  1024.     return NGX_OK;
  1025. }


  1028. static ngx_http_file_cache_node_t *
  1029. ‌ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
  1030. {
  1031.     ngx_int_t                    rc;
  1032.     ngx_rbtree_key_t             node_key;
  1033.     ngx_rbtree_node_t           *node, *sentinel;
  1034.     ngx_http_file_cache_node_t  *fcn;

  1036.     ngx_memcpy((u_char *) &node_key, key, sizeof(ngx_rbtree_key_t));

  1038.     node = cache->sh->rbtree.root;
  1039.     sentinel = cache->sh->rbtree.sentinel;

  1041.     while (node != sentinel) {

  1043.         if (node_key < node->key) {
  1044.             node = node->left;
  1045.             continue;
  1046.         }

  1048.         if (node_key > node->key) {
  1049.             node = node->right;
  1050.             continue;
  1051.         }

  1053.         /* node_key == node->key */

  1055.         fcn = (ngx_http_file_cache_node_t *) node;

  1057.         rc = ngx_memcmp(&key[sizeof(ngx_rbtree_key_t)], fcn->key,
  1058.                         NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  1060.         if (rc == 0) {
  1061.             return fcn;
  1062.         }

  1064.         node = (rc < 0) ? node->left : node->right;
  1065.     }

  1067.     /* not found */

  1069.     return NULL;
  1070. }


  1073. static void
  1074. ‌ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  1075.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  1076. {
  1077.     ngx_rbtree_node_t           **p;
  1078.     ngx_http_file_cache_node_t   *cn, *cnt;

  1080.     for ( ;; ) {

  1082.         if (node->key < temp->key) {

  1084.             p = &temp->left;

  1086.         } else if (node->key > temp->key) {

  1088.             p = &temp->right;

  1090.         } else { /* node->key == temp->key */

  1092.             cn = (ngx_http_file_cache_node_t *) node;
  1093.             cnt = (ngx_http_file_cache_node_t *) temp;

  1095.             p = (ngx_memcmp(cn->key, cnt->key,
  1096.                             NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t))
  1097.                  < 0)
  1098.                     ? &temp->left : &temp->right;
  1099.         }

  1101.         if (*p == sentinel) {
  1102.             break;
  1103.         }

  1105.         temp = *p;
  1106.     }

  1108.     *p = node;
  1109.     node->parent = temp;
  1110.     node->left = sentinel;
  1111.     node->right = sentinel;
  1112.     ngx_rbt_red(node);
  1113. }


  1116. static void
  1117. ‌ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary, size_t len,
  1118.     u_char *hash)
  1119. {
  1120.     u_char     *p, *last;
  1121.     ngx_str_t   name;
  1122.     ngx_md5_t   md5;
  1123.     u_char      buf[NGX_HTTP_CACHE_VARY_LEN];

  1125.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1126.                    "http file cache vary: \"%*s\"", len, vary);

  1128.     ngx_md5_init(&md5);
  1129.     ngx_md5_update(&md5, r->cache->main, NGX_HTTP_CACHE_KEY_LEN);

  1131.     ngx_strlow(buf, vary, len);

  1133.     p = buf;
  1134.     last = buf + len;

  1136.     while (p < last) {

  1138.         while (p < last && (*p == ' ' || *p == ',')) { p++; }

  1140.         name.data = p;

  1142.         while (p < last && *p != ',' && *p != ' ') { p++; }

  1144.         name.len = p - name.data;

  1146.         if (name.len == 0) {
  1147.             break;
  1148.         }

  1150.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1151.                        "http file cache vary: %V", &name);

  1153.         ngx_md5_update(&md5, name.data, name.len);
  1154.         ngx_md5_update(&md5, (u_char *) ":", sizeof(":") - 1);

  1156.         ngx_http_file_cache_vary_header(r, &md5, &name);

  1158.         ngx_md5_update(&md5, (u_char *) CRLF, sizeof(CRLF) - 1);
  1159.     }

  1161.     ngx_md5_final(hash, &md5);
  1162. }


  1165. static void
  1166. ‌ngx_http_file_cache_vary_header(ngx_http_request_t *r, ngx_md5_t *md5,
  1167.     ngx_str_t *name)
  1168. {
  1169.     size_t            len;
  1170.     u_char           *p, *start, *last;
  1171.     ngx_uint_t        i, multiple, normalize;
  1172.     ngx_list_part_t  *part;
  1173.     ngx_table_elt_t  *header;

  1175.     multiple = 0;
  1176.     normalize = 0;

  1178.     if (name->len == sizeof("Accept-Charset") - 1
  1179.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Charset",
  1180.                            sizeof("Accept-Charset") - 1) == 0)
  1181.     {
  1182.         normalize = 1;

  1184.     } else if (name->len == sizeof("Accept-Encoding") - 1
  1185.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Encoding",
  1186.                            sizeof("Accept-Encoding") - 1) == 0)
  1187.     {
  1188.         normalize = 1;

  1190.     } else if (name->len == sizeof("Accept-Language") - 1
  1191.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Language",
  1192.                            sizeof("Accept-Language") - 1) == 0)
  1193.     {
  1194.         normalize = 1;
  1195.     }

  1197.     part = &r->headers_in.headers.part;
  1198.     header = part->elts;

  1200.     for (i = 0; /* void */ ; i++) {

  1202.         if (i >= part->nelts) {
  1203.             if (part->next == NULL) {
  1204.                 break;
  1205.             }

  1207.             part = part->next;
  1208.             header = part->elts;
  1209.             i = 0;
  1210.         }

  1212.         if (header[i].hash == 0) {
  1213.             continue;
  1214.         }

  1216.         if (header[i].key.len != name->len) {
  1217.             continue;
  1218.         }

  1220.         if (ngx_strncasecmp(header[i].key.data, name->data, name->len) != 0) {
  1221.             continue;
  1222.         }

  1224.         if (!normalize) {

  1226.             if (multiple) {
  1227.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1228.             }

  1230.             ngx_md5_update(md5, header[i].value.data, header[i].value.len);

  1232.             multiple = 1;

  1234.             continue;
  1235.         }

  1237.         /* normalize spaces */

  1239.         p = header[i].value.data;
  1240.         last = p + header[i].value.len;

  1242.         while (p < last) {

  1244.             while (p < last && (*p == ' ' || *p == ',')) { p++; }

  1246.             start = p;

  1248.             while (p < last && *p != ',' && *p != ' ') { p++; }

  1250.             len = p - start;

  1252.             if (len == 0) {
  1253.                 break;
  1254.             }

  1256.             if (multiple) {
  1257.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1258.             }

  1260.             ngx_md5_update(md5, start, len);

  1262.             multiple = 1;
  1263.         }
  1264.     }
  1265. }


  1268. static ngx_int_t
  1269. ‌ngx_http_file_cache_reopen(ngx_http_request_t *r, ngx_http_cache_t *c)
  1270. {
  1271.     ngx_http_file_cache_t  *cache;

  1273.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1274.                    "http file cache reopen");

  1276.     if (c->secondary) {
  1277.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1278.                       "cache file \"%s\" has incorrect vary hash",
  1279.                       c->file.name.data);
  1280.         return NGX_DECLINED;
  1281.     }

  1283.     cache = c->file_cache;

  1285.     ngx_shmtx_lock(&cache->shpool->mutex);

  1287.     c->node->count--;
  1288.     c->node = NULL;

  1290.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1292.     c->secondary = 1;
  1293.     c->file.name.len = 0;
  1294.     c->body_start = c->buffer_size;

  1296.     ngx_memcpy(c->key, c->variant, NGX_HTTP_CACHE_KEY_LEN);

  1298.     return ngx_http_file_cache_open(r);
  1299. }


  1302. ngx_int_t
  1303. ‌ngx_http_file_cache_set_header(ngx_http_request_t *r, u_char *buf)
  1304. {
  1305.     ngx_http_file_cache_header_t  *h = (ngx_http_file_cache_header_t *) buf;

  1307.     u_char            *p;
  1308.     ngx_str_t         *key;
  1309.     ngx_uint_t         i;
  1310.     ngx_http_cache_t  *c;

  1312.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1313.                    "http file cache set header");

  1315.     c = r->cache;

  1317.     ngx_memzero(h, sizeof(ngx_http_file_cache_header_t));

  1319.     h->version = NGX_HTTP_CACHE_VERSION;
  1320.     h->valid_sec = c->valid_sec;
  1321.     h->updating_sec = c->updating_sec;
  1322.     h->error_sec = c->error_sec;
  1323.     h->last_modified = c->last_modified;
  1324.     h->date = c->date;
  1325.     h->crc32 = c->crc32;
  1326.     h->valid_msec = (u_short) c->valid_msec;
  1327.     h->header_start = (u_short) c->header_start;
  1328.     h->body_start = (u_short) c->body_start;

  1330.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1331.         h->etag_len = (u_char) c->etag.len;
  1332.         ngx_memcpy(h->etag, c->etag.data, c->etag.len);
  1333.     }

  1335.     if (c->vary.len) {
  1336.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1337.             /* should not happen */
  1338.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1339.         }

  1341.         h->vary_len = (u_char) c->vary.len;
  1342.         ngx_memcpy(h->vary, c->vary.data, c->vary.len);

  1344.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1345.         ngx_memcpy(h->variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1346.     }

  1348.     if (ngx_http_file_cache_update_variant(r, c) != NGX_OK) {
  1349.         return NGX_ERROR;
  1350.     }

  1352.     p = buf + sizeof(ngx_http_file_cache_header_t);

  1354.     p = ngx_cpymem(p, ngx_http_file_cache_key, sizeof(ngx_http_file_cache_key));

  1356.     key = c->keys.elts;
  1357.     for (i = 0; i < c->keys.nelts; i++) {
  1358.         p = ngx_copy(p, key[i].data, key[i].len);
  1359.     }

  1361.     *p = LF;

  1363.     return NGX_OK;
  1364. }


  1367. static ngx_int_t
  1368. ‌ngx_http_file_cache_update_variant(ngx_http_request_t *r, ngx_http_cache_t *c)
  1369. {
  1370.     ngx_http_file_cache_t  *cache;

  1372.     if (!c->secondary) {
  1373.         return NGX_OK;
  1374.     }

  1376.     if (c->vary.len
  1377.         && ngx_memcmp(c->variant, c->key, NGX_HTTP_CACHE_KEY_LEN) == 0)
  1378.     {
  1379.         return NGX_OK;
  1380.     }

  1382.     /*
  1383.      * if the variant hash doesn't match one we used as a secondary
  1384.      * cache key, switch back to the original key
  1385.      */

  1387.     cache = c->file_cache;

  1389.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1390.                    "http file cache main key");

  1392.     ngx_shmtx_lock(&cache->shpool->mutex);

  1394.     c->node->count--;
  1395.     c->node->updating = 0;
  1396.     c->node = NULL;

  1398.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1400.     c->file.name.len = 0;
  1401.     c->update_variant = 1;

  1403.     ngx_memcpy(c->key, c->main, NGX_HTTP_CACHE_KEY_LEN);

  1405.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  1406.         return NGX_ERROR;
  1407.     }

  1409.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  1410.         return NGX_ERROR;
  1411.     }

  1413.     return NGX_OK;
  1414. }


  1417. void
  1418. ‌ngx_http_file_cache_update(ngx_http_request_t *r, ngx_temp_file_t *tf)
  1419. {
  1420.     off_t                   fs_size;
  1421.     ngx_int_t               rc;
  1422.     ngx_file_uniq_t         uniq;
  1423.     ngx_file_info_t         fi;
  1424.     ngx_http_cache_t        *c;
  1425.     ngx_ext_rename_file_t   ext;
  1426.     ngx_http_file_cache_t  *cache;

  1428.     c = r->cache;

  1430.     if (c->updated) {
  1431.         return;
  1432.     }

  1434.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1435.                    "http file cache update");

  1437.     cache = c->file_cache;

  1439.     c->updated = 1;
  1440.     c->updating = 0;

  1442.     uniq = 0;
  1443.     fs_size = 0;

  1445.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1446.                    "http file cache rename: \"%s\" to \"%s\"",
  1447.                    tf->file.name.data, c->file.name.data);

  1449.     ext.access = NGX_FILE_OWNER_ACCESS;
  1450.     ext.path_access = NGX_FILE_OWNER_ACCESS;
  1451.     ext.time = -1;
  1452.     ext.create_path = 1;
  1453.     ext.delete_file = 1;
  1454.     ext.log = r->connection->log;

  1456.     rc = ngx_ext_rename_file(&tf->file.name, &c->file.name, &ext);

  1458.     if (rc == NGX_OK) {

  1460.         if (ngx_fd_info(tf->file.fd, &fi) == NGX_FILE_ERROR) {
  1461.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1462.                           ngx_fd_info_n " \"%s\" failed", tf->file.name.data);

  1464.             rc = NGX_ERROR;

  1466.         } else {
  1467.             uniq = ngx_file_uniq(&fi);
  1468.             fs_size = (ngx_file_fs_size(&fi) + cache->bsize - 1) / cache->bsize;
  1469.         }
  1470.     }

  1472.     ngx_shmtx_lock(&cache->shpool->mutex);

  1474.     c->node->count--;
  1475.     c->node->error = 0;
  1476.     c->node->uniq = uniq;
  1477.     c->node->body_start = c->body_start;

  1479.     cache->sh->size += fs_size - c->node->fs_size;
  1480.     c->node->fs_size = fs_size;

  1482.     if (rc == NGX_OK) {
  1483.         c->node->exists = 1;
  1484.     }

  1486.     c->node->updating = 0;

  1488.     ngx_shmtx_unlock(&cache->shpool->mutex);
  1489. }


  1492. void
  1493. ‌ngx_http_file_cache_update_header(ngx_http_request_t *r)
  1494. {
  1495.     ssize_t                        n;
  1496.     ngx_err_t                      err;
  1497.     ngx_file_t                     file;
  1498.     ngx_file_info_t                fi;
  1499.     ngx_http_cache_t              *c;
  1500.     ngx_http_file_cache_header_t   h;

  1502.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1503.                    "http file cache update header");

  1505.     c = r->cache;

  1507.     ngx_memzero(&file, sizeof(ngx_file_t));

  1509.     file.name = c->file.name;
  1510.     file.log = r->connection->log;
  1511.     file.fd = ngx_open_file(file.name.data, NGX_FILE_RDWR, NGX_FILE_OPEN, 0);

  1513.     if (file.fd == NGX_INVALID_FILE) {
  1514.         err = ngx_errno;

  1516.         /* cache file may have been deleted */

  1518.         if (err == NGX_ENOENT) {
  1519.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1520.                            "http file cache \"%s\" not found",
  1521.                            file.name.data);
  1522.             return;
  1523.         }

  1525.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
  1526.                       ngx_open_file_n " \"%s\" failed", file.name.data);
  1527.         return;
  1528.     }

  1530.     /*
  1531.      * make sure cache file wasn't replaced;
  1532.      * if it was, do nothing
  1533.      */

  1535.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1536.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1537.                       ngx_fd_info_n " \"%s\" failed", file.name.data);
  1538.         goto done;
  1539.     }

  1541.     if (c->uniq != ngx_file_uniq(&fi)
  1542.         || c->length != ngx_file_size(&fi))
  1543.     {
  1544.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1545.                        "http file cache \"%s\" changed",
  1546.                        file.name.data);
  1547.         goto done;
  1548.     }

  1550.     n = ngx_read_file(&file, (u_char *) &h,
  1551.                       sizeof(ngx_http_file_cache_header_t), 0);

  1553.     if (n == NGX_ERROR) {
  1554.         goto done;
  1555.     }

  1557.     if ((size_t) n != sizeof(ngx_http_file_cache_header_t)) {
  1558.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1559.                       ngx_read_file_n " read only %z of %z from \"%s\"",
  1560.                       n, sizeof(ngx_http_file_cache_header_t), file.name.data);
  1561.         goto done;
  1562.     }

  1564.     if (h.version != NGX_HTTP_CACHE_VERSION
  1565.         || h.last_modified != c->last_modified
  1566.         || h.crc32 != c->crc32
  1567.         || (size_t) h.header_start != c->header_start
  1568.         || (size_t) h.body_start != c->body_start)
  1569.     {
  1570.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1571.                        "http file cache \"%s\" content changed",
  1572.                        file.name.data);
  1573.         goto done;
  1574.     }

  1576.     /*
  1577.      * update cache file header with new data,
  1578.      * notably h.valid_sec and h.date
  1579.      */

  1581.     ngx_memzero(&h, sizeof(ngx_http_file_cache_header_t));

  1583.     h.version = NGX_HTTP_CACHE_VERSION;
  1584.     h.valid_sec = c->valid_sec;
  1585.     h.updating_sec = c->updating_sec;
  1586.     h.error_sec = c->error_sec;
  1587.     h.last_modified = c->last_modified;
  1588.     h.date = c->date;
  1589.     h.crc32 = c->crc32;
  1590.     h.valid_msec = (u_short) c->valid_msec;
  1591.     h.header_start = (u_short) c->header_start;
  1592.     h.body_start = (u_short) c->body_start;

  1594.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1595.         h.etag_len = (u_char) c->etag.len;
  1596.         ngx_memcpy(h.etag, c->etag.data, c->etag.len);
  1597.     }

  1599.     if (c->vary.len) {
  1600.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1601.             /* should not happen */
  1602.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1603.         }

  1605.         h.vary_len = (u_char) c->vary.len;
  1606.         ngx_memcpy(h.vary, c->vary.data, c->vary.len);

  1608.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1609.         ngx_memcpy(h.variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1610.     }

  1612.     (void) ngx_write_file(&file, (u_char *) &h,
  1613.                           sizeof(ngx_http_file_cache_header_t), 0);

  1615. done:

  1617.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1618.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
  1619.                       ngx_close_file_n " \"%s\" failed", file.name.data);
  1620.     }
  1621. }


  1624. ngx_int_t
  1625. ‌ngx_http_cache_send(ngx_http_request_t *r)
  1626. {
  1627.     ngx_int_t          rc;
  1628.     ngx_buf_t         *b;
  1629.     ngx_chain_t        out;
  1630.     ngx_http_cache_t  *c;

  1632.     c = r->cache;

  1634.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1635.                    "http file cache send: %s", c->file.name.data);

  1637.     /* we need to allocate all before the header would be sent */

  1639.     b = ngx_calloc_buf(r->pool);
  1640.     if (b == NULL) {
  1641.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1642.     }

  1644.     b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
  1645.     if (b->file == NULL) {
  1646.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1647.     }

  1649.     rc = ngx_http_send_header(r);

  1651.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1652.         return rc;
  1653.     }

  1655.     b->file_pos = c->body_start;
  1656.     b->file_last = c->length;

  1658.     b->in_file = (c->length - c->body_start) ? 1 : 0;
  1659.     b->last_buf = (r == r->main) ? 1 : 0;
  1660.     b->last_in_chain = 1;
  1661.     b->sync = (b->last_buf || b->in_file) ? 0 : 1;

  1663.     b->file->fd = c->file.fd;
  1664.     b->file->name = c->file.name;
  1665.     b->file->log = r->connection->log;

  1667.     out.buf = b;
  1668.     out.next = NULL;

  1670.     return ngx_http_output_filter(r, &out);
  1671. }


  1674. void
  1675. ‌ngx_http_file_cache_free(ngx_http_cache_t *c, ngx_temp_file_t *tf)
  1676. {
  1677.     ngx_http_file_cache_t       *cache;
  1678.     ngx_http_file_cache_node_t  *fcn;

  1680.     if (c->updated || c->node == NULL) {
  1681.         return;
  1682.     }

  1684.     cache = c->file_cache;

  1686.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1687.                    "http file cache free, fd: %d", c->file.fd);

  1689.     ngx_shmtx_lock(&cache->shpool->mutex);

  1691.     fcn = c->node;
  1692.     fcn->count--;

  1694.     if (c->updating && fcn->lock_time == c->lock_time) {
  1695.         fcn->updating = 0;
  1696.     }

  1698.     if (c->error) {
  1699.         fcn->error = c->error;

  1701.         if (c->valid_sec) {
  1702.             fcn->valid_sec = c->valid_sec;
  1703.             fcn->valid_msec = c->valid_msec;
  1704.         }

  1706.     } else if (!fcn->exists && fcn->count == 0 && c->min_uses == 1) {
  1707.         ngx_queue_remove(&fcn->queue);
  1708.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  1709.         ngx_slab_free_locked(cache->shpool, fcn);
  1710.         cache->sh->count--;
  1711.         c->node = NULL;
  1712.     }

  1714.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1716.     c->updated = 1;
  1717.     c->updating = 0;

  1719.     if (c->temp_file) {
  1720.         if (tf && tf->file.fd != NGX_INVALID_FILE) {
  1721.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1722.                            "http file cache incomplete: \"%s\"",
  1723.                            tf->file.name.data);

  1725.             if (ngx_delete_file(tf->file.name.data) == NGX_FILE_ERROR) {
  1726.                 ngx_log_error(NGX_LOG_CRIT, c->file.log, ngx_errno,
  1727.                               ngx_delete_file_n " \"%s\" failed",
  1728.                               tf->file.name.data);
  1729.             }
  1730.         }
  1731.     }

  1733.     if (c->wait_event.timer_set) {
  1734.         ngx_del_timer(&c->wait_event);
  1735.     }
  1736. }


  1739. static void
  1740. ‌ngx_http_file_cache_cleanup(void *data)
  1741. {
  1742.     ngx_http_cache_t  *c = data;

  1744.     if (c->updated) {
  1745.         return;
  1746.     }

  1748.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1749.                    "http file cache cleanup");

  1751.     if (c->updating && !c->background) {
  1752.         ngx_log_error(NGX_LOG_ALERT, c->file.log, 0,
  1753.                       "stalled cache updating, error:%ui", c->error);
  1754.     }

  1756.     ngx_http_file_cache_free(c, NULL);
  1757. }


  1760. static time_t
  1761. ‌ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache)
  1762. {
  1763.     u_char                      *name, *p;
  1764.     size_t                       len;
  1765.     time_t                       wait;
  1766.     ngx_uint_t                   tries;
  1767.     ngx_path_t                  *path;
  1768.     ngx_queue_t                 *q, *sentinel;
  1769.     ngx_http_file_cache_node_t  *fcn;
  1770.     u_char                       key[2 * NGX_HTTP_CACHE_KEY_LEN];

  1772.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1773.                    "http file cache forced expire");

  1775.     path = cache->path;
  1776.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1778.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1779.     if (name == NULL) {
  1780.         return 10;
  1781.     }

  1783.     ngx_memcpy(name, path->name.data, path->name.len);

  1785.     wait = 10;
  1786.     tries = 20;
  1787.     sentinel = NULL;

  1789.     ngx_shmtx_lock(&cache->shpool->mutex);

  1791.     for ( ;; ) {
  1792.         if (ngx_queue_empty(&cache->sh->queue)) {
  1793.             break;
  1794.         }

  1796.         q = ngx_queue_last(&cache->sh->queue);

  1798.         if (q == sentinel) {
  1799.             break;
  1800.         }

  1802.         fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1804.         ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1805.                   "http file cache forced expire: #%d %d %02xd%02xd%02xd%02xd",
  1806.                   fcn->count, fcn->exists,
  1807.                   fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

  1809.         if (fcn->count == 0) {
  1810.             ngx_http_file_cache_delete(cache, q, name);
  1811.             wait = 0;
  1812.             break;
  1813.         }

  1815.         if (fcn->deleting) {
  1816.             wait = 1;
  1817.             break;
  1818.         }

  1820.         p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
  1821.                          sizeof(ngx_rbtree_key_t));
  1822.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1823.         (void) ngx_hex_dump(p, fcn->key, len);

  1825.         /*
  1826.          * abnormally exited workers may leave locked cache entries,
  1827.          * and although it may be safe to remove them completely,
  1828.          * we prefer to just move them to the top of the inactive queue
  1829.          */

  1831.         ngx_queue_remove(q);
  1832.         fcn->expire = ngx_time() + cache->inactive;
  1833.         ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  1835.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1836.                       "ignore long locked inactive cache entry %*s, count:%d",
  1837.                       (size_t) 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);

  1839.         if (sentinel == NULL) {
  1840.             sentinel = q;
  1841.         }

  1843.         if (--tries) {
  1844.             continue;
  1845.         }

  1847.         wait = 1;
  1848.         break;
  1849.     }

  1851.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1853.     ngx_free(name);

  1855.     return wait;
  1856. }


  1859. static time_t
  1860. ‌ngx_http_file_cache_expire(ngx_http_file_cache_t *cache)
  1861. {
  1862.     u_char                      *name, *p;
  1863.     size_t                       len;
  1864.     time_t                       now, wait;
  1865.     ngx_path_t                  *path;
  1866.     ngx_msec_t                   elapsed;
  1867.     ngx_queue_t                 *q;
  1868.     ngx_http_file_cache_node_t  *fcn;
  1869.     u_char                       key[2 * NGX_HTTP_CACHE_KEY_LEN];

  1871.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1872.                    "http file cache expire");

  1874.     path = cache->path;
  1875.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1877.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1878.     if (name == NULL) {
  1879.         return 10;
  1880.     }

  1882.     ngx_memcpy(name, path->name.data, path->name.len);

  1884.     now = ngx_time();

  1886.     ngx_shmtx_lock(&cache->shpool->mutex);

  1888.     for ( ;; ) {

  1890.         if (ngx_quit || ngx_terminate) {
  1891.             wait = 1;
  1892.             break;
  1893.         }

  1895.         if (ngx_queue_empty(&cache->sh->queue)) {
  1896.             wait = 10;
  1897.             break;
  1898.         }

  1900.         q = ngx_queue_last(&cache->sh->queue);

  1902.         fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1904.         wait = fcn->expire - now;

  1906.         if (wait > 0) {
  1907.             wait = wait > 10 ? 10 : wait;
  1908.             break;
  1909.         }

  1911.         ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1912.                        "http file cache expire: #%d %d %02xd%02xd%02xd%02xd",
  1913.                        fcn->count, fcn->exists,
  1914.                        fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

  1916.         if (fcn->count == 0) {
  1917.             ngx_http_file_cache_delete(cache, q, name);
  1918.             goto next;
  1919.         }

  1921.         if (fcn->deleting) {
  1922.             wait = 1;
  1923.             break;
  1924.         }

  1926.         p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
  1927.                          sizeof(ngx_rbtree_key_t));
  1928.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1929.         (void) ngx_hex_dump(p, fcn->key, len);

  1931.         /*
  1932.          * abnormally exited workers may leave locked cache entries,
  1933.          * and although it may be safe to remove them completely,
  1934.          * we prefer to just move them to the top of the inactive queue
  1935.          */

  1937.         ngx_queue_remove(q);
  1938.         fcn->expire = ngx_time() + cache->inactive;
  1939.         ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  1941.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1942.                       "ignore long locked inactive cache entry %*s, count:%d",
  1943.                       (size_t) 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);

  1945. next:

  1947.         if (++cache->files >= cache->manager_files) {
  1948.             wait = 0;
  1949.             break;
  1950.         }

  1952.         ngx_time_update();

  1954.         elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  1956.         if (elapsed >= cache->manager_threshold) {
  1957.             wait = 0;
  1958.             break;
  1959.         }
  1960.     }

  1962.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1964.     ngx_free(name);

  1966.     return wait;
  1967. }


  1970. static void
  1971. ‌ngx_http_file_cache_delete(ngx_http_file_cache_t *cache, ngx_queue_t *q,
  1972.     u_char *name)
  1973. {
  1974.     u_char                      *p;
  1975.     size_t                       len;
  1976.     ngx_path_t                  *path;
  1977.     ngx_http_file_cache_node_t  *fcn;

  1979.     fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1981.     if (fcn->exists) {
  1982.         cache->sh->size -= fcn->fs_size;

  1984.         path = cache->path;
  1985.         p = name + path->name.len + 1 + path->len;
  1986.         p = ngx_hex_dump(p, (u_char *) &fcn->node.key,
  1987.                          sizeof(ngx_rbtree_key_t));
  1988.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1989.         p = ngx_hex_dump(p, fcn->key, len);
  1990.         *p = '\0';

  1992.         fcn->count++;
  1993.         fcn->deleting = 1;
  1994.         ngx_shmtx_unlock(&cache->shpool->mutex);

  1996.         len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
  1997.         ngx_create_hashed_filename(path, name, len);

  1999.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2000.                        "http file cache expire: \"%s\"", name);

  2002.         if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  2003.             ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
  2004.                           ngx_delete_file_n " \"%s\" failed", name);
  2005.         }

  2007.         ngx_shmtx_lock(&cache->shpool->mutex);
  2008.         fcn->count--;
  2009.         fcn->deleting = 0;
  2010.     }

  2012.     if (fcn->count == 0) {
  2013.         ngx_queue_remove(q);
  2014.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  2015.         ngx_slab_free_locked(cache->shpool, fcn);
  2016.         cache->sh->count--;
  2017.     }
  2018. }


  2021. static ngx_msec_t
  2022. ‌ngx_http_file_cache_manager(void *data)
  2023. {
  2024.     ngx_http_file_cache_t  *cache = data;

  2026.     off_t       size, free;
  2027.     time_t      wait;
  2028.     ngx_msec_t  elapsed, next;
  2029.     ngx_uint_t  count, watermark;

  2031.     cache->last = ngx_current_msec;
  2032.     cache->files = 0;

  2034.     next = (ngx_msec_t) ngx_http_file_cache_expire(cache) * 1000;

  2036.     if (next == 0) {
  2037.         next = cache->manager_sleep;
  2038.         goto done;
  2039.     }

  2041.     for ( ;; ) {
  2042.         ngx_shmtx_lock(&cache->shpool->mutex);

  2044.         size = cache->sh->size;
  2045.         count = cache->sh->count;
  2046.         watermark = cache->sh->watermark;

  2048.         ngx_shmtx_unlock(&cache->shpool->mutex);

  2050.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2051.                        "http file cache size: %O c:%ui w:%i",
  2052.                        size, count, (ngx_int_t) watermark);

  2054.         if (size < cache->max_size && count < watermark) {

  2056.             if (!cache->min_free) {
  2057.                 break;
  2058.             }

  2060.             free = ngx_fs_available(cache->path->name.data);

  2062.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2063.                            "http file cache free: %O", free);

  2065.             if (free > cache->min_free) {
  2066.                 break;
  2067.             }
  2068.         }

  2070.         wait = ngx_http_file_cache_forced_expire(cache);

  2072.         if (wait > 0) {
  2073.             next = (ngx_msec_t) wait * 1000;
  2074.             break;
  2075.         }

  2077.         if (ngx_quit || ngx_terminate) {
  2078.             break;
  2079.         }

  2081.         if (++cache->files >= cache->manager_files) {
  2082.             next = cache->manager_sleep;
  2083.             break;
  2084.         }

  2086.         ngx_time_update();

  2088.         elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  2090.         if (elapsed >= cache->manager_threshold) {
  2091.             next = cache->manager_sleep;
  2092.             break;
  2093.         }
  2094.     }

  2096. done:

  2098.     elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  2100.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2101.                    "http file cache manager: %ui e:%M n:%M",
  2102.                    cache->files, elapsed, next);

  2104.     return next;
  2105. }


  2108. static void
  2109. ‌ngx_http_file_cache_loader(void *data)
  2110. {
  2111.     ngx_http_file_cache_t  *cache = data;

  2113.     ngx_tree_ctx_t  tree;

  2115.     if (!cache->sh->cold || cache->sh->loading) {
  2116.         return;
  2117.     }

  2119.     if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
  2120.         return;
  2121.     }

  2123.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2124.                    "http file cache loader");

  2126.     tree.init_handler = NULL;
  2127.     tree.file_handler = ngx_http_file_cache_manage_file;
  2128.     tree.pre_tree_handler = ngx_http_file_cache_manage_directory;
  2129.     tree.post_tree_handler = ngx_http_file_cache_noop;
  2130.     tree.spec_handler = ngx_http_file_cache_delete_file;
  2131.     tree.data = cache;
  2132.     tree.alloc = 0;
  2133.     tree.log = ngx_cycle->log;

  2135.     cache->last = ngx_current_msec;
  2136.     cache->files = 0;

  2138.     if (ngx_walk_tree(&tree, &cache->path->name) == NGX_ABORT) {
  2139.         cache->sh->loading = 0;
  2140.         return;
  2141.     }

  2143.     cache->sh->cold = 0;
  2144.     cache->sh->loading = 0;

  2146.     ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
  2147.                   "http file cache: %V %.3fM, bsize: %uz",
  2148.                   &cache->path->name,
  2149.                   ((double) cache->sh->size * cache->bsize) / (1024 * 1024),
  2150.                   cache->bsize);
  2151. }


  2154. static ngx_int_t
  2155. ‌ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2156. {
  2157.     return NGX_OK;
  2158. }


  2161. static ngx_int_t
  2162. ‌ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2163. {
  2164.     ngx_msec_t              elapsed;
  2165.     ngx_http_file_cache_t  *cache;

  2167.     cache = ctx->data;

  2169.     if (ngx_http_file_cache_add_file(ctx, path) != NGX_OK) {
  2170.         (void) ngx_http_file_cache_delete_file(ctx, path);
  2171.     }

  2173.     if (++cache->files >= cache->loader_files) {
  2174.         ngx_http_file_cache_loader_sleep(cache);

  2176.     } else {
  2177.         ngx_time_update();

  2179.         elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  2181.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2182.                        "http file cache loader time elapsed: %M", elapsed);

  2184.         if (elapsed >= cache->loader_threshold) {
  2185.             ngx_http_file_cache_loader_sleep(cache);
  2186.         }
  2187.     }

  2189.     return (ngx_quit || ngx_terminate) ? NGX_ABORT : NGX_OK;
  2190. }


  2193. static ngx_int_t
  2194. ‌ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2195. {
  2196.     if (path->len >= 5
  2197.         && ngx_strncmp(path->data + path->len - 5, "/temp", 5) == 0)
  2198.     {
  2199.         return NGX_DECLINED;
  2200.     }

  2202.     return NGX_OK;
  2203. }


  2206. static void
  2207. ‌ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache)
  2208. {
  2209.     ngx_msleep(cache->loader_sleep);

  2211.     ngx_time_update();

  2213.     cache->last = ngx_current_msec;
  2214.     cache->files = 0;
  2215. }


  2218. static ngx_int_t
  2219. ‌ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx, ngx_str_t *name)
  2220. {
  2221.     u_char                 *p;
  2222.     ngx_int_t               n;
  2223.     ngx_uint_t              i;
  2224.     ngx_http_cache_t        c;
  2225.     ngx_http_file_cache_t  *cache;

  2227.     if (name->len < 2 * NGX_HTTP_CACHE_KEY_LEN) {
  2228.         return NGX_ERROR;
  2229.     }

  2231.     /*
  2232.      * Temporary files in cache have a suffix consisting of a dot
  2233.      * followed by 10 digits.
  2234.      */

  2236.     if (name->len >= 2 * NGX_HTTP_CACHE_KEY_LEN + 1 + 10
  2237.         && name->data[name->len - 10 - 1] == '.')
  2238.     {
  2239.         return NGX_OK;
  2240.     }

  2242.     if (ctx->size < (off_t) sizeof(ngx_http_file_cache_header_t)) {
  2243.         ngx_log_error(NGX_LOG_CRIT, ctx->log, 0,
  2244.                       "cache file \"%s\" is too small", name->data);
  2245.         return NGX_ERROR;
  2246.     }

  2248.     ngx_memzero(&c, sizeof(ngx_http_cache_t));
  2249.     cache = ctx->data;

  2251.     c.length = ctx->size;
  2252.     c.fs_size = (ctx->fs_size + cache->bsize - 1) / cache->bsize;

  2254.     p = &name->data[name->len - 2 * NGX_HTTP_CACHE_KEY_LEN];

  2256.     for (i = 0; i < NGX_HTTP_CACHE_KEY_LEN; i++) {
  2257.         n = ngx_hextoi(p, 2);

  2259.         if (n == NGX_ERROR) {
  2260.             return NGX_ERROR;
  2261.         }

  2263.         p += 2;

  2265.         c.key[i] = (u_char) n;
  2266.     }

  2268.     return ngx_http_file_cache_add(cache, &c);
  2269. }


  2272. static ngx_int_t
  2273. ‌ngx_http_file_cache_add(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  2274. {
  2275.     ngx_http_file_cache_node_t  *fcn;

  2277.     ngx_shmtx_lock(&cache->shpool->mutex);

  2279.     fcn = ngx_http_file_cache_lookup(cache, c->key);

  2281.     if (fcn == NULL) {

  2283.         fcn = ngx_slab_calloc_locked(cache->shpool,
  2284.                                      sizeof(ngx_http_file_cache_node_t));
  2285.         if (fcn == NULL) {
  2286.             ngx_http_file_cache_set_watermark(cache);

  2288.             if (cache->fail_time != ngx_time()) {
  2289.                 cache->fail_time = ngx_time();
  2290.                 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  2291.                            "could not allocate node%s", cache->shpool->log_ctx);
  2292.             }

  2294.             ngx_shmtx_unlock(&cache->shpool->mutex);
  2295.             return NGX_ERROR;
  2296.         }

  2298.         cache->sh->count++;

  2300.         ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));

  2302.         ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
  2303.                    NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  2305.         ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);

  2307.         fcn->uses = 1;
  2308.         fcn->exists = 1;
  2309.         fcn->fs_size = c->fs_size;

  2311.         cache->sh->size += c->fs_size;

  2313.     } else {
  2314.         ngx_queue_remove(&fcn->queue);
  2315.     }

  2317.     fcn->expire = ngx_time() + cache->inactive;

  2319.     ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  2321.     ngx_shmtx_unlock(&cache->shpool->mutex);

  2323.     return NGX_OK;
  2324. }


  2327. static ngx_int_t
  2328. ‌ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2329. {
  2330.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
  2331.                    "http file cache delete: \"%s\"", path->data);

  2333.     if (ngx_delete_file(path->data) == NGX_FILE_ERROR) {
  2334.         ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
  2335.                       ngx_delete_file_n " \"%s\" failed", path->data);
  2336.     }

  2338.     return NGX_OK;
  2339. }


  2342. static void
  2343. ‌ngx_http_file_cache_set_watermark(ngx_http_file_cache_t *cache)
  2344. {
  2345.     cache->sh->watermark = cache->sh->count - cache->sh->count / 8;

  2347.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2348.                    "http file cache watermark: %ui", cache->sh->watermark);
  2349. }


  2352. time_t
  2353. ‌ngx_http_file_cache_valid(ngx_array_t *cache_valid, ngx_uint_t status)
  2354. {
  2355.     ngx_uint_t               i;
  2356.     ngx_http_cache_valid_t  *valid;

  2358.     if (cache_valid == NULL) {
  2359.         return 0;
  2360.     }

  2362.     valid = cache_valid->elts;
  2363.     for (i = 0; i < cache_valid->nelts; i++) {

  2365.         if (valid[i].status == 0) {
  2366.             return valid[i].valid;
  2367.         }

  2369.         if (valid[i].status == status) {
  2370.             return valid[i].valid;
  2371.         }
  2372.     }

  2374.     return 0;
  2375. }


  2378. char *
  2379. ‌ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2380. {
  2381.     char  *confp = conf;

  2383.     off_t                   max_size, min_free;
  2384.     u_char                 *last, *p;
  2385.     time_t                  inactive;
  2386.     ssize_t                 size;
  2387.     ngx_str_t               s, name, *value;
  2388.     ngx_int_t               loader_files, manager_files;
  2389.     ngx_msec_t              loader_sleep, manager_sleep, loader_threshold,
  2390.                             manager_threshold;
  2391.     ngx_uint_t              i, n, use_temp_path;
  2392.     ngx_array_t            *caches;
  2393.     ngx_http_file_cache_t  *cache, **ce;

  2395.     cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
  2396.     if (cache == NULL) {
  2397.         return NGX_CONF_ERROR;
  2398.     }

  2400.     cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  2401.     if (cache->path == NULL) {
  2402.         return NGX_CONF_ERROR;
  2403.     }

  2405.     use_temp_path = 1;

  2407.     inactive = 600;

  2409.     loader_files = 100;
  2410.     loader_sleep = 50;
  2411.     loader_threshold = 200;

  2413.     manager_files = 100;
  2414.     manager_sleep = 50;
  2415.     manager_threshold = 200;

  2417.     name.len = 0;
  2418.     size = 0;
  2419.     max_size = NGX_MAX_OFF_T_VALUE;
  2420.     min_free = 0;

  2422.     value = cf->args->elts;

  2424.     cache->path->name = value[1];

  2426.     if (cache->path->name.data[cache->path->name.len - 1] == '/') {
  2427.         cache->path->name.len--;
  2428.     }

  2430.     if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != NGX_OK) {
  2431.         return NGX_CONF_ERROR;
  2432.     }

  2434.     for (i = 2; i < cf->args->nelts; i++) {

  2436.         if (ngx_strncmp(value[i].data, "levels=", 7) == 0) {

  2438.             p = value[i].data + 7;
  2439.             last = value[i].data + value[i].len;

  2441.             for (n = 0; n < NGX_MAX_PATH_LEVEL && p < last; n++) {

  2443.                 if (*p > '0' && *p < '3') {

  2445.                     cache->path->level[n] = *p++ - '0';
  2446.                     cache->path->len += cache->path->level[n] + 1;

  2448.                     if (p == last) {
  2449.                         break;
  2450.                     }

  2452.                     if (*p++ == ':' && n < NGX_MAX_PATH_LEVEL - 1 && p < last) {
  2453.                         continue;
  2454.                     }

  2456.                     goto invalid_levels;
  2457.                 }

  2459.                 goto invalid_levels;
  2460.             }

  2462.             if (cache->path->len < 10 + NGX_MAX_PATH_LEVEL) {
  2463.                 continue;
  2464.             }

  2466.         invalid_levels:

  2468.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2469.                                "invalid \"levels\" \"%V\"", &value[i]);
  2470.             return NGX_CONF_ERROR;
  2471.         }

  2473.         if (ngx_strncmp(value[i].data, "use_temp_path=", 14) == 0) {

  2475.             if (ngx_strcmp(&value[i].data[14], "on") == 0) {
  2476.                 use_temp_path = 1;

  2478.             } else if (ngx_strcmp(&value[i].data[14], "off") == 0) {
  2479.                 use_temp_path = 0;

  2481.             } else {
  2482.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2483.                                    "invalid use_temp_path value \"%V\", "
  2484.                                    "it must be \"on\" or \"off\"",
  2485.                                    &value[i]);
  2486.                 return NGX_CONF_ERROR;
  2487.             }

  2489.             continue;
  2490.         }

  2492.         if (ngx_strncmp(value[i].data, "keys_zone=", 10) == 0) {

  2494.             name.data = value[i].data + 10;

  2496.             p = (u_char *) ngx_strchr(name.data, ':');

  2498.             if (p == NULL) {
  2499.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2500.                                    "invalid keys zone size \"%V\"", &value[i]);
  2501.                 return NGX_CONF_ERROR;
  2502.             }

  2504.             name.len = p - name.data;

  2506.             s.data = p + 1;
  2507.             s.len = value[i].data + value[i].len - s.data;

  2509.             size = ngx_parse_size(&s);

  2511.             if (size == NGX_ERROR) {
  2512.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2513.                                    "invalid keys zone size \"%V\"", &value[i]);
  2514.                 return NGX_CONF_ERROR;
  2515.             }

  2517.             if (size < (ssize_t) (2 * ngx_pagesize)) {
  2518.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2519.                                    "keys zone \"%V\" is too small", &value[i]);
  2520.                 return NGX_CONF_ERROR;
  2521.             }

  2523.             continue;
  2524.         }

  2526.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  2528.             s.len = value[i].len - 9;
  2529.             s.data = value[i].data + 9;

  2531.             inactive = ngx_parse_time(&s, 1);
  2532.             if (inactive == (time_t) NGX_ERROR) {
  2533.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2534.                                    "invalid inactive value \"%V\"", &value[i]);
  2535.                 return NGX_CONF_ERROR;
  2536.             }

  2538.             continue;
  2539.         }

  2541.         if (ngx_strncmp(value[i].data, "max_size=", 9) == 0) {

  2543.             s.len = value[i].len - 9;
  2544.             s.data = value[i].data + 9;

  2546.             max_size = ngx_parse_offset(&s);
  2547.             if (max_size < 0) {
  2548.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2549.                                    "invalid max_size value \"%V\"", &value[i]);
  2550.                 return NGX_CONF_ERROR;
  2551.             }

  2553.             continue;
  2554.         }

  2556.         if (ngx_strncmp(value[i].data, "min_free=", 9) == 0) {

  2558. #if (NGX_WIN32 || NGX_HAVE_STATFS || NGX_HAVE_STATVFS)

  2560.             s.len = value[i].len - 9;
  2561.             s.data = value[i].data + 9;

  2563.             min_free = ngx_parse_offset(&s);
  2564.             if (min_free < 0) {
  2565.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2566.                                    "invalid min_free value \"%V\"", &value[i]);
  2567.                 return NGX_CONF_ERROR;
  2568.             }

  2570. #else
  2571.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  2572.                                "min_free is not supported "
  2573.                                "on this platform, ignored");
  2574. #endif

  2576.             continue;
  2577.         }

  2579.         if (ngx_strncmp(value[i].data, "loader_files=", 13) == 0) {

  2581.             loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
  2582.             if (loader_files == NGX_ERROR) {
  2583.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2584.                            "invalid loader_files value \"%V\"", &value[i]);
  2585.                 return NGX_CONF_ERROR;
  2586.             }

  2588.             continue;
  2589.         }

  2591.         if (ngx_strncmp(value[i].data, "loader_sleep=", 13) == 0) {

  2593.             s.len = value[i].len - 13;
  2594.             s.data = value[i].data + 13;

  2596.             loader_sleep = ngx_parse_time(&s, 0);
  2597.             if (loader_sleep == (ngx_msec_t) NGX_ERROR) {
  2598.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2599.                            "invalid loader_sleep value \"%V\"", &value[i]);
  2600.                 return NGX_CONF_ERROR;
  2601.             }

  2603.             continue;
  2604.         }

  2606.         if (ngx_strncmp(value[i].data, "loader_threshold=", 17) == 0) {

  2608.             s.len = value[i].len - 17;
  2609.             s.data = value[i].data + 17;

  2611.             loader_threshold = ngx_parse_time(&s, 0);
  2612.             if (loader_threshold == (ngx_msec_t) NGX_ERROR) {
  2613.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2614.                            "invalid loader_threshold value \"%V\"", &value[i]);
  2615.                 return NGX_CONF_ERROR;
  2616.             }

  2618.             continue;
  2619.         }

  2621.         if (ngx_strncmp(value[i].data, "manager_files=", 14) == 0) {

  2623.             manager_files = ngx_atoi(value[i].data + 14, value[i].len - 14);
  2624.             if (manager_files == NGX_ERROR) {
  2625.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2626.                            "invalid manager_files value \"%V\"", &value[i]);
  2627.                 return NGX_CONF_ERROR;
  2628.             }

  2630.             continue;
  2631.         }

  2633.         if (ngx_strncmp(value[i].data, "manager_sleep=", 14) == 0) {

  2635.             s.len = value[i].len - 14;
  2636.             s.data = value[i].data + 14;

  2638.             manager_sleep = ngx_parse_time(&s, 0);
  2639.             if (manager_sleep == (ngx_msec_t) NGX_ERROR) {
  2640.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2641.                            "invalid manager_sleep value \"%V\"", &value[i]);
  2642.                 return NGX_CONF_ERROR;
  2643.             }

  2645.             continue;
  2646.         }

  2648.         if (ngx_strncmp(value[i].data, "manager_threshold=", 18) == 0) {

  2650.             s.len = value[i].len - 18;
  2651.             s.data = value[i].data + 18;

  2653.             manager_threshold = ngx_parse_time(&s, 0);
  2654.             if (manager_threshold == (ngx_msec_t) NGX_ERROR) {
  2655.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2656.                            "invalid manager_threshold value \"%V\"", &value[i]);
  2657.                 return NGX_CONF_ERROR;
  2658.             }

  2660.             continue;
  2661.         }

  2663.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2664.                            "invalid parameter \"%V\"", &value[i]);
  2665.         return NGX_CONF_ERROR;
  2666.     }

  2668.     if (name.len == 0 || size == 0) {
  2669.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2670.                            "\"%V\" must have \"keys_zone\" parameter",
  2671.                            &cmd->name);
  2672.         return NGX_CONF_ERROR;
  2673.     }

  2675.     cache->path->manager = ngx_http_file_cache_manager;
  2676.     cache->path->loader = ngx_http_file_cache_loader;
  2677.     cache->path->data = cache;
  2678.     cache->path->conf_file = cf->conf_file->file.name.data;
  2679.     cache->path->line = cf->conf_file->line;
  2680.     cache->loader_files = loader_files;
  2681.     cache->loader_sleep = loader_sleep;
  2682.     cache->loader_threshold = loader_threshold;
  2683.     cache->manager_files = manager_files;
  2684.     cache->manager_sleep = manager_sleep;
  2685.     cache->manager_threshold = manager_threshold;

  2687.     if (ngx_add_path(cf, &cache->path) != NGX_OK) {
  2688.         return NGX_CONF_ERROR;
  2689.     }

  2691.     cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
  2692.     if (cache->shm_zone == NULL) {
  2693.         return NGX_CONF_ERROR;
  2694.     }

  2696.     if (cache->shm_zone->data) {
  2697.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2698.                            "duplicate zone \"%V\"", &name);
  2699.         return NGX_CONF_ERROR;
  2700.     }


  2703.     cache->shm_zone->init = ngx_http_file_cache_init;
  2704.     cache->shm_zone->data = cache;

  2706.     cache->use_temp_path = use_temp_path;

  2708.     cache->inactive = inactive;
  2709.     cache->max_size = max_size;
  2710.     cache->min_free = min_free;

  2712.     caches = (ngx_array_t *) (confp + cmd->offset);

  2714.     ce = ngx_array_push(caches);
  2715.     if (ce == NULL) {
  2716.         return NGX_CONF_ERROR;
  2717.     }

  2719.     *ce = cache;

  2721.     return NGX_CONF_OK;
  2722. }


  2725. char *
  2726. ‌ngx_http_file_cache_valid_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  2727.     void *conf)
  2728. {
  2729.     char  *p = conf;

  2731.     time_t                    valid;
  2732.     ngx_str_t                *value;
  2733.     ngx_int_t                 status;
  2734.     ngx_uint_t                i, n;
  2735.     ngx_array_t             **a;
  2736.     ngx_http_cache_valid_t   *v;
  2737.     static ngx_uint_t         statuses[] = { 200, 301, 302 };

  2739.     a = (ngx_array_t **) (p + cmd->offset);

  2741.     if (*a == NGX_CONF_UNSET_PTR) {
  2742.         *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_cache_valid_t));
  2743.         if (*a == NULL) {
  2744.             return NGX_CONF_ERROR;
  2745.         }
  2746.     }

  2748.     value = cf->args->elts;
  2749.     n = cf->args->nelts - 1;

  2751.     valid = ngx_parse_time(&value[n], 1);
  2752.     if (valid == (time_t) NGX_ERROR) {
  2753.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2754.                            "invalid time value \"%V\"", &value[n]);
  2755.         return NGX_CONF_ERROR;
  2756.     }

  2758.     if (n == 1) {

  2760.         for (i = 0; i < 3; i++) {
  2761.             v = ngx_array_push(*a);
  2762.             if (v == NULL) {
  2763.                 return NGX_CONF_ERROR;
  2764.             }

  2766.             v->status = statuses[i];
  2767.             v->valid = valid;
  2768.         }

  2770.         return NGX_CONF_OK;
  2771.     }

  2773.     for (i = 1; i < n; i++) {

  2775.         if (ngx_strcmp(value[i].data, "any") == 0) {

  2777.             status = 0;

  2779.         } else {

  2781.             status = ngx_atoi(value[i].data, value[i].len);
  2782.             if (status < 100 || status > 599) {
  2783.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2784.                                    "invalid status \"%V\"", &value[i]);
  2785.                 return NGX_CONF_ERROR;
  2786.             }
  2787.         }

  2789.         v = ngx_array_push(*a);
  2790.         if (v == NULL) {
  2791.             return NGX_CONF_ERROR;
  2792.         }

  2794.         v->status = status;
  2795.         v->valid = valid;
  2796.     }

  2798.     return NGX_CONF_OK;
  2799. }

One Level Up Top Level