From 552df47dc0c22d567e11e87204229d04a0fb7f2d Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Fri, 15 May 2015 16:00:15 -0700 Subject: [PATCH] Remove leftovers of the old-style locks. At this point, none of these functions or macros are used so they can just be deleted. Change-Id: I8ed1aae7a252e886864bf43e3096eff2228183cd Reviewed-on: https://boringssl-review.googlesource.com/4777 Reviewed-by: Adam Langley --- crypto/thread.c | 48 ++--------------- include/openssl/thread.h | 113 +++------------------------------------ 2 files changed, 12 insertions(+), 149 deletions(-) diff --git a/crypto/thread.c b/crypto/thread.c index 954e2ae4..88371159 100644 --- a/crypto/thread.c +++ b/crypto/thread.c @@ -69,40 +69,16 @@ #include -#define CRYPTO_LOCK_ITEM(x) #x - -/* lock_names contains the names of all the locks defined in thread.h. */ -static const char *const lock_names[] = { - CRYPTO_LOCK_LIST -}; - -#undef CRYPTO_LOCK_ITEM - -#define CRYPTO_NUM_LOCKS (sizeof(lock_names) / sizeof(lock_names[0])) - -static void (*locking_callback)(int mode, int lock_num, const char *file, - int line) = 0; -static int (*add_lock_callback)(int *pointer, int amount, int lock_num, - const char *file, int line) = 0; - -int CRYPTO_num_locks(void) { return CRYPTO_NUM_LOCKS; } +int CRYPTO_num_locks(void) { return 1; } void CRYPTO_set_locking_callback(void (*func)(int mode, int lock_num, - const char *file, int line)) { - locking_callback = func; -} + const char *file, int line)) {} void CRYPTO_set_add_lock_callback(int (*func)(int *num, int mount, int lock_num, - const char *file, int line)) { - add_lock_callback = func; -} + const char *file, int line)) {} const char *CRYPTO_get_lock_name(int lock_num) { - if (lock_num >= 0 && lock_num < CRYPTO_NUM_LOCKS) { - return lock_names[lock_num]; - } else { - return "ERROR"; - } + return "No old-style OpenSSL locks anymore"; } int CRYPTO_THREADID_set_callback(void (*func)(CRYPTO_THREADID *)) { return 1; } @@ -113,22 +89,6 @@ void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr) {} void CRYPTO_THREADID_current(CRYPTO_THREADID *id) {} -void (*CRYPTO_get_locking_callback(void))(int mode, int lock_num, - const char *file, int line) { - return locking_callback; -} - -int (*CRYPTO_get_add_lock_callback(void))(int *num, int mount, int lock_num, - const char *file, int line) { - return add_lock_callback; -} - -void CRYPTO_lock(int mode, int lock_num, const char *file, int line) { - if (locking_callback != NULL) { - locking_callback(mode, lock_num, file, line); - } -} - void CRYPTO_set_id_callback(unsigned long (*func)(void)) {} void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *( diff --git a/include/openssl/thread.h b/include/openssl/thread.h index d5e05b76..a05becec 100644 --- a/include/openssl/thread.h +++ b/include/openssl/thread.h @@ -100,55 +100,25 @@ typedef union crypto_mutex_st { typedef uint32_t CRYPTO_refcount_t; -/* Functions to support multithreading. - * - * OpenSSL can safely be used in multi-threaded applications provided that at - * least |CRYPTO_set_locking_callback| is set. - * - * The locking callback performs mutual exclusion. Rather than using a single - * lock for all, shared data-structures, OpenSSL requires that the locking - * callback support a fixed (at run-time) number of different locks, given by - * |CRYPTO_num_locks|. */ - +/* Deprecated functions */ -/* CRYPTO_num_locks returns the number of static locks that the callback - * function passed to |CRYPTO_set_locking_callback| must be able to handle. */ +/* CRYPTO_num_locks returns one. (This is non-zero that callers who allocate + * sizeof(lock) times this value don't get zero and then fail because malloc(0) + * returned NULL.) */ OPENSSL_EXPORT int CRYPTO_num_locks(void); -/* CRYPTO_set_locking_callback sets a callback function that implements locking - * on behalf of OpenSSL. The callback is called whenever OpenSSL needs to lock - * or unlock a lock, and locks are specified as a number between zero and - * |CRYPTO_num_locks()-1|. - * - * The mode argument to the callback is a bitwise-OR of either CRYPTO_LOCK or - * CRYPTO_UNLOCK, to denote the action, and CRYPTO_READ or CRYPTO_WRITE, to - * indicate the type of lock. The |file| and |line| arguments give the location - * in the OpenSSL source where the locking action originated. */ +/* CRYPTO_set_locking_callback does nothing. */ OPENSSL_EXPORT void CRYPTO_set_locking_callback( void (*func)(int mode, int lock_num, const char *file, int line)); -/* CRYPTO_set_add_lock_callback sets an optional callback which is used when - * OpenSSL needs to add a fixed amount to an integer. For example, this is used - * when maintaining reference counts. Normally the reference counts are - * maintained by performing the addition under a lock but, if this callback - * has been set, the application is free to implement the operation using - * faster methods (i.e. atomic operations). - * - * The callback is given a pointer to the integer to be altered (|num|), the - * amount to add to the integer (|amount|, which may be negative), the number - * of the lock which would have been taken to protect the operation and the - * position in the OpenSSL code where the operation originated. */ +/* CRYPTO_set_add_lock_callback does nothing. */ OPENSSL_EXPORT void CRYPTO_set_add_lock_callback(int (*func)( int *num, int amount, int lock_num, const char *file, int line)); -/* CRYPTO_get_lock_name returns the name of the lock given by |lock_num|. This - * can be used in a locking callback for debugging purposes. */ +/* CRYPTO_get_lock_name returns a fixed, dummy string. */ OPENSSL_EXPORT const char *CRYPTO_get_lock_name(int lock_num); - -/* Deprecated functions */ - -/* CRYPTO_THREADID_set_callback does nothing. */ +/* CRYPTO_THREADID_set_callback returns one. */ OPENSSL_EXPORT int CRYPTO_THREADID_set_callback( void (*threadid_func)(CRYPTO_THREADID *threadid)); @@ -163,73 +133,6 @@ OPENSSL_EXPORT void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr); OPENSSL_EXPORT void CRYPTO_THREADID_current(CRYPTO_THREADID *id); -/* Private functions: */ - -/* CRYPTO_get_locking_callback returns the callback, if any, that was most - * recently set using |CRYPTO_set_locking_callback|. */ -void (*CRYPTO_get_locking_callback(void))(int mode, int lock_num, - const char *file, int line); - -/* CRYPTO_get_add_lock_callback returns the callback, if any, that was most - * recently set using |CRYPTO_set_add_lock_callback|. */ -int (*CRYPTO_get_add_lock_callback(void))(int *num, int amount, int lock_num, - const char *file, int line); - -/* CRYPTO_lock locks or unlocks the lock specified by |lock_num| (one of - * |CRYPTO_LOCK_*|). Don't call this directly, rather use one of the - * CRYPTO_[rw]_(un)lock macros. */ -OPENSSL_EXPORT void CRYPTO_lock(int mode, int lock_num, const char *file, - int line); - -/* Lock IDs start from 1. CRYPTO_LOCK_INVALID_LOCK is an unused placeholder - * used to ensure no lock has ID 0. */ -#define CRYPTO_LOCK_LIST \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_INVALID_LOCK), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_BIO), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_DH), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_DSA), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_EC), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_EC_PRE_COMP), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_ERR), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_EVP_PKEY), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_EX_DATA), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_OBJ), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_RAND), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_READDIR), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_RSA), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_RSA_BLINDING), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_SSL_CTX), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_SSL_SESSION), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509_INFO), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509_PKEY), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509_CRL), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509_REQ), \ - CRYPTO_LOCK_ITEM(CRYPTO_LOCK_X509_STORE), \ - -#define CRYPTO_LOCK_ITEM(x) x - -enum { - CRYPTO_LOCK_LIST -}; - -#undef CRYPTO_LOCK_ITEM - -#define CRYPTO_LOCK 1 -#define CRYPTO_UNLOCK 2 -#define CRYPTO_READ 4 -#define CRYPTO_WRITE 8 - -#define CRYPTO_w_lock(lock_num) \ - CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, lock_num, __FILE__, __LINE__) -#define CRYPTO_w_unlock(lock_num) \ - CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, lock_num, __FILE__, __LINE__) -#define CRYPTO_r_lock(lock_num) \ - CRYPTO_lock(CRYPTO_LOCK | CRYPTO_READ, lock_num, __FILE__, __LINE__) -#define CRYPTO_r_unlock(lock_num) \ - CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_READ, lock_num, __FILE__, __LINE__) - - /* Private functions. * * Some old code calls these functions and so no-op implementations are