usb 2.1.3 → 2.3.1

package/libusb/libusb/os/sunos_usb.h

@@ -30,7 +30,6 @@
 typedef struct sunos_device_priv {
 	uint8_t	cfgvalue;		/* active config value */
 	uint8_t	*raw_cfgdescr;		/* active config descriptor */
-	struct libusb_device_descriptor	dev_descr;	/* usb device descriptor */
 	char	*ugenpath;		/* name of the ugen(4) node */
 	char	*phypath;		/* physical path */
 } sunos_dev_priv_t;

package/libusb/libusb/os/threads_posix.c

@@ -19,23 +19,39 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <config.h>
+#include "libusbi.h"
 
-#include <time.h>
-#if defined(__linux__) || defined(__OpenBSD__)
-# if defined(__OpenBSD__)
-#  define _BSD_SOURCE
-# endif
+#include <errno.h>
+#if defined(__ANDROID__)
 # include <unistd.h>
+#elif defined(__HAIKU__)
+# include <os/kernel/OS.h>
+#elif defined(__linux__)
 # include <sys/syscall.h>
-#elif defined(__APPLE__)
-# include <pthread.h>
-#elif defined(__CYGWIN__)
-# include <windows.h>
+# include <unistd.h>
+#elif defined(__NetBSD__)
+# include <lwp.h>
+#elif defined(__OpenBSD__)
+# define _BSD_SOURCE
+# include <sys/syscall.h>
+# include <unistd.h>
+#elif defined(__sun__)
+# include <sys/lwp.h>
 #endif
 
-#include "threads_posix.h"
-#include "libusbi.h"
+void usbi_cond_init(pthread_cond_t *cond)
+{
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+	pthread_condattr_t condattr;
+
+	PTHREAD_CHECK(pthread_condattr_init(&condattr));
+	PTHREAD_CHECK(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC));
+	PTHREAD_CHECK(pthread_cond_init(cond, &condattr));
+	PTHREAD_CHECK(pthread_condattr_destroy(&condattr));
+#else
+	PTHREAD_CHECK(pthread_cond_init(cond, NULL));
+#endif
+}
 
 int usbi_cond_timedwait(pthread_cond_t *cond,
 	pthread_mutex_t *mutex, const struct timeval *tv)
