improve based on feedback from first round of review.

Author: dgrove-oss

private/private.h

@@ -176,26 +176,28 @@ void _dispatch_prohibit_transition_to_multithreaded(bool prohibit);
 
 #if DISPATCH_COCOA_COMPAT
 
-#if TARGET_OS_WIN32
-typedef HANDLE dispatch_handle_t;
+#if TARGET_OS_MAC
+typedef mach_port_t dispatch_runloop_handle_t;
 #elif defined(__linux__)
-typedef int dispatch_handle_t;
+typedef int dispatch_runloop_handle_t;
+#else
+#error
 #endif
 
 #if TARGET_OS_MAC
 __OSX_AVAILABLE_STARTING(__MAC_10_6,__IPHONE_4_0)
 DISPATCH_EXPORT DISPATCH_CONST DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-mach_port_t
+dispatch_runloop_handle_t
 _dispatch_get_main_queue_port_4CF(void);
 
 __OSX_AVAILABLE_STARTING(__MAC_10_6,__IPHONE_4_0)
 DISPATCH_EXPORT DISPATCH_NOTHROW
 void
 _dispatch_main_queue_callback_4CF(mach_msg_header_t *_Null_unspecified msg);
-#elif (TARGET_OS_WIN32 || defined(__linux__))
+#else
 __OSX_AVAILABLE_STARTING(__MAC_10_6,__IPHONE_4_0)
 DISPATCH_EXPORT DISPATCH_NOTHROW
-dispatch_handle_t
+dispatch_runloop_handle_t
 _dispatch_get_main_queue_handle_4CF(void);
 
 __OSX_AVAILABLE_STARTING(__MAC_10_6,__IPHONE_4_0)

src/internal.h

@@ -251,6 +251,9 @@ DISPATCH_EXPORT DISPATCH_NOTHROW void dispatch_atfork_child(void);
 #include <sys/mman.h>
 #include <netinet/in.h>
 #endif
+#if defined(__linux__)
+#include <sys/eventfd.h>
+#endif
 
 #ifdef __BLOCKS__
 #include <Block_private.h>

src/queue.c

@@ -23,10 +23,6 @@
 #include "protocol.h"
 #endif
 
-#if defined(__linux__)
-#include <sys/eventfd.h>
-#endif
-
 #if (!HAVE_PTHREAD_WORKQUEUES || DISPATCH_DEBUG) && \
 		!defined(DISPATCH_ENABLE_THREAD_POOL)
 #define DISPATCH_ENABLE_THREAD_POOL 1
@@ -4067,6 +4063,46 @@ _dispatch_queue_wakeup(dispatch_queue_t dq, pthread_priority_t pp,
 }
 
 #if DISPATCH_COCOA_COMPAT
+
+DISPATCH_ALWAYS_INLINE
+static inline bool
+_dispatch_runloop_handle_is_valid(dispatch_runloop_handle_t handle)
+{
+#if TARGET_OS_MAC
+	return MACH_PORT_VALID(handle);
+#elif defined(__linux__)
+	return handle >= 0;
+#else
+#error
+#endif
+}
+
+DISPATCH_ALWAYS_INLINE
+static inline dispatch_runloop_handle_t
+_dispatch_runloop_queue_get_handle(dispatch_queue_t dq)
+{
+#if TARGET_OS_MAC
+	return ((dispatch_runloop_handle_t)(uintptr_t)dq->do_ctxt);
+#elif defined(__linux__)
+	return ((dispatch_runloop_handle_t)(uintptr_t)dq->do_ctxt) - 1;
+#else
+#error
+#endif
+}
+
+DISPATCH_ALWAYS_INLINE
+static inline void
+_dispatch_runloop_queue_set_handle(dispatch_queue_t dq, dispatch_runloop_handle_t handle)
+{
+#if TARGET_OS_MAC
+	dq->do_ctxt = (void *)(uintptr_t)handle;
+#elif defined(__linux__)
+	dq->do_ctxt = (void *)(uintptr_t)(handle + 1);
+#else
+#error
+#endif
+}
+
 void
 _dispatch_runloop_queue_wakeup(dispatch_queue_t dq, pthread_priority_t pp,
 		dispatch_wakeup_flags_t flags)
