don't double define our own string functions on platforms that don't have them (issue...
[asterisk/asterisk.git] / astmm.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Memory Management
5  * 
6  * Copyright (C) 2002-2005, Mark Spencer
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #ifdef __AST_DEBUG_MALLOC
15
16 #include <stdio.h>
17 #include <string.h>
18 #include <time.h>
19
20 #include "asterisk.h"
21
22 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
23
24 #include "asterisk/cli.h"
25 #include "asterisk/logger.h"
26 #include "asterisk/options.h"
27 #include "asterisk/lock.h"
28 #include "asterisk/strings.h"
29
30 #define SOME_PRIME 563
31
32 #define FUNC_CALLOC     1
33 #define FUNC_MALLOC     2
34 #define FUNC_REALLOC    3
35 #define FUNC_STRDUP     4
36 #define FUNC_STRNDUP    5
37 #define FUNC_VASPRINTF  6
38
39 /* Undefine all our macros */
40 #undef malloc
41 #undef calloc
42 #undef realloc
43 #undef strdup
44 #undef strndup
45 #undef free
46 #undef vasprintf
47
48 static FILE *mmlog;
49
50 static struct ast_region {
51         struct ast_region *next;
52         char file[40];
53         char func[40];
54         int lineno;
55         int which;
56         size_t len;
57         unsigned char data[0];
58 } *regions[SOME_PRIME];
59
60 #define HASH(a) \
61         (((unsigned long)(a)) % SOME_PRIME)
62         
63 AST_MUTEX_DEFINE_STATIC(reglock);
64 AST_MUTEX_DEFINE_STATIC(showmemorylock);
65
66 static inline void *__ast_alloc_region(size_t size, int which, const char *file, int lineno, const char *func)
67 {
68         struct ast_region *reg;
69         void *ptr = NULL;
70         int hash;
71         reg = malloc(size + sizeof(struct ast_region));
72         ast_mutex_lock(&reglock);
73         if (reg) {
74                 ast_copy_string(reg->file, file, sizeof(reg->file));
75                 reg->file[sizeof(reg->file) - 1] = '\0';
76                 ast_copy_string(reg->func, func, sizeof(reg->func));
77                 reg->func[sizeof(reg->func) - 1] = '\0';
78                 reg->lineno = lineno;
79                 reg->len = size;
80                 reg->which = which;
81                 ptr = reg->data;
82                 hash = HASH(ptr);
83                 reg->next = regions[hash];
84                 regions[hash] = reg;
85         }
86         ast_mutex_unlock(&reglock);
87         if (!reg) {
88                 fprintf(stderr, "Out of memory :(\n");
89                 if (mmlog) {
90                         fprintf(mmlog, "%ld - Out of memory\n", time(NULL));
91                         fflush(mmlog);
92                 }
93         }
94         return ptr;
95 }
96
97 static inline size_t __ast_sizeof_region(void *ptr)
98 {
99         int hash = HASH(ptr);
100         struct ast_region *reg;
101         size_t len = 0;
102         
103         ast_mutex_lock(&reglock);
104         reg = regions[hash];
105         while (reg) {
106                 if (reg->data == ptr) {
107                         len = reg->len;
108                         break;
109                 }
110                 reg = reg->next;
111         }
112         ast_mutex_unlock(&reglock);
113         return len;
114 }
115
116 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
117 {
118         int hash = HASH(ptr);
119         struct ast_region *reg, *prev = NULL;
120         ast_mutex_lock(&reglock);
121         reg = regions[hash];
122         while (reg) {
123                 if (reg->data == ptr) {
124                         if (prev) {
125                                 prev->next = reg->next;
126                         } else {
127                                 regions[hash] = reg->next;
128                         }
129                         break;
130                 }
131                 prev = reg;
132                 reg = reg->next;
133         }
134         ast_mutex_unlock(&reglock);
135         if (reg) {
136                 free(reg);
137         } else {
138                 fprintf(stderr, "WARNING: Freeing unused memory at %p, in %s of %s, line %d\n", ptr, func, file, lineno);
139                 if (mmlog) {
140                         fprintf(mmlog, "%ld - WARNING: Freeing unused memory at %p, in %s of %s, line %d\n", time(NULL), ptr, func, file, lineno);
141                         fflush(mmlog);
142                 }
143         }
144 }
145
146 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
147 {
148         void *ptr;
149         ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func);
150         if (ptr) 
151                 memset(ptr, 0, size * nmemb);
152         return ptr;
153 }
154
155 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func) 
156 {
157         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func);
158 }
159
160 void __ast_free(void *ptr, const char *file, int lineno, const char *func) 
161 {
162         __ast_free_region(ptr, file, lineno, func);
163 }
164
165 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func) 
166 {
167         void *tmp;
168         size_t len = 0;
169         if (ptr) {
170                 len = __ast_sizeof_region(ptr);
171                 if (!len) {
172                         fprintf(stderr, "WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n", ptr, func, file, lineno);
173                         if (mmlog) {
174                                 fprintf(mmlog, "%ld - WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n", time(NULL), ptr, func, file, lineno);
175                                 fflush(mmlog);
176                         }
177                         return NULL;
178                 }
179         }
180         tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func);
181         if (tmp) {
182                 if (len > size)
183                         len = size;
184                 if (ptr) {
185                         memcpy(tmp, ptr, len);
186                         __ast_free_region(ptr, file, lineno, func);
187                 }
188         }
189         return tmp;
190 }
191
192 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func) 
193 {
194         size_t len;
195         void *ptr;
196         if (!s)
197                 return NULL;
198         len = strlen(s) + 1;
199         ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func);
200         if (ptr)
201                 strcpy(ptr, s);
202         return ptr;
203 }
204
205 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func) 
206 {
207         size_t len;
208         void *ptr;
209         if (!s)
210                 return NULL;
211         len = strlen(s) + 1;
212         if (len > n)
213                 len = n;
214         ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func);
215         if (ptr)
216                 strcpy(ptr, s);
217         return ptr;
218 }
219
220 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func) 
221 {
222         int n, size = strlen(fmt) + 1;
223         if ((*strp = __ast_alloc_region(size, FUNC_VASPRINTF, file, lineno, func)) == NULL)
224                 return -1; 
225         for (;;) {
226                 n = vsnprintf(*strp, size, fmt, ap);
227                 if (n > -1 && n < size)
228                         return n;
229                 if (n > -1) {   /* glibc 2.1 */
230                         size = n+1;
231                 } else {        /* glibc 2.0 */
232                         size *= 2;
233                 }
234                 if ((*strp = __ast_realloc(*strp, size, file, lineno, func)) == NULL)
235                         return -1;
236         }
237 }
238
239 static int handle_show_memory(int fd, int argc, char *argv[])
240 {
241         char *fn = NULL;
242         int x;
243         struct ast_region *reg;
244         unsigned int len = 0;
245         int count = 0;
246         if (argc > 3) 
247                 fn = argv[3];
248
249         /* try to lock applications list ... */
250         ast_mutex_lock(&showmemorylock);
251
252         for (x = 0; x < SOME_PRIME; x++) {
253                 reg = regions[x];
254                 while (reg) {
255                         if (!fn || !strcasecmp(fn, reg->file)) {
256                                 ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %s\n", (int) reg->len, reg->func, reg->lineno, reg->file);
257                                 len += reg->len;
258                                 count++;
259                         }
260                         reg = reg->next;
261                 }
262         }
263         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
264         ast_mutex_unlock(&showmemorylock);
265         return RESULT_SUCCESS;
266 }
267
268 struct file_summary {
269         char fn[80];
270         int len;
271         int count;
272         struct file_summary *next;
273 };
274
275 static int handle_show_memory_summary(int fd, int argc, char *argv[])
276 {
277         char *fn = NULL;
278         int x;
279         struct ast_region *reg;
280         unsigned int len = 0;
281         int count = 0;
282         struct file_summary *list = NULL, *cur;
283         
284         if (argc > 3) 
285                 fn = argv[3];
286
287         /* try to lock applications list ... */
288         ast_mutex_lock(&reglock);
289
290         for (x = 0; x < SOME_PRIME; x++) {
291                 reg = regions[x];
292                 while (reg) {
293                         if (!fn || !strcasecmp(fn, reg->file)) {
294                                 cur = list;
295                                 while (cur) {
296                                         if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
297                                                 break;
298                                         cur = cur->next;
299                                 }
300                                 if (!cur) {
301                                         cur = alloca(sizeof(struct file_summary));
302                                         memset(cur, 0, sizeof(struct file_summary));
303                                         ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
304                                         cur->next = list;
305                                         list = cur;
306                                 }
307                                 cur->len += reg->len;
308                                 cur->count++;
309                         }
310                         reg = reg->next;
311                 }
312         }
313         ast_mutex_unlock(&reglock);
314         
315         /* Dump the whole list */
316         while (list) {
317                 cur = list;
318                 len += list->len;
319                 count += list->count;
320                 if (fn) {
321                         ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n", list->len, list->count, list->fn, fn);
322                 } else {
323                         ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n", list->len, list->count, list->fn);
324                 }
325                 list = list->next;
326 #if 0
327                 free(cur);
328 #endif          
329         }
330         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
331         return RESULT_SUCCESS;
332 }
333
334 static char show_memory_help[] = 
335 "Usage: show memory allocations [<file>]\n"
336 "       Dumps a list of all segments of allocated memory, optionally\n"
337 "limited to those from a specific file\n";
338
339 static char show_memory_summary_help[] = 
340 "Usage: show memory summary [<file>]\n"
341 "       Summarizes heap memory allocations by file, or optionally\n"
342 "by function, if a file is specified\n";
343
344 static struct ast_cli_entry show_memory_allocations_cli = 
345         { { "show", "memory", "allocations", NULL }, 
346         handle_show_memory, "Display outstanding memory allocations",
347         show_memory_help };
348
349 static struct ast_cli_entry show_memory_summary_cli = 
350         { { "show", "memory", "summary", NULL }, 
351         handle_show_memory_summary, "Summarize outstanding memory allocations",
352         show_memory_summary_help };
353
354 void __ast_mm_init(void)
355 {
356         char filename[80] = "";
357         ast_cli_register(&show_memory_allocations_cli);
358         ast_cli_register(&show_memory_summary_cli);
359         
360         snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
361         mmlog = fopen(filename, "a+");
362         if (option_verbose)
363                 ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
364         if (mmlog) {
365                 fprintf(mmlog, "%ld - New session\n", time(NULL));
366                 fflush(mmlog);
367         }
368 }
369
370 #endif