Add Valgrind hooks for memory pools
[exim.git] / src / src / store.c
CommitLineData
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
11implementation there was a lot of mallocing and freeing of small bits of store.
12The 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
14need to do any garbage collection, but the stack concept allows quick resetting
15in places where this seems sensible.
16
17Obviously the long-running processes (the daemon, the queue runner, and eximon)
18must take care not to eat store.
19
20The 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
48how to get an alignment factor in general. In the current world, a value of 8
49is 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
51is a constant, the compiler should optimize it to a simple constant wherever it
52appears (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
58must be a multiple of the alignment. We assume that 8192 is going to be
59suitably aligned. */
60
61#define STORE_BLOCK_SIZE 8192
62
63/* store_reset() will not free the following block if the last used block has
64less than this much left in it. */
65
66#define STOREPOOL_MIN_SIZE 256
67
68/* Structure describing the beginning of each big block. */
69
70typedef 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
76length that is not a multiple of the alignment, set up a macro for the padded
77length. */
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
83is held in store_pool, which is global so that it can be changed from outside.
84Setting the initial length values to -1 forces a malloc for the first call,
85even if the length is zero (which is used for getting a point to reset to). */
86
87int store_pool = POOL_PERM;
88
89static storeblock *chainbase[3] = { NULL, NULL, NULL };
90static storeblock *current_block[3] = { NULL, NULL, NULL };
91static void *next_yield[3] = { NULL, NULL, NULL };
92static int yield_length[3] = { -1, -1, -1 };
93
94/* pool_malloc holds the amount of memory used by the store pools; this goes up
95and down as store is reset or released. nonpool_malloc is the total got by
96malloc from other calls; this doesn't go down because it is just freed by
97pointer. */
98
99static int pool_malloc = 0;
100static int nonpool_malloc = 0;
101
102/* This variable is set by store_get() to its yield, and by store_reset() to
103NULL. This enables string_cat() to optimize its store handling for very long
104strings. That's why the variable is global. */
105
106void *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
115macro store_get(). It passes back a block of store within the current big
116block, getting a new one if necessary. The address is saved in
117store_last_was_get.
118
119Arguments:
120 size amount wanted
121 filename source file from which called
122 linenumber line number in source file.
123
124Returns: pointer to store (panic on malloc failure)
125*/
126
127void *
128store_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
131messy statement, because "alignment" is a constant expression, the compiler can
132do a reasonable job of optimizing, especially if the value of "alignment" is a
133power of two. I checked this with -O2, and gcc did very well, compiling it to 4
134instructions on a Sparc (alignment = 8). */
135
136if (size % alignment != 0) size += alignment - (size % alignment);
137
138/* If there isn't room in the current block, get a new one. The minimum
139size is STORE_BLOCK_SIZE, and we would expect this to be the norm, since
140these functions are mostly called for small amounts of store. */
141
142if (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
183pointer. */
184
185store_last_get[store_pool] = next_yield[store_pool];
186
187/* Cut out the debugging stuff for utilities, but stop picky compilers from
188giving warnings. */
189
190#ifdef COMPILE_UTILITY
191filename = filename;
192linenumber = linenumber;
193#else
194DEBUG(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 204VALGRIND_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
207next_yield[store_pool] = (void *)((char *)next_yield[store_pool] + size);
208yield_length[store_pool] -= size;
209
210return 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
220be obtained.
221
222Arguments:
223 size amount wanted
224 filename source file from which called
225 linenumber line number in source file.
226
227Returns: pointer to store (panic on malloc failure)
228*/
229
230void *
231store_get_perm_3(int size, const char *filename, int linenumber)
232{
233void *yield;
234int old_pool = store_pool;
235store_pool = POOL_PERM;
236yield = store_get_3(size, filename, linenumber);
237store_pool = old_pool;
238return 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
248string is being read into the block at the top of the stack. If it needs to be
249extended, it is more efficient just to extend the top block rather than
250allocate a new block and then have to copy the data. This function is provided
251for the use of string_cat(), but of course can be used elsewhere too.
252
253Arguments:
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
260Returns: 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
265BOOL
266store_extend_3(void *ptr, int oldsize, int newsize, const char *filename,
267 int linenumber)
268{
269int inc = newsize - oldsize;
270int rounded_oldsize = oldsize;
271
272if (rounded_oldsize % alignment != 0)
273 rounded_oldsize += alignment - (rounded_oldsize % alignment);
274
275if ((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
280giving warnings. */
281
282#ifdef COMPILE_UTILITY
283filename = filename;
284linenumber = linenumber;
285#else
286DEBUG(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
296if (newsize % alignment != 0) newsize += alignment - (newsize % alignment);
297next_yield[store_pool] = (char *)ptr + newsize;
298yield_length[store_pool] -= newsize - rounded_oldsize;
7f36d675 299VALGRIND_MAKE_MEM_UNDEFINED(ptr + oldsize, inc);
059ec3d9
PH
300return 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
311that are now unused. Normally it is given a pointer that was the yield of a
312call to store_get, and is therefore aligned, but it may be given an offset
313after such a pointer in order to release the end of a block and anything that
314follows.
315
316Arguments:
317 ptr place to back up to
318 filename source file from which called
319 linenumber line number in source file
320
321Returns: nothing
322*/
323
324void
325store_reset_3(void *ptr, const char *filename, int linenumber)
326{
327storeblock *bb;
328storeblock *b = current_block[store_pool];
329char *bc = (char *)b + ALIGNED_SIZEOF_STOREBLOCK;
330int newlength;
331
332/* Last store operation was not a get */
333
334store_last_get[store_pool] = NULL;
335
336/* See if the place is in the current block - as it often will be. Otherwise,
337search for the block in which it lies. */
338
339if ((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
352the released memory. */
353
354newlength = bc + b->length - (char *)ptr;
355#ifndef COMPILE_UTILITY
356if (running_in_test_harness) memset(ptr, 0xF0, newlength);
357#endif
7f36d675 358VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength);
059ec3d9
PH
359yield_length[store_pool] = newlength - (newlength % alignment);
360next_yield[store_pool] = (char *)ptr + (newlength % alignment);
361current_block[store_pool] = b;
362
363/* Free any subsequent block. Do NOT free the first successor, if our
364current block has less than 256 bytes left. This should prevent us from
365flapping memory. However, keep this block only when it has the default size. */
366
367if (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
375bb = b->next;
376b->next = NULL;
377
378while (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
387giving warnings. */
388
389#ifdef COMPILE_UTILITY
390filename = filename;
391linenumber = linenumber;
392#else
393DEBUG(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
413long strings, e.g. header lines. When the string gets longer than a
414complete block, it gets copied to a new block. It is helpful to free
415the old block iff the previous copy of the string is at its start,
416and therefore the only thing in it. Otherwise, for very long strings,
417dead store can pile up somewhat disastrously. This function checks that
418the pointer it is given is the first thing in a block, and if so,
419releases that block.
420
421Arguments:
422 block block of store to consider
423 filename source file from which called
424 linenumber line number in source file
425
426Returns: nothing
427*/
428
429void
430store_release_3(void *block, const char *filename, int linenumber)
431{
432storeblock *b;
433
434/* It will never be the first block, so no need to check that. */
435
436for (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
477do not run happily on very small sizes, nor do they document this fact. This
478function is called via the macro store_malloc().
479
480Arguments:
481 size amount of store wanted
482 filename source file from which called
483 linenumber line number in source file
484
485Returns: pointer to gotten store (panic on failure)
486*/
487
488void *
489store_malloc_3(int size, const char *filename, int linenumber)
490{
491void *yield;
492
493if (size < 16) size = 16;
494yield = malloc((size_t)size);
495
496if (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
500nonpool_malloc += size;
501
502/* Cut out the debugging stuff for utilities, but stop picky compilers from
503giving warnings. */
504
505#ifdef COMPILE_UTILITY
506filename = filename;
507linenumber = linenumber;
508#else
509
510/* If running in test harness, spend time making sure all the new store
511is not filled with zeros so as to catch problems. */
512
513if (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 }
519else
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
526return yield;
527}
528
529
530/************************************************
531* Free store *
532************************************************/
533
534/* This function is called by the macro store_free().
535
536Arguments:
537 block block of store to free
538 filename source file from which called
539 linenumber line number in source file
540
541Returns: nothing
542*/
543
544void
545store_free_3(void *block, const char *filename, int linenumber)
546{
547#ifdef COMPILE_UTILITY
548filename = filename;
549linenumber = linenumber;
550#else
551DEBUG(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 */
559free(block);
560}
561
562/* End of store.c */