nginx-mail: src/http/ngx_http_file

comparison src/http/ngx_http_file_cache.c @ 665:0b460e61bdcd default tip

Merge with nginx 1.0.0.

author	Maxim Dounin <mdounin@mdounin.ru>
date	Mon, 25 Apr 2011 04:22:17 +0400
parents	b4dcae568a2a
children

comparison

equal deleted inserted replaced

-:06419a2298a9
+:0b460e61bdcd
 #include <ngx_http.h>
 #include <ngx_md5.h>
 static ngx_int_t ngx_http_file_cache_read(ngx_http_request_t *r,
+ngx_http_cache_t *c);
+static ssize_t ngx_http_file_cache_aio_read(ngx_http_request_t *r,
 ngx_http_cache_t *c);
 #if (NGX_HAVE_FILE_AIO)
 static void ngx_http_cache_aio_event_handler(ngx_event_t *ev);
 #endif
 static ngx_int_t ngx_http_file_cache_exists(ngx_http_file_cache_t *cache,
 ngx_http_cache_t *c);
+static ngx_int_t ngx_http_file_cache_name(ngx_http_request_t *r,
+ngx_path_t *path);
 static ngx_http_file_cache_node_t *
 ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key);
 static void ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
 ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
 static void ngx_http_file_cache_cleanup(void *data);
 ngx_str_t *path);
 ngx_str_t  ngx_http_cache_status[] = {
 ngx_string("MISS"),
+ngx_string("BYPASS"),
 ngx_string("EXPIRED"),
 ngx_string("STALE"),
 ngx_string("UPDATING"),
 ngx_string("HIT")
 };
 return NGX_OK;
 }
+ngx_int_t
+ngx_http_file_cache_new(ngx_http_request_t *r)
+{
+ngx_http_cache_t  *c;
+c = ngx_pcalloc(r->pool, sizeof(ngx_http_cache_t));
+if (c == NULL) {
+return NGX_ERROR;
+}
+if (ngx_array_init(&c->keys, r->pool, 4, sizeof(ngx_str_t)) != NGX_OK) {
+return NGX_ERROR;
+}
+r->cache = c;
+c->file.log = r->connection->log;
+c->file.fd = NGX_INVALID_FILE;
+return NGX_OK;
+}
+ngx_int_t
+ngx_http_file_cache_create(ngx_http_request_t *r)
+{
+ngx_http_cache_t       *c;
+ngx_pool_cleanup_t     *cln;
+ngx_http_file_cache_t  *cache;
+ngx_http_file_cache_create_key(r);
+c = r->cache;
+cache = c->file_cache;
+cln = ngx_pool_cleanup_add(r->pool, 0);
+if (cln == NULL) {
+return NGX_ERROR;
+}
+if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
+return NGX_ERROR;
+}
+cln->handler = ngx_http_file_cache_cleanup;
+cln->data = c;
+if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
+return NGX_ERROR;
+}
+return NGX_OK;
+}
 void
 ngx_http_file_cache_create_key(ngx_http_request_t *r)
 {
 size_t             len;
 ngx_str_t         *key;
 ngx_int_t
 ngx_http_file_cache_open(ngx_http_request_t *r)
 {
-u_char                    *p;
 ngx_int_t                  rc, rv;
 ngx_uint_t                 cold, test;
-ngx_path_t                *path;
 ngx_http_cache_t          *c;
 ngx_pool_cleanup_t        *cln;
 ngx_open_file_info_t       of;
 ngx_http_file_cache_t     *cache;
 ngx_http_core_loc_conf_t  *clcf;
 test = cold ? 1 : 0;
 rv = NGX_DECLINED;
 }
 }
-path = cache->path;
+if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
-c->file.name.len = path->name.len + 1 + path->len
-+ 2 * NGX_HTTP_CACHE_KEY_LEN;
-c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
-if (c->file.name.data == NULL) {
 return NGX_ERROR;
 }
-ngx_memcpy(c->file.name.data, path->name.data, path->name.len);
-p = c->file.name.data + path->name.len + 1 + path->len;
-p = ngx_hex_dump(p, c->key, NGX_HTTP_CACHE_KEY_LEN);
-*p = '\0';
-ngx_create_hashed_filename(path, c->file.name.data, c->file.name.len);
-ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
-"cache file: \"%s\"", c->file.name.data);
 if (!test) {
 return NGX_DECLINED;
 }
 of.uniq = c->uniq;
 of.valid = clcf->open_file_cache_valid;
 of.min_uses = clcf->open_file_cache_min_uses;
 of.events = clcf->open_file_cache_events;
 of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