@@ -43,38 +59,71 @@ int usbi_cond_timedwait(pthread_cond_t *cond,
 	struct timespec timeout;
 	int r;
 
-	r = usbi_backend.clock_gettime(USBI_CLOCK_REALTIME, &timeout);
-	if (r < 0)
-		return r;
+#ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
+	usbi_get_monotonic_time(&timeout);
+#else
+	usbi_get_real_time(&timeout);
+#endif
 
 	timeout.tv_sec += tv->tv_sec;
-	timeout.tv_nsec += tv->tv_usec * 1000;
-	while (timeout.tv_nsec >= 1000000000L) {
-		timeout.tv_nsec -= 1000000000L;
+	timeout.tv_nsec += tv->tv_usec * 1000L;
+	if (timeout.tv_nsec >= NSEC_PER_SEC) {
+		timeout.tv_nsec -= NSEC_PER_SEC;
 		timeout.tv_sec++;
 	}
 
-	return pthread_cond_timedwait(cond, mutex, &timeout);
+	r = pthread_cond_timedwait(cond, mutex, &timeout);
+	if (r == 0)
+		return 0;
+	else if (r == ETIMEDOUT)
+		return LIBUSB_ERROR_TIMEOUT;
+	else
+		return LIBUSB_ERROR_OTHER;
 }
 
-int usbi_get_tid(void)
+unsigned int usbi_get_tid(void)
 {
-	int ret;
+	static _Thread_local unsigned int tl_tid;
+	int tid;
+
+	if (tl_tid)
+		return tl_tid;
+
 #if defined(__ANDROID__)
-	ret = gettid();
+	tid = gettid();
+#elif defined(__APPLE__)
+#ifdef HAVE_PTHREAD_THREADID_NP
+	uint64_t thread_id;
+
+	if (pthread_threadid_np(NULL, &thread_id) == 0)
+		tid = (int)thread_id;
+	else
+		tid = -1;
+#else
+	tid = (int)pthread_mach_thread_np(pthread_self());
+#endif
+#elif defined(__HAIKU__)
+	tid = get_pthread_thread_id(pthread_self());
 #elif defined(__linux__)
-	ret = syscall(SYS_gettid);
+	tid = (int)syscall(SYS_gettid);
+#elif defined(__NetBSD__)
+	tid = _lwp_self();
 #elif defined(__OpenBSD__)
 	/* The following only works with OpenBSD > 5.1 as it requires
-	   real thread support. For 5.1 and earlier, -1 is returned. */
-	ret = syscall(SYS_getthrid);
-#elif defined(__APPLE__)
-	ret = (int)pthread_mach_thread_np(pthread_self());
-#elif defined(__CYGWIN__)
-	ret = GetCurrentThreadId();
+	 * real thread support. For 5.1 and earlier, -1 is returned. */
+	tid = syscall(SYS_getthrid);
+#elif defined(__sun__)
+	tid = _lwp_self();
 #else
-	ret = -1;
+	tid = -1;
 #endif
-/* TODO: NetBSD thread ID support */
-	return ret;
+
+	if (tid == -1) {
+		/* If we don't have a thread ID, at least return a unique
+		 * value that can be used to distinguish individual
+		 * threads. */
+		tid = (int)(intptr_t)pthread_self();
+	}
+
+	return tl_tid = (unsigned int)tid;
 }

package/libusb/libusb/os/threads_posix.h

@@ -22,67 +22,63 @@
 #define LIBUSB_THREADS_POSIX_H
 
 #include <pthread.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
+
+#define PTHREAD_CHECK(expression)	ASSERT_EQ(expression, 0)
 
 #define USBI_MUTEX_INITIALIZER	PTHREAD_MUTEX_INITIALIZER
 typedef pthread_mutex_t usbi_mutex_static_t;
 static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
 {
-	(void)pthread_mutex_lock(mutex);
+	PTHREAD_CHECK(pthread_mutex_lock(mutex));
 }
 static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
 {
-	(void)pthread_mutex_unlock(mutex);
+	PTHREAD_CHECK(pthread_mutex_unlock(mutex));
 }
 
 typedef pthread_mutex_t usbi_mutex_t;
-static inline int usbi_mutex_init(usbi_mutex_t *mutex)
+static inline void usbi_mutex_init(usbi_mutex_t *mutex)
 {
-	return pthread_mutex_init(mutex, NULL);
+	PTHREAD_CHECK(pthread_mutex_init(mutex, NULL));
 }
 static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
 {
-	(void)pthread_mutex_lock(mutex);
+	PTHREAD_CHECK(pthread_mutex_lock(mutex));
 }
 static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
 {
-	(void)pthread_mutex_unlock(mutex);
+	PTHREAD_CHECK(pthread_mutex_unlock(mutex));
 }
 static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
 {
-	return pthread_mutex_trylock(mutex);
+	return pthread_mutex_trylock(mutex) == 0;
 }
 static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
 {
-	(void)pthread_mutex_destroy(mutex);
+	PTHREAD_CHECK(pthread_mutex_destroy(mutex));
 }
 
 typedef pthread_cond_t usbi_cond_t;
-static inline void usbi_cond_init(pthread_cond_t *cond)
-{
-	(void)pthread_cond_init(cond, NULL);
-}
-static inline int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+void usbi_cond_init(pthread_cond_t *cond);
+static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
 {
-	return pthread_cond_wait(cond, mutex);
+	PTHREAD_CHECK(pthread_cond_wait(cond, mutex));
 }
 int usbi_cond_timedwait(usbi_cond_t *cond,
 	usbi_mutex_t *mutex, const struct timeval *tv);
 static inline void usbi_cond_broadcast(usbi_cond_t *cond)
 {
-	(void)pthread_cond_broadcast(cond);
+	PTHREAD_CHECK(pthread_cond_broadcast(cond));
 }
 static inline void usbi_cond_destroy(usbi_cond_t *cond)
 {
-	(void)pthread_cond_destroy(cond);
+	PTHREAD_CHECK(pthread_cond_destroy(cond));
 }
 
 typedef pthread_key_t usbi_tls_key_t;
 static inline void usbi_tls_key_create(usbi_tls_key_t *key)
 {
-	(void)pthread_key_create(key, NULL);
+	PTHREAD_CHECK(pthread_key_create(key, NULL));
 }
 static inline void *usbi_tls_key_get(usbi_tls_key_t key)
 {
@@ -90,13 +86,13 @@ static inline void *usbi_tls_key_get(usbi_tls_key_t key)
 }
 static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
 {
-	(void)pthread_setspecific(key, ptr);
+	PTHREAD_CHECK(pthread_setspecific(key, ptr));
 }
 static inline void usbi_tls_key_delete(usbi_tls_key_t key)
 {
-	(void)pthread_key_delete(key);
+	PTHREAD_CHECK(pthread_key_delete(key));
 }
 
-int usbi_get_tid(void);
+unsigned int usbi_get_tid(void);
 
 #endif /* LIBUSB_THREADS_POSIX_H */

package/libusb/libusb/os/threads_windows.c

@@ -2,6 +2,7 @@
  * libusb synchronization on Microsoft Windows
  *
  * Copyright © 2010 Michael Plante <michael.plante@gmail.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -18,109 +19,22 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <config.h>
-
-#include <errno.h>
-
 #include "libusbi.h"
 
-struct usbi_cond_perthread {
-	struct list_head list;
-	HANDLE event;
-};
-
-void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
-{
-	while (InterlockedExchange(mutex, 1L) == 1L)
-		SleepEx(0, TRUE);
-}
-
-void usbi_cond_init(usbi_cond_t *cond)
-{
-	list_init(&cond->waiters);
-	list_init(&cond->not_waiting);
-}
-
-static int usbi_cond_intwait(usbi_cond_t *cond,
-	usbi_mutex_t *mutex, DWORD timeout_ms)
-{
-	struct usbi_cond_perthread *pos;
-	DWORD r;
-
-	// Same assumption as usbi_cond_broadcast() holds
-	if (list_empty(&cond->not_waiting)) {
-		pos = malloc(sizeof(*pos));
-		if (pos == NULL)
-			return ENOMEM; // This errno is not POSIX-allowed.
-		pos->event = CreateEvent(NULL, FALSE, FALSE, NULL); // auto-reset.
-		if (pos->event == NULL) {
-			free(pos);
-			return ENOMEM;
-		}
-	} else {
-		pos = list_first_entry(&cond->not_waiting, struct usbi_cond_perthread, list);
-		list_del(&pos->list); // remove from not_waiting list.
-		// Ensure the event is clear before waiting
-		WaitForSingleObject(pos->event, 0);
-	}
-
-	list_add(&pos->list, &cond->waiters);
-
-	LeaveCriticalSection(mutex);
-	r = WaitForSingleObject(pos->event, timeout_ms);
-	EnterCriticalSection(mutex);
-
-	list_del(&pos->list);
-	list_add(&pos->list, &cond->not_waiting);
-
-	if (r == WAIT_OBJECT_0)
-		return 0;
-	else if (r == WAIT_TIMEOUT)
-		return ETIMEDOUT;
-	else
-		return EINVAL;
-}
-
-// N.B.: usbi_cond_*wait() can also return ENOMEM, even though pthread_cond_*wait cannot!
-int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
-{
-	return usbi_cond_intwait(cond, mutex, INFINITE);
-}
-
 int usbi_cond_timedwait(usbi_cond_t *cond,
 	usbi_mutex_t *mutex, const struct timeval *tv)
 {
 	DWORD millis;
 
-	millis = (DWORD)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
+	millis = (DWORD)(tv->tv_sec * 1000L) + (tv->tv_usec / 1000L);
 	/* round up to next millisecond */
-	if (tv->tv_usec % 1000)
+	if (tv->tv_usec % 1000L)
 		millis++;
-	return usbi_cond_intwait(cond, mutex, millis);
-}
 
-void usbi_cond_broadcast(usbi_cond_t *cond)
-{
-	// Assumes mutex is locked; this is not in keeping with POSIX spec, but
-	//   libusb does this anyway, so we simplify by not adding more sync
-	//   primitives to the CV definition!
-	struct usbi_cond_perthread *pos;
-
-	list_for_each_entry(pos, &cond->waiters, list, struct usbi_cond_perthread)
-		SetEvent(pos->event);
-	// The wait function will remove its respective item from the list.
-}
-
-void usbi_cond_destroy(usbi_cond_t *cond)
-{
-	// This assumes no one is using this anymore.  The check MAY NOT BE safe.
-	struct usbi_cond_perthread *pos, *next;
-
-	if (!list_empty(&cond->waiters))
-		return; // (!see above!)
-	list_for_each_entry_safe(pos, next, &cond->not_waiting, list, struct usbi_cond_perthread) {
-		CloseHandle(pos->event);
-		list_del(&pos->list);
-		free(pos);
-	}
+	if (SleepConditionVariableCS(cond, mutex, millis))
+		return 0;
+	else if (GetLastError() == ERROR_TIMEOUT)
+		return LIBUSB_ERROR_TIMEOUT;
+	else
+		return LIBUSB_ERROR_OTHER;
 }

package/libusb/libusb/os/threads_windows.h

@@ -21,23 +21,24 @@
 #ifndef LIBUSB_THREADS_WINDOWS_H
 #define LIBUSB_THREADS_WINDOWS_H
 
+#define WINAPI_CHECK(expression)	ASSERT_NE(expression, 0)
+
 #define USBI_MUTEX_INITIALIZER	0L
-#ifdef _WIN32_WCE
 typedef LONG usbi_mutex_static_t;
-#else
-typedef volatile LONG usbi_mutex_static_t;
-#endif
-void usbi_mutex_static_lock(usbi_mutex_static_t *mutex);
+static inline void usbi_mutex_static_lock(usbi_mutex_static_t *mutex)
+{
+	while (InterlockedExchange(mutex, 1L) == 1L)
+		SleepEx(0, TRUE);
+}
 static inline void usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
 {
 	InterlockedExchange(mutex, 0L);
 }
 
 typedef CRITICAL_SECTION usbi_mutex_t;
-static inline int usbi_mutex_init(usbi_mutex_t *mutex)
+static inline void usbi_mutex_init(usbi_mutex_t *mutex)
 {
 	InitializeCriticalSection(mutex);
-	return 0;
 }
 static inline void usbi_mutex_lock(usbi_mutex_t *mutex)
 {
@@ -49,46 +50,47 @@ static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
 }
 static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
 {
-	return !TryEnterCriticalSection(mutex);
+	return TryEnterCriticalSection(mutex) != 0;
 }
 static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
 {
 	DeleteCriticalSection(mutex);
 }
 
-// We *were* getting timespec from pthread.h:
-#if (!defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED))
+#if !defined(HAVE_STRUCT_TIMESPEC) && !defined(_TIMESPEC_DEFINED)
 #define HAVE_STRUCT_TIMESPEC 1
 #define _TIMESPEC_DEFINED 1
 struct timespec {
 	long tv_sec;
 	long tv_nsec;
 };
-#endif /* HAVE_STRUCT_TIMESPEC | _TIMESPEC_DEFINED */
-
-// We *were* getting ETIMEDOUT from pthread.h:
-#ifndef ETIMEDOUT
-#define ETIMEDOUT	10060	/* This is the value in winsock.h. */
-#endif
+#endif /* HAVE_STRUCT_TIMESPEC || _TIMESPEC_DEFINED */
 
-typedef struct usbi_cond {
-	// Every time a thread touches the CV, it winds up in one of these lists.
-	//   It stays there until the CV is destroyed, even if the thread terminates.
-	struct list_head waiters;
-	struct list_head not_waiting;
-} usbi_cond_t;
-
-void usbi_cond_init(usbi_cond_t *cond);
-int usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex);
+typedef CONDITION_VARIABLE usbi_cond_t;
+static inline void usbi_cond_init(usbi_cond_t *cond)
+{
+	InitializeConditionVariable(cond);
+}
+static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
+{
+	WINAPI_CHECK(SleepConditionVariableCS(cond, mutex, INFINITE));
+}
 int usbi_cond_timedwait(usbi_cond_t *cond,
 	usbi_mutex_t *mutex, const struct timeval *tv);
