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 */