61f9464af58bdd76b42d07529a05cce8bc78001c
[users/jgh/exim.git] / src / src / store.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim maintainers 2019 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Exim gets and frees all its store through these functions. In the original
10 implementation there was a lot of mallocing and freeing of small bits of store.
11 The philosophy has now changed to a scheme which includes the concept of
12 "stacking pools" of store. For the short-lived processes, there isn't any real
13 need to do any garbage collection, but the stack concept allows quick resetting
14 in places where this seems sensible.
15
16 Obviously the long-running processes (the daemon, the queue runner, and eximon)
17 must take care not to eat store.
18
19 The following different types of store are recognized:
20
21 . Long-lived, large blocks: This is implemented by retaining the original
22   malloc/free functions, and it used for permanent working buffers and for
23   getting blocks to cut up for the other types.
24
25 . Long-lived, small blocks: This is used for blocks that have to survive until
26   the process exits. It is implemented as a stacking pool (POOL_PERM). This is
27   functionally the same as store_malloc(), except that the store can't be
28   freed, but I expect it to be more efficient for handling small blocks.
29
30 . Short-lived, short blocks: Most of the dynamic store falls into this
31   category. It is implemented as a stacking pool (POOL_MAIN) which is reset
32   after accepting a message when multiple messages are received by a single
33   process. Resetting happens at some other times as well, usually fairly
34   locally after some specific processing that needs working store.
35
36 . There is a separate pool (POOL_SEARCH) that is used only for lookup storage.
37   This means it can be freed when search_tidyup() is called to close down all
38   the lookup caching.
39
40 . Orthogonal to the three pool types, there are two classes of memory: untainted
41   and tainted.  The latter is used for values derived from untrusted input, and
42   the string-expansion mechanism refuses to operate on such values (obviously,
43   it can expand an untainted value to return a tainted result).  The classes
44   are implemented by duplicating the three pool types.  Pool resets are requested
45   against the nontainted sibling and apply to both siblings.
46
47   Only memory blocks requested for tainted use are regarded as tainted; anything
48   else (including stack auto variables) is untainted.  Care is needed when coding
49   to not copy untrusted data into untainted memory, as downstream taint-checks
50   would be avoided.
51
52   Internally we currently use malloc for nontainted pools, and mmap for tainted
53   pools.  The disparity is for speed of testing the taintedness of pointers;
54   because Linux appears to use distinct non-overlapping address allocations for
55   mmap vs. everything else, which means only two pointer-compares suffice for the
56   test.  Other OS' cannot use that optimisation, and a more lengthy test against
57   the limits of tainted-pool allcations has to be done.
58
59   Intermediate layers (eg. the string functions) can test for taint, and use this
60   for ensurinng that results have proper state.  For example the
61   string_vformat_trc() routing supporting the string_sprintf() interface will
62   recopy a string being built into a tainted allocation if it meets a %s for a
63   tainted argument.  Any intermediate-layer function that (can) return a new
64   allocation should behave this way; returning a tainted result if any tainted
65   content is used.  Intermediate-layer functions (eg. Ustrncpy) that modify
66   existing allocations fail if tainted data is written into an untainted area.
67   Users of functions that modify existing allocations should check if a tainted
68   source and an untainted destination is used, and fail instead (sprintf() being
69   the classic case).
70 */
71
72
73 #include "exim.h"
74 /* keep config.h before memcheck.h, for NVALGRIND */
75 #include "config.h"
76
77 #include <sys/mman.h>
78 #include "memcheck.h"
79
80
81 /* We need to know how to align blocks of data for general use. I'm not sure
82 how to get an alignment factor in general. In the current world, a value of 8
83 is probably right, and this is sizeof(double) on some systems and sizeof(void
84 *) on others, so take the larger of those. Since everything in this expression
85 is a constant, the compiler should optimize it to a simple constant wherever it
86 appears (I checked that gcc does do this). */
87
88 #define alignment \
89   (sizeof(void *) > sizeof(double) ? sizeof(void *) : sizeof(double))
90
91 /* store_reset() will not free the following block if the last used block has
92 less than this much left in it. */
93
94 #define STOREPOOL_MIN_SIZE 256
95
96 /* Structure describing the beginning of each big block. */
97
98 typedef struct storeblock {
99   struct storeblock *next;
100   size_t length;
101 } storeblock;
102
103 /* Just in case we find ourselves on a system where the structure above has a
104 length that is not a multiple of the alignment, set up a macro for the padded
105 length. */
106
107 #define ALIGNED_SIZEOF_STOREBLOCK \
108   (((sizeof(storeblock) + alignment - 1) / alignment) * alignment)
109
110 /* Size of block to get from malloc to carve up into smaller ones. This
111 must be a multiple of the alignment. We assume that 8192 is going to be
112 suitably aligned. */
113
114 #define STORE_BLOCK_SIZE (8192 - ALIGNED_SIZEOF_STOREBLOCK)
115
116 /* Variables holding data for the local pools of store. The current pool number
117 is held in store_pool, which is global so that it can be changed from outside.
118 Setting the initial length values to -1 forces a malloc for the first call,
119 even if the length is zero (which is used for getting a point to reset to). */
120
121 int store_pool = POOL_MAIN;
122
123 #define NPOOLS 6
124 static storeblock *chainbase[NPOOLS];
125 static storeblock *current_block[NPOOLS];
126 static void *next_yield[NPOOLS];
127 static int yield_length[NPOOLS] = { -1, -1, -1,  -1, -1, -1 };
128
129 /* The limits of the tainted pools.  Tracking these on new allocations enables
130 a fast is_tainted implementation. We assume the kernel only allocates mmaps using
131 one side or the other of data+heap, not both. */
132
133 void * tainted_base = (void *)-1;
134 void * tainted_top = (void *)0;
135
136 /* pool_malloc holds the amount of memory used by the store pools; this goes up
137 and down as store is reset or released. nonpool_malloc is the total got by
138 malloc from other calls; this doesn't go down because it is just freed by
139 pointer. */
140
141 static int pool_malloc;
142 static int nonpool_malloc;
143
144 /* This variable is set by store_get() to its yield, and by store_reset() to
145 NULL. This enables string_cat() to optimize its store handling for very long
146 strings. That's why the variable is global. */
147
148 void *store_last_get[NPOOLS];
149
150 /* These are purely for stats-gathering */
151
152 static int nbytes[NPOOLS];      /* current bytes allocated */
153 static int maxbytes[NPOOLS];    /* max number reached */
154 static int nblocks[NPOOLS];     /* current number of blocks allocated */
155 static int maxblocks[NPOOLS];
156 static int n_nonpool_blocks;    /* current number of direct store_malloc() blocks */
157 static int max_nonpool_blocks;
158 static int max_pool_malloc;     /* max value for pool_malloc */
159 static int max_nonpool_malloc;  /* max value for nonpool_malloc */
160
161
162 #ifndef COMPILE_UTILITY
163 static const uschar * pooluse[NPOOLS] = {
164 [POOL_MAIN] =           US"main",
165 [POOL_PERM] =           US"perm",
166 [POOL_SEARCH] =         US"search",
167 [POOL_TAINT_MAIN] =     US"main",
168 [POOL_TAINT_PERM] =     US"perm",
169 [POOL_TAINT_SEARCH] =   US"search",
170 };
171 static const uschar * poolclass[NPOOLS] = {
172 [POOL_MAIN] =           US"untainted",
173 [POOL_PERM] =           US"untainted",
174 [POOL_SEARCH] =         US"untainted",
175 [POOL_TAINT_MAIN] =     US"tainted",
176 [POOL_TAINT_PERM] =     US"tainted",
177 [POOL_TAINT_SEARCH] =   US"tainted",
178 };
179 #endif
180
181
182 static void * store_mmap(int, const char *, int);
183 static void * internal_store_malloc(int, const char *, int);
184 static void   internal_untainted_free(void *, const char *, int linenumber);
185 static void   internal_tainted_free(storeblock *, const char *, int linenumber);
186
187 /******************************************************************************/
188
189 #ifndef TAINT_CHECK_FAST
190 /* Test if a pointer refers to tainted memory.
191
192 Slower version check, for use when platform intermixes malloc and mmap area
193 addresses. Test against the current-block of all tainted pools first, then all
194 blocks of all tainted pools.
195
196 Return: TRUE iff tainted
197 */
198
199 BOOL
200 is_tainted_fn(const void * p)
201 {
202 storeblock * b;
203 int pool;
204
205 for (pool = POOL_TAINT_BASE; pool < nelem(chainbase); pool++)
206   if ((b = current_block[pool]))
207     {
208     char * bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
209     if (CS p >= bc && CS p <= bc + b->length) return TRUE;
210     }
211
212 for (pool = POOL_TAINT_BASE; pool < nelem(chainbase); pool++)
213   for (b = chainbase[pool]; b; b = b->next)
214     {
215     char * bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
216     if (CS p >= bc && CS p <= bc + b->length) return TRUE;
217     }
218 return FALSE;
219 }
220 #endif
221
222
223 void
224 die_tainted(const uschar * msg, const uschar * func, int line)
225 {
226 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Taint mismatch, %s: %s %d\n",
227         msg, func, line);
228 }
229
230
231 /*************************************************
232 *       Get a block from the current pool        *
233 *************************************************/
234
235 /* Running out of store is a total disaster. This function is called via the
236 macro store_get(). It passes back a block of store within the current big
237 block, getting a new one if necessary. The address is saved in
238 store_last_was_get.
239
240 Arguments:
241   size        amount wanted, bytes
242   tainted     class: set to true for untrusted data (eg. from smtp input)
243   func        function from which called
244   linenumber  line number in source file
245
246 Returns:      pointer to store (panic on malloc failure)
247 */
248
249 void *
250 store_get_3(int size, BOOL tainted, const char *func, int linenumber)
251 {
252 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
253
254 /* Round up the size to a multiple of the alignment. Although this looks a
255 messy statement, because "alignment" is a constant expression, the compiler can
256 do a reasonable job of optimizing, especially if the value of "alignment" is a
257 power of two. I checked this with -O2, and gcc did very well, compiling it to 4
258 instructions on a Sparc (alignment = 8). */
259
260 if (size % alignment != 0) size += alignment - (size % alignment);
261
262 /* If there isn't room in the current block, get a new one. The minimum
263 size is STORE_BLOCK_SIZE, and we would expect this to be the norm, since
264 these functions are mostly called for small amounts of store. */
265
266 if (size > yield_length[pool])
267   {
268   int length = size <= STORE_BLOCK_SIZE ? STORE_BLOCK_SIZE : size;
269   int mlength = length + ALIGNED_SIZEOF_STOREBLOCK;
270   storeblock * newblock;
271
272   /* Sometimes store_reset() may leave a block for us; check if we can use it */
273
274   if (  (newblock = current_block[pool])
275      && (newblock = newblock->next)
276      && newblock->length < length
277      )
278     {
279     /* Give up on this block, because it's too small */
280     nblocks[pool]--;
281     if (pool < POOL_TAINT_BASE)
282       internal_untainted_free(newblock, func, linenumber);
283     else
284       internal_tainted_free(newblock, func, linenumber);
285     newblock = NULL;
286     }
287
288   /* If there was no free block, get a new one */
289
290   if (!newblock)
291     {
292     if ((nbytes[pool] += mlength) > maxbytes[pool])
293       maxbytes[pool] = nbytes[pool];
294     if ((pool_malloc += mlength) > max_pool_malloc)     /* Used in pools */
295       max_pool_malloc = pool_malloc;
296     nonpool_malloc -= mlength;                  /* Exclude from overall total */
297     if (++nblocks[pool] > maxblocks[pool])
298       maxblocks[pool] = nblocks[pool];
299
300     newblock = tainted
301       ? store_mmap(mlength, func, linenumber)
302       : internal_store_malloc(mlength, func, linenumber);
303     newblock->next = NULL;
304     newblock->length = length;
305
306     if (!chainbase[pool])
307       chainbase[pool] = newblock;
308     else
309       current_block[pool]->next = newblock;
310     }
311
312   current_block[pool] = newblock;
313   yield_length[pool] = newblock->length;
314   next_yield[pool] =
315     (void *)(CS current_block[pool] + ALIGNED_SIZEOF_STOREBLOCK);
316   (void) VALGRIND_MAKE_MEM_NOACCESS(next_yield[pool], yield_length[pool]);
317   }
318
319 /* There's (now) enough room in the current block; the yield is the next
320 pointer. */
321
322 store_last_get[pool] = next_yield[pool];
323
324 /* Cut out the debugging stuff for utilities, but stop picky compilers from
325 giving warnings. */
326
327 #ifdef COMPILE_UTILITY
328 func = func;
329 linenumber = linenumber;
330 #else
331 DEBUG(D_memory)
332   debug_printf("---%d Get %6p %5d %-14s %4d\n", pool,
333     store_last_get[pool], size, func, linenumber);
334 #endif  /* COMPILE_UTILITY */
335
336 (void) VALGRIND_MAKE_MEM_UNDEFINED(store_last_get[pool], size);
337 /* Update next pointer and number of bytes left in the current block. */
338
339 next_yield[pool] = (void *)(CS next_yield[pool] + size);
340 yield_length[pool] -= size;
341 return store_last_get[pool];
342 }
343
344
345
346 /*************************************************
347 *       Get a block from the PERM pool           *
348 *************************************************/
349
350 /* This is just a convenience function, useful when just a single block is to
351 be obtained.
352
353 Arguments:
354   size        amount wanted
355   func        function from which called
356   linenumber  line number in source file
357
358 Returns:      pointer to store (panic on malloc failure)
359 */
360
361 void *
362 store_get_perm_3(int size, BOOL tainted, const char *func, int linenumber)
363 {
364 void *yield;
365 int old_pool = store_pool;
366 store_pool = POOL_PERM;
367 yield = store_get_3(size, tainted, func, linenumber);
368 store_pool = old_pool;
369 return yield;
370 }
371
372
373
374 /*************************************************
375 *      Extend a block if it is at the top        *
376 *************************************************/
377
378 /* While reading strings of unknown length, it is often the case that the
379 string is being read into the block at the top of the stack. If it needs to be
380 extended, it is more efficient just to extend within the top block rather than
381 allocate a new block and then have to copy the data. This function is provided
382 for the use of string_cat(), but of course can be used elsewhere too.
383 The block itself is not expanded; only the top allocation from it.
384
385 Arguments:
386   ptr        pointer to store block
387   oldsize    current size of the block, as requested by user
388   newsize    new size required
389   func       function from which called
390   linenumber line number in source file
391
392 Returns:     TRUE if the block is at the top of the stack and has been
393              extended; FALSE if it isn't at the top of the stack, or cannot
394              be extended
395 */
396
397 BOOL
398 store_extend_3(void *ptr, BOOL tainted, int oldsize, int newsize,
399    const char *func, int linenumber)
400 {
401 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
402 int inc = newsize - oldsize;
403 int rounded_oldsize = oldsize;
404
405 /* Check that the block being extended was already of the required taint status;
406 refuse to extend if not. */
407
408 if (is_tainted(ptr) != tainted)
409   return FALSE;
410
411 if (rounded_oldsize % alignment != 0)
412   rounded_oldsize += alignment - (rounded_oldsize % alignment);
413
414 if (CS ptr + rounded_oldsize != CS (next_yield[pool]) ||
415     inc > yield_length[pool] + rounded_oldsize - oldsize)
416   return FALSE;
417
418 /* Cut out the debugging stuff for utilities, but stop picky compilers from
419 giving warnings. */
420
421 #ifdef COMPILE_UTILITY
422 func = func;
423 linenumber = linenumber;
424 #else
425 DEBUG(D_memory)
426   debug_printf("---%d Ext %6p %5d %-14s %4d\n", pool, ptr, newsize,
427     func, linenumber);
428 #endif  /* COMPILE_UTILITY */
429
430 if (newsize % alignment != 0) newsize += alignment - (newsize % alignment);
431 next_yield[pool] = CS ptr + newsize;
432 yield_length[pool] -= newsize - rounded_oldsize;
433 (void) VALGRIND_MAKE_MEM_UNDEFINED(ptr + oldsize, inc);
434 return TRUE;
435 }
436
437
438
439
440 /*************************************************
441 *    Back up to a previous point on the stack    *
442 *************************************************/
443
444 /* This function resets the next pointer, freeing any subsequent whole blocks
445 that are now unused. Call with a cookie obtained from store_mark() only; do
446 not call with a pointer returned by store_get().  Both the untainted and tainted
447 pools corresposding to store_pool are reset.
448
449 Arguments:
450   r           place to back up to
451   func        function from which called
452   linenumber  line number in source file
453
454 Returns:      nothing
455 */
456
457 static void
458 internal_store_reset(void * ptr, int pool, const char *func, int linenumber)
459 {
460 storeblock * bb;
461 storeblock * b = current_block[pool];
462 char * bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
463 int newlength, count;
464 #ifndef COMPILE_UTILITY
465 int oldmalloc = pool_malloc;
466 #endif
467
468 /* Last store operation was not a get */
469
470 store_last_get[pool] = NULL;
471
472 /* See if the place is in the current block - as it often will be. Otherwise,
473 search for the block in which it lies. */
474
475 if (CS ptr < bc || CS ptr > bc + b->length)
476   {
477   for (b = chainbase[pool]; b; b = b->next)
478     {
479     bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
480     if (CS ptr >= bc && CS ptr <= bc + b->length) break;
481     }
482   if (!b)
483     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal error: store_reset(%p) "
484       "failed: pool=%d %-14s %4d", ptr, pool, func, linenumber);
485   }
486
487 /* Back up, rounding to the alignment if necessary. When testing, flatten
488 the released memory. */
489
490 newlength = bc + b->length - CS ptr;
491 #ifndef COMPILE_UTILITY
492 if (debug_store)
493   {
494   assert_no_variables(ptr, newlength, func, linenumber);
495   if (f.running_in_test_harness)
496     {
497     (void) VALGRIND_MAKE_MEM_DEFINED(ptr, newlength);
498     memset(ptr, 0xF0, newlength);
499     }
500   }
501 #endif
502 (void) VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength);
503 next_yield[pool] = CS ptr + (newlength % alignment);
504 count = yield_length[pool];
505 count = (yield_length[pool] = newlength - (newlength % alignment)) - count;
506 current_block[pool] = b;
507
508 /* Free any subsequent block. Do NOT free the first
509 successor, if our current block has less than 256 bytes left. This should
510 prevent us from flapping memory. However, keep this block only when it has
511 the default size. */
512
513 if (  yield_length[pool] < STOREPOOL_MIN_SIZE
514    && b->next
515    && b->next->length == STORE_BLOCK_SIZE)
516   {
517   b = b->next;
518 #ifndef COMPILE_UTILITY
519   if (debug_store)
520     assert_no_variables(b, b->length + ALIGNED_SIZEOF_STOREBLOCK,
521                         func, linenumber);
522 #endif
523   (void) VALGRIND_MAKE_MEM_NOACCESS(CS b + ALIGNED_SIZEOF_STOREBLOCK,
524                 b->length - ALIGNED_SIZEOF_STOREBLOCK);
525   }
526
527 bb = b->next;
528 b->next = NULL;
529
530 while ((b = bb))
531   {
532   int siz = b->length + ALIGNED_SIZEOF_STOREBLOCK;
533 #ifndef COMPILE_UTILITY
534   if (debug_store)
535     assert_no_variables(b, b->length + ALIGNED_SIZEOF_STOREBLOCK,
536                         func, linenumber);
537 #endif
538   bb = bb->next;
539   nbytes[pool] -= siz;
540   pool_malloc -= siz;
541   nblocks[pool]--;
542   if (pool < POOL_TAINT_BASE)
543     internal_untainted_free(b, func, linenumber);
544   else
545     internal_tainted_free(b, func, linenumber);
546   }
547
548 /* Cut out the debugging stuff for utilities, but stop picky compilers from
549 giving warnings. */
550
551 #ifdef COMPILE_UTILITY
552 func = func;
553 linenumber = linenumber;
554 #else
555 DEBUG(D_memory)
556   debug_printf("---%d Rst %6p %5d %-14s %4d %d\n", pool, ptr,
557     count + oldmalloc - pool_malloc,
558     func, linenumber, pool_malloc);
559 #endif  /* COMPILE_UTILITY */
560 }
561
562
563 rmark
564 store_reset_3(rmark r, int pool, const char *func, int linenumber)
565 {
566 void ** ptr = r;
567
568 if (pool >= POOL_TAINT_BASE)
569   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
570     "store_reset called for pool %d: %s %d\n", pool, func, linenumber);
571 if (!r)
572   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
573     "store_reset called with bad mark: %s %d\n", func, linenumber);
574
575 internal_store_reset(*ptr, pool + POOL_TAINT_BASE, func, linenumber);
576 internal_store_reset(ptr,  pool,                   func, linenumber);
577 return NULL;
578 }
579
580
581
582 /* Free tail-end unused allocation.  This lets us allocate a big chunk
583 early, for cases when we only discover later how much was really needed.
584
585 Can be called with a value from store_get(), or an offset after such.  Only
586 the tainted or untainted pool that serviced the store_get() will be affected.
587
588 This is mostly a cut-down version of internal_store_reset().
589 XXX needs rationalising
590 */
591
592 void
593 store_release_above_3(void *ptr, const char *func, int linenumber)
594 {
595 /* Search all pools' "current" blocks.  If it isn't one of those,
596 ignore it (it usually will be). */
597
598 for (int pool = 0; pool < nelem(current_block); pool++)
599   {
600   storeblock * b = current_block[pool];
601   char * bc;
602   int count, newlength;
603
604   if (!b)
605     continue;
606
607   bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
608   if (CS ptr < bc || CS ptr > bc + b->length)
609     continue;
610
611   /* Last store operation was not a get */
612
613   store_last_get[pool] = NULL;
614
615   /* Back up, rounding to the alignment if necessary. When testing, flatten
616   the released memory. */
617
618   newlength = bc + b->length - CS ptr;
619 #ifndef COMPILE_UTILITY
620   if (debug_store)
621     {
622     assert_no_variables(ptr, newlength, func, linenumber);
623     if (f.running_in_test_harness)
624       {
625       (void) VALGRIND_MAKE_MEM_DEFINED(ptr, newlength);
626       memset(ptr, 0xF0, newlength);
627       }
628     }
629 #endif
630   (void) VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength);
631   next_yield[pool] = CS ptr + (newlength % alignment);
632   count = yield_length[pool];
633   count = (yield_length[pool] = newlength - (newlength % alignment)) - count;
634
635   /* Cut out the debugging stuff for utilities, but stop picky compilers from
636   giving warnings. */
637
638 #ifdef COMPILE_UTILITY
639   func = func;
640   linenumber = linenumber;
641 #else
642   DEBUG(D_memory)
643     debug_printf("---%d Rel %6p %5d %-14s %4d %d\n", pool, ptr, count,
644       func, linenumber, pool_malloc);
645 #endif
646   return;
647   }
648 #ifndef COMPILE_UTILITY
649 DEBUG(D_memory)
650   debug_printf("non-last memory release try: %s %d\n", func, linenumber);
651 #endif
652 }
653
654
655
656 rmark
657 store_mark_3(const char *func, int linenumber)
658 {
659 void ** p;
660
661 if (store_pool >= POOL_TAINT_BASE)
662   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
663     "store_mark called for pool %d: %s %d\n", store_pool, func, linenumber);
664
665 /* Stash a mark for the tainted-twin release, in the untainted twin. Return
666 a cookie (actually the address in the untainted pool) to the caller.
667 Reset uses the cookie to recover the t-mark, winds back the tainted pool with it
668 and winds back the untainted pool with the cookie. */
669
670 p = store_get_3(sizeof(void *), FALSE, func, linenumber);
671 *p = store_get_3(0, TRUE, func, linenumber);
672 return p;
673 }
674
675
676
677
678 /************************************************
679 *             Release store                     *
680 ************************************************/
681
682 /* This function checks that the pointer it is given is the first thing in a
683 block, and if so, releases that block.
684
685 Arguments:
686   block       block of store to consider
687   func        function from which called
688   linenumber  line number in source file
689
690 Returns:      nothing
691 */
692
693 static void
694 store_release_3(void * block, int pool, const char * func, int linenumber)
695 {
696 /* It will never be the first block, so no need to check that. */
697
698 for (storeblock * b = chainbase[pool]; b; b = b->next)
699   {
700   storeblock * bb = b->next;
701   if (bb && CS block == CS bb + ALIGNED_SIZEOF_STOREBLOCK)
702     {
703     int siz = bb->length + ALIGNED_SIZEOF_STOREBLOCK;
704     b->next = bb->next;
705     nbytes[pool] -= siz;
706     pool_malloc -= siz;
707     nblocks[pool]--;
708
709     /* Cut out the debugging stuff for utilities, but stop picky compilers
710     from giving warnings. */
711
712 #ifdef COMPILE_UTILITY
713     func = func;
714     linenumber = linenumber;
715 #else
716     DEBUG(D_memory)
717       debug_printf("-Release %6p %-20s %4d %d\n", (void *)bb, func,
718         linenumber, pool_malloc);
719
720     if (f.running_in_test_harness)
721       memset(bb, 0xF0, bb->length+ALIGNED_SIZEOF_STOREBLOCK);
722 #endif  /* COMPILE_UTILITY */
723
724     free(bb);
725     return;
726     }
727   }
728 }
729
730
731 /************************************************
732 *             Move store                        *
733 ************************************************/
734
735 /* Allocate a new block big enough to expend to the given size and
736 copy the current data into it.  Free the old one if possible.
737
738 This function is specifically provided for use when reading very
739 long strings, e.g. header lines. When the string gets longer than a
740 complete block, it gets copied to a new block. It is helpful to free
741 the old block iff the previous copy of the string is at its start,
742 and therefore the only thing in it. Otherwise, for very long strings,
743 dead store can pile up somewhat disastrously. This function checks that
744 the pointer it is given is the first thing in a block, and that nothing
745 has been allocated since. If so, releases that block.
746
747 Arguments:
748   block
749   newsize
750   len
751
752 Returns:        new location of data
753 */
754
755 void *
756 store_newblock_3(void * block, BOOL tainted, int newsize, int len,
757   const char * func, int linenumber)
758 {
759 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
760 BOOL release_ok = !tainted && store_last_get[pool] == block;
761 uschar * newtext;
762
763 #ifndef MACRO_PREDEF
764 if (is_tainted(block) != tainted)
765   die_tainted(US"store_newblock", CUS func, linenumber);
766 #endif
767
768 newtext = store_get(newsize, tainted);
769 memcpy(newtext, block, len);
770 if (release_ok) store_release_3(block, pool, func, linenumber);
771 return (void *)newtext;
772 }
773
774
775
776
777 /******************************************************************************/
778 static void *
779 store_alloc_tail(void * yield, int size, const char * func, int line,
780   const uschar * type)
781 {
782 if ((nonpool_malloc += size) > max_nonpool_malloc)
783   max_nonpool_malloc = nonpool_malloc;
784
785 /* Cut out the debugging stuff for utilities, but stop picky compilers from
786 giving warnings. */
787
788 #ifdef COMPILE_UTILITY
789 func = func; line = line; type = type;
790 #else
791
792 /* If running in test harness, spend time making sure all the new store
793 is not filled with zeros so as to catch problems. */
794
795 if (f.running_in_test_harness)
796   memset(yield, 0xF0, (size_t)size);
797 DEBUG(D_memory) debug_printf("--%6s %6p %5d bytes\t%-14s %4d\tpool %5d  nonpool %5d\n",
798   type, yield, size, func, line, pool_malloc, nonpool_malloc);
799 #endif  /* COMPILE_UTILITY */
800
801 return yield;
802 }
803
804 /*************************************************
805 *                Mmap store                      *
806 *************************************************/
807
808 static void *
809 store_mmap(int size, const char * func, int line)
810 {
811 void * yield, * top;
812
813 if (size < 16) size = 16;
814
815 if (!(yield = mmap(NULL, (size_t)size,
816                   PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)))
817   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to mmap %d bytes of memory: "
818     "called from line %d of %s", size, line, func);
819
820 if (yield < tainted_base) tainted_base = yield;
821 if ((top = US yield + size) > tainted_top) tainted_top = top;
822
823 return store_alloc_tail(yield, size, func, line, US"Mmap");
824 }
825
826 /*************************************************
827 *                Malloc store                    *
828 *************************************************/
829
830 /* Running out of store is a total disaster for exim. Some malloc functions
831 do not run happily on very small sizes, nor do they document this fact. This
832 function is called via the macro store_malloc().
833
834 Arguments:
835   size        amount of store wanted
836   func        function from which called
837   linenumber  line number in source file
838
839 Returns:      pointer to gotten store (panic on failure)
840 */
841
842 static void *
843 internal_store_malloc(int size, const char *func, int linenumber)
844 {
845 void * yield;
846
847 if (size < 16) size = 16;
848
849 if (!(yield = malloc((size_t)size)))
850   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to malloc %d bytes of memory: "
851     "called from line %d in %s", size, linenumber, func);
852
853 return store_alloc_tail(yield, size, func, linenumber, US"Malloc");
854 }
855
856 void *
857 store_malloc_3(int size, const char *func, int linenumber)
858 {
859 if (n_nonpool_blocks++ > max_nonpool_blocks)
860   max_nonpool_blocks = n_nonpool_blocks;
861 return internal_store_malloc(size, func, linenumber);
862 }
863
864
865 /************************************************
866 *             Free store                        *
867 ************************************************/
868
869 /* This function is called by the macro store_free().
870
871 Arguments:
872   block       block of store to free
873   func        function from which called
874   linenumber  line number in source file
875
876 Returns:      nothing
877 */
878
879 static void
880 internal_untainted_free(void * block, const char * func, int linenumber)
881 {
882 #ifdef COMPILE_UTILITY
883 func = func;
884 linenumber = linenumber;
885 #else
886 DEBUG(D_memory)
887   debug_printf("----Free %6p %-20s %4d\n", block, func, linenumber);
888 #endif  /* COMPILE_UTILITY */
889 free(block);
890 }
891
892 void
893 store_free_3(void * block, const char * func, int linenumber)
894 {
895 n_nonpool_blocks--;
896 internal_untainted_free(block, func, linenumber);
897 }
898
899 /******************************************************************************/
900 static void
901 internal_tainted_free(storeblock * block, const char * func, int linenumber)
902 {
903 #ifdef COMPILE_UTILITY
904 func = func;
905 linenumber = linenumber;
906 #else
907 DEBUG(D_memory)
908   debug_printf("---Unmap %6p %-20s %4d\n", block, func, linenumber);
909 #endif
910 munmap((void *)block, block->length + ALIGNED_SIZEOF_STOREBLOCK);
911 }
912
913 /******************************************************************************/
914 /* Stats output on process exit */
915 void
916 store_exit(void)
917 {
918 #ifndef COMPILE_UTILITY
919 DEBUG(D_memory)
920  {
921  debug_printf("----Exit nonpool max: %3d kB in %d blocks\n",
922   (max_nonpool_malloc+1023)/1024, max_nonpool_blocks);
923  debug_printf("----Exit npools  max: %3d kB\n", max_pool_malloc/1024);
924  for (int i = 0; i < NPOOLS; i++)
925   debug_printf("----Exit  pool %d max: %3d kB in %d blocks\t%s %s\n",
926     i, maxbytes[i]/1024, maxblocks[i], poolclass[i], pooluse[i]);
927  }
928 #endif
929 }
930
931 /* End of store.c */