usb 2.1.1 → 2.2.0

package/libusb/libusb/os/haiku_usb_raw.cpp

@@ -30,11 +30,12 @@ USBRoster gUsbRoster;
 int32 gInitCount = 0;
 
 static int haiku_get_config_descriptor(struct libusb_device *, uint8_t,
-    unsigned char *, size_t, int *);
+    void *, size_t);
 
 static int
 haiku_init(struct libusb_context *ctx)
 {
+	UNUSED(ctx);
 	if (atomic_add(&gInitCount, 1) == 0)
 		return gUsbRoster.Start();
 	return LIBUSB_SUCCESS;
@@ -51,7 +52,7 @@ haiku_exit(struct libusb_context *ctx)
 static int
 haiku_open(struct libusb_device_handle *dev_handle)
 {
-	USBDevice *dev = *((USBDevice **)dev_handle->dev->os_priv);
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(dev_handle->dev));
 	USBDeviceHandle *handle = new(std::nothrow) USBDeviceHandle(dev);
 	if (handle == NULL)
 		return LIBUSB_ERROR_NO_MEM;
@@ -59,93 +60,79 @@ haiku_open(struct libusb_device_handle *dev_handle)
 		delete handle;
 		return LIBUSB_ERROR_NO_DEVICE;
 	}
-	*((USBDeviceHandle **)dev_handle->os_priv) = handle;
+	*((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle)) = handle;
 	return LIBUSB_SUCCESS;
 }
 
 static void
 haiku_close(struct libusb_device_handle *dev_handle)
 {
-	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	USBDeviceHandle **pHandle = (USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle);
+	USBDeviceHandle *handle = *pHandle;
 	if (handle == NULL)
 		return;
 	delete handle;
-	*((USBDeviceHandle **)dev_handle->os_priv) = NULL;
-}
-
-static int
-haiku_get_device_descriptor(struct libusb_device *device, unsigned char *buffer, int *host_endian)
-{
-	USBDevice *dev = *((USBDevice **)device->os_priv);
-	memcpy(buffer, dev->Descriptor(), DEVICE_DESC_LENGTH);
-	*host_endian = 0;
-	return LIBUSB_SUCCESS;
+	*pHandle = NULL;
 }
 
 static int
-haiku_get_active_config_descriptor(struct libusb_device *device, unsigned char *buffer, size_t len, int *host_endian)
+haiku_get_active_config_descriptor(struct libusb_device *device, void *buffer, size_t len)
 {
-	USBDevice *dev = *((USBDevice **)device->os_priv);
-	return haiku_get_config_descriptor(device, dev->ActiveConfigurationIndex(), buffer, len, host_endian);
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
+	return haiku_get_config_descriptor(device, dev->ActiveConfigurationIndex(), buffer, len);
 }
 
 static int
-haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
+haiku_get_config_descriptor(struct libusb_device *device, uint8_t config_index, void *buffer, size_t len)
 {
-	USBDevice *dev = *((USBDevice **)device->os_priv);
+	USBDevice *dev = *((USBDevice **)usbi_get_device_priv(device));
 	const usb_configuration_descriptor *config = dev->ConfigurationDescriptor(config_index);
 	if (config == NULL) {
 		usbi_err(DEVICE_CTX(device), "failed getting configuration descriptor");
-		return LIBUSB_ERROR_INVALID_PARAM;
+		return LIBUSB_ERROR_IO;
 	}
 	if (len > config->total_length) {
 		len = config->total_length;
 	}
 	memcpy(buffer, config, len);
-	*host_endian = 0;
 	return len;
 }
 
 static int
 haiku_set_configuration(struct libusb_device_handle *dev_handle, int config)
 {
-	USBDeviceHandle *handle= *((USBDeviceHandle **)dev_handle->os_priv);
-	return handle->SetConfiguration(config);
+	USBDeviceHandle *handle= *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	if (config <= 0)
+		return LIBUSB_ERROR_NOT_SUPPORTED;	// cannot unconfigure
+	return handle->SetConfiguration((uint8)config);
 }
 
 static int
-haiku_claim_interface(struct libusb_device_handle *dev_handle, int interface_number)
+haiku_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 {
-	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
 	return handle->ClaimInterface(interface_number);
 }
 
 static int
-haiku_set_altsetting(struct libusb_device_handle *dev_handle, int interface_number, int altsetting)
+haiku_set_altsetting(struct libusb_device_handle *dev_handle, uint8_t interface_number, uint8_t altsetting)
 {
-	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
 	return handle->SetAltSetting(interface_number, altsetting);
 }
 
 static int
 haiku_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
 {
-	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
 	return handle->ClearHalt(endpoint);
 }
 
 static int
