git migration: Refactor the ASTERISK_FILE_VERSION macro
[asterisk/asterisk.git] / main / astmm.c
index fd0b3d6..a4d5602 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 1999 - 2006, Digium, Inc.
+ * Copyright (C) 1999 - 2012, Digium, Inc.
  *
  * Mark Spencer <markster@digium.com>
  *
  * \brief Memory Management
  *
  * \author Mark Spencer <markster@digium.com>
+ * \author Richard Mudgett <rmudgett@digium.com>
  */
 
-#ifdef __AST_DEBUG_MALLOC
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
 
 #include "asterisk.h"
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#if defined(__AST_DEBUG_MALLOC)
 
-#include <stdio.h>
-#include <string.h>
+ASTERISK_REGISTER_FILE()
+
+#include "asterisk/paths.h"    /* use ast_config_AST_LOG_DIR */
+#include <stddef.h>
 #include <time.h>
 
 #include "asterisk/cli.h"
-#include "asterisk/logger.h"
-#include "asterisk/options.h"
 #include "asterisk/lock.h"
 #include "asterisk/strings.h"
 #include "asterisk/unaligned.h"
+#include "asterisk/backtrace.h"
 
-#define SOME_PRIME 563
+/*!
+ * The larger the number the faster memory can be freed.
+ * However, more memory then is used for the regions[] hash
+ * table.
+ */
+#define SOME_PRIME 1567
 
 enum func_type {
        FUNC_CALLOC = 1,
@@ -62,24 +71,81 @@ enum func_type {
 #undef vasprintf
 #undef asprintf
 
-#define FENCE_MAGIC 0xdeadbeef
+#define FENCE_MAGIC            0xfeedbabe      /*!< Allocated memory high/low fence overwrite check. */
+#define FREED_MAGIC            0xdeaddead      /*!< Freed memory wipe filler. */
+#define MALLOC_FILLER  0x55            /*!< Malloced memory filler.  Must not be zero. */
 
 static FILE *mmlog;
 
-static struct ast_region {
-       struct ast_region *next;
-       char file[40];
-       char func[40];
+struct ast_region {
+       AST_LIST_ENTRY(ast_region) node;
+       struct ast_bt *bt;
+       size_t len;
+       unsigned int cache;             /* region was allocated as part of a cache pool */
        unsigned int lineno;
        enum func_type which;
-       unsigned int cache;             /* region was allocated as part of a cache pool */
-       size_t len;
+       char file[64];
+       char func[40];
+       /*!
+        * \brief Lower guard fence.
+        *
+        * \note Must be right before data[].
+        *
+        * \note Padding between fence and data[] is irrelevent because
+        * data[] is used to fill in the lower fence check value and not
+        * the fence member.  The fence member is to ensure that there
+        * is space reserved for the fence check value.
+        */
        unsigned int fence;
-       unsigned char data[0];
-} *regions[SOME_PRIME];
+       /*!
+        * \brief Location of the requested malloc block to return.
+        *
+        * \note Must have the same alignment that malloc returns.
+        * i.e., It is suitably aligned for any kind of varible.
+        */
+       unsigned char data[0] __attribute__((aligned));
+};
+
+/*! Hash table of lists of active allocated memory regions. */
+static struct ast_region *regions[SOME_PRIME];
+
+/*! Number of freed regions to keep around to delay actually freeing them. */
+#define FREED_MAX_COUNT                1500
+
+/*! Maximum size of a minnow block */
+#define MINNOWS_MAX_SIZE       50
+
+struct ast_freed_regions {
+       /*! Memory regions that have been freed. */
+       struct ast_region *regions[FREED_MAX_COUNT];
+       /*! Next index into freed regions[] to use. */
+       int index;
+};
+
+/*! Large memory blocks that have been freed. */
+static struct ast_freed_regions whales;
+/*! Small memory blocks that have been freed. */
+static struct ast_freed_regions minnows;
+
+enum summary_opts {
+       /*! No summary at exit. */
+       SUMMARY_OFF,
+       /*! Bit set if summary by line at exit. */
+       SUMMARY_BY_LINE = (1 << 0),
+       /*! Bit set if summary by function at exit. */
+       SUMMARY_BY_FUNC = (1 << 1),
+       /*! Bit set if summary by file at exit. */
+       SUMMARY_BY_FILE = (1 << 2),
+};
+
+/*! Summary options of unfreed regions at exit. */
+static enum summary_opts atexit_summary;
+/*! Nonzero if the unfreed regions are listed at exit. */
+static int atexit_list;
+/*! Nonzero if the memory allocation backtrace is enabled. */
+static int backtrace_enabled;
 
-#define HASH(a) \
-       (((unsigned long)(a)) % SOME_PRIME)
+#define HASH(a)                (((unsigned long)(a)) % ARRAY_LEN(regions))
 
 /*! Tracking this mutex will cause infinite recursion, as the mutex tracking
  *  code allocates memory */
@@ -94,147 +160,446 @@ AST_MUTEX_DEFINE_STATIC_NOTRACKING(reglock);
                }                                    \
        } while (0)
 
-static inline void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func, unsigned int cache)
+void *ast_std_malloc(size_t size)
+{
+       return malloc(size);
+}
+
+void *ast_std_calloc(size_t nmemb, size_t size)
+{
+       return calloc(nmemb, size);
+}
+
+void *ast_std_realloc(void *ptr, size_t size)
+{
+       return realloc(ptr, size);
+}
+
+void ast_std_free(void *ptr)
+{
+       free(ptr);
+}
+
+void ast_free_ptr(void *ptr)
+{
+       ast_free(ptr);
+}
+
+static void print_backtrace(struct ast_bt *bt)
+{
+       int i = 0;
+       char **strings;
+
+       if (!bt) {
+               return;
+       }
+
+       if ((strings = ast_bt_get_symbols(bt->addresses, bt->num_frames))) {
+               astmm_log("Memory allocation backtrace:\n");
+               for (i = 3; i < bt->num_frames - 2; i++) {
+                       astmm_log("#%d: [%p] %s\n", i - 3, bt->addresses[i], strings[i]);
+               }
+               ast_std_free(strings);
+       }
+}
+
+/*!
+ * \internal
+ *
+ * \note If DO_CRASH is not defined then the function returns.
+ *
+ * \return Nothing
+ */
+static void my_do_crash(void)
+{
+       /*
+        * Give the logger a chance to get the message out, just in case
+        * we abort(), or Asterisk crashes due to whatever problem just
+        * happened.
+        */
+       usleep(1);
+       ast_do_crash();
+}
+
+static void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func, unsigned int cache)
 {
        struct ast_region *reg;
-       void *ptr = NULL;
        unsigned int *fence;
        int hash;
 
        if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
-               astmm_log("Memory Allocation Failure - '%d' bytes in function %s "
-                         "at line %d of %s\n", (int) size, func, lineno, file);
+               astmm_log("Memory Allocation Failure - '%d' bytes at %s %s() line %d\n",
+                       (int) size, file, func, lineno);
+               return NULL;
        }
 
