if (!dev)
return NULL;
- r = usbi_mutex_init(&dev->lock, NULL);
+ r = usbi_mutex_init(&dev->lock);
if (r) {
free(dev);
return NULL;
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;
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);
{
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);
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;
*/
int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
{
- struct timespec timeout;
int r;
USBI_GET_CONTEXT(ctx);
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)
#include <config.h>
+#include <time.h>
#if defined(__linux__) || defined(__OpenBSD__)
# if defined(__OpenBSD__)
# define _BSD_SOURCE
#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;
#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
#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);
#include "libusbi.h"
-extern const uint64_t epoch_time;
-
struct usbi_cond_perthread {
struct list_head list;
DWORD tid;
SleepEx(0, TRUE);
return 0;
}
+
int usbi_mutex_static_unlock(usbi_mutex_static_t *mutex)
{
if (!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);
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);
}
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();
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;
# 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);
}
// 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;
}
// 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();
-#define LIBUSB_NANO 11059
+#define LIBUSB_NANO 11060