+of.read_ahead = clcf->read_ahead;
 if (ngx_open_cached_file(clcf->open_file_cache, &c->file.name, &of, r->pool)
 != NGX_OK)
 {
 switch (of.err) {
 ssize_t                        n;
 ngx_int_t                      rc;
 ngx_http_file_cache_t         *cache;
 ngx_http_file_cache_header_t  *h;
-c = r->cache;
+n = ngx_http_file_cache_aio_read(r, c);
-#if (NGX_HAVE_FILE_AIO)
+if (n < 0) {
-{
-ngx_http_core_loc_conf_t      *clcf;
-clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
-if (clcf->aio) {
-n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);
-if (n == NGX_AGAIN) {
-c->file.aio->data = r;
-c->file.aio->handler = ngx_http_cache_aio_event_handler;
-r->main->blocked++;
-r->aio = 1;
-return NGX_AGAIN;
-}
-} else {
-n = ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
-}
-}
-#else
-n = ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
-#endif
-if (n == NGX_ERROR) {
 return n;
 }
-if ((size_t) n <= c->header_start) {
+if ((size_t) n < c->header_start) {
 ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
 "cache file \"%s\" is too small", c->file.name.data);
 return NGX_ERROR;
 }
 h = (ngx_http_file_cache_header_t *) c->buf->pos;
-if (h->crc32 != c->crc32 || (size_t) h->header_start != c->header_start) {
+if (h->crc32 != c->crc32) {
 ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
 "cache file \"%s\" has md5 collision", c->file.name.data);
 return NGX_DECLINED;
 }
 c->valid_sec = h->valid_sec;
 c->last_modified = h->last_modified;
 c->date = h->date;
 c->valid_msec = h->valid_msec;
+c->header_start = h->header_start;
 c->body_start = h->body_start;
 r->cached = 1;
 cache = c->file_cache;
 if (c->node->updating) {
 rc = NGX_HTTP_CACHE_UPDATING;
 } else {
 c->node->updating = 1;
+c->updating = 1;
 rc = NGX_HTTP_CACHE_STALE;
 }
 ngx_shmtx_unlock(&cache->shpool->mutex);
 return NGX_OK;
 }
+static ssize_t
+ngx_http_file_cache_aio_read(ngx_http_request_t *r, ngx_http_cache_t *c)
+{
 #if (NGX_HAVE_FILE_AIO)
+ssize_t                    n;
+ngx_http_core_loc_conf_t  *clcf;
+if (!ngx_file_aio) {
+goto noaio;
+}
+clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+if (!clcf->aio) {
+goto noaio;
+}
+n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);
+if (n != NGX_AGAIN) {
+return n;
+}
+c->file.aio->data = r;
+c->file.aio->handler = ngx_http_cache_aio_event_handler;
+r->main->blocked++;
+r->aio = 1;
+return NGX_AGAIN;
+noaio:
+#endif
+return ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
+}
+#if (NGX_HAVE_FILE_AIO)
 static void
 ngx_http_cache_aio_event_handler(ngx_event_t *ev)
 {
 ngx_event_aio_t     *aio;
 fcn = ngx_http_file_cache_lookup(cache, c->key);
 if (fcn) {
 ngx_queue_remove(&fcn->queue);
+fcn->uses++;
+fcn->count++;
 if (fcn->error) {
 if (fcn->valid_sec < ngx_time()) {
 goto renew;
 rc = NGX_OK;
 goto done;
 }
-fcn->uses++;
-fcn->count++;
 if (fcn->exists) {
 c->exists = fcn->exists;
 c->body_start = fcn->body_start;
 ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
 NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
 ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);
-renew:
-rc = NGX_DECLINED;
 fcn->uses = 1;
 fcn->count = 1;
+fcn->updating = 0;
+fcn->deleting = 0;
+renew:
+rc = NGX_DECLINED;
 fcn->valid_msec = 0;
 fcn->error = 0;
 fcn->exists = 0;
 fcn->valid_sec = 0;
 fcn->uniq = 0;
 return rc;
 }
+static ngx_int_t
+ngx_http_file_cache_name(ngx_http_request_t *r, ngx_path_t *path)
+{
+u_char            *p;
+ngx_http_cache_t  *c;
+c = r->cache;
+c->file.name.len = path->name.len + 1 + path->len
++ 2 * NGX_HTTP_CACHE_KEY_LEN;
+c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
+if (c->file.name.data == NULL) {
+return NGX_ERROR;
+}
+ngx_memcpy(c->file.name.data, path->name.data, path->name.len);
+p = c->file.name.data + path->name.len + 1 + path->len;
+p = ngx_hex_dump(p, c->key, NGX_HTTP_CACHE_KEY_LEN);
+*p = '\0';
+ngx_create_hashed_filename(path, c->file.name.data, c->file.name.len);
+ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+"cache file: \"%s\"", c->file.name.data);
+return NGX_OK;
+}
 static ngx_http_file_cache_node_t *
 ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
 {
 ngx_int_t                    rc;
 ngx_rbtree_key_t             node_key;
 void
 ngx_http_file_cache_update(ngx_http_request_t *r, ngx_temp_file_t *tf)
 {
-off_t                   size;
+off_t                   size, length;
 ngx_int_t               rc;
 ngx_file_uniq_t         uniq;
 ngx_file_info_t         fi;
 ngx_http_cache_t        *c;
 ngx_ext_rename_file_t   ext;
 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 "http file cache update");
 c->updated = 1;
+c->updating = 0;
 cache = c->file_cache;
 uniq = 0;
+length = 0;
 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 "http file cache rename: \"%s\" to \"%s\"",
 tf->file.name.data, c->file.name.data);
 rc = NGX_ERROR;
 } else {
 uniq = ngx_file_uniq(&fi);
-}
+length = ngx_file_size(&fi);
 }