-haiku_reset_device(struct libusb_device_handle *dev_handle)
-{
-	/* TODO */
-	return LIBUSB_ERROR_NOT_SUPPORTED;
-}
-
-static int
-haiku_release_interface(struct libusb_device_handle *dev_handle, int interface_number)
+haiku_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 {
-	USBDeviceHandle *handle = *((USBDeviceHandle **)dev_handle->os_priv);
-	haiku_set_altsetting(dev_handle,interface_number, 0);
+	USBDeviceHandle *handle = *((USBDeviceHandle **)usbi_get_device_handle_priv(dev_handle));
+	haiku_set_altsetting(dev_handle, interface_number, 0);
 	return handle->ReleaseInterface(interface_number);
 }
 
@@ -153,7 +140,7 @@ static int
 haiku_submit_transfer(struct usbi_transfer *itransfer)
 {
 	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)fLibusbTransfer->dev_handle->os_priv);
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
 	return fDeviceHandle->SubmitTransfer(itransfer);
 }
 
@@ -161,27 +148,20 @@ static int
 haiku_cancel_transfer(struct usbi_transfer *itransfer)
 {
 	struct libusb_transfer *fLibusbTransfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)fLibusbTransfer->dev_handle->os_priv);
-	return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)));
-}
-
-static void
-haiku_clear_transfer_priv(struct usbi_transfer *itransfer)
-{
-	USBTransfer *transfer = *((USBTransfer **)usbi_transfer_get_os_priv(itransfer));
-	delete transfer;
-	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+	USBDeviceHandle *fDeviceHandle = *((USBDeviceHandle **)usbi_get_device_handle_priv(fLibusbTransfer->dev_handle));
+	return fDeviceHandle->CancelTransfer(*((USBTransfer **)usbi_get_transfer_priv(itransfer)));
 }
 
 static int
 haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
 {
-	USBTransfer *transfer = *((USBTransfer **)usbi_transfer_get_os_priv(itransfer));
+	USBTransfer **pTransfer = (USBTransfer **)usbi_get_transfer_priv(itransfer);
+	USBTransfer *transfer = *pTransfer;
 
 	usbi_mutex_lock(&itransfer->lock);
 	if (transfer->IsCancelled()) {
 		delete transfer;
-		*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+		*pTransfer = NULL;
 		usbi_mutex_unlock(&itransfer->lock);
 		if (itransfer->transferred < 0)
 			itransfer->transferred = 0;
@@ -194,74 +174,58 @@ haiku_handle_transfer_completion(struct usbi_transfer *itransfer)
 		itransfer->transferred = 0;
 	}
 	delete transfer;
-	*((USBTransfer **)usbi_transfer_get_os_priv(itransfer)) = NULL;
+	*pTransfer = NULL;
 	usbi_mutex_unlock(&itransfer->lock);
 	return usbi_handle_transfer_completion(itransfer, status);
 }
 
