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