+}
-size = (c->length + cache->bsize - 1) / cache->bsize;
+size = (length + cache->bsize - 1) / cache->bsize;
 ngx_shmtx_lock(&cache->shpool->mutex);
 c->node->count--;
 c->node->uniq = uniq;
 c->node->body_start = c->body_start;
 size = size - (c->node->length + cache->bsize - 1) / cache->bsize;
-c->node->length = c->length;
+c->node->length = length;
 cache->sh->size += size;
 if (rc == NGX_OK) {
 c->node->exists = 1;
 ngx_int_t
 ngx_http_cache_send(ngx_http_request_t *r)
 {
-off_t              size;
 ngx_int_t          rc;
 ngx_buf_t         *b;
 ngx_chain_t        out;
 ngx_http_cache_t  *c;
 b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
 if (b->file == NULL) {
 return NGX_HTTP_INTERNAL_SERVER_ERROR;
 }
+r->header_only = (c->length - c->body_start) == 0;
 rc = ngx_http_send_header(r);
 if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
 return rc;
 }
-size = c->length - c->body_start;
-if (size == 0) {
-return rc;
-}
 b->file_pos = c->body_start;
 b->file_last = c->length;
-b->in_file = size ? 1: 0;
+b->in_file = 1;
 b->last_buf = (r == r->main) ? 1: 0;
 b->last_in_chain = 1;
 b->file->fd = c->file.fd;
 b->file->name = c->file.name;
 return ngx_http_output_filter(r, &out);
 }
 void
-ngx_http_file_cache_free(ngx_http_request_t *r, ngx_temp_file_t *tf)
+ngx_http_file_cache_free(ngx_http_cache_t *c, ngx_temp_file_t *tf)
 {
-ngx_http_cache_t       *c;
+ngx_http_file_cache_t       *cache;
-ngx_http_file_cache_t  *cache;
+ngx_http_file_cache_node_t  *fcn;
-c = r->cache;
 if (c->updated) {
 return;
 }
+cache = c->file_cache;
+ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
+"http file cache free, fd: %d", c->file.fd);
+ngx_shmtx_lock(&cache->shpool->mutex);
+fcn = c->node;
+fcn->count--;
+if (c->updating) {
+fcn->updating = 0;
+}
+if (c->error) {
+fcn->error = c->error;
+if (c->valid_sec) {
+fcn->valid_sec = c->valid_sec;
+fcn->valid_msec = c->valid_msec;
+}
+} else if (!fcn->exists && fcn->count == 0 && c->min_uses == 1) {
+ngx_queue_remove(&fcn->queue);
+ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
+ngx_slab_free_locked(cache->shpool, fcn);
+c->node = NULL;
+}
+ngx_shmtx_unlock(&cache->shpool->mutex);
 c->updated = 1;
