main/astmm.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2012, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Memory Management
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  * \author Richard Mudgett <rmudgett@digium.com>
  25  */
  26
  27 /*** MODULEINFO
  28         <support_level>core</support_level>
  29  ***/
  30
  31 #include "asterisk.h"
  32
  33 #if defined(__AST_DEBUG_MALLOC)
  34
  35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  36
  37 #include "asterisk/paths.h"     /* use ast_config_AST_LOG_DIR */
  38 #include <stddef.h>
  39 #include <time.h>
  40
  41 #include "asterisk/cli.h"
  42 #include "asterisk/lock.h"
  43 #include "asterisk/strings.h"
  44 #include "asterisk/unaligned.h"
  45 #include "asterisk/backtrace.h"
  46
  47 /*!
  48  * The larger the number the faster memory can be freed.
  49  * However, more memory then is used for the regions[] hash
  50  * table.
  51  */
  52 #define SOME_PRIME 1567
  53
  54 enum func_type {
  55         FUNC_CALLOC = 1,
  56         FUNC_MALLOC,
  57         FUNC_REALLOC,
  58         FUNC_STRDUP,
  59         FUNC_STRNDUP,
  60         FUNC_VASPRINTF,
  61         FUNC_ASPRINTF
  62 };
  63
  64 /* Undefine all our macros */
  65 #undef malloc
  66 #undef calloc
  67 #undef realloc
  68 #undef strdup
  69 #undef strndup
  70 #undef free
  71 #undef vasprintf
  72 #undef asprintf
  73
  74 #define FENCE_MAGIC             0xfeedbabe      /*!< Allocated memory high/low fence overwrite check. */
  75 #define FREED_MAGIC             0xdeaddead      /*!< Freed memory wipe filler. */
  76 #define MALLOC_FILLER   0x55            /*!< Malloced memory filler.  Must not be zero. */
  77
  78 static FILE *mmlog;
  79
  80 struct ast_region {
  81         AST_LIST_ENTRY(ast_region) node;
  82         struct ast_bt *bt;
  83         size_t len;
  84         unsigned int cache;             /* region was allocated as part of a cache pool */
  85         unsigned int lineno;
  86         enum func_type which;
  87         char file[64];
  88         char func[40];
  89         /*!
  90          * \brief Lower guard fence.
  91          *
  92          * \note Must be right before data[].
  93          *
  94          * \note Padding between fence and data[] is irrelevent because
  95          * data[] is used to fill in the lower fence check value and not
  96          * the fence member.  The fence member is to ensure that there
  97          * is space reserved for the fence check value.
  98          */
  99         unsigned int fence;
 100         /*!
 101          * \brief Location of the requested malloc block to return.
 102          *
 103          * \note Must have the same alignment that malloc returns.
 104          * i.e., It is suitably aligned for any kind of varible.
 105          */
 106         unsigned char data[0] __attribute__((aligned));
 107 };
 108
 109 /*! Hash table of lists of active allocated memory regions. */
 110 static struct ast_region *regions[SOME_PRIME];
 111
 112 /*! Number of freed regions to keep around to delay actually freeing them. */
 113 #define FREED_MAX_COUNT         1500
 114
 115 /*! Maximum size of a minnow block */
 116 #define MINNOWS_MAX_SIZE        50
 117
 118 struct ast_freed_regions {
 119         /*! Memory regions that have been freed. */
 120         struct ast_region *regions[FREED_MAX_COUNT];
 121         /*! Next index into freed regions[] to use. */
 122         int index;
 123 };
 124
 125 /*! Large memory blocks that have been freed. */
 126 static struct ast_freed_regions whales;
 127 /*! Small memory blocks that have been freed. */
 128 static struct ast_freed_regions minnows;
 129
 130 enum summary_opts {
 131         /*! No summary at exit. */
 132         SUMMARY_OFF,
 133         /*! Bit set if summary by line at exit. */
 134         SUMMARY_BY_LINE = (1 << 0),
 135         /*! Bit set if summary by function at exit. */
 136         SUMMARY_BY_FUNC = (1 << 1),
 137         /*! Bit set if summary by file at exit. */
 138         SUMMARY_BY_FILE = (1 << 2),
 139 };
 140
 141 /*! Summary options of unfreed regions at exit. */
 142 static enum summary_opts atexit_summary;
 143 /*! Nonzero if the unfreed regions are listed at exit. */
 144 static int atexit_list;
 145 /*! Nonzero if the memory allocation backtrace is enabled. */
 146 static int backtrace_enabled;
 147
 148 #define HASH(a)         (((unsigned long)(a)) % ARRAY_LEN(regions))
 149
 150 /*! Tracking this mutex will cause infinite recursion, as the mutex tracking
 151  *  code allocates memory */
 152 AST_MUTEX_DEFINE_STATIC_NOTRACKING(reglock);
 153
 154 #define astmm_log(...)                               \
 155         do {                                         \
 156                 fprintf(stderr, __VA_ARGS__);        \
 157                 if (mmlog) {                         \
 158                         fprintf(mmlog, __VA_ARGS__); \
 159                         fflush(mmlog);               \
 160                 }                                    \
 161         } while (0)
 162
 163 void *ast_std_malloc(size_t size)
 164 {
 165         return malloc(size);
 166 }
 167
 168 void *ast_std_calloc(size_t nmemb, size_t size)
 169 {
 170         return calloc(nmemb, size);
 171 }
 172
 173 void *ast_std_realloc(void *ptr, size_t size)
 174 {
 175         return realloc(ptr, size);
 176 }
 177
 178 void ast_std_free(void *ptr)
 179 {
 180         free(ptr);
 181 }
 182
 183 void ast_free_ptr(void *ptr)
 184 {
 185         ast_free(ptr);
 186 }
 187
 188 static void print_backtrace(struct ast_bt *bt)
 189 {
 190         int i = 0;
 191         char **strings;
 192
 193         if (!bt) {
 194                 return;
 195         }
 196
 197         if ((strings = ast_bt_get_symbols(bt->addresses, bt->num_frames))) {
 198                 astmm_log("Memory allocation backtrace:\n");
 199                 for (i = 3; i < bt->num_frames - 2; i++) {
 200                         astmm_log("#%d: [%p] %s\n", i - 3, bt->addresses[i], strings[i]);
 201                 }
 202                 ast_std_free(strings);
 203         }
 204 }
 205
 206 /*!
 207  * \internal
 208  *
 209  * \note If DO_CRASH is not defined then the function returns.
 210  *
 211  * \return Nothing
 212  */
 213 static void my_do_crash(void)
 214 {
 215         /*
 216          * Give the logger a chance to get the message out, just in case
 217          * we abort(), or Asterisk crashes due to whatever problem just
 218          * happened.
 219          */
 220         usleep(1);
 221         ast_do_crash();
 222 }
 223
 224 static void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func, unsigned int cache)
 225 {
 226         struct ast_region *reg;
 227         unsigned int *fence;
 228         int hash;
 229
 230         if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
 231                 astmm_log("Memory Allocation Failure - '%d' bytes at %s %s() line %d\n",
 232                         (int) size, file, func, lineno);
 233                 return NULL;
 234         }
 235
 236         reg->len = size;
 237         reg->cache = cache;
 238         reg->lineno = lineno;
 239         reg->which = which;
 240         reg->bt = backtrace_enabled ? ast_bt_create() : NULL;
 241         ast_copy_string(reg->file, file, sizeof(reg->file));
 242         ast_copy_string(reg->func, func, sizeof(reg->func));
 243
 244         /*
 245          * Init lower fence.
 246          *
 247          * We use the bytes just preceeding reg->data and not reg->fence
 248          * because there is likely to be padding between reg->fence and
 249          * reg->data for reg->data alignment.
 250          */
 251         fence = (unsigned int *) (reg->data - sizeof(*fence));
 252         *fence = FENCE_MAGIC;
 253
 254         /* Init higher fence. */
 255         fence = (unsigned int *) (reg->data + reg->len);
 256         put_unaligned_uint32(fence, FENCE_MAGIC);
 257
 258         hash = HASH(reg->data);
 259         ast_mutex_lock(&reglock);
 260         AST_LIST_NEXT(reg, node) = regions[hash];
 261         regions[hash] = reg;
 262         ast_mutex_unlock(&reglock);
 263
 264         return reg->data;
 265 }
 266
 267 /*!
 268  * \internal
 269  * \brief Wipe the region payload data with a known value.
 270  *
 271  * \param reg Region block to be wiped.
 272  *
 273  * \return Nothing
 274  */
 275 static void region_data_wipe(struct ast_region *reg)
 276 {
 277         void *end;
 278         unsigned int *pos;
 279
 280         /*
 281          * Wipe the lower fence, the payload, and whatever amount of the
 282          * higher fence that falls into alignment with the payload.
 283          */
 284         end = reg->data + reg->len;
 285         for (pos = &reg->fence; (void *) pos <= end; ++pos) {
 286                 *pos = FREED_MAGIC;
 287         }
 288 }
 289
 290 /*!
 291  * \internal
 292  * \brief Check the region payload data for memory corruption.
 293  *
 294  * \param reg Region block to be checked.
 295  *
 296  * \return Nothing
 297  */
 298 static void region_data_check(struct ast_region *reg)
 299 {
 300         void *end;
 301         unsigned int *pos;
 302
 303         /*
 304          * Check the lower fence, the payload, and whatever amount of
 305          * the higher fence that falls into alignment with the payload.
 306          */
 307         end = reg->data + reg->len;
 308         for (pos = &reg->fence; (void *) pos <= end; ++pos) {
 309                 if (*pos != FREED_MAGIC) {
 310                         astmm_log("WARNING: Memory corrupted after free of %p allocated at %s %s() line %d\n",
 311                                 reg->data, reg->file, reg->func, reg->lineno);
 312                         print_backtrace(reg->bt);
 313                         my_do_crash();
 314                         break;
 315                 }
 316         }
 317 }
 318
 319 /*!
 320  * \internal
 321  * \brief Flush the circular array of freed regions.
 322  *
 323  * \param freed Already freed region blocks storage.
 324  *
 325  * \return Nothing
 326  */
 327 static void freed_regions_flush(struct ast_freed_regions *freed)
 328 {
 329         int idx;
 330         struct ast_region *old;
 331
 332         ast_mutex_lock(&reglock);
 333         for (idx = 0; idx < ARRAY_LEN(freed->regions); ++idx) {
 334                 old = freed->regions[idx];
 335                 freed->regions[idx] = NULL;
 336                 if (old) {
 337                         region_data_check(old);
 338                         free(old);
 339                 }
 340         }
 341         freed->index = 0;
 342         ast_mutex_unlock(&reglock);
 343 }
 344
 345 /*!
 346  * \internal
 347  * \brief Delay freeing a region block.
 348  *
 349  * \param freed Already freed region blocks storage.
 350  * \param reg Region block to be freed.
 351  *
 352  * \return Nothing
 353  */
 354 static void region_free(struct ast_freed_regions *freed, struct ast_region *reg)
 355 {
 356         struct ast_region *old;
 357
 358         region_data_wipe(reg);
 359
 360         ast_mutex_lock(&reglock);
 361         old = freed->regions[freed->index];
 362         freed->regions[freed->index] = reg;
 363
 364         ++freed->index;
 365         if (ARRAY_LEN(freed->regions) <= freed->index) {
 366                 freed->index = 0;
 367         }
 368         ast_mutex_unlock(&reglock);
 369
 370         if (old) {
 371                 region_data_check(old);
 372                 old->bt = ast_bt_destroy(old->bt);
 373                 free(old);
 374         }
 375 }
 376
 377 /*!
 378  * \internal
 379  * \brief Remove a region from the active regions.
 380  *
 381  * \param ptr Region payload data pointer.
 382  *
 383  * \retval region on success.
 384  * \retval NULL if not found.
 385  */
 386 static struct ast_region *region_remove(void *ptr)
 387 {
 388         int hash;
 389         struct ast_region *reg;
 390         struct ast_region *prev = NULL;
 391
 392         hash = HASH(ptr);
 393
 394         ast_mutex_lock(&reglock);
 395         for (reg = regions[hash]; reg; reg = AST_LIST_NEXT(reg, node)) {
 396                 if (reg->data == ptr) {
 397                         if (prev) {
 398                                 AST_LIST_NEXT(prev, node) = AST_LIST_NEXT(reg, node);
 399                         } else {
 400                                 regions[hash] = AST_LIST_NEXT(reg, node);
 401                         }
 402                         break;
 403                 }
 404                 prev = reg;
 405         }
 406         ast_mutex_unlock(&reglock);
 407
 408         return reg;
 409 }
 410
 411 /*!
 412  * \internal
 413  * \brief Check the fences of a region.
 414  *
 415  * \param reg Region block to check.
 416  *
 417  * \return Nothing
 418  */
 419 static void region_check_fences(struct ast_region *reg)
 420 {
 421         unsigned int *fence;
 422
 423         /*
 424          * We use the bytes just preceeding reg->data and not reg->fence
 425          * because there is likely to be padding between reg->fence and
 426          * reg->data for reg->data alignment.
 427          */
 428         fence = (unsigned int *) (reg->data - sizeof(*fence));
 429         if (*fence != FENCE_MAGIC) {
 430                 astmm_log("WARNING: Low fence violation of %p allocated at %s %s() line %d\n",
 431                         reg->data, reg->file, reg->func, reg->lineno);
 432                 print_backtrace(reg->bt);
 433                 my_do_crash();
 434         }
 435         fence = (unsigned int *) (reg->data + reg->len);
 436         if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
 437                 astmm_log("WARNING: High fence violation of %p allocated at %s %s() line %d\n",
 438                         reg->data, reg->file, reg->func, reg->lineno);
 439                 print_backtrace(reg->bt);
 440                 my_do_crash();
 441         }
 442 }
 443
 444 /*!
 445  * \internal
 446  * \brief Check the fences of all regions currently allocated.
 447  *
 448  * \return Nothing
 449  */
 450 static void regions_check_all_fences(void)
 451 {
 452         int idx;
 453         struct ast_region *reg;
 454
 455         ast_mutex_lock(&reglock);
 456         for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
 457                 for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
 458                         region_check_fences(reg);
 459                 }
 460         }
 461         ast_mutex_unlock(&reglock);
 462 }
 463
 464 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
 465 {
 466         struct ast_region *reg;
 467
 468         if (!ptr) {
 469                 return;
 470         }
 471
 472         reg = region_remove(ptr);
 473         if (reg) {
 474                 region_check_fences(reg);
 475
 476                 if (reg->len <= MINNOWS_MAX_SIZE) {
 477                         region_free(&minnows, reg);
 478                 } else {
 479                         region_free(&whales, reg);
 480                 }
 481         } else {
 482                 /*
 483                  * This memory region is not registered.  It could be because of
 484                  * a double free or the memory block was not allocated by the
 485                  * malloc debug code.
 486                  */
 487                 astmm_log("WARNING: Freeing unregistered memory %p by %s %s() line %d\n",
 488                         ptr, file, func, lineno);
 489                 my_do_crash();
 490         }
 491 }
 492
 493 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 494 {
 495         void *ptr;
 496
 497         ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0);
 498         if (ptr) {
 499                 memset(ptr, 0, size * nmemb);
 500         }
 501
 502         return ptr;
 503 }
 504
 505 void *__ast_calloc_cache(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 506 {
 507         void *ptr;
 508
 509         ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1);
 510         if (ptr) {
 511                 memset(ptr, 0, size * nmemb);
 512         }
 513
 514         return ptr;
 515 }
 516
 517 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func)
 518 {
 519         void *ptr;
 520
 521         ptr = __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
 522         if (ptr) {
 523                 /* Make sure that the malloced memory is not zero. */
 524                 memset(ptr, MALLOC_FILLER, size);
 525         }
 526
 527         return ptr;
 528 }
 529
 530 void __ast_free(void *ptr, const char *file, int lineno, const char *func)
 531 {
 532         __ast_free_region(ptr, file, lineno, func);
 533 }
 534
 535 /*!
 536  * \note reglock must be locked before calling.
 537  */
 538 static struct ast_region *region_find(void *ptr)
 539 {
 540         int hash;
 541         struct ast_region *reg;
 542
 543         hash = HASH(ptr);
 544         for (reg = regions[hash]; reg; reg = AST_LIST_NEXT(reg, node)) {
 545                 if (reg->data == ptr) {
 546                         break;
 547                 }
 548         }
 549
 550         return reg;
 551 }
 552
 553 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
 554 {
 555         size_t len;
 556         struct ast_region *found;
 557         void *new_mem;
 558
 559         if (ptr) {
 560                 ast_mutex_lock(&reglock);
 561                 found = region_find(ptr);
 562                 if (!found) {
 563                         ast_mutex_unlock(&reglock);
 564                         astmm_log("WARNING: Realloc of unregistered memory %p by %s %s() line %d\n",
 565                                 ptr, file, func, lineno);
 566                         my_do_crash();
 567                         return NULL;
 568                 }
 569                 len = found->len;
 570                 ast_mutex_unlock(&reglock);
 571         } else {
 572                 found = NULL;
 573                 len = 0;
 574         }
 575
 576         if (!size) {
 577                 __ast_free_region(ptr, file, lineno, func);
 578                 return NULL;
 579         }
 580
 581         new_mem = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0);
 582         if (new_mem) {
 583                 if (found) {
 584                         /* Copy the old data to the new malloced memory. */
 585                         if (size <= len) {
 586                                 memcpy(new_mem, ptr, size);
 587                         } else {
 588                                 memcpy(new_mem, ptr, len);
 589                                 /* Make sure that the added memory is not zero. */
 590                                 memset(new_mem + len, MALLOC_FILLER, size - len);
 591                         }
 592                         __ast_free_region(ptr, file, lineno, func);
 593                 } else {
 594                         /* Make sure that the malloced memory is not zero. */
 595                         memset(new_mem, MALLOC_FILLER, size);
 596                 }
 597         }
 598
 599         return new_mem;
 600 }
 601
 602 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func)
 603 {
 604         size_t len;
 605         void *ptr;
 606
 607         if (!s)
 608                 return NULL;
 609
 610         len = strlen(s) + 1;
 611         if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func, 0)))
 612                 strcpy(ptr, s);
 613
 614         return ptr;
 615 }
 616
 617 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
 618 {
 619         size_t len;
 620         char *ptr;
 621
 622         if (!s) {
 623                 return NULL;
 624         }
 625
 626         len = strnlen(s, n);
 627         if ((ptr = __ast_alloc_region(len + 1, FUNC_STRNDUP, file, lineno, func, 0))) {
 628                 memcpy(ptr, s, len);
 629                 ptr[len] = '\0';
 630         }
 631
 632         return ptr;
 633 }
 634
 635 int __ast_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
 636 {
 637         int size;
 638         va_list ap, ap2;
 639         char s;
 640
 641         *strp = NULL;
 642         va_start(ap, fmt);
 643         va_copy(ap2, ap);
 644         size = vsnprintf(&s, 1, fmt, ap2);
 645         va_end(ap2);
 646         if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func, 0))) {
 647                 va_end(ap);
 648                 return -1;
 649         }
 650         vsnprintf(*strp, size + 1, fmt, ap);
 651         va_end(ap);
 652
 653         return size;
 654 }
 655
 656 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
 657 {
 658         int size;
 659         va_list ap2;
 660         char s;
 661
 662         *strp = NULL;
 663         va_copy(ap2, ap);
 664         size = vsnprintf(&s, 1, fmt, ap2);
 665         va_end(ap2);
 666         if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func, 0))) {
 667                 va_end(ap);
 668                 return -1;
 669         }
 670         vsnprintf(*strp, size + 1, fmt, ap);
 671
 672         return size;
 673 }
 674
 675 static char *handle_memory_atexit_list(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 676 {
 677         switch (cmd) {
 678         case CLI_INIT:
 679                 e->command = "memory atexit list";
 680                 e->usage =
 681                         "Usage: memory atexit list {on|off}\n"
 682                         "       Enable dumping a list of still allocated memory segments at exit.\n";
 683                 return NULL;
 684         case CLI_GENERATE:
 685                 if (a->pos == 3) {
 686                         const char * const options[] = { "off", "on", NULL };
 687
 688                         return ast_cli_complete(a->word, options, a->n);
 689                 }
 690                 return NULL;
 691         }
 692
 693         if (a->argc != 4) {
 694                 return CLI_SHOWUSAGE;
 695         }
 696
 697         if (ast_true(a->argv[3])) {
 698                 atexit_list = 1;
 699         } else if (ast_false(a->argv[3])) {
 700                 atexit_list = 0;
 701         } else {
 702                 return CLI_SHOWUSAGE;
 703         }
 704
 705         ast_cli(a->fd, "The atexit list is: %s\n", atexit_list ? "On" : "Off");
 706
 707         return CLI_SUCCESS;
 708 }
 709
 710 static char *handle_memory_atexit_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 711 {
 712         char buf[80];
 713
 714         switch (cmd) {
 715         case CLI_INIT:
 716                 e->command = "memory atexit summary";
 717                 e->usage =
 718                         "Usage: memory atexit summary {off|byline|byfunc|byfile}\n"
 719                         "       Summary of still allocated memory segments at exit options.\n"
 720                         "       off - Disable at exit summary.\n"
 721                         "       byline - Enable at exit summary by file line number.\n"
 722                         "       byfunc - Enable at exit summary by function name.\n"
 723                         "       byfile - Enable at exit summary by file.\n"
 724                         "\n"
 725                         "       Note: byline, byfunc, and byfile are cumulative enables.\n";
 726                 return NULL;
 727         case CLI_GENERATE:
 728                 if (a->pos == 3) {
 729                         const char * const options[] = { "off", "byline", "byfunc", "byfile", NULL };
 730
 731                         return ast_cli_complete(a->word, options, a->n);
 732                 }
 733                 return NULL;
 734         }
 735
 736         if (a->argc != 4) {
 737                 return CLI_SHOWUSAGE;
 738         }
 739
 740         if (ast_false(a->argv[3])) {
 741                 atexit_summary = SUMMARY_OFF;
 742         } else if (!strcasecmp(a->argv[3], "byline")) {
 743                 atexit_summary |= SUMMARY_BY_LINE;
 744         } else if (!strcasecmp(a->argv[3], "byfunc")) {
 745                 atexit_summary |= SUMMARY_BY_FUNC;
 746         } else if (!strcasecmp(a->argv[3], "byfile")) {
 747                 atexit_summary |= SUMMARY_BY_FILE;
 748         } else {
 749                 return CLI_SHOWUSAGE;
 750         }
 751
 752         if (atexit_summary) {
 753                 buf[0] = '\0';
 754                 if (atexit_summary & SUMMARY_BY_LINE) {
 755                         strcat(buf, "byline");
 756                 }
 757                 if (atexit_summary & SUMMARY_BY_FUNC) {
 758                         if (buf[0]) {
 759                                 strcat(buf, " | ");
 760                         }
 761                         strcat(buf, "byfunc");
 762                 }
 763                 if (atexit_summary & SUMMARY_BY_FILE) {
 764                         if (buf[0]) {
 765                                 strcat(buf, " | ");
 766                         }
 767                         strcat(buf, "byfile");
 768                 }
 769         } else {
 770                 strcpy(buf, "Off");
 771         }
 772         ast_cli(a->fd, "The atexit summary is: %s\n", buf);
 773
 774         return CLI_SUCCESS;
 775 }
 776
 777 static char *handle_memory_show_allocations(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 778 {
 779         const char *fn = NULL;
 780         struct ast_region *reg;
 781         unsigned int idx;
 782         unsigned int len = 0;
 783         unsigned int cache_len = 0;
 784         unsigned int count = 0;
 785
 786         switch (cmd) {
 787         case CLI_INIT:
 788                 e->command = "memory show allocations";
 789                 e->usage =
 790                         "Usage: memory show allocations [<file>|anomalies]\n"
 791                         "       Dumps a list of segments of allocated memory.\n"
 792                         "       Defaults to listing all memory allocations.\n"
 793                         "       <file> - Restricts output to memory allocated by the file.\n"
 794                         "       anomalies - Only check for fence violations.\n";
 795                 return NULL;
 796         case CLI_GENERATE:
 797                 return NULL;
 798         }
 799
 800         if (a->argc == 4) {
 801                 fn = a->argv[3];
 802         } else if (a->argc != 3) {
 803                 return CLI_SHOWUSAGE;
 804         }
 805
 806         /* Look for historical misspelled option as well. */
 807         if (fn && (!strcasecmp(fn, "anomalies") || !strcasecmp(fn, "anomolies"))) {
 808                 regions_check_all_fences();
 809                 ast_cli(a->fd, "Anomaly check complete.\n");
 810                 return CLI_SUCCESS;
 811         }
 812
 813         ast_mutex_lock(&reglock);
 814         for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
 815                 for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
 816                         if (fn && strcasecmp(fn, reg->file)) {
 817                                 continue;
 818                         }
 819
 820                         region_check_fences(reg);
 821
 822                         ast_cli(a->fd, "%10u bytes allocated%s by %20s() line %5u of %s\n",
 823                                 (unsigned int) reg->len, reg->cache ? " (cache)" : "",
 824                                 reg->func, reg->lineno, reg->file);
 825
 826                         len += reg->len;
 827                         if (reg->cache) {
 828                                 cache_len += reg->len;
 829                         }
 830                         ++count;
 831                 }
 832         }
 833         ast_mutex_unlock(&reglock);
 834
 835         if (cache_len) {
 836                 ast_cli(a->fd, "%u bytes allocated (%u in caches) in %u allocations\n",
 837                         len, cache_len, count);
 838         } else {
 839                 ast_cli(a->fd, "%u bytes allocated in %u allocations\n", len, count);
 840         }
 841
 842         return CLI_SUCCESS;
 843 }
 844
 845 static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 846 {
 847 #define my_max(a, b) ((a) >= (b) ? (a) : (b))
 848
 849         const char *fn = NULL;
 850         int idx;
 851         int cmp;
 852         struct ast_region *reg;
 853         unsigned int len = 0;
 854         unsigned int cache_len = 0;
 855         unsigned int count = 0;
 856         struct file_summary {
 857                 struct file_summary *next;
 858                 unsigned int len;
 859                 unsigned int cache_len;
 860                 unsigned int count;
 861                 unsigned int lineno;
 862                 char name[my_max(sizeof(reg->file), sizeof(reg->func))];
 863         } *list = NULL, *cur, **prev;
 864
 865         switch (cmd) {
 866         case CLI_INIT:
 867                 e->command = "memory show summary";
 868                 e->usage =
 869                         "Usage: memory show summary [<file>]\n"
 870                         "       Summarizes heap memory allocations by file, or optionally\n"
 871                         "       by line, if a file is specified.\n";
 872                 return NULL;
 873         case CLI_GENERATE:
 874                 return NULL;
 875         }
 876
 877         if (a->argc == 4) {
 878                 fn = a->argv[3];
 879         } else if (a->argc != 3) {
 880                 return CLI_SHOWUSAGE;
 881         }
 882
 883         ast_mutex_lock(&reglock);
 884         for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
 885                 for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
 886                         if (fn) {
 887                                 if (strcasecmp(fn, reg->file)) {
 888                                         continue;
 889                                 }
 890
 891                                 /* Sort list by func/lineno.  Find existing or place to insert. */
 892                                 for (prev = &list; (cur = *prev); prev = &cur->next) {
 893                                         cmp = strcmp(cur->name, reg->func);
 894                                         if (cmp < 0) {
 895                                                 continue;
 896                                         }
 897                                         if (cmp > 0) {
 898                                                 /* Insert before current */
 899                                                 cur = NULL;
 900                                                 break;
 901                                         }
 902                                         cmp = cur->lineno - reg->lineno;
 903                                         if (cmp < 0) {
 904                                                 continue;
 905                                         }
 906                                         if (cmp > 0) {
 907                                                 /* Insert before current */
 908                                                 cur = NULL;
 909                                         }
 910                                         break;
 911                                 }
 912                         } else {
 913                                 /* Sort list by filename.  Find existing or place to insert. */
 914                                 for (prev = &list; (cur = *prev); prev = &cur->next) {
 915                                         cmp = strcmp(cur->name, reg->file);
 916                                         if (cmp < 0) {
 917                                                 continue;
 918                                         }
 919                                         if (cmp > 0) {
 920                                                 /* Insert before current */
 921                                                 cur = NULL;
 922                                         }
 923                                         break;
 924                                 }
 925                         }
 926
 927                         if (!cur) {
 928                                 cur = ast_alloca(sizeof(*cur));
 929                                 memset(cur, 0, sizeof(*cur));
 930                                 cur->lineno = reg->lineno;
 931                                 ast_copy_string(cur->name, fn ? reg->func : reg->file, sizeof(cur->name));
 932
 933                                 cur->next = *prev;
 934                                 *prev = cur;
 935                         }
 936
 937                         cur->len += reg->len;
 938                         if (reg->cache) {
 939                                 cur->cache_len += reg->len;
 940                         }
 941                         ++cur->count;
 942                 }
 943         }
 944         ast_mutex_unlock(&reglock);
 945
 946         /* Dump the whole list */
 947         for (cur = list; cur; cur = cur->next) {
 948                 len += cur->len;
 949                 cache_len += cur->cache_len;
 950                 count += cur->count;
 951                 if (cur->cache_len) {
 952                         if (fn) {
 953                                 ast_cli(a->fd, "%10u bytes (%10u cache) in %10u allocations by %20s() line %5u of %s\n",
 954                                         cur->len, cur->cache_len, cur->count, cur->name, cur->lineno, fn);
 955                         } else {
 956                                 ast_cli(a->fd, "%10u bytes (%10u cache) in %10u allocations in file %s\n",
 957                                         cur->len, cur->cache_len, cur->count, cur->name);
 958                         }
 959                 } else {
 960                         if (fn) {
 961                                 ast_cli(a->fd, "%10u bytes in %10u allocations by %20s() line %5u of %s\n",
 962                                         cur->len, cur->count, cur->name, cur->lineno, fn);
 963                         } else {
 964                                 ast_cli(a->fd, "%10u bytes in %10u allocations in file %s\n",
 965                                         cur->len, cur->count, cur->name);
 966                         }
 967                 }
 968         }
 969
 970         if (cache_len) {
 971                 ast_cli(a->fd, "%u bytes allocated (%u in caches) in %u allocations\n",
 972                         len, cache_len, count);
 973         } else {
 974                 ast_cli(a->fd, "%u bytes allocated in %u allocations\n", len, count);
 975         }
 976
 977         return CLI_SUCCESS;
 978 }
 979
 980 static char *handle_memory_backtrace(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 981 {
 982         switch (cmd) {
 983         case CLI_INIT:
 984                 e->command = "memory backtrace";
 985                 e->usage =
 986                         "Usage: memory backtrace {on|off}\n"
 987                         "       Enable dumping an allocation backtrace with memory diagnostics.\n"
 988                         "       Note that saving the backtrace data for each allocation\n"
 989                         "       can be CPU intensive.\n";
 990                 return NULL;
 991         case CLI_GENERATE:
 992                 if (a->pos == 2) {
 993                         const char * const options[] = { "off", "on", NULL };
 994
 995                         return ast_cli_complete(a->word, options, a->n);
 996                 }
 997                 return NULL;
 998         }
 999
1000         if (a->argc != 3) {
1001                 return CLI_SHOWUSAGE;
1002         }
1003
1004         if (ast_true(a->argv[2])) {
1005                 backtrace_enabled = 1;
1006         } else if (ast_false(a->argv[2])) {
1007                 backtrace_enabled = 0;
1008         } else {
1009                 return CLI_SHOWUSAGE;
1010         }
1011
1012         ast_cli(a->fd, "The memory backtrace is: %s\n", backtrace_enabled ? "On" : "Off");
1013
1014         return CLI_SUCCESS;
1015 }
1016
1017 static struct ast_cli_entry cli_memory[] = {
1018         AST_CLI_DEFINE(handle_memory_atexit_list, "Enable memory allocations not freed at exit list."),
1019         AST_CLI_DEFINE(handle_memory_atexit_summary, "Enable memory allocations not freed at exit summary."),
1020         AST_CLI_DEFINE(handle_memory_show_allocations, "Display outstanding memory allocations"),
1021         AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
1022         AST_CLI_DEFINE(handle_memory_backtrace, "Enable dumping an allocation backtrace with memory diagnostics."),
1023 };
1024
1025 AST_LIST_HEAD_NOLOCK(region_list, ast_region);
1026
1027 /*!
1028  * \internal
1029  * \brief Convert the allocated regions hash table to a list.
1030  *
1031  * \param list Fill list with the allocated regions.
1032  *
1033  * \details
1034  * Take all allocated regions from the regions[] and put them
1035  * into the list.
1036  *
1037  * \note reglock must be locked before calling.
1038  *
1039  * \note This function is destructive to the regions[] lists.
1040  *
1041  * \return Length of list created.
1042  */
1043 static size_t mm_atexit_hash_list(struct region_list *list)
1044 {
1045         struct ast_region *reg;
1046         size_t total_length;
1047         int idx;
1048
1049         total_length = 0;
1050         for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
1051                 while ((reg = regions[idx])) {
1052                         regions[idx] = AST_LIST_NEXT(reg, node);
1053                         AST_LIST_NEXT(reg, node) = NULL;
1054                         AST_LIST_INSERT_HEAD(list, reg, node);
1055                         ++total_length;
1056                 }
1057         }
1058         return total_length;
1059 }
1060
1061 /*!
1062  * \internal
1063  * \brief Put the regions list into the allocated regions hash table.
1064  *
1065  * \param list List to put into the allocated regions hash table.
1066  *
1067  * \note reglock must be locked before calling.
1068  *
1069  * \return Nothing
1070  */
1071 static void mm_atexit_hash_restore(struct region_list *list)
1072 {
1073         struct ast_region *reg;
1074         int hash;
1075
1076         while ((reg = AST_LIST_REMOVE_HEAD(list, node))) {
1077                 hash = HASH(reg->data);
1078                 AST_LIST_NEXT(reg, node) = regions[hash];
1079                 regions[hash] = reg;
1080         }
1081 }
1082
1083 /*!
1084  * \internal
1085  * \brief Sort regions comparision.
1086  *
1087  * \param left Region to compare.
1088  * \param right Region to compare.
1089  *
1090  * \retval <0 if left < right
1091  * \retval =0 if left == right
1092  * \retval >0 if left > right
1093  */
1094 static int mm_atexit_cmp(struct ast_region *left, struct ast_region *right)
1095 {
1096         int cmp;
1097         ptrdiff_t cmp_ptr;
1098         ssize_t cmp_size;
1099
1100         /* Sort by filename. */
1101         cmp = strcmp(left->file, right->file);
1102         if (cmp) {
1103                 return cmp;
1104         }
1105
1106         /* Sort by line number. */
1107         cmp = left->lineno - right->lineno;
1108         if (cmp) {
1109                 return cmp;
1110         }
1111
1112         /* Sort by allocated size. */
1113         cmp_size = left->len - right->len;
1114         if (cmp_size) {
1115                 if (cmp_size < 0) {
1116                         return -1;
1117                 }
1118                 return 1;
1119         }
1120
1121         /* Sort by allocated pointers just because. */
1122         cmp_ptr = left->data - right->data;
1123         if (cmp_ptr) {
1124                 if (cmp_ptr < 0) {
1125                         return -1;
1126                 }
1127                 return 1;
1128         }
1129
1130         return 0;
1131 }
1132
1133 /*!
1134  * \internal
1135  * \brief Merge the given sorted sublists into sorted order onto the end of the list.
1136  *
1137  * \param list Merge sublists onto this list.
1138  * \param sub1 First sublist to merge.
1139  * \param sub2 Second sublist to merge.
1140  *
1141  * \return Nothing
1142  */
1143 static void mm_atexit_list_merge(struct region_list *list, struct region_list *sub1, struct region_list *sub2)
1144 {
1145         struct ast_region *reg;
1146
1147         for (;;) {
1148                 if (AST_LIST_EMPTY(sub1)) {
1149                         /* The remaining sublist goes onto the list. */
1150                         AST_LIST_APPEND_LIST(list, sub2, node);
1151                         break;
1152                 }
1153                 if (AST_LIST_EMPTY(sub2)) {
1154                         /* The remaining sublist goes onto the list. */
1155                         AST_LIST_APPEND_LIST(list, sub1, node);
1156                         break;
1157                 }
1158
1159                 if (mm_atexit_cmp(AST_LIST_FIRST(sub1), AST_LIST_FIRST(sub2)) <= 0) {
1160                         reg = AST_LIST_REMOVE_HEAD(sub1, node);
1161                 } else {
1162                         reg = AST_LIST_REMOVE_HEAD(sub2, node);
1163                 }
1164                 AST_LIST_INSERT_TAIL(list, reg, node);
1165         }
1166 }
1167
1168 /*!
1169  * \internal
1170  * \brief Take sublists off of the given list.
1171  *
1172  * \param list Source list to remove sublists from the beginning of list.
1173  * \param sub Array of sublists to fill. (Lists are empty on entry.)
1174  * \param num_lists Number of lists to remove from the source list.
1175  * \param size Size of the sublists to remove.
1176  * \param remaining Remaining number of elements on the source list.
1177  *
1178  * \return Nothing
1179  */
1180 static void mm_atexit_list_split(struct region_list *list, struct region_list sub[], size_t num_lists, size_t size, size_t *remaining)
1181 {
1182         int idx;
1183
1184         for (idx = 0; idx < num_lists; ++idx) {
1185                 size_t count;
1186
1187                 if (*remaining < size) {
1188                         /* The remaining source list goes onto the sublist. */
1189                         AST_LIST_APPEND_LIST(&sub[idx], list, node);
1190                         *remaining = 0;
1191                         break;
1192                 }
1193
1194                 /* Take a sublist off the beginning of the source list. */
1195                 *remaining -= size;
1196                 for (count = size; count--;) {
1197                         struct ast_region *reg;
1198
1199                         reg = AST_LIST_REMOVE_HEAD(list, node);
1200                         AST_LIST_INSERT_TAIL(&sub[idx], reg, node);
1201                 }
1202         }
1203 }
1204
1205 /*!
1206  * \internal
1207  * \brief Sort the regions list using mergesort.
1208  *
1209  * \param list Allocated regions list to sort.
1210  * \param length Length of the list.
1211  *
1212  * \return Nothing
1213  */
1214 static void mm_atexit_list_sort(struct region_list *list, size_t length)
1215 {
1216         /*! Semi-sorted merged list. */
1217         struct region_list merged = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
1218         /*! Sublists to merge. (Can only merge two sublists at this time.) */
1219         struct region_list sub[2] = {
1220                 AST_LIST_HEAD_NOLOCK_INIT_VALUE,
1221                 AST_LIST_HEAD_NOLOCK_INIT_VALUE
1222         };
1223         /*! Sublist size. */
1224         size_t size = 1;
1225         /*! Remaining elements in the list. */
1226         size_t remaining;
1227         /*! Number of sublist merge passes to process the list. */
1228         int passes;
1229
1230         for (;;) {
1231                 remaining = length;
1232
1233                 passes = 0;
1234                 while (!AST_LIST_EMPTY(list)) {
1235                         mm_atexit_list_split(list, sub, ARRAY_LEN(sub), size, &remaining);
1236                         mm_atexit_list_merge(&merged, &sub[0], &sub[1]);
1237                         ++passes;
1238                 }
1239                 AST_LIST_APPEND_LIST(list, &merged, node);
1240                 if (passes <= 1) {
1241                         /* The list is now sorted. */
1242                         break;
1243                 }
1244
1245                 /* Double the sublist size to remove for next round. */
1246                 size <<= 1;
1247         }
1248 }
1249
1250 /*!
1251  * \internal
1252  * \brief List all regions currently allocated.
1253  *
1254  * \param alloced regions list.
1255  *
1256  * \return Nothing
1257  */
1258 static void mm_atexit_regions_list(struct region_list *alloced)
1259 {
1260         struct ast_region *reg;
1261
1262         AST_LIST_TRAVERSE(alloced, reg, node) {
1263                 astmm_log("%s %s() line %u: %u bytes%s at %p\n",
1264                         reg->file, reg->func, reg->lineno,
1265                         (unsigned int) reg->len, reg->cache ? " (cache)" : "", reg->data);
1266         }
1267 }
1268
1269 /*!
1270  * \internal
1271  * \brief Summarize all regions currently allocated.
1272  *
1273  * \param alloced Sorted regions list.
1274  *
1275  * \return Nothing
1276  */
1277 static void mm_atexit_regions_summary(struct region_list *alloced)
1278 {
1279         struct ast_region *reg;
1280         struct ast_region *next;
1281         struct {
1282                 unsigned int count;
1283                 unsigned int len;
1284                 unsigned int cache_len;
1285         } by_line, by_func, by_file, total;
1286
1287         by_line.count = 0;
1288         by_line.len = 0;
1289         by_line.cache_len = 0;
1290
1291         by_func.count = 0;
1292         by_func.len = 0;
1293         by_func.cache_len = 0;
1294
1295         by_file.count = 0;
1296         by_file.len = 0;
1297         by_file.cache_len = 0;
1298
1299         total.count = 0;
1300         total.len = 0;
1301         total.cache_len = 0;
1302
1303         AST_LIST_TRAVERSE(alloced, reg, node) {
1304                 next = AST_LIST_NEXT(reg, node);
1305
1306                 ++by_line.count;
1307                 by_line.len += reg->len;
1308                 if (reg->cache) {
1309                         by_line.cache_len += reg->len;
1310                 }
1311                 if (next && !strcmp(reg->file, next->file) && reg->lineno == next->lineno) {
1312                         continue;
1313                 }
1314                 if (atexit_summary & SUMMARY_BY_LINE) {
1315                         if (by_line.cache_len) {
1316                                 astmm_log("%10u bytes (%u in caches) in %u allocations. %s %s() line %u\n",
1317                                         by_line.len, by_line.cache_len, by_line.count, reg->file, reg->func, reg->lineno);
1318                         } else {
1319                                 astmm_log("%10u bytes in %5u allocations. %s %s() line %u\n",
1320                                         by_line.len, by_line.count, reg->file, reg->func, reg->lineno);
1321                         }
1322                 }
1323
1324                 by_func.count += by_line.count;
1325                 by_func.len += by_line.len;
1326                 by_func.cache_len += by_line.cache_len;
1327                 by_line.count = 0;
1328                 by_line.len = 0;
1329                 by_line.cache_len = 0;
1330                 if (next && !strcmp(reg->file, next->file) && !strcmp(reg->func, next->func)) {
1331                         continue;
1332                 }
1333                 if (atexit_summary & SUMMARY_BY_FUNC) {
1334                         if (by_func.cache_len) {
1335                                 astmm_log("%10u bytes (%u in caches) in %u allocations. %s %s()\n",
1336                                         by_func.len, by_func.cache_len, by_func.count, reg->file, reg->func);
1337                         } else {
1338                                 astmm_log("%10u bytes in %5u allocations. %s %s()\n",
1339                                         by_func.len, by_func.count, reg->file, reg->func);
1340                         }
1341                 }
1342
1343                 by_file.count += by_func.count;
1344                 by_file.len += by_func.len;
1345                 by_file.cache_len += by_func.cache_len;
1346                 by_func.count = 0;
1347                 by_func.len = 0;
1348                 by_func.cache_len = 0;
1349                 if (next && !strcmp(reg->file, next->file)) {
1350                         continue;
1351                 }
1352                 if (atexit_summary & SUMMARY_BY_FILE) {
1353                         if (by_file.cache_len) {
1354                                 astmm_log("%10u bytes (%u in caches) in %u allocations. %s\n",
1355                                         by_file.len, by_file.cache_len, by_file.count, reg->file);
1356                         } else {
1357                                 astmm_log("%10u bytes in %5u allocations. %s\n",
1358                                         by_file.len, by_file.count, reg->file);
1359                         }
1360                 }
1361
1362                 total.count += by_file.count;
1363                 total.len += by_file.len;
1364                 total.cache_len += by_file.cache_len;
1365                 by_file.count = 0;
1366                 by_file.len = 0;
1367                 by_file.cache_len = 0;
1368         }
1369
1370         if (total.cache_len) {
1371                 astmm_log("%u bytes (%u in caches) in %u allocations.\n",
1372                         total.len, total.cache_len, total.count);
1373         } else {
1374                 astmm_log("%u bytes in %u allocations.\n", total.len, total.count);
1375         }
1376 }
1377
1378 /*!
1379  * \internal
1380  * \brief Dump the memory allocations atexit.
1381  *
1382  * \note reglock must be locked before calling.
1383  *
1384  * \return Nothing
1385  */
1386 static void mm_atexit_dump(void)
1387 {
1388         struct region_list alloced_atexit = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
1389         size_t length;
1390
1391         length = mm_atexit_hash_list(&alloced_atexit);
1392         if (!length) {
1393                 /* Wow!  This is amazing! */
1394                 astmm_log("Exiting with all memory freed.\n");
1395                 return;
1396         }
1397
1398         mm_atexit_list_sort(&alloced_atexit, length);
1399
1400         astmm_log("Exiting with the following memory not freed:\n");
1401         if (atexit_list) {
1402                 mm_atexit_regions_list(&alloced_atexit);
1403         }
1404         if (atexit_summary) {
1405                 mm_atexit_regions_summary(&alloced_atexit);
1406         }
1407
1408         /*
1409          * Put the alloced list back into regions[].
1410          *
1411          * We have do do this because we can get called before all other
1412          * threads have terminated.
1413          */
1414         mm_atexit_hash_restore(&alloced_atexit);
1415 }
1416
1417 /*!
1418  * \internal
1419  * \return Nothing
1420  */
1421 static void mm_atexit_final(void)
1422 {
1423         FILE *log;
1424
1425         /* Only wait if we want atexit allocation dumps. */
1426         if (atexit_list || atexit_summary) {
1427                 fprintf(stderr, "Waiting 10 seconds to let other threads die.\n");
1428                 sleep(10);
1429         }
1430
1431         regions_check_all_fences();
1432
1433         /* Flush all delayed memory free circular arrays. */
1434         freed_regions_flush(&whales);
1435         freed_regions_flush(&minnows);
1436
1437         /* Peform atexit allocation dumps. */
1438         if (atexit_list || atexit_summary) {
1439                 ast_mutex_lock(&reglock);
1440                 mm_atexit_dump();
1441                 ast_mutex_unlock(&reglock);
1442         }
1443
1444         /* Close the log file. */
1445         log = mmlog;
1446         mmlog = NULL;
1447         if (log) {
1448                 fclose(log);
1449         }
1450 }
1451
1452 /*!
1453  * \brief Initialize malloc debug phase 1.
1454  *
1455  * \note Must be called first thing in main().
1456  *
1457  * \return Nothing
1458  */
1459 void __ast_mm_init_phase_1(void)
1460 {
1461         atexit(mm_atexit_final);
1462 }
1463
1464 /*!
1465  * \internal
1466  * \return Nothing
1467  */
1468 static void mm_atexit_ast(void)
1469 {
1470         ast_cli_unregister_multiple(cli_memory, ARRAY_LEN(cli_memory));
1471 }
1472
1473 /*!
1474  * \brief Initialize malloc debug phase 2.
1475  *
1476  * \return Nothing
1477  */
1478 void __ast_mm_init_phase_2(void)
1479 {
1480         char filename[PATH_MAX];
1481
1482         ast_cli_register_multiple(cli_memory, ARRAY_LEN(cli_memory));
1483
1484         snprintf(filename, sizeof(filename), "%s/mmlog", ast_config_AST_LOG_DIR);
1485
1486         ast_verb(1, "Asterisk Malloc Debugger Started (see %s))\n", filename);
1487
1488         mmlog = fopen(filename, "a+");
1489         if (mmlog) {
1490                 fprintf(mmlog, "%ld - New session\n", (long) time(NULL));
1491                 fflush(mmlog);
1492         } else {
1493                 ast_log(LOG_ERROR, "Could not open malloc debug log file: %s\n", filename);
1494         }
1495
1496         ast_register_atexit(mm_atexit_ast);
1497 }
1498
1499 #endif  /* defined(__AST_DEBUG_MALLOC) */