From 09ec037e34601d155f8651f7fe4dc1931aa6da56 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Tue, 25 Mar 2025 16:50:11 +1000 Subject: [PATCH] Make the mutex symbols always available so we do not need to wrap them inside an ifdef. Signed-off-by: Ronnie Sahlberg --- include/iscsi-multithreading.h | 106 +++++++++++++++++++++++++++++++-- lib/init.c | 4 -- lib/multithreading.c | 79 ------------------------ lib/pdu.c | 4 -- 4 files changed, 100 insertions(+), 93 deletions(-) diff --git a/include/iscsi-multithreading.h b/include/iscsi-multithreading.h index 39134b0..197b08c 100644 --- a/include/iscsi-multithreading.h +++ b/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 typedef pthread_t libiscsi_thread_t; -typedef pthread_mutex_t libiscsi_mutex_t; #if defined(__APPLE__) && defined(HAVE_DISPATCH_DISPATCH_H) #include @@ -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 diff --git a/lib/init.c b/lib/init.c index 233a5c2..817a045 100644 --- a/lib/init.c +++ b/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); diff --git a/lib/multithreading.c b/lib/multithreading.c index 5b57804..fd3a5a5 100644 --- a/lib/multithreading.c +++ b/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) { diff --git a/lib/pdu.c b/lib/pdu.c index 73687d7..68e8a20 100644 --- a/lib/pdu.c +++ b/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; }