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