src/vppinfra/mem_dlmalloc.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vppinfra/format.h>
  17 #include <vppinfra/dlmalloc.h>
  18 #include <vppinfra/os.h>
  19 #include <vppinfra/lock.h>
  20 #include <vppinfra/hash.h>
  21 #include <vppinfra/elf_clib.h>
  22 #include <vppinfra/sanitizer.h>
  23
  24 typedef struct
  25 {
  26   /* Address of callers: outer first, inner last. */
  27   uword callers[12];
  28
  29   /* Count of allocations with this traceback. */
  30   u32 n_allocations;
  31
  32   /* Count of bytes allocated with this traceback. */
  33   u32 n_bytes;
  34
  35   /* Offset of this item */
  36   uword offset;
  37 } mheap_trace_t;
  38
  39 typedef struct
  40 {
  41   clib_spinlock_t lock;
  42   uword enabled;
  43
  44   mheap_trace_t *traces;
  45
  46   /* Indices of free traces. */
  47   u32 *trace_free_list;
  48
  49   /* Hash table mapping callers to trace index. */
  50   uword *trace_by_callers;
  51
  52   /* Hash table mapping mheap offset to trace index. */
  53   uword *trace_index_by_offset;
  54
  55   /* So we can easily shut off current segment trace, if any */
  56   void *current_traced_mheap;
  57
  58 } mheap_trace_main_t;
  59
  60 mheap_trace_main_t mheap_trace_main;
  61
  62 void
  63 mheap_get_trace (uword offset, uword size)
  64 {
  65   mheap_trace_main_t *tm = &mheap_trace_main;
  66   mheap_trace_t *t;
  67   uword i, n_callers, trace_index, *p;
  68   mheap_trace_t trace;
  69   uword save_enabled;
  70
  71   if (tm->enabled == 0 || (clib_mem_get_heap () != tm->current_traced_mheap))
  72     return;
  73
  74   /* Spurious Coverity warnings be gone. */
  75   clib_memset (&trace, 0, sizeof (trace));
  76
  77   clib_spinlock_lock (&tm->lock);
  78
  79   /* Turn off tracing to avoid embarrassment... */
  80   save_enabled = tm->enabled;
  81   tm->enabled = 0;
  82
  83   /* Skip our frame and mspace_get_aligned's frame */
  84   n_callers = clib_backtrace (trace.callers, ARRAY_LEN (trace.callers), 2);
  85   if (n_callers == 0)
  86     goto out;
  87
  88   if (!tm->trace_by_callers)
  89     tm->trace_by_callers =
  90       hash_create_shmem (0, sizeof (trace.callers), sizeof (uword));
  91
  92   p = hash_get_mem (tm->trace_by_callers, &trace.callers);
  93   if (p)
  94     {
  95       trace_index = p[0];
  96       t = tm->traces + trace_index;
  97     }
  98   else
  99     {
 100       i = vec_len (tm->trace_free_list);
 101       if (i > 0)
 102         {
 103           trace_index = tm->trace_free_list[i - 1];
 104           vec_set_len (tm->trace_free_list, i - 1);
 105         }
 106       else
 107         {
 108           mheap_trace_t *old_start = tm->traces;
 109           mheap_trace_t *old_end = vec_end (tm->traces);
 110
 111           vec_add2 (tm->traces, t, 1);
 112
 113           if (tm->traces != old_start)
 114             {
 115               hash_pair_t *p;
 116               mheap_trace_t *q;
 117             /* *INDENT-OFF* */
 118             hash_foreach_pair (p, tm->trace_by_callers,
 119             ({
 120               q = uword_to_pointer (p->key, mheap_trace_t *);
 121               ASSERT (q >= old_start && q < old_end);
 122               p->key = pointer_to_uword (tm->traces + (q - old_start));
 123             }));
 124             /* *INDENT-ON* */
 125             }
 126           trace_index = t - tm->traces;
 127         }
 128
 129       t = tm->traces + trace_index;
 130       t[0] = trace;
 131       t->n_allocations = 0;
 132       t->n_bytes = 0;
 133       hash_set_mem (tm->trace_by_callers, t->callers, trace_index);
 134     }
 135
 136   t->n_allocations += 1;
 137   t->n_bytes += size;
 138   t->offset = offset;           /* keep a sample to autopsy */
 139   hash_set (tm->trace_index_by_offset, offset, t - tm->traces);
 140
 141 out:
 142   tm->enabled = save_enabled;
 143   clib_spinlock_unlock (&tm->lock);
 144 }
 145
 146 void
 147 mheap_put_trace (uword offset, uword size)
 148 {
 149   mheap_trace_t *t;
 150   uword trace_index, *p;
 151   mheap_trace_main_t *tm = &mheap_trace_main;
 152   uword save_enabled;
 153
 154   if (tm->enabled == 0)
 155     return;
 156
 157   clib_spinlock_lock (&tm->lock);
 158
 159   /* Turn off tracing for a moment */
 160   save_enabled = tm->enabled;
 161   tm->enabled = 0;
 162
 163   p = hash_get (tm->trace_index_by_offset, offset);
 164   if (!p)
 165     {
 166       tm->enabled = save_enabled;
 167       clib_spinlock_unlock (&tm->lock);
 168       return;
 169     }
 170
 171   trace_index = p[0];
 172   hash_unset (tm->trace_index_by_offset, offset);
 173   ASSERT (trace_index < vec_len (tm->traces));
 174
 175   t = tm->traces + trace_index;
 176   ASSERT (t->n_allocations > 0);
 177   ASSERT (t->n_bytes >= size);
 178   t->n_allocations -= 1;
 179   t->n_bytes -= size;
 180   if (t->n_allocations == 0)
 181     {
 182       hash_unset_mem (tm->trace_by_callers, t->callers);
 183       vec_add1 (tm->trace_free_list, trace_index);
 184       clib_memset (t, 0, sizeof (t[0]));
 185     }
 186   tm->enabled = save_enabled;
 187   clib_spinlock_unlock (&tm->lock);
 188 }
 189
 190 always_inline void
 191 mheap_trace_main_free (mheap_trace_main_t * tm)
 192 {
 193   vec_free (tm->traces);
 194   vec_free (tm->trace_free_list);
 195   hash_free (tm->trace_by_callers);
 196   hash_free (tm->trace_index_by_offset);
 197 }
 198
 199 static clib_mem_heap_t *
 200 clib_mem_create_heap_internal (void *base, uword size,
 201                                clib_mem_page_sz_t log2_page_sz, int is_locked,
 202                                char *name)
 203 {
 204   clib_mem_heap_t *h;
 205   u8 flags = 0;
 206   int sz = sizeof (clib_mem_heap_t);
 207
 208   if (base == 0)
 209     {
 210       log2_page_sz = clib_mem_log2_page_size_validate (log2_page_sz);
 211       size = round_pow2 (size, clib_mem_page_bytes (log2_page_sz));
 212       base = clib_mem_vm_map_internal (0, log2_page_sz, size, -1, 0,
 213                                        "main heap");
 214
 215       if (base == CLIB_MEM_VM_MAP_FAILED)
 216         return 0;
 217
 218       flags = CLIB_MEM_HEAP_F_UNMAP_ON_DESTROY;
 219     }
 220   else
 221     log2_page_sz = CLIB_MEM_PAGE_SZ_UNKNOWN;
 222
 223   if (is_locked)
 224     flags |= CLIB_MEM_HEAP_F_LOCKED;
 225
 226   h = base;
 227   h->base = base;
 228   h->size = size;
 229   h->log2_page_sz = log2_page_sz;
 230   h->flags = flags;
 231   sz = strlen (name);
 232   strcpy (h->name, name);
 233   sz = round_pow2 (sz + sizeof (clib_mem_heap_t), 16);
 234   h->mspace = create_mspace_with_base (base + sz, size - sz, is_locked);
 235
 236   mspace_disable_expand (h->mspace);
 237
 238   CLIB_MEM_POISON (mspace_least_addr (h->mspace),
 239                    mspace_footprint (h->mspace));
 240
 241   return h;
 242 }
 243
 244 /* Initialize CLIB heap based on memory/size given by user.
 245    Set memory to 0 and CLIB will try to allocate its own heap. */
 246 static void *
 247 clib_mem_init_internal (void *base, uword size,
 248                         clib_mem_page_sz_t log2_page_sz)
 249 {
 250   clib_mem_heap_t *h;
 251
 252   clib_mem_main_init ();
 253
 254   h = clib_mem_create_heap_internal (base, size, log2_page_sz,
 255                                      1 /*is_locked */ , "main heap");
 256
 257   clib_mem_set_heap (h);
 258
 259   if (mheap_trace_main.lock == 0)
 260     clib_spinlock_init (&mheap_trace_main.lock);
 261
 262   return h;
 263 }
 264
 265 __clib_export void *
 266 clib_mem_init (void *memory, uword memory_size)
 267 {
 268   return clib_mem_init_internal (memory, memory_size,
 269                                  CLIB_MEM_PAGE_SZ_DEFAULT);
 270 }
 271
 272 __clib_export void *
 273 clib_mem_init_with_page_size (uword memory_size,
 274                               clib_mem_page_sz_t log2_page_sz)
 275 {
 276   return clib_mem_init_internal (0, memory_size, log2_page_sz);
 277 }
 278
 279 __clib_export void *
 280 clib_mem_init_thread_safe (void *memory, uword memory_size)
 281 {
 282   return clib_mem_init_internal (memory, memory_size,
 283                                  CLIB_MEM_PAGE_SZ_DEFAULT);
 284 }
 285
 286 __clib_export void
 287 clib_mem_destroy (void)
 288 {
 289   mheap_trace_main_t *tm = &mheap_trace_main;
 290   clib_mem_heap_t *heap = clib_mem_get_heap ();
 291   void *base = mspace_least_addr (heap->mspace);
 292
 293   if (tm->enabled && heap->mspace == tm->current_traced_mheap)
 294     tm->enabled = 0;
 295
 296   destroy_mspace (heap->mspace);
 297   clib_mem_vm_unmap (base);
 298 }
 299
 300 __clib_export u8 *
 301 format_clib_mem_usage (u8 *s, va_list *va)
 302 {
 303   int verbose = va_arg (*va, int);
 304   return format (s, "$$$$ heap at %llx verbose %d", clib_mem_get_heap (),
 305                  verbose);
 306 }
 307
 308 /*
 309  * Magic decoder ring for mallinfo stats (ala dlmalloc):
 310  *
 311  * size_t arena;     / * Non-mmapped space allocated (bytes) * /
 312  * size_t ordblks;   / * Number of free chunks * /
 313  * size_t smblks;    / * Number of free fastbin blocks * /
 314  * size_t hblks;     / * Number of mmapped regions * /
 315  * size_t hblkhd;    / * Space allocated in mmapped regions (bytes) * /
 316  * size_t usmblks;   / * Maximum total allocated space (bytes) * /
 317  * size_t fsmblks;   / * Space in freed fastbin blocks (bytes) * /
 318  * size_t uordblks;  / * Total allocated space (bytes) * /
 319  * size_t fordblks;  / * Total free space (bytes) * /
 320  * size_t keepcost;  / * Top-most, releasable space (bytes) * /
 321  *
 322  */
 323
 324 u8 *
 325 format_msize (u8 * s, va_list * va)
 326 {
 327   uword a = va_arg (*va, uword);
 328
 329   if (a >= 1ULL << 30)
 330     s = format (s, "%.2fG", (((f64) a) / ((f64) (1ULL << 30))));
 331   else if (a >= 1ULL << 20)
 332     s = format (s, "%.2fM", (((f64) a) / ((f64) (1ULL << 20))));
 333   else if (a >= 1ULL << 10)
 334     s = format (s, "%.2fK", (((f64) a) / ((f64) (1ULL << 10))));
 335   else
 336     s = format (s, "%lld", a);
 337   return s;
 338 }
 339
 340 static int
 341 mheap_trace_sort (const void *_t1, const void *_t2)
 342 {
 343   const mheap_trace_t *t1 = _t1;
 344   const mheap_trace_t *t2 = _t2;
 345   word cmp;
 346
 347   cmp = (word) t2->n_bytes - (word) t1->n_bytes;
 348   if (!cmp)
 349     cmp = (word) t2->n_allocations - (word) t1->n_allocations;
 350   return cmp;
 351 }
 352
 353 u8 *
 354 format_mheap_trace (u8 * s, va_list * va)
 355 {
 356   mheap_trace_main_t *tm = va_arg (*va, mheap_trace_main_t *);
 357   int verbose = va_arg (*va, int);
 358   int have_traces = 0;
 359   int i;
 360
 361   clib_spinlock_lock (&tm->lock);
 362   if (vec_len (tm->traces) > 0 &&
 363       clib_mem_get_heap () == tm->current_traced_mheap)
 364     {
 365       have_traces = 1;
 366
 367       /* Make a copy of traces since we'll be sorting them. */
 368       mheap_trace_t *t, *traces_copy;
 369       u32 indent, total_objects_traced;
 370
 371       traces_copy = vec_dup (tm->traces);
 372
 373       qsort (traces_copy, vec_len (traces_copy), sizeof (traces_copy[0]),
 374              mheap_trace_sort);
 375
 376       total_objects_traced = 0;
 377       s = format (s, "\n");
 378       vec_foreach (t, traces_copy)
 379       {
 380         /* Skip over free elements. */
 381         if (t->n_allocations == 0)
 382           continue;
 383
 384         total_objects_traced += t->n_allocations;
 385
 386         /* When not verbose only report allocations of more than 1k. */
 387         if (!verbose && t->n_bytes < 1024)
 388           continue;
 389
 390         if (t == traces_copy)
 391           s = format (s, "%=9s%=9s %=10s Traceback\n", "Bytes", "Count",
 392                       "Sample");
 393         s = format (s, "%9d%9d %p", t->n_bytes, t->n_allocations, t->offset);
 394         indent = format_get_indent (s);
 395         for (i = 0; i < ARRAY_LEN (t->callers) && t->callers[i]; i++)
 396           {
 397             if (i > 0)
 398               s = format (s, "%U", format_white_space, indent);
 399 #if defined(CLIB_UNIX) && !defined(__APPLE__)
 400             /* $$$$ does this actually work? */
 401             s =
 402               format (s, " %U\n", format_clib_elf_symbol_with_address,
 403                       t->callers[i]);
 404 #else
 405             s = format (s, " %p\n", t->callers[i]);
 406 #endif
 407           }
 408       }
 409
 410       s = format (s, "%d total traced objects\n", total_objects_traced);
 411
 412       vec_free (traces_copy);
 413     }
 414   clib_spinlock_unlock (&tm->lock);
 415   if (have_traces == 0)
 416     s = format (s, "no traced allocations\n");
 417
 418   return s;
 419 }
 420
 421 __clib_export u8 *
 422 format_clib_mem_heap (u8 * s, va_list * va)
 423 {
 424   clib_mem_heap_t *heap = va_arg (*va, clib_mem_heap_t *);
 425   int verbose = va_arg (*va, int);
 426   struct dlmallinfo mi;
 427   mheap_trace_main_t *tm = &mheap_trace_main;
 428   u32 indent = format_get_indent (s) + 2;
 429
 430   if (heap == 0)
 431     heap = clib_mem_get_heap ();
 432
 433   mi = mspace_mallinfo (heap->mspace);
 434
 435   s = format (s, "base %p, size %U",
 436               heap->base, format_memory_size, heap->size);
 437
 438 #define _(i,v,str) \
 439   if (heap->flags & CLIB_MEM_HEAP_F_##v) s = format (s, ", %s", str);
 440   foreach_clib_mem_heap_flag;
 441 #undef _
 442
 443   s = format (s, ", name '%s'", heap->name);
 444
 445   if (heap->log2_page_sz != CLIB_MEM_PAGE_SZ_UNKNOWN)
 446     {
 447       clib_mem_page_stats_t stats;
 448       clib_mem_get_page_stats (heap->base, heap->log2_page_sz,
 449                                heap->size >> heap->log2_page_sz, &stats);
 450       s = format (s, "\n%U%U", format_white_space, indent,
 451                   format_clib_mem_page_stats, &stats);
 452     }
 453
 454   s = format (s, "\n%Utotal: %U, used: %U, free: %U, trimmable: %U",
 455               format_white_space, indent,
 456               format_msize, mi.arena,
 457               format_msize, mi.uordblks,
 458               format_msize, mi.fordblks, format_msize, mi.keepcost);
 459   if (verbose > 0)
 460     {
 461       s = format (s, "\n%Ufree chunks %llu free fastbin blks %llu",
 462                   format_white_space, indent + 2, mi.ordblks, mi.smblks);
 463       s = format (s, "\n%Umax total allocated %U",
 464                   format_white_space, indent + 2, format_msize, mi.usmblks);
 465     }
 466
 467   if (heap->flags & CLIB_MEM_HEAP_F_TRACED)
 468     s = format (s, "\n%U", format_mheap_trace, tm, verbose);
 469   return s;
 470 }
 471
 472 __clib_export __clib_flatten void
 473 clib_mem_get_heap_usage (clib_mem_heap_t *heap, clib_mem_usage_t *usage)
 474 {
 475   struct dlmallinfo mi = mspace_mallinfo (heap->mspace);
 476
 477   usage->bytes_total = mi.arena; /* non-mmapped space allocated from system */
 478   usage->bytes_used = mi.uordblks;          /* total allocated space */
 479   usage->bytes_free = mi.fordblks;          /* total free space */
 480   usage->bytes_used_mmap = mi.hblkhd;       /* space in mmapped regions */
 481   usage->bytes_max = mi.usmblks;            /* maximum total allocated space */
 482   usage->bytes_free_reclaimed = mi.ordblks; /* number of free chunks */
 483   usage->bytes_overhead = mi.keepcost; /* releasable (via malloc_trim) space */
 484
 485   /* Not supported */
 486   usage->bytes_used_sbrk = 0;
 487   usage->object_count = 0;
 488 }
 489
 490 /* Call serial number for debugger breakpoints. */
 491 uword clib_mem_validate_serial = 0;
 492
 493 __clib_export void
 494 mheap_trace (clib_mem_heap_t * h, int enable)
 495 {
 496   if (enable)
 497     h->flags |= CLIB_MEM_HEAP_F_TRACED;
 498   else
 499     h->flags &= ~CLIB_MEM_HEAP_F_TRACED;
 500
 501   if (enable == 0)
 502     mheap_trace_main_free (&mheap_trace_main);
 503 }
 504
 505 __clib_export void
 506 clib_mem_trace (int enable)
 507 {
 508   mheap_trace_main_t *tm = &mheap_trace_main;
 509   void *current_heap = clib_mem_get_heap ();
 510
 511   tm->enabled = enable;
 512   mheap_trace (current_heap, enable);
 513
 514   if (enable)
 515     tm->current_traced_mheap = current_heap;
 516   else
 517     tm->current_traced_mheap = 0;
 518 }
 519
 520 int
 521 clib_mem_is_traced (void)
 522 {
 523   clib_mem_heap_t *h = clib_mem_get_heap ();
 524   return (h->flags &= CLIB_MEM_HEAP_F_TRACED) != 0;
 525 }
 526
 527 __clib_export uword
 528 clib_mem_trace_enable_disable (uword enable)
 529 {
 530   uword rv;
 531   mheap_trace_main_t *tm = &mheap_trace_main;
 532
 533   rv = tm->enabled;
 534   tm->enabled = enable;
 535   return rv;
 536 }
 537
 538 __clib_export clib_mem_heap_t *
 539 clib_mem_create_heap (void *base, uword size, int is_locked, char *fmt, ...)
 540 {
 541   clib_mem_page_sz_t log2_page_sz = clib_mem_get_log2_page_size ();
 542   clib_mem_heap_t *h;
 543   char *name;
 544   u8 *s = 0;
 545
 546   if (fmt == 0)
 547     {
 548       name = "";
 549     }
 550   else if (strchr (fmt, '%'))
 551     {
 552       va_list va;
 553       va_start (va, fmt);
 554       s = va_format (0, fmt, &va);
 555       vec_add1 (s, 0);
 556       va_end (va);
 557       name = (char *) s;
 558     }
 559   else
 560     name = fmt;
 561
 562   h = clib_mem_create_heap_internal (base, size, log2_page_sz, is_locked,
 563                                      name);
 564   vec_free (s);
 565   return h;
 566 }
 567
 568 __clib_export void
 569 clib_mem_destroy_heap (clib_mem_heap_t * h)
 570 {
 571   mheap_trace_main_t *tm = &mheap_trace_main;
 572
 573   if (tm->enabled && h->mspace == tm->current_traced_mheap)
 574     tm->enabled = 0;
 575
 576   destroy_mspace (h->mspace);
 577   if (h->flags & CLIB_MEM_HEAP_F_UNMAP_ON_DESTROY)
 578     clib_mem_vm_unmap (h->base);
 579 }
 580
 581 __clib_export __clib_flatten uword
 582 clib_mem_get_heap_free_space (clib_mem_heap_t *h)
 583 {
 584   struct dlmallinfo dlminfo = mspace_mallinfo (h->mspace);
 585   return dlminfo.fordblks;
 586 }
 587
 588 __clib_export __clib_flatten void *
 589 clib_mem_get_heap_base (clib_mem_heap_t *h)
 590 {
 591   return h->base;
 592 }
 593
 594 __clib_export __clib_flatten uword
 595 clib_mem_get_heap_size (clib_mem_heap_t *heap)
 596 {
 597   return heap->size;
 598 }
 599
 600 /* Memory allocator which may call os_out_of_memory() if it fails */
 601 static inline void *
 602 clib_mem_heap_alloc_inline (void *heap, uword size, uword align,
 603                             int os_out_of_memory_on_failure)
 604 {
 605   clib_mem_heap_t *h = heap ? heap : clib_mem_get_per_cpu_heap ();
 606   void *p;
 607
 608   align = clib_max (CLIB_MEM_MIN_ALIGN, align);
 609
 610   p = mspace_memalign (h->mspace, align, size);
 611
 612   if (PREDICT_FALSE (0 == p))
 613     {
 614       if (os_out_of_memory_on_failure)
 615         os_out_of_memory ();
 616       return 0;
 617     }
 618
 619   if (PREDICT_FALSE (h->flags & CLIB_MEM_HEAP_F_TRACED))
 620     mheap_get_trace (pointer_to_uword (p), clib_mem_size (p));
 621
 622   CLIB_MEM_UNPOISON (p, size);
 623   return p;
 624 }
 625
 626 /* Memory allocator which calls os_out_of_memory() when it fails */
 627 __clib_export __clib_flatten void *
 628 clib_mem_alloc (uword size)
 629 {
 630   return clib_mem_heap_alloc_inline (0, size, CLIB_MEM_MIN_ALIGN,
 631                                      /* os_out_of_memory */ 1);
 632 }
 633
 634 __clib_export __clib_flatten void *
 635 clib_mem_alloc_aligned (uword size, uword align)
 636 {
 637   return clib_mem_heap_alloc_inline (0, size, align,
 638                                      /* os_out_of_memory */ 1);
 639 }
 640
 641 /* Memory allocator which calls os_out_of_memory() when it fails */
 642 __clib_export __clib_flatten void *
 643 clib_mem_alloc_or_null (uword size)
 644 {
 645   return clib_mem_heap_alloc_inline (0, size, CLIB_MEM_MIN_ALIGN,
 646                                      /* os_out_of_memory */ 0);
 647 }
 648
 649 __clib_export __clib_flatten void *
 650 clib_mem_alloc_aligned_or_null (uword size, uword align)
 651 {
 652   return clib_mem_heap_alloc_inline (0, size, align,
 653                                      /* os_out_of_memory */ 0);
 654 }
 655
 656 __clib_export __clib_flatten void *
 657 clib_mem_heap_alloc (void *heap, uword size)
 658 {
 659   return clib_mem_heap_alloc_inline (heap, size, CLIB_MEM_MIN_ALIGN,
 660                                      /* os_out_of_memory */ 1);
 661 }
 662
 663 __clib_export __clib_flatten void *
 664 clib_mem_heap_alloc_aligned (void *heap, uword size, uword align)
 665 {
 666   return clib_mem_heap_alloc_inline (heap, size, align,
 667                                      /* os_out_of_memory */ 1);
 668 }
 669
 670 __clib_export __clib_flatten void *
 671 clib_mem_heap_alloc_or_null (void *heap, uword size)
 672 {
 673   return clib_mem_heap_alloc_inline (heap, size, CLIB_MEM_MIN_ALIGN,
 674                                      /* os_out_of_memory */ 0);
 675 }
 676
 677 __clib_export __clib_flatten void *
 678 clib_mem_heap_alloc_aligned_or_null (void *heap, uword size, uword align)
 679 {
 680   return clib_mem_heap_alloc_inline (heap, size, align,
 681                                      /* os_out_of_memory */ 0);
 682 }
 683
 684 __clib_export __clib_flatten void *
 685 clib_mem_heap_realloc_aligned (void *heap, void *p, uword new_size,
 686                                uword align)
 687 {
 688   uword old_alloc_size;
 689   clib_mem_heap_t *h = heap ? heap : clib_mem_get_per_cpu_heap ();
 690   void *new;
 691
 692   ASSERT (count_set_bits (align) == 1);
 693
 694   old_alloc_size = p ? mspace_usable_size (p) : 0;
 695
 696   if (new_size == old_alloc_size)
 697     return p;
 698
 699   if (p && pointer_is_aligned (p, align) &&
 700       mspace_realloc_in_place (h->mspace, p, new_size))
 701     {
 702       CLIB_MEM_UNPOISON (p, new_size);
 703     }
 704   else
 705     {
 706       new = clib_mem_heap_alloc_inline (h, new_size, align, 1);
 707
 708       CLIB_MEM_UNPOISON (new, new_size);
 709       if (old_alloc_size)
 710         {
 711           CLIB_MEM_UNPOISON (p, old_alloc_size);
 712           clib_memcpy_fast (new, p, clib_min (new_size, old_alloc_size));
 713           clib_mem_heap_free (h, p);
 714         }
 715       p = new;
 716     }
 717
 718   return p;
 719 }
 720
 721 __clib_export __clib_flatten void *
 722 clib_mem_heap_realloc (void *heap, void *p, uword new_size)
 723 {
 724   return clib_mem_heap_realloc_aligned (heap, p, new_size, CLIB_MEM_MIN_ALIGN);
 725 }
 726
 727 __clib_export __clib_flatten void *
 728 clib_mem_realloc_aligned (void *p, uword new_size, uword align)
 729 {
 730   return clib_mem_heap_realloc_aligned (0, p, new_size, align);
 731 }
 732
 733 __clib_export __clib_flatten void *
 734 clib_mem_realloc (void *p, uword new_size)
 735 {
 736   return clib_mem_heap_realloc_aligned (0, p, new_size, CLIB_MEM_MIN_ALIGN);
 737 }
 738
 739 __clib_export __clib_flatten uword
 740 clib_mem_heap_is_heap_object (void *heap, void *p)
 741 {
 742   clib_mem_heap_t *h = heap ? heap : clib_mem_get_per_cpu_heap ();
 743   return mspace_is_heap_object (h->mspace, p);
 744 }
 745
 746 __clib_export __clib_flatten uword
 747 clib_mem_is_heap_object (void *p)
 748 {
 749   return clib_mem_heap_is_heap_object (0, p);
 750 }
 751
 752 __clib_export __clib_flatten void
 753 clib_mem_heap_free (void *heap, void *p)
 754 {
 755   clib_mem_heap_t *h = heap ? heap : clib_mem_get_per_cpu_heap ();
 756   uword size = clib_mem_size (p);
 757
 758   /* Make sure object is in the correct heap. */
 759   ASSERT (clib_mem_heap_is_heap_object (h, p));
 760
 761   if (PREDICT_FALSE (h->flags & CLIB_MEM_HEAP_F_TRACED))
 762     mheap_put_trace (pointer_to_uword (p), size);
 763   CLIB_MEM_POISON (p, clib_mem_size (p));
 764
 765   mspace_free (h->mspace, p);
 766 }
 767
 768 __clib_export __clib_flatten void
 769 clib_mem_free (void *p)
 770 {
 771   clib_mem_heap_free (0, p);
 772 }
 773
 774 __clib_export __clib_flatten uword
 775 clib_mem_size (void *p)
 776 {
 777   return mspace_usable_size (p);
 778 }
 779
 780 __clib_export void
 781 clib_mem_free_s (void *p)
 782 {
 783   uword size = clib_mem_size (p);
 784   CLIB_MEM_UNPOISON (p, size);
 785   memset_s_inline (p, size, 0, size);
 786   clib_mem_free (p);
 787 }