pthread.h

Value returned from pthread_join() when a thread is canceled

#define PTHREAD_CANCELED ((void *) 1)

We only support PTHREAD_SCOPE_SYSTEM

#define PTHREAD_SCOPE_SYSTEM 1

Mutex protocol attributes

#define PTHREAD_PRIO_NONE 0

Mutex type attributes

#define PTHREAD_MUTEX_NORMAL 0

Mutex policy attributes

#define PTHREAD_MUTEX_POLICY_FAIRSHARE_NP 1

RWLock variables

#define PTHREAD_RWLOCK_INITIALIZER {_PTHREAD_RWLOCK_SIG_init, {0}}

Mutex variables

#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}

<rdar://problem/10854763>

#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER {_PTHREAD_ERRORCHECK_MUTEX_SIG_init, {0}}

<rdar://problem/25944576>

#define _PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT() defined(SWIFT_CLASS_EXTRA) && (!defined(SWIFT_SDK_OVERLAY_PTHREAD_EPOCH) || (SWIFT_SDK_OVERLAY_PTHREAD_EPOCH < 1))

__API_AVAILABLE(macos(10.4), ios(2.0))
int pthread_atfork(
	void (* _Nullable)(void),
	void (* _Nullable)(void),
	void (* _Nullable)(void)
)

Prototypes for all PTHREAD interfaces

__API_AVAILABLE(macos(10.4), ios(2.0))
int pthread_is_threaded_np(void)

returns non-zero if pthread_create or cthread_fork have been called

__API_AVAILABLE(macos(10.6), ios(3.2))
int pthread_getname_np(pthread_t, char*, size_t)

SPI to set and get pthread name

__API_AVAILABLE(macos(10.4), ios(2.0))
int pthread_main_np(void)

returns non-zero if the current thread is the main thread

__API_AVAILABLE(macos(10.4), ios(2.0))
mach_port_t pthread_mach_thread_np(pthread_t)

return the mach thread bound to the pthread

__API_AVAILABLE(macos(10.4), ios(2.0))
int pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t _Nullable)

Like pthread_cond_signal(), but only wake up the specified pthread

__API_AVAILABLE(macos(10.4), ios(2.0)) __PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use an asynchronous wait instead of a synchronous wait")
int pthread_cond_timedwait_relative_np(
	pthread_cond_t *,
	pthread_mutex_t *,
	const struct timespec * _Nullable
)

Like pthread_cond_timedwait, but use a relative timeout

__API_AVAILABLE(macos(10.4), ios(2.0))
int pthread_create_suspended_np(
	pthread_t _Nullable * _Nonnull,
	const pthread_attr_t * _Nullable,
	void * _Nullable (* _Nonnull)(void * _Nullable),
	void * _Nullable
)

Like pthread_create(), but leaves the thread suspended

@typedef pthread_jit_write_callback_t The type of a function that can be supplied to {@link pthread_jit_write_with_callback_np} to write to the MAP_JIT region while it is writeable. @param ctx A pointer to context that will be passed through to the callback function. @result A result code to be returned to the caller of @{link pthread_jit_write_with_callback_np}. The system does not interpret/act on the value of this result.

typedef int (*pthread_jit_write_callback_t)(void * _Nullable ctx)

@define PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP A macro to be used at file scope to list the functions allowed to be passed to {@link pthread_jit_write_with_callback_np} to write to the MAP_JIT region while it is writeable. It may be invoked only once per executable/library. @param callbacks The pthread_jit_write_callback_t functions to allow. They should be supplied as a comma-delimited list.

#define PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP(...) __attribute__((__used__, __section__("__DATA_CONST,__pth_jit_func")))
		static const pthread_jit_write_callback_t __pthread_jit_write_callback_allowlist[] = {
			__VA_ARGS__, NULL
		}

__API_AVAILABLE(macos(11.4), ios(17.4)) __API_UNAVAILABLE(tvos, watchos, driverkit, visionos) __SWIFT_UNAVAILABLE_MSG("This interface cannot be safely used from Swift")
int pthread_jit_write_with_callback_np(
	pthread_jit_write_callback_t _Nonnull callback,
	void * _Nullable ctx
)