-void usbi_cond_broadcast(usbi_cond_t *cond);
-void usbi_cond_destroy(usbi_cond_t *cond);
+static inline void usbi_cond_broadcast(usbi_cond_t *cond)
+{
+	WakeAllConditionVariable(cond);
+}
+static inline void usbi_cond_destroy(usbi_cond_t *cond)
+{
+	UNUSED(cond);
+}
 
 typedef DWORD usbi_tls_key_t;
 static inline void usbi_tls_key_create(usbi_tls_key_t *key)
 {
 	*key = TlsAlloc();
+	assert(*key != TLS_OUT_OF_INDEXES);
 }
 static inline void *usbi_tls_key_get(usbi_tls_key_t key)
 {
@@ -96,16 +98,16 @@ static inline void *usbi_tls_key_get(usbi_tls_key_t key)
 }
 static inline void usbi_tls_key_set(usbi_tls_key_t key, void *ptr)
 {
-	(void)TlsSetValue(key, ptr);
+	WINAPI_CHECK(TlsSetValue(key, ptr));
 }
 static inline void usbi_tls_key_delete(usbi_tls_key_t key)
 {
-	(void)TlsFree(key);
+	WINAPI_CHECK(TlsFree(key));
 }
 
-static inline int usbi_get_tid(void)
+static inline unsigned int usbi_get_tid(void)
 {
-	return (int)GetCurrentThreadId();
+	return (unsigned int)GetCurrentThreadId();
 }
 
 #endif /* LIBUSB_THREADS_WINDOWS_H */