Make the mutex symbols always available

so we do not need to wrap them inside an ifdef.

Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>

include/iscsi-multithreading.h

@@ -31,13 +31,11 @@ extern "C" {
 
 #ifdef WIN32
 typedef HANDLE libiscsi_thread_t;
-typedef HANDLE libiscsi_mutex_t;
 typedef HANDLE libiscsi_sem_t;
 typedef DWORD iscsi_tid_t;
 #elif defined(HAVE_PTHREAD)
 #include <pthread.h>
 typedef pthread_t libiscsi_thread_t;
-typedef pthread_mutex_t libiscsi_mutex_t;
 
 #if defined(__APPLE__) && defined(HAVE_DISPATCH_DISPATCH_H)
 #include <dispatch/dispatch.h>
@@ -54,10 +52,8 @@ typedef pid_t iscsi_tid_t;
 #endif /* HAVE_PTHREAD */
 
 iscsi_tid_t iscsi_mt_get_tid(void);
-int iscsi_mt_mutex_init(libiscsi_mutex_t *mutex);
+
-int iscsi_mt_mutex_destroy(libiscsi_mutex_t *mutex);
+
-int iscsi_mt_mutex_lock(libiscsi_mutex_t *mutex);
-int iscsi_mt_mutex_unlock(libiscsi_mutex_t *mutex);
 
 int iscsi_mt_sem_init(libiscsi_sem_t *sem, int value);
 int iscsi_mt_sem_destroy(libiscsi_sem_t *sem);
@@ -66,6 +62,104 @@ int iscsi_mt_sem_wait(libiscsi_sem_t *sem);
 
 #endif /* HAVE_MULTITHREADING */
 
+/*
+ * We always have access to mutex functions even if multithreading
+ * is not enabled.
+ */
+#if defined(HAVE_PTHREAD)
+typedef pthread_mutex_t libiscsi_mutex_t;
+/*
+ * If this is enabled we check for the following locking violations, at the
+ * (slight) cost of performance:
+ * - Thread holding the lock again tries to lock.
+ * - Thread not holding the lock tries to unlock.
+ *
+ * This is very useful for catching any coding errors.
+ * The performance hit is not very significant so you can leave it enabled,
+ * but if you really care then once the code has been vetted, this can be
+ * undef'ed to get the perf back.
+ */
+#define DEBUG_PTHREAD_LOCKING_VIOLATIONS
+
+static inline int iscsi_mt_mutex_init(libiscsi_mutex_t *mutex)
+{
+	int ret;
+#ifdef DEBUG_PTHREAD_LOCKING_VIOLATIONS
+	pthread_mutexattr_t attr;
+
+	ret = pthread_mutexattr_init(&attr);
+	if (ret != 0) {
+		return ret;
+	}
+
+	ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+	if (ret != 0) {
+		return ret;
+	}
+
+	ret = pthread_mutex_init(mutex, &attr);
+	if (ret != 0) {
+		return ret;
+	}
+#else
+	ret = pthread_mutex_init(mutex, NULL);
+	assert(ret == 0);
+#endif
+	return ret;
+}
+
+static inline int iscsi_mt_mutex_destroy(libiscsi_mutex_t *mutex)
+{
+	return pthread_mutex_destroy(mutex);
+}
+
+static inline int iscsi_mt_mutex_lock(libiscsi_mutex_t *mutex)
+{
+	return pthread_mutex_lock(mutex);
+}
+
+static inline int iscsi_mt_mutex_unlock(libiscsi_mutex_t *mutex)
+{
+	return pthread_mutex_unlock(mutex);
+}
+
+#elif defined(WIN32)
+typedef HANDLE libiscsi_mutex_t;
+static inline int iscsi_mt_mutex_init(libiscsi_mutex_t* mutex)
+{
+    *mutex = CreateSemaphoreA(NULL, 1, 1, NULL);
+    return 0;
+}
+
+static inline int iscsi_mt_mutex_destroy(libiscsi_mutex_t* mutex)
+{
+    CloseHandle(*mutex);
+    return 0;
+}
+
+static inline int iscsi_mt_mutex_lock(libiscsi_mutex_t* mutex)
+{
+    while (WaitForSingleObject(*mutex, INFINITE) != WAIT_OBJECT_0);
+    return 0;
+}
+
+static inline int iscsi_mt_mutex_unlock(libiscsi_mutex_t* mutex)
+{
+    ReleaseSemaphore(*mutex, 1, NULL);
+    return 0;
+}
+
+#else
+
+typedef const int libiscsi_mutex_t;
+#define iscsi_mt_mutex_init(x) ;
+#define iscsi_mt_mutex_destroy(x) ;
+#define iscsi_mt_mutex_lock(x) ;
+#define iscsi_mt_mutex_unlock(x) ;
+
+#endif /* mutex */
+
+
 #ifdef __cplusplus
 }
 #endif

