Merged revisions 144924-144925 via svnmerge from
[asterisk/asterisk.git] / main / astmm.c
index 3b184a6..4659d5b 100644 (file)
  * \author Mark Spencer <markster@digium.com>
  */
 
-#ifdef __AST_DEBUG_MALLOC
-
 #include "asterisk.h"
 
+#ifdef __AST_DEBUG_MALLOC
+
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
-#include <stdio.h>
-#include <string.h>
+#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"
@@ -66,22 +64,36 @@ enum func_type {
 
 static FILE *mmlog;
 
+/* NOTE: Be EXTREMELY careful with modifying this structure; the total size of this structure
+   must result in 'automatic' alignment so that the 'fence' field lands exactly at the end of
+   the structure in memory (and thus immediately before the allocated region the fence is
+   supposed to be used to monitor). In other words, we cannot allow the compiler to insert
+   any padding between this structure and anything following it, so add up the sizes of all the
+   fields and compare to sizeof(struct ast_region)... if they don't match, then the compiler
+   is padding the structure and either the fields need to be rearranged to eliminate internal
+   padding, or a dummy field will need to be inserted before the 'fence' field to push it to
+   the end of the actual space it will consume. Note that this must be checked for both 32-bit
+   and 64-bit platforms, as the sizes of pointers and 'size_t' differ on these platforms.
+*/
+
 static struct ast_region {
        struct ast_region *next;
-       char file[40];
+       size_t len;
+       char file[64];
        char func[40];
        unsigned int lineno;
        enum func_type which;
-       size_t len;
+       unsigned int cache;             /* region was allocated as part of a cache pool */
        unsigned int fence;
        unsigned char data[0];
 } *regions[SOME_PRIME];
 
 #define HASH(a) \
        (((unsigned long)(a)) % SOME_PRIME)
-       
-AST_MUTEX_DEFINE_STATIC(reglock);
-AST_MUTEX_DEFINE_STATIC(showmemorylock);
+
+/*! Tracking this mutex will cause infinite recursion, as the mutex tracking
+ *  code allocates memory */
+AST_MUTEX_DEFINE_STATIC_NOTRACKING(reglock);
 
 #define astmm_log(...)                               \
        do {                                         \
@@ -92,7 +104,7 @@ AST_MUTEX_DEFINE_STATIC(showmemorylock);
                }                                    \
        } while (0)
 
-static inline void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func)
+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)
 {
        struct ast_region *reg;
        void *ptr = NULL;
@@ -101,7 +113,7 @@ static inline void *__ast_alloc_region(size_t size, const enum func_type which,
 
        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);
+                         "at line %d of %s\n", (int) size, func, lineno, file);
        }
 
        ast_copy_string(reg->file, file, sizeof(reg->file));
@@ -109,6 +121,7 @@ static inline void *__ast_alloc_region(size_t size, const enum func_type which,
        reg->lineno = lineno;
        reg->len = size;
        reg->which = which;
+       reg->cache = cache;
        ptr = reg->data;
        hash = HASH(ptr);
        reg->fence = FENCE_MAGIC;
@@ -143,10 +156,15 @@ static inline size_t __ast_sizeof_region(void *ptr)
 
 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
 {
-       int hash = HASH(ptr);
+       int hash;
        struct ast_region *reg, *prev = NULL;
        unsigned int *fence;
 
+       if (!ptr)
+               return;
+
+       hash = HASH(ptr);
+
        ast_mutex_lock(&reglock);
        for (reg = regions[hash]; reg; reg = reg->next) {
                if (reg->data == ptr) {
@@ -181,7 +199,17 @@ void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, cons
 {
        void *ptr;
 
-       if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func))) 
+       if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0))) 
+               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 *ptr;
+
+       if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1))) 
                memset(ptr, 0, size * nmemb);
 
        return ptr;
@@ -189,7 +217,7 @@ void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, cons
 
 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func) 
 {
-       return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func);
+       return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
 }
 
 void __ast_free(void *ptr, const char *file, int lineno, const char *func) 
@@ -208,7 +236,7 @@ void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const
                return NULL;
        }
 
-       if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func)))
+       if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0)))
                return NULL;
 
        if (len > size)
@@ -230,7 +258,7 @@ char *__ast_strdup(const char *s, const char *file, int lineno, const char *func
                return NULL;
 
        len = strlen(s) + 1;
-       if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func)))
+       if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func, 0)))
                strcpy(ptr, s);
 
        return ptr;
@@ -247,7 +275,7 @@ char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const
        len = strlen(s) + 1;
        if (len > n)
                len = n;
-       if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func)))
+       if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func, 0)))
                strcpy(ptr, s);
 
        return ptr;
@@ -264,7 +292,7 @@ int __ast_asprintf(const char *file, int lineno, const char *func, char **strp,
        va_copy(ap2, ap);
        size = vsnprintf(&s, 1, fmt, ap2);
        va_end(ap2);
-       if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func))) {
+       if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func, 0))) {
                va_end(ap);
                return -1;
        }
@@ -284,7 +312,7 @@ int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file,
        va_copy(ap2, ap);
        size = vsnprintf(&s, 1, fmt, ap2);
        va_end(ap2);
-       if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func))) {
+       if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func, 0))) {
                va_end(ap);
                return -1;
        }
@@ -293,19 +321,33 @@ int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file,
        return size;
 }
 
