astmm.c File Reference

Memory Management. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include <stddef.h>
#include <time.h>
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/strings.h"
#include "asterisk/unaligned.h"

Include dependency graph for astmm.c:

Go to the source code of this file.

Data Structures
struct	ast_region
Defines
#define	astmm_log(...)
#define	FENCE_MAGIC   0xdeadbeef
#define	HASH(a)   (((unsigned long)(a)) % SOME_PRIME)
#define	SOME_PRIME   563
Enumerations
enum	func_type {   FUNC_CALLOC = 1, FUNC_MALLOC, FUNC_REALLOC, FUNC_STRDUP,   FUNC_STRNDUP, FUNC_VASPRINTF, FUNC_ASPRINTF }
Functions
static void *	__ast_alloc_region (size_t size, const enum func_type which, const char *file, int lineno, const char *func, unsigned int cache)
int	__ast_asprintf (const char *file, int lineno, const char *func, char **strp, const char *fmt,...)
void *	__ast_calloc (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	__ast_free (void *ptr, const char *file, int lineno, const char *func)
static void	__ast_free_region (void *ptr, const char *file, int lineno, const char *func)
void *	__ast_malloc (size_t size, const char *file, int lineno, const char *func)
void	__ast_mm_init (void)
void *	__ast_realloc (void *ptr, size_t size, const char *file, int lineno, const char *func)
static size_t	__ast_sizeof_region (void *ptr)
char *	__ast_strdup (const char *s, 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)
int	__ast_vasprintf (char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
static char *	handle_memory_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_memory_show_summary (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Variables
static struct ast_cli_entry	cli_memory []
static FILE *	mmlog
static struct ast_region *	regions [SOME_PRIME]
static ast_mutex_t	reglock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP )

---

Detailed Description

Memory Management.

Author:

Mark Spencer <markster@digium.com>

Definition in file astmm.c.

---

Define Documentation

#define astmm_log

(

...

)

Definition at line 98 of file astmm.c.

Referenced by __ast_alloc_region(), __ast_free_region(), __ast_realloc(), and handle_memory_show().

#define FENCE_MAGIC   0xdeadbeef

Definition at line 63 of file astmm.c.

Referenced by __ast_alloc_region(), __ast_free_region(), and handle_memory_show().

#define HASH

(

a

)

(((unsigned long)(a)) % SOME_PRIME)

Definition at line 91 of file astmm.c.

Referenced by __ast_alloc_region(), __ast_free_region(), and __ast_sizeof_region().

#define SOME_PRIME   563

Definition at line 41 of file astmm.c.

Referenced by handle_memory_show(), and handle_memory_show_summary().

---

Enumeration Type Documentation

enum func_type

Enumerator:

FUNC_CALLOC
FUNC_MALLOC
FUNC_REALLOC
FUNC_STRDUP
FUNC_STRNDUP
FUNC_VASPRINTF
FUNC_ASPRINTF

Definition at line 43 of file astmm.c.

               {
   FUNC_CALLOC = 1,
   FUNC_MALLOC,
   FUNC_REALLOC,
   FUNC_STRDUP,
   FUNC_STRNDUP,
   FUNC_VASPRINTF,
   FUNC_ASPRINTF
};

---

Function Documentation

static void* __ast_alloc_region	(	size_t	size,
		const enum func_type	which,
		const char *	file,
		int	lineno,
		const char *	func,
		unsigned int	cache
	)			[inline, static]

Definition at line 107 of file astmm.c.

References ast_copy_string(), ast_mutex_lock(), ast_mutex_unlock(), astmm_log, ast_region::cache, ast_region::data, ast_region::fence, FENCE_MAGIC, ast_region::file, ast_region::func, HASH, ast_region::len, ast_region::lineno, malloc, ast_region::next, put_unaligned_uint32(), regions, reglock, and ast_region::which.

Referenced by __ast_asprintf(), __ast_calloc(), __ast_calloc_cache(), __ast_malloc(), __ast_realloc(), __ast_strdup(), __ast_strndup(), and __ast_vasprintf().

{
   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);
      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);
   put_unaligned_uint32(fence, FENCE_MAGIC);

   ast_mutex_lock(&reglock);
   reg->next = regions[hash];
   regions[hash] = reg;
   ast_mutex_unlock(&reglock);

   return ptr;
}

int __ast_asprintf	(	const char *	file,
		int	lineno,
		const char *	func,
		char **	strp,
		const char *	fmt,
			...
	)

Definition at line 285 of file astmm.c.

References __ast_alloc_region(), FUNC_ASPRINTF, and s.

{
   int size;
   va_list ap, ap2;
   char s;

   *strp = NULL;
   va_start(ap, fmt);
   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, 0))) {
      va_end(ap);
      return -1;
   }
   vsnprintf(*strp, size + 1, fmt, ap);
   va_end(ap);

   return size;
}

void* __ast_calloc	(	size_t	nmemb,
		size_t	size,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 199 of file astmm.c.

References __ast_alloc_region(), and FUNC_CALLOC.

Referenced by __ao2_alloc(), __ast_channel_alloc_ap(), __ast_datastore_alloc(), add_string_pool(), ast_hashtab_create(), ast_hashtab_dup(), ast_hashtab_insert_immediate_bucket(), ast_hashtab_resize(), ast_hashtab_start_traversal(), ast_hashtab_start_write_traversal(), ast_heap_create(), ast_var_assign(), and ast_variable_new().

{
   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
	)

Definition at line 209 of file astmm.c.

References __ast_alloc_region(), and FUNC_CALLOC.

{
   void *ptr;

   if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1))) 
      memset(ptr, 0, size * nmemb);

   return ptr;
}

