X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=crypto%2Fmem.c;h=780053ffeff1e2723eec5e44dbbff69d2d1b0e9a;hb=f61c68043d3bd2ad9718d356e7988ee2fdfc3621;hp=2e8a00cf93e8a207ad74099c3fc6fe4ac69bcfbf;hpb=f7edeced4d8d3f650c5ee32f20ba7165da4e3067;p=oweals%2Fopenssl.git diff --git a/crypto/mem.c b/crypto/mem.c index 2e8a00cf93..780053ffef 100644 --- a/crypto/mem.c +++ b/crypto/mem.c @@ -1,5 +1,5 @@ /* - * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. + * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the OpenSSL license (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy @@ -7,12 +7,13 @@ * https://www.openssl.org/source/license.html */ +#include "e_os.h" +#include "internal/cryptlib.h" +#include "internal/cryptlib_int.h" #include #include #include #include -#include "internal/cryptlib.h" -#include "internal/cryptlib_int.h" #ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE # include #endif @@ -30,9 +31,17 @@ static void (*free_impl)(void *, const char *, int) = CRYPTO_free; #ifndef OPENSSL_NO_CRYPTO_MDEBUG +# include "internal/tsan_assist.h" + +static TSAN_QUALIFIER int malloc_count; +static TSAN_QUALIFIER int realloc_count; +static TSAN_QUALIFIER int free_count; + +# define INCREMENT(x) tsan_counter(&(x)) + static char *md_failstring; static long md_count; -static int md_percent = 100; +static int md_fail_percent = 0; static int md_tracefd = -1; static int call_malloc_debug = 1; @@ -44,6 +53,7 @@ static int shouldfail(void); #else static int call_malloc_debug = 0; +# define INCREMENT(x) /* empty */ # define FAILTEST() /* empty */ #endif @@ -85,11 +95,22 @@ void CRYPTO_get_mem_functions( } #ifndef OPENSSL_NO_CRYPTO_MDEBUG +void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount) +{ + if (mcount != NULL) + *mcount = tsan_load(&malloc_count); + if (rcount != NULL) + *rcount = tsan_load(&realloc_count); + if (fcount != NULL) + *fcount = tsan_load(&free_count); +} + /* * Parse a "malloc failure spec" string. This likes like a set of fields * separated by semicolons. Each field has a count and an optional failure * percentage. For example: - * 100;100@25;@100 + * 100@0;100@25;0@0 + * or 100;100@25;0 * This means 100 mallocs succeed, then next 100 fail 25% of the time, and * all remaining (count is zero) succeed. */ @@ -104,35 +125,49 @@ static void parseit(void) /* Get the count (atol will stop at the @ if there), and percentage */ md_count = atol(md_failstring); atsign = strchr(md_failstring, '@'); - md_percent = atsign == NULL ? 100 : atoi(atsign + 1); + md_fail_percent = atsign == NULL ? 0 : atoi(atsign + 1); if (semi != NULL) md_failstring = semi; } +/* + * Windows doesn't have random(), but it has rand() + * Some rand() implementations aren't good, but we're not + * dealing with secure randomness here. + */ +# ifdef _WIN32 +# define random() rand() +# endif /* * See if the current malloc should fail. */ static int shouldfail(void) { int roll = (int)(random() % 100); - int shouldfail = roll > md_percent; + int shoulditfail = roll < md_fail_percent; +# ifndef _WIN32 +/* suppressed on Windows as POSIX-like file descriptors are non-inheritable */ + int len; char buff[80]; if (md_tracefd > 0) { BIO_snprintf(buff, sizeof(buff), "%c C%ld %%%d R%d\n", - shouldfail ? '-' : '+', md_count, md_percent, roll); - write(md_tracefd, buff, strlen(buff)); -#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE - if (shouldfail) { + shoulditfail ? '-' : '+', md_count, md_fail_percent, roll); + len = strlen(buff); + if (write(md_tracefd, buff, len) != len) + perror("shouldfail write failed"); +# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE + if (shoulditfail) { void *addrs[30]; int num = backtrace(addrs, OSSL_NELEM(addrs)); backtrace_symbols_fd(addrs, num, md_tracefd); } -#endif +# endif } +# endif if (md_count) { /* If we used up this one, go to the next. */ @@ -140,7 +175,7 @@ static int shouldfail(void) parseit(); } - return shouldfail; + return shoulditfail; } void ossl_malloc_setup_failures(void) @@ -158,14 +193,22 @@ void *CRYPTO_malloc(size_t num, const char *file, int line) { void *ret = NULL; + INCREMENT(malloc_count); if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc) return malloc_impl(num, file, line); - if (num <= 0) + if (num == 0) return NULL; FAILTEST(); - allow_customize = 0; + if (allow_customize) { + /* + * Disallow customization after the first allocation. We only set this + * if necessary to avoid a store to the same cache line on every + * allocation. + */ + allow_customize = 0; + } #ifndef OPENSSL_NO_CRYPTO_MDEBUG if (call_malloc_debug) { CRYPTO_mem_debug_malloc(NULL, num, 0, file, line); @@ -175,7 +218,7 @@ void *CRYPTO_malloc(size_t num, const char *file, int line) ret = malloc(num); } #else - osslargused(file); osslargused(line); + (void)(file); (void)(line); ret = malloc(num); #endif @@ -194,6 +237,7 @@ void *CRYPTO_zalloc(size_t num, const char *file, int line) void *CRYPTO_realloc(void *str, size_t num, const char *file, int line) { + INCREMENT(realloc_count); if (realloc_impl != NULL && realloc_impl != &CRYPTO_realloc) return realloc_impl(str, num, file, line); @@ -206,7 +250,6 @@ void *CRYPTO_realloc(void *str, size_t num, const char *file, int line) return NULL; } - allow_customize = 0; #ifndef OPENSSL_NO_CRYPTO_MDEBUG if (call_malloc_debug) { void *ret; @@ -216,7 +259,7 @@ void *CRYPTO_realloc(void *str, size_t num, const char *file, int line) return ret; } #else - osslargused(file); osslargused(line); + (void)(file); (void)(line); #endif return realloc(str, num); @@ -251,6 +294,7 @@ void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num, void CRYPTO_free(void *str, const char *file, int line) { + INCREMENT(free_count); if (free_impl != NULL && free_impl != &CRYPTO_free) { free_impl(str, file, line); return;