-static int handle_show_memory(int fd, int argc, char *argv[])
+static char *handle_memory_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
        char *fn = NULL;
        struct ast_region *reg;
        unsigned int x;
        unsigned int len = 0;
+       unsigned int cache_len = 0;
        unsigned int count = 0;
        unsigned int *fence;
 
-       if (argc > 3)
-               fn = argv[3];
+       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";
+               return NULL;
+       case CLI_GENERATE:
+               return NULL;
+       }
+
+
+       if (a->argc > 3)
+               fn = a->argv[3];
 
-       ast_mutex_lock(&showmemorylock);
+       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")) {
@@ -321,36 +363,56 @@ static int handle_show_memory(int fd, int argc, char *argv[])
                                }
                        }
                        if (!fn || !strcasecmp(fn, reg->file)) {
-                               ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %s\n", 
-                                               (int) reg->len, reg->func, reg->lineno, 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++;
                        }
                }
        }
-       ast_mutex_unlock(&showmemorylock);
+       ast_mutex_unlock(&reglock);
        
-       ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
+       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);
        
-       return RESULT_SUCCESS;
+       return CLI_SUCCESS;
 }
 
-static int handle_show_memory_summary(int fd, int argc, char *argv[])
+static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
        char *fn = NULL;
        int x;
        struct ast_region *reg;
        unsigned int len = 0;
+       unsigned int cache_len = 0;
        int count = 0;
        struct file_summary {
                char fn[80];
                int len;
+               int cache_len;
                int count;
                struct file_summary *next;
        } *list = NULL, *cur;
        
-       if (argc > 3) 
-               fn = argv[3];
+       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";
+               return NULL;
+       case CLI_GENERATE:
+               return NULL;
+       }
+
+       if (a->argc > 3) 
+               fn = a->argv[3];
 
        ast_mutex_lock(&reglock);
        for (x = 0; x < SOME_PRIME; x++) {
@@ -371,6 +433,8 @@ static int handle_show_memory_summary(int fd, int argc, char *argv[])
                        }
 
                        cur->len += reg->len;
+                       if (reg->cache)
+                               cur->cache_len += reg->len;
                        cur->count++;
                }
        }
@@ -378,65 +442,58 @@ static int handle_show_memory_summary(int fd, int argc, char *argv[])
        
        /* Dump the whole list */
        for (cur = list; cur; cur = cur->next) {
-               len += list->len;
-               count += list->count;
-               if (fn) {
-                       ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n", 
-                               cur->len, cur->count, cur->fn, fn);
+               len += cur->len;
+               cache_len += cur->cache_len;
+               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);
+                       } 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);
+                       }
                } else {
-                       ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n", 
-                               cur->len, cur->count, cur->fn);
+                       if (fn) {
+                               ast_cli(a->fd, "%10d bytes in %d allocations in function '%s' of '%s'\n", 
+                                       cur->len, cur->count, cur->fn, fn);
+                       } else {
+                               ast_cli(a->fd, "%10d bytes in %d allocations in file '%s'\n", 
+                                       cur->len, cur->count, cur->fn);
+                       }
                }
        }
 
-       ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
+       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);
 
-       return RESULT_SUCCESS;
+       return CLI_SUCCESS;
 }
 
-static char show_memory_help[] = 
-"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";
-
-static char show_memory_summary_help[] = 
-"Usage: memory show summary [<file>]\n"
-"       Summarizes heap memory allocations by file, or optionally\n"
-"by function, if a file is specified\n";
-
-static struct ast_cli_entry cli_show_memory_allocations_deprecated = {
-       { "show", "memory", "allocations", NULL },
-       handle_show_memory, NULL,
-       NULL };
-
-static struct ast_cli_entry cli_show_memory_summary_deprecated = {
-       { "show", "memory", "summary", NULL },
-       handle_show_memory_summary, NULL,
-       NULL };
-
 static struct ast_cli_entry cli_memory[] = {
-       { { "memory", "show", "allocations", NULL },
-       handle_show_memory, "Display outstanding memory allocations",
-       show_memory_help, NULL, &cli_show_memory_allocations_deprecated },
-
-       { { "memory", "show", "summary", NULL },
-       handle_show_memory_summary, "Summarize outstanding memory allocations",
-       show_memory_summary_help, NULL, &cli_show_memory_summary_deprecated },
+       AST_CLI_DEFINE(handle_memory_show, "Display outstanding memory allocations"),
+       AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
 };
 
 void __ast_mm_init(void)
 {
        char filename[PATH_MAX];
+       size_t pad = sizeof(struct ast_region) - offsetof(struct ast_region, data);
+
+       if (pad) {
+               ast_log(LOG_ERROR, "struct ast_region has %d bytes of padding! This must be eliminated for low-fence checking to work properly!\n", (int) pad);
+       }
 
        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);
+       snprintf(filename, sizeof(filename), "%s/mmlog", ast_config_AST_LOG_DIR);
        
-       if (option_verbose)
-               ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
+       ast_verb(1, "Asterisk Malloc Debugger Started (see %s))\n", filename);
        
        if ((mmlog = fopen(filename, "a+"))) {
-               fprintf(mmlog, "%ld - New session\n", time(NULL));
+               fprintf(mmlog, "%ld - New session\n", (long)time(NULL));
                fflush(mmlog);
        }
 }