main/astmm.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Memory Management
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  */
  25
  26 #ifdef __AST_DEBUG_MALLOC
  27
  28 #include "asterisk.h"
  29
  30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  31
  32 #include "asterisk/paths.h"     /* use ast_config_AST_LOG_DIR */
  33 #include <time.h>
  34
  35 #include "asterisk/cli.h"
  36 #include "asterisk/lock.h"
  37 #include "asterisk/strings.h"
  38 #include "asterisk/unaligned.h"
  39
  40 #define SOME_PRIME 563
  41
  42 enum func_type {
  43         FUNC_CALLOC = 1,
  44         FUNC_MALLOC,
  45         FUNC_REALLOC,
  46         FUNC_STRDUP,
  47         FUNC_STRNDUP,
  48         FUNC_VASPRINTF,
  49         FUNC_ASPRINTF
  50 };
  51
  52 /* Undefine all our macros */
  53 #undef malloc
  54 #undef calloc
  55 #undef realloc
  56 #undef strdup
  57 #undef strndup
  58 #undef free
  59 #undef vasprintf
  60 #undef asprintf
  61
  62 #define FENCE_MAGIC 0xdeadbeef
  63
  64 static FILE *mmlog;
  65
  66 static struct ast_region {
  67         struct ast_region *next;
  68         char file[64];
  69         char func[40];
  70         unsigned int lineno;
  71         enum func_type which;
  72         unsigned int cache;             /* region was allocated as part of a cache pool */
  73         size_t len;
  74         unsigned int fence;
  75         unsigned char data[0];
  76 } *regions[SOME_PRIME];
  77
  78 #define HASH(a) \
  79         (((unsigned long)(a)) % SOME_PRIME)
  80
  81 /*! Tracking this mutex will cause infinite recursion, as the mutex tracking
  82  *  code allocates memory */
  83 AST_MUTEX_DEFINE_STATIC_NOTRACKING(reglock);
  84
  85 #define astmm_log(...)                               \
  86         do {                                         \
  87                 fprintf(stderr, __VA_ARGS__);        \
  88                 if (mmlog) {                         \
  89                         fprintf(mmlog, __VA_ARGS__); \
  90                         fflush(mmlog);               \
  91                 }                                    \
  92         } while (0)
  93
  94 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)
  95 {
  96         struct ast_region *reg;
  97         void *ptr = NULL;
  98         unsigned int *fence;
  99         int hash;
 100
 101         if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
 102                 astmm_log("Memory Allocation Failure - '%d' bytes in function %s "
 103                           "at line %d of %s\n", (int) size, func, lineno, file);
 104         }
 105
 106         ast_copy_string(reg->file, file, sizeof(reg->file));
 107         ast_copy_string(reg->func, func, sizeof(reg->func));
 108         reg->lineno = lineno;
 109         reg->len = size;
 110         reg->which = which;
 111         reg->cache = cache;
 112         ptr = reg->data;
 113         hash = HASH(ptr);
 114         reg->fence = FENCE_MAGIC;
 115         fence = (ptr + reg->len);
 116         put_unaligned_uint32(fence, FENCE_MAGIC);
 117
 118         ast_mutex_lock(&reglock);
 119         reg->next = regions[hash];
 120         regions[hash] = reg;
 121         ast_mutex_unlock(&reglock);
 122
 123         return ptr;
 124 }
 125
 126 static inline size_t __ast_sizeof_region(void *ptr)
 127 {
 128         int hash = HASH(ptr);
 129         struct ast_region *reg;
 130         size_t len = 0;
 131
 132         ast_mutex_lock(&reglock);
 133         for (reg = regions[hash]; reg; reg = reg->next) {
 134                 if (reg->data == ptr) {
 135                         len = reg->len;
 136                         break;
 137                 }
 138         }
 139         ast_mutex_unlock(&reglock);
 140
 141         return len;
 142 }
 143
 144 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
 145 {
 146         int hash = HASH(ptr);
 147         struct ast_region *reg, *prev = NULL;
 148         unsigned int *fence;
 149
 150         ast_mutex_lock(&reglock);
 151         for (reg = regions[hash]; reg; reg = reg->next) {
 152                 if (reg->data == ptr) {
 153                         if (prev)
 154                                 prev->next = reg->next;
 155                         else
 156                                 regions[hash] = reg->next;
 157                         break;
 158                 }
 159                 prev = reg;
 160         }
 161         ast_mutex_unlock(&reglock);
 162
 163         if (reg) {
 164                 fence = (unsigned int *)(reg->data + reg->len);
 165                 if (reg->fence != FENCE_MAGIC) {
 166                         astmm_log("WARNING: Low fence violation at %p, in %s of %s, "
 167                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
 168                 }
 169                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
 170                         astmm_log("WARNING: High fence violation at %p, in %s of %s, "
 171                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
 172                 }
 173                 free(reg);
 174         } else {
 175                 astmm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",
 176                         ptr, func, file, lineno);
 177         }
 178 }
 179
 180 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 181 {
 182         void *ptr;
 183
 184         if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0)))
 185                 memset(ptr, 0, size * nmemb);
 186
 187         return ptr;
 188 }
 189
 190 void *__ast_calloc_cache(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
 191 {
 192         void *ptr;
 193
 194         if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1)))
 195                 memset(ptr, 0, size * nmemb);
 196
 197         return ptr;
 198 }
 199
 200 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func)
 201 {
 202         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
 203 }
 204
 205 void __ast_free(void *ptr, const char *file, int lineno, const char *func)
 206 {
 207         __ast_free_region(ptr, file, lineno, func);
 208 }
 209
 210 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
 211 {
 212         void *tmp;
 213         size_t len = 0;
 214
 215         if (ptr && !(len = __ast_sizeof_region(ptr))) {
 216                 astmm_log("WARNING: Realloc of unalloced memory at %p, in %s of %s, "
 217                         "line %d\n", ptr, func, file, lineno);
 218                 return NULL;
 219         }
 220
 221         if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0)))
 222                 return NULL;
 223
 224         if (len > size)
 225                 len = size;
 226         if (ptr) {
 227                 memcpy(tmp, ptr, len);
 228                 __ast_free_region(ptr, file, lineno, func);
 229         }
 230
 231         return tmp;
 232 }
 233
 234 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func)
 235 {
 236         size_t len;
 237         void *ptr;
 238
 239         if (!s)
 240                 return NULL;
 241
 242         len = strlen(s) + 1;
 243         if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func, 0)))
 244                 strcpy(ptr, s);
 245
 246         return ptr;
 247 }
 248
 249 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
 250 {
 251         size_t len;
 252         void *ptr;
 253
 254         if (!s)
 255                 return NULL;
 256
 257         len = strlen(s) + 1;
 258         if (len > n)
 259                 len = n;
 260         if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func, 0)))
 261                 strcpy(ptr, s);
 262
 263         return ptr;
 264 }
 265
 266 int __ast_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
 267 {
 268         int size;
 269         va_list ap, ap2;
 270         char s;
 271
 272         *strp = NULL;
 273         va_start(ap, fmt);
 274         va_copy(ap2, ap);
 275         size = vsnprintf(&s, 1, fmt, ap2);
 276         va_end(ap2);
 277         if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func, 0))) {
 278                 va_end(ap);
 279                 return -1;
 280         }
 281         vsnprintf(*strp, size + 1, fmt, ap);
 282         va_end(ap);
 283
 284         return size;
 285 }
 286
 287 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
 288 {
 289         int size;
 290         va_list ap2;
 291         char s;
 292
 293         *strp = NULL;
 294         va_copy(ap2, ap);
 295         size = vsnprintf(&s, 1, fmt, ap2);
 296         va_end(ap2);
 297         if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func, 0))) {
 298                 va_end(ap);
 299                 return -1;
 300         }
 301         vsnprintf(*strp, size + 1, fmt, ap);
 302
 303         return size;
 304 }
 305
 306 static char *handle_memory_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 307 {
 308         char *fn = NULL;
 309         struct ast_region *reg;
 310         unsigned int x;
 311         unsigned int len = 0;
 312         unsigned int cache_len = 0;
 313         unsigned int count = 0;
 314         unsigned int *fence;
 315
 316         switch (cmd) {
 317         case CLI_INIT:
 318                 e->command = "memory show allocations";
 319                 e->usage =
 320                         "Usage: memory show allocations [<file>]\n"
 321                         "       Dumps a list of all segments of allocated memory, optionally\n"
 322                         "       limited to those from a specific file\n";
 323                 return NULL;
 324         case CLI_GENERATE:
 325                 return NULL;
 326         }
 327
 328
 329         if (a->argc > 3)
 330                 fn = a->argv[3];
 331
 332         ast_mutex_lock(&reglock);
 333         for (x = 0; x < SOME_PRIME; x++) {
 334                 for (reg = regions[x]; reg; reg = reg->next) {
 335                         if (!fn || !strcasecmp(fn, reg->file) || !strcasecmp(fn, "anomolies")) {
 336                                 fence = (unsigned int *)(reg->data + reg->len);
 337                                 if (reg->fence != FENCE_MAGIC) {
 338                                         astmm_log("WARNING: Low fence violation at %p, "
 339                                                 "in %s of %s, line %d\n", reg->data,
 340                                                 reg->func, reg->file, reg->lineno);
 341                                 }
 342                                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
 343                                         astmm_log("WARNING: High fence violation at %p, in %s of %s, "
 344                                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
 345                                 }
 346                         }
 347                         if (!fn || !strcasecmp(fn, reg->file)) {
 348                                 ast_cli(a->fd, "%10d bytes allocated%s in %20s at line %5d of %s\n",
 349                                         (int) reg->len, reg->cache ? " (cache)" : "",
 350                                         reg->func, reg->lineno, reg->file);
 351                                 len += reg->len;
 352                                 if (reg->cache)
 353                                         cache_len += reg->len;
 354                                 count++;
 355                         }
 356                 }
 357         }
 358         ast_mutex_unlock(&reglock);
 359
 360         if (cache_len)
 361                 ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
 362         else
 363                 ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
 364
 365         return CLI_SUCCESS;
 366 }
 367
 368 static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 369 {
 370         char *fn = NULL;
 371         int x;
 372         struct ast_region *reg;
 373         unsigned int len = 0;
 374         unsigned int cache_len = 0;
 375         int count = 0;
 376         struct file_summary {
 377                 char fn[80];
 378                 int len;
 379                 int cache_len;
 380                 int count;
 381                 struct file_summary *next;
 382         } *list = NULL, *cur;
 383
 384         switch (cmd) {
 385         case CLI_INIT:
 386                 e->command = "memory show summary";
 387                 e->usage =
 388                         "Usage: memory show summary [<file>]\n"
 389                         "       Summarizes heap memory allocations by file, or optionally\n"
 390                         "by function, if a file is specified\n";
 391                 return NULL;
 392         case CLI_GENERATE:
 393                 return NULL;
 394         }
 395
 396         if (a->argc > 3)
 397                 fn = a->argv[3];
 398
 399         ast_mutex_lock(&reglock);
 400         for (x = 0; x < SOME_PRIME; x++) {
 401                 for (reg = regions[x]; reg; reg = reg->next) {
 402                         if (fn && strcasecmp(fn, reg->file))
 403                                 continue;
 404
 405                         for (cur = list; cur; cur = cur->next) {
 406                                 if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
 407                                         break;
 408                         }
 409                         if (!cur) {
 410                                 cur = alloca(sizeof(*cur));
 411                                 memset(cur, 0, sizeof(*cur));
 412                                 ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
 413                                 cur->next = list;
 414                                 list = cur;
 415                         }
 416
 417                         cur->len += reg->len;
 418                         if (reg->cache)
 419                                 cur->cache_len += reg->len;
 420                         cur->count++;
 421                 }
 422         }
 423         ast_mutex_unlock(&reglock);
 424
 425         /* Dump the whole list */
 426         for (cur = list; cur; cur = cur->next) {
 427                 len += cur->len;
 428                 cache_len += cur->cache_len;
 429                 count += cur->count;
 430                 if (cur->cache_len) {
 431                         if (fn) {
 432                                 ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in function '%s' of '%s'\n",
 433                                         cur->len, cur->cache_len, cur->count, cur->fn, fn);
 434                         } else {
 435                                 ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in file '%s'\n",
 436                                         cur->len, cur->cache_len, cur->count, cur->fn);
 437                         }
 438                 } else {
 439                         if (fn) {
 440                                 ast_cli(a->fd, "%10d bytes in %d allocations in function '%s' of '%s'\n",
 441                                         cur->len, cur->count, cur->fn, fn);
 442                         } else {
 443                                 ast_cli(a->fd, "%10d bytes in %d allocations in file '%s'\n",
 444                                         cur->len, cur->count, cur->fn);
 445                         }
 446                 }
 447         }
 448
 449         if (cache_len)
 450                 ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
 451         else
 452                 ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
 453
 454         return CLI_SUCCESS;
 455 }
 456
 457 static struct ast_cli_entry cli_memory[] = {
 458         AST_CLI_DEFINE(handle_memory_show, "Display outstanding memory allocations"),
 459         AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
 460 };
 461
 462 void __ast_mm_init(void)
 463 {
 464         char filename[PATH_MAX];
 465
 466         ast_cli_register_multiple(cli_memory, sizeof(cli_memory) / sizeof(struct ast_cli_entry));
 467
 468         snprintf(filename, sizeof(filename), "%s/mmlog", ast_config_AST_LOG_DIR);
 469
 470         ast_verb(1, "Asterisk Malloc Debugger Started (see %s))\n", filename);
 471
 472         if ((mmlog = fopen(filename, "a+"))) {
 473                 fprintf(mmlog, "%ld - New session\n", (long)time(NULL));
 474                 fflush(mmlog);
 475         }
 476 }
 477
 478 #endif