1/* 2 * Copyright (c) 2000-2012 Apple Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23/* 24 * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991 25 * All Rights Reserved 26 * 27 * Permission to use, copy, modify, and distribute this software and 28 * its documentation for any purpose and without fee is hereby granted, 29 * provided that the above copyright notice appears in all copies and 30 * that both the copyright notice and this permission notice appear in 31 * supporting documentation. 32 * 33 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 34 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 35 * FOR A PARTICULAR PURPOSE. 36 * 37 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR 38 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 39 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, 40 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 41 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 42 * 43 */ 44/* 45 * MkLinux 46 */ 47 48/* 49 * POSIX Threads - IEEE 1003.1c 50 */ 51 52#ifndef _PTHREAD_H 53#define _PTHREAD_H 54 55#include <_types.h> 56#ifndef __POSIX_LIB__ 57#include <pthread/pthread_impl.h> 58#endif 59#include <pthread/sched.h> 60#include <time.h> 61#include <sys/_pthread/_pthread_types.h> 62#include <sys/_pthread/_pthread_attr_t.h> 63#include <sys/_pthread/_pthread_cond_t.h> 64#include <sys/_pthread/_pthread_condattr_t.h> 65#include <sys/_pthread/_pthread_key_t.h> 66#include <sys/_pthread/_pthread_mutex_t.h> 67#include <sys/_pthread/_pthread_mutexattr_t.h> 68#include <sys/_pthread/_pthread_once_t.h> 69#include <sys/_pthread/_pthread_rwlock_t.h> 70#include <sys/_pthread/_pthread_rwlockattr_t.h> 71#include <sys/_pthread/_pthread_t.h> 72 73#include <pthread/qos.h> 74 75#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) 76 77#include <sys/_types/_mach_port_t.h> 78#include <sys/_types/_sigset_t.h> 79 80#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */ 81 82/* 83 * These symbols indicate which [optional] features are available 84 * They can be tested at compile time via '#ifdef XXX' 85 * The way to check for pthreads is like so: 86 87 * #include <unistd.h> 88 * #ifdef _POSIX_THREADS 89 * #include <pthread.h> 90 * #endif 91 92 */ 93 94/* These will be moved to unistd.h */ 95 96/* 97 * Note: These data structures are meant to be opaque. Only enough 98 * structure is exposed to support initializers. 99 * All of the typedefs will be moved to <sys/types.h> 100 */ 101 102#include <sys/cdefs.h> 103#include <Availability.h> 104 105__BEGIN_DECLS 106/* 107 * Threads 108 */ 109 110 111/* 112 * Cancel cleanup handler management. Note, since these are implemented as macros, 113 * they *MUST* occur in matched pairs! 114 */ 115 116#define pthread_cleanup_push(func, val) \ 117 { \ 118 struct __darwin_pthread_handler_rec __handler; \ 119 pthread_t __self = pthread_self(); \ 120 __handler.__routine = func; \ 121 __handler.__arg = val; \ 122 __handler.__next = __self->__cleanup_stack; \ 123 __self->__cleanup_stack = &__handler; 124 125#define pthread_cleanup_pop(execute) \ 126 /* Note: 'handler' must be in this same lexical context! */ \ 127 __self->__cleanup_stack = __handler.__next; \ 128 if (execute) (__handler.__routine)(__handler.__arg); \ 129 } 130 131/* 132 * Thread attributes 133 */ 134 135#define PTHREAD_CREATE_JOINABLE 1 136#define PTHREAD_CREATE_DETACHED 2 137 138#define PTHREAD_INHERIT_SCHED 1 139#define PTHREAD_EXPLICIT_SCHED 2 140 141#define PTHREAD_CANCEL_ENABLE 0x01 /* Cancel takes place at next cancellation point */ 142#define PTHREAD_CANCEL_DISABLE 0x00 /* Cancel postponed */ 143#define PTHREAD_CANCEL_DEFERRED 0x02 /* Cancel waits until cancellation point */ 144#define PTHREAD_CANCEL_ASYNCHRONOUS 0x00 /* Cancel occurs immediately */ 145 146/* Value returned from pthread_join() when a thread is canceled */ 147#define PTHREAD_CANCELED ((void *) 1) 148 149/* We only support PTHREAD_SCOPE_SYSTEM */ 150#define PTHREAD_SCOPE_SYSTEM 1 151#define PTHREAD_SCOPE_PROCESS 2 152 153/* We only support PTHREAD_PROCESS_PRIVATE */ 154#define PTHREAD_PROCESS_SHARED 1 155#define PTHREAD_PROCESS_PRIVATE 2 156 157/* 158 * Mutex protocol attributes 159 */ 160#define PTHREAD_PRIO_NONE 0 161#define PTHREAD_PRIO_INHERIT 1 162#define PTHREAD_PRIO_PROTECT 2 163 164/* 165 * Mutex type attributes 166 */ 167#define PTHREAD_MUTEX_NORMAL 0 168#define PTHREAD_MUTEX_ERRORCHECK 1 169#define PTHREAD_MUTEX_RECURSIVE 2 170#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL 171 172/* 173 * RWLock variables 174 */ 175#define PTHREAD_RWLOCK_INITIALIZER {_PTHREAD_RWLOCK_SIG_init, {0}} 176 177/* 178 * Mutex variables 179 */ 180#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}} 181 182/* <rdar://problem/10854763> */ 183#if ((__MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070) || (__IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED >= 50000)) 184# if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) 185# define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER {_PTHREAD_ERRORCHECK_MUTEX_SIG_init, {0}} 186# define PTHREAD_RECURSIVE_MUTEX_INITIALIZER {_PTHREAD_RECURSIVE_MUTEX_SIG_init, {0}} 187# endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */ 188#endif 189 190/* 191 * Condition variable attributes 192 */ 193 194/* 195 * Condition variables 196 */ 197 198#define PTHREAD_COND_INITIALIZER {_PTHREAD_COND_SIG_init, {0}} 199 200/* 201 * Initialization control (once) variables 202 */ 203 204#define PTHREAD_ONCE_INIT {_PTHREAD_ONCE_SIG_init, {0}} 205 206/* 207 * Prototypes for all PTHREAD interfaces 208 */ 209__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 210int pthread_atfork(void (*)(void), void (*)(void), void (*)(void)); 211 212__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 213int pthread_attr_destroy(pthread_attr_t *); 214 215__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 216int pthread_attr_getdetachstate(const pthread_attr_t *, int *); 217 218__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 219int pthread_attr_getguardsize(const pthread_attr_t * __restrict, size_t * __restrict); 220 221__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 222int pthread_attr_getinheritsched(const pthread_attr_t * __restrict, int * __restrict); 223 224__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 225int pthread_attr_getschedparam(const pthread_attr_t * __restrict, 226 struct sched_param * __restrict); 227 228__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 229int pthread_attr_getschedpolicy(const pthread_attr_t * __restrict, int * __restrict); 230 231__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 232int pthread_attr_getscope(const pthread_attr_t * __restrict, int * __restrict); 233 234__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 235int pthread_attr_getstack(const pthread_attr_t * __restrict, void ** __restrict, 236 size_t * __restrict); 237 238__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 239int pthread_attr_getstackaddr(const pthread_attr_t * __restrict, void ** __restrict); 240 241__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 242int pthread_attr_getstacksize(const pthread_attr_t * __restrict, size_t * __restrict); 243 244__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 245int pthread_attr_init(pthread_attr_t *); 246 247__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 248int pthread_attr_setdetachstate(pthread_attr_t *, int); 249 250__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 251int pthread_attr_setguardsize(pthread_attr_t *, size_t); 252 253__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 254int pthread_attr_setinheritsched(pthread_attr_t *, int); 255 256__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 257int pthread_attr_setschedparam(pthread_attr_t * __restrict, 258 const struct sched_param * __restrict); 259 260__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 261int pthread_attr_setschedpolicy(pthread_attr_t *, int); 262 263__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 264int pthread_attr_setscope(pthread_attr_t *, int); 265 266__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 267int pthread_attr_setstack(pthread_attr_t *, void *, size_t); 268 269__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 270int pthread_attr_setstackaddr(pthread_attr_t *, void *); 271 272__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 273int pthread_attr_setstacksize(pthread_attr_t *, size_t); 274 275__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 276int pthread_cancel(pthread_t) __DARWIN_ALIAS(pthread_cancel); 277 278__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 279int pthread_cond_broadcast(pthread_cond_t *); 280 281__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 282int pthread_cond_destroy(pthread_cond_t *); 283 284__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 285int pthread_cond_init(pthread_cond_t * __restrict, 286 const pthread_condattr_t * __restrict) __DARWIN_ALIAS(pthread_cond_init); 287 288__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 289int pthread_cond_signal(pthread_cond_t *); 290 291__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 292int pthread_cond_timedwait(pthread_cond_t * __restrict, pthread_mutex_t * __restrict, 293 const struct timespec * __restrict) __DARWIN_ALIAS_C(pthread_cond_timedwait); 294 295__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 296int pthread_cond_wait(pthread_cond_t * __restrict, 297 pthread_mutex_t * __restrict) __DARWIN_ALIAS_C(pthread_cond_wait); 298 299__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 300int pthread_condattr_destroy(pthread_condattr_t *); 301 302__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 303int pthread_condattr_init(pthread_condattr_t *); 304 305__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 306int pthread_condattr_getpshared(const pthread_condattr_t * __restrict, 307 int * __restrict); 308 309__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 310int pthread_condattr_setpshared(pthread_condattr_t *, int); 311 312__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 313int pthread_create(pthread_t * __restrict, const pthread_attr_t * __restrict, 314 void *(*)(void *), void * __restrict); 315 316__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 317int pthread_detach(pthread_t); 318 319__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 320int pthread_equal(pthread_t, pthread_t); 321 322__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 323void pthread_exit(void *) __dead2; 324 325__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 326int pthread_getconcurrency(void); 327 328__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 329int pthread_getschedparam(pthread_t , int * __restrict, 330 struct sched_param * __restrict); 331 332__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 333void* pthread_getspecific(pthread_key_t); 334 335__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 336int pthread_join(pthread_t , void **) __DARWIN_ALIAS_C(pthread_join); 337 338__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 339int pthread_key_create(pthread_key_t *, void (*)(void *)); 340 341__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 342int pthread_key_delete(pthread_key_t); 343 344__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 345int pthread_mutex_destroy(pthread_mutex_t *); 346 347__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 348int pthread_mutex_getprioceiling(const pthread_mutex_t * __restrict, 349 int * __restrict); 350 351__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 352int pthread_mutex_init(pthread_mutex_t * __restrict, 353 const pthread_mutexattr_t * __restrict); 354 355__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 356int pthread_mutex_lock(pthread_mutex_t *); 357 358__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 359int pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int, 360 int * __restrict); 361 362__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 363int pthread_mutex_trylock(pthread_mutex_t *); 364 365__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 366int pthread_mutex_unlock(pthread_mutex_t *); 367 368__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 369int pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy); 370 371__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 372int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * __restrict, 373 int * __restrict); 374 375__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 376int pthread_mutexattr_getprotocol(const pthread_mutexattr_t * __restrict, 377 int * __restrict); 378 379__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 380int pthread_mutexattr_getpshared(const pthread_mutexattr_t * __restrict, 381 int * __restrict); 382 383__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 384int pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict, 385 int * __restrict); 386 387__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 388int pthread_mutexattr_init(pthread_mutexattr_t *); 389 390__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 391int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int); 392 393__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 394int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int); 395 396__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 397int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int); 398 399__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 400int pthread_mutexattr_settype(pthread_mutexattr_t *, int); 401 402__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 403int pthread_once(pthread_once_t *, void (*)(void)); 404 405__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 406int pthread_rwlock_destroy(pthread_rwlock_t * ) __DARWIN_ALIAS(pthread_rwlock_destroy); 407 408__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 409int pthread_rwlock_init(pthread_rwlock_t * __restrict, 410 const pthread_rwlockattr_t * __restrict) __DARWIN_ALIAS(pthread_rwlock_init); 411 412__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 413int pthread_rwlock_rdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_rdlock); 414 415__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 416int pthread_rwlock_tryrdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_tryrdlock); 417 418__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 419int pthread_rwlock_trywrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_trywrlock); 420 421__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 422int pthread_rwlock_wrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_wrlock); 423 424__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 425int pthread_rwlock_unlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_unlock); 426 427__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 428int pthread_rwlockattr_destroy(pthread_rwlockattr_t *); 429 430__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 431int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t * __restrict, 432 int * __restrict); 433 434__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 435int pthread_rwlockattr_init(pthread_rwlockattr_t *); 436 437__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 438int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int); 439 440__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 441pthread_t pthread_self(void); 442 443__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 444int pthread_setcancelstate(int , int *) __DARWIN_ALIAS(pthread_setcancelstate); 445 446__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 447int pthread_setcanceltype(int , int *) __DARWIN_ALIAS(pthread_setcanceltype); 448 449__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 450int pthread_setconcurrency(int); 451 452__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 453int pthread_setschedparam(pthread_t, int, const struct sched_param *); 454 455__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 456int pthread_setspecific(pthread_key_t , const void *); 457 458__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 459void pthread_testcancel(void) __DARWIN_ALIAS(pthread_testcancel); 460 461#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) 462 463/* returns non-zero if pthread_create or cthread_fork have been called */ 464__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 465int pthread_is_threaded_np(void); 466 467__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2) 468int pthread_threadid_np(pthread_t,__uint64_t*); 469 470/*SPI to set and get pthread name*/ 471__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2) 472int pthread_getname_np(pthread_t,char*,size_t); 473 474__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2) 475int pthread_setname_np(const char*); 476 477/* returns non-zero if the current thread is the main thread */ 478__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 479int pthread_main_np(void); 480 481/* return the mach thread bound to the pthread */ 482__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 483mach_port_t pthread_mach_thread_np(pthread_t); 484 485__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 486size_t pthread_get_stacksize_np(pthread_t); 487 488__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 489void* pthread_get_stackaddr_np(pthread_t); 490 491/* Like pthread_cond_signal(), but only wake up the specified pthread */ 492__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 493int pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t); 494 495/* Like pthread_cond_timedwait, but use a relative timeout */ 496__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 497int pthread_cond_timedwait_relative_np(pthread_cond_t *, pthread_mutex_t *, 498 const struct timespec *); 499 500/* Like pthread_create(), but leaves the thread suspended */ 501__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 502int pthread_create_suspended_np(pthread_t *, const pthread_attr_t *, 503 void *(*)(void *), void *); 504 505__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 506int pthread_kill(pthread_t, int); 507 508__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0) 509pthread_t pthread_from_mach_thread_np(mach_port_t); 510 511__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 512int pthread_sigmask(int, const sigset_t *, sigset_t *) __DARWIN_ALIAS(pthread_sigmask); 513 514__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0) 515void pthread_yield_np(void); 516 517#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */ 518__END_DECLS 519#endif /* _PTHREAD_H */ 520