From 23b5db8b3e353176dfa0635bfb6f0e2658f6e3de Mon Sep 17 00:00:00 2001 From: Peter Stuge Date: Tue, 11 May 2010 00:51:43 +0100 Subject: Add internal abstraction for POSIX Threads This prepares for a Windows backend without dependency on pthreads-w32. pthread_* is renamed to usbi_* and PTHREAD_* to USBI_*. A usbi_mutex_static_t and usbi_mutex_static_lock() and _unlock() are introduced for statically initialized mutexes, since they may be implemented using other types when pthreads mutexes aren't used. Move -pthread from libusb/Makefile.am to host-specific THREAD_CFLAGS in configure.ac. This will enable optional use of -lpthread for cygwin. [dsd: minor tweaks, and roll in a change based on patches from Pete Batard to only build dpfp_threaded example when we're using pthreads] --- libusb/core.c | 84 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 42 insertions(+), 42 deletions(-) (limited to 'libusb/core.c') diff --git a/libusb/core.c b/libusb/core.c index 7e4fd24..0f5b894 100644 --- a/libusb/core.c +++ b/libusb/core.c @@ -41,7 +41,7 @@ const struct usbi_os_backend * const usbi_backend = &darwin_backend; #endif struct libusb_context *usbi_default_context = NULL; -static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER; +static usbi_mutex_static_t default_context_lock = USBI_MUTEX_INITIALIZER; /** * \mainpage libusb-1.0 API Reference @@ -506,7 +506,7 @@ struct libusb_device *usbi_alloc_device(struct libusb_context *ctx, if (!dev) return NULL; - r = pthread_mutex_init(&dev->lock, NULL); + r = usbi_mutex_init(&dev->lock, NULL); if (r) return NULL; @@ -515,9 +515,9 @@ struct libusb_device *usbi_alloc_device(struct libusb_context *ctx, dev->session_data = session_id; memset(&dev->os_priv, 0, priv_size); - pthread_mutex_lock(&ctx->usb_devs_lock); + usbi_mutex_lock(&ctx->usb_devs_lock); list_add(&dev->list, &ctx->usb_devs); - pthread_mutex_unlock(&ctx->usb_devs_lock); + usbi_mutex_unlock(&ctx->usb_devs_lock); return dev; } @@ -557,13 +557,13 @@ struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx, struct libusb_device *dev; struct libusb_device *ret = NULL; - pthread_mutex_lock(&ctx->usb_devs_lock); + usbi_mutex_lock(&ctx->usb_devs_lock); list_for_each_entry(dev, &ctx->usb_devs, list) if (dev->session_data == session_id) { ret = dev; break; } - pthread_mutex_unlock(&ctx->usb_devs_lock); + usbi_mutex_unlock(&ctx->usb_devs_lock); return ret; } @@ -799,9 +799,9 @@ API_EXPORTED int libusb_get_max_iso_packet_size(libusb_device *dev, */ API_EXPORTED libusb_device *libusb_ref_device(libusb_device *dev) { - pthread_mutex_lock(&dev->lock); + usbi_mutex_lock(&dev->lock); dev->refcnt++; - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); return dev; } @@ -817,9 +817,9 @@ API_EXPORTED void libusb_unref_device(libusb_device *dev) if (!dev) return; - pthread_mutex_lock(&dev->lock); + usbi_mutex_lock(&dev->lock); refcnt = --dev->refcnt; - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); if (refcnt == 0) { usbi_dbg("destroy device %d.%d", dev->bus_number, dev->device_address); @@ -827,9 +827,9 @@ API_EXPORTED void libusb_unref_device(libusb_device *dev) if (usbi_backend->destroy_device) usbi_backend->destroy_device(dev); - pthread_mutex_lock(&dev->ctx->usb_devs_lock); + usbi_mutex_lock(&dev->ctx->usb_devs_lock); list_del(&dev->list); - pthread_mutex_unlock(&dev->ctx->usb_devs_lock); + usbi_mutex_unlock(&dev->ctx->usb_devs_lock); free(dev); } @@ -867,7 +867,7 @@ API_EXPORTED int libusb_open(libusb_device *dev, libusb_device_handle **handle) if (!_handle) return LIBUSB_ERROR_NO_MEM; - r = pthread_mutex_init(&_handle->lock, NULL); + r = usbi_mutex_init(&_handle->lock, NULL); if (r) return LIBUSB_ERROR_OTHER; @@ -882,9 +882,9 @@ API_EXPORTED int libusb_open(libusb_device *dev, libusb_device_handle **handle) return r; } - pthread_mutex_lock(&ctx->open_devs_lock); + usbi_mutex_lock(&ctx->open_devs_lock); list_add(&_handle->list, &ctx->open_devs); - pthread_mutex_unlock(&ctx->open_devs_lock); + usbi_mutex_unlock(&ctx->open_devs_lock); *handle = _handle; @@ -896,17 +896,17 @@ API_EXPORTED int libusb_open(libusb_device *dev, libusb_device_handle **handle) * so that it picks up the new fd, and then continues. */ /* record that we are messing with poll fds */ - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify++; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); /* write some data on control pipe to interrupt event handlers */ r = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); if (r <= 0) { usbi_warn(ctx, "internal signalling write failed"); - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify--; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); return 0; } @@ -919,9 +919,9 @@ API_EXPORTED int libusb_open(libusb_device *dev, libusb_device_handle **handle) usbi_warn(ctx, "internal signalling read failed"); /* we're done with modifying poll fds */ - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify--; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); /* Release event handling lock and wake up event waiters */ libusb_unlock_events(ctx); @@ -983,9 +983,9 @@ out: static void do_close(struct libusb_context *ctx, struct libusb_device_handle *dev_handle) { - pthread_mutex_lock(&ctx->open_devs_lock); + usbi_mutex_lock(&ctx->open_devs_lock); list_del(&dev_handle->list); - pthread_mutex_unlock(&ctx->open_devs_lock); + usbi_mutex_unlock(&ctx->open_devs_lock); usbi_backend->close(dev_handle); libusb_unref_device(dev_handle->dev); @@ -1022,18 +1022,18 @@ API_EXPORTED void libusb_close(libusb_device_handle *dev_handle) * descriptor from the polling loop. */ /* record that we are messing with poll fds */ - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify++; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); /* write some data on control pipe to interrupt event handlers */ r = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); if (r <= 0) { usbi_warn(ctx, "internal signalling write failed, closing anyway"); do_close(ctx, dev_handle); - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify--; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); return; } @@ -1049,9 +1049,9 @@ API_EXPORTED void libusb_close(libusb_device_handle *dev_handle) do_close(ctx, dev_handle); /* we're done with modifying poll fds */ - pthread_mutex_lock(&ctx->pollfd_modify_lock); + usbi_mutex_lock(&ctx->pollfd_modify_lock); ctx->pollfd_modify--; - pthread_mutex_unlock(&ctx->pollfd_modify_lock); + usbi_mutex_unlock(&ctx->pollfd_modify_lock); /* Release event handling lock and wake up event waiters */ libusb_unlock_events(ctx); @@ -1198,7 +1198,7 @@ API_EXPORTED int libusb_claim_interface(libusb_device_handle *dev, if (interface_number >= sizeof(dev->claimed_interfaces) * 8) return LIBUSB_ERROR_INVALID_PARAM; - pthread_mutex_lock(&dev->lock); + usbi_mutex_lock(&dev->lock); if (dev->claimed_interfaces & (1 << interface_number)) goto out; @@ -1207,7 +1207,7 @@ API_EXPORTED int libusb_claim_interface(libusb_device_handle *dev, dev->claimed_interfaces |= 1 << interface_number; out: - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); return r; } @@ -1235,7 +1235,7 @@ API_EXPORTED int libusb_release_interface(libusb_device_handle *dev, if (interface_number >= sizeof(dev->claimed_interfaces) * 8) return LIBUSB_ERROR_INVALID_PARAM; - pthread_mutex_lock(&dev->lock); + usbi_mutex_lock(&dev->lock); if (!(dev->claimed_interfaces & (1 << interface_number))) { r = LIBUSB_ERROR_NOT_FOUND; goto out; @@ -1246,7 +1246,7 @@ API_EXPORTED int libusb_release_interface(libusb_device_handle *dev, dev->claimed_interfaces &= ~(1 << interface_number); out: - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); return r; } @@ -1279,12 +1279,12 @@ API_EXPORTED int libusb_set_interface_alt_setting(libusb_device_handle *dev, if (interface_number >= sizeof(dev->claimed_interfaces) * 8) return LIBUSB_ERROR_INVALID_PARAM; - pthread_mutex_lock(&dev->lock); + usbi_mutex_lock(&dev->lock); if (!(dev->claimed_interfaces & (1 << interface_number))) { - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); return LIBUSB_ERROR_NOT_FOUND; } - pthread_mutex_unlock(&dev->lock); + usbi_mutex_unlock(&dev->lock); return usbi_backend->set_interface_altsetting(dev, interface_number, alternate_setting); @@ -1476,8 +1476,8 @@ API_EXPORTED int libusb_init(libusb_context **context) goto err; } - pthread_mutex_init(&ctx->usb_devs_lock, NULL); - pthread_mutex_init(&ctx->open_devs_lock, NULL); + usbi_mutex_init(&ctx->usb_devs_lock, NULL); + usbi_mutex_init(&ctx->open_devs_lock, NULL); list_init(&ctx->usb_devs); list_init(&ctx->open_devs); @@ -1488,12 +1488,12 @@ API_EXPORTED int libusb_init(libusb_context **context) goto err; } - pthread_mutex_lock(&default_context_lock); + usbi_mutex_static_lock(&default_context_lock); if (!usbi_default_context) { usbi_dbg("created default context"); usbi_default_context = ctx; } - pthread_mutex_unlock(&default_context_lock); + usbi_mutex_static_unlock(&default_context_lock); if (context) *context = ctx; @@ -1523,12 +1523,12 @@ API_EXPORTED void libusb_exit(struct libusb_context *ctx) if (usbi_backend->exit) usbi_backend->exit(); - pthread_mutex_lock(&default_context_lock); + usbi_mutex_static_lock(&default_context_lock); if (ctx == usbi_default_context) { usbi_dbg("freeing default context"); usbi_default_context = NULL; } - pthread_mutex_unlock(&default_context_lock); + usbi_mutex_static_unlock(&default_context_lock); free(ctx); } -- cgit v1.2.1