Add support for CFRunLoop integration APIs

Author: seabaylea

dispatch/queue.h

@@ -990,6 +990,54 @@ DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
 void *
 dispatch_get_specific(const void *key);
 
+#if __linux__
+/*!
+ * @functiongroup Runloop integration APIs
+ * APIs to provide integration of the main queue into run loop implementations
+ * such as Swift Foundation.
+ */
+
+/*!
+ * @function dispatch_get_main_queue_eventfd_np
+ *
+ * @abstract
+ * Returns a file descriptor representing an eventfd object that provides a
+ * wait/notify mechanism to signal pending tasks on the main queue.
+ *
+ * @discussion
+ * The file descriptor can be monitored with epoll() and becomes readable when
+ * there are pending tasks on the queue. Once readable you should call
+ * eventfd_read() to acknowledge the notification and then call
+ * dispatch_main_queue_drain_np() to perform the pending tasks on the queue.
+ *
+ * @availability
+ * Linux only.
+ * 
+ * @result
+ * A file descriptor representing the eventfd object.
+ */
+DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+int
+dispatch_get_main_queue_eventfd_np();
+
+/*!
+ * @function dispatch_main_queue_drain_np
+ *
+ * @abstract
+ * Executes pending tasks enqueued to the main queue.
+ *
+ * @availability
+ * Linux only.
+ * 
+ * @discussion
+ * The run loop should invoke this function to execute pending tasks on the
+ * main queue.
+ */
+DISPATCH_EXPORT DISPATCH_NOTHROW
+void
+dispatch_main_queue_drain_np();
+#endif
+
 __END_DECLS
 
 #endif

src/Makefile.am

@@ -44,6 +44,7 @@ libdispatch_la_SOURCES=		\
 	shims/perfmon.h			\
 	shims/time.h			\
 	shims/tsd.h				\
+	shims/pthread_main_np.h		\
 	shims/yield.h
 
 AM_CPPFLAGS=-I$(top_builddir) -I$(top_srcdir) \

src/queue.c

@@ -23,6 +23,11 @@
 #include "protocol.h"
 #endif
 
+#if __linux__
+#include <sys/eventfd.h>
+#define DISPATCH_LINUX_COMPAT 1
+#endif
+
 #if (!HAVE_PTHREAD_WORKQUEUES || DISPATCH_DEBUG) && \
 		!defined(DISPATCH_ENABLE_THREAD_POOL)
 #define DISPATCH_ENABLE_THREAD_POOL 1
@@ -77,12 +82,21 @@ static int _dispatch_pthread_sigmask(int how, sigset_t *set, sigset_t *oset);
 
 #if DISPATCH_COCOA_COMPAT
 static dispatch_once_t _dispatch_main_q_port_pred;
-static dispatch_queue_t _dispatch_main_queue_wakeup(void);
 unsigned long _dispatch_runloop_queue_wakeup(dispatch_queue_t dq);
 static void _dispatch_runloop_queue_port_init(void *ctxt);
 static void _dispatch_runloop_queue_port_dispose(dispatch_queue_t dq);
 #endif
 
+#if DISPATCH_COCOA_COMPAT || DISPATCH_LINUX_COMPAT
+static dispatch_queue_t _dispatch_main_queue_wakeup(void);
+#endif
+
+#if DISPATCH_LINUX_COMPAT
+static dispatch_once_t _dispatch_main_q_eventfd_pred;
+static void _dispatch_main_q_eventfd_init(void *ctxt);
+static int main_q_eventfd = -1;
+#endif
+
 static void _dispatch_root_queues_init(void *context);
 static dispatch_once_t _dispatch_root_queues_pred;
 
@@ -3509,6 +3523,29 @@ _dispatch_main_queue_wakeup(void)
 }
 #endif
 
+#if DISPATCH_LINUX_COMPAT
+DISPATCH_NOINLINE
+static dispatch_queue_t
+_dispatch_main_queue_wakeup(void)
+{
+	dispatch_queue_t dq = &_dispatch_main_q;
+	f (!dq->dq_is_thread_bound) {
+		return NULL;
+	}
+	dispatch_once_f(&_dispatch_main_q_eventfd_pred, dq,
+			_dispatch_main_q_eventfd_init);
+	if (main_q_eventfd != -1) {
+		int result;
+		do {
+			result = eventfd_write(main_q_eventfd, 1);
+		} while (result == -1 && errno == EINTR);
+		(void)dispatch_assume_zero(result);
+	}
+	return NULL;
+}
+#endif
+
+
 DISPATCH_NOINLINE
 static void
 _dispatch_queue_wakeup_global_slow(dispatch_queue_t dq, unsigned int n)
@@ -3752,7 +3789,7 @@ _dispatch_queue_drain(dispatch_object_t dou)
 	return sema;
 }
 
