![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to leak_detective.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils|
Return to leak_detective.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils |
1.1 misho 1: /*
2: * Copyright (C) 2013-2018 Tobias Brunner
3: * Copyright (C) 2006-2013 Martin Willi
4: * HSR Hochschule fuer Technik Rapperswil
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #define _GNU_SOURCE
18: #include <stddef.h>
19: #include <string.h>
20: #include <stdio.h>
21: #include <signal.h>
22: #include <unistd.h>
23: #include <locale.h>
24: #ifdef HAVE_DLADDR
25: #include <dlfcn.h>
26: #endif
27: #include <time.h>
28: #include <errno.h>
29:
30: #ifdef __APPLE__
31: #include <sys/mman.h>
32: #include <malloc/malloc.h>
33: /* overload some of our types clashing with mach */
34: #define host_t strongswan_host_t
35: #define processor_t strongswan_processor_t
36: #define thread_t strongswan_thread_t
37: #endif /* __APPLE__ */
38:
39: #include "leak_detective.h"
40:
41: #include <library.h>
42: #include <utils/utils.h>
43: #include <utils/debug.h>
44: #include <utils/backtrace.h>
45: #include <collections/hashtable.h>
46: #include <threading/thread_value.h>
47: #include <threading/spinlock.h>
48:
49: typedef struct private_leak_detective_t private_leak_detective_t;
50:
51: /**
52: * private data of leak_detective
53: */
54: struct private_leak_detective_t {
55:
56: /**
57: * public functions
58: */
59: leak_detective_t public;
60:
61: /**
62: * Registered report() function
63: */
64: leak_detective_report_cb_t report_cb;
65:
66: /**
67: * Registered report() summary function
68: */
69: leak_detective_summary_cb_t report_scb;
70:
71: /**
72: * Registered user data for callbacks
73: */
74: void *report_data;
75: };
76:
77: /**
78: * Magic value which helps to detect memory corruption. Yummy!
79: */
80: #define MEMORY_HEADER_MAGIC 0x7ac0be11
81:
82: /**
83: * Magic written to tail of allocation
84: */
85: #define MEMORY_TAIL_MAGIC 0xcafebabe
86:
87: /**
88: * Pattern which is filled in memory before freeing it
89: */
90: #define MEMORY_FREE_PATTERN 0xFF
91:
92: /**
93: * Pattern which is filled in newly allocated memory
94: */
95: #define MEMORY_ALLOC_PATTERN 0xEE
96:
97: typedef struct memory_header_t memory_header_t;
98: typedef struct memory_tail_t memory_tail_t;
99:
100: /**
101: * Header which is prepended to each allocated memory block
102: */
103: struct memory_header_t {
104:
105: /**
106: * Pointer to previous entry in linked list
107: */
108: memory_header_t *previous;
109:
110: /**
111: * Pointer to next entry in linked list
112: */
113: memory_header_t *next;
114:
115: /**
116: * backtrace taken during (re-)allocation
117: */
118: backtrace_t *backtrace;
119:
120: /**
121: * Padding to make sizeof(memory_header_t) == 32
122: */
123: uint32_t padding[sizeof(void*) == sizeof(uint32_t) ? 3 : 0];
124:
125: /**
126: * Number of bytes following after the header
127: */
128: uint32_t bytes;
129:
130: /**
131: * magic bytes to detect bad free or heap underflow, MEMORY_HEADER_MAGIC
132: */
133: uint32_t magic;
134:
135: }__attribute__((__packed__));
136:
137: /**
138: * tail appended to each allocated memory block
139: */
140: struct memory_tail_t {
141:
142: /**
143: * Magic bytes to detect heap overflow, MEMORY_TAIL_MAGIC
144: */
145: uint32_t magic;
146:
147: }__attribute__((__packed__));
148:
149: /**
150: * first mem header is just a dummy to chain
151: * the others on it...
152: */
153: static memory_header_t first_header = {
154: .magic = MEMORY_HEADER_MAGIC,
155: };
156:
157: /**
158: * Spinlock to access header linked list
159: */
160: static spinlock_t *lock;
161:
162: /**
163: * Is leak detection currently enabled?
164: */
165: static bool enabled;
166:
167: /**
168: * Whether to report calls to free() with memory not allocated by us
169: */
170: static bool ignore_unknown;
171:
172: /**
173: * Is leak detection disabled for the current thread?
174: */
175: static thread_value_t *thread_disabled;
176:
177: /**
178: * Installs the malloc hooks, enables leak detection
179: */
180: static void enable_leak_detective()
181: {
182: enabled = TRUE;
183: }
184:
185: /**
186: * Uninstalls the malloc hooks, disables leak detection
187: */
188: static void disable_leak_detective()
189: {
190: enabled = FALSE;
191: }
192:
193: /**
194: * Enable/Disable leak detective for the current thread
195: *
196: * @return Previous value
197: */
198: static bool enable_thread(bool enable)
199: {
200: bool before;
201:
202: before = thread_disabled->get(thread_disabled) == NULL;
203: thread_disabled->set(thread_disabled, enable ? NULL : (void*)TRUE);
204: return before;
205: }
206:
207: /**
208: * Add a header to the beginning of the list
209: */
210: static void add_hdr(memory_header_t *hdr)
211: {
212: lock->lock(lock);
213: hdr->next = first_header.next;
214: if (hdr->next)
215: {
216: hdr->next->previous = hdr;
217: }
218: hdr->previous = &first_header;
219: first_header.next = hdr;
220: lock->unlock(lock);
221: }
222:
223: /**
224: * Remove a header from the list
225: */
226: static void remove_hdr(memory_header_t *hdr)
227: {
228: lock->lock(lock);
229: if (hdr->next)
230: {
231: hdr->next->previous = hdr->previous;
232: }
233: hdr->previous->next = hdr->next;
234: lock->unlock(lock);
235: }
236:
237: /**
238: * Check if a header is in the list
239: */
240: static bool has_hdr(memory_header_t *hdr)
241: {
242: memory_header_t *current;
243: bool found = FALSE;
244:
245: lock->lock(lock);
246: for (current = &first_header; current != NULL; current = current->next)
247: {
248: if (current == hdr)
249: {
250: found = TRUE;
251: break;
252: }
253: }
254: lock->unlock(lock);
255:
256: return found;
257: }
258:
259: #ifdef __APPLE__
260:
261: /**
262: * Copy of original default zone, with functions we call in hooks
263: */
264: static malloc_zone_t original;
265:
266: /**
267: * Call original malloc()
268: */
269: static void* real_malloc(size_t size)
270: {
271: return original.malloc(malloc_default_zone(), size);
272: }
273:
274: /**
275: * Call original free()
276: */
277: static void real_free(void *ptr)
278: {
279: original.free(malloc_default_zone(), ptr);
280: }
281:
282: /**
283: * Call original realloc()
284: */
285: static void* real_realloc(void *ptr, size_t size)
286: {
287: return original.realloc(malloc_default_zone(), ptr, size);
288: }
289:
290: /**
291: * Hook definition: static function with _hook suffix, takes additional zone
292: */
293: #define HOOK(ret, name, ...) \
294: static ret name ## _hook(malloc_zone_t *_z, __VA_ARGS__)
295:
296: /**
297: * forward declaration of hooks
298: */
299: HOOK(void*, malloc, size_t bytes);
300: HOOK(void*, calloc, size_t nmemb, size_t size);
301: HOOK(void*, valloc, size_t size);
302: HOOK(void, free, void *ptr);
303: HOOK(void*, realloc, void *old, size_t bytes);
304:
305: /**
306: * malloc zone size(), must consider the memory header prepended
307: */
308: HOOK(size_t, size, const void *ptr)
309: {
310: bool before;
311: size_t size;
312:
313: if (enabled)
314: {
315: before = enable_thread(FALSE);
316: if (before)
317: {
318: ptr -= sizeof(memory_header_t);
319: }
320: }
321: size = original.size(malloc_default_zone(), ptr);
322: if (enabled)
323: {
324: enable_thread(before);
325: }
326: return size;
327: }
328:
329: /**
330: * Version of malloc zones we currently support
331: */
332: #define MALLOC_ZONE_VERSION 8 /* Snow Leopard */
333:
334: /**
335: * Hook-in our malloc functions into the default zone
336: */
337: static bool register_hooks()
338: {
339: static bool once = FALSE;
340: malloc_zone_t *zone;
341: void *page;
342:
343: if (once)
344: {
345: return TRUE;
346: }
347: once = TRUE;
348:
349: zone = malloc_default_zone();
350: if (zone->version != MALLOC_ZONE_VERSION)
351: {
352: DBG1(DBG_CFG, "malloc zone version %d unsupported (requiring %d)",
353: zone->version, MALLOC_ZONE_VERSION);
354: return FALSE;
355: }
356:
357: original = *zone;
358:
359: page = (void*)((uintptr_t)zone / getpagesize() * getpagesize());
360: if (mprotect(page, getpagesize(), PROT_WRITE | PROT_READ) != 0)
361: {
362: DBG1(DBG_CFG, "malloc zone unprotection failed: %s", strerror(errno));
363: return FALSE;
364: }
365:
366: zone->size = size_hook;
367: zone->malloc = malloc_hook;
368: zone->calloc = calloc_hook;
369: zone->valloc = valloc_hook;
370: zone->free = free_hook;
371: zone->realloc = realloc_hook;
372:
373: /* those other functions can be NULLed out to not use them */
374: zone->batch_malloc = NULL;
375: zone->batch_free = NULL;
376: zone->memalign = NULL;
377: zone->free_definite_size = NULL;
378:
379: return TRUE;
380: }
381:
382: #else /* !__APPLE__ */
383:
384: /**
385: * dlsym() might do a malloc(), but we can't do one before we get the malloc()
386: * function pointer. Use this minimalistic malloc implementation instead.
387: */
388: static void* malloc_for_dlsym(size_t size)
389: {
390: static char buf[1024] = {};
391: static size_t used = 0;
392: char *ptr;
393:
394: /* roundup to a multiple of 32 */
395: size = (size - 1) / 32 * 32 + 32;
396:
397: if (used + size > sizeof(buf))
398: {
399: return NULL;
400: }
401: ptr = buf + used;
402: used += size;
403: return ptr;
404: }
405:
406: /**
407: * Lookup a malloc function, while disabling wrappers
408: */
409: static void* get_malloc_fn(char *name)
410: {
411: bool before = FALSE;
412: void *fn;
413:
414: if (enabled)
415: {
416: before = enable_thread(FALSE);
417: }
418: fn = dlsym(RTLD_NEXT, name);
419: if (enabled)
420: {
421: enable_thread(before);
422: }
423: return fn;
424: }
425:
426: /**
427: * Call original malloc()
428: */
429: static void* real_malloc(size_t size)
430: {
431: static void* (*fn)(size_t size);
432: static int recursive = 0;
433:
434: if (!fn)
435: {
436: /* checking recursiveness should actually be thread-specific. But as
437: * it is very likely that the first allocation is done before we go
438: * multi-threaded, we keep it simple. */
439: if (recursive)
440: {
441: return malloc_for_dlsym(size);
442: }
443: recursive++;
444: fn = get_malloc_fn("malloc");
445: recursive--;
446: }
447: return fn(size);
448: }
449:
450: /**
451: * Call original free()
452: */
453: static void real_free(void *ptr)
454: {
455: static void (*fn)(void *ptr);
456:
457: if (!fn)
458: {
459: fn = get_malloc_fn("free");
460: }
461: return fn(ptr);
462: }
463:
464: /**
465: * Call original realloc()
466: */
467: static void* real_realloc(void *ptr, size_t size)
468: {
469: static void* (*fn)(void *ptr, size_t size);
470:
471: if (!fn)
472: {
473: fn = get_malloc_fn("realloc");
474: }
475: return fn(ptr, size);
476: }
477:
478: /**
479: * Hook definition: plain function overloading existing malloc calls
480: */
481: #define HOOK(ret, name, ...) ret name(__VA_ARGS__)
482:
483: /**
484: * Hook initialization when not using hooks, resolve functions.
485: */
486: static bool register_hooks()
487: {
488: void *buf = real_malloc(8);
489: buf = real_realloc(buf, 16);
490: real_free(buf);
491: return TRUE;
492: }
493:
494: #endif /* !__APPLE__ */
495:
496: /**
497: * Leak report white list
498: *
499: * List of functions using static allocation buffers or should be suppressed
500: * otherwise on leak report.
501: */
502: static char *whitelist[] = {
503: /* backtraces, including own */
504: "backtrace_create",
505: "strerror_safe",
506: /* pthread stuff */
507: "pthread_create",
508: "pthread_setspecific",
509: "__pthread_setspecific",
510: /* glibc functions */
511: "inet_ntoa",
512: "strerror",
513: "getprotobyname",
514: "getprotobynumber",
515: "getservbyport",
516: "getservbyname",
517: "gethostbyname",
518: "gethostbyname2",
519: "gethostbyname_r",
520: "gethostbyname2_r",
521: "getnetbyname",
522: "getpwnam_r",
523: "getgrnam_r",
524: "register_printf_function",
525: "register_printf_specifier",
526: "syslog",
527: "vsyslog",
528: "__syslog_chk",
529: "__vsyslog_chk",
530: "__fprintf_chk",
531: "getaddrinfo",
532: "setlocale",
533: "getpass",
534: "getpwent_r",
535: "setpwent",
536: "endpwent",
537: "getspnam_r",
538: "getpwuid_r",
539: "initgroups",
540: "tzset",
541: "_IO_file_doallocate",
542: /* ignore dlopen, as we do not dlclose to get proper leak reports */
543: "dlopen",
544: "dlerror",
545: "dlclose",
546: "dlsym",
547: /* mysql functions */
548: "mysql_init_character_set",
549: "init_client_errs",
550: "my_thread_init",
551: /* fastcgi library */
552: "FCGX_Init",
553: /* libxml */
554: "xmlInitCharEncodingHandlers",
555: "xmlInitParser",
556: "xmlInitParserCtxt",
557: /* libcurl */
558: "Curl_client_write",
559: /* libsoup */
560: "soup_add_timeout",
561: "soup_headers_parse_response",
562: "soup_message_headers_append",
563: "soup_message_headers_clear",
564: "soup_message_headers_get_list",
565: "soup_message_headers_get_one",
566: "soup_session_abort",
567: "soup_session_get_type",
568: "soup_session_remove_feature",
569: /* libldap */
570: "ldap_int_initialize",
571: /* ClearSilver */
572: "nerr_init",
573: /* libgcrypt */
574: "gcrypt_plugin_create",
575: "gcry_control",
576: "gcry_check_version",
577: "gcry_randomize",
578: "gcry_create_nonce",
579: /* OpenSSL: These are needed for unit-tests only, the openssl plugin
580: * does properly clean up any memory during destroy(). */
581: "ECDSA_do_sign_ex",
582: "ECDSA_verify",
583: "RSA_new_method",
584: /* OpenSSL 1.1.0 does not cleanup anymore until the library is unloaded */
585: "OPENSSL_init_crypto",
586: "CRYPTO_THREAD_lock_new",
587: "ERR_add_error_data",
588: "ERR_set_mark",
589: "ENGINE_load_builtin_engines",
590: "OPENSSL_load_builtin_modules",
591: "CONF_modules_load_file",
592: "CONF_module_add",
593: "RAND_DRBG_bytes",
594: "RAND_DRBG_generate",
595: "RAND_DRBG_get0_master",
596: "RAND_DRBG_get0_private",
597: "RAND_DRBG_get0_public",
598: /* OpenSSL libssl */
599: "SSL_COMP_get_compression_methods",
600: /* NSPR */
601: "PR_CallOnce",
602: /* libapr */
603: "apr_pool_create_ex",
604: /* glib */
605: "g_output_stream_write",
606: "g_resolver_lookup_by_name",
607: "g_signal_connect_data",
608: "g_socket_connection_factory_lookup_type",
609: "g_type_init_with_debug_flags",
610: "g_type_register_static",
611: "g_type_class_ref",
612: "g_type_create_instance",
613: "g_type_add_interface_static",
614: "g_type_interface_add_prerequisite",
615: "g_private_set",
616: "g_queue_pop_tail",
617: /* libgpg */
618: "gpg_err_init",
619: /* gnutls */
620: "gnutls_global_init",
621: /* Ada runtime */
622: "system__tasking__initialize",
623: "system__tasking__initialization__abort_defer",
624: "system__tasking__stages__create_task",
625: /* in case external threads call into our code */
626: "thread_current_id",
627: /* FHH IMCs and IMVs */
628: "TNC_IMC_NotifyConnectionChange",
629: "TNC_IMV_NotifyConnectionChange",
630: /* Botan */
631: "botan_public_key_load",
632: "botan_privkey_create",
633: "botan_privkey_load_ecdh",
634: "botan_privkey_load",
635: };
636:
637: /**
638: * Some functions are hard to whitelist, as they don't use a symbol directly.
639: * Use some static initialization to suppress them on leak reports
640: */
641: static void init_static_allocations()
642: {
643: struct tm tm;
644: time_t t = 0;
645:
646: tzset();
647: gmtime_r(&t, &tm);
648: localtime_r(&t, &tm);
649: }
650:
651: /**
652: * Hashtable hash function
653: */
654: static u_int hash(backtrace_t *key)
655: {
656: enumerator_t *enumerator;
657: void *addr;
658: u_int hash = 0;
659:
660: enumerator = key->create_frame_enumerator(key);
661: while (enumerator->enumerate(enumerator, &addr))
662: {
663: hash = chunk_hash_inc(chunk_from_thing(addr), hash);
664: }
665: enumerator->destroy(enumerator);
666:
667: return hash;
668: }
669:
670: /**
671: * Hashtable equals function
672: */
673: static bool equals(backtrace_t *a, backtrace_t *b)
674: {
675: return a->equals(a, b);
676: }
677:
678: /**
679: * Summarize and print backtraces
680: */
681: static int print_traces(private_leak_detective_t *this,
682: leak_detective_report_cb_t cb, void *user,
683: int thresh, int thresh_count,
684: bool detailed, int *whitelisted, size_t *sum)
685: {
686: int leaks = 0;
687: memory_header_t *hdr;
688: enumerator_t *enumerator;
689: hashtable_t *entries, *ignored = NULL;
690: backtrace_t *bt;
691: struct {
692: /** associated backtrace */
693: backtrace_t *backtrace;
694: /** total size of all allocations */
695: size_t bytes;
696: /** number of allocations */
697: u_int count;
698: } *entry;
699: bool before;
700:
701: before = enable_thread(FALSE);
702:
703: entries = hashtable_create((hashtable_hash_t)hash,
704: (hashtable_equals_t)equals, 1024);
705: if (whitelisted)
706: {
707: ignored = hashtable_create((hashtable_hash_t)hash,
708: (hashtable_equals_t)equals, 1024);
709: }
710:
711: lock->lock(lock);
712: for (hdr = first_header.next; hdr != NULL; hdr = hdr->next)
713: {
714: if (whitelisted)
715: {
716: bt = ignored->get(ignored, hdr->backtrace);
717: if (!bt)
718: {
719: if (hdr->backtrace->contains_function(hdr->backtrace, whitelist,
720: countof(whitelist)))
721: {
722: bt = hdr->backtrace;
723: ignored->put(ignored, bt, bt);
724: }
725: }
726: if (bt)
727: {
728: (*whitelisted)++;
729: continue;
730: }
731: }
732: entry = entries->get(entries, hdr->backtrace);
733: if (entry)
734: {
735: entry->bytes += hdr->bytes;
736: entry->count++;
737: }
738: else
739: {
740: INIT(entry,
741: .backtrace = hdr->backtrace->clone(hdr->backtrace),
742: .bytes = hdr->bytes,
743: .count = 1,
744: );
745: entries->put(entries, entry->backtrace, entry);
746: }
747: if (sum)
748: {
749: *sum += hdr->bytes;
750: }
751: leaks++;
752: }
753: lock->unlock(lock);
754: DESTROY_IF(ignored);
755:
756: enumerator = entries->create_enumerator(entries);
757: while (enumerator->enumerate(enumerator, NULL, &entry))
758: {
759: if (cb)
760: {
761: if (!thresh || entry->bytes >= thresh)
762: {
763: if (!thresh_count || entry->count >= thresh_count)
764: {
765: cb(user, entry->count, entry->bytes, entry->backtrace,
766: detailed);
767: }
768: }
769: }
770: entry->backtrace->destroy(entry->backtrace);
771: free(entry);
772: }
773: enumerator->destroy(enumerator);
774: entries->destroy(entries);
775:
776: enable_thread(before);
777: return leaks;
778: }
779:
780: METHOD(leak_detective_t, report, void,
781: private_leak_detective_t *this, bool detailed)
782: {
783: if (lib->leak_detective)
784: {
785: int leaks, whitelisted = 0;
786: size_t sum = 0;
787:
788: leaks = print_traces(this, this->report_cb, this->report_data,
789: 0, 0, detailed, &whitelisted, &sum);
790: if (this->report_scb)
791: {
792: this->report_scb(this->report_data, leaks, sum, whitelisted);
793: }
794: }
795: }
796:
797: METHOD(leak_detective_t, set_report_cb, void,
798: private_leak_detective_t *this, leak_detective_report_cb_t cb,
799: leak_detective_summary_cb_t scb, void *user)
800: {
801: this->report_cb = cb;
802: this->report_scb = scb;
803: this->report_data = user;
804: }
805:
806: METHOD(leak_detective_t, leaks, int,
807: private_leak_detective_t *this)
808: {
809: int whitelisted = 0;
810:
811: return print_traces(this, NULL, NULL, 0, 0, FALSE, &whitelisted, NULL);
812: }
813:
814: METHOD(leak_detective_t, set_state, bool,
815: private_leak_detective_t *this, bool enable)
816: {
817: return enable_thread(enable);
818: }
819:
820: METHOD(leak_detective_t, usage, void,
821: private_leak_detective_t *this, leak_detective_report_cb_t cb,
822: leak_detective_summary_cb_t scb, void *user)
823: {
824: bool detailed;
825: int thresh, thresh_count, leaks, whitelisted = 0;
826: size_t sum = 0;
827:
828: thresh = lib->settings->get_int(lib->settings,
829: "%s.leak_detective.usage_threshold", 10240, lib->ns);
830: thresh_count = lib->settings->get_int(lib->settings,
831: "%s.leak_detective.usage_threshold_count", 0, lib->ns);
832: detailed = lib->settings->get_bool(lib->settings,
833: "%s.leak_detective.detailed", TRUE, lib->ns);
834:
835: leaks = print_traces(this, cb, user, thresh, thresh_count,
836: detailed, &whitelisted, &sum);
837: if (scb)
838: {
839: scb(user, leaks, sum, whitelisted);
840: }
841: }
842:
843: /**
844: * Wrapped malloc() function
845: */
846: HOOK(void*, malloc, size_t bytes)
847: {
848: memory_header_t *hdr;
849: memory_tail_t *tail;
850: bool before;
851:
852: if (!enabled || thread_disabled->get(thread_disabled))
853: {
854: return real_malloc(bytes);
855: }
856:
857: hdr = real_malloc(sizeof(memory_header_t) + bytes + sizeof(memory_tail_t));
858: tail = ((void*)hdr) + bytes + sizeof(memory_header_t);
859: /* set to something which causes crashes */
860: memset(hdr, MEMORY_ALLOC_PATTERN,
861: sizeof(memory_header_t) + bytes + sizeof(memory_tail_t));
862:
863: before = enable_thread(FALSE);
864: hdr->backtrace = backtrace_create(2);
865: enable_thread(before);
866:
867: hdr->magic = MEMORY_HEADER_MAGIC;
868: hdr->bytes = bytes;
869: tail->magic = MEMORY_TAIL_MAGIC;
870:
871: add_hdr(hdr);
872:
873: return hdr + 1;
874: }
875:
876: /**
877: * Wrapped calloc() function
878: */
879: HOOK(void*, calloc, size_t nmemb, size_t size)
880: {
881: void *ptr;
882: volatile size_t total;
883:
884: total = nmemb * size;
885: ptr = malloc(total);
886: memset(ptr, 0, total);
887:
888: return ptr;
889: }
890:
891: /**
892: * Wrapped valloc(), TODO: currently not supported
893: */
894: HOOK(void*, valloc, size_t size)
895: {
896: DBG1(DBG_LIB, "valloc() used, but leak-detective hook missing");
897: return NULL;
898: }
899:
900: /**
901: * Wrapped free() function
902: */
903: HOOK(void, free, void *ptr)
904: {
905: memory_header_t *hdr;
906: memory_tail_t *tail;
907: backtrace_t *backtrace;
908: bool before;
909:
910: if (!enabled || thread_disabled->get(thread_disabled))
911: {
912: /* after deinitialization we might have to free stuff we allocated
913: * while we were enabled */
914: if (!first_header.magic && ptr)
915: {
916: hdr = ptr - sizeof(memory_header_t);
917: tail = ptr + hdr->bytes;
918: if (hdr->magic == MEMORY_HEADER_MAGIC &&
919: tail->magic == MEMORY_TAIL_MAGIC)
920: {
921: ptr = hdr;
922: }
923: }
924: real_free(ptr);
925: return;
926: }
927: /* allow freeing of NULL */
928: if (!ptr)
929: {
930: return;
931: }
932: hdr = ptr - sizeof(memory_header_t);
933: tail = ptr + hdr->bytes;
934:
935: before = enable_thread(FALSE);
936: if (hdr->magic != MEMORY_HEADER_MAGIC ||
937: tail->magic != MEMORY_TAIL_MAGIC)
938: {
939: bool bt = TRUE;
940:
941: /* check if memory appears to be allocated by our hooks */
942: if (has_hdr(hdr))
943: {
944: fprintf(stderr, "freeing corrupted memory (%p): "
945: "%u bytes, header magic 0x%x, tail magic 0x%x:\n",
946: ptr, hdr->bytes, hdr->magic, tail->magic);
947: remove_hdr(hdr);
948:
949: if (hdr->magic == MEMORY_HEADER_MAGIC)
950: { /* only access the old backtrace if header magic is valid */
951: hdr->backtrace->log(hdr->backtrace, stderr, TRUE);
952: hdr->backtrace->destroy(hdr->backtrace);
953: }
954: else
955: {
956: fprintf(stderr, " header magic invalid, ignore backtrace of "
957: "allocation\n");
958: }
959: }
960: else
961: {
962: /* just free this block of unknown memory */
963: hdr = ptr;
964:
965: if (ignore_unknown)
966: {
967: bt = FALSE;
968: }
969: else
970: {
971: fprintf(stderr, "freeing unknown memory (%p):\n", ptr);
972: }
973: }
974: if (bt)
975: {
976: backtrace = backtrace_create(2);
977: backtrace->log(backtrace, stderr, TRUE);
978: backtrace->destroy(backtrace);
979: }
980: }
981: else
982: {
983: remove_hdr(hdr);
984:
985: hdr->backtrace->destroy(hdr->backtrace);
986:
987: /* set mem to something remarkable */
988: memset(hdr, MEMORY_FREE_PATTERN,
989: sizeof(memory_header_t) + hdr->bytes + sizeof(memory_tail_t));
990: }
991: real_free(hdr);
992: enable_thread(before);
993: }
994:
995: /**
996: * Wrapped realloc() function
997: */
998: HOOK(void*, realloc, void *old, size_t bytes)
999: {
1000: memory_header_t *hdr;
1001: memory_tail_t *tail;
1002: backtrace_t *backtrace;
1003: bool before, have_backtrace = TRUE;
1004:
1005: if (!enabled || thread_disabled->get(thread_disabled))
1006: {
1007: return real_realloc(old, bytes);
1008: }
1009: /* allow reallocation of NULL */
1010: if (!old)
1011: {
1012: return malloc(bytes);
1013: }
1014: /* handle zero size as a free() */
1015: if (!bytes)
1016: {
1017: free(old);
1018: return NULL;
1019: }
1020:
1021: hdr = old - sizeof(memory_header_t);
1022: tail = old + hdr->bytes;
1023:
1024: before = enable_thread(FALSE);
1025: if (hdr->magic != MEMORY_HEADER_MAGIC ||
1026: tail->magic != MEMORY_TAIL_MAGIC)
1027: {
1028: bool bt = TRUE;
1029:
1030: /* check if memory appears to be allocated by our hooks */
1031: if (has_hdr(hdr))
1032: {
1033: fprintf(stderr, "reallocating corrupted memory (%p, %u bytes): "
1034: "%zu bytes, header magic 0x%x, tail magic 0x%x:\n",
1035: old, hdr->bytes, bytes, hdr->magic, tail->magic);
1036: remove_hdr(hdr);
1037:
1038: if (hdr->magic == MEMORY_HEADER_MAGIC)
1039: { /* only access header fields (backtrace, bytes) if header magic
1040: * is still valid */
1041: hdr->backtrace->log(hdr->backtrace, stderr, TRUE);
1042: memset(&tail->magic, MEMORY_ALLOC_PATTERN, sizeof(tail->magic));
1043: }
1044: else
1045: {
1046: fprintf(stderr, " header magic invalid, ignore backtrace of "
1047: "allocation\n");
1048: have_backtrace = FALSE;
1049: hdr->magic = MEMORY_HEADER_MAGIC;
1050: }
1051: }
1052: else
1053: {
1054: /* adopt this block of unknown memory */
1055: hdr = old;
1056: have_backtrace = FALSE;
1057:
1058: if (ignore_unknown)
1059: {
1060: bt = FALSE;
1061: }
1062: else
1063: {
1064: fprintf(stderr, "reallocating unknown memory (%p): %zu bytes:\n",
1065: old, bytes);
1066: }
1067: }
1068: if (bt)
1069: {
1070: backtrace = backtrace_create(2);
1071: backtrace->log(backtrace, stderr, TRUE);
1072: backtrace->destroy(backtrace);
1073: }
1074: }
1075: else
1076: {
1077: remove_hdr(hdr);
1078: /* clear tail magic, allocate, set tail magic */
1079: memset(&tail->magic, MEMORY_ALLOC_PATTERN, sizeof(tail->magic));
1080: }
1081:
1082: hdr = real_realloc(hdr,
1083: sizeof(memory_header_t) + bytes + sizeof(memory_tail_t));
1084: tail = ((void*)hdr) + bytes + sizeof(memory_header_t);
1085: tail->magic = MEMORY_TAIL_MAGIC;
1086:
1087: /* update statistics */
1088: hdr->bytes = bytes;
1089:
1090: if (have_backtrace)
1091: {
1092: hdr->backtrace->destroy(hdr->backtrace);
1093: }
1094: hdr->backtrace = backtrace_create(2);
1095: enable_thread(before);
1096:
1097: add_hdr(hdr);
1098:
1099: return hdr + 1;
1100: }
1101:
1102: METHOD(leak_detective_t, destroy, void,
1103: private_leak_detective_t *this)
1104: {
1105: disable_leak_detective();
1106: lock->destroy(lock);
1107: thread_disabled->destroy(thread_disabled);
1108: free(this);
1109: first_header.magic = 0;
1110: first_header.next = NULL;
1111: }
1112:
1113: /*
1114: * see header file
1115: */
1116: leak_detective_t *leak_detective_create()
1117: {
1118: private_leak_detective_t *this;
1119:
1120: INIT(this,
1121: .public = {
1122: .report = _report,
1123: .set_report_cb = _set_report_cb,
1124: .usage = _usage,
1125: .leaks = _leaks,
1126: .set_state = _set_state,
1127: .destroy = _destroy,
1128: },
1129: );
1130:
1131: if (getenv("LEAK_DETECTIVE_DISABLE") != NULL)
1132: {
1133: free(this);
1134: return NULL;
1135: }
1136: ignore_unknown = getenv("LEAK_DETECTIVE_IGNORE_UNKNOWN") != NULL;
1137:
1138: lock = spinlock_create();
1139: thread_disabled = thread_value_create(NULL);
1140:
1141: init_static_allocations();
1142:
1143: if (register_hooks())
1144: {
1145: enable_leak_detective();
1146: }
1147: return &this->public;
1148: }