-       ast_copy_string(reg->file, file, sizeof(reg->file));
-       ast_copy_string(reg->func, func, sizeof(reg->func));
-       reg->lineno = lineno;
        reg->len = size;
-       reg->which = which;
        reg->cache = cache;
-       ptr = reg->data;
-       hash = HASH(ptr);
-       reg->fence = FENCE_MAGIC;
-       fence = (ptr + reg->len);
+       reg->lineno = lineno;
+       reg->which = which;
+       reg->bt = backtrace_enabled ? ast_bt_create() : NULL;
+       ast_copy_string(reg->file, file, sizeof(reg->file));
+       ast_copy_string(reg->func, func, sizeof(reg->func));
+
+       /*
+        * Init lower fence.
+        *
+        * We use the bytes just preceeding reg->data and not reg->fence
+        * because there is likely to be padding between reg->fence and
+        * reg->data for reg->data alignment.
+        */
+       fence = (unsigned int *) (reg->data - sizeof(*fence));
+       *fence = FENCE_MAGIC;
+
+       /* Init higher fence. */
+       fence = (unsigned int *) (reg->data + reg->len);
        put_unaligned_uint32(fence, FENCE_MAGIC);
 
+       hash = HASH(reg->data);
        ast_mutex_lock(&reglock);
-       reg->next = regions[hash];
+       AST_LIST_NEXT(reg, node) = regions[hash];
        regions[hash] = reg;
        ast_mutex_unlock(&reglock);
 
-       return ptr;
+       return reg->data;
+}
+
+/*!
+ * \internal
+ * \brief Wipe the region payload data with a known value.
+ *
+ * \param reg Region block to be wiped.
+ *
+ * \return Nothing
+ */
+static void region_data_wipe(struct ast_region *reg)
+{
+       void *end;
+       unsigned int *pos;
+
+       /*
+        * Wipe the lower fence, the payload, and whatever amount of the
+        * higher fence that falls into alignment with the payload.
+        */
+       end = reg->data + reg->len;
+       for (pos = &reg->fence; (void *) pos <= end; ++pos) {
+               *pos = FREED_MAGIC;
+       }
+}
+
+/*!
+ * \internal
+ * \brief Check the region payload data for memory corruption.
+ *
+ * \param reg Region block to be checked.
+ *
+ * \return Nothing
+ */
+static void region_data_check(struct ast_region *reg)
+{
+       void *end;
+       unsigned int *pos;
+
+       /*
+        * Check the lower fence, the payload, and whatever amount of
+        * the higher fence that falls into alignment with the payload.
+        */
+       end = reg->data + reg->len;
+       for (pos = &reg->fence; (void *) pos <= end; ++pos) {
+               if (*pos != FREED_MAGIC) {
+                       astmm_log("WARNING: Memory corrupted after free of %p allocated at %s %s() line %d\n",
+                               reg->data, reg->file, reg->func, reg->lineno);
+                       print_backtrace(reg->bt);
+                       my_do_crash();
+                       break;
+               }
+       }
+}
+
+/*!
+ * \internal
+ * \brief Flush the circular array of freed regions.
+ *
+ * \param freed Already freed region blocks storage.
+ *
+ * \return Nothing
+ */
+static void freed_regions_flush(struct ast_freed_regions *freed)
+{
+       int idx;
+       struct ast_region *old;
+
+       ast_mutex_lock(&reglock);
+       for (idx = 0; idx < ARRAY_LEN(freed->regions); ++idx) {
+               old = freed->regions[idx];
+               freed->regions[idx] = NULL;
+               if (old) {
+                       region_data_check(old);
+                       free(old);
+               }
+       }
+       freed->index = 0;
+       ast_mutex_unlock(&reglock);
 }
 