-static int
-haiku_clock_gettime(int clkid, struct timespec *tp)
-{
-	if (clkid == USBI_CLOCK_REALTIME)
-		return clock_gettime(CLOCK_REALTIME, tp);
-	if (clkid == USBI_CLOCK_MONOTONIC)
-		return clock_gettime(CLOCK_MONOTONIC, tp);
-	return LIBUSB_ERROR_INVALID_PARAM;
-}
-
 const struct usbi_os_backend usbi_backend = {
-	.name = "Haiku usbfs",
-	.caps = 0,
-	.init = haiku_init,
-	.exit = haiku_exit,
-	.set_option = NULL,
-	.get_device_list = NULL,
-	.hotplug_poll = NULL,
-	.wrap_sys_device = NULL,
-	.open = haiku_open,
-	.close = haiku_close,
-	.get_device_descriptor = haiku_get_device_descriptor,
-	.get_active_config_descriptor = haiku_get_active_config_descriptor,
-	.get_config_descriptor = haiku_get_config_descriptor,
-	.get_config_descriptor_by_value = NULL,
-
-
-	.get_configuration = NULL,
-	.set_configuration = haiku_set_configuration,
-	.claim_interface = haiku_claim_interface,
-	.release_interface = haiku_release_interface,
-
-	.set_interface_altsetting = haiku_set_altsetting,
-	.clear_halt = haiku_clear_halt,
-	.reset_device = haiku_reset_device,
-
-	.alloc_streams = NULL,
-	.free_streams = NULL,
-
-	.dev_mem_alloc = NULL,
-	.dev_mem_free = NULL,
-
-	.kernel_driver_active = NULL,
-	.detach_kernel_driver = NULL,
-	.attach_kernel_driver = NULL,
-
-	.destroy_device = NULL,
-
-	.submit_transfer = haiku_submit_transfer,
-	.cancel_transfer = haiku_cancel_transfer,
-	.clear_transfer_priv = haiku_clear_transfer_priv,
-
-	.handle_events = NULL,
-	.handle_transfer_completion = haiku_handle_transfer_completion,
-
-	.clock_gettime = haiku_clock_gettime,
-
-#ifdef USBI_TIMERFD_AVAILABLE
-	.get_timerfd_clockid = NULL,
-#endif
-
-	.context_priv_size = 0,
-	.device_priv_size = sizeof(USBDevice *),
-	.device_handle_priv_size = sizeof(USBDeviceHandle *),
-	.transfer_priv_size = sizeof(USBTransfer *),
+	/*.name =*/ "Haiku usbfs",
+	/*.caps =*/ 0,
+	/*.init =*/ haiku_init,
+	/*.exit =*/ haiku_exit,
+	/*.set_option =*/ NULL,
+	/*.get_device_list =*/ NULL,
+	/*.hotplug_poll =*/ NULL,
+	/*.wrap_sys_device =*/ NULL,
+	/*.open =*/ haiku_open,
+	/*.close =*/ haiku_close,
+
+	/*.get_active_config_descriptor =*/ haiku_get_active_config_descriptor,
+	/*.get_config_descriptor =*/ haiku_get_config_descriptor,
+	/*.get_config_descriptor_by_value =*/ NULL,
+
+	/*.get_configuration =*/ NULL,
+	/*.set_configuration =*/ haiku_set_configuration,
+
+	/*.claim_interface =*/ haiku_claim_interface,
+	/*.release_interface =*/ haiku_release_interface,
+	/*.set_interface_altsetting =*/ haiku_set_altsetting,
+
+	/*.clear_halt =*/ haiku_clear_halt,
+	/*.reset_device =*/ NULL,
+
+	/*.alloc_streams =*/ NULL,
+	/*.free_streams =*/ NULL,
+
+	/*.dev_mem_alloc =*/ NULL,
+	/*.dev_mem_free =*/ NULL,
+
+	/*.kernel_driver_active =*/ NULL,
+	/*.detach_kernel_driver =*/ NULL,
+	/*.attach_kernel_driver =*/ NULL,
+
+	/*.destroy_device =*/ NULL,
+
+	/*.submit_transfer =*/ haiku_submit_transfer,
+	/*.cancel_transfer =*/ haiku_cancel_transfer,
+	/*.clear_transfer_priv =*/ NULL,
+
+	/*.handle_events =*/ NULL,
+	/*.handle_transfer_completion =*/ haiku_handle_transfer_completion,
+
+	/*.context_priv_size =*/ 0,
+	/*.device_priv_size =*/ sizeof(USBDevice *),
+	/*.device_handle_priv_size =*/ sizeof(USBDeviceHandle *),
+	/*.transfer_priv_size =*/ sizeof(USBTransfer *),
 };

package/libusb/libusb/os/linux_netlink.c

@@ -21,28 +21,22 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <config.h>
+#include "libusbi.h"
+#include "linux_usbfs.h"
 
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include <pthread.h>
 #include <string.h>
 #include <unistd.h>
-#include <sys/types.h>
 
 #ifdef HAVE_ASM_TYPES_H
 #include <asm/types.h>
 #endif
-
 #include <sys/socket.h>
 #include <linux/netlink.h>
 
-#include "libusbi.h"
-#include "linux_usbfs.h"
-
 #define NL_GROUP_KERNEL 1
 
 #ifndef SOCK_CLOEXEC
@@ -54,7 +48,7 @@
 #endif
 
 static int linux_netlink_socket = -1;
-static int netlink_control_pipe[2] = { -1, -1 };
+static usbi_event_t netlink_control_event = USBI_INVALID_EVENT;
 static pthread_t libusb_linux_event_thread;
 
 static void *linux_netlink_event_thread_main(void *arg);
