Issue #5637 - Realtime driver for PostgreSQL (mguesdon)
[asterisk/asterisk.git] / 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 <stdio.h>
29 #include <string.h>
30 #include <time.h>
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
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         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 static inline void *__ast_alloc_region(size_t size, const enum func_type which, const char *file, int lineno, const char *func)
87 {
88         struct ast_region *reg;
89         void *ptr = NULL;
90         unsigned int *fence;
91         int hash;
92         reg = malloc(size + sizeof(*reg) + sizeof(*fence));
93         ast_mutex_lock(&reglock);
94         if (reg) {
95                 ast_copy_string(reg->file, file, sizeof(reg->file));
96                 reg->file[sizeof(reg->file) - 1] = '\0';
97                 ast_copy_string(reg->func, func, sizeof(reg->func));
98                 reg->func[sizeof(reg->func) - 1] = '\0';
99                 reg->lineno = lineno;
100                 reg->len = size;
101                 reg->which = which;
102                 ptr = reg->data;
103                 hash = HASH(ptr);
104                 reg->next = regions[hash];
105                 regions[hash] = reg;
106                 reg->fence = FENCE_MAGIC;
107                 fence = (ptr + reg->len);
108                 put_unaligned_uint32(fence, FENCE_MAGIC);
109         }
110         ast_mutex_unlock(&reglock);
111         if (!reg) {
112                 fprintf(stderr, "Memory Allocation Failure - '%d' bytes in function %s at line %d of %s\n", (int) size, func, lineno, file);
113                 if (mmlog) {
114                         fprintf(stderr, "%ld - Memory Allocation Failure - '%d' bytes in function %s at line %d of %s\n", time(NULL), (int) size, func, lineno, file);
115                         fflush(mmlog);
116                 }
117         }
118         return ptr;
119 }
120
121 static inline size_t __ast_sizeof_region(void *ptr)
122 {
123         int hash = HASH(ptr);
124         struct ast_region *reg;
125         size_t len = 0;
126         
127         ast_mutex_lock(&reglock);
128         reg = regions[hash];
129         while (reg) {
130                 if (reg->data == ptr) {
131                         len = reg->len;
132                         break;
133                 }
134                 reg = reg->next;
135         }
136         ast_mutex_unlock(&reglock);
137         return len;
138 }
139
140 static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
141 {
142         int hash = HASH(ptr);
143         struct ast_region *reg, *prev = NULL;
144         unsigned int *fence;
145
146         ast_mutex_lock(&reglock);
147         reg = regions[hash];
148         while (reg) {
149                 if (reg->data == ptr) {
150                         if (prev) {
151                                 prev->next = reg->next;
152                         } else {
153                                 regions[hash] = reg->next;
154                         }
155                         break;
156                 }
157                 prev = reg;
158                 reg = reg->next;
159         }
160         ast_mutex_unlock(&reglock);
161         if (reg) {
162                 fence = (unsigned int *)(reg->data + reg->len);
163                 if (reg->fence != FENCE_MAGIC) {
164                         fprintf(stderr, "WARNING: Low fence violation at %p, in %s of %s, line %d\n", reg->data, reg->func, reg->file, reg->lineno);
165                         if (mmlog) {
166                                 fprintf(mmlog, "%ld - WARNING: Low fence violation at %p, in %s of %s, line %d\n", time(NULL), reg->data, reg->func, reg->file, reg->lineno);
167                                 fflush(mmlog);
168                         }
169                 }
170                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
171                         fprintf(stderr, "WARNING: High fence violation at %p, in %s of %s, line %d\n", reg->data, reg->func, reg->file, reg->lineno);
172                         if (mmlog) {
173                                 fprintf(mmlog, "%ld - WARNING: High fence violation at %p, in %s of %s, line %d\n", time(NULL), reg->data, reg->func, reg->file, reg->lineno);
174                                 fflush(mmlog);
175                         }
176                 }
177                 free(reg);
178         } else {
179                 fprintf(stderr, "WARNING: Freeing unused memory at %p, in %s of %s, line %d\n", ptr, func, file, lineno);
180                 if (mmlog) {
181                         fprintf(mmlog, "%ld - WARNING: Freeing unused memory at %p, in %s of %s, line %d\n", time(NULL), ptr, func, file, lineno);
182                         fflush(mmlog);
183                 }
184         }
185 }
186
187 void *__ast_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func) 
188 {
189         void *ptr;
190         if ((ptr = __ast_alloc_region(size * nmemb, FUNC_CALLOC, file, lineno, func))) 
191                 memset(ptr, 0, size * nmemb);
192         return ptr;
193 }
194
195 void *__ast_malloc(size_t size, const char *file, int lineno, const char *func) 
196 {
197         return __ast_alloc_region(size, FUNC_MALLOC, file, lineno, func);
198 }
199
200 void __ast_free(void *ptr, const char *file, int lineno, const char *func) 
201 {
202         __ast_free_region(ptr, file, lineno, func);
203 }
204
205 void *__ast_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func) 
206 {
207         void *tmp;
208         size_t len = 0;
209         if (ptr && !(len = __ast_sizeof_region(ptr))) {
210                 fprintf(stderr, "WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n", ptr, func, file, lineno);
211                 if (mmlog) {
212                         fprintf(mmlog, "%ld - WARNING: Realloc of unalloced memory at %p, in %s of %s, line %d\n", time(NULL), ptr, func, file, lineno);
213                         fflush(mmlog);
214                 }
215                 return NULL;
216         }
217         if ((tmp = __ast_alloc_region(size, FUNC_REALLOC, file, lineno, func))) {
218                 if (len > size)
219                         len = size;
220                 if (ptr) {
221                         memcpy(tmp, ptr, len);
222                         __ast_free_region(ptr, file, lineno, func);
223                 }
224         }
225         return tmp;
226 }
227
228 char *__ast_strdup(const char *s, const char *file, int lineno, const char *func) 
229 {
230         size_t len;
231         void *ptr;
232         if (!s)
233                 return NULL;
234         len = strlen(s) + 1;
235         if ((ptr = __ast_alloc_region(len, FUNC_STRDUP, file, lineno, func)))
236                 strcpy(ptr, s);
237         return ptr;
238 }
239
240 char *__ast_strndup(const char *s, size_t n, const char *file, int lineno, const char *func) 
241 {
242         size_t len;
243         void *ptr;
244         if (!s)
245                 return NULL;
246         len = strlen(s) + 1;
247         if (len > n)
248                 len = n;
249         if ((ptr = __ast_alloc_region(len, FUNC_STRNDUP, file, lineno, func)))
250                 strcpy(ptr, s);
251         return ptr;
252 }
253
254 int __ast_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
255 {
256         int size;
257         va_list ap, ap2;
258         char s;
259
260         *strp = NULL;
261         va_start(ap, fmt);
262         va_copy(ap2, ap);
263         size = vsnprintf(&s, 1, fmt, ap2);
264         va_end(ap2);
265         if (!(*strp = __ast_alloc_region(size + 1, FUNC_ASPRINTF, file, lineno, func))) {
266                 va_end(ap);
267                 return -1;
268         }
269         vsnprintf(*strp, size + 1, fmt, ap);
270         va_end(ap);
271
272         return size;
273 }
274
275 int __ast_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func) 
276 {
277         int size;
278         va_list ap2;
279         char s;
280
281         *strp = NULL;
282         va_copy(ap2, ap);
283         size = vsnprintf(&s, 1, fmt, ap2);
284         va_end(ap2);
285         if (!(*strp = __ast_alloc_region(size + 1, FUNC_VASPRINTF, file, lineno, func))) {
286                 va_end(ap);
287                 return -1;
288         }
289         vsnprintf(*strp, size + 1, fmt, ap);
290
291         return size;
292 }
293
294 static int handle_show_memory(int fd, int argc, char *argv[])
295 {
296         char *fn = NULL;
297         int x;
298         struct ast_region *reg;
299         unsigned int len = 0;
300         int count = 0;
301         unsigned int *fence;
302         if (argc > 3) 
303                 fn = argv[3];
304
305         /* try to lock applications list ... */
306         ast_mutex_lock(&showmemorylock);
307
308         for (x = 0; x < SOME_PRIME; x++) {
309                 reg = regions[x];
310                 while (reg) {
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                                         fprintf(stderr, "WARNING: Low fence violation at %p, in %s of %s, line %d\n", reg->data, reg->func, reg->file, reg->lineno);
315                                         if (mmlog) {
316                                                 fprintf(mmlog, "%ld - WARNING: Low fence violation at %p, in %s of %s, line %d\n", time(NULL), reg->data, reg->func, reg-> file, reg->lineno);
317                                                 fflush(mmlog);
318                                         }
319                                 }
320                                 if (get_unaligned_uint32(fence) != FENCE_MAGIC) {
321                                         fprintf(stderr, "WARNING: High fence violation at %p, in %s of %s, line %d\n", reg->data, reg->func, reg->file, reg->lineno);
322                                         if (mmlog) {
323                                                 fprintf(mmlog, "%ld - WARNING: High fence violation at %p, in %s of %s, line %d\n", time(NULL), reg->data, reg->func, reg->file, reg->lineno);
324                                                 fflush(mmlog);
325                                         }
326                                 }
327                         }
328                         if (!fn || !strcasecmp(fn, reg->file)) {
329                                 ast_cli(fd, "%10d bytes allocated in %20s at line %5d of %s\n", (int) reg->len, reg->func, reg->lineno, reg->file);
330                                 len += reg->len;
331                                 count++;
332                         }
333                         reg = reg->next;
334                 }
335         }
336         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
337         ast_mutex_unlock(&showmemorylock);
338         return RESULT_SUCCESS;
339 }
340
341 struct file_summary {
342         char fn[80];
343         int len;
344         int count;
345         struct file_summary *next;
346 };
347
348 static int handle_show_memory_summary(int fd, int argc, char *argv[])
349 {
350         char *fn = NULL;
351         int x;
352         struct ast_region *reg;
353         unsigned int len = 0;
354         int count = 0;
355         struct file_summary *list = NULL, *cur;
356         
357         if (argc > 3) 
358                 fn = argv[3];
359
360         /* try to lock applications list ... */
361         ast_mutex_lock(&reglock);
362
363         for (x = 0; x < SOME_PRIME; x++) {
364                 reg = regions[x];
365                 while (reg) {
366                         if (!fn || !strcasecmp(fn, reg->file)) {
367                                 cur = list;
368                                 while (cur) {
369                                         if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
370                                                 break;
371                                         cur = cur->next;
372                                 }
373                                 if (!cur) {
374                                         cur = alloca(sizeof(*cur));
375                                         memset(cur, 0, sizeof(*cur));
376                                         ast_copy_string(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
377                                         cur->next = list;
378                                         list = cur;
379                                 }
380                                 cur->len += reg->len;
381                                 cur->count++;
382                         }
383                         reg = reg->next;
384                 }
385         }
386         ast_mutex_unlock(&reglock);
387         
388         /* Dump the whole list */
389         while (list) {
390                 cur = list;
391                 len += list->len;
392                 count += list->count;
393                 if (fn) {
394                         ast_cli(fd, "%10d bytes in %5d allocations in function '%s' of '%s'\n", list->len, list->count, list->fn, fn);
395                 } else {
396                         ast_cli(fd, "%10d bytes in %5d allocations in file '%s'\n", list->len, list->count, list->fn);
397                 }
398                 list = list->next;
399 #if 0
400                 free(cur);
401 #endif          
402         }
403         ast_cli(fd, "%d bytes allocated %d units total\n", len, count);
404         return RESULT_SUCCESS;
405 }
406
407 static char show_memory_help[] = 
408 "Usage: show memory allocations [<file>]\n"
409 "       Dumps a list of all segments of allocated memory, optionally\n"
410 "limited to those from a specific file\n";
411
412 static char show_memory_summary_help[] = 
413 "Usage: show memory summary [<file>]\n"
414 "       Summarizes heap memory allocations by file, or optionally\n"
415 "by function, if a file is specified\n";
416
417 static struct ast_cli_entry show_memory_allocations_cli = 
418         { { "show", "memory", "allocations", NULL }, 
419         handle_show_memory, "Display outstanding memory allocations",
420         show_memory_help };
421
422 static struct ast_cli_entry show_memory_summary_cli = 
423         { { "show", "memory", "summary", NULL }, 
424         handle_show_memory_summary, "Summarize outstanding memory allocations",
425         show_memory_summary_help };
426
427 void __ast_mm_init(void)
428 {
429         char filename[80] = "";
430         ast_cli_register(&show_memory_allocations_cli);
431         ast_cli_register(&show_memory_summary_cli);
432         
433         snprintf(filename, sizeof(filename), "%s/mmlog", (char *)ast_config_AST_LOG_DIR);
434         mmlog = fopen(filename, "a+");
435         if (option_verbose)
436                 ast_verbose("Asterisk Malloc Debugger Started (see %s))\n", filename);
437         if (mmlog) {
438                 fprintf(mmlog, "%ld - New session\n", time(NULL));
439                 fflush(mmlog);
440         }
441 }
442
443 #endif