-#if DISPATCH_COCOA_COMPAT
+#if DISPATCH_COCOA_COMPAT || DISPATCH_LINUX_COMPAT
 static void
 _dispatch_main_queue_drain(void)
 {
@@ -4485,10 +4522,25 @@ _dispatch_runloop_queue_port_dispose(dispatch_queue_t dq)
 	DISPATCH_VERIFY_MIG(kr);
 	(void)dispatch_assume_zero(kr);
 }
+#endif
 
 #pragma mark -
 #pragma mark dispatch_main_queue
 
+#if DISPATCH_COCOA_COMPAT || DISPATCH_LINUX_COMPAT
+static bool main_q_is_draining;
+
+// 6618342 Contact the team that owns the Instrument DTrace probe before
+//         renaming this symbol
+DISPATCH_NOINLINE
+static void
+_dispatch_queue_set_mainq_drain_state(bool arg)
+{
+	main_q_is_draining = arg;
+}
+#endif
+
+#if DISPATCH_COCOA_COMPAT
 mach_port_t
 _dispatch_get_main_queue_port_4CF(void)
 {
@@ -4498,20 +4550,36 @@ _dispatch_get_main_queue_port_4CF(void)
 	return (mach_port_t)dq->do_ctxt;
 }
 
-static bool main_q_is_draining;
+void
+_dispatch_main_queue_callback_4CF(mach_msg_header_t *msg DISPATCH_UNUSED)
+{
+	if (main_q_is_draining) {
+		return;
+	}
+	_dispatch_queue_set_mainq_drain_state(true);
+	_dispatch_main_queue_drain();
+	_dispatch_queue_set_mainq_drain_state(false);
+}
 
-// 6618342 Contact the team that owns the Instrument DTrace probe before
-//         renaming this symbol
-DISPATCH_NOINLINE
-static void
-_dispatch_queue_set_mainq_drain_state(bool arg)
+#endif
+
+#if DISPATCH_LINUX_COMPAT
+int
+dispatch_get_main_queue_eventfd_np()
 {
-	main_q_is_draining = arg;
+	dispatch_once_f(&_dispatch_main_q_eventfd_pred, NULL,
+			_dispatch_main_q_eventfd_init);
+	return main_q_eventfd;
 }
 
 void
-_dispatch_main_queue_callback_4CF(mach_msg_header_t *msg DISPATCH_UNUSED)
+dispatch_main_queue_drain_np()
 {
+	if (!pthread_main_np()) {
+		DISPATCH_CLIENT_CRASH("dispatch_main_queue_drain_np() must be called on "
+				"the main thread");
+	}
+
 	if (main_q_is_draining) {
 		return;
 	}
@@ -4520,6 +4588,14 @@ _dispatch_main_queue_callback_4CF(mach_msg_header_t *msg DISPATCH_UNUSED)
 	_dispatch_queue_set_mainq_drain_state(false);
 }
 
+static
+void _dispatch_main_q_eventfd_init(void *ctxt DISPATCH_UNUSED)
+{
+	_dispatch_safe_fork = false;
+	main_q_eventfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+	(void)dispatch_assume(main_q_eventfd != -1);
+	_dispatch_program_is_probably_callback_driven = true;
+}
 #endif
 
 void
@@ -4586,6 +4662,16 @@ _dispatch_queue_cleanup2(void)
 			_dispatch_runloop_queue_port_init);
 	_dispatch_runloop_queue_port_dispose(dq);
 #endif
+#if DISPATCH_LINUX_COMPAT
+	dispatch_once_f(&_dispatch_main_q_eventfd_pred, NULL,
+			_dispatch_main_q_eventfd_init);
+	int fd = main_q_eventfd;
+	main_q_eventfd = -1;
+
+	if (fd != -1) {
+		close(fd);
+	}
+#endif
 }
 
 static void

src/shims.h

@@ -174,6 +174,8 @@ void __builtin_trap(void);
 #include "shims/getprogname.h"
 #include "shims/time.h"
 
+#include "shims/pthread_main_np.h"
+
 #ifdef __APPLE__
 // Clear the stack before calling long-running thread-handler functions that
 // never return (and don't take arguments), to facilitate leak detection and

src/shims/pthread_main_np.h

@@ -0,0 +1,40 @@
+/*
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_SHIMS_PTHREAD_MAIN_NP__
+#define __DISPATCH_SHIMS_PTHREAD_MAIN_NP__
+
+#if !HAVE_PTHREAD_MAIN_NP
+
+#if __linux__
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#endif
+
+static inline int
+pthread_main_np()
+{
+#if __linux__
+	return syscall(SYS_gettid) == getpid() ? 1 : 0;
+#else
+#error "No suported way to determine if the current thread is the main thread."
+#endif
+}
+#endif /* !HAVE_PTHREAD_MAIN_NP */
+#endif /* __DISPATCH_SHIMS_PTHREAD_MAIN_NP__ */