Fix the memory show allocations CLI command so that it doesn't spew out all
[asterisk/asterisk.git] / 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         unsigned int cache;             /* region was allocated as part of a cache pool */
76         size_t len;
77         unsigned int fence;
78         unsigned char data[0];
79 } *regions[SOME_PRIME];
80
81 #define HASH(a) \
82         (((unsigned long)(a)) % SOME_PRIME)
83
84 /*! Tracking this mutex will cause infinite recursion, as the mutex tracking
85  *  code allocates memory */
86 AST_MUTEX_DEFINE_STATIC_NOTRACKING(reglock);
87
88 #define astmm_log(...)                               \
89         do {                                         \
90                 fprintf(stderr, __VA_ARGS__);        \
91                 if (mmlog) {                         \
92                         fprintf(mmlog, __VA_ARGS__); \
93                         fflush(mmlog);               \
94                 }                                    \
95         } while (0)
96
97 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)
98 {
99         struct ast_region *reg;
100         void *ptr = NULL;
101         unsigned int *fence;
102         int hash;
103
104         if (!(reg = malloc(size + sizeof(*reg) + sizeof(*fence)))) {
105                 astmm_log("Memory Allocation Failure - '%d' bytes in function %s "
106                           "at line %d of %s\n", (int) size, func, lineno, file);
107         }
108
109         ast_copy_string(reg->file, file, sizeof(reg->file));
110         ast_copy_string(reg->func, func, sizeof(reg->func));
111         reg->lineno = lineno;
112         reg->len = size;
113         reg->which = which;
114         reg->cache = cache;
115         ptr = reg->data;
116         hash = HASH(ptr);
117         reg->fence = FENCE_MAGIC;
118         fence = (ptr + reg->len);
119         put_unaligned_uint32(fence, FENCE_MAGIC);
120
121         ast_mutex_lock(&reglock);
122         reg->next = regions[hash];
123         regions[hash] = reg;
124         ast_mutex_unlock(&reglock);
125
126         return ptr;
127 }
128
129 static inline size_t __ast_sizeof_region(void *ptr)
130 {
131         int hash = HASH(ptr);
132         struct ast_region *reg;
133         size_t len = 0;
134         
135         ast_mutex_lock(&reglock);
136         for (reg = regions[hash]; reg; reg = reg->next) {
137                 if (reg->data == ptr) {
138                         len = reg->len;
139                         break;
140                 }
141         }
142         ast_mutex_unlock(&reglock);
143
144         return len;
145 }
146
147 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
148 {
149         int hash = HASH(ptr);
150         struct ast_region *reg, *prev = NULL;
151         unsigned int *fence;
152
153         ast_mutex_lock(&reglock);
154         for (reg = regions[hash]; reg; reg = reg->next) {
155                 if (reg->data == ptr) {
156                         if (prev)
157                                 prev->next = reg->next;
158                         else
159                                 regions[hash] = reg->next;
160                         break;
161                 }
162                 prev = reg;
163         }
164         ast_mutex_unlock(&reglock);
165
166         if (reg) {
167                 fence = (unsigned int *)(reg->data + reg->len);
168                 if (reg->fence != FENCE_MAGIC) {
169                         astmm_log("WARNING: Low fence violation at %p, in %s of %s, "
170                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
171                 }
172                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
173                         astmm_log("WARNING: High fence violation at %p, in %s of %s, "
174                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
175                 }
176                 free(reg);
177         } else {
178                 astmm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",       
179                         ptr, func, file, lineno);
180         }
181 }
182
183 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
184 {
185         void *ptr;
186
187         if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 0))) 
188                 memset(ptr, 0, size * nmemb);
189
190         return ptr;
191 }
192
193 void *__ast_calloc_cache(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
194 {
195         void *ptr;
196
197         if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func, 1))) 
198                 memset(ptr, 0, size * nmemb);
199
200         return ptr;
201 }
202
203 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func) 
204 {
205         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func, 0);
206 }
207
208 void __ast_free(void *ptr, const char *file, int lineno, const char *func) 
209 {
210         __ast_free_region(ptr, file, lineno, func);
211 }
212
213 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func) 
214 {
215         void *tmp;
216         size_t len = 0;
217
218         if (ptr && !(len = __ast_sizeof_region(ptr))) {
219                 astmm_log("WARNING: Realloc of unalloced memory at %p, in %s of %s, "
220                         "line %d\n", ptr, func, file, lineno);
221                 return NULL;
222         }
223
224         if (!(tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func, 0)))
225                 return NULL;
226
227         if (len > size)
228                 len = size;
229         if (ptr) {
230                 memcpy(tmp, ptr, len);
231                 __ast_free_region(ptr, file, lineno, func);
232         }
233         
234         return tmp;
235 }
236
237 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func) 
238 {
239         size_t len;
240         void *ptr;
241
242         if (!s)
243                 return NULL;
244
245         len = strlen(s) + 1;
246         if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func, 0)))
247                 strcpy(ptr, s);
248
249         return ptr;
250 }
251
252 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func) 
253 {
254         size_t len;
255         void *ptr;
256
257         if (!s)
258                 return NULL;
259
260         len = strlen(s) + 1;
261         if (len > n)
262                 len = n;
263         if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func, 0)))
264                 strcpy(ptr, s);
265
266         return ptr;
267 }
268
269 int __ast_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
270 {
271         int size;
272         va_list ap, ap2;
273         char s;
274
275         *strp = NULL;
276         va_start(ap, fmt);
277         va_copy(ap2, ap);
278         size = vsnprintf(&s, 1, fmt, ap2);
279         va_end(ap2);
280         if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func, 0))) {
281                 va_end(ap);
282                 return -1;
283         }
284         vsnprintf(*strp, size + 1, fmt, ap);
285         va_end(ap);
286
287         return size;
288 }
289
290 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func) 
291 {
292         int size;
293         va_list ap2;
294         char s;
295
296         *strp = NULL;
297         va_copy(ap2, ap);
298         size = vsnprintf(&s, 1, fmt, ap2);
299         va_end(ap2);
300         if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func, 0))) {
301                 va_end(ap);
302                 return -1;
303         }
304         vsnprintf(*strp, size + 1, fmt, ap);
305
306         return size;
307 }
308
309 static char *handle_memory_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
310 {
311         char *fn = NULL;
312         struct ast_region *reg;
313         unsigned int x;
314         unsigned int len = 0;
315         unsigned int cache_len = 0;
316         unsigned int count = 0;
317         unsigned int *fence;
318
319         switch (cmd) {
320         case CLI_INIT:
321                 e->command = "memory show allocations";
322                 e->usage =
323                         "Usage: memory show allocations [<file>]\n"
324                         "       Dumps a list of all segments of allocated memory, optionally\n"
325                         "       limited to those from a specific file\n";
326                 return NULL;
327         case CLI_GENERATE:
328                 return NULL;
329         }
330
331
332         if (a->argc > 3)
333                 fn = a->argv[3];
334
335         ast_mutex_lock(&reglock);
336         for (x = 0; x < SOME_PRIME; x++) {
337                 for (reg = regions[x]; reg; reg = reg->next) {
338                         if (!fn || !strcasecmp(fn, reg->file) || !strcasecmp(fn, "anomolies")) {
339                                 fence = (unsigned int *)(reg->data + reg->len);
340                                 if (reg->fence != FENCE_MAGIC) {
341                                         astmm_log("WARNING: Low fence violation at %p, "
342                                                 "in %s of %s, line %d\n", reg->data, 
343                                                 reg->func, reg->file, reg->lineno);
344                                 }
345                                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
346                                         astmm_log("WARNING: High fence violation at %p, in %s of %s, "
347                                                 "line %d\n", reg->data, reg->func, reg->file, reg->lineno);
348                                 }
349                         }
350                         if (!fn || !strcasecmp(fn, reg->file)) {
351                                 ast_cli(a->fd, "%10d bytes allocated%s in %20s at line %5d of %s\n", 
352                                         (int) reg->len, reg->cache ? " (cache)" : "", 
353                                         reg->func, reg->lineno, reg->file);
354                                 len += reg->len;
355                                 if (reg->cache)
356                                         cache_len += reg->len;
357                                 count++;
358                         }
359                 }
360         }
361         ast_mutex_unlock(&reglock);
362         
363         if (cache_len)
364                 ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
365         else
366                 ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
367         
368         return CLI_SUCCESS;
369 }
370
371 static char *handle_memory_show_summary(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
372 {
373         char *fn = NULL;
374         int x;
375         struct ast_region *reg;
376         unsigned int len = 0;
377         unsigned int cache_len = 0;
378         int count = 0;
379         struct file_summary {
380                 char fn[80];
381                 int len;
382                 int cache_len;
383                 int count;
384                 struct file_summary *next;
385         } *list = NULL, *cur;
386         
387         switch (cmd) {
388         case CLI_INIT:
389                 e->command = "memory show summary";
390                 e->usage =
391                         "Usage: memory show summary [<file>]\n"
392                         "       Summarizes heap memory allocations by file, or optionally\n"
393                         "by function, if a file is specified\n";
394                 break;
395         case CLI_GENERATE:
396                 return NULL;
397         }
398
399         if (a->argc > 3) 
400                 fn = a->argv[3];
401
402         ast_mutex_lock(&reglock);
403         for (x = 0; x < SOME_PRIME; x++) {
404                 for (reg = regions[x]; reg; reg = reg->next) {
405                         if (fn && strcasecmp(fn, reg->file))
406                                 continue;
407
408                         for (cur = list; cur; cur = cur->next) {
409                                 if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
410                                         break;
411                         }
412                         if (!cur) {
413                                 cur = alloca(sizeof(*cur));
414                                 memset(cur, 0, sizeof(*cur));
415                                 ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
416                                 cur->next = list;
417                                 list = cur;
418                         }
419
420                         cur->len += reg->len;
421                         if (reg->cache)
422                                 cur->cache_len += reg->len;
423                         cur->count++;
424                 }
425         }
426         ast_mutex_unlock(&reglock);
427         
428         /* Dump the whole list */
429         for (cur = list; cur; cur = cur->next) {
430                 len += cur->len;
431                 cache_len += cur->cache_len;
432                 count += cur->count;
433                 if (cur->cache_len) {
434                         if (fn) {
435                                 ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in function '%s' of '%s'\n", 
436                                         cur->len, cur->cache_len, cur->count, cur->fn, fn);
437                         } else {
438                                 ast_cli(a->fd, "%10d bytes (%10d cache) in %d allocations in file '%s'\n", 
439                                         cur->len, cur->cache_len, cur->count, cur->fn);
440                         }
441                 } else {
442                         if (fn) {
443                                 ast_cli(a->fd, "%10d bytes in %d allocations in function '%s' of '%s'\n", 
444                                         cur->len, cur->count, cur->fn, fn);
445                         } else {
446                                 ast_cli(a->fd, "%10d bytes in %d allocations in file '%s'\n", 
447                                         cur->len, cur->count, cur->fn);
448                         }
449                 }
450         }
451
452         if (cache_len)
453                 ast_cli(a->fd, "%d bytes allocated (%d in caches) in %d allocations\n", len, cache_len, count);
454         else
455                 ast_cli(a->fd, "%d bytes allocated in %d allocations\n", len, count);
456
457         return CLI_SUCCESS;
458 }
459
460 static struct ast_cli_entry cli_memory[] = {
461         AST_CLI_DEFINE(handle_memory_show, "Display outstanding memory allocations"),
462         AST_CLI_DEFINE(handle_memory_show_summary, "Summarize outstanding memory allocations"),
463 };
464
465 void __ast_mm_init(void)
466 {
467         char filename[PATH_MAX];
468
469         ast_cli_register_multiple(cli_memory, sizeof(cli_memory) / sizeof(struct ast_cli_entry));
470         
471         snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
472         
473         if (option_verbose)
474                 ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
475         
476         if ((mmlog = fopen(filename, "a+"))) {
477                 fprintf(mmlog, "%ld - New session\n", (long)time(NULL));
478                 fflush(mmlog);
479         }
480 }
481
482 #endif