Remove deprecated CLI apps from the core
[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         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 += cur->len;
382                 count += cur->count;
383                 if (fn) {
384                         ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n", 
385                                 cur->len, cur->count, cur->fn, fn);
386                 } else {
387                         ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n", 
388                                 cur->len, cur->count, cur->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_memory[] = {
408         { { "memory", "show", "allocations", NULL },
409         handle_show_memory, "Display outstanding memory allocations",
410         show_memory_help },
411
412         { { "memory", "show", "summary", NULL },
413         handle_show_memory_summary, "Summarize outstanding memory allocations",
414         show_memory_summary_help },
415 };
416
417 void __ast_mm_init(void)
418 {
419         char filename[PATH_MAX];
420
421         ast_cli_register_multiple(cli_memory, sizeof(cli_memory) / sizeof(struct ast_cli_entry));
422         
423         snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
424         
425         if (option_verbose)
426                 ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
427         
428         if ((mmlog = fopen(filename, "a+"))) {
429                 fprintf(mmlog, "%ld - New session\n", time(NULL));
430                 fflush(mmlog);
431         }
432 }
433
434 #endif