devel/libdispatch: bring back Grand Central Dispatch API support library (+)

2025-05-30 09:56:43 -04:00 · 2022-11-08 12:43:02 +03:00 · 2022-11-08 12:43:02 +03:00 · b9662312df
commit b9662312df
parent 1ac270f16e
26 changed files with 1016 additions and 1 deletions
--- a/1
+++ b/1
@ -14507,7 +14507,6 @@ devel/hs-bytestring-nums||2020-05-05|Has expired: No releases since 2012
 devel/iz||2020-05-05|Has expired: Broken for more than 6 months
 devel/jfrog-cli||2020-05-05|Has expired: Broken for more than 6 months
 devel/libcfg||2020-05-05|Has expired: Broken for more than 6 months
-devel/libdispatch||2020-05-05|Has expired: Broken for more than 6 months
 devel/libjson++||2020-05-05|Has expired: Broken for more than 6 months
 devel/libmonetra||2020-05-05|Has expired: Broken for more than 6 months
 devel/libol||2020-05-05|Has expired: Broken for more than 6 months
--- a/devel/Makefile
+++ b/devel/Makefile
@ -1149,6 +1149,7 @@
    SUBDIR += libdatrie
    SUBDIR += libdbusmenu
    SUBDIR += libdbusmenu-qt
+    SUBDIR += libdispatch
    SUBDIR += libddoc
    SUBDIR += libdevq
    SUBDIR += libdfui
