Upgrade from trousers 0.3.3 to 0.3.6 and from testsuite 0.2 to 0.3.

src/tcsd/tcsd_threads.c

 
 /*
  * Licensed Materials - Property of IBM
  *
  * trousers - An open source TCG Software Stack
  *
  * (C) Copyright International Business Machines Corp. 2004-2006
  *
  */
 
@@ skipping 27 matching lines @@
 
         MUTEX_LOCK(tm->lock);
 
         tm->shutdown = 1;
 
         MUTEX_UNLOCK(tm->lock);
 
         /* wait for all currently running threads to exit */
         for (i = 0; i < tm->max_threads; i++) {
                 if (tm->thread_data[i].thread_id != THREAD_NULL) {
-                        if ((rc = THREAD_JOIN(tm->thread_data[i].thread_id, NULL))) {
+                        if ((rc = THREAD_JOIN(*(tm->thread_data[i].thread_id), NULL))) {
                                 LogError("Thread join failed: error: %d", rc);
                         }
                 }
         }
 
         free(tm->thread_data);
         free(tm);
 
         return TSS_SUCCESS;
 }
 
 TSS_RESULT
 tcsd_threads_init(void)
 {
         /* allocate the thread mgmt structure */
         tm = calloc(1, sizeof(struct tcsd_thread_mgr));
         if (tm == NULL) {
                 LogError("malloc of %zd bytes failed.", sizeof(struct tcsd_thread_mgr));
                 return TCSERR(TSS_E_OUTOFMEMORY);
         }
+        /* initialize mutex */
+        MUTEX_INIT(tm->lock);
 
         /* set the max threads variable from config */
         tm->max_threads = tcsd_options.num_threads;
 
         /* allocate each thread's data structure */
         tm->thread_data = calloc(tcsd_options.num_threads, sizeof(struct tcsd_thread_data));
         if (tm->thread_data == NULL) {
                 LogError("malloc of %zu bytes failed.",
                          tcsd_options.num_threads * sizeof(struct tcsd_thread_data));
                 free(tm);
                 return TCSERR(TSS_E_OUTOFMEMORY);
         }
 
         return TSS_SUCCESS;
 }
 
 
 TSS_RESULT
 tcsd_thread_create(int socket, char *hostname)
 {
-        UINT32 thread_num;
+        UINT32 thread_num = -1;
+        int rc = TCS_SUCCESS;
 #ifndef TCSD_SINGLE_THREAD_DEBUG
-        int rc;
         THREAD_ATTR_DECLARE(tcsd_thread_attr);
 
         /* init the thread attribute */
         if ((rc = THREAD_ATTR_INIT(tcsd_thread_attr))) {
                 LogError("Initializing thread attribute failed: error=%d: %s", rc, strerror(rc));
-                return TCSERR(TSS_E_INTERNAL_ERROR);
+                rc = TCSERR(TSS_E_INTERNAL_ERROR);
+                goto out;
         }
         /* make all threads joinable */
         if ((rc = THREAD_ATTR_SETJOINABLE(tcsd_thread_attr))) {
                 LogError("Making thread attribute joinable failed: error=%d: %s", rc, strerror(rc));
-                return TCSERR(TSS_E_INTERNAL_ERROR);
+                rc = TCSERR(TSS_E_INTERNAL_ERROR);
+                goto out;
         }
 
         MUTEX_LOCK(tm->lock);
 #endif
         if (tm->num_active_threads == tm->max_threads) {
-                close(socket);
                 if (hostname != NULL) {
                         LogError("max number of connections reached (%d), new connection"
                                  " from %s refused.", tm->max_threads, hostname);
                 } else {
                         LogError("max number of connections reached (%d), new connection"
                                  " refused.", tm->max_threads);
                 }
-                free(hostname);
-                MUTEX_UNLOCK(tm->lock);
-                return TCSERR(TSS_E_CONNECTION_FAILED);
+                rc = TCSERR(TSS_E_CONNECTION_FAILED);
+#ifndef TCSD_SINGLE_THREAD_DEBUG
+                goto out_unlock;
+#else
+                goto out;
+#endif
         }
 
         /* search for an open slot to store the thread data in */
         for (thread_num = 0; thread_num < tm->max_threads; thread_num++) {
                 if (tm->thread_data[thread_num].thread_id == THREAD_NULL)
                         break;
         }
 
         DBG_ASSERT(thread_num != tm->max_threads);
 
         tm->thread_data[thread_num].sock = socket;
         tm->thread_data[thread_num].context = NULL_TCS_HANDLE;
         if (hostname != NULL)
                 tm->thread_data[thread_num].hostname = hostname;
 
 #ifdef TCSD_SINGLE_THREAD_DEBUG
         (void)tcsd_thread_run((void *)(&(tm->thread_data[thread_num])));
 #else
-        if ((rc = THREAD_CREATE(&(tm->thread_data[thread_num].thread_id),
+        tm->thread_data[thread_num].thread_id = calloc(1, sizeof(THREAD_TYPE));
+        if (tm->thread_data[thread_num].thread_id == NULL) {
+                rc = TCSERR(TSS_E_OUTOFMEMORY);
+                LogError("malloc of %zd bytes failed.", sizeof(THREAD_TYPE));
+                goto out_unlock;
+        }
+
+        if ((rc = THREAD_CREATE(tm->thread_data[thread_num].thread_id,
                                  &tcsd_thread_attr,
                                  tcsd_thread_run,
                                  (void *)(&(tm->thread_data[thread_num]))))) {
                 LogError("Thread create failed: %d", rc);
-                MUTEX_UNLOCK(tm->lock);
-                return TCSERR(TSS_E_INTERNAL_ERROR);
+                rc = TCSERR(TSS_E_INTERNAL_ERROR);
+                goto out_unlock;
         }
 
         tm->num_active_threads++;
 
+out_unlock:
         MUTEX_UNLOCK(tm->lock);
 #endif
-        return TSS_SUCCESS;
+out:
+        /* cleanup in case of error */
+        if (rc != TCS_SUCCESS) {
+                if (hostname != NULL) {
+                        tm->thread_data[thread_num].hostname = NULL;
+                        free(hostname);
+                }
+                close(socket);
+        }
+        return rc;
 }
 
 /* Since we don't want any of the worker threads to catch any signals, we must mask off any
  * potential signals here after creating the threads.  If any of the created threads catch a signal,
  * they'd eventually call join on themselves, causing a deadlock.
  */
 void
 thread_signal_init()
 {
         sigset_t thread_sigmask;
         int rc;
 
         if ((rc = sigfillset(&thread_sigmask))) {
                 LogError("sigfillset failed: error=%d: %s", rc, strerror(rc));
-                LogError("worker thread %zd is exiting prematurely", THREAD_ID);
+                LogError("worker thread %ld is exiting prematurely", THREAD_ID);
                 THREAD_EXIT(NULL);
         }
 
         if ((rc = THREAD_SET_SIGNAL_MASK(SIG_BLOCK, &thread_sigmask, NULL))) {
                 LogError("Setting thread sigmask failed: error=%d: %s", rc, strerror(rc));
-                LogError("worker thread %zd is exiting prematurely", THREAD_ID);
+                LogError("worker thread %ld is exiting prematurely", THREAD_ID);
                 THREAD_EXIT(NULL);
         }
 }
 #if 0
 void *
 tcsd_thread_run(void *v)
 {
         struct tcsd_thread_data *data = (struct tcsd_thread_data *)v;
         BYTE buffer[TCSD_TXBUF_SIZE];
         struct tcsd_packet_hdr *ret_buf = NULL;
@@ skipping 101 matching lines @@
                 TCS_CloseContext_Internal(data->context);
                 data->context = NULL_TCS_HANDLE;
         }
 
 #ifndef TCSD_SINGLE_THREAD_DEBUG
         MUTEX_LOCK(tm->lock);
         tm->num_active_threads--;
         /* if we're not in shutdown mode, then nobody is waiting to join this thread, so
          * detach it so that its resources are free at THREAD_EXIT() time. */
         if (!tm->shutdown) {
-                if ((rc = THREAD_DETACH(data->thread_id))) {
+                if ((rc = THREAD_DETACH(*(data->thread_id)))) {
                         LogError("Thread detach failed (errno %d)."
                                  " Resources may not be properly released.", rc);
                 }
         }
         free(data->hostname);
         data->hostname = NULL;
         data->thread_id = THREAD_NULL;
         MUTEX_UNLOCK(tm->lock);
         THREAD_EXIT(NULL);
 #else
@@ skipping 78 matching lines @@
                         LoadBlob_UINT32(&offset, result, data->comm.buf);
                 }
                 send_size = Decode_UINT32(data->comm.buf);
                 LogDebug("Sending 0x%X bytes back", send_size);
                 send_size = send_to_socket(data->sock, data->comm.buf, send_size);
                 if (send_size < 0)
                         break;
 
                 /* check for shutdown */
                 if (tm->shutdown) {
-                        LogDebug("Thread %zd exiting via shutdown signal!", THREAD_ID);
+                        LogDebug("Thread %ld exiting via shutdown signal!", THREAD_ID);
                         break;
                 }
         }
 
         LogDebug("Thread exiting.");
 
         /* Closing connection to TSP */
         close(data->sock);
         data->sock = -1;
         free(data->comm.buf);
         data->comm.buf = NULL;
         data->comm.buf_size = -1;
         /* If the connection was not shut down cleanly, free TCS resources here */
         if (data->context != NULL_TCS_HANDLE) {
                 TCS_CloseContext_Internal(data->context);
                 data->context = NULL_TCS_HANDLE;
         }
+        if(data->hostname != NULL) {
+                free(data->hostname);
+                data->hostname = NULL;
+        }
 
 #ifndef TCSD_SINGLE_THREAD_DEBUG
         pthread_mutex_lock(&(tm->lock));
         tm->num_active_threads--;
         /* if we're not in shutdown mode, then nobody is waiting to join this thread, so
          * detach it so that its resources are free at pthread_exit() time. */
         if (!tm->shutdown) {
-                if ((rc = pthread_detach(data->thread_id))) {
+                if ((rc = pthread_detach(*(data->thread_id)))) {
                         LogError("pthread_detach failed (errno %d)."
                                  " Resources may not be properly released.", rc);
                 }
         }
-        free(data->hostname);
-        data->hostname = NULL;
-        data->thread_id = (pthread_t)0;
+        free(data->thread_id);
+        data->thread_id = THREAD_NULL;
         pthread_mutex_unlock(&(tm->lock));
         pthread_exit(NULL);
 #else
         return NULL;
 #endif
 }
 
 #endif