-static inline size_t __ast_sizeof_region(void *ptr)
+/*!
+ * \internal
+ * \brief Delay freeing a region block.
+ *
+ * \param freed Already freed region blocks storage.
+ * \param reg Region block to be freed.
+ *
+ * \return Nothing
+ */
+static void region_free(struct ast_freed_regions *freed, struct ast_region *reg)
 {
-       int hash = HASH(ptr);
+       struct ast_region *old;
+
+       region_data_wipe(reg);
+
+       ast_mutex_lock(&reglock);
+       old = freed->regions[freed->index];
+       freed->regions[freed->index] = reg;
+
+       ++freed->index;
+       if (ARRAY_LEN(freed->regions) <= freed->index) {
+               freed->index = 0;
+       }
+       ast_mutex_unlock(&reglock);
+
+       if (old) {
+               region_data_check(old);
+               old->bt = ast_bt_destroy(old->bt);
+               free(old);
+       }
+}
+
+/*!
+ * \internal
+ * \brief Remove a region from the active regions.
+ *
+ * \param ptr Region payload data pointer.
+ *
+ * \retval region on success.
+ * \retval NULL if not found.
+ */
+static struct ast_region *region_remove(void *ptr)
+{
+       int hash;
        struct ast_region *reg;
-       size_t len = 0;
-       
+       struct ast_region *prev = NULL;
+
+       hash = HASH(ptr);
+
        ast_mutex_lock(&reglock);
-       for (reg = regions[hash]; reg; reg = reg->next) {
+       for (reg = regions[hash]; reg; reg = AST_LIST_NEXT(reg, node)) {
                if (reg->data == ptr) {
-                       len = reg->len;
+                       if (prev) {
+                               AST_LIST_NEXT(prev, node) = AST_LIST_NEXT(reg, node);
+                       } else {
+                               regions[hash] = AST_LIST_NEXT(reg, node);
+                       }
                        break;
                }
+               prev = reg;
        }
        ast_mutex_unlock(&reglock);
 
-       return len;
+       return reg;
 }
 
-static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
+/*!
+ * \internal
+ * \brief Check the fences of a region.
+ *
+ * \param reg Region block to check.
+ *
+ * \return Nothing
+ */
+static void region_check_fences(struct ast_region *reg)
 {
-       int hash = HASH(ptr);
-       struct ast_region *reg, *prev = NULL;
        unsigned int *fence;
 
+       /*
+        * We use the bytes just preceeding reg->data and not reg->fence
+        * because there is likely to be padding between reg->fence and
+        * reg->data for reg->data alignment.
+        */
+       fence = (unsigned int *) (reg->data - sizeof(*fence));
+       if (*fence != FENCE_MAGIC) {
+               astmm_log("WARNING: Low fence violation of %p allocated at %s %s() line %d\n",
+                       reg->data, reg->file, reg->func, reg->lineno);
+               print_backtrace(reg->bt);
+               my_do_crash();
+       }
+       fence = (unsigned int *) (reg->data + reg->len);
+       if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
+               astmm_log("WARNING: High fence violation of %p allocated at %s %s() line %d\n",
+                       reg->data, reg->file, reg->func, reg->lineno);
+               print_backtrace(reg->bt);
+               my_do_crash();
+       }
+}
+
+/*!
+ * \internal
+ * \brief Check the fences of all regions currently allocated.
+ *
+ * \return Nothing
+ */
+static void regions_check_all_fences(void)
+{
+       int idx;
+       struct ast_region *reg;
+
        ast_mutex_lock(&reglock);
-       for (reg = regions[hash]; reg; reg = reg->next) {
-               if (reg->data == ptr) {
-                       if (prev)
-                               prev->next = reg->next;
-                       else
-                               regions[hash] = reg->next;
-                       break;
+       for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
+               for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
+                       region_check_fences(reg);
                }
-               prev = reg;
        }
        ast_mutex_unlock(&reglock);
+}
+
+static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
+{
+       struct ast_region *reg;
+
+       if (!ptr) {
+               return;
+       }
 
+       reg = region_remove(ptr);
        if (reg) {
-               fence = (unsigned int *)(reg->data + reg->len);
-               if (reg->fence != FENCE_MAGIC) {
-                       astmm_log("WARNING: Low fence violation at %p, in %s of %s, "
-                               "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
-               }
-               if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
-                       astmm_log("WARNING: High fence violation at %p, in %s of %s, "
-                               "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
+               region_check_fences(reg);
+
+               if (reg->len <= MINNOWS_MAX_SIZE) {
+                       region_free(&minnows, reg);
+               } else {
+                       region_free(&whales, reg);
                }
-               free(reg);
        } else {
-               astmm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",       
-                       ptr, func, file, lineno);
+               /*
+                * This memory region is not registered.  It could be because of
+                * a double free or the memory block was not allocated by the
+                * malloc debug code.
+                */
+               astmm_log("WARNING: Freeing unregistered memory %p by %s %s() line %d\n",
+                       ptr, file, func, lineno);
+               my_do_crash();
        }
 }
 
-void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
+void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 {
        void *ptr;
 
-       if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0))) 
+       ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0);
+       if (ptr) {
                memset(ptr, 0, size * nmemb);
+       }
 
        return ptr;
 }
 
-void *__ast_calloc_cache(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
+void *__ast_calloc_cache(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 {
        void *ptr;
 
-       if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1))) 
+       ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1);
+       if (ptr) {
                memset(ptr, 0, size * nmemb);
+       }
 
        return ptr;
 }
 
-void *__ast_malloc(size_t size, const char *file, int lineno, const char *func) 
+void *__ast_malloc(size_t size, const char *file, int lineno, const char *func)
 {
-       return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
+       void *ptr;
+
+       ptr = __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
+       if (ptr) {
+               /* Make sure that the malloced memory is not zero. */
+               memset(ptr, MALLOC_FILLER, size);
+       }
+
+       return ptr;
 }
 
-void __ast_free(void *ptr, const char *file, int lineno, const char *func) 
+void __ast_free(void *ptr, const char *file, int lineno, const char *func)
 {
        __ast_free_region(ptr, file, lineno, func);
 }
 
-void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func) 
+/*!
+ * \note reglock must be locked before calling.
+ */
+static struct ast_region *region_find(void *ptr)
 {
-       void *tmp;
-       size_t len = 0;
+       int hash;
+       struct ast_region *reg;
 
-       if (ptr && !(len = __ast_sizeof_region(ptr))) {
-               astmm_log("WARNING: Realloc of unalloced memory at %p, in %s of %s, "
-                       "line %d\n", ptr, func, file, lineno);
-               return NULL;
+       hash = HASH(ptr);
+       for (reg = regions[hash]; reg; reg = AST_LIST_NEXT(reg, node)) {
+               if (reg->data == ptr) {
+                       break;
+               }
        }
 
-       if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0)))
-               return NULL;
+       return reg;
+}
+
+void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
+{
+       size_t len;
+       struct ast_region *found;
+       void *new_mem;
 
-       if (len > size)
-               len = size;
        if (ptr) {
-               memcpy(tmp, ptr, len);
+               ast_mutex_lock(&reglock);
+               found = region_find(ptr);
+               if (!found) {
+                       ast_mutex_unlock(&reglock);
+                       astmm_log("WARNING: Realloc of unregistered memory %p by %s %s() line %d\n",
+                               ptr, file, func, lineno);
+                       my_do_crash();
+                       return NULL;
+               }
+               len = found->len;
+               ast_mutex_unlock(&reglock);
+       } else {
+               found = NULL;
+               len = 0;
+       }
+
+       if (!size) {
                __ast_free_region(ptr, file, lineno, func);
+               return NULL;
        }
-       
-       return tmp;
+
+       new_mem = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0);
+       if (new_mem) {
+               if (found) {
+                       /* Copy the old data to the new malloced memory. */
+                       if (size <= len) {
+                               memcpy(new_mem, ptr, size);
+                       } else {
+                               memcpy(new_mem, ptr, len);
+                               /* Make sure that the added memory is not zero. */
+                               memset(new_mem + len, MALLOC_FILLER, size - len);
+                       }
+                       __ast_free_region(ptr, file, lineno, func);
+               } else {
+                       /* Make sure that the malloced memory is not zero. */
+                       memset(new_mem, MALLOC_FILLER, size);
+               }
+       }
+
+       return new_mem;
 }
 
