astmm.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Channel Variables
   5  *
   6  * Copyright (C) 2002, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14
  15
  16 #ifdef __AST_DEBUG_MALLOC
  17
  18 #include <malloc.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <pthread.h>
  22 #include <time.h>
  23 #include <asterisk/cli.h>
  24 #include <asterisk/logger.h>
  25 #include <asterisk/options.h>
  26
  27 #define SOME_PRIME 563
  28
  29 #define FUNC_CALLOC             1
  30 #define FUNC_MALLOC             2
  31 #define FUNC_REALLOC    3
  32 #define FUNC_STRDUP             4
  33 #define FUNC_STRNDUP    5
  34
  35 /* Undefine all our macros */
  36 #undef malloc
  37 #undef calloc
  38 #undef realloc
  39 #undef strdup
  40 #undef strndup
  41 #undef free
  42
  43 static FILE *mmlog;
  44
  45 static struct ast_region {
  46         struct ast_region *next;
  47         char file[40];
  48         char func[40];
  49         int lineno;
  50         int which;
  51         size_t len;
  52         unsigned char data[0];
  53 } *regions[SOME_PRIME];
  54
  55 #define HASH(a) \
  56         (((unsigned long)(a)) % SOME_PRIME)
  57
  58 static pthread_mutex_t reglock = PTHREAD_MUTEX_INITIALIZER;
  59
  60 static inline void *__ast_alloc_region(size_t size, int which, const char *file, int lineno, const char *func)
  61 {
  62         struct ast_region *reg;
  63         void *ptr=NULL;
  64         int hash;
  65         reg = malloc(size + sizeof(struct ast_region));
  66         pthread_mutex_lock(&reglock);
  67         if (reg) {
  68                 strncpy(reg->file, file, sizeof(reg->file) - 1);
  69                 reg->file[sizeof(reg->file) - 1] = '\0';
  70                 strncpy(reg->func, func, sizeof(reg->func) - 1);
  71                 reg->func[sizeof(reg->func) - 1] = '\0';
  72                 reg->lineno = lineno;
  73                 reg->len = size;
  74                 reg->which = which;
  75                 ptr = reg->data;
  76                 hash = HASH(ptr);
  77                 reg->next = regions[hash];
  78                 regions[hash] = reg;
  79         }
  80         pthread_mutex_unlock(&reglock);
  81         if (!reg) {
  82                 fprintf(stderr, "Out of memory :(\n");
  83                 if (mmlog) {
  84                         fprintf(mmlog, "%ld - Out of memory\n", time(NULL));
  85                         fflush(mmlog);
  86                 }
  87         }
  88         return ptr;
  89 }
  90
  91 static inline size_t __ast_sizeof_region(void *ptr)
  92 {
  93         int hash = HASH(ptr);
  94         struct ast_region *reg;
  95         size_t len = 0;
  96
  97         pthread_mutex_lock(&reglock);
  98         reg = regions[hash];
  99         while(reg) {
 100                 if (reg->data == ptr) {
 101                         len = reg->len;
 102                         break;
 103                 }
 104                 reg = reg->next;
 105         }
 106         pthread_mutex_unlock(&reglock);
 107         return len;
 108 }
 109
 110 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
 111 {
 112         int hash = HASH(ptr);
 113         struct ast_region *reg, *prev = NULL;
 114         pthread_mutex_lock(&reglock);
 115         reg = regions[hash];
 116         while(reg) {
 117                 if (reg->data == ptr) {
 118                         if (prev)
 119                                 prev->next = reg->next;
 120                         else
 121                                 regions[hash] = reg->next;
 122
 123                         break;
 124                 }
 125                 prev = reg;
 126                 reg = reg->next;
 127         }
 128         pthread_mutex_unlock(&reglock);
 129         if (reg) {
 130                 free(reg);
 131         } else {
 132                 fprintf(stderr, "WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",
 133                         ptr, func, file, lineno);
 134                 if (mmlog) {
 135                         fprintf(mmlog, "%ld - WARNING: Freeing unused memory at %p, in %s of %s, line %d\n", time(NULL),
 136                         ptr, func, file, lineno);
 137                         fflush(mmlog);
 138                 }
 139         }
 140 }
 141
 142 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 143 {
 144         void *ptr;
 145         ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func);
 146         if (ptr)
 147                 memset(ptr, 0, size * nmemb);
 148         return ptr;
 149 }
 150
 151 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func)
 152 {
 153         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func);
 154 }
 155
 156 void __ast_free(void *ptr, const char *file, int lineno, const char *func)
 157 {
 158         __ast_free_region(ptr, file, lineno, func);
 159 }
 160
 161 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
 162 {
 163         void *tmp;
 164         size_t len=0;
 165         if (ptr) {
 166                 len = __ast_sizeof_region(ptr);
 167                 if (!len) {
 168                         fprintf(stderr, "WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n",
 169                                 ptr, func, file, lineno);
 170                         if (mmlog) {
 171                                 fprintf(mmlog, "%ld - WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n",
 172                                         time(NULL), ptr, func, file, lineno);
 173                                 fflush(mmlog);
 174                         }
 175                         return NULL;
 176                 }
 177         }
 178         tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func);
 179         if (tmp) {
 180                 if (len > size)
 181                         len = size;
 182                 if (ptr) {
 183                         memcpy(tmp, ptr, len);
 184                         __ast_free_region(ptr, file, lineno, func);
 185                 }
 186         }
 187         return tmp;
 188 }
 189
 190 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func)
 191 {
 192         size_t len;
 193         void *ptr;
 194         if (!s)
 195                 return NULL;
 196         len = strlen(s) + 1;
 197         ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func);
 198         if (ptr)
 199                 strcpy(ptr, s);
 200         return ptr;
 201 }
 202
 203 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
 204 {
 205         size_t len;
 206         void *ptr;
 207         if (!s)
 208                 return NULL;
 209         len = strlen(s) + 1;
 210         if (len > n)
 211                 len = n;
 212         ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func);
 213         if (ptr)
 214                 strcpy(ptr, s);
 215         return ptr;
 216 }
 217
 218 static int handle_show_memory(int fd, int argc, char *argv[])
 219 {
 220         char *fn = NULL;
 221         int x;
 222         struct ast_region *reg;
 223         unsigned int len=0;
 224         int count = 0;
 225         if (argc >3)
 226                 fn = argv[3];
 227
 228         /* try to lock applications list ... */
 229         pthread_mutex_lock(&reglock);
 230
 231         for (x=0;x<SOME_PRIME;x++) {
 232                 reg = regions[x];
 233                 while(reg) {
 234                         if (!fn || !strcasecmp(fn, reg->file)) {
 235                                 ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %s\n", reg->len, reg->func, reg->lineno, reg->file);
 236                                 len += reg->len;
 237                                 count++;
 238                         }
 239                         reg = reg->next;
 240                 }
 241         }
 242         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
 243         pthread_mutex_unlock(&reglock);
 244         return RESULT_SUCCESS;
 245 }
 246
 247 struct file_summary {
 248         char fn[80];
 249         int len;
 250         int count;
 251         struct file_summary *next;
 252 };
 253
 254 static int handle_show_memory_summary(int fd, int argc, char *argv[])
 255 {
 256         char *fn = NULL;
 257         int x;
 258         struct ast_region *reg;
 259         unsigned int len=0;
 260         int count = 0;
 261         struct file_summary *list = NULL, *cur;
 262
 263         if (argc >3)
 264                 fn = argv[3];
 265
 266         /* try to lock applications list ... */
 267         pthread_mutex_lock(&reglock);
 268
 269         for (x=0;x<SOME_PRIME;x++) {
 270                 reg = regions[x];
 271                 while(reg) {
 272                         if (!fn || !strcasecmp(fn, reg->file)) {
 273                                 cur = list;
 274                                 while(cur) {
 275                                         if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
 276                                                 break;
 277                                         cur = cur->next;
 278                                 }
 279                                 if (!cur) {
 280                                         cur = alloca(sizeof(struct file_summary));
 281                                         memset(cur, 0, sizeof(struct file_summary));
 282                                         strncpy(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn) - 1);
 283                                         cur->next = list;
 284                                         list = cur;
 285                                 }
 286                                 cur->len += reg->len;
 287                                 cur->count++;
 288                         }
 289                         reg = reg->next;
 290                 }
 291         }
 292         pthread_mutex_unlock(&reglock);
 293
 294         /* Dump the whole list */
 295         while(list) {
 296                 cur = list;
 297                 len += list->len;
 298                 count += list->count;
 299                 if (fn)
 300                         ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n", list->len, list->count, list->fn, fn);
 301                 else
 302                         ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n", list->len, list->count, list->fn);
 303                 list = list->next;
 304 #if 0
 305                 free(cur);
 306 #endif
 307         }
 308         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
 309         return RESULT_SUCCESS;
 310 }
 311
 312 static char show_memory_help[] =
 313 "Usage: show memory allocations [<file>]\n"
 314 "       Dumps a list of all segments of allocated memory, optionally\n"
 315 "limited to those from a specific file\n";
 316
 317 static char show_memory_summary_help[] =
 318 "Usage: show memory summary [<file>]\n"
 319 "       Summarizes heap memory allocations by file, or optionally\n"
 320 "by function, if a file is specified\n";
 321
 322 static struct ast_cli_entry show_memory_allocations_cli =
 323         { { "show", "memory", "allocations", NULL },
 324         handle_show_memory, "Display outstanding memory allocations",
 325         show_memory_help };
 326
 327 static struct ast_cli_entry show_memory_summary_cli =
 328         { { "show", "memory", "summary", NULL },
 329         handle_show_memory_summary, "Summarize outstanding memory allocations",
 330         show_memory_summary_help };
 331
 332
 333 void __ast_mm_init(void)
 334 {
 335         ast_cli_register(&show_memory_allocations_cli);
 336         ast_cli_register(&show_memory_summary_cli);
 337         mmlog = fopen("/var/log/asterisk/mmlog", "a+");
 338         if (option_verbose)
 339                 ast_verbose("Asterisk Malloc Debugger Started (see /var/log/asterisk/mmlog)\n");
 340         if (mmlog) {
 341                 fprintf(mmlog, "%ld - New session\n", time(NULL));
 342                 fflush(mmlog);
 343         }
 344 }
 345
 346 #endif