@@ -4127,12 +4163,13 @@ _dispatch_root_queue_wakeup(dispatch_queue_t dq,
 static inline void
 _dispatch_runloop_queue_class_poke(dispatch_queue_t dq)
 {
-#if TARGET_OS_MAC
-	mach_port_t mp = (mach_port_t)dq->do_ctxt;
-	if (!mp) {
+	dispatch_runloop_handle_t handle = _dispatch_runloop_queue_get_handle(dq);
+	if (!_dispatch_runloop_handle_is_valid(handle)) {
 		return;
 	}
-	kern_return_t kr = _dispatch_send_wakeup_runloop_thread(mp, 0);
+
+#if TARGET_OS_MAC
+	kern_return_t kr = _dispatch_send_wakeup_runloop_thread(handle, 0);
 	switch (kr) {
 	case MACH_SEND_TIMEOUT:
 	case MACH_SEND_TIMED_OUT:
@@ -4143,15 +4180,13 @@ _dispatch_runloop_queue_class_poke(dispatch_queue_t dq)
 		break;
 	}
 #elif defined(__linux__)
-	int efd = (int)dq->do_ctxt;
-
-	if (efd != 0) {
-		int result;
-		do {
-			result = eventfd_write(efd, 1);
-		} while (result == -1 && errno == EINTR);
-		(void)dispatch_assume_zero(result);
-	}
+	int result;
+	do {
+		result = eventfd_write(handle, 1);
+	} while (result == -1 && errno == EINTR);
+	(void)dispatch_assume_zero(result);
+#else
+#error
 #endif
 }
 
@@ -5603,104 +5638,91 @@ _dispatch_runloop_root_queue_wakeup_4CF(dispatch_queue_t dq)
 	_dispatch_runloop_queue_wakeup(dq, 0, false);
 }
 
-mach_port_t
+dispatch_runloop_handle_t
 _dispatch_runloop_root_queue_get_port_4CF(dispatch_queue_t dq)
 {
 	if (slowpath(dq->do_vtable != DISPATCH_VTABLE(queue_runloop))) {
 		DISPATCH_CLIENT_CRASH(dq->do_vtable, "Not a runloop queue");
 	}
-	return (mach_port_t)dq->do_ctxt;
+	return _dispatch_runloop_queue_get_handle(dq);
 }
 
 static void
 _dispatch_runloop_queue_handle_init(void *ctxt)
 {
 	dispatch_queue_t dq = (dispatch_queue_t)ctxt;
-#if TARGET_OS_MAC
-	mach_port_t mp;
-	kern_return_t kr;
-#endif
+	dispatch_runloop_handle_t handle;
 
 	_dispatch_fork_becomes_unsafe();
-	
+
 #if TARGET_OS_MAC
-	kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &mp);
+	kern_return_t kr;
+	kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &handle);
 	DISPATCH_VERIFY_MIG(kr);
 	(void)dispatch_assume_zero(kr);
-	kr = mach_port_insert_right(mach_task_self(), mp, mp,
+	kr = mach_port_insert_right(mach_task_self(), handle, handle,
 			MACH_MSG_TYPE_MAKE_SEND);
 	DISPATCH_VERIFY_MIG(kr);
 	(void)dispatch_assume_zero(kr);
 	if (dq != &_dispatch_main_q) {
 		struct mach_port_limits limits = {
 			.mpl_qlimit = 1,
 		};
-		kr = mach_port_set_attributes(mach_task_self(), mp,
+		kr = mach_port_set_attributes(mach_task_self(), handle,
 				MACH_PORT_LIMITS_INFO, (mach_port_info_t)&limits,
 				sizeof(limits));
 		DISPATCH_VERIFY_MIG(kr);
 		(void)dispatch_assume_zero(kr);
 	}
-	dq->do_ctxt = (void*)(uintptr_t)mp;
 #elif defined(__linux__)
-	int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-	(void)dispatch_assume(efd != 0);
-	dq->do_ctxt = (void*)(uintptr_t)efd;
+	handle = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
 #else
-#error "not implemented for this platform"
-#endif
+#error
+#endif	
+	(void)dispatch_assume(_dispatch_runloop_handle_is_valid(handle));
+	_dispatch_runloop_queue_set_handle(dq, handle);
 
 	_dispatch_program_is_probably_callback_driven = true;
 }
 
 static void
 _dispatch_runloop_queue_handle_dispose(dispatch_queue_t dq)
 {
-#if TARGET_OS_MAC
-	mach_port_t mp = (mach_port_t)dq->do_ctxt;
-	if (!mp) {
+	dispatch_runloop_handle_t handle = _dispatch_runloop_queue_get_handle(dq);
+	if (!_dispatch_runloop_handle_is_valid(handle)) {
 		return;
 	}
 	dq->do_ctxt = NULL;
-	kern_return_t kr = mach_port_deallocate(mach_task_self(), mp);
+#if TARGET_OS_MAC
+	kern_return_t kr = mach_port_deallocate(mach_task_self(), hand);
 	DISPATCH_VERIFY_MIG(kr);
 	(void)dispatch_assume_zero(kr);
 	kr = mach_port_mod_refs(mach_task_self(), mp, MACH_PORT_RIGHT_RECEIVE, -1);
 	DISPATCH_VERIFY_MIG(kr);
 	(void)dispatch_assume_zero(kr);
 #elif defined(__linux__)
-	int efd = (int)dq->do_ctxt;
-	if (!efd) {
-		return;
-	}
-	dq->do_ctxt = NULL;
-	int rc = close(efd);
+	int rc = close(handle);
 	(void)dispatch_assume_zero(rc);
+#else
+#error
 #endif
 }
 
 #pragma mark -
 #pragma mark dispatch_main_queue
 
+dispatch_runloop_handle_t
 #if TARGET_OS_MAC
-mach_port_t
 _dispatch_get_main_queue_port_4CF(void)
-{
-	dispatch_queue_t dq = &_dispatch_main_q;
-	dispatch_once_f(&_dispatch_main_q_handle_pred, dq,
-			_dispatch_runloop_queue_handle_init);
-	return (mach_port_t)dq->do_ctxt;
-}
 #else
-dispatch_handle_t
 _dispatch_get_main_queue_handle_4CF(void)
+#endif
 {
 	dispatch_queue_t dq = &_dispatch_main_q;
 	dispatch_once_f(&_dispatch_main_q_handle_pred, dq,
 			_dispatch_runloop_queue_handle_init);
-	return (dispatch_handle_t)dq->do_ctxt;
+	return _dispatch_runloop_queue_get_handle(dq);
 }
-#endif
 
 static bool main_q_is_draining;
 
@@ -5717,7 +5739,7 @@ void
 #if TARGET_OS_MAC
 _dispatch_main_queue_callback_4CF(mach_msg_header_t *msg DISPATCH_UNUSED)
 #else
-_dispatch_main_queue_callback_4CF()
+_dispatch_main_queue_callback_4CF(void)
 #endif
 {
 	if (main_q_is_draining) {