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