-char *__ast_strdup(const char *s, const char *file, int lineno, const char *func) 
+char *__ast_strdup(const char *s, const char *file, int lineno, const char *func)
 {
        size_t len;
        void *ptr;
@@ -249,19 +614,20 @@ char *__ast_strdup(const char *s, const char *file, int lineno, const char *func
        return ptr;
 }
 
-char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func) 
+char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
 {
        size_t len;
-       void *ptr;
+       char *ptr;
 
-       if (!s)
+       if (!s) {
                return NULL;
+       }
 
-       len = strlen(s) + 1;
-       if (len > n)
-               len = n;
-       if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func, 0)))
-               strcpy(ptr, s);
+       len = strnlen(s, n);
+       if ((ptr = __ast_alloc_region(len + 1, FUNC_STRNDUP, file, lineno, func, 0))) {
+               memcpy(ptr, s, len);
+               ptr[len] = '\0';
+       }
 
        return ptr;
 }
@@ -287,7 +653,7 @@ int __ast_asprintf(const char *file, int lineno, const char *func, char **strp,
        return size;
 }
 
-int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func) 
+int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
 {
        int size;
        va_list ap2;
@@ -306,125 +672,277 @@ int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file,
        return size;
 }
 
-static char *handle_memory_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+static char *handle_memory_atexit_list(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+       switch (cmd) {
+       case CLI_INIT:
+               e->command = "memory atexit list";
+               e->usage =
+                       "Usage: memory atexit list {on|off}\n"
+                       "       Enable dumping a list of still allocated memory segments at exit.\n";
+               return NULL;
+       case CLI_GENERATE:
+               if (a->pos == 3) {
+                       const char * const options[] = { "off", "on", NULL };
+
+                       return ast_cli_complete(a->word, options, a->n);
+               }
+               return NULL;
+       }
+
+       if (a->argc != 4) {
+               return CLI_SHOWUSAGE;
+       }
+
+       if (ast_true(a->argv[3])) {
+               atexit_list = 1;
+       } else if (ast_false(a->argv[3])) {
+               atexit_list = 0;
+       } else {
+               return CLI_SHOWUSAGE;
+       }
+
+       ast_cli(a->fd, "The atexit list is: %s\n", atexit_list ? "On" : "Off");
+
+       return CLI_SUCCESS;
+}
+
+static char *handle_memory_atexit_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+       char buf[80];
+
+       switch (cmd) {
+       case CLI_INIT:
+               e->command = "memory atexit summary";
+               e->usage =
+                       "Usage: memory atexit summary {off|byline|byfunc|byfile}\n"
+                       "       Summary of still allocated memory segments at exit options.\n"
+                       "       off - Disable at exit summary.\n"
+                       "       byline - Enable at exit summary by file line number.\n"
+                       "       byfunc - Enable at exit summary by function name.\n"
+                       "       byfile - Enable at exit summary by file.\n"
+                       "\n"
+                       "       Note: byline, byfunc, and byfile are cumulative enables.\n";
+               return NULL;
+       case CLI_GENERATE:
+               if (a->pos == 3) {
+                       const char * const options[] = { "off", "byline", "byfunc", "byfile", NULL };
+
+                       return ast_cli_complete(a->word, options, a->n);
+               }
+               return NULL;
+       }
+
+       if (a->argc != 4) {
+               return CLI_SHOWUSAGE;
+       }
+
+       if (ast_false(a->argv[3])) {
+               atexit_summary = SUMMARY_OFF;
+       } else if (!strcasecmp(a->argv[3], "byline")) {
+               atexit_summary |= SUMMARY_BY_LINE;
+       } else if (!strcasecmp(a->argv[3], "byfunc")) {
+               atexit_summary |= SUMMARY_BY_FUNC;
+       } else if (!strcasecmp(a->argv[3], "byfile")) {
+               atexit_summary |= SUMMARY_BY_FILE;
+       } else {
+               return CLI_SHOWUSAGE;
+       }
+
+       if (atexit_summary) {
+               buf[0] = '\0';
+               if (atexit_summary & SUMMARY_BY_LINE) {
+                       strcat(buf, "byline");
+               }
+               if (atexit_summary & SUMMARY_BY_FUNC) {
+                       if (buf[0]) {
+                               strcat(buf, " | ");
+                       }
+                       strcat(buf, "byfunc");
+               }
+               if (atexit_summary & SUMMARY_BY_FILE) {
+                       if (buf[0]) {
+                               strcat(buf, " | ");
+                       }
+                       strcat(buf, "byfile");
+               }
+       } else {
+               strcpy(buf, "Off");
+       }
+       ast_cli(a->fd, "The atexit summary is: %s\n", buf);
+
+       return CLI_SUCCESS;
+}
+
+static char *handle_memory_show_allocations(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
-       char *fn = NULL;
+       const char *fn = NULL;
        struct ast_region *reg;
-       unsigned int x;
+       unsigned int idx;
        unsigned int len = 0;
        unsigned int cache_len = 0;
        unsigned int count = 0;
-       unsigned int *fence;
 
        switch (cmd) {
        case CLI_INIT:
                e->command = "memory show allocations";
                e->usage =
-                       "Usage: memory show allocations [<file>]\n"
-                       "       Dumps a list of all segments of allocated memory, optionally\n"
-                       "       limited to those from a specific file\n";
+                       "Usage: memory show allocations [<file>|anomalies]\n"
+                       "       Dumps a list of segments of allocated memory.\n"
+                       "       Defaults to listing all memory allocations.\n"
+                       "       <file> - Restricts output to memory allocated by the file.\n"
+                       "       anomalies - Only check for fence violations.\n";
                return NULL;
        case CLI_GENERATE:
                return NULL;
        }
 
-
-       if (a->argc > 3)
+       if (a->argc == 4) {
                fn = a->argv[3];
+       } else if (a->argc != 3) {
+               return CLI_SHOWUSAGE;
+       }
+
+       /* Look for historical misspelled option as well. */
+       if (fn && (!strcasecmp(fn, "anomalies") || !strcasecmp(fn, "anomolies"))) {
+               regions_check_all_fences();
+               ast_cli(a->fd, "Anomaly check complete.\n");
+               return CLI_SUCCESS;
+       }
 
        ast_mutex_lock(&reglock);
-       for (x = 0; x < SOME_PRIME; x++) {
-               for (reg = regions[x]; reg; reg = reg->next) {
-                       if (!fn || !strcasecmp(fn, reg->file) || !strcasecmp(fn, "anomolies")) {
-                               fence = (unsigned int *)(reg->data + reg->len);
-                               if (reg->fence != FENCE_MAGIC) {
-                                       astmm_log("WARNING: Low fence violation at %p, "
-                                               "in %s of %s, line %d\n", reg->data, 
-                                               reg->func, reg->file, reg->lineno);
-                               }
-                               if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
-                                       astmm_log("WARNING: High fence violation at %p, in %s of %s, "
-                                               "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
-                               }
+       for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
+               for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
+                       if (fn && strcasecmp(fn, reg->file)) {
+                               continue;
                        }
-                       if (!fn || !strcasecmp(fn, reg->file)) {
-                               ast_cli(a->fd, "%10d bytes allocated%s in %20s at line %5d of %s\n", 
-                                       (int) reg->len, reg->cache ? " (cache)" : "", 
-                                       reg->func, reg->lineno, reg->file);
-                               len += reg->len;
-                               if (reg->cache)
-                                       cache_len += reg->len;
-                               count++;
+
+                       region_check_fences(reg);
+
+                       ast_cli(a->fd, "%10u bytes allocated%s by %20s() line %5u of %s\n",
+                               (unsigned int) reg->len, reg->cache ? " (cache)" : "",
+                               reg->func, reg->lineno, reg->file);
+
+                       len += reg->len;
+                       if (reg->cache) {
+                               cache_len += reg->len;
                        }
+                       ++count;
                }
        }
        ast_mutex_unlock(&reglock);
-       
-       if (cache_len)
-               ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
-       else
-               ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
-       
+
+       if (cache_len) {
+               ast_cli(a->fd, "%u bytes allocated (%u in caches) in %u allocations\n",
+                       len, cache_len, count);
+       } else {
+               ast_cli(a->fd, "%u bytes allocated in %u allocations\n", len, count);
+       }
+
        return CLI_SUCCESS;
 }
 
 static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
-       char *fn = NULL;
-       int x;
+#define my_max(a, b) ((a) >= (b) ? (a) : (b))
+
+       const char *fn = NULL;
+       int idx;
+       int cmp;
        struct ast_region *reg;
        unsigned int len = 0;
        unsigned int cache_len = 0;
-       int count = 0;
+       unsigned int count = 0;
        struct file_summary {
-               char fn[80];
-               int len;
-               int cache_len;
-               int count;
                struct file_summary *next;
-       } *list = NULL, *cur;
-       
+               unsigned int len;
+               unsigned int cache_len;
+               unsigned int count;
+               unsigned int lineno;
+               char name[my_max(sizeof(reg->file), sizeof(reg->func))];
+       } *list = NULL, *cur, **prev;
+
        switch (cmd) {
        case CLI_INIT:
                e->command = "memory show summary";
                e->usage =
                        "Usage: memory show summary [<file>]\n"
                        "       Summarizes heap memory allocations by file, or optionally\n"
-                       "by function, if a file is specified\n";
+                       "       by line, if a file is specified.\n";
                return NULL;
        case CLI_GENERATE:
                return NULL;
        }
 
-       if (a->argc > 3) 
+       if (a->argc == 4) {
                fn = a->argv[3];
+       } else if (a->argc != 3) {
+               return CLI_SHOWUSAGE;
+       }
 
        ast_mutex_lock(&reglock);
-       for (x = 0; x < SOME_PRIME; x++) {
-               for (reg = regions[x]; reg; reg = reg->next) {
-                       if (fn && strcasecmp(fn, reg->file))
-                               continue;
+       for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
+               for (reg = regions[idx]; reg; reg = AST_LIST_NEXT(reg, node)) {
+                       if (fn) {
+                               if (strcasecmp(fn, reg->file)) {
+                                       continue;
+                               }
 
-                       for (cur = list; cur; cur = cur->next) {
-                               if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
+                               /* Sort list by func/lineno.  Find existing or place to insert. */
+                               for (prev = &list; (cur = *prev); prev = &cur->next) {
+                                       cmp = strcmp(cur->name, reg->func);
+                                       if (cmp < 0) {
+                                               continue;
+                                       }
+                                       if (cmp > 0) {
+                                               /* Insert before current */
+                                               cur = NULL;
+                                               break;
+                                       }
+                                       cmp = cur->lineno - reg->lineno;
+                                       if (cmp < 0) {
+                                               continue;
+                                       }
+                                       if (cmp > 0) {
+                                               /* Insert before current */
+                                               cur = NULL;
+                                       }
+                                       break;
+                               }
+                       } else {
+                               /* Sort list by filename.  Find existing or place to insert. */
+                               for (prev = &list; (cur = *prev); prev = &cur->next) {
+                                       cmp = strcmp(cur->name, reg->file);
+                                       if (cmp < 0) {
+                                               continue;
+                                       }
+                                       if (cmp > 0) {
+                                               /* Insert before current */
+                                               cur = NULL;
+                                       }
                                        break;
+                               }
                        }
+
                        if (!cur) {
-                               cur = alloca(sizeof(*cur));
+                               cur = ast_alloca(sizeof(*cur));
                                memset(cur, 0, sizeof(*cur));
-                               ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
-                               cur->next = list;
-                               list = cur;
+                               cur->lineno = reg->lineno;
+                               ast_copy_string(cur->name, fn ? reg->func : reg->file, sizeof(cur->name));
+
+                               cur->next = *prev;
+                               *prev = cur;
                        }
 
                        cur->len += reg->len;
-                       if (reg->cache)
+                       if (reg->cache) {
                                cur->cache_len += reg->len;
-                       cur->count++;
+                       }
+                       ++cur->count;
                }
        }
        ast_mutex_unlock(&reglock);
-       
+
        /* Dump the whole list */
        for (cur = list; cur; cur = cur->next) {
                len += cur->len;
@@ -432,51 +950,550 @@ static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct
                count += cur->count;
                if (cur->cache_len) {
                        if (fn) {
-                               ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in function '%s' of '%s'\n", 
-                                       cur->len, cur->cache_len, cur->count, cur->fn, fn);
+                               ast_cli(a->fd, "%10u bytes (%10u cache) in %10u allocations by %20s() line %5u of %s\n",
+                                       cur->len, cur->cache_len, cur->count, cur->name, cur->lineno, fn);
                        } else {
-                               ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in file '%s'\n", 
-                                       cur->len, cur->cache_len, cur->count, cur->fn);
+                               ast_cli(a->fd, "%10u bytes (%10u cache) in %10u allocations in file %s\n",
+                                       cur->len, cur->cache_len, cur->count, cur->name);
                        }
                } else {
                        if (fn) {
-                               ast_cli(a->fd, "%10d bytes in %d allocations in function '%s' of '%s'\n", 
-                                       cur->len, cur->count, cur->fn, fn);
+                               ast_cli(a->fd, "%10u bytes in %10u allocations by %20s() line %5u of %s\n",
+                                       cur->len, cur->count, cur->name, cur->lineno, fn);
                        } else {
-                               ast_cli(a->fd, "%10d bytes in %d allocations in file '%s'\n", 
-                                       cur->len, cur->count, cur->fn);
+                               ast_cli(a->fd, "%10u bytes in %10u allocations in file %s\n",
+                                       cur->len, cur->count, cur->name);
                        }
                }
        }
 
-       if (cache_len)
-               ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
-       else
-               ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
+       if (cache_len) {
+               ast_cli(a->fd, "%u bytes allocated (%u in caches) in %u allocations\n",
+                       len, cache_len, count);
+       } else {
+               ast_cli(a->fd, "%u bytes allocated in %u allocations\n", len, count);
+       }
+
+       return CLI_SUCCESS;
+}
+
+static char *handle_memory_backtrace(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+       switch (cmd) {
+       case CLI_INIT:
+               e->command = "memory backtrace";
+               e->usage =
+                       "Usage: memory backtrace {on|off}\n"
+                       "       Enable dumping an allocation backtrace with memory diagnostics.\n"
+                       "       Note that saving the backtrace data for each allocation\n"
+                       "       can be CPU intensive.\n";
+               return NULL;
+       case CLI_GENERATE:
+               if (a->pos == 2) {
+                       const char * const options[] = { "off", "on", NULL };
+
+                       return ast_cli_complete(a->word, options, a->n);
+               }
+               return NULL;
+       }
+
+       if (a->argc != 3) {
+               return CLI_SHOWUSAGE;
+       }
+
+       if (ast_true(a->argv[2])) {
+               backtrace_enabled = 1;
+       } else if (ast_false(a->argv[2])) {
+               backtrace_enabled = 0;
+       } else {
+               return CLI_SHOWUSAGE;
+       }
+
+       ast_cli(a->fd, "The memory backtrace is: %s\n", backtrace_enabled ? "On" : "Off");
 
        return CLI_SUCCESS;
 }
 
 static struct ast_cli_entry cli_memory[] = {
-       AST_CLI_DEFINE(handle_memory_show, "Display outstanding memory allocations"),
+       AST_CLI_DEFINE(handle_memory_atexit_list, "Enable memory allocations not freed at exit list."),
+       AST_CLI_DEFINE(handle_memory_atexit_summary, "Enable memory allocations not freed at exit summary."),
+       AST_CLI_DEFINE(handle_memory_show_allocations, "Display outstanding memory allocations"),
        AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
+       AST_CLI_DEFINE(handle_memory_backtrace, "Enable dumping an allocation backtrace with memory diagnostics."),
 };
 
