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