Annotation of embedaddon/thttpd/mmc.c, revision 1.1.1.1
1.1 misho 1: /* mmc.c - mmap cache
2: **
3: ** Copyright © 1998,2001 by Jef Poskanzer <jef@mail.acme.com>.
4: ** All rights reserved.
5: **
6: ** Redistribution and use in source and binary forms, with or without
7: ** modification, are permitted provided that the following conditions
8: ** are met:
9: ** 1. Redistributions of source code must retain the above copyright
10: ** notice, this list of conditions and the following disclaimer.
11: ** 2. Redistributions in binary form must reproduce the above copyright
12: ** notice, this list of conditions and the following disclaimer in the
13: ** documentation and/or other materials provided with the distribution.
14: **
15: ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16: ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: ** SUCH DAMAGE.
26: */
27:
28: #include "config.h"
29:
30: #include <sys/types.h>
31: #include <sys/stat.h>
32: #include <sys/time.h>
33: #include <stdlib.h>
34: #include <unistd.h>
35: #include <stdio.h>
36: #include <time.h>
37: #include <fcntl.h>
38: #include <syslog.h>
39: #include <errno.h>
40:
41: #ifdef HAVE_MMAP
42: #include <sys/mman.h>
43: #endif /* HAVE_MMAP */
44:
45: #include "mmc.h"
46: #include "libhttpd.h"
47:
48: #ifndef HAVE_INT64T
49: typedef long long int64_t;
50: #endif
51:
52:
53: /* Defines. */
54: #ifndef DEFAULT_EXPIRE_AGE
55: #define DEFAULT_EXPIRE_AGE 600
56: #endif
57: #ifndef DESIRED_FREE_COUNT
58: #define DESIRED_FREE_COUNT 100
59: #endif
60: #ifndef DESIRED_MAX_MAPPED_FILES
61: #define DESIRED_MAX_MAPPED_FILES 2000
62: #endif
63: #ifndef DESIRED_MAX_MAPPED_BYTES
64: #define DESIRED_MAX_MAPPED_BYTES 1000000000
65: #endif
66: #ifndef INITIAL_HASH_SIZE
67: #define INITIAL_HASH_SIZE (1 << 10)
68: #endif
69:
70: #ifndef MAX
71: #define MAX(a,b) ((a)>(b)?(a):(b))
72: #endif
73: #ifndef MIN
74: #define MIN(a,b) ((a)<(b)?(a):(b))
75: #endif
76:
77:
78: /* The Map struct. */
79: typedef struct MapStruct {
80: ino_t ino;
81: dev_t dev;
82: off_t size;
83: time_t ctime;
84: int refcount;
85: time_t reftime;
86: #ifdef USE_SENDFILE
87: int fd;
88: #endif
89: void* addr;
90: unsigned int hash;
91: int hash_idx;
92: struct MapStruct* next;
93: } Map;
94:
95:
96: /* Globals. */
97: static Map* maps = (Map*) 0;
98: static Map* free_maps = (Map*) 0;
99: static int alloc_count = 0, map_count = 0, free_count = 0;
100: static Map** hash_table = (Map**) 0;
101: static int hash_size;
102: static unsigned int hash_mask;
103: static time_t expire_age = DEFAULT_EXPIRE_AGE;
104: static off_t mapped_bytes = 0;
105:
106:
107:
108: /* Forwards. */
109: static void panic( void );
110: static void really_unmap( Map** mm );
111: static int check_hash_size( void );
112: static int add_hash( Map* m );
113: static Map* find_hash( ino_t ino, dev_t dev, off_t size, time_t ctime );
114: static unsigned int hash( ino_t ino, dev_t dev, off_t size, time_t ctime );
115:
116:
117: void*
118: mmc_map( char* filename, struct stat* sbP, struct timeval* nowP )
119: {
120: time_t now;
121: struct stat sb;
122: Map* m;
123: int fd;
124:
125: /* Stat the file, if necessary. */
126: if ( sbP != (struct stat*) 0 )
127: sb = *sbP;
128: else
129: {
130: if ( stat( filename, &sb ) != 0 )
131: {
132: syslog( LOG_ERR, "stat - %m" );
133: return (void*) 0;
134: }
135: }
136:
137: /* Get the current time, if necessary. */
138: if ( nowP != (struct timeval*) 0 )
139: now = nowP->tv_sec;
140: else
141: now = time( (time_t*) 0 );
142:
143: /* See if we have it mapped already, via the hash table. */
144: if ( check_hash_size() < 0 )
145: {
146: syslog( LOG_ERR, "check_hash_size() failure" );
147: return (void*) 0;
148: }
149: m = find_hash( sb.st_ino, sb.st_dev, sb.st_size, sb.st_ctime );
150: if ( m != (Map*) 0 )
151: {
152: /* Yep. Just return the existing map */
153: ++m->refcount;
154: m->reftime = now;
155: #ifdef USE_SENDFILE
156: return (&m->fd);
157: #else
158: return m->addr;
159: #endif
160: }
161:
162: /* Open the file. */
163: fd = open( filename, O_RDONLY );
164: if ( fd < 0 )
165: {
166: syslog( LOG_ERR, "open - %m" );
167: return (void*) 0;
168: }
169:
170: /* Find a free Map entry or make a new one. */
171: if ( free_maps != (Map*) 0 )
172: {
173: m = free_maps;
174: free_maps = m->next;
175: --free_count;
176: }
177: else
178: {
179: m = (Map*) malloc( sizeof(Map) );
180: if ( m == (Map*) 0 )
181: {
182: (void) close( fd );
183: syslog( LOG_ERR, "out of memory allocating a Map" );
184: return (void*) 0;
185: }
186: ++alloc_count;
187: }
188:
189: /* Fill in the Map entry. */
190: m->ino = sb.st_ino;
191: m->dev = sb.st_dev;
192: m->size = sb.st_size;
193: m->ctime = sb.st_ctime;
194: m->refcount = 1;
195: m->reftime = now;
196:
197: /* Avoid doing anything for zero-length files; some systems don't like
198: ** to mmap them, other systems dislike mallocing zero bytes.
199: */
200: if ( m->size == 0 )
201: m->addr = (void*) 1; /* arbitrary non-NULL address */
202: else
203: {
204: size_t size_size = (size_t) m->size; /* loses on files >2GB */
205: #ifdef USE_SENDFILE
206: m->fd = fd;
207: #elif defined(HAVE_MMAP)
208: /* Map the file into memory. */
209: m->addr = mmap( 0, size_size, PROT_READ, MAP_PRIVATE, fd, 0 );
210: if ( m->addr == (void*) -1 && errno == ENOMEM )
211: {
212: /* Ooo, out of address space. Free all unreferenced maps
213: ** and try again.
214: */
215: panic();
216: m->addr = mmap( 0, size_size, PROT_READ, MAP_PRIVATE, fd, 0 );
217: }
218: if ( m->addr == (void*) -1 )
219: {
220: syslog( LOG_ERR, "mmap - %m" );
221: (void) close( fd );
222: free( (void*) m );
223: --alloc_count;
224: return (void*) 0;
225: }
226: #else /* HAVE_MMAP */
227: /* Read the file into memory. */
228: m->addr = (void*) malloc( size_size );
229: if ( m->addr == (void*) 0 )
230: {
231: /* Ooo, out of memory. Free all unreferenced maps
232: ** and try again.
233: */
234: panic();
235: m->addr = (void*) malloc( size_size );
236: }
237: if ( m->addr == (void*) 0 )
238: {
239: syslog( LOG_ERR, "out of memory storing a file" );
240: (void) close( fd );
241: free( (void*) m );
242: --alloc_count;
243: return (void*) 0;
244: }
245: if ( httpd_read_fully( fd, m->addr, size_size ) != size_size )
246: {
247: syslog( LOG_ERR, "read - %m" );
248: (void) close( fd );
249: free( (void*) m );
250: --alloc_count;
251: return (void*) 0;
252: }
253: #endif /* HAVE_MMAP */
254: }
255: #ifndef USE_SENDFILE
256: (void) close( fd );
257: #endif /* !USE_SENDFILE */
258: /* Put the Map into the hash table. */
259: if ( add_hash( m ) < 0 )
260: {
261: syslog( LOG_ERR, "add_hash() failure" );
262: free( (void*) m );
263: --alloc_count;
264: return (void*) 0;
265: }
266:
267: /* Put the Map on the active list. */
268: m->next = maps;
269: maps = m;
270: ++map_count;
271:
272: /* Update the total byte count. */
273: mapped_bytes += m->size;
274:
275: #ifdef USE_SENDFILE
276: return (&m->fd);
277: #else
278: /* And return the address. */
279: return m->addr;
280: #endif
281: }
282:
283:
284: void
285: mmc_unmap( void* addr, struct stat* sbP, struct timeval* nowP )
286: {
287: Map* m = (Map*) 0;
288:
289: /* Find the Map entry for this address. First try a hash. */
290: if ( sbP != (struct stat*) 0 )
291: {
292: m = find_hash( sbP->st_ino, sbP->st_dev, sbP->st_size, sbP->st_ctime );
293: #ifndef USE_SENDFILE
294: if ( m != (Map*) 0 && m->addr != addr )
295: m = (Map*) 0;
296: #endif
297: }
298: #ifndef USE_SENDFILE
299: /* If that didn't work, try a full search. */
300: if ( m == (Map*) 0 )
301: for ( m = maps; m != (Map*) 0; m = m->next )
302: if ( m->addr == addr )
303: break;
304: #endif
305: if ( m == (Map*) 0 )
306: syslog( LOG_ERR, "mmc_unmap failed to find entry!" );
307: else if ( m->refcount <= 0 )
308: syslog( LOG_ERR, "mmc_unmap found zero or negative refcount!" );
309: else
310: {
311: --m->refcount;
312: if ( nowP != (struct timeval*) 0 )
313: m->reftime = nowP->tv_sec;
314: else
315: m->reftime = time( (time_t*) 0 );
316: }
317: }
318:
319:
320: void
321: mmc_cleanup( struct timeval* nowP )
322: {
323: time_t now;
324: Map** mm;
325: Map* m;
326:
327: /* Get the current time, if necessary. */
328: if ( nowP != (struct timeval*) 0 )
329: now = nowP->tv_sec;
330: else
331: now = time( (time_t*) 0 );
332:
333: /* Really unmap any unreferenced entries older than the age limit. */
334: for ( mm = &maps; *mm != (Map*) 0; )
335: {
336: m = *mm;
337: if ( m->refcount == 0 && now - m->reftime >= expire_age )
338: really_unmap( mm );
339: else
340: mm = &(*mm)->next;
341: }
342:
343: /* Adjust the age limit if there are too many bytes mapped, or
344: ** too many or too few files mapped.
345: */
346: if ( mapped_bytes > DESIRED_MAX_MAPPED_BYTES )
347: expire_age = MAX( ( expire_age * 2 ) / 3, DEFAULT_EXPIRE_AGE / 10 );
348: else if ( map_count > DESIRED_MAX_MAPPED_FILES )
349: expire_age = MAX( ( expire_age * 2 ) / 3, DEFAULT_EXPIRE_AGE / 10 );
350: else if ( map_count < DESIRED_MAX_MAPPED_FILES / 2 )
351: expire_age = MIN( ( expire_age * 5 ) / 4, DEFAULT_EXPIRE_AGE * 3 );
352:
353: /* Really free excess blocks on the free list. */
354: while ( free_count > DESIRED_FREE_COUNT )
355: {
356: m = free_maps;
357: free_maps = m->next;
358: --free_count;
359: free( (void*) m );
360: --alloc_count;
361: }
362: }
363:
364:
365: static void
366: panic( void )
367: {
368: Map** mm;
369: Map* m;
370:
371: syslog( LOG_ERR, "mmc panic - freeing all unreferenced maps" );
372:
373: /* Really unmap all unreferenced entries. */
374: for ( mm = &maps; *mm != (Map*) 0; )
375: {
376: m = *mm;
377: if ( m->refcount == 0 )
378: really_unmap( mm );
379: else
380: mm = &(*mm)->next;
381: }
382: }
383:
384:
385: static void
386: really_unmap( Map** mm )
387: {
388: Map* m;
389:
390: m = *mm;
391: if ( m->size != 0 )
392: {
393: #ifdef USE_SENDFILE
394: close(m->fd);
395: #elif defined(HAVE_MMAP)
396: if ( munmap( m->addr, m->size ) < 0 )
397: syslog( LOG_ERR, "munmap - %m" );
398: #else /* HAVE_MMAP */
399: free( (void*) m->addr );
400: #endif /* HAVE_MMAP */
401: }
402: /* Update the total byte count. */
403: mapped_bytes -= m->size;
404: /* And move the Map to the free list. */
405: *mm = m->next;
406: --map_count;
407: m->next = free_maps;
408: free_maps = m;
409: ++free_count;
410: /* This will sometimes break hash chains, but that's harmless; the
411: ** unmapping code that searches the hash table knows to keep searching.
412: */
413: hash_table[m->hash_idx] = (Map*) 0;
414: }
415:
416:
417: void
418: mmc_destroy( void )
419: {
420: Map* m;
421:
422: while ( maps != (Map*) 0 )
423: really_unmap( &maps );
424: while ( free_maps != (Map*) 0 )
425: {
426: m = free_maps;
427: free_maps = m->next;
428: --free_count;
429: free( (void*) m );
430: --alloc_count;
431: }
432: }
433:
434:
435: /* Make sure the hash table is big enough. */
436: static int
437: check_hash_size( void )
438: {
439: int i;
440: Map* m;
441:
442: /* Are we just starting out? */
443: if ( hash_table == (Map**) 0 )
444: {
445: hash_size = INITIAL_HASH_SIZE;
446: hash_mask = hash_size - 1;
447: }
448: /* Is it at least three times bigger than the number of entries? */
449: else if ( hash_size >= map_count * 3 )
450: return 0;
451: else
452: {
453: /* No, got to expand. */
454: free( (void*) hash_table );
455: /* Double the hash size until it's big enough. */
456: do
457: {
458: hash_size = hash_size << 1;
459: }
460: while ( hash_size < map_count * 6 );
461: hash_mask = hash_size - 1;
462: }
463: /* Make the new table. */
464: hash_table = (Map**) malloc( hash_size * sizeof(Map*) );
465: if ( hash_table == (Map**) 0 )
466: return -1;
467: /* Clear it. */
468: for ( i = 0; i < hash_size; ++i )
469: hash_table[i] = (Map*) 0;
470: /* And rehash all entries. */
471: for ( m = maps; m != (Map*) 0; m = m->next )
472: if ( add_hash( m ) < 0 )
473: return -1;
474: return 0;
475: }
476:
477:
478: static int
479: add_hash( Map* m )
480: {
481: unsigned int h, he, i;
482:
483: h = hash( m->ino, m->dev, m->size, m->ctime );
484: he = ( h + hash_size - 1 ) & hash_mask;
485: for ( i = h; ; i = ( i + 1 ) & hash_mask )
486: {
487: if ( hash_table[i] == (Map*) 0 )
488: {
489: hash_table[i] = m;
490: m->hash = h;
491: m->hash_idx = i;
492: return 0;
493: }
494: if ( i == he )
495: break;
496: }
497: return -1;
498: }
499:
500:
501: static Map*
502: find_hash( ino_t ino, dev_t dev, off_t size, time_t ctime )
503: {
504: unsigned int h, he, i;
505: Map* m;
506:
507: h = hash( ino, dev, size, ctime );
508: he = ( h + hash_size - 1 ) & hash_mask;
509: for ( i = h; ; i = ( i + 1 ) & hash_mask )
510: {
511: m = hash_table[i];
512: if ( m == (Map*) 0 )
513: break;
514: if ( m->hash == h && m->ino == ino && m->dev == dev &&
515: m->size == size && m->ctime == ctime )
516: return m;
517: if ( i == he )
518: break;
519: }
520: return (Map*) 0;
521: }
522:
523:
524: static unsigned int
525: hash( ino_t ino, dev_t dev, off_t size, time_t ctime )
526: {
527: unsigned int h = 177573;
528:
529: h ^= ino;
530: h += h << 5;
531: h ^= dev;
532: h += h << 5;
533: h ^= size;
534: h += h << 5;
535: h ^= ctime;
536:
537: return h & hash_mask;
538: }
539:
540:
541: /* Generate debugging statistics syslog message. */
542: void
543: mmc_logstats( long secs )
544: {
545: syslog(
546: LOG_INFO, " map cache - %d allocated, %d active (%lld bytes), %d free; hash size: %d; expire age: %ld",
547: alloc_count, map_count, (int64_t) mapped_bytes, free_count, hash_size,
548: expire_age );
549: if ( map_count + free_count != alloc_count )
550: syslog( LOG_ERR, "map counts don't add up!" );
551: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mmc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / thttpd