--- a/devel/libdispatch/Makefile
+++ b/devel/libdispatch/Makefile
@ -0,0 +1,18 @@
+PORTNAME=	libdispatch
+DISTVERSION=	5.5
+CATEGORIES=	devel
+
+MAINTAINER=	fluffy@FreeBSD.org
+COMMENT=	Grand Central Dispatch API support library
+
+LICENSE=	APACHE20
+
+USES=		cmake compiler:c++17-lang
+USE_LDCONFIG=	yes
+
+USE_GITHUB=	yes
+GH_ACCOUNT=	apple
+GH_PROJECT=	swift-corelibs-libdispatch
+GH_TAGNAME=	swift-${DISTVERSION}-RELEASE
+
+.include <bsd.port.mk>
--- a/devel/libdispatch/distinfo
+++ b/devel/libdispatch/distinfo
@ -0,0 +1,3 @@
+TIMESTAMP = 1667817651
+SHA256 (apple-swift-corelibs-libdispatch-5.5-swift-5.5-RELEASE_GH0.tar.gz) = 5efdfa1d2897c598acea42fc00776477bb3713645686774f5ff0818b26649e62
+SIZE (apple-swift-corelibs-libdispatch-5.5-swift-5.5-RELEASE_GH0.tar.gz) = 592054
--- a/devel/libdispatch/files/patch-cmake_modules_DispatchCompilerWarnings.cmake
+++ b/devel/libdispatch/files/patch-cmake_modules_DispatchCompilerWarnings.cmake
@ -0,0 +1,10 @@
+--- cmake/modules/DispatchCompilerWarnings.cmake.orig	2021-09-17 04:54:52 UTC
+++ cmake/modules/DispatchCompilerWarnings.cmake
+@@ -2,7 +2,6 @@ else()
+ if("${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC")
+   # TODO: someone needs to provide the msvc equivalent warning flags
+ else()
+-  add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Werror>)
+   add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wall>)
+   add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wextra>)
+ 
--- a/devel/libdispatch/files/patch-cmake_modules_SwiftSupport.cmake
+++ b/devel/libdispatch/files/patch-cmake_modules_SwiftSupport.cmake
@ -0,0 +1,11 @@
+--- cmake/modules/SwiftSupport.cmake.orig	2021-09-17 04:54:52 UTC
+++ cmake/modules/SwiftSupport.cmake
+@@ -23,6 +23,8 @@ function(get_swift_host_arch result_var_name)
+     set("${result_var_name}" "armv7" PARENT_SCOPE)
+   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv7l")
+     set("${result_var_name}" "armv7" PARENT_SCOPE)
+  elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "amd64")
+    set("${result_var_name}" "amd64" PARENT_SCOPE)
+   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64")
+     set("${result_var_name}" "x86_64" PARENT_SCOPE)
+   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "IA64")
--- a/devel/libdispatch/files/patch-private_private.h
+++ b/devel/libdispatch/files/patch-private_private.h
@ -0,0 +1,20 @@
+--- private/private.h.orig	2021-09-17 04:54:52 UTC
+++ private/private.h
+@@ -177,7 +177,7 @@ void _dispatch_prohibit_transition_to_multithreaded(bo
+ 
+ #if TARGET_OS_MAC
+ #define DISPATCH_COCOA_COMPAT 1
+-#elif defined(__linux__) || defined(__FreeBSD__) || defined(_WIN32)
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(_WIN32)
+ #define DISPATCH_COCOA_COMPAT 1
+ #else
+ #define DISPATCH_COCOA_COMPAT 0
+@@ -191,6 +191,8 @@ typedef int dispatch_runloop_handle_t;
+ typedef mach_port_t dispatch_runloop_handle_t;
+ #elif defined(__linux__) || defined(__FreeBSD__)
+ typedef int dispatch_runloop_handle_t;
+#elif defined(__unix__)
+typedef uint64_t dispatch_runloop_handle_t;
+ #elif defined(_WIN32)
+ typedef void *dispatch_runloop_handle_t;
+ #else
--- a/devel/libdispatch/files/patch-src_CMakeLists.txt
+++ b/devel/libdispatch/files/patch-src_CMakeLists.txt
@ -0,0 +1,11 @@
+--- src/CMakeLists.txt.orig	2021-09-17 04:54:52 UTC
+++ src/CMakeLists.txt
+@@ -127,7 +127,7 @@ target_compile_options(dispatch PRIVATE -fblocks)
+ # FIXME(compnerd) add check for -fblocks?
+ target_compile_options(dispatch PRIVATE -fblocks)
+ 
+-check_c_compiler_flag("-momit-leaf-frame-pointer -Werror -Wall -O3" C_SUPPORTS_OMIT_LEAF_FRAME_POINTER)
+check_c_compiler_flag("-momit-leaf-frame-pointer -Wall" C_SUPPORTS_OMIT_LEAF_FRAME_POINTER)
+ if (C_SUPPORTS_OMIT_LEAF_FRAME_POINTER)
+   target_compile_options(dispatch PRIVATE -momit-leaf-frame-pointer)
+ endif()
--- a/devel/libdispatch/files/patch-src_event_event.c
+++ b/devel/libdispatch/files/patch-src_event_event.c
@ -0,0 +1,23 @@
+--- src/event/event.c.orig	2021-09-17 04:54:52 UTC
+++ src/event/event.c
+@@ -766,9 +766,9 @@ _dispatch_timer_heap_update(dispatch_timer_heap_t dth,
+ #pragma mark timer unote
+ 
+ #define _dispatch_timer_du_debug(what, du) \
+-		_dispatch_debug("kevent-source[%p]: %s kevent[%p] { ident = 0x%x }", \
+		_dispatch_debug("kevent-source[%p]: %s kevent[%p] { ident = 0x%llx }", \
+ 				_dispatch_wref2ptr((du)->du_owner_wref), what, \
+-				(du), (du)->du_ident)
+				(du), (unsigned long long)(du)->du_ident)
+ 
+ DISPATCH_ALWAYS_INLINE
+ static inline unsigned int
+@@ -792,7 +792,7 @@ _dispatch_timer_unote_disarm(dispatch_timer_source_ref
+ _dispatch_timer_unote_disarm(dispatch_timer_source_refs_t dt,
+ 		dispatch_timer_heap_t dth)
+ {
+-	uint32_t tidx = dt->du_ident;
+	uint32_t tidx = (uint32_t)dt->du_ident;
+ 
+ 	dispatch_assert(_dispatch_unote_armed(dt));
+ 	_dispatch_timer_heap_remove(&dth[tidx], dt);
--- a/devel/libdispatch/files/patch-src_event_event__internal.h
+++ b/devel/libdispatch/files/patch-src_event_event__internal.h
@ -0,0 +1,11 @@
+--- src/event/event_internal.h.orig	2021-09-17 04:54:52 UTC
+++ src/event/event_internal.h
+@@ -125,6 +125,8 @@ typedef uintptr_t dispatch_unote_ident_t;
+ 
+ #if defined(_WIN32)
+ typedef uintptr_t dispatch_unote_ident_t;
+#elif defined(__FreeBSD__)
+typedef uintptr_t dispatch_unote_ident_t;
+ #else
+ typedef uint32_t dispatch_unote_ident_t;
+ #endif
--- a/devel/libdispatch/files/patch-src_event_event__kevent.c
+++ b/devel/libdispatch/files/patch-src_event_event__kevent.c
@ -0,0 +1,259 @@
+--- src/event/event_kevent.c.orig	2021-09-17 04:54:52 UTC
+++ src/event/event_kevent.c
+@@ -101,8 +101,12 @@ _evfiltstr(short filt)
+ 	_evfilt2(EVFILT_MACHPORT);
+ 	_evfilt2(DISPATCH_EVFILT_MACH_NOTIFICATION);
+ #endif
+#ifdef EVFILT_FS
+ 	_evfilt2(EVFILT_FS);
+#endif
+#ifdef EVFILT_USER
+ 	_evfilt2(EVFILT_USER);
+#endif
+ #ifdef EVFILT_SOCK
+ 	_evfilt2(EVFILT_SOCK);
+ #endif
+@@ -236,9 +240,9 @@ dispatch_kevent_debug(const char *verb, const dispatch
+ 
+ #define _dispatch_du_debug(what, du) \
+ 		_dispatch_debug("kevent-source[%p]: %s kevent[%p] " \
+-				"{ filter = %s, ident = 0x%x }", \
+				"{ filter = %s, ident = 0x%llx }", \
+ 				_dispatch_wref2ptr((du)->du_owner_wref), what, \
+-				(du), _evfiltstr((du)->du_filter), (du)->du_ident)
+				(du), _evfiltstr((du)->du_filter), (unsigned long long)(du)->du_ident)
+ 
+ #if DISPATCH_MACHPORT_DEBUG
+ #ifndef MACH_PORT_TYPE_SPREQUEST
+@@ -388,8 +392,10 @@ _dispatch_kevent_print_error(dispatch_kevent_t ke)
+ 	switch (ke->data) {
+ 	case 0:
+ 		return;
+#if DISPATCH_USE_KEVENT_QOS
+ 	case ERANGE: /* A broken QoS was passed to kevent_id() */
+ 		DISPATCH_INTERNAL_CRASH(ke->qos, "Invalid kevent priority");
+#endif
+ 	default:
+ 		// log the unexpected error
+ 		_dispatch_bug_kevent_client("kevent", _evfiltstr(ke->filter),
+@@ -397,7 +403,7 @@ _dispatch_kevent_print_error(dispatch_kevent_t ke)
+ 				ke->flags & EV_DELETE ? "delete" :
+ 				ke->flags & EV_ADD ? "add" :
+ 				ke->flags & EV_ENABLE ? "enable" : "monitor",
+-				(int)ke->data, ke->ident, ke->udata, du);
+				(int)ke->data, ke->ident, (uint64_t)ke->udata, du);
+ 	}
+ }
+ 
+@@ -528,11 +534,17 @@ _dispatch_kevent_merge_muxed(dispatch_kevent_t ke)
+ 	}
+ }
+ 
+#define DISPATCH_KEVENT_ERSATZ_EVFILT_USER_MASK 0xfffffe00
+
+ DISPATCH_NOINLINE
+ static void
+ _dispatch_kevent_drain(dispatch_kevent_t ke)
+ {
+#ifdef EVFILT_USER
+ 	if (ke->filter == EVFILT_USER) {
+#else
+	if (ke->filter == EVFILT_TIMER && ke->ident == DISPATCH_KEVENT_ERSATZ_EVFILT_USER_MASK) {
+#endif
+ 		_dispatch_kevent_mgr_debug("received", ke);
+ 		return;
+ 	}
+@@ -579,10 +591,17 @@ _dispatch_kq_create(intptr_t *fd_ptr)
+ _dispatch_kq_create(intptr_t *fd_ptr)
+ {
+ 	static const dispatch_kevent_s kev = {
+#ifdef EVFILT_USER
+ 		.ident = 1,
+ 		.filter = EVFILT_USER,
+ 		.flags = EV_ADD|EV_CLEAR,
+ 		.udata = (dispatch_kevent_udata_t)DISPATCH_WLH_MANAGER,
+#else
+		.ident = DISPATCH_KEVENT_ERSATZ_EVFILT_USER_MASK,
+		.filter = EVFILT_TIMER,
+		.flags = EV_ADD|EV_DISABLE,
+		.data = 1,
+#endif
+ 	};
+ 	int kqfd;
+ 
+@@ -591,7 +610,6 @@ _dispatch_kq_create(intptr_t *fd_ptr)
+ 	guardid_t guard = (uintptr_t)fd_ptr;
+ 	kqfd = guarded_kqueue_np(&guard, GUARD_CLOSE | GUARD_DUP);
+ #else
+-	(void)guard_ptr;
+ 	kqfd = kqueue();
+ #endif
+ 	if (kqfd == -1) {
+@@ -727,6 +745,10 @@ retry:
+ 		(void)avail;
+ 		const struct timespec timeout_immediately = {}, *timeout = NULL;
+ 		if (flags & KEVENT_FLAG_IMMEDIATE) timeout = &timeout_immediately;
+#ifdef EVFILT_USER
+		const struct timespec timeout_1ms = {.tv_sec = 0, .tv_nsec = 1000000};
+		if (ke->ident == DISPATCH_KEVENT_ERSATZ_EVFILT_USER_MASK) timeout = &timeout_1ms;
+#endif
+ 		r = kevent(kqfd, ke, n, ke_out, n_out, timeout);
+ #endif
+ #if DISPATCH_USE_KEVENT_WORKLOOP
+@@ -743,7 +765,7 @@ retry:
+ 		switch (err) {
+ 		case ENOMEM:
+ 			_dispatch_temporary_resource_shortage();
+-			/* FALLTHROUGH */
+			DISPATCH_FALLTHROUGH;
+ 		case EINTR:
+ 			goto retry;
+ 		case EBADF:
+@@ -754,7 +776,7 @@ retry:
+ 					(flags & KEVENT_FLAG_DYNAMIC_KQ_MUST_EXIST)) {
+ 				return 0;
+ 			}
+-			/* FALLTHROUGH */
+			DISPATCH_FALLTHROUGH;
+ #endif // DISPATCH_USE_KEVENT_WORKLOOP
+ 		default:
+ 			DISPATCH_CLIENT_CRASH(err, "Unexpected error from kevent");
+@@ -786,9 +808,15 @@ _dispatch_kq_drain(dispatch_wlh_t wlh, dispatch_kevent
+ 
+ #if DISPATCH_DEBUG
+ 	for (r = 0; r < n; r++) {
+#ifdef EVFILT_USER
+ 		if (ke[r].filter != EVFILT_USER || DISPATCH_MGR_QUEUE_DEBUG) {
+ 			_dispatch_kevent_debug_n(NULL, ke + r, r, n);
+ 		}
+#else
+		if (DISPATCH_MGR_QUEUE_DEBUG) {
+			_dispatch_kevent_debug_n(NULL, ke + r, r, n);
+		}
+#endif
+ 	}
+ #endif
+ 
+@@ -860,7 +888,6 @@ _dispatch_kq_unote_set_kevent(dispatch_unote_t _du, di
+ 				du->du_priority),
+ #endif
+ 	};
+-	(void)pp; // if DISPATCH_USE_KEVENT_QOS == 0
+ }
+ 
+ DISPATCH_ALWAYS_INLINE
+@@ -921,9 +948,13 @@ _dispatch_kq_deferred_update(dispatch_wlh_t wlh, dispa
+ 				ke->udata);
+ 		dispatch_kevent_t dk = _dispatch_kq_deferred_reuse_slot(wlh, ddi, slot);
+ 		*dk = *ke;
+#ifdef EVFILT_USER
+ 		if (ke->filter != EVFILT_USER) {
+ 			_dispatch_kevent_mgr_debug("deferred", ke);
+ 		}
+#else
+		_dispatch_kevent_mgr_debug("deferred", ke);
+#endif
+ 	} else {
+ 		_dispatch_kq_update_one(wlh, ke);
+ 	}
+@@ -985,6 +1016,7 @@ _dispatch_sync_ipc_handoff_end(dispatch_wlh_t wlh, mac
+ }
+ #endif
+ 
+#if DISPATCH_HAVE_DIRECT_KNOTES
+ DISPATCH_NOINLINE
+ static bool
+ _dispatch_kq_unote_update(dispatch_wlh_t wlh, dispatch_unote_t _du,
+@@ -1055,6 +1087,7 @@ done:
+ 	dispatch_assume_zero(r);
+ 	return true;
+ }
+#endif
+ 
+ #pragma mark dispatch_muxnote_t
+ 
+@@ -1283,6 +1316,7 @@ _dispatch_unote_unregister_direct(dispatch_unote_t du,
+ #pragma mark -
+ #pragma mark dispatch_event_loop
+ 
+#if DISPATCH_USE_KEVENT_WORKLOOP
+ enum {
+ 	DISPATCH_WORKLOOP_ASYNC,
+ 	DISPATCH_WORKLOOP_ASYNC_FROM_SYNC,
+@@ -1316,6 +1350,7 @@ static char const * const _dispatch_workloop_actions[]
+ 	[DISPATCH_WORKLOOP_SYNC_WAKE]                   = "sync-wake",
+ 	[DISPATCH_WORKLOOP_SYNC_END]                    = "sync-end",
+ };
+#endif
+ 
+ void
+ _dispatch_event_loop_atfork_child(void)
+@@ -1410,7 +1445,7 @@ _dispatch_kq_fill_workloop_event(dispatch_kevent_t ke,
+ 	switch (which) {
+ 	case DISPATCH_WORKLOOP_ASYNC_FROM_SYNC:
+ 		fflags |= NOTE_WL_END_OWNERSHIP;
+-		/* FALLTHROUGH */
+		DISPATCH_FALLTHROUGH;
+ 	case DISPATCH_WORKLOOP_ASYNC:
+ 	case DISPATCH_WORKLOOP_ASYNC_DISCOVER_SYNC:
+ 	case DISPATCH_WORKLOOP_ASYNC_QOS_UPDATE:
+@@ -1434,10 +1469,10 @@ _dispatch_kq_fill_workloop_event(dispatch_kevent_t ke,
+ 
+ 	case DISPATCH_WORKLOOP_ASYNC_LEAVE_FROM_SYNC:
+ 		fflags |= NOTE_WL_END_OWNERSHIP;
+-		/* FALLTHROUGH */
+		DISPATCH_FALLTHROUGH;
+ 	case DISPATCH_WORKLOOP_ASYNC_LEAVE_FROM_TRANSFER:
+ 		fflags |= NOTE_WL_IGNORE_ESTALE;
+-		/* FALLTHROUGH */
+		DISPATCH_FALLTHROUGH;
+ 	case DISPATCH_WORKLOOP_ASYNC_LEAVE:
+ 		dispatch_assert(!_dq_state_is_enqueued_on_target(dq_state));
+ 		action = EV_ADD | EV_DELETE | EV_ENABLE;
+@@ -1881,10 +1916,17 @@ _dispatch_event_loop_poke(dispatch_wlh_t wlh, uint64_t
+ {
+ 	if (wlh == DISPATCH_WLH_MANAGER) {
+ 		dispatch_kevent_s ke = (dispatch_kevent_s){
+#ifdef EVFILT_USER
+ 			.ident  = 1,
+ 			.filter = EVFILT_USER,
+ 			.fflags = NOTE_TRIGGER,
+ 			.udata = (dispatch_kevent_udata_t)DISPATCH_WLH_MANAGER,
+#else
+			.ident = DISPATCH_KEVENT_ERSATZ_EVFILT_USER_MASK,
+			.filter = EVFILT_TIMER,
+			.flags = EV_ADD|EV_ENABLE,
+			.data = 1
+#endif
+ 		};
+ 		return _dispatch_kq_deferred_update(DISPATCH_WLH_ANON, &ke);
+ 	} else if (wlh && wlh != DISPATCH_WLH_ANON) {
+@@ -2357,6 +2399,12 @@ _dispatch_event_loop_timer_arm(dispatch_timer_heap_t d
+ 		target += range.leeway;
+ 		range.leeway = 0;
+ 	}
+#if !NOTE_ABSOLUTE
+	target = range.delay;
+#if defined(__FreeBSD__)
+	target /= 1000000;
+#endif
+#endif
+ 
+ 	_dispatch_event_loop_timer_program(dth, tidx, target, range.leeway,
+ 			EV_ADD | EV_ENABLE);
+@@ -2445,6 +2493,7 @@ const dispatch_source_type_s _dispatch_source_type_vno
+ 	.dst_merge_evt  = _dispatch_source_merge_evt,
+ };
+ 
+#ifdef EVFILT_FS
+ const dispatch_source_type_s _dispatch_source_type_vfs = {
+ 	.dst_kind       = "vfs",
+ 	.dst_filter     = EVFILT_FS,
+@@ -2477,6 +2526,7 @@ const dispatch_source_type_s _dispatch_source_type_vfs
+ 	.dst_create     = _dispatch_unote_create_without_handle,
+ 	.dst_merge_evt  = _dispatch_source_merge_evt,
+ };
+#endif
+ 
+ #ifdef EVFILT_SOCK
+ const dispatch_source_type_s _dispatch_source_type_sock = {
--- a/devel/libdispatch/files/patch-src_event_workqueue.c
+++ b/devel/libdispatch/files/patch-src_event_workqueue.c
@ -0,0 +1,55 @@
+--- src/event/workqueue.c.orig	2021-09-17 04:54:52 UTC
+++ src/event/workqueue.c
+@@ -180,6 +180,52 @@ _dispatch_workq_count_runnable_workers(dispatch_workq_
+ 
+ 	_dispatch_unfair_lock_unlock(&mon->registered_tid_lock);
+ }
+#elif defined(__FreeBSD__)
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/proc.h>
+
+static void
+_dispatch_workq_count_runnable_workers(dispatch_workq_monitor_t mon)
+{
+	struct kinfo_proc kp[WORKQ_MAX_TRACKED_TIDS] = {0};
+	size_t size, len;
+	int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, (int)getpid(), (int)sizeof(struct kinfo_proc), 0};
+	if (sysctl(mib, 6, NULL, &size, NULL, 0) < 0) {
+		_dispatch_debug("workq: Failed to sysctl1");
+		return;
+	}
+
+	size = size > sizeof(kp)? sizeof(kp): size;
+	len = size / sizeof(struct kinfo_proc);
+	mib[5] = (int)len;
+	if (sysctl(mib, 6, kp, &size, NULL, 0) < 0) {
+		_dispatch_debug("workq: Failed to sysctl2");
+		return;
+	}
+
+	int running_count = 0;
+
+	_dispatch_unfair_lock_lock(&mon->registered_tid_lock);
+
+	for (int i = 0; i < mon->num_registered_tids; i++) {
+		dispatch_tid tid = mon->registered_tids[i];
+		for (size_t j = 0; j < len; j++) {
+			if ((dispatch_tid)kp[j].p_tid != tid) {
+				continue;
+			}
+
+			if (kp[j].p_stat == SRUN || kp[j].p_stat == SIDL || kp[j].p_stat == SONPROC) {
+				running_count++;
+				break;
+			}
+		}
+	}
+
+	mon->num_runnable = running_count;
+
+	_dispatch_unfair_lock_unlock(&mon->registered_tid_lock);
+}
+ #else
+ #error must define _dispatch_workq_count_runnable_workers
+ #endif
--- a/devel/libdispatch/files/patch-src_init.c
+++ b/devel/libdispatch/files/patch-src_init.c
@ -0,0 +1,38 @@
+--- src/init.c.orig	2021-09-17 04:54:52 UTC
+++ src/init.c
+@@ -961,7 +961,6 @@ _dispatch_continuation_get_function_symbol(dispatch_co
+ 	return dc->dc_func;
+ }
+ 
+-#if HAVE_MACH
+ void
+ _dispatch_bug_kevent_client(const char *msg, const char *filter,
+ 		const char *operation, int err, uint64_t ident, uint64_t udata,
+@@ -1005,7 +1004,6 @@ _dispatch_bug_kevent_client(const char *msg, const cha
+ 				msg, strerror(err), err, udata, filter, ident, ident, func);
+ 	}
+ }
+-#endif // HAVE_MACH
+ 
+ #if RDAR_49023449
+ 
+@@ -1048,7 +1046,7 @@ _dispatch_bug_kevent_vanished(dispatch_unote_t du)
+ 			"{ %p[%s], ident: %" PRIdPTR " / 0x%" PRIxPTR ", handler: %p }",
+ 			dux_type(du._du)->dst_kind, dou._dq,
+ 			dou._dq->dq_label ? dou._dq->dq_label : "<unknown>",
+-			du._du->du_ident, du._du->du_ident, func);
+			(intptr_t)du._du->du_ident, (uintptr_t)du._du->du_ident, func);
+ }
+ 
+ #endif // RDAR_49023449
+@@ -1153,8 +1151,8 @@ _dispatch_logv_init(void *context DISPATCH_UNUSED)
+ 			}
+ #else
+ 			dprintf(dispatch_logfile, "=== log file opened for %s[%u] at "
+-					"%ld.%06u ===\n", getprogname() ?: "", getpid(),
+-					tv.tv_sec, (int)tv.tv_usec);
+					"%lld.%06u ===\n", getprogname() ?: "", getpid(),
+					(time_t)tv.tv_sec, (int)tv.tv_usec);
+ #endif
+ 		}
+ 	}
--- a/devel/libdispatch/files/patch-src_internal.h
+++ b/devel/libdispatch/files/patch-src_internal.h
@ -0,0 +1,15 @@
+--- src/internal.h.orig	2021-09-17 04:54:52 UTC
+++ src/internal.h
+@@ -475,12 +475,10 @@ struct dispatch_unote_class_s;
+ 
+ struct dispatch_unote_class_s;
+ 
+-#if HAVE_MACH
+ DISPATCH_NOINLINE DISPATCH_COLD
+ void _dispatch_bug_kevent_client(const char *msg, const char *filter,
+ 		const char *operation, int err, uint64_t ident, uint64_t udata,
+ 		struct dispatch_unote_class_s *du);
+-#endif // HAVE_MACH
+ 
+ DISPATCH_NOINLINE DISPATCH_COLD
+ void _dispatch_bug_kevent_vanished(struct dispatch_unote_class_s *du);
--- a/devel/libdispatch/files/patch-src_io.c
+++ b/devel/libdispatch/files/patch-src_io.c
@ -0,0 +1,20 @@
+--- src/io.c.orig	2021-09-17 04:54:52 UTC
+++ src/io.c
+@@ -22,7 +22,7 @@
+ 
+ #if defined(__FreeBSD__)
+ #include <fcntl.h>
+-#define F_RDADVISE F_RDAHEAD
+//#define F_RDADVISE F_RDAHEAD
+ #endif
+ 
+ #ifndef DISPATCH_IO_DEBUG
+@@ -2308,7 +2308,7 @@ _dispatch_operation_advise(dispatch_operation_t op, si
+ 		default: (void)dispatch_assume_zero(err); break;
+ 	}
+ #else
+-#error "_dispatch_operation_advise not implemented on this platform"
+	(void)err;
+ #endif // defined(F_RDADVISE)
+ #endif // defined(_WIN32)
+ }
--- a/devel/libdispatch/files/patch-src_queue.c
+++ b/devel/libdispatch/files/patch-src_queue.c
@ -0,0 +1,106 @@
+--- src/queue.c.orig	2021-09-17 04:54:52 UTC
+++ src/queue.c
+@@ -6469,6 +6469,8 @@ _dispatch_runloop_handle_is_valid(dispatch_runloop_han
+ 	return MACH_PORT_VALID(handle);
+ #elif defined(__linux__)
+ 	return handle >= 0;
+#elif defined(__unix__)
+	return handle >= 0;
+ #elif defined(_WIN32)
+ 	return handle != NULL;
+ #else
+@@ -6485,6 +6487,8 @@ _dispatch_runloop_queue_get_handle(dispatch_lane_t dq)
+ #elif defined(__linux__)
+ 	// decode: 0 is a valid fd, so offset by 1 to distinguish from NULL
+ 	return ((dispatch_runloop_handle_t)(uintptr_t)dq->do_ctxt) - 1;
+#elif defined(__unix__)
+	return ((dispatch_runloop_handle_t)(uintptr_t)dq->do_ctxt);
+ #elif defined(_WIN32)
+ 	return ((dispatch_runloop_handle_t)(uintptr_t)dq->do_ctxt);
+ #else
+@@ -6502,6 +6506,8 @@ _dispatch_runloop_queue_set_handle(dispatch_lane_t dq,
+ #elif defined(__linux__)
+ 	// encode: 0 is a valid fd, so offset by 1 to distinguish from NULL
+ 	dq->do_ctxt = (void *)(uintptr_t)(handle + 1);
+#elif defined(__unix__)
+	dq->do_ctxt = (void *)(uintptr_t)handle;
+ #elif defined(_WIN32)
+ 	dq->do_ctxt = (void *)(uintptr_t)handle;
+ #else
+@@ -6509,6 +6515,12 @@ _dispatch_runloop_queue_set_handle(dispatch_lane_t dq,
+ #endif
+ }
+ 
+#if defined(__unix__)
+#define DISPATCH_RUNLOOP_HANDLE_PACK(rfd, wfd) (((uint64_t)(rfd) << 32) | (wfd))
+#define DISPATCH_RUNLOOP_HANDLE_RFD(h) ((int)((h) >> 32))
+#define DISPATCH_RUNLOOP_HANDLE_WFD(h) ((int)((h) & 0xffffffff))
+#endif
+
+ static void
+ _dispatch_runloop_queue_handle_init(void *ctxt)
+ {
+@@ -6558,6 +6570,14 @@ _dispatch_runloop_queue_handle_init(void *ctxt)
+ 		}
+ 	}
+ 	handle = fd;
+#elif defined(__unix__)
+	int fds[2];
+	int r = pipe2(fds, O_CLOEXEC | O_NONBLOCK);
+	if (r == -1) {
+		DISPATCH_CLIENT_CRASH(errno, "pipe2 failure");
+	}
+	uint32_t rfd = (uint32_t)fds[0], wfd = (uint32_t)fds[1];
+	handle = DISPATCH_RUNLOOP_HANDLE_PACK(rfd, wfd);
+ #elif defined(_WIN32)
+ 	HANDLE hEvent;
+ 	hEvent = CreateEventW(NULL, /*bManualReset=*/FALSE,
+@@ -6592,6 +6612,11 @@ _dispatch_runloop_queue_handle_dispose(dispatch_lane_t
+ #elif defined(__linux__)
+ 	int rc = close(handle);
+ 	(void)dispatch_assume_zero(rc);
+#elif defined(__unix__)
+	int rc = close(DISPATCH_RUNLOOP_HANDLE_WFD(handle));
+	(void)dispatch_assume_zero(rc);
+	rc = close(DISPATCH_RUNLOOP_HANDLE_RFD(handle));
+	(void)dispatch_assume_zero(rc);
+ #elif defined(_WIN32)
+ 	BOOL bSuccess;
+ 	bSuccess = CloseHandle(handle);
+@@ -6628,6 +6653,13 @@ _dispatch_runloop_queue_class_poke(dispatch_lane_t dq)
+ 		result = eventfd_write(handle, 1);
+ 	} while (result == -1 && errno == EINTR);
+ 	(void)dispatch_assume_zero(result);
+#elif defined(__unix__)
+	int wfd = DISPATCH_RUNLOOP_HANDLE_WFD(handle);
+	ssize_t result;
+	do {
+		result = write(wfd, "x", 1);
+	} while (result == -1 && errno == EINTR);
+	(void)dispatch_assume_zero(result - 1);
+ #elif defined(_WIN32)
+ 	BOOL bSuccess;
+ 	bSuccess = SetEvent(handle);
+@@ -6915,7 +6947,7 @@ _dispatch_runloop_root_queue_wakeup_4CF(dispatch_queue
+ 	_dispatch_runloop_queue_wakeup(upcast(dq)._dl, 0, false);
+ }
+ 
+-#if TARGET_OS_MAC || defined(_WIN32)
+#if TARGET_OS_MAC || defined(_WIN32) || defined(__FreeBSD__)
+ dispatch_runloop_handle_t
+ _dispatch_runloop_root_queue_get_port_4CF(dispatch_queue_t dq)
+ {
+@@ -7304,6 +7336,13 @@ _gettid(void)
+ _gettid(void)
+ {
+ 	return (pid_t)pthread_getthreadid_np();
+}
+#elif defined(__FreeBSD__)
+DISPATCH_ALWAYS_INLINE
+static inline pid_t
+_gettid(void)
+{
+	return getthrid();
+ }
+ #elif defined(_WIN32)
+ DISPATCH_ALWAYS_INLINE
--- a/devel/libdispatch/files/patch-src_shims_lock.c
+++ b/devel/libdispatch/files/patch-src_shims_lock.c
@ -0,0 +1,119 @@
+--- src/shims/lock.c.orig	2021-09-17 04:54:52 UTC
+++ src/shims/lock.c
+@@ -56,6 +56,18 @@ _dispatch_thread_switch(dispatch_lock value, dispatch_
+ #endif
+ #endif
+ 
+#if defined(__unix__)
+DISPATCH_ALWAYS_INLINE
+static inline void
+_dispatch_thread_switch(dispatch_lock value, dispatch_lock_options_t flags,
+  uint32_t timeout)
+{
+	(void)value;
+	(void)flags;
+	(void)timeout;
+}
+#endif
+
+ #pragma mark - semaphores
+ 
+ #if USE_MACH_SEM
+@@ -394,8 +406,10 @@ _dispatch_unfair_lock_wake(uint32_t *uaddr, uint32_t f
+ #include <sys/time.h>
+ #ifdef __ANDROID__
+ #include <sys/syscall.h>
+-#else
+#elif __linux__
+ #include <syscall.h>
+#else
+#include <sys/futex.h>
+ #endif /* __ANDROID__ */
+ 
+ DISPATCH_ALWAYS_INLINE
+@@ -404,7 +418,12 @@ _dispatch_futex(uint32_t *uaddr, int op, uint32_t val,
+ 		const struct timespec *timeout, uint32_t *uaddr2, uint32_t val3,
+ 		int opflags)
+ {
+#if __linux__
+ 	return (int)syscall(SYS_futex, uaddr, op | opflags, val, timeout, uaddr2, val3);
+#else
+	(void)val3;
+	return futex(uaddr, op | opflags, (int)val, timeout, uaddr2);
+#endif
+ }
+ 
+ // returns 0, ETIMEDOUT, EFAULT, EINTR, EWOULDBLOCK
+@@ -414,11 +433,15 @@ _futex_blocking_op(uint32_t *uaddr, int futex_op, uint
+ 		const struct timespec *timeout, int flags)
+ {
+ 	for (;;) {
+-		int rc = _dispatch_futex(uaddr, futex_op, val, timeout, NULL, 0, flags);
+-		if (!rc) {
+		int err = _dispatch_futex(uaddr, futex_op, val, timeout, NULL, 0, flags);
+		if (!err) {
+ 			return 0;
+ 		}
+-		switch (errno) {
+#if __linux__
+		// syscall sets errno to communicate error code.
+		err = errno
+#endif
+		switch (err) {
+ 		case EINTR:
+ 			/*
+ 			 * if we have a timeout, we need to return for the caller to
+@@ -454,6 +477,7 @@ _dispatch_futex_wake(uint32_t *uaddr, int wake, int op
+ 	DISPATCH_INTERNAL_CRASH(errno, "_dlock_wake() failed");
+ }
+ 
+#if HAVE_FUTEX_PI
+ static void
+ _dispatch_futex_lock_pi(uint32_t *uaddr, struct timespec *timeout, int detect,
+ 	      int opflags)
+@@ -471,6 +495,7 @@ _dispatch_futex_unlock_pi(uint32_t *uaddr, int opflags
+ 	if (rc == 0) return;
+ 	DISPATCH_CLIENT_CRASH(errno, "futex_unlock_pi() failed");
+ }
+#endif
+ 
+ #endif
+ #pragma mark - wait for address
+@@ -509,6 +534,19 @@ _dispatch_wait_on_address(uint32_t volatile *_address,
+ 	return _dispatch_futex_wait(address, value, NULL, FUTEX_PRIVATE_FLAG);
+ #elif defined(_WIN32)
+ 	return WaitOnAddress(address, &value, sizeof(value), INFINITE) == TRUE;
+#elif defined(__FreeBSD__)
+	uint64_t usecs = 0;
+	int rc;
+	if (nsecs == DISPATCH_TIME_FOREVER) {
+		return _dispatch_ulock_wait(address, value, 0, flags);
+	}
+	do {
+		usecs = howmany(nsecs, NSEC_PER_USEC);
+		if (usecs > UINT32_MAX) usecs = UINT32_MAX;
+		rc = _dispatch_ulock_wait(address, value, (uint32_t)usecs, flags);
+	} while (usecs == UINT32_MAX && rc == ETIMEDOUT &&
+			(nsecs = _dispatch_timeout(timeout)) != 0);
+	return rc;
+ #else
+ #error _dispatch_wait_on_address unimplemented for this platform
+ #endif
+@@ -599,7 +637,7 @@ _dispatch_unfair_lock_lock_slow(dispatch_unfair_lock_t
+ 		}
+ 	}
+ }
+-#elif HAVE_FUTEX
+#elif HAVE_FUTEX_PI
+ void
+ _dispatch_unfair_lock_lock_slow(dispatch_unfair_lock_t dul,
+ 		dispatch_lock_options_t flags)
+@@ -636,7 +674,7 @@ _dispatch_unfair_lock_unlock_slow(dispatch_unfair_lock
+ 	if (_dispatch_lock_has_waiters(cur)) {
+ 		_dispatch_unfair_lock_wake(&dul->dul_lock, 0);
+ 	}
+-#elif HAVE_FUTEX
+#elif HAVE_FUTEX_PI
+ 	// futex_unlock_pi() handles both OWNER_DIED which we abuse & WAITERS
+ 	_dispatch_futex_unlock_pi(&dul->dul_lock, FUTEX_PRIVATE_FLAG);
+ #else
--- a/devel/libdispatch/files/patch-src_shims_lock.h
+++ b/devel/libdispatch/files/patch-src_shims_lock.h
@ -0,0 +1,45 @@
+--- src/shims/lock.h.orig	2021-09-17 04:54:52 UTC
+++ src/shims/lock.h
+@@ -100,6 +100,25 @@ _dispatch_lock_owner(dispatch_lock lock_value)
+ 	return lock_value & DLOCK_OWNER_MASK;
+ }
+ 
+#elif defined(__FreeBSD__)
+
+typedef uint32_t dispatch_tid;
+typedef uint32_t dispatch_lock;
+
+#define DLOCK_OWNER_NULL   ((dispatch_tid)0)
+#define DLOCK_OWNER_MASK   ((dispatch_lock)0xfffffffc)
+#define DLOCK_WAITERS_BIT   ((dispatch_lock)0x00000001)
+#define DLOCK_FAILED_TRYLOCK_BIT  ((dispatch_lock)0x00000002)
+
+#define _dispatch_tid_self()        ((dispatch_tid)(_dispatch_get_tsd_base()->tid))
+
+DISPATCH_ALWAYS_INLINE
+static inline dispatch_tid
+_dispatch_lock_owner(dispatch_lock lock_value)
+{
+  return lock_value & DLOCK_OWNER_MASK;
+}
+
+ #else
+ #  error define _dispatch_lock encoding scheme for your platform here
+ #endif
+@@ -167,10 +186,15 @@ _dispatch_lock_has_failed_trylock(dispatch_lock lock_v
+ #endif
+ 
+ #ifndef HAVE_FUTEX
+-#ifdef __linux__
+#if defined(__linux__)
+ #define HAVE_FUTEX 1
+#define HAVE_FUTEX_PI 1
+#elif defined(__FreeBSD__)
+#define HAVE_FUTEX 0
+#define HAVE_FUTEX_PI 0
+ #else
+ #define HAVE_FUTEX 0
+#define HAVE_FUTEX_PI 0
+ #endif
+ #endif // HAVE_FUTEX
+ 
--- a/devel/libdispatch/files/patch-src_source.c
+++ b/devel/libdispatch/files/patch-src_source.c
@ -0,0 +1,16 @@
+--- src/source.c.orig	2021-09-17 04:54:52 UTC
+++ src/source.c
+@@ -1398,11 +1398,11 @@ _dispatch_source_debug_attr(dispatch_source_t ds, char
+ 	dispatch_source_refs_t dr = ds->ds_refs;
+ 	dispatch_queue_flags_t dqf = _dispatch_queue_atomic_flags(ds);
+ 	dispatch_unote_state_t du_state = _dispatch_unote_state(dr);
+-	return dsnprintf(buf, bufsiz, "target = %s[%p], ident = 0x%x, "
+	return dsnprintf(buf, bufsiz, "target = %s[%p], ident = 0x%llx, "
+ 			"mask = 0x%x, pending_data = 0x%llx, registered = %d, "
+ 			"armed = %d, %s%s%s",
+ 			target && target->dq_label ? target->dq_label : "", target,
+-			dr->du_ident, dr->du_fflags, (unsigned long long)dr->ds_pending_data,
+			(unsigned long long)dr->du_ident, dr->du_fflags, (unsigned long long)dr->ds_pending_data,
+ 			_du_state_registered(du_state), _du_state_armed(du_state),
+ 			(dqf & DSF_CANCELED) ? "cancelled, " : "",
+ 			(dqf & DSF_NEEDS_EVENT) ? "needs-event, " : "",
--- a/devel/libdispatch/files/patch-src_swift_Source.swift
+++ b/devel/libdispatch/files/patch-src_swift_Source.swift
@ -0,0 +1,47 @@
+--- src/swift/Source.swift.orig	2021-09-17 04:54:52 UTC
+++ src/swift/Source.swift
+@@ -116,7 +116,7 @@ extension DispatchSource {
+ 	}
+ #endif
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ 	public struct ProcessEvent : OptionSet, RawRepresentable {
+ 		public let rawValue: UInt
+ 		public init(rawValue: UInt) { self.rawValue = rawValue }
+@@ -174,7 +174,7 @@ extension DispatchSource {
+ 	}
+ #endif
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ 	public class func makeProcessSource(identifier: pid_t, eventMask: ProcessEvent, queue: DispatchQueue? = nil) -> DispatchSourceProcess {
+ 		let source = dispatch_source_create(_swift_dispatch_source_type_PROC(), UInt(identifier), eventMask.rawValue, queue?.__wrapped)
+ 		return DispatchSource(source: source) as DispatchSourceProcess
+@@ -224,7 +224,7 @@ extension DispatchSource {
+ 		return DispatchSource(source: source) as DispatchSourceUserDataReplace
+ 	}
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ 	public class func makeFileSystemObjectSource(fileDescriptor: Int32, eventMask: FileSystemEvent, queue: DispatchQueue? = nil) -> DispatchSourceFileSystemObject {
+ 		let source = dispatch_source_create(_swift_dispatch_source_type_VNODE(), UInt(fileDescriptor), eventMask.rawValue, queue?.__wrapped)
+ 		return DispatchSource(source: source) as DispatchSourceFileSystemObject
+@@ -290,7 +290,7 @@ extension DispatchSourceMemoryPressure {
+ }
+ #endif
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ extension DispatchSourceProcess {
+ 	public var handle: pid_t {
+ 		return pid_t(dispatch_source_get_handle(self as! DispatchSource))
+@@ -646,7 +646,7 @@ extension DispatchSourceTimer {
+ 	}
+ }
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ extension DispatchSourceFileSystemObject {
+ 	public var handle: Int32 {
+ 		return Int32(dispatch_source_get_handle((self as! DispatchSource).__wrapped))
--- a/devel/libdispatch/files/patch-src_swift_Wrapper.swift
+++ b/devel/libdispatch/files/patch-src_swift_Wrapper.swift
@ -0,0 +1,29 @@
+--- src/swift/Wrapper.swift.orig	2021-09-17 04:54:52 UTC
+++ src/swift/Wrapper.swift
+@@ -181,7 +181,7 @@ extension DispatchSource : DispatchSourceMachSend,
+ }
+ #endif
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ extension DispatchSource : DispatchSourceProcess,
+ 	DispatchSourceFileSystemObject {
+ }
+@@ -272,7 +272,7 @@ public protocol DispatchSourceMemoryPressure : Dispatc
+ }
+ #endif
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ public protocol DispatchSourceProcess : DispatchSourceProtocol {
+ 	var handle: pid_t { get }
+ 
+@@ -302,7 +302,7 @@ public protocol DispatchSourceTimer : DispatchSourcePr
+ 	func scheduleRepeating(wallDeadline: DispatchWallTime, interval: Double, leeway: DispatchTimeInterval)
+ }
+ 
+-#if !os(Linux) && !os(Android) && !os(Windows)
+#if !os(Linux) && !os(Android) && !os(Windows) && !os(FreeBSD)
+ public protocol DispatchSourceFileSystemObject : DispatchSourceProtocol {
+ 	var handle: Int32 { get }
+ 
--- a/devel/libdispatch/files/patch-tests_CMakeLists.txt
+++ b/devel/libdispatch/files/patch-tests_CMakeLists.txt
@ -0,0 +1,15 @@
+--- tests/CMakeLists.txt.orig	2021-09-17 04:54:52 UTC
+++ tests/CMakeLists.txt
+@@ -183,6 +183,12 @@ add_unit_test(dispatch_plusplus SOURCES dispatch_plusp
+ add_unit_test(dispatch_c99 SOURCES dispatch_c99.c)
+ add_unit_test(dispatch_plusplus SOURCES dispatch_plusplus.cpp)
+ 
+if (DISPATCH_USE_INTERNAL_WORKQUEUE)
+  add_unit_test(dispatch_workqueue
+                SOURCES
+                  dispatch_workqueue.c)
+endif()
+
+ # test-specific link options
+ if(WIN32)
+   target_link_libraries(dispatch_io_muxed PRIVATE WS2_32)
--- a/devel/libdispatch/files/patch-tests_bsdtestharness.c
+++ b/devel/libdispatch/files/patch-tests_bsdtestharness.c
@ -0,0 +1,32 @@
+--- tests/bsdtestharness.c.orig	2021-09-17 04:54:52 UTC
+++ tests/bsdtestharness.c
+@@ -20,6 +20,7 @@
+ 
+ #include <dispatch/dispatch.h>
+ #include <assert.h>
+#include <inttypes.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+@@ -151,7 +152,7 @@ main(int argc, char *argv[])
+ 	//fprintf(stderr, "pid = %d\n", pid);
+ 	assert(pid > 0);
+ 
+-#if defined(__linux__)
+#if defined(__unix__)
+ 	int status;
+ 	struct rusage usage;
+ 	struct timeval tv_stop, tv_wall;
+@@ -166,9 +167,9 @@ main(int argc, char *argv[])
+ 
+ 	assert(res2 != -1);
+ 	test_long("Process exited", (WIFEXITED(status) && WEXITSTATUS(status) && WEXITSTATUS(status) != 0xff) || WIFSIGNALED(status), 0);
+-	printf("[PERF]\twall time: %ld.%06ld\n", tv_wall.tv_sec, tv_wall.tv_usec);
+-	printf("[PERF]\tuser time: %ld.%06ld\n", usage.ru_utime.tv_sec, usage.ru_utime.tv_usec);
+-	printf("[PERF]\tsystem time: %ld.%06ld\n", usage.ru_stime.tv_sec, usage.ru_stime.tv_usec);
+	printf("[PERF]\twall time: %" PRIdMAX ".%06" PRIdMAX "\n", (intmax_t)tv_wall.tv_sec, (intmax_t)tv_wall.tv_usec);
+	printf("[PERF]\tuser time: %" PRIdMAX ".%06" PRIdMAX"\n", (intmax_t)usage.ru_utime.tv_sec, (intmax_t)usage.ru_utime.tv_usec);
+	printf("[PERF]\tsystem time: %" PRIdMAX ".%06" PRIdMAX "\n", (intmax_t)usage.ru_stime.tv_sec, (intmax_t)usage.ru_stime.tv_usec);
+ 	printf("[PERF]\tmax resident set size: %ld\n", usage.ru_maxrss);
+ 	printf("[PERF]\tpage faults: %ld\n", usage.ru_majflt);
+ 	printf("[PERF]\tswaps: %ld\n", usage.ru_nswap);
--- a/devel/libdispatch/files/patch-tests_dispatch__workqueue.c
+++ b/devel/libdispatch/files/patch-tests_dispatch__workqueue.c
@ -0,0 +1,75 @@
+--- tests/dispatch_workqueue.c.orig	2022-11-07 10:43:31 UTC
+++ tests/dispatch_workqueue.c
+@@ -0,0 +1,72 @@
+#include <bsdtests.h>
+#include "dispatch_test.h"
+
+struct test_context {
+	uint32_t ncpu;
+	int flag;
+};
+
+static void
+timeout(void *context)
+{
+	struct test_context *ctx = (struct test_context *)context;
+	sleep(2);  // Give the monitor the best chance of firing.
+	test_int32_format(ctx->flag, 1, "flag");
+	test_stop();
+}
+
+static void
+raise_flag(void *context)
+{
+	struct test_context *ctx = (struct test_context *)context;
+	ctx->flag++;
+}
+
+static void
+spin(void *context)
+{
+	struct test_context *ctx = (struct test_context *)context;
+	sleep(ctx->ncpu * 2);
+}
+
+static uint32_t
+activecpu(void)
+{
+        uint32_t activecpu;
+#if defined(__linux__) || defined(__FreeBSD__)
+        activecpu = (uint32_t)sysconf(_SC_NPROCESSORS_ONLN);
+#elif defined(_WIN32)
+        SYSTEM_INFO si;
+        GetSystemInfo(&si);
+        activecpu = si.dwNumberOfProcessors;
+#else
+        size_t s = sizeof(activecpu);
+        sysctlbyname("hw.activecpu", &activecpu, &s, NULL, 0);
+#endif
+	return activecpu;
+}
+
+int
+main(void)
+{
+	uint32_t ncpu = activecpu();
+
+	dispatch_test_start("Dispatch workqueue");
+
+	dispatch_queue_t global = dispatch_get_global_queue(0, 0);
+	test_ptr_notnull("dispatch_get_global_queue", global);
+
+	struct test_context ctx = {ncpu, 0};
+	dispatch_async_f(global, &ctx, timeout);
+
+	for(int i = 0; i < (int)ncpu - 1; i++) {
+		dispatch_async_f(global, &ctx, spin);
+	}
+
+	// All cpus are tied up at this point. Workqueue
+	// should execute this function by overcommit.
+	dispatch_async_f(global, &ctx, raise_flag);
+
+	dispatch_main();
+	return 0;
+}
--- a/devel/libdispatch/pkg-descr
+++ b/devel/libdispatch/pkg-descr
@ -0,0 +1,2 @@
+Grand Central Dispatch (GCD or libdispatch) provides comprehensive
+support for concurrent code execution on multicore hardware.
--- a/devel/libdispatch/pkg-plist
+++ b/devel/libdispatch/pkg-plist
@ -0,0 +1,35 @@
+include/Block.h
+include/dispatch/base.h
+include/dispatch/block.h
+include/dispatch/data.h
+include/dispatch/dispatch.h
+include/dispatch/group.h
+include/dispatch/introspection.h
+include/dispatch/io.h
+include/dispatch/object.h
+include/dispatch/once.h
+include/dispatch/queue.h
+include/dispatch/semaphore.h
+include/dispatch/source.h
+include/dispatch/time.h
+include/os/generic_unix_base.h
+include/os/generic_win_base.h
+include/os/object.h
+lib/libBlocksRuntime.so
+lib/libdispatch.so
+share/man/man3/dispatch.3.gz
+share/man/man3/dispatch_after.3.gz
+share/man/man3/dispatch_api.3.gz
+share/man/man3/dispatch_apply.3.gz
+share/man/man3/dispatch_async.3.gz
+share/man/man3/dispatch_data_create.3.gz
+share/man/man3/dispatch_group_create.3.gz
+share/man/man3/dispatch_io_create.3.gz
+share/man/man3/dispatch_io_read.3.gz
+share/man/man3/dispatch_object.3.gz
+share/man/man3/dispatch_once.3.gz
+share/man/man3/dispatch_queue_create.3.gz
+share/man/man3/dispatch_read.3.gz
+share/man/man3/dispatch_semaphore_create.3.gz
+share/man/man3/dispatch_source_create.3.gz
+share/man/man3/dispatch_time.3.gz