void __ast_free	(	void *	ptr,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 224 of file astmm.c.

References __ast_free_region().

{
   __ast_free_region(ptr, file, lineno, func);
}

static void __ast_free_region	(	void *	ptr,
		const char *	file,
		int	lineno,
		const char *	func
	)			[static]

Definition at line 158 of file astmm.c.

References ast_mutex_lock(), ast_mutex_unlock(), astmm_log, ast_region::data, ast_region::fence, FENCE_MAGIC, ast_region::file, free, ast_region::func, get_unaligned_uint32(), HASH, ast_region::len, ast_region::lineno, ast_region::next, regions, and reglock.

Referenced by __ast_free(), and __ast_realloc().

{
   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) {
         if (prev)
            prev->next = reg->next;
         else
            regions[hash] = reg->next;
         break;
      }
      prev = reg;
   }
   ast_mutex_unlock(&reglock);

   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);
   } else {
      astmm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",  
         ptr, func, file, lineno);
   }
}

void* __ast_malloc	(	size_t	size,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 219 of file astmm.c.

References __ast_alloc_region(), and FUNC_MALLOC.

{
   return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
}

void __ast_mm_init

(

void

)

Definition at line 481 of file astmm.c.

References ARRAY_LEN, ast_cli_register_multiple(), ast_config_AST_LOG_DIR, ast_log(), ast_verb, and LOG_ERROR.

Referenced by main().

{
   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));
   
   snprintf(filename, sizeof(filename), "%s/mmlog", ast_config_AST_LOG_DIR);
   
   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));
      fflush(mmlog);
   }
}

void* __ast_realloc	(	void *	ptr,
		size_t	size,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 229 of file astmm.c.

References __ast_alloc_region(), __ast_free_region(), __ast_sizeof_region(), astmm_log, FUNC_REALLOC, and len().

Referenced by grow_heap().

{
   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);
      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;
}

static size_t __ast_sizeof_region

(

void *

ptr

)

[inline, static]

Definition at line 140 of file astmm.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_region::data, HASH, ast_region::len, len(), ast_region::next, regions, and reglock.

Referenced by __ast_realloc().

{
   int hash = HASH(ptr);
   struct ast_region *reg;
   size_t len = 0;
   
   ast_mutex_lock(&reglock);
   for (reg = regions[hash]; reg; reg = reg->next) {
      if (reg->data == ptr) {
         len = reg->len;
         break;
      }
   }
   ast_mutex_unlock(&reglock);

   return len;
}

char* __ast_strdup	(	const char *	s,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 253 of file astmm.c.

References __ast_alloc_region(), FUNC_STRDUP, and len().

{
   size_t len;
   void *ptr;

   if (!s)
      return NULL;

   len = strlen(s) + 1;
   if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func, 0)))
      strcpy(ptr, s);

   return ptr;
}

char* __ast_strndup	(	const char *	s,
		size_t	n,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 268 of file astmm.c.

References __ast_alloc_region(), FUNC_STRNDUP, and len().

{
   size_t len;
   void *ptr;

   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);

   return ptr;
}

int __ast_vasprintf	(	char **	strp,
		const char *	fmt,
		va_list	ap,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 306 of file astmm.c.

References __ast_alloc_region(), FUNC_VASPRINTF, and s.

{
   int size;
   va_list ap2;
   char s;

   *strp = NULL;
   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, 0))) {
      va_end(ap);
      return -1;
   }
   vsnprintf(*strp, size + 1, fmt, ap);

   return size;
}

static char* handle_memory_show	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

Definition at line 325 of file astmm.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), astmm_log, ast_region::cache, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_region::data, ast_cli_args::fd, ast_region::fence, FENCE_MAGIC, ast_region::file, ast_region::func, get_unaligned_uint32(), ast_region::len, len(), ast_region::lineno, ast_region::next, regions, reglock, SOME_PRIME, and ast_cli_entry::usage.

{
   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;

   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(&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);
            }
         }
         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++;
         }
      }
   }
   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);
   
   return CLI_SUCCESS;
}

static char* handle_memory_show_summary	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

Definition at line 387 of file astmm.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), ast_mutex_lock(), ast_mutex_unlock(), ast_region::cache, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_region::file, ast_region::func, ast_region::len, len(), ast_region::next, regions, reglock, SOME_PRIME, and ast_cli_entry::usage.

{
   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;
   
   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++) {
      for (reg = regions[x]; reg; reg = reg->next) {
         if (fn && 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)))
               break;
         }
         if (!cur) {
            cur = 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->len += reg->len;
         if (reg->cache)
            cur->cache_len += reg->len;
         cur->count++;
      }
   }
   ast_mutex_unlock(&reglock);
   
   /* Dump the whole list */
   for (cur = list; cur; cur = cur->next) {
      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 {
         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);
         }
      }
   }

   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 CLI_SUCCESS;
}

---

Variable Documentation

struct ast_cli_entry cli_memory[] [static]

Initial value:

 {
   AST_CLI_DEFINE(handle_memory_show, "Display outstanding memory allocations"),
   AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
}

Definition at line 476 of file astmm.c.

FILE* mmlog [static]

Definition at line 65 of file astmm.c.

struct ast_region * regions[SOME_PRIME] [static]

Referenced by __ast_alloc_region(), __ast_free_region(), __ast_sizeof_region(), handle_memory_show(), and handle_memory_show_summary().

ast_mutex_t reglock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static]

Tracking this mutex will cause infinite recursion, as the mutex tracking code allocates memory

Definition at line 96 of file astmm.c.

Referenced by __ast_alloc_region(), __ast_free_region(), __ast_sizeof_region(), handle_memory_show(), and handle_memory_show_summary().