usb 2.1.3 → 2.3.1

package/libusb/libusb/io.c

@@ -21,24 +21,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <config.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef USBI_TIMERFD_AVAILABLE
-#include <unistd.h>
-#include <sys/timerfd.h>
-#endif
-
 #include "libusbi.h"
-#include "hotplug.h"
 
 /**
  * \page libusb_io Synchronous and asynchronous device I/O
@@ -89,7 +72,7 @@
  * a single function call. When the function call returns, the transfer has
  * completed and you can parse the results.
  *
- * If you have used the libusb-0.1 before, this I/O style will seem familar to
+ * If you have used libusb-0.1 before, this I/O style will seem familiar to
  * you. libusb-0.1 only offered a synchronous interface.
  *
  * In our input device example, to read button presses you might write code
@@ -115,7 +98,7 @@ if (r == 0 && actual_length == sizeof(data)) {
  * sleeping for that long. Execution will be tied up inside the library -
  * the entire thread will be useless for that duration.
  *
- * Another issue is that by tieing up the thread with that single transaction
+ * Another issue is that by tying up the thread with that single transaction
  * there is no possibility of performing I/O with multiple endpoints and/or
  * multiple devices simultaneously, unless you resort to creating one thread
  * per transaction.
@@ -333,9 +316,40 @@ if (r == 0 && actual_length == sizeof(data)) {
  * Freeing the transfer after it has been cancelled but before cancellation
  * has completed will result in undefined behaviour.
  *
+ * \attention
  * When a transfer is cancelled, some of the data may have been transferred.
- * libusb will communicate this to you in the transfer callback. Do not assume
- * that no data was transferred.
+ * libusb will communicate this to you in the transfer callback.
+ * <b>Do not assume that no data was transferred.</b>
+ *
+ * \section asyncpartial Partial data transfer resulting from cancellation
+ *
+ * As noted above, some of the data may have been transferred at the time a
+ * transfer is cancelled. It is helpful to see how this is possible if you
+ * consider a bulk transfer to an endpoint with a packet size of 64 bytes.
+ * Supposing you submit a 512-byte transfer to this endpoint, the operating
+ * system will divide this transfer up into 8 separate 64-byte frames that the
+ * host controller will schedule for the device to transfer data. If this
+ * transfer is cancelled while the device is transferring data, a subset of
+ * these frames may be descheduled from the host controller before the device
+ * has the opportunity to finish transferring data to the host.
+ *
+ * What your application should do with a partial data transfer is a policy
+ * decision; there is no single answer that satisfies the needs of every
+ * application. The data that was successfully transferred should be
+ * considered entirely valid, but your application must decide what to do with
+ * the remaining data that was not transferred. Some possible actions to take
+ * are:
+ * - Resubmit another transfer for the remaining data, possibly with a shorter
+ *   timeout
+ * - Discard the partially transferred data and report an error
+ *
+ * \section asynctimeout Timeouts
+ *
+ * When a transfer times out, libusb internally notes this and attempts to
+ * cancel the transfer. As noted in \ref asyncpartial "above", it is possible
+ * that some of the data may actually have been transferred. Your application
+ * should <b>always</b> check how much data was actually transferred once the
+ * transfer completes and act accordingly.
  *
  * \section bulk_overflows Overflows on device-to-host bulk/interrupt endpoints
  *
@@ -393,7 +407,7 @@ if (r == 0 && actual_length == sizeof(data)) {
  * wLength of the setup packet, rather than the size of the data buffer. So,
  * if your wLength was 4, your transfer's <tt>length</tt> was 12, then you
  * should expect an <tt>actual_length</tt> of 4 to indicate that the data was
- * transferred in entirity.
+ * transferred in entirety.
  *
  * To simplify parsing of setup packets and obtaining the data from the
  * correct offset, you may wish to use the libusb_control_transfer_get_data()
@@ -472,14 +486,21 @@ if (r == 0 && actual_length == sizeof(data)) {
  * libusb_get_iso_packet_buffer() and libusb_get_iso_packet_buffer_simple()
  * functions may help you here.
  *
- * <b>Note</b>: Some operating systems (e.g. Linux) may impose limits on the
- * length of individual isochronous packets and/or the total length of the
- * isochronous transfer. Such limits can be difficult for libusb to detect,
- * so the library will simply try and submit the transfer as set up by you.
- * If the transfer fails to submit because it is too large,
+ * \section asynclimits Transfer length limitations
+ *
+ * Some operating systems may impose limits on the length of the transfer data
+ * buffer or, in the case of isochronous transfers, the length of individual
+ * isochronous packets. Such limits can be difficult for libusb to detect, so
+ * in most cases the library will simply try and submit the transfer as set up
+ * by you. If the transfer fails to submit because it is too large,
  * libusb_submit_transfer() will return
  * \ref libusb_error::LIBUSB_ERROR_INVALID_PARAM "LIBUSB_ERROR_INVALID_PARAM".
  *
+ * The following are known limits for control transfer lengths. Note that this
+ * length includes the 8-byte setup packet.
+ * - Linux (4,096 bytes)
+ * - Windows (4,096 bytes)
+ *
  * \section asyncmem Memory caveats
  *
  * In most circumstances, it is not safe to use stack memory for transfer
@@ -520,7 +541,14 @@ if (r == 0 && actual_length == sizeof(data)) {
  * application must call into when libusb has work do to. This gives libusb
  * the opportunity to reap pending transfers, invoke callbacks, etc.
  *
- * There are 2 different approaches to dealing with libusb_handle_events:
+ * \note
+ * All event handling is performed by whichever thread calls the
+ * libusb_handle_events() function. libusb does not invoke any callbacks
+ * outside of this context. Consequently, any callbacks will be run on the
+ * thread that calls the libusb_handle_events() function.
+ *
+ * When to call the libusb_handle_events() function depends on which model
+ * your application decides to use. The 2 different approaches:
  *
  * -# Repeatedly call libusb_handle_events() in blocking mode from a dedicated
  *    thread.
@@ -541,7 +569,7 @@ if (r == 0 && actual_length == sizeof(data)) {
  *
  * Lets begin with stating the obvious: If you're going to use a separate
  * thread for libusb event handling, your callback functions MUST be
- * threadsafe.
+ * thread-safe.
  *
  * Other then that doing event handling from a separate thread, is mostly
  * simple. You can use an event thread function as follows:
@@ -781,7 +809,7 @@ while (user has not requested application exit) {
  * system calls. This is directly exposed at the
  * \ref libusb_asyncio "asynchronous interface" but it is important to note that the
  * \ref libusb_syncio "synchronous interface" is implemented on top of the
- * asynchonrous interface, therefore the same considerations apply.
+ * asynchronous interface, therefore the same considerations apply.
  *
  * The issue is that if two or more threads are concurrently calling poll()
  * or select() on libusb's file descriptors then only one of those threads
@@ -889,6 +917,11 @@ void myfunc() {
  * do is submit a single transfer and wait for its completion, then using
  * one of the synchronous I/O functions is much easier.
  *
+ * \note
+ * The `completed` variable must be modified while holding the event lock,
+ * otherwise a race condition can still exist. It is simplest to do so from
+ * within the transfer callback as shown above.
+ *
  * \section eventlock The events lock
  *
  * The problem is when we consider the fact that libusb exposes file
@@ -986,7 +1019,7 @@ printf("completed!\n");
  * event handling), because the event waiter seems to have taken the event
  * waiters lock while waiting for an event. However, the system does support
  * multiple event waiters, because libusb_wait_for_event() actually drops
- * the lock while waiting, and reaquires it before continuing.
+ * the lock while waiting, and reacquires it before continuing.
  *
  * We have now implemented code which can dynamically handle situations where
  * nobody is handling events (so we should do it ourselves), and it can also
@@ -1131,46 +1164,40 @@ int usbi_io_init(struct libusb_context *ctx)
 	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->removed_ipollfds);
+	list_init(&ctx->event_sources);
+	list_init(&ctx->removed_event_sources);
 	list_init(&ctx->hotplug_msgs);
 	list_init(&ctx->completed_transfers);
 
-	/* FIXME should use an eventfd on kernels that support it */
-	r = usbi_pipe(ctx->event_pipe);
-	if (r < 0) {
-		r = LIBUSB_ERROR_OTHER;
+	r = usbi_create_event(&ctx->event);
+	if (r < 0)
 		goto err;
-	}
 
-	r = usbi_add_pollfd(ctx, ctx->event_pipe[0], POLLIN);
+	r = usbi_add_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event), USBI_EVENT_POLL_EVENTS);
 	if (r < 0)
-		goto err_close_pipe;
-
-#ifdef USBI_TIMERFD_AVAILABLE
-	ctx->timerfd = timerfd_create(usbi_backend.get_timerfd_clockid(),
-		TFD_NONBLOCK | TFD_CLOEXEC);
-	if (ctx->timerfd >= 0) {
-		usbi_dbg("using timerfd for timeouts");
-		r = usbi_add_pollfd(ctx, ctx->timerfd, POLLIN);
+		goto err_destroy_event;
+
+#ifdef HAVE_OS_TIMER
+	r = usbi_create_timer(&ctx->timer);
+	if (r == 0) {
+		usbi_dbg(ctx, "using timer for timeouts");
+		r = usbi_add_event_source(ctx, USBI_TIMER_OS_HANDLE(&ctx->timer), USBI_TIMER_POLL_EVENTS);
 		if (r < 0)
-			goto err_close_timerfd;
+			goto err_destroy_timer;
 	} else {
-		usbi_dbg("timerfd not available (code %d error %d)", ctx->timerfd, errno);
-		ctx->timerfd = -1;
+		usbi_dbg(ctx, "timer not available for timeouts");
 	}
 #endif
 
 	return 0;
 
-#ifdef USBI_TIMERFD_AVAILABLE
-err_close_timerfd:
-	close(ctx->timerfd);
-	usbi_remove_pollfd(ctx, ctx->event_pipe[0]);
+#ifdef HAVE_OS_TIMER
+err_destroy_timer:
+	usbi_destroy_timer(&ctx->timer);
+	usbi_remove_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event));
 #endif