lib/init.c

@@ -216,10 +216,8 @@ iscsi_create_context(const char *initiator_name)
 
 	memset(iscsi, 0, sizeof(struct iscsi_context));
 
-#ifdef HAVE_MULTITHREADING
         iscsi_mt_mutex_init(&iscsi->iscsi_mutex);
         iscsi->poll_timeout = 100;
-#endif /* HAVE_MULTITHREADING */
 
 	/* initalize transport of context */
 	if (iscsi_init_transport(iscsi, TCP_TRANSPORT)) {
@@ -436,9 +434,7 @@ iscsi_destroy_context(struct iscsi_context *iscsi)
 		iscsi_destroy_context(iscsi->old_iscsi);
 	}
 
-#ifdef HAVE_MULTITHREADING
         iscsi_mt_mutex_destroy(&iscsi->iscsi_mutex);
-#endif /* HAVE_MULTITHREADING */
         
 	memset(iscsi, 0, sizeof(struct iscsi_context));
 	free(iscsi);

lib/multithreading.c

@@ -113,30 +113,6 @@ void iscsi_mt_service_thread_stop(struct iscsi_context* iscsi)
     while (WaitForSingleObject(iscsi->iscsii->service_thread, INFINITE) != WAIT_OBJECT_0);
 }
 
-int iscsi_mt_mutex_init(libiscsi_mutex_t* mutex)
-{
-    *mutex = CreateSemaphoreA(NULL, 1, 1, NULL);
-    return 0;
-}
-
-int iscsi_mt_mutex_destroy(libiscsi_mutex_t* mutex)
-{
-    CloseHandle(*mutex);
-    return 0;
-}
-
-int iscsi_mt_mutex_lock(libiscsi_mutex_t* mutex)
-{
-    while (WaitForSingleObject(*mutex, INFINITE) != WAIT_OBJECT_0);
-    return 0;
-}
-
-int iscsi_mt_mutex_unlock(libiscsi_mutex_t* mutex)
-{
-    ReleaseSemaphore(*mutex, 1, NULL);
-    return 0;
-}
-
 int iscsi_mt_sem_init(libiscsi_sem_t* sem, int value)
 {
     *sem = CreateSemaphoreA(NULL, 0, 16, NULL);
@@ -230,61 +206,6 @@ void iscsi_mt_service_thread_stop(struct iscsi_context *iscsi)
         pthread_join(iscsi->service_thread, NULL);
 }
         
-/*
- * If this is enabled we check for the following locking violations, at the
- * (slight) cost of performance:
- * - Thread holding the lock again tries to lock.
- * - Thread not holding the lock tries to unlock.
- *
- * This is very useful for catching any coding errors.
- * The performance hit is not very significant so you can leave it enabled,
- * but if you really care then once the code has been vetted, this can be
- * undef'ed to get the perf back.
- */
-#define DEBUG_PTHREAD_LOCKING_VIOLATIONS
-
-int iscsi_mt_mutex_init(libiscsi_mutex_t *mutex)
-{
-	int ret;
-#ifdef DEBUG_PTHREAD_LOCKING_VIOLATIONS
-	pthread_mutexattr_t attr;
-
-	ret = pthread_mutexattr_init(&attr);
-	if (ret != 0) {
-		return ret;
-	}
-
-	ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
-	if (ret != 0) {
-		return ret;
-	}
-
-	ret = pthread_mutex_init(mutex, &attr);
-	if (ret != 0) {
-		return ret;
-	}
-#else
-	ret = pthread_mutex_init(mutex, NULL);
-	assert(ret == 0);
-#endif
-	return ret;
-}
-
-int iscsi_mt_mutex_destroy(libiscsi_mutex_t *mutex)
-{
-	return pthread_mutex_destroy(mutex);
-}
-
-int iscsi_mt_mutex_lock(libiscsi_mutex_t *mutex)
-{
-	return pthread_mutex_lock(mutex);
-}
-
-int iscsi_mt_mutex_unlock(libiscsi_mutex_t *mutex)
-{
-	return pthread_mutex_unlock(mutex);
-}
-
 #if defined(__APPLE__) && defined(HAVE_DISPATCH_DISPATCH_H)
 int iscsi_mt_sem_init(libiscsi_sem_t *sem, int value)
 {

lib/pdu.c

@@ -942,13 +942,9 @@ iscsi_queue_pdu(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
 {
         int ret;
 
-#ifdef HAVE_MULTITHREADING
         iscsi_mt_mutex_lock(&iscsi->iscsi_mutex);
-#endif /* HAVE_MULTITHREADING */
 	ret = iscsi->drv->queue_pdu(iscsi, pdu);
-#ifdef HAVE_MULTITHREADING
         iscsi_mt_mutex_unlock(&iscsi->iscsi_mutex);
-#endif /* HAVE_MULTITHREADING */
 
         return ret;
 }