@@ -68,12 +62,12 @@ static int set_fd_cloexec_nb(int fd, int socktype)
 	if (!(socktype & SOCK_CLOEXEC)) {
 		flags = fcntl(fd, F_GETFD);
 		if (flags == -1) {
-			usbi_err(NULL, "failed to get netlink fd flags (%d)", errno);
+			usbi_err(NULL, "failed to get netlink fd flags, errno=%d", errno);
 			return -1;
 		}
 
 		if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
-			usbi_err(NULL, "failed to set netlink fd flags (%d)", errno);
+			usbi_err(NULL, "failed to set netlink fd flags, errno=%d", errno);
 			return -1;
 		}
 	}
@@ -83,12 +77,12 @@ static int set_fd_cloexec_nb(int fd, int socktype)
 	if (!(socktype & SOCK_NONBLOCK)) {
 		flags = fcntl(fd, F_GETFL);
 		if (flags == -1) {
-			usbi_err(NULL, "failed to get netlink fd status flags (%d)", errno);
+			usbi_err(NULL, "failed to get netlink fd status flags, errno=%d", errno);
 			return -1;
 		}
 
 		if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
-			usbi_err(NULL, "failed to set netlink fd status flags (%d)", errno);
+			usbi_err(NULL, "failed to set netlink fd status flags, errno=%d", errno);
 			return -1;
 		}
 	}