@function pthread_jit_write_with_callback_np @abstract Toggles per-thread write-protection of the MAP_JIT region to writeable, invokes an allowed callback function to write to it, and toggles protection back to executable. @param callback The callback function to invoke to write to the MAP_JIT region. It must be statically allowed using {@link PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP}. @param ctx Context to pass through to the invocation of the callback function. @result The result code returned by the callback function. @discussion This function assumes that the MAP_JIT region has executable protection when called. It is therefore invalid to call it recursively from within a write callback. The implementation does not detect such invalid recursive calls, so the client is responsible for preventing them. Callbacks _must not_ perform any non-local transfer of control flow (e.g. throw an exception, longjmp(3)), as doing so would leave the MAP_JIT region writeable. On systems where pthread_jit_write_protect_supported_np(3) is false, this function calls @callback directly and does nothing else. This function only enforces that @callback is allowed if the caller has the com.apple.security.cs.jit-write-allowlist entitlement. That entitlement also disallows use of pthread_jit_write_protect_np(3). Adopting the entitlement is therefore crucial in realizing the security benefits of this interface. If the entitlement is not present then this function toggles protection of the MAP_JIT to writeable, calls @callback and then toggles protection back to executable, without validating that @callback is an allowed function. This behavior is intended to permit independent adoption of this interface by libraries - once all libraries in an application have adopted, the application should add the entitlement. By default, only callbacks in libraries/images present at process start-up are allowed - callbacks in images loaded dynamically via dlopen(3)/etc. are not permitted. However, if the additional entitlement com.apple.security.cs.jit-write-allowlist-freeze-late is _also_ present, any callbacks in dlopen'd libraries are also added to the set of allowed callbacks until the {@link pthread_jit_write_freeze_callbacks_np} function is called. The goal of this interface is to allow applications that execute JIT-compiled code to mitigate against attempts from attackers to escalate to code execution by getting their own instructions written to the MAP_JIT region. Callbacks should assume an attacker can control the input to this function. They must therefore carefully validate the data that they are passed and do so using as little attackable state as possible. This means simplifying control flow and avoiding spills of sensitive registers (e.g. those used for validation or control flow). In the event a callback detects that its input is invalid, it should either abort in the simplest fashion possible (preferring e.g. __builtin_trap() over abort(3), the latter being encumbered by various conformance requirements) or return a result indicating failure.

__API_AVAILABLE(macos(12.1), ios(17.4)) __API_UNAVAILABLE(tvos, watchos, driverkit, visionos)
void pthread_jit_write_freeze_callbacks_np(void)

@function pthread_jit_write_freeze_callbacks_np @abstract Freezes the set of allowed pthread JIT write callbacks, preventing any callbacks in subsequently dlopen'd libraries from being allowed as arguments to {@link pthread_jit_write_with_callback_np} @discussion If the com.apple.security.cs.jit-write-allowlist-freeze-late entitlement is present, this function must be called exactly once after all libraries containing JIT write callbacks have been loaded to prevent any further runtime modifications to the set of allowed callbacks. Failing to call this function before calling pthread_jit_write_with_callback_np(3) for the first time is an error, as is calling it multiple times. If the jit-write-allowlist-freeze-late entitlement is not present, calling this function is an error. If an application does not need to dlopen(3) any libraries or frameworks containing needed JIT write callbacks, it is best to avoid the jit-write-allowlist-freeze-late entitlement and accompanying need to call this function, as this allows the runtime to automatically freeze the set of allowed callbacks early in process initialization.

__API_AVAILABLE(macos(11.0), ios(14.2), tvos(14.2), watchos(7.1))
int pthread_cpu_number_np(size_t *cpu_number_out)

@function pthread_cpu_number_np @param cpu_number_out The CPU number that the thread was running on at the time of query. This cpu number is in the interval [0, ncpus) (from sysctlbyname("hw.ncpu")) @result This function returns 0 or the value of errno if an error occurred. @note Optimizations of per-CPU datastructures based on the result of this function still require synchronization since it is not guaranteed that the thread will still be on the same CPU by the time the function returns.