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