+c->updating = 0;
-cache = c->file_cache;
-ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-"http file cache free");
-ngx_shmtx_lock(&cache->shpool->mutex);
-c->node->count--;
-if (c->error) {
-c->node->valid_sec = c->valid_sec;
-c->node->valid_msec = c->valid_msec;
-c->node->error = c->error;
-}
-c->node->updating = 0;
-ngx_shmtx_unlock(&cache->shpool->mutex);
 if (c->temp_file) {
 if (tf && tf->file.fd != NGX_INVALID_FILE) {
-ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
 "http file cache incomplete: \"%s\"",
 tf->file.name.data);
 if (ngx_delete_file(tf->file.name.data) == NGX_FILE_ERROR) {
-ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
+ngx_log_error(NGX_LOG_CRIT, c->file.log, ngx_errno,
 ngx_delete_file_n " \"%s\" failed",
 tf->file.name.data);
 }
 }
 }
 static void
 ngx_http_file_cache_cleanup(void *data)
 {
 ngx_http_cache_t  *c = data;
-ngx_http_file_cache_t  *cache;
 if (c->updated) {
 return;
 }
-c->updated = 1;
 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
 "http file cache cleanup");
-if (c->error) {
+if (c->updating) {
-return;
+ngx_log_error(NGX_LOG_ALERT, c->file.log, 0,
-}
+"stalled cache updating, error:%ui", c->error);
+}
-cache = c->file_cache;
+ngx_http_file_cache_free(c, NULL);
-ngx_shmtx_lock(&cache->shpool->mutex);
-c->node->count--;
-ngx_shmtx_unlock(&cache->shpool->mutex);
 }
 static time_t
 ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache)
 }
 ngx_memcpy(name, path->name.data, path->name.len);
 wait = 10;
-tries = 0;
+tries = 20;
 ngx_shmtx_lock(&cache->shpool->mutex);
 for (q = ngx_queue_last(&cache->sh->queue);
 q != ngx_queue_sentinel(&cache->sh->queue);
 ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
 "http file cache forced expire: #%d %d %02xd%02xd%02xd%02xd",
 fcn->count, fcn->exists,
 fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);
-if (fcn->count) {
+if (fcn->count == 0) {
+ngx_http_file_cache_delete(cache, q, name);
-if (tries++ < 20) {
+wait = 0;
+} else {
+if (--tries) {
 continue;
 }
 wait = 1;
+}
-break;
-}
-if (!fcn->exists) {
-ngx_queue_remove(q);
-ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
-ngx_slab_free_locked(cache->shpool, fcn);
-break;
-}
-ngx_http_file_cache_delete(cache, q, name);
 break;
 }
 ngx_shmtx_unlock(&cache->shpool->mutex);
 ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
 "http file cache expire: #%d %d %02xd%02xd%02xd%02xd",
 fcn->count, fcn->exists,
 fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);
-if (fcn->count) {
+if (fcn->count == 0) {
+ngx_http_file_cache_delete(cache, q, name);
-p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
-sizeof(ngx_rbtree_key_t));
-len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
-(void) ngx_hex_dump(p, fcn->key, len);
-/*
-* abnormally exited workers may leave locked cache entries,
-* and although it may be safe to remove them completely,
-* we prefer to remove them from inactive queue and rbtree
-* only, and to allow other leaks
-*/
-ngx_queue_remove(q);
-ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
-ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
-"ignore long locked inactive cache entry %*s, count:%d",
-2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);
 continue;
 }
-if (!fcn->exists) {
+if (fcn->deleting) {
-ngx_queue_remove(q);
-ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
-ngx_slab_free_locked(cache->shpool, fcn);
 continue;
 }
-ngx_http_file_cache_delete(cache, q, name);
+p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
+sizeof(ngx_rbtree_key_t));
+len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
+(void) ngx_hex_dump(p, fcn->key, len);
+/*
+* abnormally exited workers may leave locked cache entries,
+* and although it may be safe to remove them completely,
+* we prefer to remove them from inactive queue and rbtree
+* only, and to allow other leaks
+*/
+ngx_queue_remove(q);
+ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
+ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
+"ignore long locked inactive cache entry %*s, count:%d",
+2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);
 }
 ngx_shmtx_unlock(&cache->shpool->mutex);
 ngx_free(name);
 ngx_path_t                  *path;
 ngx_http_file_cache_node_t  *fcn;
 fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);