@@ -105,13 +99,13 @@ int linux_netlink_start_event_monitor(void)
 
 	linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
 	if (linux_netlink_socket == -1 && errno == EINVAL) {
-		usbi_dbg("failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
+		usbi_dbg(NULL, "failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
 		socktype = SOCK_RAW;
 		linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
 	}
 
 	if (linux_netlink_socket == -1) {
-		usbi_err(NULL, "failed to create netlink socket (%d)", errno);
+		usbi_err(NULL, "failed to create netlink socket, errno=%d", errno);
 		goto err;
 	}
 
@@ -121,35 +115,33 @@ int linux_netlink_start_event_monitor(void)
 
 	ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
 	if (ret == -1) {
-		usbi_err(NULL, "failed to bind netlink socket (%d)", errno);
+		usbi_err(NULL, "failed to bind netlink socket, errno=%d", errno);
 		goto err_close_socket;
 	}
 
 	ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
 	if (ret == -1) {
-		usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option (%d)", errno);
+		usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option, errno=%d", errno);
 		goto err_close_socket;
 	}
 
-	ret = usbi_pipe(netlink_control_pipe);
+	ret = usbi_create_event(&netlink_control_event);
 	if (ret) {
-		usbi_err(NULL, "failed to create netlink control pipe");
+		usbi_err(NULL, "failed to create netlink control event");
 		goto err_close_socket;
 	}
 
 	ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
 	if (ret != 0) {
 		usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
-		goto err_close_pipe;
+		goto err_destroy_event;
 	}
 
 	return LIBUSB_SUCCESS;
 
-err_close_pipe:
-	close(netlink_control_pipe[0]);
-	close(netlink_control_pipe[1]);
-	netlink_control_pipe[0] = -1;
-	netlink_control_pipe[1] = -1;
+err_destroy_event:
+	usbi_destroy_event(&netlink_control_event);
+	netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
 err_close_socket:
 	close(linux_netlink_socket);
 	linux_netlink_socket = -1;
@@ -159,28 +151,23 @@ err:
 
 int linux_netlink_stop_event_monitor(void)
 {
-	char dummy = 1;
-	ssize_t r;
+	int ret;
 
 	assert(linux_netlink_socket != -1);
 
-	/* Write some dummy data to the control pipe and
-	 * wait for the thread to exit */
-	r = write(netlink_control_pipe[1], &dummy, sizeof(dummy));
-	if (r <= 0)
-		usbi_warn(NULL, "netlink control pipe signal failed");
+	/* Signal the control event and wait for the thread to exit */
+	usbi_signal_event(&netlink_control_event);
+
+	ret = pthread_join(libusb_linux_event_thread, NULL);
+	if (ret)
+		usbi_warn(NULL, "failed to join netlink event thread (%d)", ret);
 
-	pthread_join(libusb_linux_event_thread, NULL);
+	usbi_destroy_event(&netlink_control_event);
+	netlink_control_event = (usbi_event_t)USBI_INVALID_EVENT;
 
 	close(linux_netlink_socket);
 	linux_netlink_socket = -1;
 
-	/* close and reset control pipe */
-	close(netlink_control_pipe[0]);
-	close(netlink_control_pipe[1]);
-	netlink_control_pipe[0] = -1;
-	netlink_control_pipe[1] = -1;
-
 	return LIBUSB_SUCCESS;
 }
 
@@ -217,7 +204,7 @@ static int linux_netlink_parse(const char *buffer, size_t len, int *detached,
 	} else if (strcmp(tmp, "remove") == 0) {
 		*detached = 1;
 	} else if (strcmp(tmp, "add") != 0) {
-		usbi_dbg("unknown device action %s", tmp);
+		usbi_dbg(NULL, "unknown device action %s", tmp);
 		return -1;
 	}
 
@@ -314,7 +301,7 @@ static int linux_netlink_read_message(void)
 	len = recvmsg(linux_netlink_socket, &msg, 0);
 	if (len == -1) {
 		if (errno != EAGAIN && errno != EINTR)
-			usbi_err(NULL, "error receiving message from netlink (%d)", errno);
+			usbi_err(NULL, "error receiving message from netlink, errno=%d", errno);
 		return -1;
 	}
 
@@ -324,20 +311,20 @@ static int linux_netlink_read_message(void)
 	}
 
 	if (sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
-		usbi_dbg("ignoring netlink message from unknown group/PID (%u/%u)",
+		usbi_dbg(NULL, "ignoring netlink message from unknown group/PID (%u/%u)",
 			 (unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
 		return -1;
 	}
 
 	cmsg = CMSG_FIRSTHDR(&msg);
 	if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
-		usbi_dbg("ignoring netlink message with no sender credentials");
+		usbi_dbg(NULL, "ignoring netlink message with no sender credentials");
 		return -1;
 	}
 
 	cred = (struct ucred *)CMSG_DATA(cmsg);
 	if (cred->uid != 0) {
-		usbi_dbg("ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
+		usbi_dbg(NULL, "ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
 		return -1;
 	}
 
@@ -345,7 +332,7 @@ static int linux_netlink_read_message(void)
 	if (r)
 		return r;
 
-	usbi_dbg("netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s",
+	usbi_dbg(NULL, "netlink hotplug found device busnum: %hhu, devaddr: %hhu, sys_name: %s, removed: %s",
 		 busnum, devaddr, sys_name, detached ? "yes" : "no");
 
 	/* signal device is available (or not) to all contexts */
@@ -359,40 +346,45 @@ static int linux_netlink_read_message(void)
 
 static void *linux_netlink_event_thread_main(void *arg)
 {
-	char dummy;
-	int r;
-	ssize_t nb;
 	struct pollfd fds[] = {
-		{ .fd = netlink_control_pipe[0],
-		  .events = POLLIN },
+		{ .fd = USBI_EVENT_OS_HANDLE(&netlink_control_event),
+		  .events = USBI_EVENT_POLL_EVENTS },
 		{ .fd = linux_netlink_socket,
 		  .events = POLLIN },
 	};
+	int r;
 
 	UNUSED(arg);
 
-	usbi_dbg("netlink event thread entering");
+#if defined(HAVE_PTHREAD_SETNAME_NP)
+	r = pthread_setname_np(pthread_self(), "libusb_event");
+	if (r)
+		usbi_warn(NULL, "failed to set hotplug event thread name, error=%d", r);
+#endif
 
-	while ((r = poll(fds, 2, -1)) >= 0 || errno == EINTR) {
-		if (r < 0) {
-			/* temporary failure */
-			continue;
+	usbi_dbg(NULL, "netlink event thread entering");
+
+	while (1) {
+		r = poll(fds, 2, -1);
+		if (r == -1) {
+			/* check for temporary failure */
+			if (errno == EINTR)
+				continue;
+			usbi_err(NULL, "poll() failed, errno=%d", errno);
+			break;
 		}
-		if (fds[0].revents & POLLIN) {
-			/* activity on control pipe, read the byte and exit */
-			nb = read(netlink_control_pipe[0], &dummy, sizeof(dummy));
-			if (nb <= 0)
-				usbi_warn(NULL, "netlink control pipe read failed");
+		if (fds[0].revents) {
+			/* activity on control event, exit */
 			break;
 		}
-		if (fds[1].revents & POLLIN) {
+		if (fds[1].revents) {
 			usbi_mutex_static_lock(&linux_hotplug_lock);
 			linux_netlink_read_message();
 			usbi_mutex_static_unlock(&linux_hotplug_lock);
 		}
 	}
 
-	usbi_dbg("netlink event thread exiting");
+	usbi_dbg(NULL, "netlink event thread exiting");
 
 	return NULL;
 }