![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_file_cache.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http|
Return to ngx_http_file_cache.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10: #include <ngx_http.h>
11: #include <ngx_md5.h>
12:
13:
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_read(ngx_http_request_t *r,
18: ngx_http_cache_t *c);
19: static ssize_t ngx_http_file_cache_aio_read(ngx_http_request_t *r,
20: ngx_http_cache_t *c);
21: #if (NGX_HAVE_FILE_AIO)
22: static void ngx_http_cache_aio_event_handler(ngx_event_t *ev);
23: #endif
24: static ngx_int_t ngx_http_file_cache_exists(ngx_http_file_cache_t *cache,
25: ngx_http_cache_t *c);
26: static ngx_int_t ngx_http_file_cache_name(ngx_http_request_t *r,
27: ngx_path_t *path);
28: static ngx_http_file_cache_node_t *
29: ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key);
30: static void ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
31: ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
32: static void ngx_http_file_cache_cleanup(void *data);
33: static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache);
34: static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache);
35: static void ngx_http_file_cache_delete(ngx_http_file_cache_t *cache,
36: ngx_queue_t *q, u_char *name);
37: static void ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache);
38: static ngx_int_t ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx,
39: ngx_str_t *path);
40: static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx,
41: ngx_str_t *path);
42: static ngx_int_t ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx,
43: ngx_str_t *path);
44: static ngx_int_t ngx_http_file_cache_add(ngx_http_file_cache_t *cache,
45: ngx_http_cache_t *c);
46: static ngx_int_t ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx,
47: ngx_str_t *path);
48:
49:
50: ngx_str_t ngx_http_cache_status[] = {
51: ngx_string("MISS"),
52: ngx_string("BYPASS"),
53: ngx_string("EXPIRED"),
54: ngx_string("STALE"),
55: ngx_string("UPDATING"),
56: ngx_string("HIT")
57: };
58:
59:
60: static u_char ngx_http_file_cache_key[] = { LF, 'K', 'E', 'Y', ':', ' ' };
61:
62:
63: static ngx_int_t
64: ngx_http_file_cache_init(ngx_shm_zone_t *shm_zone, void *data)
65: {
66: ngx_http_file_cache_t *ocache = data;
67:
68: size_t len;
69: ngx_uint_t n;
70: ngx_http_file_cache_t *cache;
71:
72: cache = shm_zone->data;
73:
74: if (ocache) {
75: if (ngx_strcmp(cache->path->name.data, ocache->path->name.data) != 0) {
76: ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
77: "cache \"%V\" uses the \"%V\" cache path "
78: "while previously it used the \"%V\" cache path",
79: &shm_zone->shm.name, &cache->path->name,
80: &ocache->path->name);
81:
82: return NGX_ERROR;
83: }
84:
85: for (n = 0; n < 3; n++) {
86: if (cache->path->level[n] != ocache->path->level[n]) {
87: ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
88: "cache \"%V\" had previously different levels",
89: &shm_zone->shm.name);
90: return NGX_ERROR;
91: }
92: }
93:
94: cache->sh = ocache->sh;
95:
96: cache->shpool = ocache->shpool;
97: cache->bsize = ocache->bsize;
98:
99: cache->max_size /= cache->bsize;
100:
101: if (!cache->sh->cold || cache->sh->loading) {
102: cache->path->loader = NULL;
103: }
104:
105: return NGX_OK;
106: }
107:
108: cache->shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
109:
110: if (shm_zone->shm.exists) {
111: cache->sh = cache->shpool->data;
112: cache->bsize = ngx_fs_bsize(cache->path->name.data);
113:
114: return NGX_OK;
115: }
116:
117: cache->sh = ngx_slab_alloc(cache->shpool, sizeof(ngx_http_file_cache_sh_t));
118: if (cache->sh == NULL) {
119: return NGX_ERROR;
120: }
121:
122: cache->shpool->data = cache->sh;
123:
124: ngx_rbtree_init(&cache->sh->rbtree, &cache->sh->sentinel,
125: ngx_http_file_cache_rbtree_insert_value);
126:
127: ngx_queue_init(&cache->sh->queue);
128:
129: cache->sh->cold = 1;
130: cache->sh->loading = 0;
131: cache->sh->size = 0;
132:
133: cache->bsize = ngx_fs_bsize(cache->path->name.data);
134:
135: cache->max_size /= cache->bsize;
136:
137: len = sizeof(" in cache keys zone \"\"") + shm_zone->shm.name.len;
138:
139: cache->shpool->log_ctx = ngx_slab_alloc(cache->shpool, len);
140: if (cache->shpool->log_ctx == NULL) {
141: return NGX_ERROR;
142: }
143:
144: ngx_sprintf(cache->shpool->log_ctx, " in cache keys zone \"%V\"%Z",
145: &shm_zone->shm.name);
146:
147: return NGX_OK;
148: }
149:
150:
151: ngx_int_t
152: ngx_http_file_cache_new(ngx_http_request_t *r)
153: {
154: ngx_http_cache_t *c;
155:
156: c = ngx_pcalloc(r->pool, sizeof(ngx_http_cache_t));
157: if (c == NULL) {
158: return NGX_ERROR;
159: }
160:
161: if (ngx_array_init(&c->keys, r->pool, 4, sizeof(ngx_str_t)) != NGX_OK) {
162: return NGX_ERROR;
163: }
164:
165: r->cache = c;
166: c->file.log = r->connection->log;
167: c->file.fd = NGX_INVALID_FILE;
168:
169: return NGX_OK;
170: }
171:
172:
173: ngx_int_t
174: ngx_http_file_cache_create(ngx_http_request_t *r)
175: {
176: ngx_http_cache_t *c;
177: ngx_pool_cleanup_t *cln;
178: ngx_http_file_cache_t *cache;
179:
180: c = r->cache;
181: cache = c->file_cache;
182:
183: cln = ngx_pool_cleanup_add(r->pool, 0);
184: if (cln == NULL) {
185: return NGX_ERROR;
186: }
187:
188: cln->handler = ngx_http_file_cache_cleanup;
189: cln->data = c;
190:
191: if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
192: return NGX_ERROR;
193: }
194:
195: if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
196: return NGX_ERROR;
197: }
198:
199: return NGX_OK;
200: }
201:
202:
203: void
204: ngx_http_file_cache_create_key(ngx_http_request_t *r)
205: {
206: size_t len;
207: ngx_str_t *key;
208: ngx_uint_t i;
209: ngx_md5_t md5;
210: ngx_http_cache_t *c;
211:
212: c = r->cache;
213:
214: len = 0;
215:
216: ngx_crc32_init(c->crc32);
217: ngx_md5_init(&md5);
218:
219: key = c->keys.elts;
220: for (i = 0; i < c->keys.nelts; i++) {
221: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
222: "http cache key: \"%V\"", &key[i]);
223:
224: len += key[i].len;
225:
226: ngx_crc32_update(&c->crc32, key[i].data, key[i].len);
227: ngx_md5_update(&md5, key[i].data, key[i].len);
228: }
229:
230: c->header_start = sizeof(ngx_http_file_cache_header_t)
231: + sizeof(ngx_http_file_cache_key) + len + 1;
232:
233: ngx_crc32_final(c->crc32);
234: ngx_md5_final(c->key, &md5);
235: }
236:
237:
238: ngx_int_t
239: ngx_http_file_cache_open(ngx_http_request_t *r)
240: {
241: ngx_int_t rc, rv;
242: ngx_uint_t cold, test;
243: ngx_http_cache_t *c;
244: ngx_pool_cleanup_t *cln;
245: ngx_open_file_info_t of;
246: ngx_http_file_cache_t *cache;
247: ngx_http_core_loc_conf_t *clcf;
248:
249: c = r->cache;
250:
251: if (c->waiting) {
252: return NGX_AGAIN;
253: }
254:
255: if (c->buf) {
256: return ngx_http_file_cache_read(r, c);
257: }
258:
259: cache = c->file_cache;
260:
261: if (c->node == NULL) {
262: cln = ngx_pool_cleanup_add(r->pool, 0);
263: if (cln == NULL) {
264: return NGX_ERROR;
265: }
266:
267: cln->handler = ngx_http_file_cache_cleanup;
268: cln->data = c;
269: }
270:
271: rc = ngx_http_file_cache_exists(cache, c);
272:
273: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
274: "http file cache exists: %i e:%d", rc, c->exists);
275:
276: if (rc == NGX_ERROR) {
277: return rc;
278: }
279:
280: if (rc == NGX_AGAIN) {
281: return NGX_HTTP_CACHE_SCARCE;
282: }
283:
284: cold = cache->sh->cold;
285:
286: if (rc == NGX_OK) {
287:
288: if (c->error) {
289: return c->error;
290: }
291:
292: c->temp_file = 1;
293: test = c->exists ? 1 : 0;
294: rv = NGX_DECLINED;
295:
296: } else { /* rc == NGX_DECLINED */
297:
298: if (c->min_uses > 1) {
299:
300: if (!cold) {
301: return NGX_HTTP_CACHE_SCARCE;
302: }
303:
304: test = 1;
305: rv = NGX_HTTP_CACHE_SCARCE;
306:
307: } else {
308: c->temp_file = 1;
309: test = cold ? 1 : 0;
310: rv = NGX_DECLINED;
311: }
312: }
313:
314: if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
315: return NGX_ERROR;
316: }
317:
318: if (!test) {
319: goto done;
320: }
321:
322: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
323:
324: ngx_memzero(&of, sizeof(ngx_open_file_info_t));
325:
326: of.uniq = c->uniq;
327: of.valid = clcf->open_file_cache_valid;
328: of.min_uses = clcf->open_file_cache_min_uses;
329: of.events = clcf->open_file_cache_events;
330: of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
331: of.read_ahead = clcf->read_ahead;
332:
333: if (ngx_open_cached_file(clcf->open_file_cache, &c->file.name, &of, r->pool)
334: != NGX_OK)
335: {
336: switch (of.err) {
337:
338: case 0:
339: return NGX_ERROR;
340:
341: case NGX_ENOENT:
342: case NGX_ENOTDIR:
343: goto done;
344:
345: default:
346: ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
347: ngx_open_file_n " \"%s\" failed", c->file.name.data);
348: return NGX_ERROR;
349: }
350: }
351:
352: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
353: "http file cache fd: %d", of.fd);
354:
355: c->file.fd = of.fd;
356: c->file.log = r->connection->log;
357: c->uniq = of.uniq;
358: c->length = of.size;
359: c->fs_size = (of.fs_size + cache->bsize - 1) / cache->bsize;
360:
361: c->buf = ngx_create_temp_buf(r->pool, c->body_start);
362: if (c->buf == NULL) {
363: return NGX_ERROR;
364: }
365:
366: return ngx_http_file_cache_read(r, c);
367:
368: done:
369:
370: if (rv == NGX_DECLINED) {
371: return ngx_http_file_cache_lock(r, c);
372: }
373:
374: return rv;
375: }
376:
377:
378: static ngx_int_t
379: ngx_http_file_cache_lock(ngx_http_request_t *r, ngx_http_cache_t *c)
380: {
381: ngx_msec_t now, timer;
382: ngx_http_file_cache_t *cache;
383:
384: if (!c->lock) {
385: return NGX_DECLINED;
386: }
387:
388: cache = c->file_cache;
389:
390: ngx_shmtx_lock(&cache->shpool->mutex);
391:
392: if (!c->node->updating) {
393: c->node->updating = 1;
394: c->updating = 1;
395: }
396:
397: ngx_shmtx_unlock(&cache->shpool->mutex);
398:
399: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
400: "http file cache lock u:%d wt:%M",
401: c->updating, c->wait_time);
402:
403: if (c->updating) {
404: return NGX_DECLINED;
405: }
406:
407: c->waiting = 1;
408:
409: now = ngx_current_msec;
410:
411: if (c->wait_time == 0) {
412: c->wait_time = now + c->lock_timeout;
413:
414: c->wait_event.handler = ngx_http_file_cache_lock_wait_handler;
415: c->wait_event.data = r;
416: c->wait_event.log = r->connection->log;
417: }
418:
419: timer = c->wait_time - now;
420:
421: ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);
422:
423: r->main->blocked++;
424:
425: return NGX_AGAIN;
426: }
427:
428:
429: static void
430: ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev)
431: {
432: ngx_uint_t wait;
433: ngx_msec_t timer;
434: ngx_http_cache_t *c;
435: ngx_http_request_t *r;
436: ngx_http_file_cache_t *cache;
437:
438: r = ev->data;
439: c = r->cache;
440:
441: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, ev->log, 0,
442: "http file cache wait handler wt:%M cur:%M",
443: c->wait_time, ngx_current_msec);
444:
445: timer = c->wait_time - ngx_current_msec;
446:
447: if ((ngx_msec_int_t) timer <= 0) {
448: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
449: "http file cache lock timeout");
450: c->lock = 0;
451: goto wakeup;
452: }
453:
454: cache = c->file_cache;
455: wait = 0;
456:
457: ngx_shmtx_lock(&cache->shpool->mutex);
458:
459: if (c->node->updating) {
460: wait = 1;
461: }
462:
463: ngx_shmtx_unlock(&cache->shpool->mutex);
464:
465: if (wait) {
466: ngx_add_timer(ev, (timer > 500) ? 500 : timer);
467: return;
468: }
469:
470: wakeup:
471:
472: c->waiting = 0;
473: r->main->blocked--;
474: r->connection->write->handler(r->connection->write);
475: }
476:
477:
478: static ngx_int_t
479: ngx_http_file_cache_read(ngx_http_request_t *r, ngx_http_cache_t *c)
480: {
481: time_t now;
482: ssize_t n;
483: ngx_int_t rc;
484: ngx_http_file_cache_t *cache;
485: ngx_http_file_cache_header_t *h;
486:
487: n = ngx_http_file_cache_aio_read(r, c);
488:
489: if (n < 0) {
490: return n;
491: }
492:
493: if ((size_t) n < c->header_start) {
494: ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
495: "cache file \"%s\" is too small", c->file.name.data);
496: return NGX_DECLINED;
497: }
498:
499: h = (ngx_http_file_cache_header_t *) c->buf->pos;
500:
501: if (h->crc32 != c->crc32) {
502: ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
503: "cache file \"%s\" has md5 collision", c->file.name.data);
504: return NGX_DECLINED;
505: }
506:
507: if (h->body_start > c->body_start) {
508: ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
509: "cache file \"%s\" has too long header",
510: c->file.name.data);
511: return NGX_DECLINED;
512: }
513:
514: c->buf->last += n;
515:
516: c->valid_sec = h->valid_sec;
517: c->last_modified = h->last_modified;
518: c->date = h->date;
519: c->valid_msec = h->valid_msec;
520: c->header_start = h->header_start;
521: c->body_start = h->body_start;
522:
523: r->cached = 1;
524:
525: cache = c->file_cache;
526:
527: if (cache->sh->cold) {
528:
529: ngx_shmtx_lock(&cache->shpool->mutex);
530:
531: if (!c->node->exists) {
532: c->node->uses = 1;
533: c->node->body_start = c->body_start;
534: c->node->exists = 1;
535: c->node->uniq = c->uniq;
536: c->node->fs_size = c->fs_size;
537:
538: cache->sh->size += c->fs_size;
539: }
540:
541: ngx_shmtx_unlock(&cache->shpool->mutex);
542: }
543:
544: now = ngx_time();
545:
546: if (c->valid_sec < now) {
547:
548: ngx_shmtx_lock(&cache->shpool->mutex);
549:
550: if (c->node->updating) {
551: rc = NGX_HTTP_CACHE_UPDATING;
552:
553: } else {
554: c->node->updating = 1;
555: c->updating = 1;
556: rc = NGX_HTTP_CACHE_STALE;
557: }
558:
559: ngx_shmtx_unlock(&cache->shpool->mutex);
560:
561: ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
562: "http file cache expired: %i %T %T",
563: rc, c->valid_sec, now);
564:
565: return rc;
566: }
567:
568: return NGX_OK;
569: }
570:
571:
572: static ssize_t
573: ngx_http_file_cache_aio_read(ngx_http_request_t *r, ngx_http_cache_t *c)
574: {
575: #if (NGX_HAVE_FILE_AIO)
576: ssize_t n;
577: ngx_http_core_loc_conf_t *clcf;
578:
579: if (!ngx_file_aio) {
580: goto noaio;
581: }
582:
583: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
584:
585: if (!clcf->aio) {
586: goto noaio;
587: }
588:
589: n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);
590:
591: if (n != NGX_AGAIN) {
592: return n;
593: }
594:
595: c->file.aio->data = r;
596: c->file.aio->handler = ngx_http_cache_aio_event_handler;
597:
598: r->main->blocked++;
599: r->aio = 1;
600:
601: return NGX_AGAIN;
602:
603: noaio:
604:
605: #endif
606:
607: return ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
608: }
609:
610:
611: #if (NGX_HAVE_FILE_AIO)
612:
613: static void
614: ngx_http_cache_aio_event_handler(ngx_event_t *ev)
615: {
616: ngx_event_aio_t *aio;
617: ngx_http_request_t *r;
618:
619: aio = ev->data;
620: r = aio->data;
621:
622: r->main->blocked--;
623: r->aio = 0;
624:
625: r->connection->write->handler(r->connection->write);
626: }
627:
628: #endif
629:
630:
631: static ngx_int_t
632: ngx_http_file_cache_exists(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
633: {
634: ngx_int_t rc;
635: ngx_http_file_cache_node_t *fcn;
636:
637: ngx_shmtx_lock(&cache->shpool->mutex);
638:
639: fcn = c->node;
640:
641: if (fcn == NULL) {
642: fcn = ngx_http_file_cache_lookup(cache, c->key);
643: }
644:
645: if (fcn) {
646: ngx_queue_remove(&fcn->queue);
647:
648: if (c->node == NULL) {
649: fcn->uses++;
650: fcn->count++;
651: }
652:
653: if (fcn->error) {
654:
655: if (fcn->valid_sec < ngx_time()) {
656: goto renew;
657: }
658:
659: rc = NGX_OK;
660:
661: goto done;
662: }
663:
664: if (fcn->exists || fcn->uses >= c->min_uses) {
665:
666: c->exists = fcn->exists;
667: if (fcn->body_start) {
668: c->body_start = fcn->body_start;
669: }
670:
671: rc = NGX_OK;
672:
673: goto done;
674: }
675:
676: rc = NGX_AGAIN;
677:
678: goto done;
679: }
680:
681: fcn = ngx_slab_alloc_locked(cache->shpool,
682: sizeof(ngx_http_file_cache_node_t));
683: if (fcn == NULL) {
684: ngx_shmtx_unlock(&cache->shpool->mutex);
685:
686: (void) ngx_http_file_cache_forced_expire(cache);
687:
688: ngx_shmtx_lock(&cache->shpool->mutex);
689:
690: fcn = ngx_slab_alloc_locked(cache->shpool,
691: sizeof(ngx_http_file_cache_node_t));
692: if (fcn == NULL) {
693: rc = NGX_ERROR;
694: goto failed;
695: }
696: }
697:
698: ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));
699:
700: ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
701: NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
702:
703: ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);
704:
705: fcn->uses = 1;
706: fcn->count = 1;
707: fcn->updating = 0;
708: fcn->deleting = 0;
709:
710: renew:
711:
712: rc = NGX_DECLINED;
713:
714: fcn->valid_msec = 0;
715: fcn->error = 0;
716: fcn->exists = 0;
717: fcn->valid_sec = 0;
718: fcn->uniq = 0;
719: fcn->body_start = 0;
720: fcn->fs_size = 0;
721:
722: done:
723:
724: fcn->expire = ngx_time() + cache->inactive;
725:
726: ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);
727:
728: c->uniq = fcn->uniq;
729: c->error = fcn->error;
730: c->node = fcn;
731:
732: failed:
733:
734: ngx_shmtx_unlock(&cache->shpool->mutex);
735:
736: return rc;
737: }
738:
739:
740: static ngx_int_t
741: ngx_http_file_cache_name(ngx_http_request_t *r, ngx_path_t *path)
742: {
743: u_char *p;
744: ngx_http_cache_t *c;
745:
746: c = r->cache;
747:
748: if (c->file.name.len) {
749: return NGX_OK;
750: }
751:
752: c->file.name.len = path->name.len + 1 + path->len
753: + 2 * NGX_HTTP_CACHE_KEY_LEN;
754:
755: c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
756: if (c->file.name.data == NULL) {
757: return NGX_ERROR;
758: }
759:
760: ngx_memcpy(c->file.name.data, path->name.data, path->name.len);
761:
762: p = c->file.name.data + path->name.len + 1 + path->len;
763: p = ngx_hex_dump(p, c->key, NGX_HTTP_CACHE_KEY_LEN);
764: *p = '\0';
765:
766: ngx_create_hashed_filename(path, c->file.name.data, c->file.name.len);
767:
768: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
769: "cache file: \"%s\"", c->file.name.data);
770:
771: return NGX_OK;
772: }
773:
774:
775: static ngx_http_file_cache_node_t *
776: ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
777: {
778: ngx_int_t rc;
779: ngx_rbtree_key_t node_key;
780: ngx_rbtree_node_t *node, *sentinel;
781: ngx_http_file_cache_node_t *fcn;
782:
783: ngx_memcpy((u_char *) &node_key, key, sizeof(ngx_rbtree_key_t));
784:
785: node = cache->sh->rbtree.root;
786: sentinel = cache->sh->rbtree.sentinel;
787:
788: while (node != sentinel) {
789:
790: if (node_key < node->key) {
791: node = node->left;
792: continue;
793: }
794:
795: if (node_key > node->key) {
796: node = node->right;
797: continue;
798: }
799:
800: /* node_key == node->key */
801:
802: fcn = (ngx_http_file_cache_node_t *) node;
803:
804: rc = ngx_memcmp(&key[sizeof(ngx_rbtree_key_t)], fcn->key,
805: NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
806:
807: if (rc == 0) {
808: return fcn;
809: }
810:
811: node = (rc < 0) ? node->left : node->right;
812: }
813:
814: /* not found */
815:
816: return NULL;
817: }
818:
819:
820: static void
821: ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
822: ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
823: {
824: ngx_rbtree_node_t **p;
825: ngx_http_file_cache_node_t *cn, *cnt;
826:
827: for ( ;; ) {
828:
829: if (node->key < temp->key) {
830:
831: p = &temp->left;
832:
833: } else if (node->key > temp->key) {
834:
835: p = &temp->right;
836:
837: } else { /* node->key == temp->key */
838:
839: cn = (ngx_http_file_cache_node_t *) node;
840: cnt = (ngx_http_file_cache_node_t *) temp;
841:
842: p = (ngx_memcmp(cn->key, cnt->key,
843: NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t))
844: < 0)
845: ? &temp->left : &temp->right;
846: }
847:
848: if (*p == sentinel) {
849: break;
850: }
851:
852: temp = *p;
853: }
854:
855: *p = node;
856: node->parent = temp;
857: node->left = sentinel;
858: node->right = sentinel;
859: ngx_rbt_red(node);
860: }
861:
862:
863: void
864: ngx_http_file_cache_set_header(ngx_http_request_t *r, u_char *buf)
865: {
866: ngx_http_file_cache_header_t *h = (ngx_http_file_cache_header_t *) buf;
867:
868: u_char *p;
869: ngx_str_t *key;
870: ngx_uint_t i;
871: ngx_http_cache_t *c;
872:
873: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
874: "http file cache set header");
875:
876: c = r->cache;
877:
878: h->valid_sec = c->valid_sec;
879: h->last_modified = c->last_modified;
880: h->date = c->date;
881: h->crc32 = c->crc32;
882: h->valid_msec = (u_short) c->valid_msec;
883: h->header_start = (u_short) c->header_start;
884: h->body_start = (u_short) c->body_start;
885:
886: p = buf + sizeof(ngx_http_file_cache_header_t);
887:
888: p = ngx_cpymem(p, ngx_http_file_cache_key, sizeof(ngx_http_file_cache_key));
889:
890: key = c->keys.elts;
891: for (i = 0; i < c->keys.nelts; i++) {
892: p = ngx_copy(p, key[i].data, key[i].len);
893: }
894:
895: *p = LF;
896: }
897:
898:
899: void
900: ngx_http_file_cache_update(ngx_http_request_t *r, ngx_temp_file_t *tf)
901: {
902: off_t fs_size;
903: ngx_int_t rc;
904: ngx_file_uniq_t uniq;
905: ngx_file_info_t fi;
906: ngx_http_cache_t *c;
907: ngx_ext_rename_file_t ext;
908: ngx_http_file_cache_t *cache;
909:
910: c = r->cache;
911:
912: if (c->updated) {
913: return;
914: }
915:
916: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
917: "http file cache update");
918:
919: c->updated = 1;
920: c->updating = 0;
921:
922: cache = c->file_cache;
923:
924: uniq = 0;
925: fs_size = 0;
926:
927: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
928: "http file cache rename: \"%s\" to \"%s\"",
929: tf->file.name.data, c->file.name.data);
930:
931: ext.access = NGX_FILE_OWNER_ACCESS;
932: ext.path_access = NGX_FILE_OWNER_ACCESS;
933: ext.time = -1;
934: ext.create_path = 1;
935: ext.delete_file = 1;
936: ext.log = r->connection->log;
937:
938: rc = ngx_ext_rename_file(&tf->file.name, &c->file.name, &ext);
939:
940: if (rc == NGX_OK) {
941:
942: if (ngx_fd_info(tf->file.fd, &fi) == NGX_FILE_ERROR) {
943: ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
944: ngx_fd_info_n " \"%s\" failed", tf->file.name.data);
945:
946: rc = NGX_ERROR;
947:
948: } else {
949: uniq = ngx_file_uniq(&fi);
950: fs_size = (ngx_file_fs_size(&fi) + cache->bsize - 1) / cache->bsize;
951: }
952: }
953:
954: ngx_shmtx_lock(&cache->shpool->mutex);
955:
956: c->node->count--;
957: c->node->uniq = uniq;
958: c->node->body_start = c->body_start;
959:
960: cache->sh->size += fs_size - c->node->fs_size;
961: c->node->fs_size = fs_size;
962:
963: if (rc == NGX_OK) {
964: c->node->exists = 1;
965: }
966:
967: c->node->updating = 0;
968:
969: ngx_shmtx_unlock(&cache->shpool->mutex);
970: }
971:
972:
973: ngx_int_t
974: ngx_http_cache_send(ngx_http_request_t *r)
975: {
976: ngx_int_t rc;
977: ngx_buf_t *b;
978: ngx_chain_t out;
979: ngx_http_cache_t *c;
980:
981: c = r->cache;
982:
983: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
984: "http file cache send: %s", c->file.name.data);
985:
986: if (r != r->main && c->length - c->body_start == 0) {
987: return ngx_http_send_header(r);
988: }
989:
990: /* we need to allocate all before the header would be sent */
991:
992: b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
993: if (b == NULL) {
994: return NGX_HTTP_INTERNAL_SERVER_ERROR;
995: }
996:
997: b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
998: if (b->file == NULL) {
999: return NGX_HTTP_INTERNAL_SERVER_ERROR;
1000: }
1001:
1002: rc = ngx_http_send_header(r);
1003:
1004: if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
1005: return rc;
1006: }
1007:
1008: b->file_pos = c->body_start;
1009: b->file_last = c->length;
1010:
1011: b->in_file = (c->length - c->body_start) ? 1: 0;
1012: b->last_buf = (r == r->main) ? 1: 0;
1013: b->last_in_chain = 1;
1014:
1015: b->file->fd = c->file.fd;
1016: b->file->name = c->file.name;
1017: b->file->log = r->connection->log;
1018:
1019: out.buf = b;
1020: out.next = NULL;
1021:
1022: return ngx_http_output_filter(r, &out);
1023: }
1024:
1025:
1026: void
1027: ngx_http_file_cache_free(ngx_http_cache_t *c, ngx_temp_file_t *tf)
1028: {
1029: ngx_http_file_cache_t *cache;
1030: ngx_http_file_cache_node_t *fcn;
1031:
1032: if (c->updated || c->node == NULL) {
1033: return;
1034: }
1035:
1036: cache = c->file_cache;
1037:
1038: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
1039: "http file cache free, fd: %d", c->file.fd);
1040:
1041: ngx_shmtx_lock(&cache->shpool->mutex);
1042:
1043: fcn = c->node;
1044: fcn->count--;
1045:
1046: if (c->updating) {
1047: fcn->updating = 0;
1048: }
1049:
1050: if (c->error) {
1051: fcn->error = c->error;
1052:
1053: if (c->valid_sec) {
1054: fcn->valid_sec = c->valid_sec;
1055: fcn->valid_msec = c->valid_msec;
1056: }
1057:
1058: } else if (!fcn->exists && fcn->count == 0 && c->min_uses == 1) {
1059: ngx_queue_remove(&fcn->queue);
1060: ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
1061: ngx_slab_free_locked(cache->shpool, fcn);
1062: c->node = NULL;
1063: }
1064:
1065: ngx_shmtx_unlock(&cache->shpool->mutex);
1066:
1067: c->updated = 1;
1068: c->updating = 0;
1069:
1070: if (c->temp_file) {
1071: if (tf && tf->file.fd != NGX_INVALID_FILE) {
1072: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
1073: "http file cache incomplete: \"%s\"",
1074: tf->file.name.data);
1075:
1076: if (ngx_delete_file(tf->file.name.data) == NGX_FILE_ERROR) {
1077: ngx_log_error(NGX_LOG_CRIT, c->file.log, ngx_errno,
1078: ngx_delete_file_n " \"%s\" failed",
1079: tf->file.name.data);
1080: }
1081: }
1082: }
1083:
1084: if (c->wait_event.timer_set) {
1085: ngx_del_timer(&c->wait_event);
1086: }
1087: }
1088:
1089:
1090: static void
1091: ngx_http_file_cache_cleanup(void *data)
1092: {
1093: ngx_http_cache_t *c = data;
1094:
1095: if (c->updated) {
1096: return;
1097: }
1098:
1099: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
1100: "http file cache cleanup");
1101:
1102: if (c->updating) {
1103: ngx_log_error(NGX_LOG_ALERT, c->file.log, 0,
1104: "stalled cache updating, error:%ui", c->error);
1105: }
1106:
1107: ngx_http_file_cache_free(c, NULL);
1108: }
1109:
1110:
1111: static time_t
1112: ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache)
1113: {
1114: u_char *name;
1115: size_t len;
1116: time_t wait;
1117: ngx_uint_t tries;
1118: ngx_path_t *path;
1119: ngx_queue_t *q;
1120: ngx_http_file_cache_node_t *fcn;
1121:
1122: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1123: "http file cache forced expire");
1124:
1125: path = cache->path;
1126: len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
1127:
1128: name = ngx_alloc(len + 1, ngx_cycle->log);
1129: if (name == NULL) {
1130: return 10;
1131: }
1132:
1133: ngx_memcpy(name, path->name.data, path->name.len);
1134:
1135: wait = 10;
1136: tries = 20;
1137:
1138: ngx_shmtx_lock(&cache->shpool->mutex);
1139:
1140: for (q = ngx_queue_last(&cache->sh->queue);
1141: q != ngx_queue_sentinel(&cache->sh->queue);
1142: q = ngx_queue_prev(q))
1143: {
1144: fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);
1145:
1146: ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1147: "http file cache forced expire: #%d %d %02xd%02xd%02xd%02xd",
1148: fcn->count, fcn->exists,
1149: fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);
1150:
1151: if (fcn->count == 0) {
1152: ngx_http_file_cache_delete(cache, q, name);
1153: wait = 0;
1154:
1155: } else {
1156: if (--tries) {
1157: continue;
1158: }
1159:
1160: wait = 1;
1161: }
1162:
1163: break;
1164: }
1165:
1166: ngx_shmtx_unlock(&cache->shpool->mutex);
1167:
1168: ngx_free(name);
1169:
1170: return wait;
1171: }
1172:
1173:
1174: static time_t
1175: ngx_http_file_cache_expire(ngx_http_file_cache_t *cache)
1176: {
1177: u_char *name, *p;
1178: size_t len;
1179: time_t now, wait;
1180: ngx_path_t *path;
1181: ngx_queue_t *q;
1182: ngx_http_file_cache_node_t *fcn;
1183: u_char key[2 * NGX_HTTP_CACHE_KEY_LEN];
1184:
1185: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1186: "http file cache expire");
1187:
1188: path = cache->path;
1189: len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
1190:
1191: name = ngx_alloc(len + 1, ngx_cycle->log);
1192: if (name == NULL) {
1193: return 10;
1194: }
1195:
1196: ngx_memcpy(name, path->name.data, path->name.len);
1197:
1198: now = ngx_time();
1199:
1200: ngx_shmtx_lock(&cache->shpool->mutex);
1201:
1202: for ( ;; ) {
1203:
1204: if (ngx_queue_empty(&cache->sh->queue)) {
1205: wait = 10;
1206: break;
1207: }
1208:
1209: q = ngx_queue_last(&cache->sh->queue);
1210:
1211: fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);
1212:
1213: wait = fcn->expire - now;
1214:
1215: if (wait > 0) {
1216: wait = wait > 10 ? 10 : wait;
1217: break;
1218: }
1219:
1220: ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1221: "http file cache expire: #%d %d %02xd%02xd%02xd%02xd",
1222: fcn->count, fcn->exists,
1223: fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);
1224:
1225: if (fcn->count == 0) {
1226: ngx_http_file_cache_delete(cache, q, name);
1227: continue;
1228: }
1229:
1230: if (fcn->deleting) {
1231: wait = 1;
1232: break;
1233: }
1234:
1235: p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
1236: sizeof(ngx_rbtree_key_t));
1237: len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
1238: (void) ngx_hex_dump(p, fcn->key, len);
1239:
1240: /*
1241: * abnormally exited workers may leave locked cache entries,
1242: * and although it may be safe to remove them completely,
1243: * we prefer to just move them to the top of the inactive queue
1244: */
1245:
1246: ngx_queue_remove(q);
1247: fcn->expire = ngx_time() + cache->inactive;
1248: ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);
1249:
1250: ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
1251: "ignore long locked inactive cache entry %*s, count:%d",
1252: 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);
1253: }
1254:
1255: ngx_shmtx_unlock(&cache->shpool->mutex);
1256:
1257: ngx_free(name);
1258:
1259: return wait;
1260: }
1261:
1262:
1263: static void
1264: ngx_http_file_cache_delete(ngx_http_file_cache_t *cache, ngx_queue_t *q,
1265: u_char *name)
1266: {
1267: u_char *p;
1268: size_t len;
1269: ngx_path_t *path;
1270: ngx_http_file_cache_node_t *fcn;
1271:
1272: fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);
1273:
1274: if (fcn->exists) {
1275: cache->sh->size -= fcn->fs_size;
1276:
1277: path = cache->path;
1278: p = name + path->name.len + 1 + path->len;
1279: p = ngx_hex_dump(p, (u_char *) &fcn->node.key,
1280: sizeof(ngx_rbtree_key_t));
1281: len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
1282: p = ngx_hex_dump(p, fcn->key, len);
1283: *p = '\0';
1284:
1285: fcn->count++;
1286: fcn->deleting = 1;
1287: ngx_shmtx_unlock(&cache->shpool->mutex);
1288:
1289: len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
1290: ngx_create_hashed_filename(path, name, len);
1291:
1292: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1293: "http file cache expire: \"%s\"", name);
1294:
1295: if (ngx_delete_file(name) == NGX_FILE_ERROR) {
1296: ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
1297: ngx_delete_file_n " \"%s\" failed", name);
1298: }
1299:
1300: ngx_shmtx_lock(&cache->shpool->mutex);
1301: fcn->count--;
1302: fcn->deleting = 0;
1303: }
1304:
1305: if (fcn->count == 0) {
1306: ngx_queue_remove(q);
1307: ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
1308: ngx_slab_free_locked(cache->shpool, fcn);
1309: }
1310: }
1311:
1312:
1313: static time_t
1314: ngx_http_file_cache_manager(void *data)
1315: {
1316: ngx_http_file_cache_t *cache = data;
1317:
1318: off_t size;
1319: time_t next, wait;
1320:
1321: next = ngx_http_file_cache_expire(cache);
1322:
1323: cache->last = ngx_current_msec;
1324: cache->files = 0;
1325:
1326: for ( ;; ) {
1327: ngx_shmtx_lock(&cache->shpool->mutex);
1328:
1329: size = cache->sh->size;
1330:
1331: ngx_shmtx_unlock(&cache->shpool->mutex);
1332:
1333: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1334: "http file cache size: %O", size);
1335:
1336: if (size < cache->max_size) {
1337: return next;
1338: }
1339:
1340: wait = ngx_http_file_cache_forced_expire(cache);
1341:
1342: if (wait > 0) {
1343: return wait;
1344: }
1345:
1346: if (ngx_quit || ngx_terminate) {
1347: return next;
1348: }
1349: }
1350: }
1351:
1352:
1353: static void
1354: ngx_http_file_cache_loader(void *data)
1355: {
1356: ngx_http_file_cache_t *cache = data;
1357:
1358: ngx_tree_ctx_t tree;
1359:
1360: if (!cache->sh->cold || cache->sh->loading) {
1361: return;
1362: }
1363:
1364: if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
1365: return;
1366: }
1367:
1368: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1369: "http file cache loader");
1370:
1371: tree.init_handler = NULL;
1372: tree.file_handler = ngx_http_file_cache_manage_file;
1373: tree.pre_tree_handler = ngx_http_file_cache_noop;
1374: tree.post_tree_handler = ngx_http_file_cache_noop;
1375: tree.spec_handler = ngx_http_file_cache_delete_file;
1376: tree.data = cache;
1377: tree.alloc = 0;
1378: tree.log = ngx_cycle->log;
1379:
1380: cache->last = ngx_current_msec;
1381: cache->files = 0;
1382:
1383: if (ngx_walk_tree(&tree, &cache->path->name) == NGX_ABORT) {
1384: cache->sh->loading = 0;
1385: return;
1386: }
1387:
1388: cache->sh->cold = 0;
1389: cache->sh->loading = 0;
1390:
1391: ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
1392: "http file cache: %V %.3fM, bsize: %uz",
1393: &cache->path->name,
1394: ((double) cache->sh->size * cache->bsize) / (1024 * 1024),
1395: cache->bsize);
1396: }
1397:
1398:
1399: static ngx_int_t
1400: ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path)
1401: {
1402: return NGX_OK;
1403: }
1404:
1405:
1406: static ngx_int_t
1407: ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
1408: {
1409: ngx_msec_t elapsed;
1410: ngx_http_file_cache_t *cache;
1411:
1412: cache = ctx->data;
1413:
1414: if (ngx_http_file_cache_add_file(ctx, path) != NGX_OK) {
1415: (void) ngx_http_file_cache_delete_file(ctx, path);
1416: }
1417:
1418: if (++cache->files >= cache->loader_files) {
1419: ngx_http_file_cache_loader_sleep(cache);
1420:
1421: } else {
1422: ngx_time_update();
1423:
1424: elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));
1425:
1426: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
1427: "http file cache loader time elapsed: %M", elapsed);
1428:
1429: if (elapsed >= cache->loader_threshold) {
1430: ngx_http_file_cache_loader_sleep(cache);
1431: }
1432: }
1433:
1434: return (ngx_quit || ngx_terminate) ? NGX_ABORT : NGX_OK;
1435: }
1436:
1437:
1438: static void
1439: ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache)
1440: {
1441: ngx_msleep(cache->loader_sleep);
1442:
1443: ngx_time_update();
1444:
1445: cache->last = ngx_current_msec;
1446: cache->files = 0;
1447: }
1448:
1449:
1450: static ngx_int_t
1451: ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx, ngx_str_t *name)
1452: {
1453: u_char *p;
1454: ngx_int_t n;
1455: ngx_uint_t i;
1456: ngx_http_cache_t c;
1457: ngx_http_file_cache_t *cache;
1458:
1459: if (name->len < 2 * NGX_HTTP_CACHE_KEY_LEN) {
1460: return NGX_ERROR;
1461: }
1462:
1463: if (ctx->size < (off_t) sizeof(ngx_http_file_cache_header_t)) {
1464: ngx_log_error(NGX_LOG_CRIT, ctx->log, 0,
1465: "cache file \"%s\" is too small", name->data);
1466: return NGX_ERROR;
1467: }
1468:
1469: ngx_memzero(&c, sizeof(ngx_http_cache_t));
1470: cache = ctx->data;
1471:
1472: c.length = ctx->size;
1473: c.fs_size = (ctx->fs_size + cache->bsize - 1) / cache->bsize;
1474:
1475: p = &name->data[name->len - 2 * NGX_HTTP_CACHE_KEY_LEN];
1476:
1477: for (i = 0; i < NGX_HTTP_CACHE_KEY_LEN; i++) {
1478: n = ngx_hextoi(p, 2);
1479:
1480: if (n == NGX_ERROR) {
1481: return NGX_ERROR;
1482: }
1483:
1484: p += 2;
1485:
1486: c.key[i] = (u_char) n;
1487: }
1488:
1489: return ngx_http_file_cache_add(cache, &c);
1490: }
1491:
1492:
1493: static ngx_int_t
1494: ngx_http_file_cache_add(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
1495: {
1496: ngx_http_file_cache_node_t *fcn;
1497:
1498: ngx_shmtx_lock(&cache->shpool->mutex);
1499:
1500: fcn = ngx_http_file_cache_lookup(cache, c->key);
1501:
1502: if (fcn == NULL) {
1503:
1504: fcn = ngx_slab_alloc_locked(cache->shpool,
1505: sizeof(ngx_http_file_cache_node_t));
1506: if (fcn == NULL) {
1507: ngx_shmtx_unlock(&cache->shpool->mutex);
1508: return NGX_ERROR;
1509: }
1510:
1511: ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));
1512:
1513: ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
1514: NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));
1515:
1516: ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);
1517:
1518: fcn->uses = 1;
1519: fcn->count = 0;
1520: fcn->valid_msec = 0;
1521: fcn->error = 0;
1522: fcn->exists = 1;
1523: fcn->updating = 0;
1524: fcn->deleting = 0;
1525: fcn->uniq = 0;
1526: fcn->valid_sec = 0;
1527: fcn->body_start = 0;
1528: fcn->fs_size = c->fs_size;
1529:
1530: cache->sh->size += c->fs_size;
1531:
1532: } else {
1533: ngx_queue_remove(&fcn->queue);
1534: }
1535:
1536: fcn->expire = ngx_time() + cache->inactive;
1537:
1538: ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);
1539:
1540: ngx_shmtx_unlock(&cache->shpool->mutex);
1541:
1542: return NGX_OK;
1543: }
1544:
1545:
1546: static ngx_int_t
1547: ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
1548: {
1549: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
1550: "http file cache delete: \"%s\"", path->data);
1551:
1552: if (ngx_delete_file(path->data) == NGX_FILE_ERROR) {
1553: ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
1554: ngx_delete_file_n " \"%s\" failed", path->data);
1555: }
1556:
1557: return NGX_OK;
1558: }
1559:
1560:
1561: time_t
1562: ngx_http_file_cache_valid(ngx_array_t *cache_valid, ngx_uint_t status)
1563: {
1564: ngx_uint_t i;
1565: ngx_http_cache_valid_t *valid;
1566:
1567: if (cache_valid == NULL) {
1568: return 0;
1569: }
1570:
1571: valid = cache_valid->elts;
1572: for (i = 0; i < cache_valid->nelts; i++) {
1573:
1574: if (valid[i].status == 0) {
1575: return valid[i].valid;
1576: }
1577:
1578: if (valid[i].status == status) {
1579: return valid[i].valid;
1580: }
1581: }
1582:
1583: return 0;
1584: }
1585:
1586:
1587: char *
1588: ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1589: {
1590: off_t max_size;
1591: u_char *last, *p;
1592: time_t inactive;
1593: ssize_t size;
1594: ngx_str_t s, name, *value;
1595: ngx_int_t loader_files;
1596: ngx_msec_t loader_sleep, loader_threshold;
1597: ngx_uint_t i, n;
1598: ngx_http_file_cache_t *cache;
1599:
1600: cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
1601: if (cache == NULL) {
1602: return NGX_CONF_ERROR;
1603: }
1604:
1605: cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
1606: if (cache->path == NULL) {
1607: return NGX_CONF_ERROR;
1608: }
1609:
1610: inactive = 600;
1611: loader_files = 100;
1612: loader_sleep = 50;
1613: loader_threshold = 200;
1614:
1615: name.len = 0;
1616: size = 0;
1617: max_size = NGX_MAX_OFF_T_VALUE;
1618:
1619: value = cf->args->elts;
1620:
1621: cache->path->name = value[1];
1622:
1623: if (cache->path->name.data[cache->path->name.len - 1] == '/') {
1624: cache->path->name.len--;
1625: }
1626:
1627: if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != NGX_OK) {
1628: return NGX_CONF_ERROR;
1629: }
1630:
1631: for (i = 2; i < cf->args->nelts; i++) {
1632:
1633: if (ngx_strncmp(value[i].data, "levels=", 7) == 0) {
1634:
1635: p = value[i].data + 7;
1636: last = value[i].data + value[i].len;
1637:
1638: for (n = 0; n < 3 && p < last; n++) {
1639:
1640: if (*p > '0' && *p < '3') {
1641:
1642: cache->path->level[n] = *p++ - '0';
1643: cache->path->len += cache->path->level[n] + 1;
1644:
1645: if (p == last) {
1646: break;
1647: }
1648:
1649: if (*p++ == ':' && n < 2 && p != last) {
1650: continue;
1651: }
1652:
1653: goto invalid_levels;
1654: }
1655:
1656: goto invalid_levels;
1657: }
1658:
1659: if (cache->path->len < 10 + 3) {
1660: continue;
1661: }
1662:
1663: invalid_levels:
1664:
1665: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1666: "invalid \"levels\" \"%V\"", &value[i]);
1667: return NGX_CONF_ERROR;
1668: }
1669:
1670: if (ngx_strncmp(value[i].data, "keys_zone=", 10) == 0) {
1671:
1672: name.data = value[i].data + 10;
1673:
1674: p = (u_char *) ngx_strchr(name.data, ':');
1675:
1676: if (p) {
1677: name.len = p - name.data;
1678:
1679: p++;
1680:
1681: s.len = value[i].data + value[i].len - p;
1682: s.data = p;
1683:
1684: size = ngx_parse_size(&s);
1685: if (size > 8191) {
1686: continue;
1687: }
1688: }
1689:
1690: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1691: "invalid keys zone size \"%V\"", &value[i]);
1692: return NGX_CONF_ERROR;
1693: }
1694:
1695: if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {
1696:
1697: s.len = value[i].len - 9;
1698: s.data = value[i].data + 9;
1699:
1700: inactive = ngx_parse_time(&s, 1);
1701: if (inactive == (time_t) NGX_ERROR) {
1702: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1703: "invalid inactive value \"%V\"", &value[i]);
1704: return NGX_CONF_ERROR;
1705: }
1706:
1707: continue;
1708: }
1709:
1710: if (ngx_strncmp(value[i].data, "max_size=", 9) == 0) {
1711:
1712: s.len = value[i].len - 9;
1713: s.data = value[i].data + 9;
1714:
1715: max_size = ngx_parse_offset(&s);
1716: if (max_size < 0) {
1717: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1718: "invalid max_size value \"%V\"", &value[i]);
1719: return NGX_CONF_ERROR;
1720: }
1721:
1722: continue;
1723: }
1724:
1725: if (ngx_strncmp(value[i].data, "loader_files=", 13) == 0) {
1726:
1727: loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
1728: if (loader_files == NGX_ERROR) {
1729: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1730: "invalid loader_files value \"%V\"", &value[i]);
1731: return NGX_CONF_ERROR;
1732: }
1733:
1734: continue;
1735: }
1736:
1737: if (ngx_strncmp(value[i].data, "loader_sleep=", 13) == 0) {
1738:
1739: s.len = value[i].len - 13;
1740: s.data = value[i].data + 13;
1741:
1742: loader_sleep = ngx_parse_time(&s, 0);
1743: if (loader_sleep == (ngx_msec_t) NGX_ERROR) {
1744: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1745: "invalid loader_sleep value \"%V\"", &value[i]);
1746: return NGX_CONF_ERROR;
1747: }
1748:
1749: continue;
1750: }
1751:
1752: if (ngx_strncmp(value[i].data, "loader_threshold=", 17) == 0) {
1753:
1754: s.len = value[i].len - 17;
1755: s.data = value[i].data + 17;
1756:
1757: loader_threshold = ngx_parse_time(&s, 0);
1758: if (loader_threshold == (ngx_msec_t) NGX_ERROR) {
1759: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1760: "invalid loader_threshold value \"%V\"", &value[i]);
1761: return NGX_CONF_ERROR;
1762: }
1763:
1764: continue;
1765: }
1766:
1767: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1768: "invalid parameter \"%V\"", &value[i]);
1769: return NGX_CONF_ERROR;
1770: }
1771:
1772: if (name.len == 0 || size == 0) {
1773: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1774: "\"%V\" must have \"keys_zone\" parameter",
1775: &cmd->name);
1776: return NGX_CONF_ERROR;
1777: }
1778:
1779: cache->path->manager = ngx_http_file_cache_manager;
1780: cache->path->loader = ngx_http_file_cache_loader;
1781: cache->path->data = cache;
1782: cache->path->conf_file = cf->conf_file->file.name.data;
1783: cache->path->line = cf->conf_file->line;
1784: cache->loader_files = loader_files;
1785: cache->loader_sleep = loader_sleep;
1786: cache->loader_threshold = loader_threshold;
1787:
1788: if (ngx_add_path(cf, &cache->path) != NGX_OK) {
1789: return NGX_CONF_ERROR;
1790: }
1791:
1792: cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
1793: if (cache->shm_zone == NULL) {
1794: return NGX_CONF_ERROR;
1795: }
1796:
1797: if (cache->shm_zone->data) {
1798: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1799: "duplicate zone \"%V\"", &name);
1800: return NGX_CONF_ERROR;
1801: }
1802:
1803:
1804: cache->shm_zone->init = ngx_http_file_cache_init;
1805: cache->shm_zone->data = cache;
1806:
1807: cache->inactive = inactive;
1808: cache->max_size = max_size;
1809:
1810: return NGX_CONF_OK;
1811: }
1812:
1813:
1814: char *
1815: ngx_http_file_cache_valid_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
1816: void *conf)
1817: {
1818: char *p = conf;
1819:
1820: time_t valid;
1821: ngx_str_t *value;
1822: ngx_uint_t i, n, status;
1823: ngx_array_t **a;
1824: ngx_http_cache_valid_t *v;
1825: static ngx_uint_t statuses[] = { 200, 301, 302 };
1826:
1827: a = (ngx_array_t **) (p + cmd->offset);
1828:
1829: if (*a == NGX_CONF_UNSET_PTR) {
1830: *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_cache_valid_t));
1831: if (*a == NULL) {
1832: return NGX_CONF_ERROR;
1833: }
1834: }
1835:
1836: value = cf->args->elts;
1837: n = cf->args->nelts - 1;
1838:
1839: valid = ngx_parse_time(&value[n], 1);
1840: if (valid == (time_t) NGX_ERROR) {
1841: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1842: "invalid time value \"%V\"", &value[n]);
1843: return NGX_CONF_ERROR;
1844: }
1845:
1846: if (n == 1) {
1847:
1848: for (i = 0; i < 3; i++) {
1849: v = ngx_array_push(*a);
1850: if (v == NULL) {
1851: return NGX_CONF_ERROR;
1852: }
1853:
1854: v->status = statuses[i];
1855: v->valid = valid;
1856: }
1857:
1858: return NGX_CONF_OK;
1859: }
1860:
1861: for (i = 1; i < n; i++) {
1862:
1863: if (ngx_strcmp(value[i].data, "any") == 0) {
1864:
1865: status = 0;
1866:
1867: } else {
1868:
1869: status = ngx_atoi(value[i].data, value[i].len);
1870: if (status < 100) {
1871: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1872: "invalid status \"%V\"", &value[i]);
1873: return NGX_CONF_ERROR;
1874: }
1875: }
1876:
1877: v = ngx_array_push(*a);
1878: if (v == NULL) {
1879: return NGX_CONF_ERROR;
1880: }
1881:
1882: v->status = status;
1883: v->valid = valid;
1884: }
1885:
1886: return NGX_CONF_OK;
1887: }