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