2 * Copyright 1995-2018 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_lock_new();
97 long_memdbg_lock
= CRYPTO_THREAD_lock_new();
98 if (memdbg_lock
== NULL
|| long_memdbg_lock
== NULL
99 || !CRYPTO_THREAD_init_local(&appinfokey
, NULL
)) {
100 CRYPTO_THREAD_lock_free(memdbg_lock
);
102 CRYPTO_THREAD_lock_free(long_memdbg_lock
);
103 long_memdbg_lock
= NULL
;
109 static void app_info_free(APP_INFO
*inf
)
113 if (--(inf
->references
) <= 0) {
114 app_info_free(inf
->next
);
120 int CRYPTO_mem_ctrl(int mode
)
122 #ifdef OPENSSL_NO_CRYPTO_MDEBUG
127 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
))
130 CRYPTO_THREAD_write_lock(memdbg_lock
);
135 case CRYPTO_MEM_CHECK_ON
:
136 mh_mode
= CRYPTO_MEM_CHECK_ON
| CRYPTO_MEM_CHECK_ENABLE
;
140 case CRYPTO_MEM_CHECK_OFF
:
145 /* switch off temporarily (for library-internal use): */
146 case CRYPTO_MEM_CHECK_DISABLE
:
147 if (mh_mode
& CRYPTO_MEM_CHECK_ON
) {
148 CRYPTO_THREAD_ID cur
= CRYPTO_THREAD_get_current_id();
149 /* see if we don't have long_memdbg_lock already */
151 || !CRYPTO_THREAD_compare_id(disabling_threadid
, cur
)) {
153 * Long-time lock long_memdbg_lock must not be claimed
154 * while we're holding memdbg_lock, or we'll deadlock
155 * if somebody else holds long_memdbg_lock (and cannot
156 * release it because we block entry to this function). Give
157 * them a chance, first, and then claim the locks in
158 * appropriate order (long-time lock first).
160 CRYPTO_THREAD_unlock(memdbg_lock
);
162 * Note that after we have waited for long_memdbg_lock and
163 * memdbg_lock, we'll still be in the right "case" and
164 * "if" branch because MemCheck_start and MemCheck_stop may
165 * never be used while there are multiple OpenSSL threads.
167 CRYPTO_THREAD_write_lock(long_memdbg_lock
);
168 CRYPTO_THREAD_write_lock(memdbg_lock
);
169 mh_mode
&= ~CRYPTO_MEM_CHECK_ENABLE
;
170 disabling_threadid
= cur
;
176 case CRYPTO_MEM_CHECK_ENABLE
:
177 if (mh_mode
& CRYPTO_MEM_CHECK_ON
) {
178 if (num_disable
) { /* always true, or something is going wrong */
180 if (num_disable
== 0) {
181 mh_mode
|= CRYPTO_MEM_CHECK_ENABLE
;
182 CRYPTO_THREAD_unlock(long_memdbg_lock
);
188 CRYPTO_THREAD_unlock(memdbg_lock
);
193 #ifndef OPENSSL_NO_CRYPTO_MDEBUG
195 static int mem_check_on(void)
198 CRYPTO_THREAD_ID cur
;
200 if (mh_mode
& CRYPTO_MEM_CHECK_ON
) {
201 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
))
204 cur
= CRYPTO_THREAD_get_current_id();
205 CRYPTO_THREAD_read_lock(memdbg_lock
);
207 ret
= (mh_mode
& CRYPTO_MEM_CHECK_ENABLE
)
208 || !CRYPTO_THREAD_compare_id(disabling_threadid
, cur
);
210 CRYPTO_THREAD_unlock(memdbg_lock
);
215 static int mem_cmp(const MEM
*a
, const MEM
*b
)
218 const char *ap
= (const char *)a
->addr
, *bp
= (const char *)b
->addr
;
226 return (const char *)a
->addr
- (const char *)b
->addr
;
230 static unsigned long mem_hash(const MEM
*a
)
234 ret
= (size_t)a
->addr
;
236 ret
= ret
* 17851 + (ret
>> 14) * 7 + (ret
>> 4) * 251;
240 /* returns 1 if there was an info to pop, 0 if the stack was empty. */
241 static int pop_info(void)
243 APP_INFO
*current
= NULL
;
245 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
))
248 current
= (APP_INFO
*)CRYPTO_THREAD_get_local(&appinfokey
);
249 if (current
!= NULL
) {
250 APP_INFO
*next
= current
->next
;
254 CRYPTO_THREAD_set_local(&appinfokey
, next
);
256 CRYPTO_THREAD_set_local(&appinfokey
, NULL
);
258 if (--(current
->references
) <= 0) {
259 current
->next
= NULL
;
262 OPENSSL_free(current
);
269 int CRYPTO_mem_debug_push(const char *info
, const char *file
, int line
)
271 APP_INFO
*ami
, *amim
;
274 if (mem_check_on()) {
275 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
277 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
)
278 || (ami
= OPENSSL_malloc(sizeof(*ami
))) == NULL
)
281 ami
->threadid
= CRYPTO_THREAD_get_current_id();
288 amim
= (APP_INFO
*)CRYPTO_THREAD_get_local(&appinfokey
);
289 CRYPTO_THREAD_set_local(&appinfokey
, ami
);
295 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
301 int CRYPTO_mem_debug_pop(void)
305 if (mem_check_on()) {
306 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
308 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
313 static unsigned long break_order_num
= 0;
315 void CRYPTO_mem_debug_malloc(void *addr
, size_t num
, int before_p
,
316 const char *file
, int line
)
321 switch (before_p
& 127) {
328 if (mem_check_on()) {
329 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
331 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
)
332 || (m
= OPENSSL_malloc(sizeof(*m
))) == NULL
) {
334 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
338 if ((mh
= lh_MEM_new(mem_hash
, mem_cmp
)) == NULL
) {
350 m
->threadid
= CRYPTO_THREAD_get_current_id();
352 if (order
== break_order_num
) {
357 # ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
358 m
->array_siz
= backtrace(m
->array
, OSSL_NELEM(m
->array
));
360 m
->time
= time(NULL
);
362 amim
= (APP_INFO
*)CRYPTO_THREAD_get_local(&appinfokey
);
367 if ((mm
= lh_MEM_insert(mh
, m
)) != NULL
) {
368 /* Not good, but don't sweat it */
369 if (mm
->app_info
!= NULL
) {
370 mm
->app_info
->references
--;
375 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
382 void CRYPTO_mem_debug_free(void *addr
, int before_p
,
383 const char *file
, int line
)
392 if (mem_check_on() && (mh
!= NULL
)) {
393 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
396 mp
= lh_MEM_delete(mh
, &m
);
398 app_info_free(mp
->app_info
);
402 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
410 void CRYPTO_mem_debug_realloc(void *addr1
, void *addr2
, size_t num
,
411 int before_p
, const char *file
, int line
)
423 CRYPTO_mem_debug_malloc(addr2
, num
, 128 | before_p
, file
, line
);
427 if (mem_check_on()) {
428 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
431 mp
= lh_MEM_delete(mh
, &m
);
435 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
436 mp
->array_siz
= backtrace(mp
->array
, OSSL_NELEM(mp
->array
));
438 (void)lh_MEM_insert(mh
, mp
);
441 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
448 typedef struct mem_leak_st
{
449 int (*print_cb
) (const char *str
, size_t len
, void *u
);
455 static void print_leak(const MEM
*m
, MEM_LEAK
*l
)
459 size_t len
= sizeof(buf
), ami_cnt
;
462 struct tm
*lcl
= NULL
;
464 * Convert between CRYPTO_THREAD_ID (which could be anything at all) and
465 * a long. This may not be meaningful depending on what CRYPTO_THREAD_ID is
466 * but hopefully should give something sensible on most platforms
469 CRYPTO_THREAD_ID tid
;
474 lcl
= localtime(&m
->time
);
475 n
= BIO_snprintf(bufp
, len
, "[%02d:%02d:%02d] ",
476 lcl
->tm_hour
, lcl
->tm_min
, lcl
->tm_sec
);
484 n
= BIO_snprintf(bufp
, len
, "%5lu file=%s, line=%d, ",
485 m
->order
, m
->file
, m
->line
);
492 tid
.tid
= m
->threadid
;
493 n
= BIO_snprintf(bufp
, len
, "thread=%lu, ", tid
.ltid
);
499 n
= BIO_snprintf(bufp
, len
, "number=%d, address=%p\n", m
->num
, m
->addr
);
505 l
->print_cb(buf
, (size_t)(bufp
- buf
), l
->print_cb_arg
);
521 if (ami_cnt
>= sizeof(buf
) - 1)
523 memset(buf
, '>', ami_cnt
);
526 tid
.tid
= amip
->threadid
;
527 n
= BIO_snprintf(buf
+ ami_cnt
, sizeof(buf
) - ami_cnt
,
528 " thread=%lu, file=%s, line=%d, info=\"",
529 tid
.ltid
, amip
->file
, amip
->line
);
532 buf_len
= ami_cnt
+ n
;
533 info_len
= strlen(amip
->info
);
534 if (128 - buf_len
- 3 < info_len
) {
535 memcpy(buf
+ buf_len
, amip
->info
, 128 - buf_len
- 3);
538 n
= BIO_snprintf(buf
+ buf_len
, sizeof(buf
) - buf_len
, "%s",
544 n
= BIO_snprintf(buf
+ buf_len
, sizeof(buf
) - buf_len
, "\"\n");
548 l
->print_cb(buf
, buf_len
+ n
, l
->print_cb_arg
);
552 while (amip
&& CRYPTO_THREAD_compare_id(amip
->threadid
, ti
));
555 #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
558 char **strings
= backtrace_symbols(m
->array
, m
->array_siz
);
560 for (i
= 0; i
< m
->array_siz
; i
++)
561 fprintf(stderr
, "##> %s\n", strings
[i
]);
567 IMPLEMENT_LHASH_DOALL_ARG_CONST(MEM
, MEM_LEAK
);
569 int CRYPTO_mem_leaks_cb(int (*cb
) (const char *str
, size_t len
, void *u
),
574 /* Ensure all resources are released */
577 if (!RUN_ONCE(&memdbg_init
, do_memdbg_init
))
580 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
587 lh_MEM_doall_MEM_LEAK(mh
, print_leak
, &ml
);
589 if (ml
.chunks
!= 0) {
592 BIO_snprintf(buf
, sizeof(buf
), "%ld bytes leaked in %d chunks\n",
593 ml
.bytes
, ml
.chunks
);
594 cb(buf
, strlen(buf
), u
);
597 * Make sure that, if we found no leaks, memory-leak debugging itself
598 * does not introduce memory leaks (which might irritate external
599 * debugging tools). (When someone enables leak checking, but does not
600 * call this function, we declare it to be their fault.)
604 CRYPTO_THREAD_write_lock(memdbg_lock
);
607 * avoid deadlock when lh_free() uses CRYPTO_mem_debug_free(), which uses
610 old_mh_mode
= mh_mode
;
611 mh_mode
= CRYPTO_MEM_CHECK_OFF
;
616 mh_mode
= old_mh_mode
;
617 CRYPTO_THREAD_unlock(memdbg_lock
);
619 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF
);
621 /* Clean up locks etc */
622 CRYPTO_THREAD_cleanup_local(&appinfokey
);
623 CRYPTO_THREAD_lock_free(memdbg_lock
);
624 CRYPTO_THREAD_lock_free(long_memdbg_lock
);
626 long_memdbg_lock
= NULL
;
628 return ml
.chunks
== 0 ? 1 : 0;
631 static int print_bio(const char *str
, size_t len
, void *b
)
633 return BIO_write((BIO
*)b
, str
, len
);
636 int CRYPTO_mem_leaks(BIO
*b
)
639 * OPENSSL_cleanup() will free the ex_data locks so we can't have any
640 * ex_data hanging around
644 return CRYPTO_mem_leaks_cb(print_bio
, b
);
647 # ifndef OPENSSL_NO_STDIO
648 int CRYPTO_mem_leaks_fp(FILE *fp
)
654 * Need to turn off memory checking when allocated BIOs ... especially as
655 * we're creating them at a time when we're trying to check we've not
656 * left anything un-free()'d!!
658 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE
);
659 b
= BIO_new(BIO_s_file());
660 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE
);
663 BIO_set_fp(b
, fp
, BIO_NOCLOSE
);
664 ret
= CRYPTO_mem_leaks_cb(print_bio
, b
);