Commit | Line | Data |
---|---|---|
0a49a7a4 | 1 | /* $Cambridge: exim/src/src/store.c,v 1.5 2009/11/16 19:50:37 nm4 Exp $ */ |
059ec3d9 PH |
2 | |
3 | /************************************************* | |
4 | * Exim - an Internet mail transport agent * | |
5 | *************************************************/ | |
6 | ||
0a49a7a4 | 7 | /* Copyright (c) University of Cambridge 1995 - 2009 */ |
059ec3d9 PH |
8 | /* See the file NOTICE for conditions of use and distribution. */ |
9 | ||
10 | /* Exim gets and frees all its store through these functions. In the original | |
11 | implementation there was a lot of mallocing and freeing of small bits of store. | |
12 | The philosophy has now changed to a scheme which includes the concept of | |
13 | "stacking pools" of store. For the short-lived processes, there isn't any real | |
14 | need to do any garbage collection, but the stack concept allows quick resetting | |
15 | in places where this seems sensible. | |
16 | ||
17 | Obviously the long-running processes (the daemon, the queue runner, and eximon) | |
18 | must take care not to eat store. | |
19 | ||
20 | The following different types of store are recognized: | |
21 | ||
22 | . Long-lived, large blocks: This is implemented by retaining the original | |
23 | malloc/free functions, and it used for permanent working buffers and for | |
24 | getting blocks to cut up for the other types. | |
25 | ||
26 | . Long-lived, small blocks: This is used for blocks that have to survive until | |
27 | the process exits. It is implemented as a stacking pool (POOL_PERM). This is | |
28 | functionally the same as store_malloc(), except that the store can't be | |
29 | freed, but I expect it to be more efficient for handling small blocks. | |
30 | ||
31 | . Short-lived, short blocks: Most of the dynamic store falls into this | |
32 | category. It is implemented as a stacking pool (POOL_MAIN) which is reset | |
33 | after accepting a message when multiple messages are received by a single | |
34 | process. Resetting happens at some other times as well, usually fairly | |
35 | locally after some specific processing that needs working store. | |
36 | ||
37 | . There is a separate pool (POOL_SEARCH) that is used only for lookup storage. | |
38 | This means it can be freed when search_tidyup() is called to close down all | |
39 | the lookup caching. | |
40 | */ | |
41 | ||
42 | ||
43 | #include "exim.h" | |
7f36d675 | 44 | #include "memcheck.h" |
059ec3d9 PH |
45 | |
46 | ||
47 | /* We need to know how to align blocks of data for general use. I'm not sure | |
48 | how to get an alignment factor in general. In the current world, a value of 8 | |
49 | is probably right, and this is sizeof(double) on some systems and sizeof(void | |
50 | *) on others, so take the larger of those. Since everything in this expression | |
51 | is a constant, the compiler should optimize it to a simple constant wherever it | |
52 | appears (I checked that gcc does do this). */ | |
53 | ||
54 | #define alignment \ | |
55 | ((sizeof(void *) > sizeof(double))? sizeof(void *) : sizeof(double)) | |
56 | ||
57 | /* Size of block to get from malloc to carve up into smaller ones. This | |
58 | must be a multiple of the alignment. We assume that 8192 is going to be | |
59 | suitably aligned. */ | |
60 | ||
61 | #define STORE_BLOCK_SIZE 8192 | |
62 | ||
63 | /* store_reset() will not free the following block if the last used block has | |
64 | less than this much left in it. */ | |
65 | ||
66 | #define STOREPOOL_MIN_SIZE 256 | |
67 | ||
68 | /* Structure describing the beginning of each big block. */ | |
69 | ||
70 | typedef struct storeblock { | |
71 | struct storeblock *next; | |
72 | size_t length; | |
73 | } storeblock; | |
74 | ||
75 | /* Just in case we find ourselves on a system where the structure above has a | |
76 | length that is not a multiple of the alignment, set up a macro for the padded | |
77 | length. */ | |
78 | ||
79 | #define ALIGNED_SIZEOF_STOREBLOCK \ | |
80 | (((sizeof(storeblock) + alignment - 1) / alignment) * alignment) | |
81 | ||
82 | /* Variables holding data for the local pools of store. The current pool number | |
83 | is held in store_pool, which is global so that it can be changed from outside. | |
84 | Setting the initial length values to -1 forces a malloc for the first call, | |
85 | even if the length is zero (which is used for getting a point to reset to). */ | |
86 | ||
87 | int store_pool = POOL_PERM; | |
88 | ||
89 | static storeblock *chainbase[3] = { NULL, NULL, NULL }; | |
90 | static storeblock *current_block[3] = { NULL, NULL, NULL }; | |
91 | static void *next_yield[3] = { NULL, NULL, NULL }; | |
92 | static int yield_length[3] = { -1, -1, -1 }; | |
93 | ||
94 | /* pool_malloc holds the amount of memory used by the store pools; this goes up | |
95 | and down as store is reset or released. nonpool_malloc is the total got by | |
96 | malloc from other calls; this doesn't go down because it is just freed by | |
97 | pointer. */ | |
98 | ||
99 | static int pool_malloc = 0; | |
100 | static int nonpool_malloc = 0; | |
101 | ||
102 | /* This variable is set by store_get() to its yield, and by store_reset() to | |
103 | NULL. This enables string_cat() to optimize its store handling for very long | |
104 | strings. That's why the variable is global. */ | |
105 | ||
106 | void *store_last_get[3] = { NULL, NULL, NULL }; | |
107 | ||
108 | ||
109 | ||
110 | /************************************************* | |
111 | * Get a block from the current pool * | |
112 | *************************************************/ | |
113 | ||
114 | /* Running out of store is a total disaster. This function is called via the | |
115 | macro store_get(). It passes back a block of store within the current big | |
116 | block, getting a new one if necessary. The address is saved in | |
117 | store_last_was_get. | |
118 | ||
119 | Arguments: | |
120 | size amount wanted | |
121 | filename source file from which called | |
122 | linenumber line number in source file. | |
123 | ||
124 | Returns: pointer to store (panic on malloc failure) | |
125 | */ | |
126 | ||
127 | void * | |
128 | store_get_3(int size, const char *filename, int linenumber) | |
129 | { | |
130 | /* Round up the size to a multiple of the alignment. Although this looks a | |
131 | messy statement, because "alignment" is a constant expression, the compiler can | |
132 | do a reasonable job of optimizing, especially if the value of "alignment" is a | |
133 | power of two. I checked this with -O2, and gcc did very well, compiling it to 4 | |
134 | instructions on a Sparc (alignment = 8). */ | |
135 | ||
136 | if (size % alignment != 0) size += alignment - (size % alignment); | |
137 | ||
138 | /* If there isn't room in the current block, get a new one. The minimum | |
139 | size is STORE_BLOCK_SIZE, and we would expect this to be the norm, since | |
140 | these functions are mostly called for small amounts of store. */ | |
141 | ||
142 | if (size > yield_length[store_pool]) | |
143 | { | |
144 | int length = (size <= STORE_BLOCK_SIZE)? STORE_BLOCK_SIZE : size; | |
145 | int mlength = length + ALIGNED_SIZEOF_STOREBLOCK; | |
146 | storeblock *newblock = NULL; | |
147 | ||
148 | /* Sometimes store_reset() may leave a block for us; check if we can use it */ | |
149 | ||
150 | if (current_block[store_pool] != NULL && | |
151 | current_block[store_pool]->next != NULL) | |
152 | { | |
153 | newblock = current_block[store_pool]->next; | |
154 | if (newblock->length < length) | |
155 | { | |
156 | /* Give up on this block, because it's too small */ | |
157 | store_free(newblock); | |
158 | newblock = NULL; | |
159 | } | |
160 | } | |
161 | ||
162 | /* If there was no free block, get a new one */ | |
163 | ||
164 | if (newblock == NULL) | |
165 | { | |
166 | pool_malloc += mlength; /* Used in pools */ | |
167 | nonpool_malloc -= mlength; /* Exclude from overall total */ | |
168 | newblock = store_malloc(mlength); | |
169 | newblock->next = NULL; | |
170 | newblock->length = length; | |
171 | if (chainbase[store_pool] == NULL) chainbase[store_pool] = newblock; | |
172 | else current_block[store_pool]->next = newblock; | |
173 | } | |
174 | ||
175 | current_block[store_pool] = newblock; | |
176 | yield_length[store_pool] = newblock->length; | |
177 | next_yield[store_pool] = | |
178 | (void *)((char *)current_block[store_pool] + ALIGNED_SIZEOF_STOREBLOCK); | |
7f36d675 | 179 | VALGRIND_MAKE_MEM_NOACCESS(next_yield[store_pool], yield_length[store_pool]); |
059ec3d9 PH |
180 | } |
181 | ||
182 | /* There's (now) enough room in the current block; the yield is the next | |
183 | pointer. */ | |
184 | ||
185 | store_last_get[store_pool] = next_yield[store_pool]; | |
186 | ||
187 | /* Cut out the debugging stuff for utilities, but stop picky compilers from | |
188 | giving warnings. */ | |
189 | ||
190 | #ifdef COMPILE_UTILITY | |
191 | filename = filename; | |
192 | linenumber = linenumber; | |
193 | #else | |
194 | DEBUG(D_memory) | |
195 | { | |
196 | if (running_in_test_harness) | |
197 | debug_printf("---%d Get %5d\n", store_pool, size); | |
198 | else | |
199 | debug_printf("---%d Get %6p %5d %-14s %4d\n", store_pool, | |
200 | store_last_get[store_pool], size, filename, linenumber); | |
201 | } | |
202 | #endif /* COMPILE_UTILITY */ | |
203 | ||
7f36d675 | 204 | VALGRIND_MAKE_MEM_UNDEFINED(store_last_get[store_pool], size); |
059ec3d9 PH |
205 | /* Update next pointer and number of bytes left in the current block. */ |
206 | ||
207 | next_yield[store_pool] = (void *)((char *)next_yield[store_pool] + size); | |
208 | yield_length[store_pool] -= size; | |
209 | ||
210 | return store_last_get[store_pool]; | |
211 | } | |
212 | ||
213 | ||
214 | ||
215 | /************************************************* | |
216 | * Get a block from the PERM pool * | |
217 | *************************************************/ | |
218 | ||
219 | /* This is just a convenience function, useful when just a single block is to | |
220 | be obtained. | |
221 | ||
222 | Arguments: | |
223 | size amount wanted | |
224 | filename source file from which called | |
225 | linenumber line number in source file. | |
226 | ||
227 | Returns: pointer to store (panic on malloc failure) | |
228 | */ | |
229 | ||
230 | void * | |
231 | store_get_perm_3(int size, const char *filename, int linenumber) | |
232 | { | |
233 | void *yield; | |
234 | int old_pool = store_pool; | |
235 | store_pool = POOL_PERM; | |
236 | yield = store_get_3(size, filename, linenumber); | |
237 | store_pool = old_pool; | |
238 | return yield; | |
239 | } | |
240 | ||
241 | ||
242 | ||
243 | /************************************************* | |
244 | * Extend a block if it is at the top * | |
245 | *************************************************/ | |
246 | ||
247 | /* While reading strings of unknown length, it is often the case that the | |
248 | string is being read into the block at the top of the stack. If it needs to be | |
249 | extended, it is more efficient just to extend the top block rather than | |
250 | allocate a new block and then have to copy the data. This function is provided | |
251 | for the use of string_cat(), but of course can be used elsewhere too. | |
252 | ||
253 | Arguments: | |
254 | ptr pointer to store block | |
255 | oldsize current size of the block, as requested by user | |
256 | newsize new size required | |
257 | filename source file from which called | |
258 | linenumber line number in source file | |
259 | ||
260 | Returns: TRUE if the block is at the top of the stack and has been | |
261 | extended; FALSE if it isn't at the top of the stack, or cannot | |
262 | be extended | |
263 | */ | |
264 | ||
265 | BOOL | |
266 | store_extend_3(void *ptr, int oldsize, int newsize, const char *filename, | |
267 | int linenumber) | |
268 | { | |
269 | int inc = newsize - oldsize; | |
270 | int rounded_oldsize = oldsize; | |
271 | ||
272 | if (rounded_oldsize % alignment != 0) | |
273 | rounded_oldsize += alignment - (rounded_oldsize % alignment); | |
274 | ||
275 | if ((char *)ptr + rounded_oldsize != (char *)(next_yield[store_pool]) || | |
276 | inc > yield_length[store_pool] + rounded_oldsize - oldsize) | |
277 | return FALSE; | |
278 | ||
279 | /* Cut out the debugging stuff for utilities, but stop picky compilers from | |
280 | giving warnings. */ | |
281 | ||
282 | #ifdef COMPILE_UTILITY | |
283 | filename = filename; | |
284 | linenumber = linenumber; | |
285 | #else | |
286 | DEBUG(D_memory) | |
287 | { | |
288 | if (running_in_test_harness) | |
289 | debug_printf("---%d Ext %5d\n", store_pool, newsize); | |
290 | else | |
291 | debug_printf("---%d Ext %6p %5d %-14s %4d\n", store_pool, ptr, newsize, | |
292 | filename, linenumber); | |
293 | } | |
294 | #endif /* COMPILE_UTILITY */ | |
295 | ||
296 | if (newsize % alignment != 0) newsize += alignment - (newsize % alignment); | |
297 | next_yield[store_pool] = (char *)ptr + newsize; | |
298 | yield_length[store_pool] -= newsize - rounded_oldsize; | |
7f36d675 | 299 | VALGRIND_MAKE_MEM_UNDEFINED(ptr + oldsize, inc); |
059ec3d9 PH |
300 | return TRUE; |
301 | } | |
302 | ||
303 | ||
304 | ||
305 | ||
306 | /************************************************* | |
307 | * Back up to a previous point on the stack * | |
308 | *************************************************/ | |
309 | ||
310 | /* This function resets the next pointer, freeing any subsequent whole blocks | |
311 | that are now unused. Normally it is given a pointer that was the yield of a | |
312 | call to store_get, and is therefore aligned, but it may be given an offset | |
313 | after such a pointer in order to release the end of a block and anything that | |
314 | follows. | |
315 | ||
316 | Arguments: | |
317 | ptr place to back up to | |
318 | filename source file from which called | |
319 | linenumber line number in source file | |
320 | ||
321 | Returns: nothing | |
322 | */ | |
323 | ||
324 | void | |
325 | store_reset_3(void *ptr, const char *filename, int linenumber) | |
326 | { | |
327 | storeblock *bb; | |
328 | storeblock *b = current_block[store_pool]; | |
329 | char *bc = (char *)b + ALIGNED_SIZEOF_STOREBLOCK; | |
330 | int newlength; | |
331 | ||
332 | /* Last store operation was not a get */ | |
333 | ||
334 | store_last_get[store_pool] = NULL; | |
335 | ||
336 | /* See if the place is in the current block - as it often will be. Otherwise, | |
337 | search for the block in which it lies. */ | |
338 | ||
339 | if ((char *)ptr < bc || (char *)ptr > bc + b->length) | |
340 | { | |
341 | for (b = chainbase[store_pool]; b != NULL; b = b->next) | |
342 | { | |
343 | bc = (char *)b + ALIGNED_SIZEOF_STOREBLOCK; | |
344 | if ((char *)ptr >= bc && (char *)ptr <= bc + b->length) break; | |
345 | } | |
346 | if (b == NULL) | |
347 | log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal error: store_reset(%d) " | |
348 | "failed: pool=%d %-14s %4d", ptr, store_pool, filename, linenumber); | |
349 | } | |
350 | ||
351 | /* Back up, rounding to the alignment if necessary. When testing, flatten | |
352 | the released memory. */ | |
353 | ||
354 | newlength = bc + b->length - (char *)ptr; | |
355 | #ifndef COMPILE_UTILITY | |
356 | if (running_in_test_harness) memset(ptr, 0xF0, newlength); | |
357 | #endif | |
7f36d675 | 358 | VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength); |
059ec3d9 PH |
359 | yield_length[store_pool] = newlength - (newlength % alignment); |
360 | next_yield[store_pool] = (char *)ptr + (newlength % alignment); | |
361 | current_block[store_pool] = b; | |
362 | ||
363 | /* Free any subsequent block. Do NOT free the first successor, if our | |
364 | current block has less than 256 bytes left. This should prevent us from | |
365 | flapping memory. However, keep this block only when it has the default size. */ | |
366 | ||
367 | if (yield_length[store_pool] < STOREPOOL_MIN_SIZE && | |
368 | b->next != NULL && | |
369 | b->next->length == STORE_BLOCK_SIZE) | |
7f36d675 | 370 | { |
059ec3d9 | 371 | b = b->next; |
7f36d675 DW |
372 | VALGRIND_MAKE_MEM_NOACCESS((char *)b + ALIGNED_SIZEOF_STOREBLOCK, b->length - ALIGNED_SIZEOF_STOREBLOCK); |
373 | } | |
059ec3d9 PH |
374 | |
375 | bb = b->next; | |
376 | b->next = NULL; | |
377 | ||
378 | while (bb != NULL) | |
379 | { | |
380 | b = bb; | |
381 | bb = bb->next; | |
382 | pool_malloc -= b->length + ALIGNED_SIZEOF_STOREBLOCK; | |
383 | store_free_3(b, filename, linenumber); | |
384 | } | |
385 | ||
386 | /* Cut out the debugging stuff for utilities, but stop picky compilers from | |
387 | giving warnings. */ | |
388 | ||
389 | #ifdef COMPILE_UTILITY | |
390 | filename = filename; | |
391 | linenumber = linenumber; | |
392 | #else | |
393 | DEBUG(D_memory) | |
394 | { | |
395 | if (running_in_test_harness) | |
396 | debug_printf("---%d Rst ** %d\n", store_pool, pool_malloc); | |
397 | else | |
398 | debug_printf("---%d Rst %6p ** %-14s %4d %d\n", store_pool, ptr, | |
399 | filename, linenumber, pool_malloc); | |
400 | } | |
401 | #endif /* COMPILE_UTILITY */ | |
402 | } | |
403 | ||
404 | ||
405 | ||
406 | ||
407 | ||
408 | /************************************************ | |
409 | * Release store * | |
410 | ************************************************/ | |
411 | ||
412 | /* This function is specifically provided for use when reading very | |
413 | long strings, e.g. header lines. When the string gets longer than a | |
414 | complete block, it gets copied to a new block. It is helpful to free | |
415 | the old block iff the previous copy of the string is at its start, | |
416 | and therefore the only thing in it. Otherwise, for very long strings, | |
417 | dead store can pile up somewhat disastrously. This function checks that | |
418 | the pointer it is given is the first thing in a block, and if so, | |
419 | releases that block. | |
420 | ||
421 | Arguments: | |
422 | block block of store to consider | |
423 | filename source file from which called | |
424 | linenumber line number in source file | |
425 | ||
426 | Returns: nothing | |
427 | */ | |
428 | ||
429 | void | |
430 | store_release_3(void *block, const char *filename, int linenumber) | |
431 | { | |
432 | storeblock *b; | |
433 | ||
434 | /* It will never be the first block, so no need to check that. */ | |
435 | ||
436 | for (b = chainbase[store_pool]; b != NULL; b = b->next) | |
437 | { | |
438 | storeblock *bb = b->next; | |
439 | if (bb != NULL && (char *)block == (char *)bb + ALIGNED_SIZEOF_STOREBLOCK) | |
440 | { | |
441 | b->next = bb->next; | |
442 | pool_malloc -= bb->length + ALIGNED_SIZEOF_STOREBLOCK; | |
443 | ||
444 | /* Cut out the debugging stuff for utilities, but stop picky compilers | |
445 | from giving warnings. */ | |
446 | ||
447 | #ifdef COMPILE_UTILITY | |
448 | filename = filename; | |
449 | linenumber = linenumber; | |
450 | #else | |
451 | DEBUG(D_memory) | |
452 | { | |
453 | if (running_in_test_harness) | |
454 | debug_printf("-Release %d\n", pool_malloc); | |
455 | else | |
456 | debug_printf("-Release %6p %-20s %4d %d\n", (void *)bb, filename, | |
457 | linenumber, pool_malloc); | |
458 | } | |
459 | if (running_in_test_harness) | |
460 | memset(bb, 0xF0, bb->length+ALIGNED_SIZEOF_STOREBLOCK); | |
461 | #endif /* COMPILE_UTILITY */ | |
462 | ||
463 | free(bb); | |
464 | return; | |
465 | } | |
466 | } | |
467 | } | |
468 | ||
469 | ||
470 | ||
471 | ||
472 | /************************************************* | |
473 | * Malloc store * | |
474 | *************************************************/ | |
475 | ||
476 | /* Running out of store is a total disaster for exim. Some malloc functions | |
477 | do not run happily on very small sizes, nor do they document this fact. This | |
478 | function is called via the macro store_malloc(). | |
479 | ||
480 | Arguments: | |
481 | size amount of store wanted | |
482 | filename source file from which called | |
483 | linenumber line number in source file | |
484 | ||
485 | Returns: pointer to gotten store (panic on failure) | |
486 | */ | |
487 | ||
488 | void * | |
489 | store_malloc_3(int size, const char *filename, int linenumber) | |
490 | { | |
491 | void *yield; | |
492 | ||
493 | if (size < 16) size = 16; | |
494 | yield = malloc((size_t)size); | |
495 | ||
496 | if (yield == NULL) | |
497 | log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to malloc %d bytes of memory: " | |
498 | "called from line %d of %s", size, linenumber, filename); | |
499 | ||
500 | nonpool_malloc += size; | |
501 | ||
502 | /* Cut out the debugging stuff for utilities, but stop picky compilers from | |
503 | giving warnings. */ | |
504 | ||
505 | #ifdef COMPILE_UTILITY | |
506 | filename = filename; | |
507 | linenumber = linenumber; | |
508 | #else | |
509 | ||
510 | /* If running in test harness, spend time making sure all the new store | |
511 | is not filled with zeros so as to catch problems. */ | |
512 | ||
513 | if (running_in_test_harness) | |
514 | { | |
515 | memset(yield, 0xF0, (size_t)size); | |
516 | DEBUG(D_memory) debug_printf("--Malloc %5d %d %d\n", size, pool_malloc, | |
517 | nonpool_malloc); | |
518 | } | |
519 | else | |
520 | { | |
521 | DEBUG(D_memory) debug_printf("--Malloc %6p %5d %-14s %4d %d %d\n", yield, | |
522 | size, filename, linenumber, pool_malloc, nonpool_malloc); | |
523 | } | |
524 | #endif /* COMPILE_UTILITY */ | |
525 | ||
526 | return yield; | |
527 | } | |
528 | ||
529 | ||
530 | /************************************************ | |
531 | * Free store * | |
532 | ************************************************/ | |
533 | ||
534 | /* This function is called by the macro store_free(). | |
535 | ||
536 | Arguments: | |
537 | block block of store to free | |
538 | filename source file from which called | |
539 | linenumber line number in source file | |
540 | ||
541 | Returns: nothing | |
542 | */ | |
543 | ||
544 | void | |
545 | store_free_3(void *block, const char *filename, int linenumber) | |
546 | { | |
547 | #ifdef COMPILE_UTILITY | |
548 | filename = filename; | |
549 | linenumber = linenumber; | |
550 | #else | |
551 | DEBUG(D_memory) | |
552 | { | |
553 | if (running_in_test_harness) | |
554 | debug_printf("----Free\n"); | |
555 | else | |
556 | debug_printf("----Free %6p %-20s %4d\n", block, filename, linenumber); | |
557 | } | |
558 | #endif /* COMPILE_UTILITY */ | |
559 | free(block); | |
560 | } | |
561 | ||
562 | /* End of store.c */ |