-void __ast_mm_init(void)
+AST_LIST_HEAD_NOLOCK(region_list, ast_region);
+
+/*!
+ * \internal
+ * \brief Convert the allocated regions hash table to a list.
+ *
+ * \param list Fill list with the allocated regions.
+ *
+ * \details
+ * Take all allocated regions from the regions[] and put them
+ * into the list.
+ *
+ * \note reglock must be locked before calling.
+ *
+ * \note This function is destructive to the regions[] lists.
+ *
+ * \return Length of list created.
+ */
+static size_t mm_atexit_hash_list(struct region_list *list)
+{
+       struct ast_region *reg;
+       size_t total_length;
+       int idx;
+
+       total_length = 0;
+       for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
+               while ((reg = regions[idx])) {
+                       regions[idx] = AST_LIST_NEXT(reg, node);
+                       AST_LIST_NEXT(reg, node) = NULL;
+                       AST_LIST_INSERT_HEAD(list, reg, node);
+                       ++total_length;
+               }
+       }
+       return total_length;
+}
+
+/*!
+ * \internal
+ * \brief Put the regions list into the allocated regions hash table.
+ *
+ * \param list List to put into the allocated regions hash table.
+ *
+ * \note reglock must be locked before calling.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_hash_restore(struct region_list *list)
+{
+       struct ast_region *reg;
+       int hash;
+
+       while ((reg = AST_LIST_REMOVE_HEAD(list, node))) {
+               hash = HASH(reg->data);
+               AST_LIST_NEXT(reg, node) = regions[hash];
+               regions[hash] = reg;
+       }
+}
+
+/*!
+ * \internal
+ * \brief Sort regions comparision.
+ *
+ * \param left Region to compare.
+ * \param right Region to compare.
+ *
+ * \retval <0 if left < right
+ * \retval =0 if left == right
+ * \retval >0 if left > right
+ */
+static int mm_atexit_cmp(struct ast_region *left, struct ast_region *right)
+{
+       int cmp;
+       ptrdiff_t cmp_ptr;
+       ssize_t cmp_size;
+
+       /* Sort by filename. */
+       cmp = strcmp(left->file, right->file);
+       if (cmp) {
+               return cmp;
+       }
+
+       /* Sort by line number. */
+       cmp = left->lineno - right->lineno;
+       if (cmp) {
+               return cmp;
+       }
+
+       /* Sort by allocated size. */
+       cmp_size = left->len - right->len;
+       if (cmp_size) {
+               if (cmp_size < 0) {
+                       return -1;
+               }
+               return 1;
+       }
+
+       /* Sort by allocated pointers just because. */
+       cmp_ptr = left->data - right->data;
+       if (cmp_ptr) {
+               if (cmp_ptr < 0) {
+                       return -1;
+               }
+               return 1;
+       }
+
+       return 0;
+}
+
+/*!
+ * \internal
+ * \brief Merge the given sorted sublists into sorted order onto the end of the list.
+ *
+ * \param list Merge sublists onto this list.
+ * \param sub1 First sublist to merge.
+ * \param sub2 Second sublist to merge.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_list_merge(struct region_list *list, struct region_list *sub1, struct region_list *sub2)
+{
+       struct ast_region *reg;
+
+       for (;;) {
+               if (AST_LIST_EMPTY(sub1)) {
+                       /* The remaining sublist goes onto the list. */
+                       AST_LIST_APPEND_LIST(list, sub2, node);
+                       break;
+               }
+               if (AST_LIST_EMPTY(sub2)) {
+                       /* The remaining sublist goes onto the list. */
+                       AST_LIST_APPEND_LIST(list, sub1, node);
+                       break;
+               }
+
+               if (mm_atexit_cmp(AST_LIST_FIRST(sub1), AST_LIST_FIRST(sub2)) <= 0) {
+                       reg = AST_LIST_REMOVE_HEAD(sub1, node);
+               } else {
+                       reg = AST_LIST_REMOVE_HEAD(sub2, node);
+               }
+               AST_LIST_INSERT_TAIL(list, reg, node);
+       }
+}
+
+/*!
+ * \internal
+ * \brief Take sublists off of the given list.
+ *
+ * \param list Source list to remove sublists from the beginning of list.
+ * \param sub Array of sublists to fill. (Lists are empty on entry.)
+ * \param num_lists Number of lists to remove from the source list.
+ * \param size Size of the sublists to remove.
+ * \param remaining Remaining number of elements on the source list.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_list_split(struct region_list *list, struct region_list sub[], size_t num_lists, size_t size, size_t *remaining)
+{
+       int idx;
+
+       for (idx = 0; idx < num_lists; ++idx) {
+               size_t count;
+
+               if (*remaining < size) {
+                       /* The remaining source list goes onto the sublist. */
+                       AST_LIST_APPEND_LIST(&sub[idx], list, node);
+                       *remaining = 0;
+                       break;
+               }
+
+               /* Take a sublist off the beginning of the source list. */
+               *remaining -= size;
+               for (count = size; count--;) {
+                       struct ast_region *reg;
+
+                       reg = AST_LIST_REMOVE_HEAD(list, node);
+                       AST_LIST_INSERT_TAIL(&sub[idx], reg, node);
+               }
+       }
+}
+
+/*!
+ * \internal
+ * \brief Sort the regions list using mergesort.
+ *
+ * \param list Allocated regions list to sort.
+ * \param length Length of the list.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_list_sort(struct region_list *list, size_t length)
+{
+       /*! Semi-sorted merged list. */
+       struct region_list merged = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
+       /*! Sublists to merge. (Can only merge two sublists at this time.) */
+       struct region_list sub[2] = {
+               AST_LIST_HEAD_NOLOCK_INIT_VALUE,
+               AST_LIST_HEAD_NOLOCK_INIT_VALUE
+       };
+       /*! Sublist size. */
+       size_t size = 1;
+       /*! Remaining elements in the list. */
+       size_t remaining;
+       /*! Number of sublist merge passes to process the list. */
+       int passes;
+
+       for (;;) {
+               remaining = length;
+
+               passes = 0;
+               while (!AST_LIST_EMPTY(list)) {
+                       mm_atexit_list_split(list, sub, ARRAY_LEN(sub), size, &remaining);
+                       mm_atexit_list_merge(&merged, &sub[0], &sub[1]);
+                       ++passes;
+               }
+               AST_LIST_APPEND_LIST(list, &merged, node);
+               if (passes <= 1) {
+                       /* The list is now sorted. */
+                       break;
+               }
+
+               /* Double the sublist size to remove for next round. */
+               size <<= 1;
+       }
+}
+
+/*!
+ * \internal
+ * \brief List all regions currently allocated.
+ *
+ * \param alloced regions list.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_regions_list(struct region_list *alloced)
+{
+       struct ast_region *reg;
+
+       AST_LIST_TRAVERSE(alloced, reg, node) {
+               astmm_log("%s %s() line %u: %u bytes%s at %p\n",
+                       reg->file, reg->func, reg->lineno,
+                       (unsigned int) reg->len, reg->cache ? " (cache)" : "", reg->data);
+       }
+}
+
+/*!
+ * \internal
+ * \brief Summarize all regions currently allocated.
+ *
+ * \param alloced Sorted regions list.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_regions_summary(struct region_list *alloced)
+{
+       struct ast_region *reg;
+       struct ast_region *next;
+       struct {
+               unsigned int count;
+               unsigned int len;
+               unsigned int cache_len;
+       } by_line, by_func, by_file, total;
+
+       by_line.count = 0;
+       by_line.len = 0;
+       by_line.cache_len = 0;
+
+       by_func.count = 0;
+       by_func.len = 0;
+       by_func.cache_len = 0;
+
+       by_file.count = 0;
+       by_file.len = 0;
+       by_file.cache_len = 0;
+
+       total.count = 0;
+       total.len = 0;
+       total.cache_len = 0;
+
+       AST_LIST_TRAVERSE(alloced, reg, node) {
+               next = AST_LIST_NEXT(reg, node);
+
+               ++by_line.count;
+               by_line.len += reg->len;
+               if (reg->cache) {
+                       by_line.cache_len += reg->len;
+               }
+               if (next && !strcmp(reg->file, next->file) && reg->lineno == next->lineno) {
+                       continue;
+               }
+               if (atexit_summary & SUMMARY_BY_LINE) {
+                       if (by_line.cache_len) {
+                               astmm_log("%10u bytes (%u in caches) in %u allocations. %s %s() line %u\n",
+                                       by_line.len, by_line.cache_len, by_line.count, reg->file, reg->func, reg->lineno);
+                       } else {
+                               astmm_log("%10u bytes in %5u allocations. %s %s() line %u\n",
+                                       by_line.len, by_line.count, reg->file, reg->func, reg->lineno);
+                       }
+               }
+
+               by_func.count += by_line.count;
+               by_func.len += by_line.len;
+               by_func.cache_len += by_line.cache_len;
+               by_line.count = 0;
+               by_line.len = 0;
+               by_line.cache_len = 0;
+               if (next && !strcmp(reg->file, next->file) && !strcmp(reg->func, next->func)) {
+                       continue;
+               }
+               if (atexit_summary & SUMMARY_BY_FUNC) {
+                       if (by_func.cache_len) {
+                               astmm_log("%10u bytes (%u in caches) in %u allocations. %s %s()\n",
+                                       by_func.len, by_func.cache_len, by_func.count, reg->file, reg->func);
+                       } else {
+                               astmm_log("%10u bytes in %5u allocations. %s %s()\n",
+                                       by_func.len, by_func.count, reg->file, reg->func);
+                       }
+               }
+
+               by_file.count += by_func.count;
+               by_file.len += by_func.len;
+               by_file.cache_len += by_func.cache_len;
+               by_func.count = 0;
+               by_func.len = 0;
+               by_func.cache_len = 0;
+               if (next && !strcmp(reg->file, next->file)) {
+                       continue;
+               }
+               if (atexit_summary & SUMMARY_BY_FILE) {
+                       if (by_file.cache_len) {
+                               astmm_log("%10u bytes (%u in caches) in %u allocations. %s\n",
+                                       by_file.len, by_file.cache_len, by_file.count, reg->file);
+                       } else {
+                               astmm_log("%10u bytes in %5u allocations. %s\n",
+                                       by_file.len, by_file.count, reg->file);
+                       }
+               }
+
+               total.count += by_file.count;
+               total.len += by_file.len;
+               total.cache_len += by_file.cache_len;
+               by_file.count = 0;
+               by_file.len = 0;
+               by_file.cache_len = 0;
+       }
+
+       if (total.cache_len) {
+               astmm_log("%u bytes (%u in caches) in %u allocations.\n",
+                       total.len, total.cache_len, total.count);
+       } else {
+               astmm_log("%u bytes in %u allocations.\n", total.len, total.count);
+       }
+}
+
+/*!
+ * \internal
+ * \brief Dump the memory allocations atexit.
+ *
+ * \note reglock must be locked before calling.
+ *
+ * \return Nothing
+ */
+static void mm_atexit_dump(void)
+{
+       struct region_list alloced_atexit = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
+       size_t length;
+
+       length = mm_atexit_hash_list(&alloced_atexit);
+       if (!length) {
+               /* Wow!  This is amazing! */
+               astmm_log("Exiting with all memory freed.\n");
+               return;
+       }
+
+       mm_atexit_list_sort(&alloced_atexit, length);
+
+       astmm_log("Exiting with the following memory not freed:\n");
+       if (atexit_list) {
+               mm_atexit_regions_list(&alloced_atexit);
+       }
+       if (atexit_summary) {
+               mm_atexit_regions_summary(&alloced_atexit);
+       }
+
+       /*
+        * Put the alloced list back into regions[].
+        *
+        * We have do do this because we can get called before all other
+        * threads have terminated.
+        */
+       mm_atexit_hash_restore(&alloced_atexit);
+}
+
+/*!
+ * \internal
+ * \return Nothing
+ */
+static void mm_atexit_final(void)
+{
+       FILE *log;
+
+       /* Only wait if we want atexit allocation dumps. */
+       if (atexit_list || atexit_summary) {
+               fprintf(stderr, "Waiting 10 seconds to let other threads die.\n");
+               sleep(10);
+       }
+
+       regions_check_all_fences();
+
+       /* Flush all delayed memory free circular arrays. */
+       freed_regions_flush(&whales);
+       freed_regions_flush(&minnows);
+
+       /* Peform atexit allocation dumps. */
+       if (atexit_list || atexit_summary) {
+               ast_mutex_lock(&reglock);
+               mm_atexit_dump();
+               ast_mutex_unlock(&reglock);
+       }
+
+       /* Close the log file. */
+       log = mmlog;
+       mmlog = NULL;
+       if (log) {
+               fclose(log);
+       }
+}
+
+/*!
+ * \brief Initialize malloc debug phase 1.
+ *
+ * \note Must be called first thing in main().
+ *
+ * \return Nothing
+ */
+void __ast_mm_init_phase_1(void)
+{
+       atexit(mm_atexit_final);
+}
+
+/*!
+ * \internal
+ * \return Nothing
+ */
+static void mm_atexit_ast(void)
+{
+       ast_cli_unregister_multiple(cli_memory, ARRAY_LEN(cli_memory));
+}
+
+/*!
+ * \brief Initialize malloc debug phase 2.
+ *
+ * \return Nothing
+ */
+void __ast_mm_init_phase_2(void)
 {
        char filename[PATH_MAX];
 
-       ast_cli_register_multiple(cli_memory, sizeof(cli_memory) / sizeof(struct ast_cli_entry));
-       
-       snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
-       
-       if (option_verbose)
-               ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
-       
-       if ((mmlog = fopen(filename, "a+"))) {
-               fprintf(mmlog, "%ld - New session\n", (long)time(NULL));
+       ast_cli_register_multiple(cli_memory, ARRAY_LEN(cli_memory));
+
+       snprintf(filename, sizeof(filename), "%s/mmlog", ast_config_AST_LOG_DIR);
+
+       ast_verb(1, "Asterisk Malloc Debugger Started (see %s))\n", filename);
+
+       mmlog = fopen(filename, "a+");
+       if (mmlog) {
+               fprintf(mmlog, "%ld - New session\n", (long) time(NULL));
                fflush(mmlog);
+       } else {
+               ast_log(LOG_ERROR, "Could not open malloc debug log file: %s\n", filename);
        }
+
+       ast_register_cleanup(mm_atexit_ast);
 }
 
-#endif
+#endif /* defined(__AST_DEBUG_MALLOC) */