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 <stdio.h>
  33 #include <string.h>
  34 #include <time.h>
  35
  36 #include "asterisk/cli.h"
  37 #include "asterisk/logger.h"
  38 #include "asterisk/options.h"
  39 #include "asterisk/lock.h"
  40 #include "asterisk/strings.h"
  41 #include "asterisk/unaligned.h"
  42
  43 #define SOME_PRIME 563
  44
  45 enum func_type {
  46         FUNC_CALLOC = 1,
  47         FUNC_MALLOC,
  48         FUNC_REALLOC,
  49         FUNC_STRDUP,
  50         FUNC_STRNDUP,
  51         FUNC_VASPRINTF,
  52         FUNC_ASPRINTF
  53 };
  54
  55 /* Undefine all our macros */
  56 #undef malloc
  57 #undef calloc
  58 #undef realloc
  59 #undef strdup
  60 #undef strndup
  61 #undef free
  62 #undef vasprintf
  63 #undef asprintf
  64
  65 #define FENCE_MAGIC 0xdeadbeef
  66
  67 static FILE *mmlog;
  68
  69 static struct ast_region {
  70         struct ast_region *next;
  71         char file[40];
  72         char func[40];
  73         unsigned int lineno;
  74         enum func_type which;
  75         size_t len;
  76         unsigned int fence;
  77         unsigned char data[0];
  78 } *regions[SOME_PRIME];
  79
  80 #define HASH(a) \
  81         (((unsigned long)(a)) % SOME_PRIME)
  82
  83 AST_MUTEX_DEFINE_STATIC(reglock);
  84 AST_MUTEX_DEFINE_STATIC(showmemorylock);
  85
  86 #define astmm_log(...)                               \
  87         do {                                         \
  88                 fprintf(stderr, __VA_ARGS__);        \
  89                 if (mmlog) {                         \
  90                         fprintf(mmlog, __VA_ARGS__); \
  91                         fflush(mmlog);               \
  92                 }                                    \
  93         } while (0)
  94
  95 static inline void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func)
  96 {
  97         struct ast_region *reg;
  98         void *ptr = NULL;
  99         unsigned int *fence;
 100         int hash;
 101
 102         if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
 103                 astmm_log("Memory Allocation Failure - '%d' bytes in function %s "
 104                         "at line %d of %s\n", (int) size, func, lineno, file);
 105         }
 106
 107         ast_copy_string(reg->file, file, sizeof(reg->file));
 108         ast_copy_string(reg->func, func, sizeof(reg->func));
 109         reg->lineno = lineno;
 110         reg->len = size;
 111         reg->which = which;
 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)))
 185                 memset(ptr, 0, size * nmemb);
 186
 187         return ptr;
 188 }
 189
 190 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func)
 191 {
 192         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func);
 193 }
 194
 195 void __ast_free(void *ptr, const char *file, int lineno, const char *func)
 196 {
 197         __ast_free_region(ptr, file, lineno, func);
 198 }
 199
 200 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
 201 {
 202         void *tmp;
 203         size_t len = 0;
 204
 205         if (ptr && !(len = __ast_sizeof_region(ptr))) {
 206                 astmm_log("WARNING: Realloc of unalloced memory at %p, in %s of %s, "
 207                         "line %d\n", ptr, func, file, lineno);
 208                 return NULL;
 209         }
 210
 211         if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func)))
 212                 return NULL;
 213
 214         if (len > size)
 215                 len = size;
 216         if (ptr) {
 217                 memcpy(tmp, ptr, len);
 218                 __ast_free_region(ptr, file, lineno, func);
 219         }
 220
 221         return tmp;
 222 }
 223
 224 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func)
 225 {
 226         size_t len;
 227         void *ptr;
 228
 229         if (!s)
 230                 return NULL;
 231
 232         len = strlen(s) + 1;
 233         if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func)))
 234                 strcpy(ptr, s);
 235
 236         return ptr;
 237 }
 238
 239 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
 240 {
 241         size_t len;
 242         void *ptr;
 243
 244         if (!s)
 245                 return NULL;
 246
 247         len = strlen(s) + 1;
 248         if (len > n)
 249                 len = n;
 250         if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func)))
 251                 strcpy(ptr, s);
 252
 253         return ptr;
 254 }
 255
 256 int __ast_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
 257 {
 258         int size;
 259         va_list ap, ap2;
 260         char s;
 261
 262         *strp = NULL;
 263         va_start(ap, fmt);
 264         va_copy(ap2, ap);
 265         size = vsnprintf(&s, 1, fmt, ap2);
 266         va_end(ap2);
 267         if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func))) {
 268                 va_end(ap);
 269                 return -1;
 270         }
 271         vsnprintf(*strp, size + 1, fmt, ap);
 272         va_end(ap);
 273
 274         return size;
 275 }
 276
 277 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
 278 {
 279         int size;
 280         va_list ap2;
 281         char s;
 282
 283         *strp = NULL;
 284         va_copy(ap2, ap);
 285         size = vsnprintf(&s, 1, fmt, ap2);
 286         va_end(ap2);
 287         if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func))) {
 288                 va_end(ap);
 289                 return -1;
 290         }
 291         vsnprintf(*strp, size + 1, fmt, ap);
 292
 293         return size;
 294 }
 295
 296 static int handle_show_memory(int fd, int argc, char *argv[])
 297 {
 298         char *fn = NULL;
 299         struct ast_region *reg;
 300         unsigned int x;
 301         unsigned int len = 0;
 302         unsigned int count = 0;
 303         unsigned int *fence;
 304
 305         if (argc > 3)
 306                 fn = argv[3];
 307
 308         ast_mutex_lock(&showmemorylock);
 309         for (x = 0; x < SOME_PRIME; x++) {
 310                 for (reg = regions[x]; reg; reg = reg->next) {
 311                         if (!fn || !strcasecmp(fn, reg->file) || !strcasecmp(fn, "anomolies")) {
 312                                 fence = (unsigned int *)(reg->data + reg->len);
 313                                 if (reg->fence != FENCE_MAGIC) {
 314                                         astmm_log("WARNING: Low fence violation at %p, "
 315                                                 "in %s of %s, line %d\n", reg->data,
 316                                                 reg->func, reg->file, reg->lineno);
 317                                 }
 318                                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
 319                                         astmm_log("WARNING: High fence violation at %p, in %s of %s, "
 320                                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
 321                                 }
 322                         }
 323                         if (!fn || !strcasecmp(fn, reg->file)) {
 324                                 ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %s\n",
 325                                                 (int) reg->len, reg->func, reg->lineno, reg->file);
 326                                 len += reg->len;
 327                                 count++;
 328                         }
 329                 }
 330         }
 331         ast_mutex_unlock(&showmemorylock);
 332
 333         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
 334
 335         return RESULT_SUCCESS;
 336 }
 337
 338 static int handle_show_memory_summary(int fd, int argc, char *argv[])
 339 {
 340         char *fn = NULL;
 341         int x;
 342         struct ast_region *reg;
 343         unsigned int len = 0;
 344         int count = 0;
 345         struct file_summary {
 346                 char fn[80];
 347                 int len;
 348                 int count;
 349                 struct file_summary *next;
 350         } *list = NULL, *cur;
 351
 352         if (argc > 3)
 353                 fn = argv[3];
 354
 355         ast_mutex_lock(&reglock);
 356         for (x = 0; x < SOME_PRIME; x++) {
 357                 for (reg = regions[x]; reg; reg = reg->next) {
 358                         if (fn && strcasecmp(fn, reg->file))
 359                                 continue;
 360
 361                         for (cur = list; cur; cur = cur->next) {
 362                                 if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
 363                                         break;
 364                         }
 365                         if (!cur) {
 366                                 cur = alloca(sizeof(*cur));
 367                                 memset(cur, 0, sizeof(*cur));
 368                                 ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
 369                                 cur->next = list;
 370                                 list = cur;
 371                         }
 372
 373                         cur->len += reg->len;
 374                         cur->count++;
 375                 }
 376         }
 377         ast_mutex_unlock(&reglock);
 378
 379         /* Dump the whole list */
 380         for (cur = list; cur; cur = cur->next) {
 381                 len += list->len;
 382                 count += list->count;
 383                 if (fn) {
 384                         ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n",
 385                                 list->len, list->count, list->fn, fn);
 386                 } else {
 387                         ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n",
 388                                 list->len, list->count, list->fn);
 389                 }
 390         }
 391
 392         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
 393
 394         return RESULT_SUCCESS;
 395 }
 396
 397 static char show_memory_help[] =
 398 "Usage: memory show allocations [<file>]\n"
 399 "       Dumps a list of all segments of allocated memory, optionally\n"
 400 "limited to those from a specific file\n";
 401
 402 static char show_memory_summary_help[] =
 403 "Usage: memory show summary [<file>]\n"
 404 "       Summarizes heap memory allocations by file, or optionally\n"
 405 "by function, if a file is specified\n";
 406
 407 static struct ast_cli_entry cli_show_memory_allocations_deprecated = {
 408         { "show", "memory", "allocations", NULL },
 409         handle_show_memory, NULL,
 410         NULL };
 411
 412 static struct ast_cli_entry cli_show_memory_summary_deprecated = {
 413         { "show", "memory", "summary", NULL },
 414         handle_show_memory_summary, NULL,
 415         NULL };
 416
 417 static struct ast_cli_entry cli_memory[] = {
 418         { { "memory", "show", "allocations", NULL },
 419         handle_show_memory, "Display outstanding memory allocations",
 420         show_memory_help, NULL, &cli_show_memory_allocations },
 421
 422         { { "memory", "show", "summary", NULL },
 423         handle_show_memory_summary, "Summarize outstanding memory allocations",
 424         show_memory_summary_help, NULL, &cli_show_memory_summary },
 425 };
 426
 427 void __ast_mm_init(void)
 428 {
 429         char filename[PATH_MAX];
 430
 431         ast_cli_register_multiple(cli_memory, sizeof(cli_memory) / sizeof(struct ast_cli_entry));
 432
 433         snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
 434
 435         if (option_verbose)
 436                 ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
 437
 438         if ((mmlog = fopen(filename, "a+"))) {
 439                 fprintf(mmlog, "%ld - New session\n", time(NULL));
 440                 fflush(mmlog);
 441         }
 442 }
 443
 444 #endif