[asterisk-commits] rmudgett: branch 11 r376048 - in /branches/11: ./ include/asterisk/ main/
SVN commits to the Asterisk project
asterisk-commits at lists.digium.com
Thu Nov 8 11:26:22 CST 2012
Author: rmudgett
Date: Thu Nov 8 11:26:16 2012
New Revision: 376048
URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=376048
Log:
Add MALLOC_DEBUG enhancements.
* Makes malloc() behave like calloc(). It will return a memory block
filled with 0x55. A nonzero value.
* Makes free() fill the released memory block and boundary fence's with
0xdeaddead. Any pointer use after free is going to have a pointer
pointing to 0xdeaddead. The 0xdeaddead pointer is usually an invalid
memory address so a crash is expected.
* Puts the freed memory block into a circular array so it is not reused
immediately.
* When the circular array rotates out a memory block to the heap it checks
that the memory has not been altered from 0xdeaddead.
* Made the astmm_log message wording better.
* Made crash if the DO_CRASH menuselect option is enabled and something is
found.
* Fixed a potential alignment issue on 64 bit systems.
struct ast_region.data[] should now be aligned correctly for all
platforms.
* Extracted region_check_fences() from __ast_free_region() and
handle_memory_show().
* Updated handle_memory_show() CLI usage help.
Review: https://reviewboard.asterisk.org/r/2182/
........
Merged revisions 376029 from http://svn.asterisk.org/svn/asterisk/branches/1.8
........
Merged revisions 376030 from http://svn.asterisk.org/svn/asterisk/branches/10
Modified:
branches/11/ (props changed)
branches/11/include/asterisk/astmm.h
branches/11/include/asterisk/utils.h
branches/11/main/asterisk.c
branches/11/main/astmm.c
branches/11/main/utils.c
Propchange: branches/11/
------------------------------------------------------------------------------
Binary property 'branch-10-merged' - no diff available.
Modified: branches/11/include/asterisk/astmm.h
URL: http://svnview.digium.com/svn/asterisk/branches/11/include/asterisk/astmm.h?view=diff&rev=376048&r1=376047&r2=376048
==============================================================================
--- branches/11/include/asterisk/astmm.h (original)
+++ branches/11/include/asterisk/astmm.h Thu Nov 8 11:26:16 2012
@@ -65,7 +65,8 @@
__attribute__((format(printf, 5, 6)));
int __ast_vasprintf(char **strp, const char *format, va_list ap, const char *file, int lineno, const char *func)
__attribute__((format(printf, 2, 0)));
-void __ast_mm_init(void);
+void __ast_mm_init_phase_1(void);
+void __ast_mm_init_phase_2(void);
/* Provide our own definitions */
Modified: branches/11/include/asterisk/utils.h
URL: http://svnview.digium.com/svn/asterisk/branches/11/include/asterisk/utils.h?view=diff&rev=376048&r1=376047&r2=376048
==============================================================================
--- branches/11/include/asterisk/utils.h (original)
+++ branches/11/include/asterisk/utils.h Thu Nov 8 11:26:16 2012
@@ -729,31 +729,26 @@
#ifdef AST_DEVMODE
+void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function);
#define ast_assert(a) _ast_assert(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-static void force_inline _ast_assert(int condition, const char *condition_str,
- const char *file, int line, const char *function)
+static void force_inline _ast_assert(int condition, const char *condition_str, const char *file, int line, const char *function)
{
if (__builtin_expect(!condition, 1)) {
- /* Attempt to put it into the logger, but hope that at least someone saw the
- * message on stderr ... */
- ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
- condition_str, condition);
- fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
- condition_str, condition, line, function, file);
- /* Give the logger a chance to get the message out, just in case we abort(), or
- * Asterisk crashes due to whatever problem just happened after we exit ast_assert(). */
- usleep(1);
-#ifdef DO_CRASH
- abort();
- /* Just in case abort() doesn't work or something else super silly,
- * and for Qwell's amusement. */
- *((int*)0)=0;
-#endif
+ __ast_assert_failed(condition, condition_str, file, line, function);
}
}
#else
#define ast_assert(a)
#endif
+
+/*!
+ * \brief Force a crash if DO_CRASH is defined.
+ *
+ * \note If DO_CRASH is not defined then the function returns.
+ *
+ * \return Nothing
+ */
+void ast_do_crash(void);
#include "asterisk/strings.h"
Modified: branches/11/main/asterisk.c
URL: http://svnview.digium.com/svn/asterisk/branches/11/main/asterisk.c?view=diff&rev=376048&r1=376047&r2=376048
==============================================================================
--- branches/11/main/asterisk.c (original)
+++ branches/11/main/asterisk.c Thu Nov 8 11:26:16 2012
@@ -3458,6 +3458,10 @@
int moduleresult; /*!< Result from the module load subsystem */
struct rlimit l;
+#if defined(__AST_DEBUG_MALLOC)
+ __ast_mm_init_phase_1();
+#endif /* defined(__AST_DEBUG_MALLOC) */
+
/* Remember original args for restart */
if (argc > ARRAY_LEN(_argv) - 1) {
fprintf(stderr, "Truncating argument size to %d\n", (int)ARRAY_LEN(_argv) - 1);
@@ -4141,9 +4145,9 @@
pthread_sigmask(SIG_UNBLOCK, &sigs, NULL);
-#ifdef __AST_DEBUG_MALLOC
- __ast_mm_init();
-#endif
+#if defined(__AST_DEBUG_MALLOC)
+ __ast_mm_init_phase_2();
+#endif /* defined(__AST_DEBUG_MALLOC) */
ast_lastreloadtime = ast_startuptime = ast_tvnow();
ast_cli_register_multiple(cli_asterisk, ARRAY_LEN(cli_asterisk));
Modified: branches/11/main/astmm.c
URL: http://svnview.digium.com/svn/asterisk/branches/11/main/astmm.c?view=diff&rev=376048&r1=376047&r2=376048
==============================================================================
--- branches/11/main/astmm.c (original)
+++ branches/11/main/astmm.c Thu Nov 8 11:26:16 2012
@@ -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 at digium.com>
*
@@ -21,6 +21,7 @@
* \brief Memory Management
*
* \author Mark Spencer <markster at digium.com>
+ * \author Richard Mudgett <rmudgett at digium.com>
*/
/*** MODULEINFO
@@ -29,7 +30,7 @@
#include "asterisk.h"
-#ifdef __AST_DEBUG_MALLOC
+#if defined(__AST_DEBUG_MALLOC)
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
@@ -64,36 +65,63 @@
#undef vasprintf
#undef asprintf
-#define FENCE_MAGIC 0xdeadbeef
+#define FENCE_MAGIC 0xdeadbeef /*!< 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;
-/* 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 {
struct ast_region *next;
size_t len;
+ unsigned int cache; /* region was allocated as part of a cache pool */
+ unsigned int lineno;
+ enum func_type which;
char file[64];
char func[40];
- unsigned int lineno;
- enum func_type which;
- unsigned int cache; /* region was allocated as part of a cache pool */
+
+ /*!
+ * \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];
-
-#define HASH(a) \
- (((unsigned long)(a)) % 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;
+
+#define HASH(a) (((unsigned long)(a)) % ARRAY_LEN(regions))
/*! Tracking this mutex will cause infinite recursion, as the mutex tracking
* code allocates memory */
@@ -108,150 +136,375 @@
} \
} 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)
+/*!
+ * \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;
}
+ reg->len = size;
+ reg->cache = cache;
+ reg->lineno = lineno;
+ reg->which = which;
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);
+
+ /*
+ * 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(®lock);
reg->next = regions[hash];
regions[hash] = reg;
ast_mutex_unlock(®lock);
- return ptr;
-}
-
-static inline size_t __ast_sizeof_region(void *ptr)
-{
- int hash = HASH(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 = ®->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 = ®->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);
+ 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(®lock);
+ 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(®lock);
+}
+
+/*!
+ * \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)
+{
+ struct ast_region *old;
+
+ region_data_wipe(reg);
+
+ ast_mutex_lock(®lock);
+ 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(®lock);
+
+ if (old) {
+ region_data_check(old);
+ 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(®lock);
for (reg = regions[hash]; reg; reg = reg->next) {
if (reg->data == ptr) {
- len = reg->len;
+ if (prev) {
+ prev->next = reg->next;
+ } else {
+ regions[hash] = reg->next;
+ }
break;
}
+ prev = reg;
}
ast_mutex_unlock(®lock);
- return len;
+ return reg;
+}
+
+/*!
+ * \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)
+{
+ 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);
+ 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);
+ my_do_crash();
+ }
}
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) {
+ region_check_fences(reg);
+
+ if (reg->len <= MINNOWS_MAX_SIZE) {
+ region_free(&minnows, reg);
+ } else {
+ region_free(&whales, reg);
+ }
+ } else {
+ /*
+ * 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 *ptr;
+
+ 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 *ptr;
+
+ 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 *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)
+{
+ __ast_free_region(ptr, file, lineno, func);
+}
+
+/*!
+ * \note reglock must be locked before calling.
+ */
+static struct ast_region *region_find(void *ptr)
+{
int hash;
- struct ast_region *reg, *prev = NULL;
- unsigned int *fence;
-
- if (!ptr)
- return;
+ struct ast_region *reg;
hash = HASH(ptr);
-
- ast_mutex_lock(®lock);
for (reg = regions[hash]; reg; reg = reg->next) {
if (reg->data == ptr) {
- if (prev)
- prev->next = reg->next;
- else
- regions[hash] = reg->next;
break;
}
- prev = reg;
- }
- ast_mutex_unlock(®lock);
-
- 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);
- }
- free(reg);
+ }
+
+ 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 (ptr) {
+ ast_mutex_lock(®lock);
+ found = region_find(ptr);
+ if (!found) {
+ ast_mutex_unlock(®lock);
+ 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(®lock);
} else {
- astmm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",
- ptr, func, file, lineno);
- }
-}
-
-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)))
- 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;
-}
-
-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 __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)
-{
- void *tmp;
- size_t len = 0;
-
- 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);
+ found = NULL;
+ len = 0;
+ }
+
+ if (!size) {
+ __ast_free_region(ptr, file, lineno, func);
return NULL;
}
- if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0)))
- return NULL;
-
- if (len > size)
- len = size;
- if (ptr) {
- memcpy(tmp, ptr, len);
- __ast_free_region(ptr, file, lineno, func);
- }
-
- 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)
@@ -335,15 +588,16 @@
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>|anomolies]\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"
+ " anomolies - Only check for fence violations.\n";
return NULL;
case CLI_GENERATE:
return NULL;
@@ -354,19 +608,10 @@
fn = a->argv[3];
ast_mutex_lock(®lock);
- for (x = 0; x < SOME_PRIME; x++) {
+ for (x = 0; x < ARRAY_LEN(regions); 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);
- }
+ region_check_fences(reg);
}
if (!fn || !strcasecmp(fn, reg->file)) {
ast_cli(a->fd, "%10d bytes allocated%s in %20s at line %5d of %s\n",
@@ -411,7 +656,7 @@
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 function, if a file is specified.\n";
return NULL;
case CLI_GENERATE:
return NULL;
@@ -421,7 +666,7 @@
fn = a->argv[3];
ast_mutex_lock(®lock);
- for (x = 0; x < SOME_PRIME; x++) {
+ for (x = 0; x < ARRAY_LEN(regions); x++) {
for (reg = regions[x]; reg; reg = reg->next) {
if (fn && strcasecmp(fn, reg->file))
continue;
@@ -483,14 +728,55 @@
AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
};
-void __ast_mm_init(void)
+/*!
+ * \internal
+ * \return Nothing
+ */
+static void mm_atexit_final(void)
+{
+ FILE *log;
+
+ /* Flush all delayed memory free circular arrays. */
+ freed_regions_flush(&whales);
+ freed_regions_flush(&minnows);
+
+ /* 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];
- 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, ARRAY_LEN(cli_memory));
@@ -498,10 +784,15 @@
ast_verb(1, "Asterisk Malloc Debugger Started (see %s))\n", filename);
- if ((mmlog = fopen(filename, "a+"))) {
- fprintf(mmlog, "%ld - New session\n", (long)time(NULL));
+ mmlog = fopen(filename, "a+");
+ if (mmlog) {
+ fprintf(mmlog, "%ld - New session\n", (long) time(NULL));
fflush(mmlog);
- }
-}
-
-#endif
+ } else {
+ ast_log(LOG_ERROR, "Could not open malloc debug log file: %s\n", filename);
+ }
+
+ ast_register_atexit(mm_atexit_ast);
+}
+
+#endif /* defined(__AST_DEBUG_MALLOC) */
Modified: branches/11/main/utils.c
URL: http://svnview.digium.com/svn/asterisk/branches/11/main/utils.c?view=diff&rev=376048&r1=376047&r2=376048
==============================================================================
--- branches/11/main/utils.c (original)
+++ branches/11/main/utils.c Thu Nov 8 11:26:16 2012
@@ -2219,3 +2219,35 @@
return NULL;
}
+void ast_do_crash(void)
+{
+#if defined(DO_CRASH)
+ abort();
+ /*
+ * Just in case abort() doesn't work or something else super
+ * silly, and for Qwell's amusement.
+ */
+ *((int *) 0) = 0;
+#endif /* defined(DO_CRASH) */
+}
+
+#if defined(AST_DEVMODE)
+void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function)
+{
+ /*
+ * Attempt to put it into the logger, but hope that at least
+ * someone saw the message on stderr ...
+ */
+ ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
+ condition_str, condition);
+ fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
+ condition_str, condition, line, function, file);
+ /*
+ * Give the logger a chance to get the message out, just in case
+ * we abort(), or Asterisk crashes due to whatever problem just
+ * happened after we exit ast_assert().
+ */
+ usleep(1);
+ ast_do_crash();
+}
+#endif /* defined(AST_DEVMODE) */
More information about the asterisk-commits
mailing list