-cache->sh->size -= (fcn->length + cache->bsize - 1) / cache->bsize;
+if (fcn->exists) {
+cache->sh->size -= (fcn->length + cache->bsize - 1) / cache->bsize;
-path = cache->path;
+path = cache->path;
 p = name + path->name.len + 1 + path->len;
+p = ngx_hex_dump(p, (u_char *) &fcn->node.key,
-p = ngx_hex_dump(p, (u_char *) &fcn->node.key, sizeof(ngx_rbtree_key_t));
+sizeof(ngx_rbtree_key_t));
+len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
-len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
+p = ngx_hex_dump(p, fcn->key, len);
-p = ngx_hex_dump(p, fcn->key, len);
+*p = '\0';
-*p = '\0';
+fcn->count++;
-ngx_queue_remove(q);
+fcn->deleting = 1;
+ngx_shmtx_unlock(&cache->shpool->mutex);
-ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
+len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
-ngx_slab_free_locked(cache->shpool, fcn);
+ngx_create_hashed_filename(path, name, len);
-ngx_shmtx_unlock(&cache->shpool->mutex);
+ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
+"http file cache expire: \"%s\"", name);
-len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
+if (ngx_delete_file(name) == NGX_FILE_ERROR) {
-ngx_create_hashed_filename(path, name, len);
+ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
+ngx_delete_file_n " \"%s\" failed", name);
-ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
+}
-"http file cache expire: \"%s\"", name);
+ngx_shmtx_lock(&cache->shpool->mutex);
-if (ngx_delete_file(name) == NGX_FILE_ERROR) {
+fcn->count--;
-ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
+fcn->deleting = 0;
-ngx_delete_file_n " \"%s\" failed", name);
+}
-}
+if (fcn->count == 0) {
-ngx_shmtx_lock(&cache->shpool->mutex);
+ngx_queue_remove(q);
+ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
+ngx_slab_free_locked(cache->shpool, fcn);
+}
 }
 static time_t
 ngx_http_file_cache_manager(void *data)
 {
 ngx_http_file_cache_t  *cache = data;
 off_t   size;
-time_t  next;
+time_t  next, wait;
 next = ngx_http_file_cache_expire(cache);
 cache->last = ngx_current_msec;
 cache->files = 0;
 if (size < cache->max_size) {
 return next;
 }
-next = ngx_http_file_cache_forced_expire(cache);
+wait = ngx_http_file_cache_forced_expire(cache);
+if (wait > 0) {
+return wait;
+}
 if (ngx_http_file_cache_manager_sleep(cache) != NGX_OK) {
 return next;
 }
 }
 {
 ngx_msec_t  elapsed;
 if (cache->files++ > 100) {
-ngx_time_update(0, 0);
+ngx_time_update();
 elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));
 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
 "http file cache manager time: %M", elapsed);
 * therefore sleep 200ms
 */
 ngx_msleep(200);
-ngx_time_update(0, 0);
+ngx_time_update();
 }
 cache->last = ngx_current_msec;
 cache->files = 0;
 }
 fcn->uses = 1;
 fcn->count = 0;
 fcn->valid_msec = c->valid_msec;
 fcn->error = 0;
 fcn->exists = 1;
+fcn->updating = 0;
+fcn->deleting = 0;
 fcn->uniq = c->uniq;
 fcn->valid_sec = c->valid_sec;
 fcn->body_start = c->body_start;
 fcn->length = c->length;
 v->valid = valid;
 }
 return NGX_CONF_OK;
 }
+ngx_int_t
+ngx_http_cache(ngx_http_request_t *r, ngx_array_t *no_cache)
+{
+ngx_str_t                  val;
+ngx_uint_t                 i;
+ngx_http_complex_value_t  *cv;
+cv = no_cache->elts;
+for (i = 0; i < no_cache->nelts; i++) {
+if (ngx_http_complex_value(r, &cv[i], &val) != NGX_OK) {
+return NGX_ERROR;
+}
+if (val.len && val.data[0] != '0') {
+return NGX_DECLINED;
+}
+}
+return NGX_OK;
+}
+char *
+ngx_http_no_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+char  *p = conf;
+ngx_str_t                          *value;
+ngx_uint_t                          i;
+ngx_array_t                       **a;
+ngx_http_complex_value_t           *cv;
+ngx_http_compile_complex_value_t    ccv;
+a = (ngx_array_t **) (p + cmd->offset);
+if (*a == NGX_CONF_UNSET_PTR) {
+*a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_complex_value_t));
+if (*a == NULL) {
+return NGX_CONF_ERROR;
+}
+}
+value = cf->args->elts;
+for (i = 1; i < cf->args->nelts; i++) {
+cv = ngx_array_push(*a);
+if (cv == NULL) {
+return NGX_CONF_ERROR;
+}
+ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
+ccv.cf = cf;
+ccv.value = &value[i];
+ccv.complex_value = cv;
+if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
+return NGX_CONF_ERROR;
+}
+}
+return NGX_CONF_OK;
+}

Mercurial > hg > nginx-mail

comparison src/http/ngx_http_file_cache.c @ 665:0b460e61bdcd default tip