3192b9774f35e3c30e168be9b8724c39a4849eb8
[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 /* Test if a pointer refers to tainted memory.
190
191 Slower version check, for use when platform intermixes malloc and mmap area
192 addresses. Test against the current-block of all tainted pools first, then all
193 blocks of all tainted pools.
194
195 Return: TRUE iff tainted
196 */
197
198 BOOL
199 is_tainted_fn(const void * p)
200 {
201 storeblock * b;
202
203 for (int pool = POOL_TAINT_BASE; pool < nelem(chainbase); pool++)
204   if ((b = current_block[pool]))
205     {
206     uschar * bc = US b + ALIGNED_SIZEOF_STOREBLOCK;
207     if (US p >= bc && US p <= bc + b->length) return TRUE;
208     }
209
210 for (int pool = POOL_TAINT_BASE; pool < nelem(chainbase); pool++)
211   for (b = chainbase[pool]; b; b = b->next)
212     {
213     uschar * bc = US b + ALIGNED_SIZEOF_STOREBLOCK;
214     if (US p >= bc && US p <= bc + b->length) return TRUE;
215     }
216 return FALSE;
217 }
218
219
220 void
221 die_tainted(const uschar * msg, const uschar * func, int line)
222 {
223 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Taint mismatch, %s: %s %d\n",
224         msg, func, line);
225 }
226
227 static void
228 use_slow_taint_check(const uschar * why)
229 {
230 #ifndef COMPILE_UTILITY
231 DEBUG(D_any)
232   debug_printf("switching to slow-mode taint checking (after %s) "
233               "taint bounds %p %p\n", why, tainted_base, tainted_top);
234 #endif
235 f.taint_check_slow = TRUE;
236 }
237
238 /* If the creation of a new tainted region results in any of the
239 untainted regions appearing to be tainted, using the fast-mode test,
240 we need to switch to safe-but-slow mode. */
241
242 static void
243 verify_all_untainted(void)
244 {
245 for (int pool = 0; pool < POOL_TAINT_BASE; pool++)
246   for (storeblock * b = chainbase[pool]; b; b = b->next)
247     {
248     uschar * bc = US b + ALIGNED_SIZEOF_STOREBLOCK;
249     if (is_tainted(bc))
250       {
251       use_slow_taint_check(US"mmap");
252       return;
253       }
254     }
255 }
256
257
258
259 /*************************************************
260 *       Get a block from the current pool        *
261 *************************************************/
262
263 /* Running out of store is a total disaster. This function is called via the
264 macro store_get(). It passes back a block of store within the current big
265 block, getting a new one if necessary. The address is saved in
266 store_last_was_get.
267
268 Arguments:
269   size        amount wanted, bytes
270   tainted     class: set to true for untrusted data (eg. from smtp input)
271   func        function from which called
272   linenumber  line number in source file
273
274 Returns:      pointer to store (panic on malloc failure)
275 */
276
277 void *
278 store_get_3(int size, BOOL tainted, const char *func, int linenumber)
279 {
280 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
281
282 /* Round up the size to a multiple of the alignment. Although this looks a
283 messy statement, because "alignment" is a constant expression, the compiler can
284 do a reasonable job of optimizing, especially if the value of "alignment" is a
285 power of two. I checked this with -O2, and gcc did very well, compiling it to 4
286 instructions on a Sparc (alignment = 8). */
287
288 if (size % alignment != 0) size += alignment - (size % alignment);
289
290 /* If there isn't room in the current block, get a new one. The minimum
291 size is STORE_BLOCK_SIZE, and we would expect this to be the norm, since
292 these functions are mostly called for small amounts of store. */
293
294 if (size > yield_length[pool])
295   {
296   int length = size <= STORE_BLOCK_SIZE ? STORE_BLOCK_SIZE : size;
297   int mlength = length + ALIGNED_SIZEOF_STOREBLOCK;
298   storeblock * newblock;
299
300   /* Sometimes store_reset() may leave a block for us; check if we can use it */
301
302   if (  (newblock = current_block[pool])
303      && (newblock = newblock->next)
304      && newblock->length < length
305      )
306     {
307     /* Give up on this block, because it's too small */
308     nblocks[pool]--;
309     if (pool < POOL_TAINT_BASE)
310       internal_untainted_free(newblock, func, linenumber);
311     else
312       internal_tainted_free(newblock, func, linenumber);
313     newblock = NULL;
314     }
315
316   /* If there was no free block, get a new one */
317
318   if (!newblock)
319     {
320     if ((nbytes[pool] += mlength) > maxbytes[pool])
321       maxbytes[pool] = nbytes[pool];
322     if ((pool_malloc += mlength) > max_pool_malloc)     /* Used in pools */
323       max_pool_malloc = pool_malloc;
324     nonpool_malloc -= mlength;                  /* Exclude from overall total */
325     if (++nblocks[pool] > maxblocks[pool])
326       maxblocks[pool] = nblocks[pool];
327
328     newblock = tainted
329       ? store_mmap(mlength, func, linenumber)
330       : internal_store_malloc(mlength, func, linenumber);
331     newblock->next = NULL;
332     newblock->length = length;
333
334     if (!chainbase[pool])
335       chainbase[pool] = newblock;
336     else
337       current_block[pool]->next = newblock;
338     }
339
340   current_block[pool] = newblock;
341   yield_length[pool] = newblock->length;
342   next_yield[pool] =
343     (void *)(CS current_block[pool] + ALIGNED_SIZEOF_STOREBLOCK);
344   (void) VALGRIND_MAKE_MEM_NOACCESS(next_yield[pool], yield_length[pool]);
345   }
346
347 /* There's (now) enough room in the current block; the yield is the next
348 pointer. */
349
350 store_last_get[pool] = next_yield[pool];
351
352 /* Cut out the debugging stuff for utilities, but stop picky compilers from
353 giving warnings. */
354
355 #ifdef COMPILE_UTILITY
356 func = func;
357 linenumber = linenumber;
358 #else
359 DEBUG(D_memory)
360   debug_printf("---%d Get %6p %5d %-14s %4d\n", pool,
361     store_last_get[pool], size, func, linenumber);
362 #endif  /* COMPILE_UTILITY */
363
364 (void) VALGRIND_MAKE_MEM_UNDEFINED(store_last_get[pool], size);
365 /* Update next pointer and number of bytes left in the current block. */
366
367 next_yield[pool] = (void *)(CS next_yield[pool] + size);
368 yield_length[pool] -= size;
369 return store_last_get[pool];
370 }
371
372
373
374 /*************************************************
375 *       Get a block from the PERM pool           *
376 *************************************************/
377
378 /* This is just a convenience function, useful when just a single block is to
379 be obtained.
380
381 Arguments:
382   size        amount wanted
383   func        function from which called
384   linenumber  line number in source file
385
386 Returns:      pointer to store (panic on malloc failure)
387 */
388
389 void *
390 store_get_perm_3(int size, BOOL tainted, const char *func, int linenumber)
391 {
392 void *yield;
393 int old_pool = store_pool;
394 store_pool = POOL_PERM;
395 yield = store_get_3(size, tainted, func, linenumber);
396 store_pool = old_pool;
397 return yield;
398 }
399
400
401
402 /*************************************************
403 *      Extend a block if it is at the top        *
404 *************************************************/
405
406 /* While reading strings of unknown length, it is often the case that the
407 string is being read into the block at the top of the stack. If it needs to be
408 extended, it is more efficient just to extend within the top block rather than
409 allocate a new block and then have to copy the data. This function is provided
410 for the use of string_cat(), but of course can be used elsewhere too.
411 The block itself is not expanded; only the top allocation from it.
412
413 Arguments:
414   ptr        pointer to store block
415   oldsize    current size of the block, as requested by user
416   newsize    new size required
417   func       function from which called
418   linenumber line number in source file
419
420 Returns:     TRUE if the block is at the top of the stack and has been
421              extended; FALSE if it isn't at the top of the stack, or cannot
422              be extended
423 */
424
425 BOOL
426 store_extend_3(void *ptr, BOOL tainted, int oldsize, int newsize,
427    const char *func, int linenumber)
428 {
429 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
430 int inc = newsize - oldsize;
431 int rounded_oldsize = oldsize;
432
433 /* Check that the block being extended was already of the required taint status;
434 refuse to extend if not. */
435
436 if (is_tainted(ptr) != tainted)
437   return FALSE;
438
439 if (rounded_oldsize % alignment != 0)
440   rounded_oldsize += alignment - (rounded_oldsize % alignment);
441
442 if (CS ptr + rounded_oldsize != CS (next_yield[pool]) ||
443     inc > yield_length[pool] + rounded_oldsize - oldsize)
444   return FALSE;
445
446 /* Cut out the debugging stuff for utilities, but stop picky compilers from
447 giving warnings. */
448
449 #ifdef COMPILE_UTILITY
450 func = func;
451 linenumber = linenumber;
452 #else
453 DEBUG(D_memory)
454   debug_printf("---%d Ext %6p %5d %-14s %4d\n", pool, ptr, newsize,
455     func, linenumber);
456 #endif  /* COMPILE_UTILITY */
457
458 if (newsize % alignment != 0) newsize += alignment - (newsize % alignment);
459 next_yield[pool] = CS ptr + newsize;
460 yield_length[pool] -= newsize - rounded_oldsize;
461 (void) VALGRIND_MAKE_MEM_UNDEFINED(ptr + oldsize, inc);
462 return TRUE;
463 }
464
465
466
467
468 /*************************************************
469 *    Back up to a previous point on the stack    *
470 *************************************************/
471
472 /* This function resets the next pointer, freeing any subsequent whole blocks
473 that are now unused. Call with a cookie obtained from store_mark() only; do
474 not call with a pointer returned by store_get().  Both the untainted and tainted
475 pools corresposding to store_pool are reset.
476
477 Arguments:
478   r           place to back up to
479   func        function from which called
480   linenumber  line number in source file
481
482 Returns:      nothing
483 */
484
485 static void
486 internal_store_reset(void * ptr, int pool, const char *func, int linenumber)
487 {
488 storeblock * bb;
489 storeblock * b = current_block[pool];
490 char * bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
491 int newlength, count;
492 #ifndef COMPILE_UTILITY
493 int oldmalloc = pool_malloc;
494 #endif
495
496 /* Last store operation was not a get */
497
498 store_last_get[pool] = NULL;
499
500 /* See if the place is in the current block - as it often will be. Otherwise,
501 search for the block in which it lies. */
502
503 if (CS ptr < bc || CS ptr > bc + b->length)
504   {
505   for (b = chainbase[pool]; b; b = b->next)
506     {
507     bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
508     if (CS ptr >= bc && CS ptr <= bc + b->length) break;
509     }
510   if (!b)
511     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal error: store_reset(%p) "
512       "failed: pool=%d %-14s %4d", ptr, pool, func, linenumber);
513   }
514
515 /* Back up, rounding to the alignment if necessary. When testing, flatten
516 the released memory. */
517
518 newlength = bc + b->length - CS ptr;
519 #ifndef COMPILE_UTILITY
520 if (debug_store)
521   {
522   assert_no_variables(ptr, newlength, func, linenumber);
523   if (f.running_in_test_harness)
524     {
525     (void) VALGRIND_MAKE_MEM_DEFINED(ptr, newlength);
526     memset(ptr, 0xF0, newlength);
527     }
528   }
529 #endif
530 (void) VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength);
531 next_yield[pool] = CS ptr + (newlength % alignment);
532 count = yield_length[pool];
533 count = (yield_length[pool] = newlength - (newlength % alignment)) - count;
534 current_block[pool] = b;
535
536 /* Free any subsequent block. Do NOT free the first
537 successor, if our current block has less than 256 bytes left. This should
538 prevent us from flapping memory. However, keep this block only when it has
539 the default size. */
540
541 if (  yield_length[pool] < STOREPOOL_MIN_SIZE
542    && b->next
543    && b->next->length == STORE_BLOCK_SIZE)
544   {
545   b = b->next;
546 #ifndef COMPILE_UTILITY
547   if (debug_store)
548     assert_no_variables(b, b->length + ALIGNED_SIZEOF_STOREBLOCK,
549                         func, linenumber);
550 #endif
551   (void) VALGRIND_MAKE_MEM_NOACCESS(CS b + ALIGNED_SIZEOF_STOREBLOCK,
552                 b->length - ALIGNED_SIZEOF_STOREBLOCK);
553   }
554
555 bb = b->next;
556 b->next = NULL;
557
558 while ((b = bb))
559   {
560   int siz = b->length + ALIGNED_SIZEOF_STOREBLOCK;
561 #ifndef COMPILE_UTILITY
562   if (debug_store)
563     assert_no_variables(b, b->length + ALIGNED_SIZEOF_STOREBLOCK,
564                         func, linenumber);
565 #endif
566   bb = bb->next;
567   nbytes[pool] -= siz;
568   pool_malloc -= siz;
569   nblocks[pool]--;
570   if (pool < POOL_TAINT_BASE)
571     internal_untainted_free(b, func, linenumber);
572   else
573     internal_tainted_free(b, func, linenumber);
574   }
575
576 /* Cut out the debugging stuff for utilities, but stop picky compilers from
577 giving warnings. */
578
579 #ifdef COMPILE_UTILITY
580 func = func;
581 linenumber = linenumber;
582 #else
583 DEBUG(D_memory)
584   debug_printf("---%d Rst %6p %5d %-14s %4d %d\n", pool, ptr,
585     count + oldmalloc - pool_malloc,
586     func, linenumber, pool_malloc);
587 #endif  /* COMPILE_UTILITY */
588 }
589
590
591 rmark
592 store_reset_3(rmark r, int pool, const char *func, int linenumber)
593 {
594 void ** ptr = r;
595
596 if (pool >= POOL_TAINT_BASE)
597   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
598     "store_reset called for pool %d: %s %d\n", pool, func, linenumber);
599 if (!r)
600   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
601     "store_reset called with bad mark: %s %d\n", func, linenumber);
602
603 internal_store_reset(*ptr, pool + POOL_TAINT_BASE, func, linenumber);
604 internal_store_reset(ptr,  pool,                   func, linenumber);
605 return NULL;
606 }
607
608
609
610 /* Free tail-end unused allocation.  This lets us allocate a big chunk
611 early, for cases when we only discover later how much was really needed.
612
613 Can be called with a value from store_get(), or an offset after such.  Only
614 the tainted or untainted pool that serviced the store_get() will be affected.
615
616 This is mostly a cut-down version of internal_store_reset().
617 XXX needs rationalising
618 */
619
620 void
621 store_release_above_3(void *ptr, const char *func, int linenumber)
622 {
623 /* Search all pools' "current" blocks.  If it isn't one of those,
624 ignore it (it usually will be). */
625
626 for (int pool = 0; pool < nelem(current_block); pool++)
627   {
628   storeblock * b = current_block[pool];
629   char * bc;
630   int count, newlength;
631
632   if (!b)
633     continue;
634
635   bc = CS b + ALIGNED_SIZEOF_STOREBLOCK;
636   if (CS ptr < bc || CS ptr > bc + b->length)
637     continue;
638
639   /* Last store operation was not a get */
640
641   store_last_get[pool] = NULL;
642
643   /* Back up, rounding to the alignment if necessary. When testing, flatten
644   the released memory. */
645
646   newlength = bc + b->length - CS ptr;
647 #ifndef COMPILE_UTILITY
648   if (debug_store)
649     {
650     assert_no_variables(ptr, newlength, func, linenumber);
651     if (f.running_in_test_harness)
652       {
653       (void) VALGRIND_MAKE_MEM_DEFINED(ptr, newlength);
654       memset(ptr, 0xF0, newlength);
655       }
656     }
657 #endif
658   (void) VALGRIND_MAKE_MEM_NOACCESS(ptr, newlength);
659   next_yield[pool] = CS ptr + (newlength % alignment);
660   count = yield_length[pool];
661   count = (yield_length[pool] = newlength - (newlength % alignment)) - count;
662
663   /* Cut out the debugging stuff for utilities, but stop picky compilers from
664   giving warnings. */
665
666 #ifdef COMPILE_UTILITY
667   func = func;
668   linenumber = linenumber;
669 #else
670   DEBUG(D_memory)
671     debug_printf("---%d Rel %6p %5d %-14s %4d %d\n", pool, ptr, count,
672       func, linenumber, pool_malloc);
673 #endif
674   return;
675   }
676 #ifndef COMPILE_UTILITY
677 DEBUG(D_memory)
678   debug_printf("non-last memory release try: %s %d\n", func, linenumber);
679 #endif
680 }
681
682
683
684 rmark
685 store_mark_3(const char *func, int linenumber)
686 {
687 void ** p;
688
689 if (store_pool >= POOL_TAINT_BASE)
690   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
691     "store_mark called for pool %d: %s %d\n", store_pool, func, linenumber);
692
693 /* Stash a mark for the tainted-twin release, in the untainted twin. Return
694 a cookie (actually the address in the untainted pool) to the caller.
695 Reset uses the cookie to recover the t-mark, winds back the tainted pool with it
696 and winds back the untainted pool with the cookie. */
697
698 p = store_get_3(sizeof(void *), FALSE, func, linenumber);
699 *p = store_get_3(0, TRUE, func, linenumber);
700 return p;
701 }
702
703
704
705
706 /************************************************
707 *             Release store                     *
708 ************************************************/
709
710 /* This function checks that the pointer it is given is the first thing in a
711 block, and if so, releases that block.
712
713 Arguments:
714   block       block of store to consider
715   func        function from which called
716   linenumber  line number in source file
717
718 Returns:      nothing
719 */
720
721 static void
722 store_release_3(void * block, int pool, const char * func, int linenumber)
723 {
724 /* It will never be the first block, so no need to check that. */
725
726 for (storeblock * b = chainbase[pool]; b; b = b->next)
727   {
728   storeblock * bb = b->next;
729   if (bb && CS block == CS bb + ALIGNED_SIZEOF_STOREBLOCK)
730     {
731     int siz = bb->length + ALIGNED_SIZEOF_STOREBLOCK;
732     b->next = bb->next;
733     nbytes[pool] -= siz;
734     pool_malloc -= siz;
735     nblocks[pool]--;
736
737     /* Cut out the debugging stuff for utilities, but stop picky compilers
738     from giving warnings. */
739
740 #ifdef COMPILE_UTILITY
741     func = func;
742     linenumber = linenumber;
743 #else
744     DEBUG(D_memory)
745       debug_printf("-Release %6p %-20s %4d %d\n", (void *)bb, func,
746         linenumber, pool_malloc);
747
748     if (f.running_in_test_harness)
749       memset(bb, 0xF0, bb->length+ALIGNED_SIZEOF_STOREBLOCK);
750 #endif  /* COMPILE_UTILITY */
751
752     free(bb);
753     return;
754     }
755   }
756 }
757
758
759 /************************************************
760 *             Move store                        *
761 ************************************************/
762
763 /* Allocate a new block big enough to expend to the given size and
764 copy the current data into it.  Free the old one if possible.
765
766 This function is specifically provided for use when reading very
767 long strings, e.g. header lines. When the string gets longer than a
768 complete block, it gets copied to a new block. It is helpful to free
769 the old block iff the previous copy of the string is at its start,
770 and therefore the only thing in it. Otherwise, for very long strings,
771 dead store can pile up somewhat disastrously. This function checks that
772 the pointer it is given is the first thing in a block, and that nothing
773 has been allocated since. If so, releases that block.
774
775 Arguments:
776   block
777   newsize
778   len
779
780 Returns:        new location of data
781 */
782
783 void *
784 store_newblock_3(void * block, BOOL tainted, int newsize, int len,
785   const char * func, int linenumber)
786 {
787 int pool = tainted ? store_pool + POOL_TAINT_BASE : store_pool;
788 BOOL release_ok = !tainted && store_last_get[pool] == block;
789 uschar * newtext;
790
791 #if !defined(MACRO_PREDEF) && !defined(COMPILE_UTILITY)
792 if (is_tainted(block) != tainted)
793   die_tainted(US"store_newblock", CUS func, linenumber);
794 #endif
795
796 newtext = store_get(newsize, tainted);
797 memcpy(newtext, block, len);
798 if (release_ok) store_release_3(block, pool, func, linenumber);
799 return (void *)newtext;
800 }
801
802
803
804
805 /******************************************************************************/
806 static void *
807 store_alloc_tail(void * yield, int size, const char * func, int line,
808   const uschar * type)
809 {
810 if ((nonpool_malloc += size) > max_nonpool_malloc)
811   max_nonpool_malloc = nonpool_malloc;
812
813 /* Cut out the debugging stuff for utilities, but stop picky compilers from
814 giving warnings. */
815
816 #ifdef COMPILE_UTILITY
817 func = func; line = line; type = type;
818 #else
819
820 /* If running in test harness, spend time making sure all the new store
821 is not filled with zeros so as to catch problems. */
822
823 if (f.running_in_test_harness)
824   memset(yield, 0xF0, (size_t)size);
825 DEBUG(D_memory) debug_printf("--%6s %6p %5d bytes\t%-14s %4d\tpool %5d  nonpool %5d\n",
826   type, yield, size, func, line, pool_malloc, nonpool_malloc);
827 #endif  /* COMPILE_UTILITY */
828
829 return yield;
830 }
831
832 /*************************************************
833 *                Mmap store                      *
834 *************************************************/
835
836 static void *
837 store_mmap(int size, const char * func, int line)
838 {
839 void * yield, * top;
840
841 if (size < 16) size = 16;
842
843 if (!(yield = mmap(NULL, (size_t)size,
844                   PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)))
845   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to mmap %d bytes of memory: "
846     "called from line %d of %s", size, line, func);
847
848 if (yield < tainted_base) tainted_base = yield;
849 if ((top = US yield + size) > tainted_top) tainted_top = top;
850 if (!f.taint_check_slow) verify_all_untainted();
851
852 return store_alloc_tail(yield, size, func, line, US"Mmap");
853 }
854
855 /*************************************************
856 *                Malloc store                    *
857 *************************************************/
858
859 /* Running out of store is a total disaster for exim. Some malloc functions
860 do not run happily on very small sizes, nor do they document this fact. This
861 function is called via the macro store_malloc().
862
863 Arguments:
864   size        amount of store wanted
865   func        function from which called
866   linenumber  line number in source file
867
868 Returns:      pointer to gotten store (panic on failure)
869 */
870
871 static void *
872 internal_store_malloc(int size, const char *func, int linenumber)
873 {
874 void * yield;
875
876 if (size < 16) size = 16;
877
878 if (!(yield = malloc((size_t)size)))
879   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to malloc %d bytes of memory: "
880     "called from line %d in %s", size, linenumber, func);
881
882 /* If malloc ever returns apparently tainted memory, which glibc
883 malloc will as it uses mmap for larger requests, we must switch to
884 the slower checking for tainting (checking an address against all
885 the tainted pool block spans, rather than just the mmap span) */
886
887 if (!f.taint_check_slow && is_tainted(yield))
888   use_slow_taint_check(US"malloc");
889
890 return store_alloc_tail(yield, size, func, linenumber, US"Malloc");
891 }
892
893 void *
894 store_malloc_3(int size, const char *func, int linenumber)
895 {
896 if (n_nonpool_blocks++ > max_nonpool_blocks)
897   max_nonpool_blocks = n_nonpool_blocks;
898 return internal_store_malloc(size, func, linenumber);
899 }
900
901
902 /************************************************
903 *             Free store                        *
904 ************************************************/
905
906 /* This function is called by the macro store_free().
907
908 Arguments:
909   block       block of store to free
910   func        function from which called
911   linenumber  line number in source file
912
913 Returns:      nothing
914 */
915
916 static void
917 internal_untainted_free(void * block, const char * func, int linenumber)
918 {
919 #ifdef COMPILE_UTILITY
920 func = func;
921 linenumber = linenumber;
922 #else
923 DEBUG(D_memory)
924   debug_printf("----Free %6p %-20s %4d\n", block, func, linenumber);
925 #endif  /* COMPILE_UTILITY */
926 free(block);
927 }
928
929 void
930 store_free_3(void * block, const char * func, int linenumber)
931 {
932 n_nonpool_blocks--;
933 internal_untainted_free(block, func, linenumber);
934 }
935
936 /******************************************************************************/
937 static void
938 internal_tainted_free(storeblock * block, const char * func, int linenumber)
939 {
940 #ifdef COMPILE_UTILITY
941 func = func;
942 linenumber = linenumber;
943 #else
944 DEBUG(D_memory)
945   debug_printf("---Unmap %6p %-20s %4d\n", block, func, linenumber);
946 #endif
947 munmap((void *)block, block->length + ALIGNED_SIZEOF_STOREBLOCK);
948 }
949
950 /******************************************************************************/
951 /* Stats output on process exit */
952 void
953 store_exit(void)
954 {
955 #ifndef COMPILE_UTILITY
956 DEBUG(D_memory)
957  {
958  debug_printf("----Exit nonpool max: %3d kB in %d blocks\n",
959   (max_nonpool_malloc+1023)/1024, max_nonpool_blocks);
960  debug_printf("----Exit npools  max: %3d kB\n", max_pool_malloc/1024);
961  for (int i = 0; i < NPOOLS; i++)
962   debug_printf("----Exit  pool %d max: %3d kB in %d blocks\t%s %s\n",
963     i, maxbytes[i]/1024, maxblocks[i], poolclass[i], pooluse[i]);
964  }
965 #endif
966 }
967
968 /* End of store.c */