2 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
13 #include "internal/cryptlib.h"
14 #include "internal/thread_once.h"
15 #include <openssl/crypto.h>
16 #include <openssl/buffer.h>
17 #include "internal/bio.h"
18 #include <openssl/lhash.h>
20 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
21 # include <execinfo.h>
25 * The state changes to CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE when
26 * the application asks for it (usually after library initialisation for
27 * which no book-keeping is desired). State CRYPTO_MEM_CHECK_ON exists only
28 * temporarily when the library thinks that certain allocations should not be
29 * checked (e.g. the data structures used for memory checking). It is not
30 * suitable as an initial state: the library will unexpectedly enable memory
31 * checking when it executes one of those sections that want to disable
32 * checking temporarily. State CRYPTO_MEM_CHECK_ENABLE without ..._ON makes
33 * no sense whatsoever.
35 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
36 static int mh_mode = CRYPTO_MEM_CHECK_OFF;
39 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
40 static unsigned long order = 0; /* number of memory requests */
43 * For application-defined information (static C-string `info')
44 * to be displayed in memory leak list.
45 * Each thread has its own stack. For applications, there is
46 * OPENSSL_mem_debug_push("...") to push an entry,
47 * OPENSSL_mem_debug_pop() to pop an entry,
49 struct app_mem_info_st {
50 CRYPTO_THREAD_ID threadid;
54 struct app_mem_info_st *next; /* tail of thread's stack */
58 static CRYPTO_ONCE memdbg_init = CRYPTO_ONCE_STATIC_INIT;
59 CRYPTO_RWLOCK *memdbg_lock;
60 static CRYPTO_RWLOCK *long_memdbg_lock;
61 static CRYPTO_THREAD_LOCAL appinfokey;
63 /* memory-block description */
69 CRYPTO_THREAD_ID threadid;
73 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
80 * hash-table of memory requests (address as * key); access requires
81 * long_memdbg_lock lock
83 static LHASH_OF(MEM) *mh = NULL;
85 /* num_disable > 0 iff mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE) */
86 static unsigned int num_disable = 0;
89 * Valid iff num_disable > 0. long_memdbg_lock is locked exactly in this
90 * case (by the thread named in disabling_thread).
92 static CRYPTO_THREAD_ID disabling_threadid;
94 DEFINE_RUN_ONCE_STATIC(do_memdbg_init)
96 memdbg_lock = CRYPTO_THREAD_glock_new("malloc");
97 long_memdbg_lock = CRYPTO_THREAD_glock_new("long_malloc");
98 if (memdbg_lock == NULL
99 || long_memdbg_lock == NULL
100 || !CRYPTO_THREAD_init_local(&appinfokey, NULL)) {
101 CRYPTO_THREAD_lock_free(memdbg_lock);
103 CRYPTO_THREAD_lock_free(long_memdbg_lock);
104 long_memdbg_lock = NULL;
110 static void app_info_free(APP_INFO *inf)
114 if (--(inf->references) <= 0) {
115 app_info_free(inf->next);
121 int CRYPTO_mem_ctrl(int mode)
123 #ifdef OPENSSL_NO_CRYPTO_MDEBUG
128 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
131 CRYPTO_THREAD_write_lock(memdbg_lock);
136 case CRYPTO_MEM_CHECK_ON:
137 mh_mode = CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE;
141 case CRYPTO_MEM_CHECK_OFF:
146 /* switch off temporarily (for library-internal use): */
147 case CRYPTO_MEM_CHECK_DISABLE:
148 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
149 CRYPTO_THREAD_ID cur = CRYPTO_THREAD_get_current_id();
150 /* see if we don't have long_memdbg_lock already */
152 || !CRYPTO_THREAD_compare_id(disabling_threadid, cur)) {
154 * Long-time lock long_memdbg_lock must not be claimed
155 * while we're holding memdbg_lock, or we'll deadlock
156 * if somebody else holds long_memdbg_lock (and cannot
157 * release it because we block entry to this function). Give
158 * them a chance, first, and then claim the locks in
159 * appropriate order (long-time lock first).
161 CRYPTO_THREAD_unlock(memdbg_lock);
163 * Note that after we have waited for long_memdbg_lock and
164 * memdbg_lock, we'll still be in the right "case" and
165 * "if" branch because MemCheck_start and MemCheck_stop may
166 * never be used while there are multiple OpenSSL threads.
168 CRYPTO_THREAD_write_lock(long_memdbg_lock);
169 CRYPTO_THREAD_write_lock(memdbg_lock);
170 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
171 disabling_threadid = cur;
177 case CRYPTO_MEM_CHECK_ENABLE:
178 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
179 if (num_disable) { /* always true, or something is going wrong */
181 if (num_disable == 0) {
182 mh_mode |= CRYPTO_MEM_CHECK_ENABLE;
183 CRYPTO_THREAD_unlock(long_memdbg_lock);
189 CRYPTO_THREAD_unlock(memdbg_lock);
194 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
196 static int mem_check_on(void)
199 CRYPTO_THREAD_ID cur;
201 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
202 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
205 cur = CRYPTO_THREAD_get_current_id();
206 CRYPTO_THREAD_read_lock(memdbg_lock);
208 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
209 || !CRYPTO_THREAD_compare_id(disabling_threadid, cur);
211 CRYPTO_THREAD_unlock(memdbg_lock);
216 static int mem_cmp(const MEM *a, const MEM *b)
219 const char *ap = (const char *)a->addr, *bp = (const char *)b->addr;
227 return (const char *)a->addr - (const char *)b->addr;
231 static unsigned long mem_hash(const MEM *a)
235 ret = (size_t)a->addr;
237 ret = ret * 17851 + (ret >> 14) * 7 + (ret >> 4) * 251;
241 /* returns 1 if there was an info to pop, 0 if the stack was empty. */
242 static int pop_info(void)
244 APP_INFO *current = NULL;
246 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
249 current = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
250 if (current != NULL) {
251 APP_INFO *next = current->next;
255 CRYPTO_THREAD_set_local(&appinfokey, next);
257 CRYPTO_THREAD_set_local(&appinfokey, NULL);
259 if (--(current->references) <= 0) {
260 current->next = NULL;
263 OPENSSL_free(current);
270 int CRYPTO_mem_debug_push(const char *info, const char *file, int line)
272 APP_INFO *ami, *amim;
275 if (mem_check_on()) {
276 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
278 if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
279 || (ami = OPENSSL_malloc(sizeof(*ami))) == NULL)
282 ami->threadid = CRYPTO_THREAD_get_current_id();
289 amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
290 CRYPTO_THREAD_set_local(&appinfokey, ami);
296 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
302 int CRYPTO_mem_debug_pop(void)
306 if (mem_check_on()) {
307 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
309 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
314 static unsigned long break_order_num = 0;
316 void CRYPTO_mem_debug_malloc(void *addr, size_t num, int before_p,
317 const char *file, int line)
322 switch (before_p & 127) {
329 if (mem_check_on()) {
330 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
332 if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
333 || (m = OPENSSL_malloc(sizeof(*m))) == NULL) {
335 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
339 if ((mh = lh_MEM_new(mem_hash, mem_cmp)) == NULL) {
351 m->threadid = CRYPTO_THREAD_get_current_id();
353 if (order == break_order_num) {
358 # ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
359 m->array_siz = backtrace(m->array, OSSL_NELEM(m->array));
361 m->time = time(NULL);
363 amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
368 if ((mm = lh_MEM_insert(mh, m)) != NULL) {
369 /* Not good, but don't sweat it */
370 if (mm->app_info != NULL) {
371 mm->app_info->references--;
376 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
383 void CRYPTO_mem_debug_free(void *addr, int before_p,
384 const char *file, int line)
393 if (mem_check_on() && (mh != NULL)) {
394 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
397 mp = lh_MEM_delete(mh, &m);
399 app_info_free(mp->app_info);
403 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
411 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num,
412 int before_p, const char *file, int line)
424 CRYPTO_mem_debug_malloc(addr2, num, 128 | before_p, file, line);
428 if (mem_check_on()) {
429 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
432 mp = lh_MEM_delete(mh, &m);
436 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
437 mp->array_siz = backtrace(mp->array, OSSL_NELEM(mp->array));
439 (void)lh_MEM_insert(mh, mp);
442 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
449 typedef struct mem_leak_st {
450 int (*print_cb) (const char *str, size_t len, void *u);
456 static void print_leak(const MEM *m, MEM_LEAK *l)
460 size_t len = sizeof(buf), ami_cnt;
463 struct tm *lcl = NULL;
465 * Convert between CRYPTO_THREAD_ID (which could be anything at all) and
466 * a long. This may not be meaningful depending on what CRYPTO_THREAD_ID is
467 * but hopefully should give something sensible on most platforms
470 CRYPTO_THREAD_ID tid;
475 lcl = localtime(&m->time);
476 n = BIO_snprintf(bufp, len, "[%02d:%02d:%02d] ",
477 lcl->tm_hour, lcl->tm_min, lcl->tm_sec);
485 n = BIO_snprintf(bufp, len, "%5lu file=%s, line=%d, ",
486 m->order, m->file, m->line);
493 tid.tid = m->threadid;
494 n = BIO_snprintf(bufp, len, "thread=%lu, ", tid.ltid);
500 n = BIO_snprintf(bufp, len, "number=%d, address=%p\n", m->num, m->addr);
506 l->print_cb(buf, (size_t)(bufp - buf), l->print_cb_arg);
522 if (ami_cnt >= sizeof(buf) - 1)
524 memset(buf, '>', ami_cnt);
527 tid.tid = amip->threadid;
528 n = BIO_snprintf(buf + ami_cnt, sizeof(buf) - ami_cnt,
529 " thread=%lu, file=%s, line=%d, info=\"",
530 tid.ltid, amip->file, amip->line);
533 buf_len = ami_cnt + n;
534 info_len = strlen(amip->info);
535 if (128 - buf_len - 3 < info_len) {
536 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
539 n = BIO_snprintf(buf + buf_len, sizeof(buf) - buf_len, "%s",
545 n = BIO_snprintf(buf + buf_len, sizeof(buf) - buf_len, "\"\n");
549 l->print_cb(buf, buf_len + n, l->print_cb_arg);
553 while (amip && CRYPTO_THREAD_compare_id(amip->threadid, ti));
556 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
559 char **strings = backtrace_symbols(m->array, m->array_siz);
561 for (i = 0; i < m->array_siz; i++)
562 fprintf(stderr, "##> %s\n", strings[i]);
568 IMPLEMENT_LHASH_DOALL_ARG_CONST(MEM, MEM_LEAK);
570 int CRYPTO_mem_leaks_cb(int (*cb) (const char *str, size_t len, void *u),
575 /* Ensure all resources are released */
578 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
581 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
588 lh_MEM_doall_MEM_LEAK(mh, print_leak, &ml);
590 if (ml.chunks != 0) {
593 BIO_snprintf(buf, sizeof(buf), "%ld bytes leaked in %d chunks\n",
594 ml.bytes, ml.chunks);
595 cb(buf, strlen(buf), u);
598 * Make sure that, if we found no leaks, memory-leak debugging itself
599 * does not introduce memory leaks (which might irritate external
600 * debugging tools). (When someone enables leak checking, but does not
601 * call this function, we declare it to be their fault.)
605 CRYPTO_THREAD_write_lock(memdbg_lock);
608 * avoid deadlock when lh_free() uses CRYPTO_mem_debug_free(), which uses
611 old_mh_mode = mh_mode;
612 mh_mode = CRYPTO_MEM_CHECK_OFF;
617 mh_mode = old_mh_mode;
618 CRYPTO_THREAD_unlock(memdbg_lock);
620 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF);
622 /* Clean up locks etc */
623 CRYPTO_THREAD_cleanup_local(&appinfokey);
624 CRYPTO_THREAD_lock_free(memdbg_lock);
625 CRYPTO_THREAD_lock_free(long_memdbg_lock);
627 long_memdbg_lock = NULL;
629 return ml.chunks == 0 ? 1 : 0;
632 static int print_bio(const char *str, size_t len, void *b)
634 return BIO_write((BIO *)b, str, len);
637 int CRYPTO_mem_leaks(BIO *b)
640 * OPENSSL_cleanup() will free the ex_data locks so we can't have any
641 * ex_data hanging around
645 return CRYPTO_mem_leaks_cb(print_bio, b);
648 # ifndef OPENSSL_NO_STDIO
649 int CRYPTO_mem_leaks_fp(FILE *fp)
655 * Need to turn off memory checking when allocated BIOs ... especially as
656 * we're creating them at a time when we're trying to check we've not
657 * left anything un-free()'d!!
659 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
660 b = BIO_new(BIO_s_file());
661 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
664 BIO_set_fp(b, fp, BIO_NOCLOSE);
665 ret = CRYPTO_mem_leaks_cb(print_bio, b);