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