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]

1 files changed, 42 insertions, 42 deletions

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);
 }