Change some type definitions in pthread. (#738)

lzha101 · web-flow · commit ca3795bdfbac · 2021-08-23T16:25:06.000+08:00
Make sure the pthread structures be initialized by PTHREAD_*_INITIALIZER.
Also fix one potential race condition issue.

Signed-off-by: Zhang Lili &lt;lili.z.zhang@intel.com&gt;
diff --git a/common/inc/tlibc/pthread.h b/common/inc/tlibc/pthread.h
@@ -25,6 +25,7 @@
 #define _PTHREAD_H_
 
 #include <sgx_defs.h>
+#include <sgx_thread.h>
 
 /*
  * Flags for once initialization.
@@ -40,9 +41,9 @@
 /*
  * Static initialization values. 
  */
-#define PTHREAD_MUTEX_INITIALIZER	NULL
-#define PTHREAD_COND_INITIALIZER	NULL
-#define PTHREAD_RWLOCK_INITIALIZER	NULL
+#define PTHREAD_MUTEX_INITIALIZER   SGX_THREAD_MUTEX_INITIALIZER
+#define PTHREAD_COND_INITIALIZER    SGX_THREAD_COND_INITIALIZER
+#define PTHREAD_RWLOCK_INITIALIZER  SGX_THREAD_LOCK_INITIALIZER
 
 /*
  * Primitive system data type definitions required by P1003.1c.
@@ -51,18 +52,15 @@
  * or assignment operators for the types pthread_attr_t, pthread_cond_t,
  * pthread_condattr_t, pthread_mutex_t, pthread_mutexattr_t.
  */
-typedef struct	_pthread			*pthread_t;
-typedef struct	_pthread_attr		*pthread_attr_t;
-typedef struct _sgx_thread_mutex_t	*pthread_mutex_t;
-typedef struct	_sgx_thread_mutex_attr_t	*pthread_mutexattr_t;
-typedef struct	_sgx_thread_cond_t		*pthread_cond_t;
-typedef struct	_sgx_thread_cond_attr_t	*pthread_condattr_t;
-typedef int				pthread_key_t;
-typedef struct	_sgx_thread_rwlock_t		*pthread_rwlock_t;
-typedef struct	_sgx_thread_rwlockattr_t	*pthread_rwlockattr_t;
-//typedef struct	pthread_barrier		*pthread_barrier_t;
-//typedef struct	pthread_barrierattr	*pthread_barrierattr_t;
-//typedef struct	pthread_spinlock	*pthread_spinlock_t;
+typedef struct  _pthread                    *pthread_t;
+typedef struct  _pthread_attr               *pthread_attr_t;
+typedef struct  _sgx_thread_mutex_t         pthread_mutex_t;
+typedef struct  _sgx_thread_mutex_attr_t    pthread_mutexattr_t;
+typedef struct  _sgx_thread_cond_t          pthread_cond_t;
+typedef struct  _sgx_thread_cond_attr_t     pthread_condattr_t;
+typedef         int                         pthread_key_t;
+typedef struct  _sgx_thread_rwlock_t        pthread_rwlock_t;
+typedef struct  _sgx_thread_rwlockattr_t    pthread_rwlockattr_t;
 
 /*
  * Once definitions.
diff --git a/sdk/pthread/pthread_cond.cpp b/sdk/pthread/pthread_cond.cpp
@@ -29,56 +29,26 @@
 int pthread_cond_init(pthread_cond_t *condp, const pthread_condattr_t *attr)
 {
     UNUSED(attr);
-    pthread_cond_t cond;
-    cond = (pthread_cond_t)calloc(1, sizeof(*cond));
-    if (cond == NULL)
-        return (ENOMEM);
-    *condp = cond;
-    return sgx_thread_cond_init(cond, NULL);
+    return sgx_thread_cond_init(condp, NULL);
 }
 
 int pthread_cond_destroy(pthread_cond_t *condp)
 {
-    int error;
-    pthread_cond_t cond;
-    cond = *condp;
-    if (cond != NULL) {
-        error = sgx_thread_cond_destroy(cond);
-        if(0 != error)
-            return error;
-        free(cond);
-    }
-    *condp = NULL;
-    return 0;
+    return sgx_thread_cond_destroy(condp);
 }
 
 int pthread_cond_wait(pthread_cond_t *condp, pthread_mutex_t *mutexp)
 {
-    pthread_cond_t cond;
-    int error;
-    if (*condp == NULL) {
-        if ((error = pthread_cond_init(condp, NULL)))
-            return (error);
-    }
-    cond = *condp;
-    return sgx_thread_cond_wait(cond, *mutexp);
+    return sgx_thread_cond_wait(condp, mutexp);
 }
 
 int pthread_cond_signal(pthread_cond_t *condp)
 {
-    pthread_cond_t cond;
-    if (*condp == NULL)
-        return (0);
-    cond = *condp;
-    return sgx_thread_cond_signal(cond);
+    return sgx_thread_cond_signal(condp);
 }
 
 int pthread_cond_broadcast(pthread_cond_t *condp)
 {
-    pthread_cond_t cond;
-    if (*condp == NULL)
-        return (0);
-    cond = *condp;
-    return sgx_thread_cond_broadcast(cond);
+    return sgx_thread_cond_broadcast(condp);
 }
 
diff --git a/sdk/pthread/pthread_mutex.cpp b/sdk/pthread/pthread_mutex.cpp
@@ -28,89 +28,27 @@ static volatile uint32_t static_init_lock = SGX_SPINLOCK_INITIALIZER;
 
 int pthread_mutex_init(pthread_mutex_t *mutexp, const pthread_mutexattr_t *attr)
 {
-    pthread_mutex_t mutex;
     UNUSED(attr);
-    mutex = (pthread_mutex_t)calloc(1, sizeof(*mutex));
-    if (mutex == NULL)
-        return (ENOMEM);
-    sgx_thread_mutex_init(mutex, NULL);
-    *mutexp = mutex;
-    return 0;
+    return sgx_thread_mutex_init(mutexp, NULL);
 }
 
 int pthread_mutex_destroy(pthread_mutex_t *mutexp)
 {
-    if (mutexp == NULL)
-        return (EINVAL);
-
-    sgx_thread_mutex_t *mutex = *mutexp;
-    if(mutex) {
-        int ret = sgx_thread_mutex_destroy(mutex);
-        if(ret != 0)
-            return ret;
-
-        free((void *)(mutex));
-        *mutexp = NULL;
-    }
-    return 0;
+    return sgx_thread_mutex_destroy(mutexp);
 }
 
 int pthread_mutex_lock(pthread_mutex_t *mutexp)
 {
-    if (mutexp == NULL)
-        return (EINVAL);
-    int error=0;
-
-    /*
-      * If the mutex is statically initialized, perform the dynamic
-      * initialization. Note: _thread_mutex_lock() in libc requires
-      * pthread_mutex_lock() to perform the mutex init when *mutexp
-      * is NULL.
-    */
-    if (*mutexp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*mutexp == NULL)
-            error = pthread_mutex_init(mutexp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_mutex_lock(*mutexp);
+    return sgx_thread_mutex_lock(mutexp);
 }
 
 int pthread_mutex_trylock(pthread_mutex_t *mutexp)
 {
-    if (mutexp == NULL)
-        return (EINVAL);
-    int error=0;
-
-    /*
-      * If the mutex is statically initialized, perform the dynamic
-      * initialization. Note: _thread_mutex_lock() in libc requires
-      * pthread_mutex_lock() to perform the mutex init when *mutexp
-      * is NULL.
-    */
-    if (*mutexp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*mutexp == NULL)
-            error = pthread_mutex_init(mutexp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_mutex_trylock(*mutexp);
+    return sgx_thread_mutex_trylock(mutexp);
 }
 
 int pthread_mutex_unlock(pthread_mutex_t *mutexp)
 {
-    if (mutexp == NULL)
-        return (EINVAL);
-
-    if (*mutexp == NULL)
-        abort();
-
-    return sgx_thread_mutex_unlock(*mutexp);
+    return sgx_thread_mutex_unlock(mutexp);
 }
 
diff --git a/sdk/pthread/pthread_rwlock.cpp b/sdk/pthread/pthread_rwlock.cpp
@@ -28,131 +28,39 @@ static volatile uint32_t static_init_lock = SGX_SPINLOCK_INITIALIZER;
 
 int pthread_rwlock_init(pthread_rwlock_t *rwlockp, const pthread_rwlockattr_t *attr)
 {
-    pthread_rwlock_t rwlock;
     UNUSED(attr);
-    rwlock = (pthread_rwlock_t)calloc(1, sizeof(*rwlock));
-    if (rwlock == NULL)
-        return (ENOMEM);
-    sgx_thread_rwlock_init(rwlock, NULL);
-    *rwlockp = rwlock;
-    return 0;
+    return sgx_thread_rwlock_init(rwlockp, NULL);
 }
 
 int pthread_rwlock_destroy(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-
-    sgx_thread_rwlock_t *rwlock = *rwlockp;
-    if(rwlock) {
-        int ret = sgx_thread_rwlock_destroy(rwlock);
-        if(ret != 0)
-            return ret;
-
-        free((void *)(rwlock));
-        *rwlockp = NULL;
-    }
-    return 0;
+    return sgx_thread_rwlock_destroy(rwlockp);
 }
 
 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-    int error = 0;
-
-    /*
-      * If the rwlock is statically initialized, perform the dynamic
-      * initialization.
-    */
-    if (*rwlockp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*rwlockp == NULL)
-            error = pthread_rwlock_init(rwlockp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_rwlock_rdlock(*rwlockp);
+    return sgx_thread_rwlock_rdlock(rwlockp);
 }
 
 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-    int error=0;
-
-    /*
-      * If the rwlock is statically initialized, perform the dynamic
-      * initialization. 
-    */
-    if (*rwlockp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*rwlockp == NULL)
-            error = pthread_rwlock_init(rwlockp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_rwlock_tryrdlock(*rwlockp);
+    return sgx_thread_rwlock_tryrdlock(rwlockp);
 }
 
 
 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-    int error = 0;
-
-    /*
-      * If the rwlock is statically initialized, perform the dynamic
-      * initialization.
-    */
-    if (*rwlockp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*rwlockp == NULL)
-            error = pthread_rwlock_init(rwlockp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_rwlock_wrlock(*rwlockp);
+    return sgx_thread_rwlock_wrlock(rwlockp);
 }
 
 
 int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-    int error = 0;
-
-    /*
-      * If the rwlock is statically initialized, perform the dynamic
-      * initialization.
-    */
-    if (*rwlockp == NULL) {
-        sgx_spin_lock(&static_init_lock);
-        if (*rwlockp == NULL)
-            error = pthread_rwlock_init(rwlockp, NULL);
-        sgx_spin_unlock(&static_init_lock);
-        if (error != 0)
-            return (EINVAL);
-    }
-
-    return sgx_thread_rwlock_trywrlock(*rwlockp);
+    return sgx_thread_rwlock_trywrlock(rwlockp);
 }
 
 int pthread_rwlock_unlock(pthread_rwlock_t *rwlockp)
 {
-    if (rwlockp == NULL)
-        return (EINVAL);
-
-    if (*rwlockp == NULL)
-        abort();
-
-    return sgx_thread_rwlock_unlock(*rwlockp);
+    return sgx_thread_rwlock_unlock(rwlockp);
 }
 
