source: EcnlProtoTool/trunk/openssl-1.1.0e/crypto/mem_dbg.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc
File size: 16.8 KB
Line 
1/*
2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
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
8 */
9
10#include <stdio.h>
11#include <stdlib.h>
12#include <time.h>
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>
19
20#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
21# include <execinfo.h>
22#endif
23
24/*
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.
34 */
35#ifndef OPENSSL_NO_CRYPTO_MDEBUG
36static int mh_mode = CRYPTO_MEM_CHECK_OFF;
37#endif
38
39#ifndef OPENSSL_NO_CRYPTO_MDEBUG
40static unsigned long order = 0; /* number of memory requests */
41
42/*-
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,
48 */
49struct app_mem_info_st {
50 CRYPTO_THREAD_ID threadid;
51 const char *file;
52 int line;
53 const char *info;
54 struct app_mem_info_st *next; /* tail of thread's stack */
55 int references;
56};
57
58static CRYPTO_ONCE memdbg_init = CRYPTO_ONCE_STATIC_INIT;
59static CRYPTO_RWLOCK *malloc_lock = NULL;
60static CRYPTO_RWLOCK *long_malloc_lock = NULL;
61static CRYPTO_THREAD_LOCAL appinfokey;
62
63/* memory-block description */
64struct mem_st {
65 void *addr;
66 int num;
67 const char *file;
68 int line;
69 CRYPTO_THREAD_ID threadid;
70 unsigned long order;
71 time_t time;
72 APP_INFO *app_info;
73#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
74 void *array[30];
75 size_t array_siz;
76#endif
77};
78
79static LHASH_OF(MEM) *mh = NULL; /* hash-table of memory requests (address as
80 * key); access requires MALLOC2 lock */
81
82/* num_disable > 0 iff mh_mode == CRYPTO_MEM_CHECK_ON (w/o ..._ENABLE) */
83static unsigned int num_disable = 0;
84
85/*
86 * Valid iff num_disable > 0. long_malloc_lock is locked exactly in this
87 * case (by the thread named in disabling_thread).
88 */
89static CRYPTO_THREAD_ID disabling_threadid;
90
91DEFINE_RUN_ONCE_STATIC(do_memdbg_init)
92{
93 malloc_lock = CRYPTO_THREAD_lock_new();
94 long_malloc_lock = CRYPTO_THREAD_lock_new();
95 if (malloc_lock == NULL || long_malloc_lock == NULL
96 || !CRYPTO_THREAD_init_local(&appinfokey, NULL)) {
97 CRYPTO_THREAD_lock_free(malloc_lock);
98 malloc_lock = NULL;
99 CRYPTO_THREAD_lock_free(long_malloc_lock);
100 long_malloc_lock = NULL;
101 return 0;
102 }
103 return 1;
104}
105
106static void app_info_free(APP_INFO *inf)
107{
108 if (!inf)
109 return;
110 if (--(inf->references) <= 0) {
111 app_info_free(inf->next);
112 OPENSSL_free(inf);
113 }
114}
115#endif
116
117int CRYPTO_mem_ctrl(int mode)
118{
119#ifdef OPENSSL_NO_CRYPTO_MDEBUG
120 return mode - mode;
121#else
122 int ret = mh_mode;
123
124 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
125 return -1;
126
127 CRYPTO_THREAD_write_lock(malloc_lock);
128 switch (mode) {
129 default:
130 break;
131
132 case CRYPTO_MEM_CHECK_ON:
133 mh_mode = CRYPTO_MEM_CHECK_ON | CRYPTO_MEM_CHECK_ENABLE;
134 num_disable = 0;
135 break;
136
137 case CRYPTO_MEM_CHECK_OFF:
138 mh_mode = 0;
139 num_disable = 0;
140 break;
141
142 /* switch off temporarily (for library-internal use): */
143 case CRYPTO_MEM_CHECK_DISABLE:
144 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
145 CRYPTO_THREAD_ID cur = CRYPTO_THREAD_get_current_id();
146 /* see if we don't have long_malloc_lock already */
147 if (!num_disable
148 || !CRYPTO_THREAD_compare_id(disabling_threadid, cur)) {
149 /*
150 * Long-time lock long_malloc_lock must not be claimed
151 * while we're holding malloc_lock, or we'll deadlock
152 * if somebody else holds long_malloc_lock (and cannot
153 * release it because we block entry to this function). Give
154 * them a chance, first, and then claim the locks in
155 * appropriate order (long-time lock first).
156 */
157 CRYPTO_THREAD_unlock(malloc_lock);
158 /*
159 * Note that after we have waited for long_malloc_lock and
160 * malloc_lock, we'll still be in the right "case" and
161 * "if" branch because MemCheck_start and MemCheck_stop may
162 * never be used while there are multiple OpenSSL threads.
163 */
164 CRYPTO_THREAD_write_lock(long_malloc_lock);
165 CRYPTO_THREAD_write_lock(malloc_lock);
166 mh_mode &= ~CRYPTO_MEM_CHECK_ENABLE;
167 disabling_threadid = cur;
168 }
169 num_disable++;
170 }
171 break;
172
173 case CRYPTO_MEM_CHECK_ENABLE:
174 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
175 if (num_disable) { /* always true, or something is going wrong */
176 num_disable--;
177 if (num_disable == 0) {
178 mh_mode |= CRYPTO_MEM_CHECK_ENABLE;
179 CRYPTO_THREAD_unlock(long_malloc_lock);
180 }
181 }
182 }
183 break;
184 }
185 CRYPTO_THREAD_unlock(malloc_lock);
186 return (ret);
187#endif
188}
189
190#ifndef OPENSSL_NO_CRYPTO_MDEBUG
191
192static int mem_check_on(void)
193{
194 int ret = 0;
195 CRYPTO_THREAD_ID cur;
196
197 if (mh_mode & CRYPTO_MEM_CHECK_ON) {
198 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
199 return 0;
200
201 cur = CRYPTO_THREAD_get_current_id();
202 CRYPTO_THREAD_read_lock(malloc_lock);
203
204 ret = (mh_mode & CRYPTO_MEM_CHECK_ENABLE)
205 || !CRYPTO_THREAD_compare_id(disabling_threadid, cur);
206
207 CRYPTO_THREAD_unlock(malloc_lock);
208 }
209 return (ret);
210}
211
212static int mem_cmp(const MEM *a, const MEM *b)
213{
214#ifdef _WIN64
215 const char *ap = (const char *)a->addr, *bp = (const char *)b->addr;
216 if (ap == bp)
217 return 0;
218 else if (ap > bp)
219 return 1;
220 else
221 return -1;
222#else
223 return (const char *)a->addr - (const char *)b->addr;
224#endif
225}
226
227static unsigned long mem_hash(const MEM *a)
228{
229 size_t ret;
230
231 ret = (size_t)a->addr;
232
233 ret = ret * 17851 + (ret >> 14) * 7 + (ret >> 4) * 251;
234 return (ret);
235}
236
237/* returns 1 if there was an info to pop, 0 if the stack was empty. */
238static int pop_info(void)
239{
240 APP_INFO *current = NULL;
241
242 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
243 return 0;
244
245 current = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
246 if (current != NULL) {
247 APP_INFO *next = current->next;
248
249 if (next != NULL) {
250 next->references++;
251 CRYPTO_THREAD_set_local(&appinfokey, next);
252 } else {
253 CRYPTO_THREAD_set_local(&appinfokey, NULL);
254 }
255 if (--(current->references) <= 0) {
256 current->next = NULL;
257 if (next != NULL)
258 next->references--;
259 OPENSSL_free(current);
260 }
261 return 1;
262 }
263 return 0;
264}
265
266int CRYPTO_mem_debug_push(const char *info, const char *file, int line)
267{
268 APP_INFO *ami, *amim;
269 int ret = 0;
270
271 if (mem_check_on()) {
272 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
273
274 if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
275 || (ami = OPENSSL_malloc(sizeof(*ami))) == NULL)
276 goto err;
277
278 ami->threadid = CRYPTO_THREAD_get_current_id();
279 ami->file = file;
280 ami->line = line;
281 ami->info = info;
282 ami->references = 1;
283 ami->next = NULL;
284
285 amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
286 CRYPTO_THREAD_set_local(&appinfokey, ami);
287
288 if (amim != NULL)
289 ami->next = amim;
290 ret = 1;
291 err:
292 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
293 }
294
295 return (ret);
296}
297
298int CRYPTO_mem_debug_pop(void)
299{
300 int ret = 0;
301
302 if (mem_check_on()) {
303 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
304 ret = pop_info();
305 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
306 }
307 return (ret);
308}
309
310static unsigned long break_order_num = 0;
311
312void CRYPTO_mem_debug_malloc(void *addr, size_t num, int before_p,
313 const char *file, int line)
314{
315 MEM *m, *mm;
316 APP_INFO *amim;
317
318 switch (before_p & 127) {
319 case 0:
320 break;
321 case 1:
322 if (addr == NULL)
323 break;
324
325 if (mem_check_on()) {
326 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
327
328 if (!RUN_ONCE(&memdbg_init, do_memdbg_init)
329 || (m = OPENSSL_malloc(sizeof(*m))) == NULL) {
330 OPENSSL_free(addr);
331 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
332 return;
333 }
334 if (mh == NULL) {
335 if ((mh = lh_MEM_new(mem_hash, mem_cmp)) == NULL) {
336 OPENSSL_free(addr);
337 OPENSSL_free(m);
338 addr = NULL;
339 goto err;
340 }
341 }
342
343 m->addr = addr;
344 m->file = file;
345 m->line = line;
346 m->num = num;
347 m->threadid = CRYPTO_THREAD_get_current_id();
348
349 if (order == break_order_num) {
350 /* BREAK HERE */
351 m->order = order;
352 }
353 m->order = order++;
354# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
355 m->array_siz = backtrace(m->array, OSSL_NELEM(m->array));
356# endif
357 m->time = time(NULL);
358
359 amim = (APP_INFO *)CRYPTO_THREAD_get_local(&appinfokey);
360 m->app_info = amim;
361 if (amim != NULL)
362 amim->references++;
363
364 if ((mm = lh_MEM_insert(mh, m)) != NULL) {
365 /* Not good, but don't sweat it */
366 if (mm->app_info != NULL) {
367 mm->app_info->references--;
368 }
369 OPENSSL_free(mm);
370 }
371 err:
372 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
373 }
374 break;
375 }
376 return;
377}
378
379void CRYPTO_mem_debug_free(void *addr, int before_p,
380 const char *file, int line)
381{
382 MEM m, *mp;
383
384 switch (before_p) {
385 case 0:
386 if (addr == NULL)
387 break;
388
389 if (mem_check_on() && (mh != NULL)) {
390 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
391
392 m.addr = addr;
393 mp = lh_MEM_delete(mh, &m);
394 if (mp != NULL) {
395 app_info_free(mp->app_info);
396 OPENSSL_free(mp);
397 }
398
399 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
400 }
401 break;
402 case 1:
403 break;
404 }
405}
406
407void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num,
408 int before_p, const char *file, int line)
409{
410 MEM m, *mp;
411
412 switch (before_p) {
413 case 0:
414 break;
415 case 1:
416 if (addr2 == NULL)
417 break;
418
419 if (addr1 == NULL) {
420 CRYPTO_mem_debug_malloc(addr2, num, 128 | before_p, file, line);
421 break;
422 }
423
424 if (mem_check_on()) {
425 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
426
427 m.addr = addr1;
428 mp = lh_MEM_delete(mh, &m);
429 if (mp != NULL) {
430 mp->addr = addr2;
431 mp->num = num;
432#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
433 mp->array_siz = backtrace(mp->array, OSSL_NELEM(mp->array));
434#endif
435 (void)lh_MEM_insert(mh, mp);
436 }
437
438 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
439 }
440 break;
441 }
442 return;
443}
444
445typedef struct mem_leak_st {
446 BIO *bio;
447 int chunks;
448 long bytes;
449} MEM_LEAK;
450
451static void print_leak(const MEM *m, MEM_LEAK *l)
452{
453 char buf[1024];
454 char *bufp = buf;
455 APP_INFO *amip;
456 int ami_cnt;
457 struct tm *lcl = NULL;
458 /*
459 * Convert between CRYPTO_THREAD_ID (which could be anything at all) and
460 * a long. This may not be meaningful depending on what CRYPTO_THREAD_ID is
461 * but hopefully should give something sensible on most platforms
462 */
463 union {
464 CRYPTO_THREAD_ID tid;
465 unsigned long ltid;
466 } tid;
467 CRYPTO_THREAD_ID ti;
468
469#define BUF_REMAIN (sizeof buf - (size_t)(bufp - buf))
470
471 lcl = localtime(&m->time);
472 BIO_snprintf(bufp, BUF_REMAIN, "[%02d:%02d:%02d] ",
473 lcl->tm_hour, lcl->tm_min, lcl->tm_sec);
474 bufp += strlen(bufp);
475
476 BIO_snprintf(bufp, BUF_REMAIN, "%5lu file=%s, line=%d, ",
477 m->order, m->file, m->line);
478 bufp += strlen(bufp);
479
480 tid.ltid = 0;
481 tid.tid = m->threadid;
482 BIO_snprintf(bufp, BUF_REMAIN, "thread=%lu, ", tid.ltid);
483 bufp += strlen(bufp);
484
485 BIO_snprintf(bufp, BUF_REMAIN, "number=%d, address=%p\n",
486 m->num, m->addr);
487 bufp += strlen(bufp);
488
489 BIO_puts(l->bio, buf);
490
491 l->chunks++;
492 l->bytes += m->num;
493
494 amip = m->app_info;
495 ami_cnt = 0;
496
497 if (amip) {
498 ti = amip->threadid;
499
500 do {
501 int buf_len;
502 int info_len;
503
504 ami_cnt++;
505 memset(buf, '>', ami_cnt);
506 tid.ltid = 0;
507 tid.tid = amip->threadid;
508 BIO_snprintf(buf + ami_cnt, sizeof buf - ami_cnt,
509 " thread=%lu, file=%s, line=%d, info=\"",
510 tid.ltid, amip->file,
511 amip->line);
512 buf_len = strlen(buf);
513 info_len = strlen(amip->info);
514 if (128 - buf_len - 3 < info_len) {
515 memcpy(buf + buf_len, amip->info, 128 - buf_len - 3);
516 buf_len = 128 - 3;
517 } else {
518 OPENSSL_strlcpy(buf + buf_len, amip->info, sizeof buf - buf_len);
519 buf_len = strlen(buf);
520 }
521 BIO_snprintf(buf + buf_len, sizeof buf - buf_len, "\"\n");
522
523 BIO_puts(l->bio, buf);
524
525 amip = amip->next;
526 }
527 while (amip && CRYPTO_THREAD_compare_id(amip->threadid, ti));
528 }
529
530#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
531 {
532 size_t i;
533 char **strings = backtrace_symbols(m->array, m->array_siz);
534
535 for (i = 0; i < m->array_siz; i++)
536 fprintf(stderr, "##> %s\n", strings[i]);
537 free(strings);
538 }
539#endif
540}
541
542IMPLEMENT_LHASH_DOALL_ARG_CONST(MEM, MEM_LEAK);
543
544int CRYPTO_mem_leaks(BIO *b)
545{
546 MEM_LEAK ml;
547
548 /*
549 * OPENSSL_cleanup() will free the ex_data locks so we can't have any
550 * ex_data hanging around
551 */
552 bio_free_ex_data(b);
553
554 /* Ensure all resources are released */
555 OPENSSL_cleanup();
556
557 if (!RUN_ONCE(&memdbg_init, do_memdbg_init))
558 return -1;
559
560 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
561
562 ml.bio = b;
563 ml.bytes = 0;
564 ml.chunks = 0;
565 if (mh != NULL)
566 lh_MEM_doall_MEM_LEAK(mh, print_leak, &ml);
567
568 if (ml.chunks != 0) {
569 BIO_printf(b, "%ld bytes leaked in %d chunks\n", ml.bytes, ml.chunks);
570 } else {
571 /*
572 * Make sure that, if we found no leaks, memory-leak debugging itself
573 * does not introduce memory leaks (which might irritate external
574 * debugging tools). (When someone enables leak checking, but does not
575 * call this function, we declare it to be their fault.)
576 */
577 int old_mh_mode;
578
579 CRYPTO_THREAD_write_lock(malloc_lock);
580
581 /*
582 * avoid deadlock when lh_free() uses CRYPTO_mem_debug_free(), which uses
583 * mem_check_on
584 */
585 old_mh_mode = mh_mode;
586 mh_mode = CRYPTO_MEM_CHECK_OFF;
587
588 lh_MEM_free(mh);
589 mh = NULL;
590
591 mh_mode = old_mh_mode;
592 CRYPTO_THREAD_unlock(malloc_lock);
593 }
594 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF);
595
596 /* Clean up locks etc */
597 CRYPTO_THREAD_cleanup_local(&appinfokey);
598 CRYPTO_THREAD_lock_free(malloc_lock);
599 CRYPTO_THREAD_lock_free(long_malloc_lock);
600 malloc_lock = NULL;
601 long_malloc_lock = NULL;
602
603 return ml.chunks == 0 ? 1 : 0;
604}
605
606# ifndef OPENSSL_NO_STDIO
607int CRYPTO_mem_leaks_fp(FILE *fp)
608{
609 BIO *b;
610 int ret;
611
612 /*
613 * Need to turn off memory checking when allocated BIOs ... especially as
614 * we're creating them at a time when we're trying to check we've not
615 * left anything un-free()'d!!
616 */
617 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
618 b = BIO_new(BIO_s_file());
619 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE);
620 if (b == NULL)
621 return -1;
622 BIO_set_fp(b, fp, BIO_NOCLOSE);
623 ret = CRYPTO_mem_leaks(b);
624 BIO_free(b);
625 return ret;
626}
627# endif
628
629#endif
Note: See TracBrowser for help on using the repository browser.