-err_close_pipe:
-	usbi_close(ctx->event_pipe[0]);
-	usbi_close(ctx->event_pipe[1]);
+err_destroy_event:
+	usbi_destroy_event(&ctx->event);
 err:
 	usbi_mutex_destroy(&ctx->flying_transfers_lock);
 	usbi_mutex_destroy(&ctx->events_lock);
@@ -1181,65 +1208,54 @@ err:
 	return r;
 }
 
-static void cleanup_removed_pollfds(struct libusb_context *ctx)
+static void cleanup_removed_event_sources(struct libusb_context *ctx)
 {
-	struct usbi_pollfd *ipollfd, *tmp;
-	list_for_each_entry_safe(ipollfd, tmp, &ctx->removed_ipollfds, list, struct usbi_pollfd) {
-		list_del(&ipollfd->list);
-		free(ipollfd);
+	struct usbi_event_source *ievent_source, *tmp;
+
+	for_each_removed_event_source_safe(ctx, ievent_source, tmp) {
+		list_del(&ievent_source->list);
+		free(ievent_source);
 	}
 }
 
 void usbi_io_exit(struct libusb_context *ctx)
 {
-	usbi_remove_pollfd(ctx, ctx->event_pipe[0]);
-	usbi_close(ctx->event_pipe[0]);
-	usbi_close(ctx->event_pipe[1]);
-#ifdef USBI_TIMERFD_AVAILABLE
-	if (usbi_using_timerfd(ctx)) {
-		usbi_remove_pollfd(ctx, ctx->timerfd);
-		close(ctx->timerfd);
+#ifdef HAVE_OS_TIMER
+	if (usbi_using_timer(ctx)) {
+		usbi_remove_event_source(ctx, USBI_TIMER_OS_HANDLE(&ctx->timer));
+		usbi_destroy_timer(&ctx->timer);
 	}
 #endif
+	usbi_remove_event_source(ctx, USBI_EVENT_OS_HANDLE(&ctx->event));
+	usbi_destroy_event(&ctx->event);
 	usbi_mutex_destroy(&ctx->flying_transfers_lock);
 	usbi_mutex_destroy(&ctx->events_lock);
 	usbi_mutex_destroy(&ctx->event_waiters_lock);
 	usbi_cond_destroy(&ctx->event_waiters_cond);
 	usbi_mutex_destroy(&ctx->event_data_lock);
 	usbi_tls_key_delete(ctx->event_handling_key);
-	free(ctx->pollfds);
-	cleanup_removed_pollfds(ctx);
+	cleanup_removed_event_sources(ctx);
+	free(ctx->event_data);
 }
 
-static int calculate_timeout(struct usbi_transfer *transfer)
+static void calculate_timeout(struct usbi_transfer *itransfer)
 {
-	int r;
-	struct timespec current_time;
 	unsigned int timeout =
-		USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout;
+		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout;
 
 	if (!timeout) {
-		timerclear(&transfer->timeout);
-		return 0;
-	}
-
-	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &current_time);
-	if (r < 0) {
-		usbi_err(ITRANSFER_CTX(transfer),
-			"failed to read monotonic clock, errno=%d", errno);
-		return r;
+		TIMESPEC_CLEAR(&itransfer->timeout);
+		return;
 	}
 
-	current_time.tv_sec += timeout / 1000;
-	current_time.tv_nsec += (timeout % 1000) * 1000000;
+	usbi_get_monotonic_time(&itransfer->timeout);
 
-	while (current_time.tv_nsec >= 1000000000) {
-		current_time.tv_nsec -= 1000000000;
-		current_time.tv_sec++;
+	itransfer->timeout.tv_sec += timeout / 1000U;
+	itransfer->timeout.tv_nsec += (timeout % 1000U) * 1000000L;
+	if (itransfer->timeout.tv_nsec >= NSEC_PER_SEC) {
+		++itransfer->timeout.tv_sec;
+		itransfer->timeout.tv_nsec -= NSEC_PER_SEC;
 	}
-
-	TIMESPEC_TO_TIMEVAL(&transfer->timeout, &current_time);
-	return 0;
 }
 
 /** \ingroup libusb_asyncio
@@ -1269,26 +1285,30 @@ DEFAULT_VISIBILITY
 struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(
 	int iso_packets)
 {
-	struct libusb_transfer *transfer;
-	size_t os_alloc_size;
+	size_t priv_size;
 	size_t alloc_size;
+	unsigned char *ptr;
 	struct usbi_transfer *itransfer;
+	struct libusb_transfer *transfer;
 
 	assert(iso_packets >= 0);
+	if (iso_packets < 0)
+		return NULL;
 
-	os_alloc_size = usbi_backend.transfer_priv_size;
-	alloc_size = sizeof(struct usbi_transfer)
+	priv_size = PTR_ALIGN(usbi_backend.transfer_priv_size);
+	alloc_size = priv_size
+		+ sizeof(struct usbi_transfer)
 		+ sizeof(struct libusb_transfer)
-		+ (sizeof(struct libusb_iso_packet_descriptor) * (size_t)iso_packets)
-		+ os_alloc_size;
-	itransfer = calloc(1, alloc_size);
-	if (!itransfer)
+		+ (sizeof(struct libusb_iso_packet_descriptor) * (size_t)iso_packets);
+	ptr = calloc(1, alloc_size);
+	if (!ptr)
 		return NULL;
 
+	itransfer = (struct usbi_transfer *)(ptr + priv_size);
 	itransfer->num_iso_packets = iso_packets;
+	itransfer->priv = ptr;
 	usbi_mutex_init(&itransfer->lock);
 	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	usbi_dbg("transfer %p", transfer);
 	return transfer;
 }
 
@@ -1312,67 +1332,60 @@ struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(
 void API_EXPORTED libusb_free_transfer(struct libusb_transfer *transfer)
 {
 	struct usbi_transfer *itransfer;
+	size_t priv_size;
+	unsigned char *ptr;
+
 	if (!transfer)
 		return;
 
-	usbi_dbg("transfer %p", transfer);
+	usbi_dbg(TRANSFER_CTX(transfer), "transfer %p", transfer);
 	if (transfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
 		free(transfer->buffer);
 
 	itransfer = LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
 	usbi_mutex_destroy(&itransfer->lock);
-	free(itransfer);
-}
-
-#ifdef USBI_TIMERFD_AVAILABLE
-static int disarm_timerfd(struct libusb_context *ctx)
-{
-	const struct itimerspec disarm_timer = { { 0, 0 }, { 0, 0 } };
-	int r;
+	if (itransfer->dev)
+		libusb_unref_device(itransfer->dev);
 
-	usbi_dbg("");
-	r = timerfd_settime(ctx->timerfd, 0, &disarm_timer, NULL);
-	if (r < 0)
-		return LIBUSB_ERROR_OTHER;
-	else
-		return 0;
+	priv_size = PTR_ALIGN(usbi_backend.transfer_priv_size);
+	ptr = (unsigned char *)itransfer - priv_size;
+	assert(ptr == itransfer->priv);
+	free(ptr);
 }
 
-/* iterates through the flying transfers, and rearms the timerfd based on the
+/* iterates through the flying transfers, and rearms the timer based on the
  * next upcoming timeout.
  * must be called with flying_list locked.
  * returns 0 on success or a LIBUSB_ERROR code on failure.
  */
-static int arm_timerfd_for_next_timeout(struct libusb_context *ctx)
+#ifdef HAVE_OS_TIMER
+static int arm_timer_for_next_timeout(struct libusb_context *ctx)
 {
-	struct usbi_transfer *transfer;
+	struct usbi_transfer *itransfer;
 
-	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
-		struct timeval *cur_tv = &transfer->timeout;
+	if (!usbi_using_timer(ctx))
+		return 0;
+
+	for_each_transfer(ctx, itransfer) {
+		struct timespec *cur_ts = &itransfer->timeout;
 
 		/* if we've reached transfers of infinite timeout, then we have no
 		 * arming to do */
-		if (!timerisset(cur_tv))
-			goto disarm;
+		if (!TIMESPEC_IS_SET(cur_ts))
+			break;
 
 		/* act on first transfer that has not already been handled */
-		if (!(transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))) {
-			int r;
-			const struct itimerspec it = { {0, 0},
-				{ cur_tv->tv_sec, cur_tv->tv_usec * 1000 } };
-			usbi_dbg("next timeout originally %dms", USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout);
-			r = timerfd_settime(ctx->timerfd, TFD_TIMER_ABSTIME, &it, NULL);
-			if (r < 0)
-				return LIBUSB_ERROR_OTHER;
-			return 0;
+		if (!(itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))) {
+			usbi_dbg(ctx, "next timeout originally %ums", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout);
+			return usbi_arm_timer(&ctx->timer, cur_ts);
 		}
 	}
 
-disarm:
-	return disarm_timerfd(ctx);
+	usbi_dbg(ctx, "no timeouts, disarming timer");
+	return usbi_disarm_timer(&ctx->timer);
 }
 #else
-static int arm_timerfd_for_next_timeout(struct libusb_context *ctx)
+static inline int arm_timer_for_next_timeout(struct libusb_context *ctx)
 {
 	UNUSED(ctx);
 	return 0;
@@ -1382,40 +1395,36 @@ static int arm_timerfd_for_next_timeout(struct libusb_context *ctx)
 /* add a transfer to the (timeout-sorted) active transfers list.
  * This function will return non 0 if fails to update the timer,
  * in which case the transfer is *not* on the flying_transfers list. */
-static int add_to_flying_list(struct usbi_transfer *transfer)
+static int add_to_flying_list(struct usbi_transfer *itransfer)
 {
 	struct usbi_transfer *cur;
-	struct timeval *timeout = &transfer->timeout;
-	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
-	int r;
+	struct timespec *timeout = &itransfer->timeout;
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+	int r = 0;
 	int first = 1;
 
-	r = calculate_timeout(transfer);
-	if (r)
-		return r;
+	calculate_timeout(itransfer);
 
 	/* if we have no other flying transfers, start the list with this one */
 	if (list_empty(&ctx->flying_transfers)) {
-		list_add(&transfer->list, &ctx->flying_transfers);
+		list_add(&itransfer->list, &ctx->flying_transfers);
 		goto out;
 	}
 
 	/* if we have infinite timeout, append to end of list */
-	if (!timerisset(timeout)) {
-		list_add_tail(&transfer->list, &ctx->flying_transfers);
+	if (!TIMESPEC_IS_SET(timeout)) {
+		list_add_tail(&itransfer->list, &ctx->flying_transfers);
 		/* first is irrelevant in this case */
 		goto out;
 	}
 
 	/* otherwise, find appropriate place in list */
-	list_for_each_entry(cur, &ctx->flying_transfers, list, struct usbi_transfer) {
+	for_each_transfer(ctx, cur) {
 		/* find first timeout that occurs after the transfer in question */
-		struct timeval *cur_tv = &cur->timeout;
+		struct timespec *cur_ts = &cur->timeout;
 
-		if (!timerisset(cur_tv) || (cur_tv->tv_sec > timeout->tv_sec) ||
-				(cur_tv->tv_sec == timeout->tv_sec &&
-					cur_tv->tv_usec > timeout->tv_usec)) {
-			list_add_tail(&transfer->list, &cur->list);
+		if (!TIMESPEC_IS_SET(cur_ts) || TIMESPEC_CMP(cur_ts, timeout, >)) {
+			list_add_tail(&itransfer->list, &cur->list);
 			goto out;
 		}
 		first = 0;
@@ -1423,28 +1432,22 @@ static int add_to_flying_list(struct usbi_transfer *transfer)
 	/* first is 0 at this stage (list not empty) */
 
 	/* otherwise we need to be inserted at the end */
-	list_add_tail(&transfer->list, &ctx->flying_transfers);
+	list_add_tail(&itransfer->list, &ctx->flying_transfers);
 out:
-#ifdef USBI_TIMERFD_AVAILABLE
-	if (first && usbi_using_timerfd(ctx) && timerisset(timeout)) {
+#ifdef HAVE_OS_TIMER
+	if (first && usbi_using_timer(ctx) && TIMESPEC_IS_SET(timeout)) {
 		/* if this transfer has the lowest timeout of all active transfers,
-		 * rearm the timerfd with this transfer's timeout */
-		const struct itimerspec it = { {0, 0},
-			{ timeout->tv_sec, timeout->tv_usec * 1000 } };
-		usbi_dbg("arm timerfd for timeout in %dms (first in line)",
-			USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->timeout);
-		r = timerfd_settime(ctx->timerfd, TFD_TIMER_ABSTIME, &it, NULL);
-		if (r < 0) {
-			usbi_warn(ctx, "failed to arm first timerfd (errno %d)", errno);
-			r = LIBUSB_ERROR_OTHER;
-		}
+		 * rearm the timer with this transfer's timeout */
+		usbi_dbg(ctx, "arm timer for timeout in %ums (first in line)",
+			USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer)->timeout);
+		r = usbi_arm_timer(&ctx->timer, timeout);
 	}
 #else
 	UNUSED(first);
 #endif
 
 	if (r)
-		list_del(&transfer->list);
+		list_del(&itransfer->list);
 
 	return r;
 }
@@ -1453,18 +1456,18 @@ out:
  * This function will *always* remove the transfer from the
  * flying_transfers list. It will return a LIBUSB_ERROR code
  * if it fails to update the timer for the next timeout. */
-static int remove_from_flying_list(struct usbi_transfer *transfer)
+static int remove_from_flying_list(struct usbi_transfer *itransfer)
 {
-	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
-	int rearm_timerfd;
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
+	int rearm_timer;
 	int r = 0;
 
 	usbi_mutex_lock(&ctx->flying_transfers_lock);
-	rearm_timerfd = (timerisset(&transfer->timeout) &&
-		list_first_entry(&ctx->flying_transfers, struct usbi_transfer, list) == transfer);
-	list_del(&transfer->list);
-	if (usbi_using_timerfd(ctx) && rearm_timerfd)
-		r = arm_timerfd_for_next_timeout(ctx);
+	rearm_timer = (TIMESPEC_IS_SET(&itransfer->timeout) &&
+		list_first_entry(&ctx->flying_transfers, struct usbi_transfer, list) == itransfer);
+	list_del(&itransfer->list);
+	if (rearm_timer)
+		r = arm_timer_for_next_timeout(ctx);
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
 
 	return r;
@@ -1481,17 +1484,23 @@ static int remove_from_flying_list(struct usbi_transfer *transfer)
  * \returns LIBUSB_ERROR_NOT_SUPPORTED if the transfer flags are not supported
  * by the operating system.
  * \returns LIBUSB_ERROR_INVALID_PARAM if the transfer size is larger than
- * the operating system and/or hardware can support
+ * the operating system and/or hardware can support (see \ref asynclimits)
  * \returns another LIBUSB_ERROR code on other failure
  */
 int API_EXPORTED libusb_submit_transfer(struct libusb_transfer *transfer)
 {
 	struct usbi_transfer *itransfer =
 		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
-	struct libusb_context *ctx = TRANSFER_CTX(transfer);
+	struct libusb_context *ctx;
 	int r;
 
-	usbi_dbg("transfer %p", transfer);
+	assert(transfer->dev_handle);
+	if (itransfer->dev)
+		libusb_unref_device(itransfer->dev);
+	itransfer->dev = libusb_ref_device(transfer->dev_handle->dev);
+
+	ctx = HANDLE_CTX(transfer->dev_handle);
+	usbi_dbg(ctx, "transfer %p", transfer);
 
 	/*
 	 * Important note on locking, this function takes / releases locks
@@ -1543,15 +1552,13 @@ int API_EXPORTED libusb_submit_transfer(struct libusb_transfer *transfer)
 	}
 	/*
 	 * We must release the flying transfers lock here, because with
-	 * some backends the submit_transfer method is synchroneous.
+	 * some backends the submit_transfer method is synchronous.
 	 */
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
 
 	r = usbi_backend.submit_transfer(itransfer);
 	if (r == LIBUSB_SUCCESS) {
 		itransfer->state_flags |= USBI_TRANSFER_IN_FLIGHT;
-		/* keep a reference to this device */
-		libusb_ref_device(transfer->dev_handle->dev);
 	}
 	usbi_mutex_unlock(&itransfer->lock);
 
@@ -1569,6 +1576,26 @@ int API_EXPORTED libusb_submit_transfer(struct libusb_transfer *transfer)
  * \ref libusb_transfer_status::LIBUSB_TRANSFER_CANCELLED
  * "LIBUSB_TRANSFER_CANCELLED."
  *
+ * This function behaves differently on Darwin-based systems (macOS and iOS):
+ *
+ * - Calling this function for one transfer will cause all transfers on the
+ *   same endpoint to be cancelled. Your callback function will be invoked with
+ *   a transfer status of
+ *   \ref libusb_transfer_status::LIBUSB_TRANSFER_CANCELLED
+ *   "LIBUSB_TRANSFER_CANCELLED" for each transfer that was cancelled.
+
+ * - Calling this function also sends a \c ClearFeature(ENDPOINT_HALT) request
+ *   for the transfer's endpoint. If the device does not handle this request
+ *   correctly, the data toggle bits for the endpoint can be left out of sync
+ *   between host and device, which can have unpredictable results when the
+ *   next data is sent on the endpoint, including data being silently lost.
+ *   A call to \ref libusb_clear_halt will not resolve this situation, since
+ *   that function uses the same request. Therefore, if your program runs on
+ *   Darwin and uses a device that does not correctly implement
+ *   \c ClearFeature(ENDPOINT_HALT) requests, it may only be safe to cancel
+ *   transfers when followed by a device reset using
+ *   \ref libusb_reset_device.
+ *
  * \param transfer the transfer to cancel
  * \returns 0 on success
  * \returns LIBUSB_ERROR_NOT_FOUND if the transfer is not in progress,
@@ -1579,9 +1606,10 @@ int API_EXPORTED libusb_cancel_transfer(struct libusb_transfer *transfer)
 {
 	struct usbi_transfer *itransfer =
 		LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer);
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
 	int r;
 
-	usbi_dbg("transfer %p", transfer );
+	usbi_dbg(ctx, "transfer %p", transfer );
 	usbi_mutex_lock(&itransfer->lock);
 	if (!(itransfer->state_flags & USBI_TRANSFER_IN_FLIGHT)
 			|| (itransfer->state_flags & USBI_TRANSFER_CANCELLING)) {
@@ -1592,10 +1620,9 @@ int API_EXPORTED libusb_cancel_transfer(struct libusb_transfer *transfer)
 	if (r < 0) {
 		if (r != LIBUSB_ERROR_NOT_FOUND &&
 		    r != LIBUSB_ERROR_NO_DEVICE)
-			usbi_err(TRANSFER_CTX(transfer),
-				"cancel transfer failed error %d", r);
+			usbi_err(ctx, "cancel transfer failed error %d", r);
 		else
-			usbi_dbg("cancel transfer failed error %d", r);
+			usbi_dbg(ctx, "cancel transfer failed error %d", r);
 
 		if (r == LIBUSB_ERROR_NO_DEVICE)
 			itransfer->state_flags |= USBI_TRANSFER_DEVICE_DISAPPEARED;
@@ -1658,13 +1685,13 @@ int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
 {
 	struct libusb_transfer *transfer =
 		USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	struct libusb_device_handle *dev_handle = transfer->dev_handle;
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
 	uint8_t flags;
 	int r;
 
 	r = remove_from_flying_list(itransfer);
 	if (r < 0)
-		usbi_err(ITRANSFER_CTX(itransfer), "failed to set timer for next timeout, errno=%d", errno);
+		usbi_err(ctx, "failed to set timer for next timeout");
 
 	usbi_mutex_lock(&itransfer->lock);
 	itransfer->state_flags &= ~USBI_TRANSFER_IN_FLIGHT;
@@ -1676,7 +1703,7 @@ int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
 		if (transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL)
 			rqlen -= LIBUSB_CONTROL_SETUP_SIZE;
 		if (rqlen != itransfer->transferred) {
-			usbi_dbg("interpreting short transfer as error");
+			usbi_dbg(ctx, "interpreting short transfer as error");
 			status = LIBUSB_TRANSFER_ERROR;
 		}
 	}
@@ -1684,14 +1711,13 @@ int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
 	flags = transfer->flags;
 	transfer->status = status;
 	transfer->actual_length = itransfer->transferred;
-	usbi_dbg("transfer %p has callback %p", transfer, transfer->callback);
+	usbi_dbg(ctx, "transfer %p has callback %p", transfer, transfer->callback);
 	if (transfer->callback)
 		transfer->callback(transfer);
 	/* transfer might have been freed by the above call, do not use from
 	 * this point. */
 	if (flags & LIBUSB_TRANSFER_FREE_TRANSFER)
 		libusb_free_transfer(transfer);
-	libusb_unref_device(dev_handle->dev);
 	return r;
 }
 
@@ -1701,41 +1727,42 @@ int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
  * Do not call this function with the usbi_transfer lock held. User-specified
  * callback functions may attempt to directly resubmit the transfer, which
  * will attempt to take the lock. */
-int usbi_handle_transfer_cancellation(struct usbi_transfer *transfer)
+int usbi_handle_transfer_cancellation(struct usbi_transfer *itransfer)
 {
-	struct libusb_context *ctx = ITRANSFER_CTX(transfer);
+	struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
 	uint8_t timed_out;
 
 	usbi_mutex_lock(&ctx->flying_transfers_lock);
-	timed_out = transfer->timeout_flags & USBI_TRANSFER_TIMED_OUT;
+	timed_out = itransfer->timeout_flags & USBI_TRANSFER_TIMED_OUT;
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
 
 	/* if the URB was cancelled due to timeout, report timeout to the user */
 	if (timed_out) {
-		usbi_dbg("detected timeout cancellation");
-		return usbi_handle_transfer_completion(transfer, LIBUSB_TRANSFER_TIMED_OUT);
+		usbi_dbg(ctx, "detected timeout cancellation");
+		return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_TIMED_OUT);
 	}
 
 	/* otherwise its a normal async cancel */
-	return usbi_handle_transfer_completion(transfer, LIBUSB_TRANSFER_CANCELLED);
+	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_CANCELLED);
 }
 
 /* Add a completed transfer to the completed_transfers list of the
  * context and signal the event. The backend's handle_transfer_completion()
  * function will be called the next time an event handler runs. */
-void usbi_signal_transfer_completion(struct usbi_transfer *transfer)
+void usbi_signal_transfer_completion(struct usbi_transfer *itransfer)
 {
-	libusb_device_handle *dev_handle = USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer)->dev_handle;
+	struct libusb_device *dev = itransfer->dev;
 
-	if (dev_handle) {
-		struct libusb_context *ctx = HANDLE_CTX(dev_handle);
-		int pending_events;
+	if (dev) {
+		struct libusb_context *ctx = DEVICE_CTX(dev);
+		unsigned int event_flags;
 
 		usbi_mutex_lock(&ctx->event_data_lock);
-		pending_events = usbi_pending_events(ctx);
-		list_add_tail(&transfer->completed_list, &ctx->completed_transfers);
-		if (!pending_events)
-			usbi_signal_event(ctx);
+		event_flags = ctx->event_flags;
+		ctx->event_flags |= USBI_EVENT_TRANSFER_COMPLETED;
+		list_add_tail(&itransfer->completed_list, &ctx->completed_transfers);
+		if (!event_flags)
+			usbi_signal_event(&ctx->event);
 		usbi_mutex_unlock(&ctx->event_data_lock);
 	}
 }
@@ -1763,7 +1790,8 @@ int API_EXPORTED libusb_try_lock_events(libusb_context *ctx)
 {
 	int r;
 	unsigned int ru;
-	USBI_GET_CONTEXT(ctx);
+
+	ctx = usbi_get_context(ctx);
 
 	/* is someone else waiting to close a device? if so, don't let this thread
 	 * start event handling */
@@ -1771,12 +1799,12 @@ int API_EXPORTED libusb_try_lock_events(libusb_context *ctx)
 	ru = ctx->device_close;
 	usbi_mutex_unlock(&ctx->event_data_lock);
 	if (ru) {
-		usbi_dbg("someone else is closing a device");
+		usbi_dbg(ctx, "someone else is closing a device");
 		return 1;
 	}
 
 	r = usbi_mutex_trylock(&ctx->events_lock);
-	if (r)
+	if (!r)
 		return 1;
 
 	ctx->event_handler_active = 1;
@@ -1803,7 +1831,7 @@ int API_EXPORTED libusb_try_lock_events(libusb_context *ctx)
  */
 void API_EXPORTED libusb_lock_events(libusb_context *ctx)
 {
-	USBI_GET_CONTEXT(ctx);
+	ctx = usbi_get_context(ctx);
 	usbi_mutex_lock(&ctx->events_lock);
 	ctx->event_handler_active = 1;
 }
@@ -1818,7 +1846,7 @@ void API_EXPORTED libusb_lock_events(libusb_context *ctx)
  */
 void API_EXPORTED libusb_unlock_events(libusb_context *ctx)
 {
-	USBI_GET_CONTEXT(ctx);
+	ctx = usbi_get_context(ctx);
 	ctx->event_handler_active = 0;
 	usbi_mutex_unlock(&ctx->events_lock);
 
@@ -1854,7 +1882,8 @@ void API_EXPORTED libusb_unlock_events(libusb_context *ctx)
 int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx)
 {
 	unsigned int r;
-	USBI_GET_CONTEXT(ctx);
+
+	ctx = usbi_get_context(ctx);
 
 	/* is someone else waiting to close a device? if so, don't let this thread
 	 * continue event handling */
@@ -1862,7 +1891,7 @@ int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx)
 	r = ctx->device_close;
 	usbi_mutex_unlock(&ctx->event_data_lock);
 	if (r) {
-		usbi_dbg("someone else is closing a device");
+		usbi_dbg(ctx, "someone else is closing a device");
 		return 0;
 	}
 
@@ -1882,7 +1911,8 @@ int API_EXPORTED libusb_event_handling_ok(libusb_context *ctx)
 int API_EXPORTED libusb_event_handler_active(libusb_context *ctx)
 {
 	unsigned int r;
-	USBI_GET_CONTEXT(ctx);
+
+	ctx = usbi_get_context(ctx);
 
 	/* is someone else waiting to close a device? if so, don't let this thread
 	 * start event handling -- indicate that event handling is happening */
@@ -1890,7 +1920,7 @@ int API_EXPORTED libusb_event_handler_active(libusb_context *ctx)
 	r = ctx->device_close;
 	usbi_mutex_unlock(&ctx->event_data_lock);
 	if (r) {
-		usbi_dbg("someone else is closing a device");
+		usbi_dbg(ctx, "someone else is closing a device");
 		return 1;
 	}
 
@@ -1909,16 +1939,17 @@ int API_EXPORTED libusb_event_handler_active(libusb_context *ctx)
  */
 void API_EXPORTED libusb_interrupt_event_handler(libusb_context *ctx)
 {
-	int pending_events;
-	USBI_GET_CONTEXT(ctx);
+	unsigned int event_flags;
+
+	usbi_dbg(ctx, " ");
 
-	usbi_dbg("");
+	ctx = usbi_get_context(ctx);
 	usbi_mutex_lock(&ctx->event_data_lock);
 
-	pending_events = usbi_pending_events(ctx);
+	event_flags = ctx->event_flags;
 	ctx->event_flags |= USBI_EVENT_USER_INTERRUPT;
-	if (!pending_events)
-		usbi_signal_event(ctx);
+	if (!event_flags)
+		usbi_signal_event(&ctx->event);
 
 	usbi_mutex_unlock(&ctx->event_data_lock);
 }
@@ -1934,7 +1965,7 @@ void API_EXPORTED libusb_interrupt_event_handler(libusb_context *ctx)
  *
  * You only need to use this lock if you are developing an application
  * which calls poll() or select() on libusb's file descriptors directly,
- * <b>and</b> may potentially be handling events from 2 threads simultaenously.
+ * <b>and</b> may potentially be handling events from 2 threads simultaneously.
  * If you stick to libusb's event handling loop functions (e.g.
  * libusb_handle_events()) then you do not need to be concerned with this
  * locking.
@@ -1944,7 +1975,7 @@ void API_EXPORTED libusb_interrupt_event_handler(libusb_context *ctx)
  */
 void API_EXPORTED libusb_lock_event_waiters(libusb_context *ctx)
 {
-	USBI_GET_CONTEXT(ctx);
+	ctx = usbi_get_context(ctx);
 	usbi_mutex_lock(&ctx->event_waiters_lock);
 }
 
@@ -1955,7 +1986,7 @@ void API_EXPORTED libusb_lock_event_waiters(libusb_context *ctx)
  */
 void API_EXPORTED libusb_unlock_event_waiters(libusb_context *ctx)
 {
-	USBI_GET_CONTEXT(ctx);
+	ctx = usbi_get_context(ctx);
 	usbi_mutex_unlock(&ctx->event_waiters_lock);
 }
 
@@ -1982,25 +2013,28 @@ void API_EXPORTED libusb_unlock_event_waiters(libusb_context *ctx)
  * indicates unlimited timeout.
  * \returns 0 after a transfer completes or another thread stops event handling
  * \returns 1 if the timeout expired
+ * \returns LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
  * \ref libusb_mtasync
  */
 int API_EXPORTED libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
 {
 	int r;
 
-	USBI_GET_CONTEXT(ctx);
-	if (tv == NULL) {
+	ctx = usbi_get_context(ctx);
+	if (!tv) {
 		usbi_cond_wait(&ctx->event_waiters_cond, &ctx->event_waiters_lock);
 		return 0;
 	}
 
+	if (!TIMEVAL_IS_VALID(tv))
+		return LIBUSB_ERROR_INVALID_PARAM;
+
 	r = usbi_cond_timedwait(&ctx->event_waiters_cond,
 		&ctx->event_waiters_lock, tv);
-
 	if (r < 0)
-		return r;
-	else
-		return (r == ETIMEDOUT);
+		return r == LIBUSB_ERROR_TIMEOUT;
+
+	return 0;
 }
 
 static void handle_timeout(struct usbi_transfer *itransfer)
@@ -2015,78 +2049,146 @@ static void handle_timeout(struct usbi_transfer *itransfer)
 		itransfer->timeout_flags |= USBI_TRANSFER_TIMED_OUT;
 	else
 		usbi_warn(TRANSFER_CTX(transfer),
-			"async cancel failed %d errno=%d", r, errno);
+			"async cancel failed %d", r);
 }
 
-static int handle_timeouts_locked(struct libusb_context *ctx)
+static void handle_timeouts_locked(struct libusb_context *ctx)
 {
-	int r;
-	struct timespec systime_ts;
-	struct timeval systime;
-	struct usbi_transfer *transfer;
+	struct timespec systime;
+	struct usbi_transfer *itransfer;
 
 	if (list_empty(&ctx->flying_transfers))
-		return 0;
+		return;
 
 	/* get current time */
-	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &systime_ts);
-	if (r < 0)
-		return r;
-
-	TIMESPEC_TO_TIMEVAL(&systime, &systime_ts);
+	usbi_get_monotonic_time(&systime);
 
 	/* iterate through flying transfers list, finding all transfers that
 	 * have expired timeouts */
-	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
-		struct timeval *cur_tv = &transfer->timeout;
+	for_each_transfer(ctx, itransfer) {
+		struct timespec *cur_ts = &itransfer->timeout;
 
 		/* if we've reached transfers of infinite timeout, we're all done */
-		if (!timerisset(cur_tv))
-			return 0;
+		if (!TIMESPEC_IS_SET(cur_ts))
+			return;
 
 		/* ignore timeouts we've already handled */
-		if (transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+		if (itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
 			continue;
 
 		/* if transfer has non-expired timeout, nothing more to do */
-		if ((cur_tv->tv_sec > systime.tv_sec) ||
-				(cur_tv->tv_sec == systime.tv_sec &&
-					cur_tv->tv_usec > systime.tv_usec))
-			return 0;
+		if (TIMESPEC_CMP(cur_ts, &systime, >))
+			return;
 
 		/* otherwise, we've got an expired timeout to handle */
-		handle_timeout(transfer);
+		handle_timeout(itransfer);
 	}
-	return 0;
 }
 
-static int handle_timeouts(struct libusb_context *ctx)
+static void handle_timeouts(struct libusb_context *ctx)
 {
-	int r;
-	USBI_GET_CONTEXT(ctx);
+	ctx = usbi_get_context(ctx);
 	usbi_mutex_lock(&ctx->flying_transfers_lock);
-	r = handle_timeouts_locked(ctx);
+	handle_timeouts_locked(ctx);
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+}
+
+static int handle_event_trigger(struct libusb_context *ctx)
+{
+	struct list_head hotplug_msgs;
+	int hotplug_event = 0;
+	int r = 0;
+
+	usbi_dbg(ctx, "event triggered");
+
+	list_init(&hotplug_msgs);
+
+	/* take the the event data lock while processing events */
+	usbi_mutex_lock(&ctx->event_data_lock);
+
+	/* check if someone modified the event sources */
+	if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED)
+		usbi_dbg(ctx, "someone updated the event sources");
+
+	if (ctx->event_flags & USBI_EVENT_USER_INTERRUPT) {
+		usbi_dbg(ctx, "someone purposefully interrupted");
+		ctx->event_flags &= ~USBI_EVENT_USER_INTERRUPT;
+	}
+
+	if (ctx->event_flags & USBI_EVENT_HOTPLUG_CB_DEREGISTERED) {
+		usbi_dbg(ctx, "someone unregistered a hotplug cb");
+		ctx->event_flags &= ~USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
+		hotplug_event = 1;
+	}
+
+	/* check if someone is closing a device */
+	if (ctx->event_flags & USBI_EVENT_DEVICE_CLOSE)
+		usbi_dbg(ctx, "someone is closing a device");
+
+	/* check for any pending hotplug messages */
+	if (ctx->event_flags & USBI_EVENT_HOTPLUG_MSG_PENDING) {
+		usbi_dbg(ctx, "hotplug message received");
+		ctx->event_flags &= ~USBI_EVENT_HOTPLUG_MSG_PENDING;
+		hotplug_event = 1;
+		assert(!list_empty(&ctx->hotplug_msgs));
+		list_cut(&hotplug_msgs, &ctx->hotplug_msgs);
+	}
+
+	/* complete any pending transfers */
+	if (ctx->event_flags & USBI_EVENT_TRANSFER_COMPLETED) {
+		struct usbi_transfer *itransfer, *tmp;
+		struct list_head completed_transfers;
+
+		assert(!list_empty(&ctx->completed_transfers));
+		list_cut(&completed_transfers, &ctx->completed_transfers);
+		usbi_mutex_unlock(&ctx->event_data_lock);
+
+		__for_each_completed_transfer_safe(&completed_transfers, itransfer, tmp) {
+			list_del(&itransfer->completed_list);
+			r = usbi_backend.handle_transfer_completion(itransfer);
+			if (r) {
+				usbi_err(ctx, "backend handle_transfer_completion failed with error %d", r);
+				break;
+			}
+		}
+
+		usbi_mutex_lock(&ctx->event_data_lock);
+		if (!list_empty(&completed_transfers)) {
+			/* an error occurred, put the remaining transfers back on the list */
+			list_splice_front(&completed_transfers, &ctx->completed_transfers);
+		} else if (list_empty(&ctx->completed_transfers)) {
+			ctx->event_flags &= ~USBI_EVENT_TRANSFER_COMPLETED;
+		}
+	}
+
+	/* if no further pending events, clear the event */
+	if (!ctx->event_flags)
+		usbi_clear_event(&ctx->event);
+
+	usbi_mutex_unlock(&ctx->event_data_lock);
+
+	/* process the hotplug events, if any */
+	if (hotplug_event)
+		usbi_hotplug_process(ctx, &hotplug_msgs);
+
 	return r;
 }
 
-#ifdef USBI_TIMERFD_AVAILABLE
-static int handle_timerfd_trigger(struct libusb_context *ctx)
+#ifdef HAVE_OS_TIMER
+static int handle_timer_trigger(struct libusb_context *ctx)
 {
 	int r;
 
 	usbi_mutex_lock(&ctx->flying_transfers_lock);
 
 	/* process the timeout that just happened */
-	r = handle_timeouts_locked(ctx);
-	if (r < 0)
-		goto out;
+	handle_timeouts_locked(ctx);
 
-	/* arm for next timeout*/
-	r = arm_timerfd_for_next_timeout(ctx);
+	/* arm for next timeout */
+	r = arm_timer_for_next_timeout(ctx);
 
-out:
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
+
 	return r;
 }
 #endif
@@ -2095,81 +2197,38 @@ out:
  * doing the same thing. */
 static int handle_events(struct libusb_context *ctx, struct timeval *tv)
 {
-	int r;
-	struct usbi_pollfd *ipollfd;
-	POLL_NFDS_TYPE nfds = 0;
-	POLL_NFDS_TYPE internal_nfds;
-	struct pollfd *fds = NULL;
-	int i = -1;
-	int timeout_ms;
+	struct usbi_reported_events reported_events;
+	int r, timeout_ms;
 
 	/* prevent attempts to recursively handle events (e.g. calling into
 	 * libusb_handle_events() from within a hotplug or transfer callback) */
-	usbi_mutex_lock(&ctx->event_data_lock);
-	r = 0;
 	if (usbi_handling_events(ctx))
-		r = LIBUSB_ERROR_BUSY;
-	else
-		usbi_start_event_handling(ctx);
-	usbi_mutex_unlock(&ctx->event_data_lock);
-
-	if (r)
-		return r;
-
-	/* there are certain fds that libusb uses internally, currently:
-	 *
-	 *   1) event pipe
-	 *   2) timerfd
-	 *
-	 * the backend will never need to attempt to handle events on these fds, so
-	 * we determine how many fds are in use internally for this context and when
-	 * handle_events() is called in the backend, the pollfd list and count will
-	 * be adjusted to skip over these internal fds */
-	if (usbi_using_timerfd(ctx))
-		internal_nfds = 2;
-	else
-		internal_nfds = 1;
+		return LIBUSB_ERROR_BUSY;
 
-	/* only reallocate the poll fds when the list of poll fds has been modified
-	 * since the last poll, otherwise reuse them to save the additional overhead */
+	/* only reallocate the event source data when the list of event sources has
+	 * been modified since the last handle_events(), otherwise reuse them to
+	 * save the additional overhead */
 	usbi_mutex_lock(&ctx->event_data_lock);
-	/* clean up removed poll fds */
-	cleanup_removed_pollfds(ctx);
-	if (ctx->event_flags & USBI_EVENT_POLLFDS_MODIFIED) {
-		usbi_dbg("poll fds modified, reallocating");
+	if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
+		usbi_dbg(ctx, "event sources modified, reallocating event data");
 
-		free(ctx->pollfds);
-		ctx->pollfds = NULL;
+		/* free anything removed since we last ran */
+		cleanup_removed_event_sources(ctx);
 
-		/* sanity check - it is invalid for a context to have fewer than the
-		 * required internal fds (memory corruption?) */
-		assert(ctx->pollfds_cnt >= internal_nfds);
-
-		ctx->pollfds = calloc(ctx->pollfds_cnt, sizeof(*ctx->pollfds));
-		if (!ctx->pollfds) {
+		r = usbi_alloc_event_data(ctx);
+		if (r) {
 			usbi_mutex_unlock(&ctx->event_data_lock);
-			r = LIBUSB_ERROR_NO_MEM;
-			goto done;
-		}
-
-		list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd) {
-			struct libusb_pollfd *pollfd = &ipollfd->pollfd;
-			i++;
-			ctx->pollfds[i].fd = pollfd->fd;
-			ctx->pollfds[i].events = pollfd->events;
+			return r;
 		}
 
 		/* reset the flag now that we have the updated list */
-		ctx->event_flags &= ~USBI_EVENT_POLLFDS_MODIFIED;
+		ctx->event_flags &= ~USBI_EVENT_EVENT_SOURCES_MODIFIED;
 
-		/* if no further pending events, clear the event pipe so that we do
-		 * not immediately return from poll */
-		if (!usbi_pending_events(ctx))
-			usbi_clear_event(ctx);
+		/* if no further pending events, clear the event so that we do
+		 * not immediately return from the wait function */
+		if (!ctx->event_flags)
+			usbi_clear_event(&ctx->event);
 	}
-	fds = ctx->pollfds;
-	nfds = ctx->pollfds_cnt;
-	usbi_inc_fds_ref(fds, nfds);
 	usbi_mutex_unlock(&ctx->event_data_lock);
 
 	timeout_ms = (int)(tv->tv_sec * 1000) + (tv->tv_usec / 1000);
@@ -2178,145 +2237,47 @@ static int handle_events(struct libusb_context *ctx, struct timeval *tv)
 	if (tv->tv_usec % 1000)
 		timeout_ms++;
 
-	usbi_dbg("poll() %d fds with timeout in %dms", (int)nfds, timeout_ms);
-	r = usbi_poll(fds, nfds, timeout_ms);
-	usbi_dbg("poll() returned %d", r);
-	if (r == 0) {
-		r = handle_timeouts(ctx);
-		goto done;
-	} else if (r == -1 && errno == EINTR) {
-		r = LIBUSB_ERROR_INTERRUPTED;
-		goto done;
-	} else if (r < 0) {
-		usbi_err(ctx, "poll failed %d err=%d", r, errno);
-		r = LIBUSB_ERROR_IO;
-		goto done;
-	}
-
-	/* fds[0] is always the event pipe */
-	if (fds[0].revents) {
-		struct list_head hotplug_msgs;
-		struct usbi_transfer *itransfer;
-		int hotplug_cb_deregistered = 0;
-		int ret = 0;
-
-		list_init(&hotplug_msgs);
-
-		usbi_dbg("caught a fish on the event pipe");
-
-		/* take the the event data lock while processing events */
-		usbi_mutex_lock(&ctx->event_data_lock);
-
-		/* check if someone added a new poll fd */
-		if (ctx->event_flags & USBI_EVENT_POLLFDS_MODIFIED)
-			usbi_dbg("someone updated the poll fds");
-
-		if (ctx->event_flags & USBI_EVENT_USER_INTERRUPT) {
-			usbi_dbg("someone purposely interrupted");
-			ctx->event_flags &= ~USBI_EVENT_USER_INTERRUPT;
-		}
-
-		if (ctx->event_flags & USBI_EVENT_HOTPLUG_CB_DEREGISTERED) {
-			usbi_dbg("someone unregistered a hotplug cb");
-			ctx->event_flags &= ~USBI_EVENT_HOTPLUG_CB_DEREGISTERED;
-			hotplug_cb_deregistered = 1;
-		}
-
-		/* check if someone is closing a device */
-		if (ctx->device_close)
-			usbi_dbg("someone is closing a device");
-
-		/* check for any pending hotplug messages */
-		if (!list_empty(&ctx->hotplug_msgs)) {
-			usbi_dbg("hotplug message received");
-			list_cut(&hotplug_msgs, &ctx->hotplug_msgs);
-		}
-
-		/* complete any pending transfers */
-		while (ret == 0 && !list_empty(&ctx->completed_transfers)) {
-			itransfer = list_first_entry(&ctx->completed_transfers, struct usbi_transfer, completed_list);
-			list_del(&itransfer->completed_list);
-			usbi_mutex_unlock(&ctx->event_data_lock);
-			ret = usbi_backend.handle_transfer_completion(itransfer);
-			if (ret)
-				usbi_err(ctx, "backend handle_transfer_completion failed with error %d", ret);
-			usbi_mutex_lock(&ctx->event_data_lock);
-		}
-
-		/* if no further pending events, clear the event pipe */
-		if (!usbi_pending_events(ctx))
-			usbi_clear_event(ctx);
+	reported_events.event_bits = 0;
 
-		usbi_mutex_unlock(&ctx->event_data_lock);
-
-		if (hotplug_cb_deregistered)
-			usbi_hotplug_deregister(ctx, 0);
-
-		/* process the hotplug messages, if any */
-		while (!list_empty(&hotplug_msgs)) {
-			struct libusb_hotplug_message *message =
-				list_first_entry(&hotplug_msgs, struct libusb_hotplug_message, list);
+	usbi_start_event_handling(ctx);
 
-			usbi_hotplug_match(ctx, message->device, message->event);
-
-			/* the device left, dereference the device */
-			if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == message->event)
-				libusb_unref_device(message->device);
-
-			list_del(&message->list);
-			free(message);
+	r = usbi_wait_for_events(ctx, &reported_events, timeout_ms);
+	if (r != LIBUSB_SUCCESS) {
+		if (r == LIBUSB_ERROR_TIMEOUT) {
+			handle_timeouts(ctx);
+			r = LIBUSB_SUCCESS;
 		}
+		goto done;
+	}
 
-		if (ret) {
+	if (reported_events.event_triggered) {
+		r = handle_event_trigger(ctx);
+		if (r) {
 			/* return error code */
-			r = ret;
 			goto done;
 		}
-
-		if (0 == --r)
-			goto done;
 	}
 
-#ifdef USBI_TIMERFD_AVAILABLE
-	/* on timerfd configurations, fds[1] is the timerfd */
-	if (usbi_using_timerfd(ctx) && fds[1].revents) {
-		/* timerfd indicates that a timeout has expired */
-		int ret;
-		usbi_dbg("timerfd triggered");
-
-		ret = handle_timerfd_trigger(ctx);
-		if (ret < 0) {
+#ifdef HAVE_OS_TIMER
+	if (reported_events.timer_triggered) {
+		r = handle_timer_trigger(ctx);
+		if (r) {
 			/* return error code */
-			r = ret;
 			goto done;
 		}
-
-		if (0 == --r)
-			goto done;
 	}
 #endif
 
-	list_for_each_entry(ipollfd, &ctx->removed_ipollfds, list, struct usbi_pollfd) {
-		for (i = internal_nfds ; i < nfds ; ++i) {
-			if (ipollfd->pollfd.fd == fds[i].fd) {
-				/* pollfd was removed between the creation of the fd
-				 * array and here. remove any triggered revent as
-				 * it is no longer relevant */
-				usbi_dbg("pollfd %d was removed. ignoring raised events",
-					 fds[i].fd);
-				fds[i].revents = 0;
-				break;
-			}
-		}
-	}
+	if (!reported_events.num_ready)
+		goto done;
 
-	r = usbi_backend.handle_events(ctx, fds + internal_nfds, nfds - internal_nfds, r);
+	r = usbi_backend.handle_events(ctx, reported_events.event_data,
+		reported_events.event_data_count, reported_events.num_ready);
 	if (r)
 		usbi_err(ctx, "backend handle_events failed with error %d", r);
 
 done:
 	usbi_end_event_handling(ctx);
-	usbi_dec_fds_ref(fds, nfds);
 	return r;
 }
 
@@ -2370,7 +2331,9 @@ static int get_next_timeout(libusb_context *ctx, struct timeval *tv,
  * \param tv the maximum time to block waiting for events, or an all zero
  * timeval struct for non-blocking mode
  * \param completed pointer to completion integer to check, or NULL
- * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
+ * \returns another LIBUSB_ERROR code on other failure
  * \ref libusb_mtasync
  */
 int API_EXPORTED libusb_handle_events_timeout_completed(libusb_context *ctx,
@@ -2379,18 +2342,22 @@ int API_EXPORTED libusb_handle_events_timeout_completed(libusb_context *ctx,
 	int r;
 	struct timeval poll_timeout;
 
-	USBI_GET_CONTEXT(ctx);
+	if (!TIMEVAL_IS_VALID(tv))
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	ctx = usbi_get_context(ctx);
 	r = get_next_timeout(ctx, tv, &poll_timeout);
 	if (r) {
 		/* timeout already expired */
-		return handle_timeouts(ctx);
+		handle_timeouts(ctx);
+		return 0;
 	}
 
 retry:
 	if (libusb_try_lock_events(ctx) == 0) {
 		if (completed == NULL || !*completed) {
 			/* we obtained the event lock: do our own event handling */
-			usbi_dbg("doing our own event handling");
+			usbi_dbg(ctx, "doing our own event handling");
 			r = handle_events(ctx, &poll_timeout);
 		}
 		libusb_unlock_events(ctx);
@@ -2408,11 +2375,11 @@ retry:
 		/* we hit a race: whoever was event handling earlier finished in the
 		 * time it took us to reach this point. try the cycle again. */
 		libusb_unlock_event_waiters(ctx);
-		usbi_dbg("event handler was active but went away, retrying");
+		usbi_dbg(ctx, "event handler was active but went away, retrying");
 		goto retry;
 	}
 
-	usbi_dbg("another thread is doing event handling");
+	usbi_dbg(ctx, "another thread is doing event handling");
 	r = libusb_wait_for_event(ctx, &poll_timeout);
 
 already_done:
@@ -2421,9 +2388,8 @@ already_done:
 	if (r < 0)
 		return r;
 	else if (r == 1)
-		return handle_timeouts(ctx);
-	else
-		return 0;
+		handle_timeouts(ctx);
+	return 0;
 }
 
 /** \ingroup libusb_poll
@@ -2450,7 +2416,7 @@ int API_EXPORTED libusb_handle_events_timeout(libusb_context *ctx,
 
 /** \ingroup libusb_poll
  * Handle any pending events in blocking mode. There is currently a timeout
- * hardcoded at 60 seconds but we plan to make it unlimited in future. For
+ * hard-coded at 60 seconds but we plan to make it unlimited in future. For
  * finer control over whether this function is blocking or non-blocking, or
  * for control over the timeout, use libusb_handle_events_timeout_completed()
  * instead.
@@ -2507,7 +2473,9 @@ int API_EXPORTED libusb_handle_events_completed(libusb_context *ctx,
  * \param ctx the context to operate on, or NULL for the default context
  * \param tv the maximum time to block waiting for events, or zero for
  * non-blocking mode
- * \returns 0 on success, or a LIBUSB_ERROR code on failure
+ * \returns 0 on success
+ * \returns LIBUSB_ERROR_INVALID_PARAM if timeval is invalid
+ * \returns another LIBUSB_ERROR code on other failure
  * \ref libusb_mtasync
  */
 int API_EXPORTED libusb_handle_events_locked(libusb_context *ctx,
@@ -2516,11 +2484,15 @@ int API_EXPORTED libusb_handle_events_locked(libusb_context *ctx,
 	int r;
 	struct timeval poll_timeout;
 
-	USBI_GET_CONTEXT(ctx);
+	if (!TIMEVAL_IS_VALID(tv))
+		return LIBUSB_ERROR_INVALID_PARAM;
+
+	ctx = usbi_get_context(ctx);
 	r = get_next_timeout(ctx, tv, &poll_timeout);
 	if (r) {
 		/* timeout already expired */
-		return handle_timeouts(ctx);
+		handle_timeouts(ctx);
+		return 0;
 	}
 
 	return handle_events(ctx, &poll_timeout);
@@ -2556,13 +2528,8 @@ int API_EXPORTED libusb_handle_events_locked(libusb_context *ctx,
  */
 int API_EXPORTED libusb_pollfds_handle_timeouts(libusb_context *ctx)
 {
-#if defined(USBI_TIMERFD_AVAILABLE)
-	USBI_GET_CONTEXT(ctx);
-	return usbi_using_timerfd(ctx);
-#else
-	UNUSED(ctx);
-	return 0;
-#endif
+	ctx = usbi_get_context(ctx);
+	return usbi_using_timer(ctx);
 }
 
 /** \ingroup libusb_poll
@@ -2596,55 +2563,49 @@ int API_EXPORTED libusb_pollfds_handle_timeouts(libusb_context *ctx)
 int API_EXPORTED libusb_get_next_timeout(libusb_context *ctx,
 	struct timeval *tv)
 {
-	struct usbi_transfer *transfer;
-	struct timespec cur_ts;
-	struct timeval cur_tv;
-	struct timeval next_timeout = { 0, 0 };
-	int r;
+	struct usbi_transfer *itransfer;
+	struct timespec systime;
+	struct timespec next_timeout = { 0, 0 };
 
-	USBI_GET_CONTEXT(ctx);
-	if (usbi_using_timerfd(ctx))
+	ctx = usbi_get_context(ctx);
+	if (usbi_using_timer(ctx))
 		return 0;
 
 	usbi_mutex_lock(&ctx->flying_transfers_lock);
 	if (list_empty(&ctx->flying_transfers)) {
 		usbi_mutex_unlock(&ctx->flying_transfers_lock);
-		usbi_dbg("no URBs, no timeout!");
+		usbi_dbg(ctx, "no URBs, no timeout!");
 		return 0;
 	}
 
 	/* find next transfer which hasn't already been processed as timed out */
-	list_for_each_entry(transfer, &ctx->flying_transfers, list, struct usbi_transfer) {
-		if (transfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
+	for_each_transfer(ctx, itransfer) {
+		if (itransfer->timeout_flags & (USBI_TRANSFER_TIMEOUT_HANDLED | USBI_TRANSFER_OS_HANDLES_TIMEOUT))
 			continue;
 
-		/* if we've reached transfers of infinte timeout, we're done looking */
-		if (!timerisset(&transfer->timeout))
+		/* if we've reached transfers of infinite timeout, we're done looking */
+		if (!TIMESPEC_IS_SET(&itransfer->timeout))
 			break;
 
-		next_timeout = transfer->timeout;
+		next_timeout = itransfer->timeout;
 		break;
 	}
 	usbi_mutex_unlock(&ctx->flying_transfers_lock);
 
-	if (!timerisset(&next_timeout)) {
-		usbi_dbg("no URB with timeout or all handled by OS; no timeout!");
+	if (!TIMESPEC_IS_SET(&next_timeout)) {
+		usbi_dbg(ctx, "no URB with timeout or all handled by OS; no timeout!");
 		return 0;
 	}
 
-	r = usbi_backend.clock_gettime(USBI_CLOCK_MONOTONIC, &cur_ts);
-	if (r < 0) {
-		usbi_err(ctx, "failed to read monotonic clock, errno=%d", errno);
-		return 0;
-	}
-	TIMESPEC_TO_TIMEVAL(&cur_tv, &cur_ts);
+	usbi_get_monotonic_time(&systime);
 
-	if (!timercmp(&cur_tv, &next_timeout, <)) {
-		usbi_dbg("first timeout already expired");
+	if (!TIMESPEC_CMP(&systime, &next_timeout, <)) {
+		usbi_dbg(ctx, "first timeout already expired");
 		timerclear(tv);
 	} else {
-		timersub(&next_timeout, &cur_tv, tv);
-		usbi_dbg("next timeout in %ld.%06lds", (long)tv->tv_sec, (long)tv->tv_usec);
+		TIMESPEC_SUB(&next_timeout, &systime, &next_timeout);
+		TIMESPEC_TO_TIMEVAL(tv, &next_timeout);
+		usbi_dbg(ctx, "next timeout in %ld.%06lds", (long)tv->tv_sec, (long)tv->tv_usec);
 	}
 
 	return 1;
@@ -2675,79 +2636,92 @@ void API_EXPORTED libusb_set_pollfd_notifiers(libusb_context *ctx,
 	libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
 	void *user_data)
 {
-	USBI_GET_CONTEXT(ctx);
+#if !defined(PLATFORM_WINDOWS)
+	ctx = usbi_get_context(ctx);
 	ctx->fd_added_cb = added_cb;
 	ctx->fd_removed_cb = removed_cb;
 	ctx->fd_cb_user_data = user_data;
+#else
+	usbi_err(ctx, "external polling of libusb's internal event sources " \
+		"is not yet supported on Windows");
+	UNUSED(added_cb);
+	UNUSED(removed_cb);
+	UNUSED(user_data);
+#endif
 }
 
 /*
  * Interrupt the iteration of the event handling thread, so that it picks
- * up the fd change. Callers of this function must hold the event_data_lock.
+ * up the event source change. Callers of this function must hold the event_data_lock.
  */
-static void usbi_fd_notification(struct libusb_context *ctx)
+static void usbi_event_source_notification(struct libusb_context *ctx)
 {
-	int pending_events;
+	unsigned int event_flags;
 
 	/* Record that there is a new poll fd.
 	 * Only signal an event if there are no prior pending events. */
-	pending_events = usbi_pending_events(ctx);
-	ctx->event_flags |= USBI_EVENT_POLLFDS_MODIFIED;
-	if (!pending_events)
-		usbi_signal_event(ctx);
+	event_flags = ctx->event_flags;
+	ctx->event_flags |= USBI_EVENT_EVENT_SOURCES_MODIFIED;
+	if (!event_flags)
+		usbi_signal_event(&ctx->event);
 }
 
-/* Add a file descriptor to the list of file descriptors to be monitored.
- * events should be specified as a bitmask of events passed to poll(), e.g.
+/* Add an event source to the list of event sources to be monitored.
+ * poll_events should be specified as a bitmask of events passed to poll(), e.g.
  * POLLIN and/or POLLOUT. */
-int usbi_add_pollfd(struct libusb_context *ctx, int fd, short events)
+int usbi_add_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle, short poll_events)
 {
-	struct usbi_pollfd *ipollfd = malloc(sizeof(*ipollfd));
-	if (!ipollfd)
+	struct usbi_event_source *ievent_source = malloc(sizeof(*ievent_source));
+
+	if (!ievent_source)
 		return LIBUSB_ERROR_NO_MEM;
 
-	usbi_dbg("add fd %d events %d", fd, events);
-	ipollfd->pollfd.fd = fd;
-	ipollfd->pollfd.events = events;
+	usbi_dbg(ctx, "add " USBI_OS_HANDLE_FORMAT_STRING " events %d", os_handle, poll_events);
+	ievent_source->data.os_handle = os_handle;
+	ievent_source->data.poll_events = poll_events;
 	usbi_mutex_lock(&ctx->event_data_lock);
-	list_add_tail(&ipollfd->list, &ctx->ipollfds);
-	ctx->pollfds_cnt++;
-	usbi_fd_notification(ctx);
+	list_add_tail(&ievent_source->list, &ctx->event_sources);
+	usbi_event_source_notification(ctx);
 	usbi_mutex_unlock(&ctx->event_data_lock);
 
+#if !defined(PLATFORM_WINDOWS)
 	if (ctx->fd_added_cb)
-		ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data);
+		ctx->fd_added_cb(os_handle, poll_events, ctx->fd_cb_user_data);
+#endif
+
 	return 0;
 }
 
-/* Remove a file descriptor from the list of file descriptors to be polled. */
-void usbi_remove_pollfd(struct libusb_context *ctx, int fd)
+/* Remove an event source from the list of event sources to be monitored. */
+void usbi_remove_event_source(struct libusb_context *ctx, usbi_os_handle_t os_handle)
 {
-	struct usbi_pollfd *ipollfd;
+	struct usbi_event_source *ievent_source;
 	int found = 0;
 
-	usbi_dbg("remove fd %d", fd);
+	usbi_dbg(ctx, "remove " USBI_OS_HANDLE_FORMAT_STRING, os_handle);
 	usbi_mutex_lock(&ctx->event_data_lock);
-	list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd)
-		if (ipollfd->pollfd.fd == fd) {
+	for_each_event_source(ctx, ievent_source) {
+		if (ievent_source->data.os_handle == os_handle) {
 			found = 1;
 			break;
 		}
+	}
 
 	if (!found) {
-		usbi_dbg("couldn't find fd %d to remove", fd);
+		usbi_dbg(ctx, "couldn't find " USBI_OS_HANDLE_FORMAT_STRING " to remove", os_handle);
 		usbi_mutex_unlock(&ctx->event_data_lock);
 		return;
 	}
 
-	list_del(&ipollfd->list);
-	list_add_tail(&ipollfd->list, &ctx->removed_ipollfds);
-	ctx->pollfds_cnt--;
-	usbi_fd_notification(ctx);
+	list_del(&ievent_source->list);
+	list_add_tail(&ievent_source->list, &ctx->removed_event_sources);
+	usbi_event_source_notification(ctx);
 	usbi_mutex_unlock(&ctx->event_data_lock);
 
+#if !defined(PLATFORM_WINDOWS)
 	if (ctx->fd_removed_cb)
-		ctx->fd_removed_cb(fd, ctx->fd_cb_user_data);
+		ctx->fd_removed_cb(os_handle, ctx->fd_cb_user_data);
+#endif
 }
 
 /** \ingroup libusb_poll
@@ -2769,28 +2743,36 @@ DEFAULT_VISIBILITY
 const struct libusb_pollfd ** LIBUSB_CALL libusb_get_pollfds(
 	libusb_context *ctx)
 {
-#ifndef OS_WINDOWS
+#if !defined(PLATFORM_WINDOWS)
 	struct libusb_pollfd **ret = NULL;
-	struct usbi_pollfd *ipollfd;
-	size_t i = 0;
-	USBI_GET_CONTEXT(ctx);
+	struct usbi_event_source *ievent_source;
+	size_t i;
+
+	static_assert(sizeof(struct usbi_event_source_data) == sizeof(struct libusb_pollfd),
+		      "mismatch between usbi_event_source_data and libusb_pollfd sizes");
+
+	ctx = usbi_get_context(ctx);
 
 	usbi_mutex_lock(&ctx->event_data_lock);
 
-	ret = calloc(ctx->pollfds_cnt + 1, sizeof(struct libusb_pollfd *));
+	i = 0;
+	for_each_event_source(ctx, ievent_source)
+		i++;
+
+	ret = calloc(i + 1, sizeof(struct libusb_pollfd *));
 	if (!ret)
 		goto out;
 
-	list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd)
-		ret[i++] = (struct libusb_pollfd *) ipollfd;
-	ret[ctx->pollfds_cnt] = NULL;
+	i = 0;
+	for_each_event_source(ctx, ievent_source)
+		ret[i++] = (struct libusb_pollfd *)ievent_source;
 
 out:
 	usbi_mutex_unlock(&ctx->event_data_lock);
-	return (const struct libusb_pollfd **) ret;
+	return (const struct libusb_pollfd **)ret;
 #else
-	usbi_err(ctx, "external polling of libusb's internal descriptors "\
-		"is not yet supported on Windows platforms");
+	usbi_err(ctx, "external polling of libusb's internal event sources " \
+		"is not yet supported on Windows");
 	return NULL;
 #endif
 }
@@ -2808,7 +2790,11 @@ out:
  */
 void API_EXPORTED libusb_free_pollfds(const struct libusb_pollfd **pollfds)
 {
+#if !defined(PLATFORM_WINDOWS)
 	free((void *)pollfds);
+#else
+	UNUSED(pollfds);
+#endif
 }
 
 /* Backends may call this from handle_events to report disconnection of a
@@ -2817,10 +2803,11 @@ void API_EXPORTED libusb_free_pollfds(const struct libusb_pollfd **pollfds)
  */
 void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
 {
+	struct libusb_context *ctx = HANDLE_CTX(dev_handle);
 	struct usbi_transfer *cur;
 	struct usbi_transfer *to_cancel;
 
-	usbi_dbg("device %d.%d",
+	usbi_dbg(ctx, "device %d.%d",
 		dev_handle->dev->bus_number, dev_handle->dev->device_address);
 
 	/* terminate all pending transfers with the LIBUSB_TRANSFER_NO_DEVICE
@@ -2838,8 +2825,8 @@ void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
 
 	while (1) {
 		to_cancel = NULL;
-		usbi_mutex_lock(&HANDLE_CTX(dev_handle)->flying_transfers_lock);
-		list_for_each_entry(cur, &HANDLE_CTX(dev_handle)->flying_transfers, list, struct usbi_transfer)
+		usbi_mutex_lock(&ctx->flying_transfers_lock);
+		for_each_transfer(ctx, cur) {
 			if (USBI_TRANSFER_TO_LIBUSB_TRANSFER(cur)->dev_handle == dev_handle) {
 				usbi_mutex_lock(&cur->lock);
 				if (cur->state_flags & USBI_TRANSFER_IN_FLIGHT)
@@ -2849,12 +2836,13 @@ void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
 				if (to_cancel)
 					break;
 			}
-		usbi_mutex_unlock(&HANDLE_CTX(dev_handle)->flying_transfers_lock);
+		}
+		usbi_mutex_unlock(&ctx->flying_transfers_lock);
 
 		if (!to_cancel)
 			break;
 
-		usbi_dbg("cancelling transfer %p from disconnect",
+		usbi_dbg(ctx, "cancelling transfer %p from disconnect",
 			 USBI_TRANSFER_TO_LIBUSB_TRANSFER(to_cancel));
 
 		usbi_mutex_lock(&to_cancel->lock);
@@ -2862,5 +2850,4 @@ void usbi_handle_disconnect(struct libusb_device_handle *dev_handle)
 		usbi_mutex_unlock(&to_cancel->lock);
 		usbi_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE);
 	}
-
 }