core: Remove POSIX threads influence from synchronization code

This commit changes the signatures of the synchronization functions
to reflect the needs of the library rather than the signature of the
pthreads API. The mutex and condition variable attributes parameters
have been removed as no part of the core library makes use of them.

In addition, the condition variable timed-wait function has been modified
to accept the relative time passed in via libusb_wait_for_event(). This
allows the implementation-specific code to handle conversion to absolute
time as necessary, rather than forcing this to occur.

Signed-off-by: Chris Dickens <christopher.a.dickens@gmail.com>

9 files changed, 79 insertions, 96 deletions

diff --git a/libusb/core.c b/libusb/core.c
index b1afafa..31f3d28 100644
--- a/libusb/core.c
+++ b/libusb/core.c
@@ -676,7 +676,7 @@ struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
 	if (!dev)
 		return NULL;
 
-	r = usbi_mutex_init(&dev->lock, NULL);
+	r = usbi_mutex_init(&dev->lock);
 	if (r) {
 		free(dev);
 		return NULL;
@@ -1242,7 +1242,7 @@ int API_EXPORTED libusb_open(libusb_device *dev,
 	if (!_dev_handle)
 		return LIBUSB_ERROR_NO_MEM;
 
-	r = usbi_mutex_init(&_dev_handle->lock, NULL);
+	r = usbi_mutex_init(&_dev_handle->lock);
 	if (r) {
 		free(_dev_handle);
 		return LIBUSB_ERROR_OTHER;
@@ -2036,9 +2036,9 @@ int API_EXPORTED libusb_init(libusb_context **context)
 	usbi_dbg("libusb v%u.%u.%u.%u%s", libusb_version_internal.major, libusb_version_internal.minor,
 		libusb_version_internal.micro, libusb_version_internal.nano, libusb_version_internal.rc);
 
-	usbi_mutex_init(&ctx->usb_devs_lock, NULL);
-	usbi_mutex_init(&ctx->open_devs_lock, NULL);
-	usbi_mutex_init(&ctx->hotplug_cbs_lock, NULL);
+	usbi_mutex_init(&ctx->usb_devs_lock);
+	usbi_mutex_init(&ctx->open_devs_lock);
+	usbi_mutex_init(&ctx->hotplug_cbs_lock);
 	list_init(&ctx->usb_devs);
 	list_init(&ctx->open_devs);
 	list_init(&ctx->hotplug_cbs);
diff --git a/libusb/io.c b/libusb/io.c
index 2cd6a6e..4d03b8b 100644
--- a/libusb/io.c
+++ b/libusb/io.c
@@ -1124,12 +1124,12 @@ int usbi_io_init(struct libusb_context *ctx)
 {
 	int r;
 
-	usbi_mutex_init(&ctx->flying_transfers_lock, NULL);
-	usbi_mutex_init_recursive(&ctx->events_lock, NULL);
-	usbi_mutex_init(&ctx->event_waiters_lock, NULL);
-	usbi_cond_init(&ctx->event_waiters_cond, NULL);
-	usbi_mutex_init(&ctx->event_data_lock, NULL);
-	usbi_tls_key_create(&ctx->event_handling_key, NULL);
+	usbi_mutex_init(&ctx->flying_transfers_lock);
+	usbi_mutex_init_recursive(&ctx->events_lock);
+	usbi_mutex_init(&ctx->event_waiters_lock);
+	usbi_cond_init(&ctx->event_waiters_cond);
+	usbi_mutex_init(&ctx->event_data_lock);
+	usbi_tls_key_create(&ctx->event_handling_key);
 	list_init(&ctx->flying_transfers);
 	list_init(&ctx->ipollfds);
 	list_init(&ctx->hotplug_msgs);
@@ -1268,8 +1268,8 @@ struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(
 		return NULL;
 
 	itransfer->num_iso_packets = iso_packets;
-	usbi_mutex_init(&itransfer->lock, NULL);
-	usbi_mutex_init(&itransfer->flags_lock, NULL);
+	usbi_mutex_init(&itransfer->lock);
+	usbi_mutex_init(&itransfer->flags_lock);
 	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 	usbi_dbg("transfer %p", transfer);
 	return transfer;
@@ -1944,7 +1944,6 @@ void API_EXPORTED libusb_unlock_event_waiters(libusb_context *ctx)
  */
 int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
 {
-	struct timespec timeout;
 	int r;
 
 	USBI_GET_CONTEXT(ctx);
@@ -1953,22 +1952,13 @@ int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
 		return 0;
 	}
 
-	r = usbi_backend->clock_gettime(USBI_CLOCK_REALTIME, &timeout);
-	if (r < 0) {
-		usbi_err(ctx, "failed to read realtime clock, error %d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	timeout.tv_sec += tv->tv_sec;
-	timeout.tv_nsec += tv->tv_usec * 1000;
-	while (timeout.tv_nsec >= 1000000000) {
-		timeout.tv_nsec -= 1000000000;
-		timeout.tv_sec++;
-	}
-
 	r = usbi_cond_timedwait(&ctx->event_waiters_cond,
-		&ctx->event_waiters_lock, &timeout);
-	return (r == ETIMEDOUT);
+		&ctx->event_waiters_lock, tv);
+
+	if (r < 0)
+		return r;
+	else
+		return (r == ETIMEDOUT);
 }
 
 static void handle_timeout(struct usbi_transfer *itransfer)
diff --git a/libusb/os/threads_posix.c b/libusb/os/threads_posix.c
index e8e87bb..89b05f3 100644
--- a/libusb/os/threads_posix.c
+++ b/libusb/os/threads_posix.c
@@ -21,6 +21,7 @@
 
 #include <config.h>
 
+#include <time.h>
 #if defined(__linux__) || defined(__OpenBSD__)
 # if defined(__OpenBSD__)
 #  define _BSD_SOURCE
@@ -35,31 +36,48 @@
 
 #include "threads_posix.h"
 
-int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
+int usbi_mutex_init_recursive(pthread_mutex_t *mutex)
 {
 	int err;
-	pthread_mutexattr_t stack_attr;
-	if (!attr) {
-		attr = &stack_attr;
-		err = pthread_mutexattr_init(&stack_attr);
-		if (err != 0)
-			return err;
-	}
+	pthread_mutexattr_t attr;
+
+	err = pthread_mutexattr_init(&attr);
+	if (err != 0)
+		return err;
 
 	/* mutexattr_settype requires _GNU_SOURCE or _XOPEN_SOURCE >= 500 on Linux */
-	err = pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
+	err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 	if (err != 0)
 		goto finish;
 
-	err = pthread_mutex_init(mutex, attr);
+	err = pthread_mutex_init(mutex, &attr);
 
 finish:
-	if (attr == &stack_attr)
-		pthread_mutexattr_destroy(&stack_attr);
+	pthread_mutexattr_destroy(&attr);
 
 	return err;
 }
 
+int usbi_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t *mutex, const struct timeval *tv)
+{
+	struct timespec timeout;
+	int r;
+
+	r = clock_gettime(CLOCK_REALTIME, &timeout);
+	if (r < 0)
+		return r;
+
+	timeout.tv_sec += tv->tv_sec;
+	timeout.tv_nsec += tv->tv_usec * 1000;
+	while (timeout.tv_nsec >= 1000000000L) {
+		timeout.tv_nsec -= 1000000000L;
+		timeout.tv_sec++;
+	}
+
+	return pthread_cond_timedwait(cond, mutex, &timeout);
+}
+
 int usbi_get_tid(void)
 {
 	int ret = -1;
diff --git a/libusb/os/threads_posix.h b/libusb/os/threads_posix.h
index ce78cc3..2abb820 100644
--- a/libusb/os/threads_posix.h
+++ b/libusb/os/threads_posix.h
@@ -22,6 +22,9 @@
 #define LIBUSB_THREADS_POSIX_H
 
 #include <pthread.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
 
 #define usbi_mutex_static_t		pthread_mutex_t
 #define USBI_MUTEX_INITIALIZER		PTHREAD_MUTEX_INITIALIZER
@@ -29,26 +32,28 @@
 #define usbi_mutex_static_unlock	pthread_mutex_unlock
 
 #define usbi_mutex_t			pthread_mutex_t
-#define usbi_mutex_init			pthread_mutex_init
+#define usbi_mutex_init(mutex)		pthread_mutex_init((mutex), NULL)
 #define usbi_mutex_lock			pthread_mutex_lock
 #define usbi_mutex_unlock		pthread_mutex_unlock
 #define usbi_mutex_trylock		pthread_mutex_trylock
 #define usbi_mutex_destroy		pthread_mutex_destroy
 
 #define usbi_cond_t			pthread_cond_t
-#define usbi_cond_init			pthread_cond_init
+#define usbi_cond_init(cond)		pthread_cond_init((cond), NULL)
 #define usbi_cond_wait			pthread_cond_wait
-#define usbi_cond_timedwait		pthread_cond_timedwait
 #define usbi_cond_broadcast		pthread_cond_broadcast
 #define usbi_cond_destroy		pthread_cond_destroy
 
 #define usbi_tls_key_t			pthread_key_t
-#define usbi_tls_key_create		pthread_key_create
+#define usbi_tls_key_create(key)	pthread_key_create((key), NULL)
 #define usbi_tls_key_get		pthread_getspecific
 #define usbi_tls_key_set		pthread_setspecific
 #define usbi_tls_key_delete		pthread_key_delete
 
-extern int usbi_mutex_init_recursive(pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
+int usbi_mutex_init_recursive(pthread_mutex_t *mutex);
+
+int usbi_cond_timedwait(pthread_cond_t *cond,
+	pthread_mutex_t *mutex, const struct timeval *tv);
 
 int usbi_get_tid(void);
 
diff --git a/libusb/os/threads_windows.c b/libusb/os/threads_windows.c
index 8a9c02c..7c2e52d 100644
--- a/libusb/os/threads_windows.c
+++ b/libusb/os/threads_windows.c
@@ -25,8 +25,6 @@
 
 #include "libusbi.h"
 
-extern const uint64_t epoch_time;
-
 struct usbi_cond_perthread {
 	struct list_head list;
 	DWORD tid;
@@ -41,6 +39,7 @@ int usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
 		SleepEx(0, TRUE);
 	return 0;
 }
+
 int usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
 {
 	if (!mutex)
@@ -49,9 +48,8 @@ int usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
 	return 0;
 }
 
-int usbi_mutex_init(usbi_mutex_t *mutex, const usbi_mutexattr_t *attr)
+int usbi_mutex_init(usbi_mutex_t *mutex)
 {
-	UNUSED(attr);
 	if (!mutex)
 		return EINVAL;
 	*mutex = CreateMutex(NULL, FALSE, NULL);
@@ -110,9 +108,8 @@ int usbi_mutex_destroy(usbi_mutex_t *mutex)
 	return 0;
 }
 
-int usbi_cond_init(usbi_cond_t *cond, const usbi_condattr_t *attr)
+int usbi_cond_init(usbi_cond_t *cond)
 {
-	UNUSED(attr);
 	if (!cond)
 		return EINVAL;
 	list_init(&cond->waiters);
@@ -213,44 +210,19 @@ int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
 }
 
 int usbi_cond_timedwait(usbi_cond_t *cond,
-	usbi_mutex_t *mutex, const struct timespec *abstime)
+	usbi_mutex_t *mutex, const struct timeval *tv)
 {
-	FILETIME filetime;
-	ULARGE_INTEGER rtime;
-	struct timeval targ_time, cur_time, delta_time;
-	struct timespec cur_time_ns;
 	DWORD millis;
 
-	// GetSystemTimeAsFileTime() is not available on CE
-	SYSTEMTIME st;
-	GetSystemTime(&st);
-	if (!SystemTimeToFileTime(&st, &filetime))
-		return 0;
-	rtime.LowPart   = filetime.dwLowDateTime;
-	rtime.HighPart  = filetime.dwHighDateTime;
-	rtime.QuadPart -= epoch_time;
-	cur_time_ns.tv_sec = (long)(rtime.QuadPart / 10000000);
-	cur_time_ns.tv_nsec = (long)((rtime.QuadPart % 10000000) * 100);
-	TIMESPEC_TO_TIMEVAL(&cur_time, &cur_time_ns);
-
-	TIMESPEC_TO_TIMEVAL(&targ_time, abstime);
-	timersub(&targ_time, &cur_time, &delta_time);
-	if (delta_time.tv_sec < 0) {
-		// abstime already passed?
-		millis = 0;
-	} else {
-		millis  = delta_time.tv_usec / 1000;
-		millis += delta_time.tv_sec * 1000;
-		if (delta_time.tv_usec % 1000)
-			millis++; // round up to next millisecond
-	}
-
+	millis = (DWORD)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
+	/* round up to next millisecond */
+	if (tv->tv_usec % 1000)
+		millis++;
 	return usbi_cond_intwait(cond, mutex, millis);
 }
 
-int usbi_tls_key_create(usbi_tls_key_t *key, void (*destructor)(void *))
+int usbi_tls_key_create(usbi_tls_key_t *key)
 {
-	UNUSED(destructor);
 	if (!key)
 		return EINVAL;
 	*key = TlsAlloc();
@@ -265,9 +237,9 @@ void *usbi_tls_key_get(usbi_tls_key_t key)
 	return TlsGetValue(key);
 }
 
-int usbi_tls_key_set(usbi_tls_key_t key, const void *value)
+int usbi_tls_key_set(usbi_tls_key_t key, void *value)
 {
-	if (TlsSetValue(key, (LPVOID)value))
+	if (TlsSetValue(key, value))
 		return 0;
 	else
 		return EINVAL;
diff --git a/libusb/os/threads_windows.h b/libusb/os/threads_windows.h
index b9e7922..8b7faec 100644
--- a/libusb/os/threads_windows.h
+++ b/libusb/os/threads_windows.h
@@ -48,33 +48,31 @@ struct timespec {
 #  define ETIMEDOUT 10060     /* This is the value in winsock.h. */
 #endif
 
-#define usbi_mutexattr_t	void
-#define usbi_condattr_t		void
 #define usbi_tls_key_t		DWORD
 
 int usbi_mutex_static_lock(usbi_mutex_static_t *mutex);
 int usbi_mutex_static_unlock(usbi_mutex_static_t *mutex);
 
-int usbi_mutex_init(usbi_mutex_t *mutex, const usbi_mutexattr_t *attr);
+int usbi_mutex_init(usbi_mutex_t *mutex);
 int usbi_mutex_lock(usbi_mutex_t *mutex);
 int usbi_mutex_unlock(usbi_mutex_t *mutex);
 int usbi_mutex_trylock(usbi_mutex_t *mutex);
 int usbi_mutex_destroy(usbi_mutex_t *mutex);
 
-int usbi_cond_init(usbi_cond_t *cond, const usbi_condattr_t *attr);
+int usbi_cond_init(usbi_cond_t *cond);
 int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex);
 int usbi_cond_timedwait(usbi_cond_t *cond,
-	usbi_mutex_t *mutex, const struct timespec *abstime);
+	usbi_mutex_t *mutex, const struct timeval *tv);
 int usbi_cond_broadcast(usbi_cond_t *cond);
 int usbi_cond_destroy(usbi_cond_t *cond);
 
-int usbi_tls_key_create(usbi_tls_key_t *key, void (*destructor)(void *));
+int usbi_tls_key_create(usbi_tls_key_t *key);
 void *usbi_tls_key_get(usbi_tls_key_t key);
-int usbi_tls_key_set(usbi_tls_key_t key, const void *value);
+int usbi_tls_key_set(usbi_tls_key_t key, void *value);
 int usbi_tls_key_delete(usbi_tls_key_t key);
 
 // all Windows mutexes are recursive
-#define usbi_mutex_init_recursive(mutex, attr) usbi_mutex_init((mutex), (attr))
+#define usbi_mutex_init_recursive	usbi_mutex_init
 
 int usbi_get_tid(void);
 
diff --git a/libusb/os/windows_nt_common.c b/libusb/os/windows_nt_common.c
index 650e2fa..93e6278 100644
--- a/libusb/os/windows_nt_common.c
+++ b/libusb/os/windows_nt_common.c
@@ -156,7 +156,7 @@ static bool htab_create(struct libusb_context *ctx, unsigned long nel)
 	}
 
 	// Create a mutex
-	usbi_mutex_init(&htab_write_mutex, NULL);
+	usbi_mutex_init(&htab_write_mutex);
 
 	// Change nel to the first prime number not smaller as nel.
 	nel |= 1;
diff --git a/libusb/os/windows_winusb.c b/libusb/os/windows_winusb.c
index a3bc11d..3b58b1a 100644
--- a/libusb/os/windows_winusb.c
+++ b/libusb/os/windows_winusb.c
@@ -811,7 +811,7 @@ static int windows_init(struct libusb_context *ctx)
 		}
 
 		// We need a lock for proper auto-release
-		usbi_mutex_init(&autoclaim_lock, NULL);
+		usbi_mutex_init(&autoclaim_lock);
 
 		// Initialize pollable file descriptors
 		init_polling();
diff --git a/libusb/version_nano.h b/libusb/version_nano.h
index ec8f802..3422ff2 100644
--- a/libusb/version_nano.h
+++ b/libusb/version_nano.h
@@ -1 +1 @@
-#define LIBUSB_NANO 11059
+#define LIBUSB_NANO 11060