upstream/oracle/userland-gate: comparison components/openssl/common/patches/029-fork

equal deleted inserted replaced

-:569bef81e3c4
+:fbbec9b86c26
 #	PSARC/2014/077
 #	PSARC/2015/043
 # This change was implemented in-house.  The issue was brought up to
 # the upstream engineers, but there was no commitment.
 #
---- openssl-1.0.1f/crypto/cryptlib.c.~1~	Fri Feb  7 10:41:36 2014
+--- a/crypto/cryptlib.c	2016-05-03 06:44:42.000000000 -0700
-+++ openssl-1.0.1f/crypto/cryptlib.c	Thu Feb  6 16:03:58 2014
++++ b/crypto/cryptlib.c	2016-09-02 08:47:23.640202700 -0700
 @@ -116,6 +116,7 @@
 #include "cryptlib.h"
 #include <openssl/safestack.h>
 +#include <pthread.h>
 +    /*
 +     * we now setup our own dynamic locking callback, and disallow
 +     * setting of another locking callback.
 +     */
 }
 void CRYPTO_set_dynlock_lock_callback(void (*func) (int mode,
 @@ -382,7 +388,10 @@
 const char *file,
 int line))
 {
 +    /*
 +     * we now setup our own dynamic locking callback, and disallow
 +     * setting of another locking callback.
 +     */
 }
 void CRYPTO_set_dynlock_destroy_callback(void (*func)
 @@ -389,7 +398,10 @@
 (struct CRYPTO_dynlock_value *l,
 const char *file, int line))
 {
 +    /*
 +     * we now setup our own dynamic locking callback, and disallow
 +     * setting of another locking callback.
 +     */
 }
 void (*CRYPTO_get_locking_callback(void)) (int mode, int type,
-@@ -402,6 +414,128@@
+@@ -402,6 +414,127 @@
 return (add_lock_callback);
 }
 +/*
 + * This is the locking callback function which all applications will be
 + * using when CRYPTO_lock() is called.
 + */
 +static void solaris_locking_callback(int mode, int type, const char *file,
 +    int line)
 +{
 +    if (mode & CRYPTO_LOCK) {
-+        pthread_mutex_lock(&solaris_openssl_locks[type]);
++        (void) pthread_mutex_lock(&solaris_openssl_locks[type]);
 +    } else {
-+        pthread_mutex_unlock(&solaris_openssl_locks[type]);
++        (void) pthread_mutex_unlock(&solaris_openssl_locks[type]);
 +    }
 +}
 +
 +/*
 + * Implement Solaris's own dynamic locking routines.
 +    ret = pthread_mutex_destroy((pthread_mutex_t *)dynlock);
 +    OPENSSL_assert(ret == 0);
 +}
 +
 +
++static void solaris_fork_prep(void)
++{
++    int i;
++
++    for (i = 0; i < CRYPTO_NUM_LOCKS; i++) {
++        (void) pthread_mutex_lock(&solaris_openssl_locks[i]);
++    }
++}
++
++static void solaris_fork_post(void)
++{
++    int i;
++
++    for (i = CRYPTO_NUM_LOCKS - 1; i >= 0; i--) {
++        (void) pthread_mutex_unlock(&solaris_openssl_locks[i]);
++    }
++
++    OPENSSL_assert(dynlock_create_callback == solaris_dynlock_create);
++    OPENSSL_assert(dynlock_lock_callback == solaris_dynlock_lock);
++    OPENSSL_assert(dynlock_destroy_callback == solaris_dynlock_destroy);
++    OPENSSL_assert(locking_callback == solaris_locking_callback);
++}
++
 +/*
-+ * This function is called when a child process is forked to setup its own
++ * This is called by the _init() function to setup locks used by OpenSSL
-+ * global locking callback function ptr and mutexes.
++ * and locking callback functions.
 + */
-+static void solaris_fork_child(void)
++void
-+{
++solaris_locking_setup()
-+    /*
-+     * clear locking_callback to indicate that locks should
-+     * be reinitialized.
-+     */
-+    locking_callback = NULL;
-+    solaris_locking_setup();
-+}
-+
-+/*
-+ * This function allocates and initializes the global mutex array, and
-+ * sets the locking callback.
-+ */
-+void solaris_locking_setup()
 +{
 +    int i;
-+    int num_locks;
 +
 +    /* setup the dynlock callback if not already */
 +    if (dynlock_create_callback == NULL) {
 +        dynlock_create_callback = solaris_dynlock_create;
 +    }
 +        dynlock_lock_callback = solaris_dynlock_lock;
 +    }
 +    if (dynlock_destroy_callback == NULL) {
 +        dynlock_destroy_callback = solaris_dynlock_destroy;
 +    }
-+
++    if (locking_callback == NULL) {
-+    /* locking callback is already setup. Nothing to do */
++	    locking_callback = solaris_locking_callback;
-+    if (locking_callback != NULL) {
++    }
-+        return;
++
-+    }
++    /* allocate and initialize locks needed by OpenSSL  */
-+
-+    /*
-+     * Set atfork handler so that child can setup its own mutexes and
-+     * locking callbacks when it is forked
-+     */
-+    (void) pthread_atfork(NULL, NULL, solaris_fork_child);
-+
-+    /* allocate locks needed by OpenSSL  */
-+    num_locks = CRYPTO_num_locks();
 +    solaris_openssl_locks =
-+        OPENSSL_malloc(sizeof (pthread_mutex_t) * num_locks);
++        OPENSSL_malloc(sizeof (pthread_mutex_t) * CRYPTO_NUM_LOCKS);
 +    if (solaris_openssl_locks == NULL) {
 +        fprintf(stderr,
 +            "solaris_locking_setup: memory allocation failure.\n");
 +        abort();
 +    }
-+
++    for (i = 0; i < CRYPTO_NUM_LOCKS; i++) {
-+    /* initialize openssl mutexes */
++        (void) pthread_mutex_init(&solaris_openssl_locks[i], NULL);
-+    for (i = 0; i < num_locks; i++) {
++    }
-+        pthread_mutex_init(&solaris_openssl_locks[i], NULL);
++
-+    }
++    (void) pthread_atfork(solaris_fork_prep, solaris_fork_post, solaris_fork_post);
-+    locking_callback = solaris_locking_callback;
++}
 +
-+}
 +
 void CRYPTO_set_locking_callback(void (*func) (int mode, int type,
 const char *file, int line))
 {
-@@ -410,7 +486,11 @@
+@@ -410,7 +541,11 @@
 * started.
 */
 OPENSSL_init();
 -    locking_callback = func;
 +
 +     * setting of another locking callback.
 +     */
 }
 void CRYPTO_set_add_lock_callback(int (*func) (int *num, int mount, int type,
-@@ -471,9 +551,10 @@
+@@ -471,9 +606,10 @@
 int CRYPTO_THREADID_set_callback(void (*func) (CRYPTO_THREADID *))
 {
 -    if (threadid_callback)
 -        return 0;
 +     * thread and disallow setting the threadid callback.
 +     */
 return 1;
 }
-@@ -529,7 +669,10 @@
+@@ -529,7 +665,10 @@
 void CRYPTO_set_id_callback(unsigned long (*func) (void))
 {
 -    id_callback = func;
 +    /*

changeset 6860	fbbec9b86c26
parent 6619	57ad7bed64ee