+++ /dev/null
-/*
- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
- * All Rights Reserved
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright notice appears in all copies and
- * that both the copyright notice and this permission notice appear in
- * supporting documentation.
- *
- * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE.
- *
- * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
- * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/*
- * MkLinux
- */
-
-/*
- * POSIX Pthread Library
- */
-
-#include "pthread_internals.h"
-#include "pthread_workqueue.h"
-
-#include <assert.h>
-#include <stdio.h> /* For printf(). */
-#include <stdlib.h>
-#include <errno.h> /* For __mach_errno_addr() prototype. */
-#include <signal.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/sysctl.h>
-#include <sys/queue.h>
-#include <sys/mman.h>
-#include <machine/vmparam.h>
-#include <mach/vm_statistics.h>
-#include <mach/mach_init.h>
-#define __APPLE_API_PRIVATE
-#include <machine/cpu_capabilities.h>
-#include <libkern/OSAtomic.h>
-#if defined(__ppc__)
-#include <libkern/OSCrossEndian.h>
-#endif
-#include <dispatch/private.h> /* for at_fork handlers */
-
-
-extern int _pthread_setcancelstate_internal(int state, int *oldstate, int conforming);
-extern int __pthread_sigmask(int, const sigset_t *, sigset_t *);
-
-#ifndef BUILDING_VARIANT /* [ */
-
-__private_extern__ struct __pthread_list __pthread_head = TAILQ_HEAD_INITIALIZER(__pthread_head);
-
-
-
-int32_t workq_targetconc[WORKQ_NUM_PRIOQUEUE];
-
-/* Per-thread kernel support */
-extern void _pthread_set_self(pthread_t);
-extern void mig_init(int);
-static int _pthread_create_pthread_onstack(pthread_attr_t *attrs, void **stack, pthread_t *thread);
-static kern_return_t _pthread_free_pthread_onstack(pthread_t t, int freestruct, int termthread);
-static void _pthread_struct_init(pthread_t t, const pthread_attr_t *attrs, void * stack, size_t stacksize, int kernalloc, int nozero);
-static int _new_pthread_create_suspended(pthread_t *thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *),
- void *arg,
- int create_susp);
-
-/* the registered libdispatch worker function */
-static void (*__libdispatch_workerfunction)(int, int, void *) = NULL;
-
-/* Get CPU capabilities from the kernel */
-__private_extern__ void _init_cpu_capabilities(void);
-
-/* Needed to tell the malloc subsystem we're going multithreaded */
-extern void set_malloc_singlethreaded(int);
-
-/* Used when we need to call into the kernel with no reply port */
-extern pthread_lock_t reply_port_lock;
-int _pthread_find_thread(pthread_t thread);
-
-/* Mach message used to notify that a thread needs to be reaped */
-
-typedef struct _pthread_reap_msg_t {
- mach_msg_header_t header;
- pthread_t thread;
- mach_msg_trailer_t trailer;
-} pthread_reap_msg_t;
-
-/* Utilitie */
-
-__private_extern__ uintptr_t commpage_pfz_base=0;
-
-void __pthread_pfz_setup(const char *apple[]) __attribute__ ((visibility ("hidden")));
-
-static uintptr_t __pfz_from_kernel(const char *str)
-{
- unsigned long tmpval;
- /* Skip over key to the first value */
- str = strchr(str, '=');
- if (str == NULL)
- return 0;
- str++;
- tmpval = strtoul(str, NULL, 0); /* may err by 0 or ULONG_MAX */
- if (tmpval == ULONG_MAX)
- tmpval = 0;
-
- return (uintptr_t) tmpval;
-}
-
-void
-__pthread_pfz_setup(const char *apple[])
-{
- const char **p;
- for (p = apple; p && *p; p++) {
- /* checking if matching apple variable is at begining */
- if (strstr(*p, "pfz=") == *p) {
- commpage_pfz_base = __pfz_from_kernel(*p);
- bzero(*p,strlen(*p));
- break;
- }
- }
-
- if (commpage_pfz_base == 0)
- commpage_pfz_base = _COMM_PAGE_TEXT_START;
-
- return;
-}
-
-
-/* We'll implement this when the main thread is a pthread */
-/* Use the local _pthread struct to avoid malloc before our MiG reply port is set */
-static struct _pthread _thread = {0};
-
-/* This global should be used (carefully) by anyone needing to know if a
-** pthread has been created.
-*/
-int __is_threaded = 0;
-/* _pthread_count is protected by _pthread_list_lock */
-static int _pthread_count = 1;
-int __unix_conforming = 0;
-static int __workqueue_newspis = 0;
-static int __workqueue_oldspis = 0;
-__private_extern__ size_t pthreadsize = 0;
-
-/* under rosetta we will use old style creation of threads */
-static int __oldstyle = 0;
-
-__private_extern__ pthread_lock_t _pthread_list_lock = LOCK_INITIALIZER;
-
-/* Same implementation as LOCK, but without the __is_threaded check */
-int _spin_tries = 0;
-extern kern_return_t syscall_thread_switch(mach_port_name_t, int, mach_msg_timeout_t);
-__private_extern__ void _spin_lock_retry(pthread_lock_t *lock)
-{
- int tries = _spin_tries;
- do {
- if (tries-- > 0)
- continue;
- syscall_thread_switch(THREAD_NULL, SWITCH_OPTION_DEPRESS, 1);
- tries = _spin_tries;
- } while(!_spin_lock_try(lock));
-}
-
-static mach_port_t thread_recycle_port = MACH_PORT_NULL;
-
-/* These are used to keep track of a semaphore pool shared by mutexes and condition
-** variables.
-*/
-
-static semaphore_t *sem_pool = NULL;
-static int sem_pool_count = 0;
-static int sem_pool_current = 0;
-static pthread_lock_t sem_pool_lock = LOCK_INITIALIZER;
-
-static int default_priority;
-static int max_priority;
-static int min_priority;
-static int pthread_concurrency;
-
-static OSSpinLock __workqueue_list_lock = OS_SPINLOCK_INIT;
-
-static void _pthread_exit(pthread_t self, void *value_ptr) __dead2;
-static void _pthread_setcancelstate_exit(pthread_t self, void *value_ptr, int conforming);
-static pthread_attr_t _pthread_attr_default = {0};
-static void _pthread_workq_init(pthread_workqueue_t wq, const pthread_workqueue_attr_t * attr);
-static int kernel_workq_setup = 0;
-static volatile int32_t kernel_workq_count = 0;
-static volatile unsigned int user_workq_count = 0; /* number of outstanding workqueues */
-static volatile unsigned int user_workitem_count = 0; /* number of outstanding workitems */
-#define KERNEL_WORKQ_ELEM_MAX 64 /* Max number of elements in the kerrel */
-static int wqreadyprio = 0; /* current highest prio queue ready with items */
-
-__private_extern__ struct __pthread_workitem_pool __pthread_workitem_pool_head = TAILQ_HEAD_INITIALIZER(__pthread_workitem_pool_head);
-__private_extern__ struct __pthread_workqueue_pool __pthread_workqueue_pool_head = TAILQ_HEAD_INITIALIZER(__pthread_workqueue_pool_head);
-
-static struct _pthread_workitem * __workqueue_pool_ptr;
-static size_t __workqueue_pool_size = 0;
-static int __workqueue_nitems = 0;
-
-struct _pthread_workqueue_head __pthread_workq0_head;
-struct _pthread_workqueue_head __pthread_workq1_head;
-struct _pthread_workqueue_head __pthread_workq2_head;
-struct _pthread_workqueue_head __pthread_workq3_head;
-pthread_workqueue_head_t __pthread_wq_head_tbl[WORKQ_NUM_PRIOQUEUE] = {&__pthread_workq0_head, &__pthread_workq1_head, &__pthread_workq2_head, &__pthread_workq3_head};
-
-static void workqueue_list_lock(void);
-static void workqueue_list_unlock(void);
-static int valid_workq(pthread_workqueue_t);
-static void pick_nextworkqueue_droplock(void);
-static int post_nextworkitem(pthread_workqueue_t workq);
-static void _pthread_workq_return(pthread_t self);
-static pthread_workqueue_attr_t _pthread_wq_attr_default = {0};
-extern void start_wqthread(pthread_t self, mach_port_t kport, void * stackaddr, pthread_workitem_t item, int reuse);
-extern void thread_start(pthread_t self, mach_port_t kport, void *(*fun)(void *), void * funarg, size_t stacksize, unsigned int flags);
-static pthread_workitem_t alloc_workitem(void);
-static void free_workitem(pthread_workitem_t);
-static void grow_workitem(void);
-static pthread_workqueue_t alloc_workqueue(void);
-static void free_workqueue(pthread_workqueue_t);
-static int _pthread_work_internal_init(void);
-static void workqueue_exit(pthread_t self, pthread_workqueue_t workq, pthread_workitem_t item);
-void _pthread_fork_child_postinit();
-
-void pthread_workqueue_atfork_prepare(void);
-void pthread_workqueue_atfork_parent(void);
-void pthread_workqueue_atfork_child(void);
-
-extern void dispatch_atfork_prepare(void);
-extern void dispatch_atfork_parent(void);
-extern void dispatch_atfork_child(void);
-
-/* workq_kernreturn commands */
-#define WQOPS_QUEUE_ADD 1
-#define WQOPS_QUEUE_REMOVE 2
-#define WQOPS_THREAD_RETURN 4
-#define WQOPS_THREAD_SETCONC 8
-#define WQOPS_QUEUE_NEWSPISUPP 0x10 /* this is to check for newer SPI support */
-#define WQOPS_QUEUE_REQTHREADS 0x20 /* request number of threads of a prio */
-
-/* flag values for reuse field in the libc side _pthread_wqthread */
-#define WQ_FLAG_THREAD_PRIOMASK 0x0000ffff
-#define WQ_FLAG_THREAD_OVERCOMMIT 0x00010000 /* thread is with overcommit prio */
-#define WQ_FLAG_THREAD_REUSE 0x00020000 /* thread is being reused */
-#define WQ_FLAG_THREAD_NEWSPI 0x00040000 /* the call is with new SPIs */
-
-
-#define WORKQUEUE_OVERCOMMIT 0x10000 /* the work_kernreturn() for overcommit in prio field */
-
-/*
- * Flags filed passed to bsdthread_create and back in pthread_start
-31 <---------------------------------> 0
-_________________________________________
-| flags(8) | policy(8) | importance(16) |
------------------------------------------
-*/
-__private_extern__
-void _pthread_start(pthread_t self, mach_port_t kport, void *(*fun)(void *), void * funarg, size_t stacksize, unsigned int flags);
-
-__private_extern__
-void _pthread_wqthread(pthread_t self, mach_port_t kport, void * stackaddr, pthread_workitem_t item, int reuse);
-
-#define PTHREAD_START_CUSTOM 0x01000000
-#define PTHREAD_START_SETSCHED 0x02000000
-#define PTHREAD_START_DETACHED 0x04000000
-#define PTHREAD_START_POLICY_BITSHIFT 16
-#define PTHREAD_START_POLICY_MASK 0xff
-#define PTHREAD_START_IMPORTANCE_MASK 0xffff
-
-static int pthread_setschedparam_internal(pthread_t, mach_port_t, int, const struct sched_param *);
-extern pthread_t __bsdthread_create(void *(*func)(void *), void * func_arg, void * stack, pthread_t thread, unsigned int flags);
-extern int __bsdthread_register(void (*)(pthread_t, mach_port_t, void *(*)(void *), void *, size_t, unsigned int), void (*)(pthread_t, mach_port_t, void *, pthread_workitem_t, int), int,void (*)(pthread_t, mach_port_t, void *(*)(void *), void *, size_t, unsigned int), int32_t *,__uint64_t);
-extern int __bsdthread_terminate(void * freeaddr, size_t freesize, mach_port_t kport, mach_port_t joinsem);
-extern __uint64_t __thread_selfid( void );
-extern int __pthread_canceled(int);
-extern void _pthread_keys_init(void);
-extern int __pthread_kill(mach_port_t, int);
-extern int __pthread_markcancel(int);
-extern int __workq_open(void);
-
-
-extern int __workq_kernreturn(int, pthread_workitem_t, int, int);
-
-#if defined(__ppc__) || defined(__ppc64__)
-static const vm_address_t PTHREAD_STACK_HINT = 0xF0000000;
-#elif defined(__i386__) || defined(__x86_64__)
-static const vm_address_t PTHREAD_STACK_HINT = 0xB0000000;
-#elif defined(__arm__)
-static const vm_address_t PTHREAD_STACK_HINT = 0x30000000;
-#else
-#error Need to define a stack address hint for this architecture
-#endif
-
-/* Set the base address to use as the stack pointer, before adjusting due to the ABI
- * The guardpages for stackoverflow protection is also allocated here
- * If the stack was already allocated(stackaddr in attr) then there are no guardpages
- * set up for the thread
- */
-
-static int
-_pthread_allocate_stack(pthread_attr_t *attrs, void **stack)
-{
- kern_return_t kr;
- vm_address_t stackaddr;
- size_t guardsize;
-
- assert(attrs->stacksize >= PTHREAD_STACK_MIN);
- if (attrs->stackaddr != NULL) {
- /* No guard pages setup in this case */
- assert(((uintptr_t)attrs->stackaddr % vm_page_size) == 0);
- *stack = attrs->stackaddr;
- return 0;
- }
-
- guardsize = attrs->guardsize;
- stackaddr = PTHREAD_STACK_HINT;
- kr = vm_map(mach_task_self(), &stackaddr,
- attrs->stacksize + guardsize,
- vm_page_size-1,
- VM_MAKE_TAG(VM_MEMORY_STACK)| VM_FLAGS_ANYWHERE , MEMORY_OBJECT_NULL,
- 0, FALSE, VM_PROT_DEFAULT, VM_PROT_ALL,
- VM_INHERIT_DEFAULT);
- if (kr != KERN_SUCCESS)
- kr = vm_allocate(mach_task_self(),
- &stackaddr, attrs->stacksize + guardsize,
- VM_MAKE_TAG(VM_MEMORY_STACK)| VM_FLAGS_ANYWHERE);
- if (kr != KERN_SUCCESS) {
- return EAGAIN;
- }
- /* The guard page is at the lowest address */
- /* The stack base is the highest address */
- if (guardsize)
- kr = vm_protect(mach_task_self(), stackaddr, guardsize, FALSE, VM_PROT_NONE);
- *stack = (void *)(stackaddr + attrs->stacksize + guardsize);
- return 0;
-}
-
-static int
-_pthread_create_pthread_onstack(pthread_attr_t *attrs, void **stack, pthread_t *thread)
-{
- kern_return_t kr;
- pthread_t t;
- vm_address_t stackaddr;
- size_t guardsize, allocsize;
-
- assert(attrs->stacksize >= PTHREAD_STACK_MIN);
-
- if (attrs->stackaddr != NULL) {
- /* No guard pages setup in this case */
- assert(((uintptr_t)attrs->stackaddr % vm_page_size) == 0);
- *stack = attrs->stackaddr;
- t = (pthread_t)malloc(pthreadsize);
- _pthread_struct_init(t, attrs, attrs->stackaddr, 0, 0, 0);
- t->freeStackOnExit = 0;
- t->freeaddr = 0;
- t->freesize = 0;
- *thread = t;
- return 0;
- }
-
- guardsize = attrs->guardsize;
- allocsize = attrs->stacksize + guardsize + pthreadsize;
- stackaddr = PTHREAD_STACK_HINT;
- kr = vm_map(mach_task_self(), &stackaddr,
- allocsize,
- vm_page_size-1,
- VM_MAKE_TAG(VM_MEMORY_STACK)| VM_FLAGS_ANYWHERE , MEMORY_OBJECT_NULL,
- 0, FALSE, VM_PROT_DEFAULT, VM_PROT_ALL,
- VM_INHERIT_DEFAULT);
- if (kr != KERN_SUCCESS)
- kr = vm_allocate(mach_task_self(),
- &stackaddr, allocsize,
- VM_MAKE_TAG(VM_MEMORY_STACK)| VM_FLAGS_ANYWHERE);
- if (kr != KERN_SUCCESS) {
- return EAGAIN;
- }
- /* The guard page is at the lowest address */
- /* The stack base is the highest address */
- if (guardsize)
- kr = vm_protect(mach_task_self(), stackaddr, guardsize, FALSE, VM_PROT_NONE);
-
-
- *stack = (void *)(stackaddr + attrs->stacksize + guardsize);
-
- t = (pthread_t)(stackaddr + attrs->stacksize + guardsize);
- _pthread_struct_init(t, attrs, *stack, 0, 0, 1);
- t->kernalloc = 0;
- t->freesize = allocsize;
- t->freeaddr = (void *)stackaddr;
- t->freeStackOnExit = 1;
- *thread = t;
-
- return 0;
-}
-
-static kern_return_t
-_pthread_free_pthread_onstack(pthread_t t, int freestruct, int termthread)
-{
- kern_return_t res = 0;
- vm_address_t freeaddr;
- size_t freesize;
- int thread_count;
- mach_port_t kport;
- semaphore_t joinsem = SEMAPHORE_NULL;
-
-#if PTH_TRACE
- __kdebug_trace(0x900001c, freestruct, termthread, 0, 0, 0);
-#endif
- kport = t->kernel_thread;
- joinsem = t->joiner_notify;
-
- if (t->freeStackOnExit) {
- freeaddr = (vm_address_t)t->freeaddr;
- if (freestruct)
- freesize = t->stacksize + t->guardsize + pthreadsize;
- else
- freesize = t->stacksize + t->guardsize;
- if (termthread) {
- mig_dealloc_reply_port(MACH_PORT_NULL);
- LOCK(_pthread_list_lock);
- if (freestruct != 0) {
- TAILQ_REMOVE(&__pthread_head, t, plist);
- /* if parent has not returned from create yet keep pthread_t */
-#if PTH_LISTTRACE
- __kdebug_trace(0x9000010, t, 0, 0, 1, 0);
-#endif
- if (t->parentcheck == 0)
- freesize -= pthreadsize;
- }
- t->childexit = 1;
- thread_count = --_pthread_count;
- UNLOCK(_pthread_list_lock);
-
-#if PTH_TRACE
- __kdebug_trace(0x9000020, freeaddr, freesize, kport, 1, 0);
-#endif
- if (thread_count <=0)
- exit(0);
- else
- __bsdthread_terminate((void *)freeaddr, freesize, kport, joinsem);
- LIBC_ABORT("thread %p didn't terminate", t);
- } else {
-#if PTH_TRACE
- __kdebug_trace(0x9000024, freeaddr, freesize, 0, 1, 0);
-#endif
- res = vm_deallocate(mach_task_self(), freeaddr, freesize);
- }
- } else {
- if (termthread) {
- mig_dealloc_reply_port(MACH_PORT_NULL);
- LOCK(_pthread_list_lock);
- if (freestruct != 0) {
- TAILQ_REMOVE(&__pthread_head, t, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x9000010, t, 0, 0, 2, 0);
-#endif
- }
- thread_count = --_pthread_count;
- t->childexit = 1;
- UNLOCK(_pthread_list_lock);
-
- if (freestruct) {
-#if PTH_TRACE
- __kdebug_trace(0x9000008, t, 0, 0, 2, 0);
-#endif
- free(t);
- }
-
- freeaddr = 0;
- freesize = 0;
-#if PTH_TRACE
- __kdebug_trace(0x9000020, 0, 0, kport, 2, 0);
-#endif
-
- if (thread_count <=0)
- exit(0);
- else
- __bsdthread_terminate(NULL, 0, kport, joinsem);
- LIBC_ABORT("thread %p didn't terminate", t);
- } else if (freestruct) {
- t->sig = _PTHREAD_NO_SIG;
-#if PTH_TRACE
- __kdebug_trace(0x9000024, t, 0, 0, 2, 0);
-#endif
- free(t);
- }
- }
- return(res);
-}
-
-
-
-/*
- * Destroy a thread attribute structure
- */
-int
-pthread_attr_destroy(pthread_attr_t *attr)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- attr->sig = 0;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Get the 'detach' state from a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_getdetachstate(const pthread_attr_t *attr,
- int *detachstate)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- *detachstate = attr->detached;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Get the 'inherit scheduling' info from a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_getinheritsched(const pthread_attr_t *attr,
- int *inheritsched)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- *inheritsched = attr->inherit;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Get the scheduling parameters from a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_getschedparam(const pthread_attr_t *attr,
- struct sched_param *param)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- *param = attr->param;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Get the scheduling policy from a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_getschedpolicy(const pthread_attr_t *attr,
- int *policy)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- *policy = attr->policy;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/* Retain the existing stack size of 512K and not depend on Main thread default stack size */
-static const size_t DEFAULT_STACK_SIZE = (512*1024);
-/*
- * Initialize a thread attribute structure to default values.
- */
-int
-pthread_attr_init(pthread_attr_t *attr)
-{
- attr->stacksize = DEFAULT_STACK_SIZE;
- attr->stackaddr = NULL;
- attr->sig = _PTHREAD_ATTR_SIG;
- attr->param.sched_priority = default_priority;
- attr->param.quantum = 10; /* quantum isn't public yet */
- attr->detached = PTHREAD_CREATE_JOINABLE;
- attr->inherit = _PTHREAD_DEFAULT_INHERITSCHED;
- attr->policy = _PTHREAD_DEFAULT_POLICY;
- attr->freeStackOnExit = 1;
- attr->fastpath = 1;
- attr->schedset = 0;
- attr->guardsize = vm_page_size;
- return (0);
-}
-
-/*
- * Set the 'detach' state in a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_setdetachstate(pthread_attr_t *attr,
- int detachstate)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- if ((detachstate == PTHREAD_CREATE_JOINABLE) ||
- (detachstate == PTHREAD_CREATE_DETACHED))
- {
- attr->detached = detachstate;
- return (0);
- } else
- {
- return (EINVAL);
- }
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Set the 'inherit scheduling' state in a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_setinheritsched(pthread_attr_t *attr,
- int inheritsched)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- if ((inheritsched == PTHREAD_INHERIT_SCHED) ||
- (inheritsched == PTHREAD_EXPLICIT_SCHED))
- {
- attr->inherit = inheritsched;
- return (0);
- } else
- {
- return (EINVAL);
- }
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Set the scheduling paramters in a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_setschedparam(pthread_attr_t *attr,
- const struct sched_param *param)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- /* TODO: Validate sched_param fields */
- attr->param = *param;
- attr->schedset = 1;
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Set the scheduling policy in a thread attribute structure.
- * Note: written as a helper function for info hiding
- */
-int
-pthread_attr_setschedpolicy(pthread_attr_t *attr,
- int policy)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG)
- {
- if ((policy == SCHED_OTHER) ||
- (policy == SCHED_RR) ||
- (policy == SCHED_FIFO))
- {
- attr->policy = policy;
- attr->schedset = 1;
- return (0);
- } else
- {
- return (EINVAL);
- }
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/*
- * Set the scope for the thread.
- * We currently only provide PTHREAD_SCOPE_SYSTEM
- */
-int
-pthread_attr_setscope(pthread_attr_t *attr,
- int scope)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- if (scope == PTHREAD_SCOPE_SYSTEM) {
- /* No attribute yet for the scope */
- return (0);
- } else if (scope == PTHREAD_SCOPE_PROCESS) {
- return (ENOTSUP);
- }
- }
- return (EINVAL); /* Not an attribute structure! */
-}
-
-/*
- * Get the scope for the thread.
- * We currently only provide PTHREAD_SCOPE_SYSTEM
- */
-int
-pthread_attr_getscope(const pthread_attr_t *attr,
- int *scope)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- *scope = PTHREAD_SCOPE_SYSTEM;
- return (0);
- }
- return (EINVAL); /* Not an attribute structure! */
-}
-
-/* Get the base stack address of the given thread */
-int
-pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- *stackaddr = attr->stackaddr;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-int
-pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
-{
- if ((attr->sig == _PTHREAD_ATTR_SIG) && (((uintptr_t)stackaddr % vm_page_size) == 0)) {
- attr->stackaddr = stackaddr;
- attr->freeStackOnExit = 0;
- attr->fastpath = 0;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-int
-pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- *stacksize = attr->stacksize;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-int
-pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
-{
- if ((attr->sig == _PTHREAD_ATTR_SIG) && ((stacksize % vm_page_size) == 0) && (stacksize >= PTHREAD_STACK_MIN)) {
- attr->stacksize = stacksize;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-int
-pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t * stacksize)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- *stackaddr = (void *)((uintptr_t)attr->stackaddr - attr->stacksize);
- *stacksize = attr->stacksize;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-/* By SUSV spec, the stackaddr is the base address, the lowest addressable
- * byte address. This is not the same as in pthread_attr_setstackaddr.
- */
-int
-pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize)
-{
- if ((attr->sig == _PTHREAD_ATTR_SIG) &&
- (((uintptr_t)stackaddr % vm_page_size) == 0) &&
- ((stacksize % vm_page_size) == 0) && (stacksize >= PTHREAD_STACK_MIN)) {
- attr->stackaddr = (void *)((uintptr_t)stackaddr + stacksize);
- attr->stacksize = stacksize;
- attr->freeStackOnExit = 0;
- attr->fastpath = 0;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-
-/*
- * Set the guardsize attribute in the attr.
- */
-int
-pthread_attr_setguardsize(pthread_attr_t *attr,
- size_t guardsize)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- /* Guardsize of 0 is valid, ot means no guard */
- if ((guardsize % vm_page_size) == 0) {
- attr->guardsize = guardsize;
- attr->fastpath = 0;
- return (0);
- } else
- return(EINVAL);
- }
- return (EINVAL); /* Not an attribute structure! */
-}
-
-/*
- * Get the guardsize attribute in the attr.
- */
-int
-pthread_attr_getguardsize(const pthread_attr_t *attr,
- size_t *guardsize)
-{
- if (attr->sig == _PTHREAD_ATTR_SIG) {
- *guardsize = attr->guardsize;
- return (0);
- }
- return (EINVAL); /* Not an attribute structure! */
-}
-
-
-/*
- * Create and start execution of a new thread.
- */
-
-static void
-_pthread_body(pthread_t self)
-{
- _pthread_set_self(self);
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- if( (self->thread_id = __thread_selfid()) == (__uint64_t)-1)
- printf("Failed to set thread_id in _pthread_body\n");
-#endif
- _pthread_exit(self, (self->fun)(self->arg));
-}
-
-void
-_pthread_start(pthread_t self, mach_port_t kport, void *(*fun)(void *), void * funarg, size_t stacksize, unsigned int pflags)
-{
-#if WQ_DEBUG
- pthread_t pself;
-#endif
- pthread_attr_t *attrs = &_pthread_attr_default;
- char * stackaddr;
-
- if ((pflags & PTHREAD_START_CUSTOM) == 0) {
- stackaddr = (char *)self;
- _pthread_struct_init(self, attrs, stackaddr, stacksize, 1, 1);
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- _pthread_set_self(self);
-#endif
- LOCK(_pthread_list_lock);
- if (pflags & PTHREAD_START_SETSCHED) {
- self->policy = ((pflags >> PTHREAD_START_POLICY_BITSHIFT) & PTHREAD_START_POLICY_MASK);
- self->param.sched_priority = (pflags & PTHREAD_START_IMPORTANCE_MASK);
- }
- /* These are not joinable threads */
- if ((pflags & PTHREAD_START_DETACHED) == PTHREAD_START_DETACHED) {
- self->detached &= ~PTHREAD_CREATE_JOINABLE;
- self->detached |= PTHREAD_CREATE_DETACHED;
- }
- } else {
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- _pthread_set_self(self);
-#endif
- LOCK(_pthread_list_lock);
- }
- self->kernel_thread = kport;
- self->fun = fun;
- self->arg = funarg;
-
- /* Add to the pthread list */
- if (self->parentcheck == 0) {
- TAILQ_INSERT_TAIL(&__pthread_head, self, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, self, 0, 0, 3, 0);
-#endif
- _pthread_count++;
- }
- self->childrun = 1;
- UNLOCK(_pthread_list_lock);
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- if( (self->thread_id = __thread_selfid()) == (__uint64_t)-1)
- printf("Failed to set thread_id in pthread_start\n");
-#endif
-
-#if WQ_DEBUG
- pself = pthread_self();
- if (self != pself)
- LIBC_ABORT("self %p != pself %p", self, pself);
-#endif
-#if PTH_TRACE
- __kdebug_trace(0x9000030, self, pflags, 0, 0, 0);
-#endif
-
- _pthread_exit(self, (self->fun)(self->arg));
-}
-
-int
-_pthread_create(pthread_t t,
- const pthread_attr_t *attrs,
- void *stack,
- const mach_port_t kernel_thread)
-{
- int res;
- res = 0;
-
- do
- {
- memset(t, 0, sizeof(*t));
- t->newstyle = 0;
- t->schedset = 0;
- t->kernalloc = 0;
- t->tsd[0] = t;
- t->max_tsd_key = 0;
- t->wqthread = 0;
- t->cur_workq = 0;
- t->cur_workitem = 0;
- t->stacksize = attrs->stacksize;
- t->stackaddr = (void *)stack;
- t->guardsize = attrs->guardsize;
- t->kernel_thread = kernel_thread;
- t->detached = attrs->detached;
- t->inherit = attrs->inherit;
- t->policy = attrs->policy;
- t->param = attrs->param;
- t->freeStackOnExit = attrs->freeStackOnExit;
- t->cancel_error = 0;
- t->sig = _PTHREAD_SIG;
- t->reply_port = MACH_PORT_NULL;
- t->cthread_self = NULL;
- LOCK_INIT(t->lock);
- t->plist.tqe_next = (struct _pthread *)0;
- t->plist.tqe_prev = (struct _pthread **)0;
- t->cancel_state = PTHREAD_CANCEL_ENABLE | PTHREAD_CANCEL_DEFERRED;
- t->__cleanup_stack = (struct __darwin_pthread_handler_rec *)NULL;
- t->death = SEMAPHORE_NULL;
-
- if (kernel_thread != MACH_PORT_NULL)
- (void)pthread_setschedparam_internal(t, kernel_thread, t->policy, &t->param);
- } while (0);
- return (res);
-}
-
-void
-_pthread_struct_init(pthread_t t, const pthread_attr_t *attrs, void * stack, size_t stacksize, int kernalloc, int nozero)
-{
- mach_vm_offset_t stackaddr = (mach_vm_offset_t)(uintptr_t)stack;
-
- if (nozero == 0) {
- memset(t, 0, sizeof(*t));
- t->plist.tqe_next = (struct _pthread *)0;
- t->plist.tqe_prev = (struct _pthread **)0;
- }
- t->schedset = attrs->schedset;
- t->tsd[0] = t;
- if (kernalloc != 0) {
- stackaddr = (mach_vm_offset_t)(uintptr_t)t;
-
- /* if allocated from kernel set values appropriately */
- t->stacksize = stacksize;
- t->stackaddr = (void *)(uintptr_t)stackaddr;
- t->freeStackOnExit = 1;
- t->freeaddr = (void *)(uintptr_t)(stackaddr - stacksize - vm_page_size);
- t->freesize = pthreadsize + stacksize + vm_page_size;
- } else {
- t->stacksize = attrs->stacksize;
- t->stackaddr = (void *)stack;
- }
- t->guardsize = attrs->guardsize;
- t->detached = attrs->detached;
- t->inherit = attrs->inherit;
- t->policy = attrs->policy;
- t->param = attrs->param;
- t->cancel_error = 0;
- t->sig = _PTHREAD_SIG;
- t->reply_port = MACH_PORT_NULL;
- t->cthread_self = NULL;
- LOCK_INIT(t->lock);
- t->cancel_state = PTHREAD_CANCEL_ENABLE | PTHREAD_CANCEL_DEFERRED;
- t->__cleanup_stack = (struct __darwin_pthread_handler_rec *)NULL;
- t->death = SEMAPHORE_NULL;
- t->newstyle = 1;
- t->kernalloc = kernalloc;
- t->wqthread = 0;
- t->cur_workq = 0;
- t->cur_workitem = 0;
- t->max_tsd_key = 0;
-}
-
-/* Need to deprecate this in future */
-int
-_pthread_is_threaded(void)
-{
- return __is_threaded;
-}
-
-/* Non portable public api to know whether this process has(had) atleast one thread
- * apart from main thread. There could be race if there is a thread in the process of
- * creation at the time of call . It does not tell whether there are more than one thread
- * at this point of time.
- */
-int
-pthread_is_threaded_np(void)
-{
- return (__is_threaded);
-}
-
-mach_port_t
-pthread_mach_thread_np(pthread_t t)
-{
- mach_port_t kport = MACH_PORT_NULL;
-
- if (t == NULL)
- goto out;
-
- /*
- * If the call is on self, return the kernel port. We cannot
- * add this bypass for main thread as it might have exited,
- * and we should not return stale port info.
- */
- if (t == pthread_self())
- {
- kport = t->kernel_thread;
- goto out;
- }
-
- if (_pthread_lookup_thread(t, &kport, 0) != 0)
- return((mach_port_t)0);
-
-out:
- return(kport);
-}
-
-pthread_t pthread_from_mach_thread_np(mach_port_t kernel_thread)
-{
- struct _pthread * p = NULL;
-
- /* No need to wait as mach port is already known */
- LOCK(_pthread_list_lock);
- TAILQ_FOREACH(p, &__pthread_head, plist) {
- if (p->kernel_thread == kernel_thread)
- break;
- }
- UNLOCK(_pthread_list_lock);
- return p;
-}
-
-size_t
-pthread_get_stacksize_np(pthread_t t)
-{
- int ret;
- size_t size = 0;
-
- if (t == NULL)
- return(ESRCH);
-
- if ( t == pthread_self() || t == &_thread ) //since the main thread will not get de-allocated from underneath us
- {
- size=t->stacksize;
- return size;
- }
-
-
- LOCK(_pthread_list_lock);
-
- if ((ret = _pthread_find_thread(t)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(ret);
- }
-
- size=t->stacksize;
- UNLOCK(_pthread_list_lock);
-
- return(size);
-}
-
-void *
-pthread_get_stackaddr_np(pthread_t t)
-{
- int ret;
- void * addr = NULL;
-
- if (t == NULL)
- return((void *)(uintptr_t)ESRCH);
-
- if(t == pthread_self() || t == &_thread) //since the main thread will not get deallocated from underneath us
- return t->stackaddr;
-
- LOCK(_pthread_list_lock);
-
- if ((ret = _pthread_find_thread(t)) != 0) {
- UNLOCK(_pthread_list_lock);
- return((void *)(uintptr_t)ret);
- }
- addr = t->stackaddr;
- UNLOCK(_pthread_list_lock);
-
- return(addr);
-}
-
-mach_port_t
-_pthread_reply_port(pthread_t t)
-{
- return t->reply_port;
-}
-
-
-/* returns non-zero if the current thread is the main thread */
-int
-pthread_main_np(void)
-{
- pthread_t self = pthread_self();
-
- return ((self->detached & _PTHREAD_CREATE_PARENT) == _PTHREAD_CREATE_PARENT);
-}
-
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
-/* if we are passed in a pthread_t that is NULL, then we return
- the current thread's thread_id. So folks don't have to call
- pthread_self, in addition to us doing it, if they just want
- their thread_id.
-*/
-int
-pthread_threadid_np(pthread_t thread, __uint64_t *thread_id)
-{
- int rval=0;
- pthread_t self = pthread_self();
-
- if (thread_id == NULL) {
- return(EINVAL);
- } else if (thread == NULL || thread == self) {
- *thread_id = self->thread_id;
- return rval;
- }
-
- LOCK(_pthread_list_lock);
- if ((rval = _pthread_find_thread(thread)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(rval);
- }
- *thread_id = thread->thread_id;
- UNLOCK(_pthread_list_lock);
- return rval;
-}
-#endif
-
-int
-pthread_getname_np(pthread_t thread, char *threadname, size_t len)
-{
- int rval;
- rval = 0;
-
- if (thread == NULL)
- return(ESRCH);
-
- LOCK(_pthread_list_lock);
- if ((rval = _pthread_find_thread(thread)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(rval);
- }
- strlcpy(threadname, thread->pthread_name, len);
- UNLOCK(_pthread_list_lock);
- return rval;
-}
-
-int
-pthread_setname_np(const char *threadname)
-{
- int rval = 0;
- int len = 0;
- pthread_t current_thread = pthread_self();
-
- if (threadname != NULL)
- len = strlen(threadname);
-
- /* protytype is in pthread_internals.h */
- rval = proc_setthreadname((void *)threadname, len);
- if (rval == 0) {
- if (threadname != NULL) {
- strlcpy(current_thread->pthread_name, threadname, MAXTHREADNAMESIZE);
- } else {
- memset(current_thread->pthread_name, 0 , MAXTHREADNAMESIZE);
- }
-
- }
- return rval;
-
-}
-
-static int
-_new_pthread_create_suspended(pthread_t *thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *),
- void *arg,
- int create_susp)
-{
- pthread_attr_t *attrs;
- void *stack;
- int error;
- unsigned int flags;
- pthread_t t,t2;
- kern_return_t kern_res;
- mach_port_t kernel_thread = MACH_PORT_NULL;
- int needresume;
- task_t self = mach_task_self();
- int kernalloc = 0;
- int susp = create_susp;
-
- if ((attrs = (pthread_attr_t *)attr) == (pthread_attr_t *)NULL)
- { /* Set up default paramters */
- attrs = &_pthread_attr_default;
- } else if (attrs->sig != _PTHREAD_ATTR_SIG) {
- return EINVAL;
- }
- error = 0;
-
- if (((attrs->policy != _PTHREAD_DEFAULT_POLICY) ||
- (attrs->param.sched_priority != default_priority)) && (create_susp == 0)) {
- needresume = 1;
- susp = 1;
- } else
- needresume = 0;
-
- /* In default policy (ie SCHED_OTHER) only sched_priority is used. Check for
- * any change in priority or policy is needed here.
- */
- if ((__oldstyle == 1) || (create_susp != 0)) {
- /* Rosetta or pthread_create_suspended() */
- /* running under rosetta */
- /* Allocate a stack for the thread */
-#if PTH_TRACE
- __kdebug_trace(0x9000000, create_susp, 0, 0, 0, 0);
-#endif
- if ((error = _pthread_allocate_stack(attrs, &stack)) != 0) {
- return(error);
- }
- t = (pthread_t)malloc(sizeof(struct _pthread));
- *thread = t;
- if (susp) {
- /* Create the Mach thread for this thread */
- PTHREAD_MACH_CALL(thread_create(self, &kernel_thread), kern_res);
- if (kern_res != KERN_SUCCESS)
- {
- printf("Can't create thread: %d\n", kern_res);
- return(EINVAL);
- }
- }
- if ((error = _pthread_create(t, attrs, stack, kernel_thread)) != 0)
- {
- return(error);
- }
- set_malloc_singlethreaded(0);
- __is_threaded = 1;
-
- /* Send it on it's way */
- t->arg = arg;
- t->fun = start_routine;
- t->newstyle = 0;
- /* Now set it up to execute */
- LOCK(_pthread_list_lock);
- TAILQ_INSERT_TAIL(&__pthread_head, t, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, t, 0, 0, 4, 0);
-#endif
- _pthread_count++;
- UNLOCK(_pthread_list_lock);
- _pthread_setup(t, _pthread_body, stack, susp, needresume);
- return(0);
- } else {
-
- flags = 0;
- if (attrs->fastpath == 1)
- kernalloc = 1;
-
- if (attrs->detached == PTHREAD_CREATE_DETACHED)
- flags |= PTHREAD_START_DETACHED;
- if (attrs->schedset != 0) {
- flags |= PTHREAD_START_SETSCHED;
- flags |= ((attrs->policy & PTHREAD_START_POLICY_MASK) << PTHREAD_START_POLICY_BITSHIFT);
- flags |= (attrs->param.sched_priority & PTHREAD_START_IMPORTANCE_MASK);
- }
-
- set_malloc_singlethreaded(0);
- __is_threaded = 1;
-
- if (kernalloc == 0) {
- /* Allocate a stack for the thread */
- flags |= PTHREAD_START_CUSTOM;
- if ((error = _pthread_create_pthread_onstack(attrs, &stack, &t)) != 0) {
- return(error);
- }
- /* Send it on it's way */
- t->arg = arg;
- t->fun = start_routine;
- t->newstyle = 1;
-
-#if PTH_TRACE
- __kdebug_trace(0x9000004, t, flags, 0, 0, 0);
-#endif
-
- if ((t2 = __bsdthread_create(start_routine, arg, stack, t, flags)) == (pthread_t)-1) {
- _pthread_free_pthread_onstack(t, 1, 0);
- return (EAGAIN);
- }
- else t=t2;
- LOCK(_pthread_list_lock);
- t->parentcheck = 1;
- if ((t->childexit != 0) && ((t->detached & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)) {
- /* detached child exited, mop up */
- UNLOCK(_pthread_list_lock);
-#if PTH_TRACE
- __kdebug_trace(0x9000008, t, 0, 0, 1, 0);
-#endif
- if(t->freeStackOnExit)
- vm_deallocate(self, (mach_vm_address_t)(uintptr_t)t, pthreadsize);
- else
- free(t);
- } else if (t->childrun == 0) {
- TAILQ_INSERT_TAIL(&__pthread_head, t, plist);
- _pthread_count++;
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, t, 0, 0, 1, 0);
-#endif
- UNLOCK(_pthread_list_lock);
- } else
- UNLOCK(_pthread_list_lock);
-
- *thread = t;
-
-#if PTH_TRACE
- __kdebug_trace(0x9000014, t, 0, 0, 1, 0);
-#endif
- return (0);
-
- } else {
- /* kernel allocation */
-#if PTH_TRACE
- __kdebug_trace(0x9000018, flags, 0, 0, 0, 0);
-#endif
- if ((t = __bsdthread_create(start_routine, arg, (void *)attrs->stacksize, NULL, flags)) == (pthread_t)-1)
- return (EAGAIN);
- /* Now set it up to execute */
- LOCK(_pthread_list_lock);
- t->parentcheck = 1;
- if ((t->childexit != 0) && ((t->detached & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)) {
- /* detached child exited, mop up */
- UNLOCK(_pthread_list_lock);
-#if PTH_TRACE
- __kdebug_trace(0x9000008, t, pthreadsize, 0, 2, 0);
-#endif
- vm_deallocate(self, (mach_vm_address_t)(uintptr_t)t, pthreadsize);
- } else if (t->childrun == 0) {
- TAILQ_INSERT_TAIL(&__pthread_head, t, plist);
- _pthread_count++;
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, t, 0, 0, 2, 0);
-#endif
- UNLOCK(_pthread_list_lock);
- } else
- UNLOCK(_pthread_list_lock);
-
- *thread = t;
-
-#if PTH_TRACE
- __kdebug_trace(0x9000014, t, 0, 0, 2, 0);
-#endif
- return(0);
- }
- }
-}
-
-static int
-_pthread_create_suspended(pthread_t *thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *),
- void *arg,
- int suspended)
-{
- pthread_attr_t *attrs;
- void *stack;
- int res;
- pthread_t t;
- kern_return_t kern_res;
- mach_port_t kernel_thread = MACH_PORT_NULL;
- int needresume;
-
- if ((attrs = (pthread_attr_t *)attr) == (pthread_attr_t *)NULL)
- { /* Set up default paramters */
- attrs = &_pthread_attr_default;
- } else if (attrs->sig != _PTHREAD_ATTR_SIG) {
- return EINVAL;
- }
- res = 0;
-
- /* In default policy (ie SCHED_OTHER) only sched_priority is used. Check for
- * any change in priority or policy is needed here.
- */
- if (((attrs->policy != _PTHREAD_DEFAULT_POLICY) ||
- (attrs->param.sched_priority != default_priority)) && (suspended == 0)) {
- needresume = 1;
- suspended = 1;
- } else
- needresume = 0;
-
- do
- {
- /* Allocate a stack for the thread */
- if ((res = _pthread_allocate_stack(attrs, &stack)) != 0) {
- break;
- }
- t = (pthread_t)malloc(sizeof(struct _pthread));
- *thread = t;
- if (suspended) {
- /* Create the Mach thread for this thread */
- PTHREAD_MACH_CALL(thread_create(mach_task_self(), &kernel_thread), kern_res);
- if (kern_res != KERN_SUCCESS)
- {
- printf("Can't create thread: %d\n", kern_res);
- res = EINVAL; /* Need better error here? */
- break;
- }
- }
- if ((res = _pthread_create(t, attrs, stack, kernel_thread)) != 0)
- {
- break;
- }
- set_malloc_singlethreaded(0);
- __is_threaded = 1;
-
- /* Send it on it's way */
- t->arg = arg;
- t->fun = start_routine;
- /* Now set it up to execute */
- LOCK(_pthread_list_lock);
- TAILQ_INSERT_TAIL(&__pthread_head, t, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, t, 0, 0, 5, 0);
-#endif
- _pthread_count++;
- UNLOCK(_pthread_list_lock);
- _pthread_setup(t, _pthread_body, stack, suspended, needresume);
- } while (0);
- return (res);
-}
-
-int
-pthread_create(pthread_t *thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *),
- void *arg)
-{
- return _new_pthread_create_suspended(thread, attr, start_routine, arg, 0);
-}
-
-int
-pthread_create_suspended_np(pthread_t *thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *),
- void *arg)
-{
- return _pthread_create_suspended(thread, attr, start_routine, arg, 1);
-}
-
-/*
- * Make a thread 'undetached' - no longer 'joinable' with other threads.
- */
-int
-pthread_detach(pthread_t thread)
-{
- int newstyle = 0;
- int ret;
-
- if ((ret = _pthread_lookup_thread(thread, NULL, 1)) != 0) {
- return (ret); /* Not a valid thread */
- }
-
- LOCK(thread->lock);
- newstyle = thread->newstyle;
- if (thread->detached & PTHREAD_CREATE_JOINABLE)
- {
- if (thread->detached & _PTHREAD_EXITED) {
- UNLOCK(thread->lock);
- pthread_join(thread, NULL);
- return 0;
- } else {
- if (newstyle == 0) {
- semaphore_t death = thread->death;
-
- thread->detached &= ~PTHREAD_CREATE_JOINABLE;
- thread->detached |= PTHREAD_CREATE_DETACHED;
- UNLOCK(thread->lock);
- if (death)
- (void) semaphore_signal(death);
- } else {
- mach_port_t joinport = thread->joiner_notify;
-
- thread->detached &= ~PTHREAD_CREATE_JOINABLE;
- thread->detached |= PTHREAD_CREATE_DETACHED;
-
- UNLOCK(thread->lock);
- if (joinport) {
- semaphore_signal(joinport);
- }
- }
- return(0);
- }
- } else {
- UNLOCK(thread->lock);
- return (EINVAL);
- }
-}
-
-
-/*
- * pthread_kill call to system call
- */
-int
-pthread_kill (
- pthread_t th,
- int sig)
-{
- int error = 0;
- mach_port_t kport = MACH_PORT_NULL;
-
- if ((sig < 0) || (sig > NSIG))
- return(EINVAL);
-
- if (_pthread_lookup_thread(th, &kport, 0) != 0)
- return (ESRCH); /* Not a valid thread */
-
- /* if the thread is a workqueue thread, just return error */
- if ((th->wqthread != 0) && (th->wqkillset ==0)) {
- return(ENOTSUP);
- }
-
- error = __pthread_kill(kport, sig);
-
- if (error == -1)
- error = errno;
- return(error);
-}
-
-int
-__pthread_workqueue_setkill(int enable)
-{
- pthread_t self = pthread_self();
-
- LOCK(self->lock);
- if (enable == 0)
- self->wqkillset = 0;
- else
- self->wqkillset = 1;
- UNLOCK(self->lock);
-
- return(0);
-
-}
-
-/* Announce that there are pthread resources ready to be reclaimed in a */
-/* subsequent pthread_exit or reaped by pthread_join. In either case, the Mach */
-/* thread underneath is terminated right away. */
-static
-void _pthread_become_available(pthread_t thread, mach_port_t kernel_thread) {
- pthread_reap_msg_t msg;
- kern_return_t ret;
-
- msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,
- MACH_MSG_TYPE_MOVE_SEND);
- msg.header.msgh_size = sizeof msg - sizeof msg.trailer;
- msg.header.msgh_remote_port = thread_recycle_port;
- msg.header.msgh_local_port = kernel_thread;
- msg.header.msgh_id = 0x44454144; /* 'DEAD' */
- msg.thread = thread;
- ret = mach_msg_send(&msg.header);
- assert(ret == MACH_MSG_SUCCESS);
-}
-
-/* Reap the resources for available threads */
-__private_extern__
-int _pthread_reap_thread(pthread_t th, mach_port_t kernel_thread, void **value_ptr, int conforming) {
- mach_port_type_t ptype;
- kern_return_t ret;
- task_t self;
-
- self = mach_task_self();
- if (kernel_thread != MACH_PORT_DEAD) {
- ret = mach_port_type(self, kernel_thread, &ptype);
- if (ret == KERN_SUCCESS && ptype != MACH_PORT_TYPE_DEAD_NAME) {
- /* not quite dead yet... */
- return EAGAIN;
- }
- ret = mach_port_deallocate(self, kernel_thread);
- if (ret != KERN_SUCCESS) {
- fprintf(stderr,
- "mach_port_deallocate(kernel_thread) failed: %s\n",
- mach_error_string(ret));
- }
- }
-
- if (th->reply_port != MACH_PORT_NULL) {
- ret = mach_port_mod_refs(self, th->reply_port,
- MACH_PORT_RIGHT_RECEIVE, -1);
- if (ret != KERN_SUCCESS) {
- fprintf(stderr,
- "mach_port_mod_refs(reply_port) failed: %s\n",
- mach_error_string(ret));
- }
- }
-
- if (th->freeStackOnExit) {
- vm_address_t addr = (vm_address_t)th->stackaddr;
- vm_size_t size;
-
- size = (vm_size_t)th->stacksize + th->guardsize;
-
- addr -= size;
- ret = vm_deallocate(self, addr, size);
- if (ret != KERN_SUCCESS) {
- fprintf(stderr,
- "vm_deallocate(stack) failed: %s\n",
- mach_error_string(ret));
- }
- }
-
-
- if (value_ptr)
- *value_ptr = th->exit_value;
- if (conforming) {
- if ((th->cancel_state & (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING)) ==
- (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING) && (value_ptr != NULL))
- *value_ptr = PTHREAD_CANCELED;
- th->sig = _PTHREAD_NO_SIG;
- }
-
-
- if (th != &_thread)
- free(th);
-
- return 0;
-}
-
-static
-void _pthread_reap_threads(void)
-{
- pthread_reap_msg_t msg;
- kern_return_t ret;
-
- ret = mach_msg(&msg.header, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0,
- sizeof msg, thread_recycle_port,
- MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
- while (ret == MACH_MSG_SUCCESS) {
- mach_port_t kernel_thread = msg.header.msgh_remote_port;
- pthread_t thread = msg.thread;
-
- /* deal with race with thread_create_running() */
- if (kernel_thread == MACH_PORT_NULL &&
- kernel_thread != thread->kernel_thread) {
- kernel_thread = thread->kernel_thread;
- }
-
- if ( kernel_thread == MACH_PORT_NULL ||
- _pthread_reap_thread(thread, kernel_thread, (void **)0, 0) == EAGAIN)
- {
- /* not dead yet, put it back for someone else to reap, stop here */
- _pthread_become_available(thread, kernel_thread);
- return;
- }
-
- ret = mach_msg(&msg.header, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0,
- sizeof msg, thread_recycle_port,
- MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
- }
-}
-
-/* For compatibility... */
-
-pthread_t
-_pthread_self() {
- return pthread_self();
-}
-
-/*
- * Terminate a thread.
- */
-int __disable_threadsignal(int);
-
-static void
-_pthread_exit(pthread_t self, void *value_ptr)
-{
- struct __darwin_pthread_handler_rec *handler;
- kern_return_t kern_res;
- int thread_count;
- int newstyle = self->newstyle;
-
- /* Make this thread not to receive any signals */
- __disable_threadsignal(1);
-
-#if PTH_TRACE
- __kdebug_trace(0x900001c, self, newstyle, 0, 0, 0);
-#endif
-
- /* set cancel state to disable and type to deferred */
- _pthread_setcancelstate_exit(self, value_ptr, __unix_conforming);
-
- while ((handler = self->__cleanup_stack) != 0)
- {
- (handler->__routine)(handler->__arg);
- self->__cleanup_stack = handler->__next;
- }
- _pthread_tsd_cleanup(self);
-
- if (newstyle == 0) {
- _pthread_reap_threads();
-
- LOCK(self->lock);
- self->detached |= _PTHREAD_EXITED;
-
- if (self->detached & PTHREAD_CREATE_JOINABLE) {
- mach_port_t death = self->death;
- self->exit_value = value_ptr;
- UNLOCK(self->lock);
- /* the joiner will need a kernel thread reference, leave ours for it */
- if (death) {
- PTHREAD_MACH_CALL(semaphore_signal(death), kern_res);
- if (kern_res != KERN_SUCCESS)
- fprintf(stderr,
- "semaphore_signal(death) failed: %s\n",
- mach_error_string(kern_res));
- }
- LOCK(_pthread_list_lock);
- thread_count = --_pthread_count;
- UNLOCK(_pthread_list_lock);
- } else {
- UNLOCK(self->lock);
- LOCK(_pthread_list_lock);
- TAILQ_REMOVE(&__pthread_head, self, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x9000010, self, 0, 0, 5, 0);
-#endif
- thread_count = --_pthread_count;
- UNLOCK(_pthread_list_lock);
- /* with no joiner, we let become available consume our cached ref */
- _pthread_become_available(self, self->kernel_thread);
- }
-
- if (thread_count <= 0)
- exit(0);
-
- /* Use a new reference to terminate ourselves. Should never return. */
- PTHREAD_MACH_CALL(thread_terminate(mach_thread_self()), kern_res);
- fprintf(stderr, "thread_terminate(mach_thread_self()) failed: %s\n",
- mach_error_string(kern_res));
- } else {
- semaphore_t joinsem = SEMAPHORE_NULL;
-
- if ((self->joiner_notify == (mach_port_t)0) && (self->detached & PTHREAD_CREATE_JOINABLE))
- joinsem = new_sem_from_pool();
- LOCK(self->lock);
- self->detached |= _PTHREAD_EXITED;
-
- self->exit_value = value_ptr;
- if (self->detached & PTHREAD_CREATE_JOINABLE) {
- if (self->joiner_notify == (mach_port_t)0) {
- self->joiner_notify = joinsem;
- joinsem = SEMAPHORE_NULL;
- }
- UNLOCK(self->lock);
- if (joinsem != SEMAPHORE_NULL)
- restore_sem_to_pool(joinsem);
- _pthread_free_pthread_onstack(self, 0, 1);
- } else {
- UNLOCK(self->lock);
- /* with no joiner, we let become available consume our cached ref */
- if (joinsem != SEMAPHORE_NULL)
- restore_sem_to_pool(joinsem);
- _pthread_free_pthread_onstack(self, 1, 1);
- }
- }
- LIBC_ABORT("thread %p didn't exit", self);
-}
-
-void
-pthread_exit(void *value_ptr)
-{
- pthread_t self = pthread_self();
- /* if the current thread is a workqueue thread, just crash the app, as per libdispatch folks */
- if (self->wqthread == 0) {
- _pthread_exit(self, value_ptr);
- } else {
- LIBC_ABORT("pthread_exit() may only be called against threads created via pthread_create()");
- }
-}
-
-/*
- * Get the scheduling policy and scheduling paramters for a thread.
- */
-int
-pthread_getschedparam(pthread_t thread,
- int *policy,
- struct sched_param *param)
-{
- int ret;
-
- if (thread == NULL)
- return(ESRCH);
-
- LOCK(_pthread_list_lock);
-
- if ((ret = _pthread_find_thread(thread)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(ret);
- }
- if (policy != 0)
- *policy = thread->policy;
- if (param != 0)
- *param = thread->param;
- UNLOCK(_pthread_list_lock);
-
- return(0);
-}
-
-/*
- * Set the scheduling policy and scheduling paramters for a thread.
- */
-static int
-pthread_setschedparam_internal(pthread_t thread,
- mach_port_t kport,
- int policy,
- const struct sched_param *param)
-{
- policy_base_data_t bases;
- policy_base_t base;
- mach_msg_type_number_t count;
- kern_return_t ret;
-
- switch (policy)
- {
- case SCHED_OTHER:
- bases.ts.base_priority = param->sched_priority;
- base = (policy_base_t)&bases.ts;
- count = POLICY_TIMESHARE_BASE_COUNT;
- break;
- case SCHED_FIFO:
- bases.fifo.base_priority = param->sched_priority;
- base = (policy_base_t)&bases.fifo;
- count = POLICY_FIFO_BASE_COUNT;
- break;
- case SCHED_RR:
- bases.rr.base_priority = param->sched_priority;
- /* quantum isn't public yet */
- bases.rr.quantum = param->quantum;
- base = (policy_base_t)&bases.rr;
- count = POLICY_RR_BASE_COUNT;
- break;
- default:
- return (EINVAL);
- }
- ret = thread_policy(kport, policy, base, count, TRUE);
- if (ret != KERN_SUCCESS)
- return (EINVAL);
- return (0);
-}
-
-int
-pthread_setschedparam(pthread_t t,
- int policy,
- const struct sched_param *param)
-{
- mach_port_t kport = MACH_PORT_NULL;
- int error;
- int bypass = 1;
-
- if (t != pthread_self() && t != &_thread ) { //since the main thread will not get de-allocated from underneath us
- bypass = 0;
- if (_pthread_lookup_thread(t, &kport, 0) != 0)
- return(ESRCH);
- } else
- kport = t->kernel_thread;
-
- error = pthread_setschedparam_internal(t, kport, policy, param);
- if (error == 0) {
- if (bypass == 0) {
- /* ensure the thread is still valid */
- LOCK(_pthread_list_lock);
- if ((error = _pthread_find_thread(t)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(error);
- }
- t->policy = policy;
- t->param = *param;
- UNLOCK(_pthread_list_lock);
- } else {
- t->policy = policy;
- t->param = *param;
- }
- }
- return(error);
-}
-
-/*
- * Get the minimum priority for the given policy
- */
-int
-sched_get_priority_min(int policy)
-{
- return default_priority - 16;
-}
-
-/*
- * Get the maximum priority for the given policy
- */
-int
-sched_get_priority_max(int policy)
-{
- return default_priority + 16;
-}
-
-/*
- * Determine if two thread identifiers represent the same thread.
- */
-int
-pthread_equal(pthread_t t1,
- pthread_t t2)
-{
- return (t1 == t2);
-}
-
-// Force LLVM not to optimise this to a call to __pthread_set_self, if it does
-// then _pthread_set_self won't be bound when secondary threads try and start up.
-void __attribute__((noinline))
-_pthread_set_self(pthread_t p)
-{
- extern void __pthread_set_self(void *);
-
- if (p == 0) {
- if (_thread.tsd[0] != 0) {
- bzero(&_thread, sizeof(struct _pthread));
- }
- p = &_thread;
- }
- p->tsd[0] = p;
- __pthread_set_self(&p->tsd[0]);
-}
-
-void
-cthread_set_self(void *cself)
-{
- pthread_t self = pthread_self();
- if ((self == (pthread_t)NULL) || (self->sig != _PTHREAD_SIG)) {
- _pthread_set_self(cself);
- return;
- }
- self->cthread_self = cself;
-}
-
-void *
-ur_cthread_self(void) {
- pthread_t self = pthread_self();
- if ((self == (pthread_t)NULL) || (self->sig != _PTHREAD_SIG)) {
- return (void *)self;
- }
- return self->cthread_self;
-}
-
-/*
- * cancellation handler for pthread once as the init routine can have a
- * cancellation point. In that case we need to restore the spin unlock
- */
-void
-__pthread_once_cancel_handler(pthread_once_t *once_control)
-{
- _spin_unlock(&once_control->lock);
-}
-
-
-/*
- * Execute a function exactly one time in a thread-safe fashion.
- */
-int
-pthread_once(pthread_once_t *once_control,
- void (*init_routine)(void))
-{
- _spin_lock(&once_control->lock);
- if (once_control->sig == _PTHREAD_ONCE_SIG_init)
- {
- pthread_cleanup_push((void (*)(void *))__pthread_once_cancel_handler, once_control);
- (*init_routine)();
- pthread_cleanup_pop(0);
- once_control->sig = _PTHREAD_ONCE_SIG;
- }
- _spin_unlock(&once_control->lock);
- return (0); /* Spec defines no possible errors! */
-}
-
-/*
- * Insert a cancellation point in a thread.
- */
-__private_extern__ void
-_pthread_testcancel(pthread_t thread, int isconforming)
-{
- LOCK(thread->lock);
- if ((thread->cancel_state & (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING)) ==
- (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING))
- {
- UNLOCK(thread->lock);
- if (isconforming)
- pthread_exit(PTHREAD_CANCELED);
- else
- pthread_exit(0);
- }
- UNLOCK(thread->lock);
-}
-
-
-
-int
-pthread_getconcurrency(void)
-{
- return(pthread_concurrency);
-}
-
-int
-pthread_setconcurrency(int new_level)
-{
- if (new_level < 0)
- return EINVAL;
- pthread_concurrency = new_level;
- return(0);
-}
-
-/*
- * Perform package initialization - called automatically when application starts
- */
-int
-pthread_init(void)
-{
- pthread_attr_t *attrs;
- pthread_t thread;
- kern_return_t kr;
- host_priority_info_data_t priority_info;
- host_info_t info;
- host_flavor_t flavor;
- host_t host;
- mach_msg_type_number_t count;
- int mib[2];
- int ncpus = 0;
- size_t len;
- void *stackaddr;
-
- pthreadsize = round_page(sizeof (struct _pthread));
- count = HOST_PRIORITY_INFO_COUNT;
- info = (host_info_t)&priority_info;
- flavor = HOST_PRIORITY_INFO;
- host = mach_host_self();
- kr = host_info(host, flavor, info, &count);
- if (kr != KERN_SUCCESS)
- printf("host_info failed (%d); probably need privilege.\n", kr);
- else {
- default_priority = priority_info.user_priority;
- min_priority = priority_info.minimum_priority;
- max_priority = priority_info.maximum_priority;
- }
- attrs = &_pthread_attr_default;
- pthread_attr_init(attrs);
-
- TAILQ_INIT(&__pthread_head);
- LOCK_INIT(_pthread_list_lock);
- thread = &_thread;
- TAILQ_INSERT_HEAD(&__pthread_head, thread, plist);
- _pthread_set_self(thread);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, thread, 0, 0, 10, 0);
-#endif
-
- /* In case of dyld reset the tsd keys from 1 - 10 */
- _pthread_keys_init();
-
- mib[0] = CTL_KERN;
- mib[1] = KERN_USRSTACK;
- len = sizeof (stackaddr);
- if (sysctl (mib, 2, &stackaddr, &len, NULL, 0) != 0)
- stackaddr = (void *)USRSTACK;
- _pthread_create(thread, attrs, stackaddr, mach_thread_self());
- thread->stacksize = DFLSSIZ; //initialize main thread's stacksize based on vmparam.h
- thread->detached = PTHREAD_CREATE_JOINABLE|_PTHREAD_CREATE_PARENT;
-
- _init_cpu_capabilities();
- if ((ncpus = _NumCPUs()) > 1)
- _spin_tries = MP_SPIN_TRIES;
-
- workq_targetconc[WORKQ_HIGH_PRIOQUEUE] = ncpus;
- workq_targetconc[WORKQ_DEFAULT_PRIOQUEUE] = ncpus;
- workq_targetconc[WORKQ_LOW_PRIOQUEUE] = ncpus;
- workq_targetconc[WORKQ_BG_PRIOQUEUE] = ncpus;
-
- mach_port_deallocate(mach_task_self(), host);
-
-#if defined(__ppc__)
- IF_ROSETTA() {
- __oldstyle = 1;
- }
-#endif
-
-#if defined(_OBJC_PAGE_BASE_ADDRESS)
-{
- vm_address_t objcRTPage = (vm_address_t)_OBJC_PAGE_BASE_ADDRESS;
- kr = vm_map(mach_task_self(),
- &objcRTPage, vm_page_size * 4, vm_page_size - 1,
- VM_FLAGS_FIXED | VM_MAKE_TAG(0), // Which tag to use?
- MACH_PORT_NULL,
- (vm_address_t)0, FALSE,
- (vm_prot_t)0, VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE,
- VM_INHERIT_DEFAULT);
- /* We ignore the return result here. The ObjC runtime will just have to deal. */
-}
-#endif
- //added so that thread_recycle_port is initialized on new launch.
- _pthread_fork_child_postinit();
- mig_init(1); /* enable multi-threaded mig interfaces */
- if (__oldstyle == 0) {
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- __bsdthread_register(thread_start, start_wqthread, round_page(sizeof(struct _pthread)), _pthread_start, &workq_targetconc[0], (uintptr_t)(&thread->tsd[__PTK_LIBDISPATCH_KEY0]) - (uintptr_t)(&thread->tsd[0]));
-#else
- __bsdthread_register(_pthread_start, _pthread_wqthread, round_page(sizeof(struct _pthread)), NULL, &workq_targetconc[0], (uintptr_t)&thread->tsd[__PTK_LIBDISPATCH_KEY0] - (uintptr_t)thread);
-#endif
- }
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- if( (thread->thread_id = __thread_selfid()) == (__uint64_t)-1)
- printf("Failed to set thread_id in pthread_init\n");
-#endif
- return 0;
-}
-
-int sched_yield(void)
-{
- swtch_pri(0);
- return 0;
-}
-
-/* This used to be the "magic" that gets the initialization routine called when the application starts */
-/*
- * (These has been moved to setenv.c, so we can use it to fix a less than 10.5
- * crt1.o issue)
- * static int _do_nothing(void) { return 0; }
- * int (*_cthread_init_routine)(void) = _do_nothing;
- */
-
-/* Get a semaphore from the pool, growing it if necessary */
-
-__private_extern__ semaphore_t new_sem_from_pool(void) {
- kern_return_t res;
- semaphore_t sem;
- int i;
-
- LOCK(sem_pool_lock);
- if (sem_pool_current == sem_pool_count) {
- sem_pool_count += 16;
- sem_pool = realloc(sem_pool, sem_pool_count * sizeof(semaphore_t));
- for (i = sem_pool_current; i < sem_pool_count; i++) {
- PTHREAD_MACH_CALL(semaphore_create(mach_task_self(), &sem_pool[i], SYNC_POLICY_FIFO, 0), res);
- }
- }
- sem = sem_pool[sem_pool_current++];
- UNLOCK(sem_pool_lock);
- return sem;
-}
-
-/* Put a semaphore back into the pool */
-__private_extern__ void restore_sem_to_pool(semaphore_t sem) {
- LOCK(sem_pool_lock);
- sem_pool[--sem_pool_current] = sem;
- UNLOCK(sem_pool_lock);
-}
-
-static void sem_pool_reset(void) {
- LOCK(sem_pool_lock);
- sem_pool_count = 0;
- sem_pool_current = 0;
- sem_pool = NULL;
- UNLOCK(sem_pool_lock);
-}
-
-__private_extern__ void _pthread_fork_child(pthread_t p) {
- /* Just in case somebody had it locked... */
- UNLOCK(sem_pool_lock);
- sem_pool_reset();
- /* No need to hold the pthread_list_lock as no one other than this
- * thread is present at this time
- */
- TAILQ_INIT(&__pthread_head);
- LOCK_INIT(_pthread_list_lock);
- TAILQ_INSERT_HEAD(&__pthread_head, p, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, p, 0, 0, 10, 0);
-#endif
- _pthread_count = 1;
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- if( (p->thread_id = __thread_selfid()) == (__uint64_t)-1)
- printf("Failed to set thread_id in pthread_fork_child\n");
-#endif
-}
-
-void _pthread_fork_child_postinit() {
- kern_return_t kr;
-
- kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &thread_recycle_port);
- if (kr != KERN_SUCCESS) {
- abort();
- }
-}
-
-/*
- * Query/update the cancelability 'state' of a thread
- */
-int
-_pthread_setcancelstate_internal(int state, int *oldstate, int conforming)
-{
- pthread_t self = pthread_self();
-
-
- switch (state) {
- case PTHREAD_CANCEL_ENABLE:
- if (conforming)
- __pthread_canceled(1);
- break;
- case PTHREAD_CANCEL_DISABLE:
- if (conforming)
- __pthread_canceled(2);
- break;
- default:
- return EINVAL;
- }
-
- self = pthread_self();
- LOCK(self->lock);
- if (oldstate)
- *oldstate = self->cancel_state & _PTHREAD_CANCEL_STATE_MASK;
- self->cancel_state &= ~_PTHREAD_CANCEL_STATE_MASK;
- self->cancel_state |= state;
- UNLOCK(self->lock);
- if (!conforming)
- _pthread_testcancel(self, 0); /* See if we need to 'die' now... */
- return (0);
-}
-
-/* When a thread exits set the cancellation state to DISABLE and DEFERRED */
-static void
-_pthread_setcancelstate_exit(pthread_t self, void * value_ptr, int conforming)
-{
- LOCK(self->lock);
- self->cancel_state &= ~(_PTHREAD_CANCEL_STATE_MASK | _PTHREAD_CANCEL_TYPE_MASK);
- self->cancel_state |= (PTHREAD_CANCEL_DISABLE | PTHREAD_CANCEL_DEFERRED);
- if ((value_ptr == PTHREAD_CANCELED)) {
-// 4597450: begin
- self->detached |= _PTHREAD_WASCANCEL;
-// 4597450: end
- }
- UNLOCK(self->lock);
-}
-
-int
-_pthread_join_cleanup(pthread_t thread, void ** value_ptr, int conforming)
-{
- kern_return_t res;
- int ret;
-
-#if PTH_TRACE
- __kdebug_trace(0x9000028, thread, 0, 0, 1, 0);
-#endif
- /* The scenario where the joiner was waiting for the thread and
- * the pthread detach happened on that thread. Then the semaphore
- * will trigger but by the time joiner runs, the target thread could be
- * freed. So we need to make sure that the thread is still in the list
- * and is joinable before we continue with the join.
- */
- LOCK(_pthread_list_lock);
- if ((ret = _pthread_find_thread(thread)) != 0) {
- UNLOCK(_pthread_list_lock);
- /* returns ESRCH */
- return(ret);
- }
- if ((thread->detached & PTHREAD_CREATE_JOINABLE) == 0) {
- /* the thread might be a detached thread */
- UNLOCK(_pthread_list_lock);
- return(ESRCH);
-
- }
- /* It is still a joinable thread and needs to be reaped */
- TAILQ_REMOVE(&__pthread_head, thread, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x9000010, thread, 0, 0, 3, 0);
-#endif
- UNLOCK(_pthread_list_lock);
-
- if (value_ptr)
- *value_ptr = thread->exit_value;
- if (conforming) {
- if ((thread->cancel_state & (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING)) ==
- (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING) && (value_ptr != NULL)) {
- *value_ptr = PTHREAD_CANCELED;
- }
- }
- if (thread->reply_port != MACH_PORT_NULL) {
- res = mach_port_mod_refs(mach_task_self(), thread->reply_port, MACH_PORT_RIGHT_RECEIVE, -1);
- if (res != KERN_SUCCESS)
- fprintf(stderr,"mach_port_mod_refs(reply_port) failed: %s\n",mach_error_string(res));
- thread->reply_port = MACH_PORT_NULL;
- }
- if (thread->freeStackOnExit) {
- thread->sig = _PTHREAD_NO_SIG;
-#if PTH_TRACE
- __kdebug_trace(0x9000028, thread, 0, 0, 2, 0);
-#endif
- vm_deallocate(mach_task_self(), (mach_vm_address_t)(uintptr_t)thread, pthreadsize);
- } else {
- thread->sig = _PTHREAD_NO_SIG;
-#if PTH_TRACE
- __kdebug_trace(0x9000028, thread, 0, 0, 3, 0);
-#endif
- free(thread);
- }
- return(0);
-}
-
-/* ALWAYS called with list lock and return with list lock */
-int
-_pthread_find_thread(pthread_t thread)
-{
- pthread_t p;
-
-loop:
- TAILQ_FOREACH(p, &__pthread_head, plist) {
- if (p == thread) {
- if (thread->kernel_thread == MACH_PORT_NULL) {
- UNLOCK(_pthread_list_lock);
- sched_yield();
- LOCK(_pthread_list_lock);
- goto loop;
- }
- return(0);
- }
- }
- return(ESRCH);
-}
-
-int
-_pthread_lookup_thread(pthread_t thread, mach_port_t * portp, int only_joinable)
-{
- mach_port_t kport;
- int ret = 0;
-
- if (thread == NULL)
- return(ESRCH);
-
- LOCK(_pthread_list_lock);
-
- if ((ret = _pthread_find_thread(thread)) != 0) {
- UNLOCK(_pthread_list_lock);
- return(ret);
- }
- if ((only_joinable != 0) && ((thread->detached & PTHREAD_CREATE_DETACHED) != 0)) {
- UNLOCK(_pthread_list_lock);
- return(EINVAL);
- }
- kport = thread->kernel_thread;
- UNLOCK(_pthread_list_lock);
- if (portp != NULL)
- *portp = kport;
- return(0);
-}
-
-/* XXXXXXXXXXXXX Pthread Workqueue Attributes XXXXXXXXXXXXXXXXXX */
-int
-pthread_workqueue_attr_init_np(pthread_workqueue_attr_t * attrp)
-{
- attrp->queueprio = WORKQ_DEFAULT_PRIOQUEUE;
- attrp->sig = PTHREAD_WORKQUEUE_ATTR_SIG;
- attrp->overcommit = 0;
- return(0);
-}
-
-int
-pthread_workqueue_attr_destroy_np(pthread_workqueue_attr_t * attr)
-{
- if (attr->sig == PTHREAD_WORKQUEUE_ATTR_SIG)
- {
- return (0);
- } else
- {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-int
-pthread_workqueue_attr_getqueuepriority_np(const pthread_workqueue_attr_t * attr, int * qpriop)
-{
- if (attr->sig == PTHREAD_WORKQUEUE_ATTR_SIG) {
- *qpriop = attr->queueprio;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-
-int
-pthread_workqueue_attr_setqueuepriority_np(pthread_workqueue_attr_t * attr, int qprio)
-{
-int error = 0;
-
- if (attr->sig == PTHREAD_WORKQUEUE_ATTR_SIG) {
- switch(qprio) {
- case WORKQ_HIGH_PRIOQUEUE:
- case WORKQ_DEFAULT_PRIOQUEUE:
- case WORKQ_LOW_PRIOQUEUE:
- case WORKQ_BG_PRIOQUEUE:
- attr->queueprio = qprio;
- break;
- default:
- error = EINVAL;
- }
- } else {
- error = EINVAL;
- }
- return (error);
-}
-
-
-int
-pthread_workqueue_attr_getovercommit_np(const pthread_workqueue_attr_t * attr, int * ocommp)
-{
- if (attr->sig == PTHREAD_WORKQUEUE_ATTR_SIG) {
- *ocommp = attr->overcommit;
- return (0);
- } else {
- return (EINVAL); /* Not an attribute structure! */
- }
-}
-
-
-int
-pthread_workqueue_attr_setovercommit_np(pthread_workqueue_attr_t * attr, int ocomm)
-{
-int error = 0;
-
- if (attr->sig == PTHREAD_WORKQUEUE_ATTR_SIG) {
- attr->overcommit = ocomm;
- } else {
- error = EINVAL;
- }
- return (error);
-}
-/* XXXXXXXXXXXXX Pthread Workqueue support routines XXXXXXXXXXXXXXXXXX */
-
-static void
-workqueue_list_lock()
-{
- OSSpinLockLock(&__workqueue_list_lock);
-}
-
-static void
-workqueue_list_unlock()
-{
- OSSpinLockUnlock(&__workqueue_list_lock);
-}
-
-int
-pthread_workqueue_init_np()
-{
- int ret;
-
- if (__workqueue_newspis != 0)
- return(EPERM);
- __workqueue_oldspis = 1;
-
- workqueue_list_lock();
- ret =_pthread_work_internal_init();
- workqueue_list_unlock();
-
- return(ret);
-}
-
-int
-pthread_workqueue_requestconcurrency_np(int queue, int request_concurrency)
-{
- int error = 0;
-
- if (__workqueue_newspis != 0)
- return(EPERM);
-
- if (queue < 0 || queue > WORKQ_NUM_PRIOQUEUE)
- return(EINVAL);
-
- error =__workq_kernreturn(WQOPS_THREAD_SETCONC, NULL, request_concurrency, queue);
-
- if (error == -1)
- return(errno);
- return(0);
-}
-
-void
-pthread_workqueue_atfork_prepare(void)
-{
- /*
- * NOTE: Any workq additions here
- * should be for i386,x86_64 only
- */
- dispatch_atfork_prepare();
-}
-
-void
-pthread_workqueue_atfork_parent(void)
-{
- /*
- * NOTE: Any workq additions here
- * should be for i386,x86_64 only
- */
- dispatch_atfork_parent();
-}
-
-void
-pthread_workqueue_atfork_child(void)
-{
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- pthread_t self = pthread_self();
-
- __workqueue_list_lock = OS_SPINLOCK_INIT;
-
- /* already using new spis? */
- if (__workqueue_newspis != 0) {
- /* prepare the kernel for workq action */
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- __bsdthread_register(thread_start, start_wqthread, round_page(sizeof(struct _pthread)), _pthread_start, &workq_targetconc[0], (uintptr_t)(&self->tsd[__PTK_LIBDISPATCH_KEY0]) - (uintptr_t)(&self->tsd[0]));
-#else
- __bsdthread_register(_pthread_start, _pthread_wqthread, round_page(sizeof(struct _pthread)),NULL,NULL,0);
-#endif
- (void)__workq_open();
- kernel_workq_setup = 1;
- return;
- }
-
- /* not using old spis either? */
- if (__workqueue_oldspis == 0)
- return;
-
- /*
- * NOTE: workq additions here
- * are for i386,x86_64 only as
- * ppc and arm do not support it
- */
- if (kernel_workq_setup != 0){
- kernel_workq_setup = 0;
- _pthread_work_internal_init();
- }
-#endif
- dispatch_atfork_child();
-}
-
-static int
-_pthread_work_internal_init(void)
-{
- int i, error;
- pthread_workqueue_head_t headp;
- pthread_workqueue_t wq;
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- pthread_t self = pthread_self();
-#endif
-
- if (kernel_workq_setup == 0) {
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- __bsdthread_register(thread_start, start_wqthread, round_page(sizeof(struct _pthread)), _pthread_start, &workq_targetconc[0], (uintptr_t)(&self->tsd[__PTK_LIBDISPATCH_KEY0]) - (uintptr_t)(&self->tsd[0]));
-#else
- __bsdthread_register(_pthread_start, _pthread_wqthread, round_page(sizeof(struct _pthread)),NULL,NULL,0);
-#endif
-
- _pthread_wq_attr_default.queueprio = WORKQ_DEFAULT_PRIOQUEUE;
- _pthread_wq_attr_default.sig = PTHREAD_WORKQUEUE_ATTR_SIG;
-
- for( i = 0; i< WORKQ_NUM_PRIOQUEUE; i++) {
- headp = __pthread_wq_head_tbl[i];
- TAILQ_INIT(&headp->wqhead);
- headp->next_workq = 0;
- }
-
- __workqueue_pool_ptr = NULL;
- __workqueue_pool_size = round_page(sizeof(struct _pthread_workitem) * WORKITEM_POOL_SIZE);
-
- __workqueue_pool_ptr = (struct _pthread_workitem *)mmap(NULL, __workqueue_pool_size,
- PROT_READ|PROT_WRITE,
- MAP_ANON | MAP_PRIVATE,
- 0,
- 0);
-
- if (__workqueue_pool_ptr == MAP_FAILED) {
- /* Not expected to fail, if it does, always malloc for work items */
- __workqueue_nitems = WORKITEM_POOL_SIZE;
- __workqueue_pool_ptr = NULL;
- } else
- __workqueue_nitems = 0;
-
- /* sets up the workitem pool */
- grow_workitem();
-
- /* since the size is less than a page, leaving this in malloc pool */
- wq = (struct _pthread_workqueue *)malloc(sizeof(struct _pthread_workqueue) * WORKQUEUE_POOL_SIZE);
- bzero(wq, (sizeof(struct _pthread_workqueue) * WORKQUEUE_POOL_SIZE));
- for (i = 0; i < WORKQUEUE_POOL_SIZE; i++) {
- TAILQ_INSERT_TAIL(&__pthread_workqueue_pool_head, &wq[i], wq_list);
- }
-
- if (error = __workq_open()) {
- TAILQ_INIT(&__pthread_workitem_pool_head);
- TAILQ_INIT(&__pthread_workqueue_pool_head);
- if (__workqueue_pool_ptr != NULL) {
- munmap((void *)__workqueue_pool_ptr, __workqueue_pool_size);
- }
- free(wq);
- return(ENOMEM);
- }
- kernel_workq_setup = 1;
- }
- return(0);
-}
-
-
-/* This routine is called with list lock held */
-static pthread_workitem_t
-alloc_workitem(void)
-{
- pthread_workitem_t witem;
-
- if (TAILQ_EMPTY(&__pthread_workitem_pool_head)) {
- /* the chunk size is set so some multiple of it is pool size */
- if (__workqueue_nitems < WORKITEM_POOL_SIZE) {
- grow_workitem();
- } else {
- workqueue_list_unlock();
- witem = malloc(sizeof(struct _pthread_workitem));
- workqueue_list_lock();
- witem->fromcache = 0;
- goto out;
- }
- }
- witem = TAILQ_FIRST(&__pthread_workitem_pool_head);
- TAILQ_REMOVE(&__pthread_workitem_pool_head, witem, item_entry);
- witem->fromcache = 1;
-out:
- witem->flags = 0;
- witem->item_entry.tqe_next = 0;
- witem->item_entry.tqe_prev = 0;
- user_workitem_count++;
- return(witem);
-}
-
-/* This routine is called with list lock held */
-static void
-free_workitem(pthread_workitem_t witem)
-{
- user_workitem_count--;
- witem->flags = 0;
- if (witem->fromcache != 0)
- TAILQ_INSERT_TAIL(&__pthread_workitem_pool_head, witem, item_entry);
- else
- free(witem);
-}
-
-static void
-grow_workitem(void)
-{
- pthread_workitem_t witemp;
- int i;
-
- witemp = &__workqueue_pool_ptr[__workqueue_nitems];
- bzero(witemp, (sizeof(struct _pthread_workitem) * WORKITEM_CHUNK_SIZE));
- for (i = 0; i < WORKITEM_CHUNK_SIZE; i++) {
- witemp[i].fromcache = 1;
- TAILQ_INSERT_TAIL(&__pthread_workitem_pool_head, &witemp[i], item_entry);
- }
- __workqueue_nitems += WORKITEM_CHUNK_SIZE;
-}
-
-/* This routine is called with list lock held */
-static pthread_workqueue_t
-alloc_workqueue(void)
-{
- pthread_workqueue_t wq;
-
- if (TAILQ_EMPTY(&__pthread_workqueue_pool_head)) {
- workqueue_list_unlock();
- wq = malloc(sizeof(struct _pthread_workqueue));
- workqueue_list_lock();
- } else {
- wq = TAILQ_FIRST(&__pthread_workqueue_pool_head);
- TAILQ_REMOVE(&__pthread_workqueue_pool_head, wq, wq_list);
- }
- user_workq_count++;
- return(wq);
-}
-
-/* This routine is called with list lock held */
-static void
-free_workqueue(pthread_workqueue_t wq)
-{
- user_workq_count--;
- TAILQ_INSERT_TAIL(&__pthread_workqueue_pool_head, wq, wq_list);
-}
-
-static void
-_pthread_workq_init(pthread_workqueue_t wq, const pthread_workqueue_attr_t * attr)
-{
- bzero(wq, sizeof(struct _pthread_workqueue));
- if (attr != NULL) {
- wq->queueprio = attr->queueprio;
- wq->overcommit = attr->overcommit;
- } else {
- wq->queueprio = WORKQ_DEFAULT_PRIOQUEUE;
- wq->overcommit = 0;
- }
- LOCK_INIT(wq->lock);
- wq->flags = 0;
- TAILQ_INIT(&wq->item_listhead);
- TAILQ_INIT(&wq->item_kernhead);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080ac, wq, &wq->item_listhead, wq->item_listhead.tqh_first, wq->item_listhead.tqh_last, 0);
-#endif
- wq->wq_list.tqe_next = 0;
- wq->wq_list.tqe_prev = 0;
- wq->sig = PTHREAD_WORKQUEUE_SIG;
- wq->headp = __pthread_wq_head_tbl[wq->queueprio];
-}
-
-int
-valid_workq(pthread_workqueue_t workq)
-{
- if (workq->sig == PTHREAD_WORKQUEUE_SIG)
- return(1);
- else
- return(0);
-}
-
-
-/* called with list lock */
-static void
-pick_nextworkqueue_droplock()
-{
- int i, curwqprio, val, found;
- pthread_workqueue_head_t headp;
- pthread_workqueue_t workq;
- pthread_workqueue_t nworkq = NULL;
-
-#if WQ_TRACE
- __kdebug_trace(0x9008098, kernel_workq_count, 0, 0, 0, 0);
-#endif
-loop:
- while (kernel_workq_count < KERNEL_WORKQ_ELEM_MAX) {
- found = 0;
- for (i = 0; i < WORKQ_NUM_PRIOQUEUE; i++) {
- wqreadyprio = i; /* because there is nothing else higher to run */
- headp = __pthread_wq_head_tbl[i];
-
- if (TAILQ_EMPTY(&headp->wqhead))
- continue;
- workq = headp->next_workq;
- if (workq == NULL)
- workq = TAILQ_FIRST(&headp->wqhead);
- curwqprio = workq->queueprio;
- nworkq = workq; /* starting pt */
- while (kernel_workq_count < KERNEL_WORKQ_ELEM_MAX) {
- headp->next_workq = TAILQ_NEXT(workq, wq_list);
- if (headp->next_workq == NULL)
- headp->next_workq = TAILQ_FIRST(&headp->wqhead);
-#if WQ_TRACE
- __kdebug_trace(0x9008098, kernel_workq_count, workq, 0, 1, 0);
-#endif
- val = post_nextworkitem(workq);
-
- if (val != 0) {
- /* things could have changed so reasses */
- /* If kernel queue is full , skip */
- if (kernel_workq_count >= KERNEL_WORKQ_ELEM_MAX)
- break;
- /* If anything with higher prio arrived, then reevaluate */
- if (wqreadyprio < curwqprio)
- goto loop; /* we need re evaluate again */
- /* we can post some more work items */
- found = 1;
- }
-
- /* cannot use workq here as it could be freed */
- if (TAILQ_EMPTY(&headp->wqhead))
- break;
- /* if we found nothing to run and only one workqueue in the list, skip */
- if ((val == 0) && (workq == headp->next_workq))
- break;
- workq = headp->next_workq;
- if (workq == NULL)
- workq = TAILQ_FIRST(&headp->wqhead);
- if (val != 0)
- nworkq = workq;
- /* if we found nothing to run and back to workq where we started */
- if ((val == 0) && (workq == nworkq))
- break;
- }
- if (kernel_workq_count >= KERNEL_WORKQ_ELEM_MAX)
- break;
- }
- /* nothing found to run? */
- if (found == 0)
- break;
- }
- workqueue_list_unlock();
-}
-
-static int
-post_nextworkitem(pthread_workqueue_t workq)
-{
- int error, prio;
- pthread_workitem_t witem;
- pthread_workqueue_head_t headp;
- void (*func)(pthread_workqueue_t, void *);
-
- if ((workq->flags & PTHREAD_WORKQ_SUSPEND) == PTHREAD_WORKQ_SUSPEND) {
- return(0);
- }
-#if WQ_TRACE
- __kdebug_trace(0x900809c, workq, workq->item_listhead.tqh_first, 0, 1, 0);
-#endif
- if (TAILQ_EMPTY(&workq->item_listhead)) {
- return(0);
- }
- if ((workq->flags & PTHREAD_WORKQ_BARRIER_ON) == PTHREAD_WORKQ_BARRIER_ON)
- return(0);
-
- witem = TAILQ_FIRST(&workq->item_listhead);
- headp = workq->headp;
-#if WQ_TRACE
- __kdebug_trace(0x900809c, workq, witem, 0, 0xee, 0);
-#endif
- if ((witem->flags & PTH_WQITEM_BARRIER) == PTH_WQITEM_BARRIER) {
-#if WQ_TRACE
- __kdebug_trace(0x9000064, workq, 0, 0, 2, 0);
-#endif
-
- if ((witem->flags & PTH_WQITEM_APPLIED) != 0) {
- return(0);
- }
- /* Also barrier when nothing is there needs to be handled */
- /* Nothing to wait for */
- if (workq->kq_count != 0) {
- witem->flags |= PTH_WQITEM_APPLIED;
- workq->flags |= PTHREAD_WORKQ_BARRIER_ON;
- workq->barrier_count = workq->kq_count;
-#if WQ_TRACE
- __kdebug_trace(0x9000064, 1, workq->barrier_count, 0, 0, 0);
-#endif
- return(1);
- } else {
-#if WQ_TRACE
- __kdebug_trace(0x9000064, 2, workq->barrier_count, 0, 0, 0);
-#endif
- if (witem->func != NULL) {
- /* since we are going to drop list lock */
- witem->flags |= PTH_WQITEM_APPLIED;
- workq->flags |= PTHREAD_WORKQ_BARRIER_ON;
- workqueue_list_unlock();
- func = (void (*)(pthread_workqueue_t, void *))witem->func;
- (*func)(workq, witem->func_arg);
-#if WQ_TRACE
- __kdebug_trace(0x9000064, 3, workq->barrier_count, 0, 0, 0);
-#endif
- workqueue_list_lock();
- workq->flags &= ~PTHREAD_WORKQ_BARRIER_ON;
- }
- TAILQ_REMOVE(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080a8, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- free_workitem(witem);
-#if WQ_TRACE
- __kdebug_trace(0x9000064, 4, workq->barrier_count, 0, 0, 0);
-#endif
- return(1);
- }
- } else if ((witem->flags & PTH_WQITEM_DESTROY) == PTH_WQITEM_DESTROY) {
-#if WQ_TRACE
- __kdebug_trace(0x9000068, 1, workq->kq_count, 0, 0, 0);
-#endif
- if ((witem->flags & PTH_WQITEM_APPLIED) != 0) {
- return(0);
- }
- witem->flags |= PTH_WQITEM_APPLIED;
- workq->flags |= (PTHREAD_WORKQ_BARRIER_ON | PTHREAD_WORKQ_TERM_ON);
- workq->barrier_count = workq->kq_count;
- workq->term_callback = (void (*)(struct _pthread_workqueue *,void *))witem->func;
- workq->term_callarg = witem->func_arg;
- TAILQ_REMOVE(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080a8, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- if ((TAILQ_EMPTY(&workq->item_listhead)) && (workq->kq_count == 0)) {
- if (!(TAILQ_EMPTY(&workq->item_kernhead))) {
-#if WQ_TRACE
- __kdebug_trace(0x900006c, workq, workq->kq_count, 0, 0xff, 0);
-#endif
- }
- free_workitem(witem);
- workq->flags |= PTHREAD_WORKQ_DESTROYED;
-#if WQ_TRACE
- __kdebug_trace(0x900006c, workq, workq->kq_count, 0, 1, 0);
-#endif
- headp = __pthread_wq_head_tbl[workq->queueprio];
- if (headp->next_workq == workq) {
- headp->next_workq = TAILQ_NEXT(workq, wq_list);
- if (headp->next_workq == NULL) {
- headp->next_workq = TAILQ_FIRST(&headp->wqhead);
- if (headp->next_workq == workq)
- headp->next_workq = NULL;
- }
- }
- workq->sig = 0;
- TAILQ_REMOVE(&headp->wqhead, workq, wq_list);
- if (workq->term_callback != NULL) {
- workqueue_list_unlock();
- (*workq->term_callback)(workq, workq->term_callarg);
- workqueue_list_lock();
- }
- free_workqueue(workq);
- return(1);
- } else {
- TAILQ_INSERT_HEAD(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080b0, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- }
-#if WQ_TRACE
- __kdebug_trace(0x9000068, 2, workq->barrier_count, 0, 0, 0);
-#endif
- return(1);
- } else {
-#if WQ_TRACE
- __kdebug_trace(0x9000060, witem, workq, witem->func_arg, 0xfff, 0);
-#endif
- TAILQ_REMOVE(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080a8, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- TAILQ_INSERT_TAIL(&workq->item_kernhead, witem, item_entry);
- if ((witem->flags & PTH_WQITEM_KERN_COUNT) == 0) {
- workq->kq_count++;
- witem->flags |= PTH_WQITEM_KERN_COUNT;
- }
- OSAtomicIncrement32Barrier(&kernel_workq_count);
- workqueue_list_unlock();
-
- prio = workq->queueprio;
- if (workq->overcommit != 0) {
- prio |= WORKQUEUE_OVERCOMMIT;
- }
-
- if (( error =__workq_kernreturn(WQOPS_QUEUE_ADD, witem, workq->affinity, prio)) == -1) {
- OSAtomicDecrement32Barrier(&kernel_workq_count);
- workqueue_list_lock();
-#if WQ_TRACE
- __kdebug_trace(0x900007c, witem, workq, witem->func_arg, workq->kq_count, 0);
-#endif
- TAILQ_REMOVE(&workq->item_kernhead, witem, item_entry);
- TAILQ_INSERT_HEAD(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080b0, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- if ((workq->flags & (PTHREAD_WORKQ_BARRIER_ON | PTHREAD_WORKQ_TERM_ON)) != 0)
- workq->flags |= PTHREAD_WORKQ_REQUEUED;
- } else
- workqueue_list_lock();
-#if WQ_TRACE
- __kdebug_trace(0x9000060, witem, workq, witem->func_arg, workq->kq_count, 0);
-#endif
- return(1);
- }
- /* noone should come here */
-#if 1
- printf("error in logic for next workitem\n");
- LIBC_ABORT("error in logic for next workitem");
-#endif
- return(0);
-}
-
-void
-_pthread_wqthread(pthread_t self, mach_port_t kport, void * stackaddr, pthread_workitem_t item, int reuse)
-{
- int ret;
- pthread_attr_t *attrs = &_pthread_attr_default;
- pthread_workqueue_t workq;
-#if WQ_DEBUG
- pthread_t pself;
-#endif
- int thread_reuse = 0;
- int thread_priority = 0;
- int thread_newspi = 0;
- int thread_options = 0;
-
- if (reuse & WQ_FLAG_THREAD_NEWSPI) {
- thread_reuse = reuse & WQ_FLAG_THREAD_REUSE;
- if ((reuse & WQ_FLAG_THREAD_OVERCOMMIT) != 0)
- thread_options = WORKQ_ADDTHREADS_OPTION_OVERCOMMIT;
- thread_priority = reuse & WQ_FLAG_THREAD_PRIOMASK;
- thread_newspi = 1;
- workq = NULL;
- } else {
- thread_reuse = (reuse == 0)? 0: WQ_FLAG_THREAD_REUSE;
- workq = item->workq;
- }
-
-
- if (thread_reuse == 0) {
- /* reuse is set to 0, when a thread is newly created to run a workitem */
- _pthread_struct_init(self, attrs, stackaddr, DEFAULT_STACK_SIZE, 1, 1);
- self->wqthread = 1;
- self->wqkillset = 0;
- self->parentcheck = 1;
-
- /* These are not joinable threads */
- self->detached &= ~PTHREAD_CREATE_JOINABLE;
- self->detached |= PTHREAD_CREATE_DETACHED;
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- _pthread_set_self(self);
-#endif
-#if WQ_TRACE
- __kdebug_trace(0x9000050, self, item, item->func_arg, 0, 0);
-#endif
- self->kernel_thread = kport;
- if (thread_newspi != 0) {
- self->fun = (void *(*)(void *))__libdispatch_workerfunction;
- self->arg = thread_priority;
- } else {
- self->fun = (void *(*)(void *))item->func;
- self->arg = item->func_arg;
- }
- /* Add to the pthread list */
- LOCK(_pthread_list_lock);
- TAILQ_INSERT_TAIL(&__pthread_head, self, plist);
-#if PTH_LISTTRACE
- __kdebug_trace(0x900000c, self, 0, 0, 10, 0);
-#endif
- _pthread_count++;
- UNLOCK(_pthread_list_lock);
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
- if( (self->thread_id = __thread_selfid()) == (__uint64_t)-1)
- printf("Failed to set thread_id in pthread_wqthread\n");
-#endif
-
- } else {
- /* reuse is set to 1, when a thread is resued to run another work item */
-#if WQ_TRACE
- __kdebug_trace(0x9000054, self, item, item->func_arg, 0, 0);
-#endif
- /* reset all tsd from 1 to KEYS_MAX */
- if (self == NULL)
- LIBC_ABORT("_pthread_wqthread: pthread %p setup to be NULL", self);
-
- if (thread_newspi != 0) {
- self->fun = (void *(*)(void *))__libdispatch_workerfunction;
- self->arg = NULL;
- } else {
- self->fun = (void *(*)(void *))item->func;
- self->arg = item->func_arg;
- }
- }
-
-#if WQ_DEBUG
- if (reuse == 0) {
- pself = pthread_self();
- if (self != pself) {
-#if WQ_TRACE
- __kdebug_trace(0x9000078, self, pself, item->func_arg, 0, 0);
-#endif
- printf("pthread_self not set: pself %p, passed in %p\n", pself, self);
- _pthread_set_self(self);
- pself = pthread_self();
- if (self != pself)
- printf("(2)pthread_self not set: pself %p, passed in %p\n", pself, self);
- pself = self;
- }
- } else {
- pself = pthread_self();
- if (self != pself) {
- printf("(3)pthread_self not set in reuse: pself %p, passed in %p\n", pself, self);
- LIBC_ABORT("(3)pthread_self not set in reuse: pself %p, passed in %p", pself, self);
- }
- }
-#endif /* WQ_DEBUG */
-
- if (thread_newspi != 0) {
- (*__libdispatch_workerfunction)(thread_priority, thread_options, NULL);
- _pthread_workq_return(self);
- } else {
- self->cur_workq = workq;
- self->cur_workitem = item;
- OSAtomicDecrement32Barrier(&kernel_workq_count);
-
- ret = (int)(intptr_t)(*self->fun)(self->arg);
- /* If we reach here without going through the above initialization path then don't go through
- * with the teardown code path ( e.g. setjmp/longjmp ). Instead just exit this thread.
- */
- if (self != pthread_self()) {
- pthread_exit(PTHREAD_CANCELED);
- }
-
- workqueue_exit(self, workq, item);
- }
-}
-
-static void
-workqueue_exit(pthread_t self, pthread_workqueue_t workq, pthread_workitem_t item)
-{
- pthread_workitem_t baritem;
- pthread_workqueue_head_t headp;
- void (*func)(pthread_workqueue_t, void *);
-
- workqueue_list_lock();
-
- TAILQ_REMOVE(&workq->item_kernhead, item, item_entry);
- workq->kq_count--;
-#if WQ_TRACE
- __kdebug_trace(0x9000070, self, 1, item->func_arg, workq->kq_count, 0);
-#endif
- free_workitem(item);
-
- if ((workq->flags & PTHREAD_WORKQ_BARRIER_ON) == PTHREAD_WORKQ_BARRIER_ON) {
- workq->barrier_count--;
-#if WQ_TRACE
- __kdebug_trace(0x9000084, self, workq->barrier_count, workq->kq_count, 1, 0);
-#endif
- if (workq->barrier_count <= 0 ) {
- /* Need to remove barrier item from the list */
- baritem = TAILQ_FIRST(&workq->item_listhead);
-#if WQ_DEBUG
- if ((baritem->flags & (PTH_WQITEM_BARRIER | PTH_WQITEM_DESTROY| PTH_WQITEM_APPLIED)) == 0)
- printf("Incorect bar item being removed in barrier processing\n");
-#endif /* WQ_DEBUG */
- /* if the front item is a barrier and call back is registered, run that */
- if (((baritem->flags & PTH_WQITEM_BARRIER) == PTH_WQITEM_BARRIER) && (baritem->func != NULL)) {
- workqueue_list_unlock();
- func = (void (*)(pthread_workqueue_t, void *))baritem->func;
- (*func)(workq, baritem->func_arg);
- workqueue_list_lock();
- }
- TAILQ_REMOVE(&workq->item_listhead, baritem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080a8, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
- free_workitem(baritem);
- workq->flags &= ~PTHREAD_WORKQ_BARRIER_ON;
-#if WQ_TRACE
- __kdebug_trace(0x9000058, self, item, item->func_arg, 0, 0);
-#endif
- if ((workq->flags & PTHREAD_WORKQ_TERM_ON) != 0) {
- headp = __pthread_wq_head_tbl[workq->queueprio];
- workq->flags |= PTHREAD_WORKQ_DESTROYED;
-#if WQ_TRACE
- __kdebug_trace(0x900006c, workq, workq->kq_count, 0, 2, 0);
-#endif
- if (headp->next_workq == workq) {
- headp->next_workq = TAILQ_NEXT(workq, wq_list);
- if (headp->next_workq == NULL) {
- headp->next_workq = TAILQ_FIRST(&headp->wqhead);
- if (headp->next_workq == workq)
- headp->next_workq = NULL;
- }
- }
- TAILQ_REMOVE(&headp->wqhead, workq, wq_list);
- workq->sig = 0;
- if (workq->term_callback != NULL) {
- workqueue_list_unlock();
- (*workq->term_callback)(workq, workq->term_callarg);
- workqueue_list_lock();
- }
- free_workqueue(workq);
- } else {
- /* if there are higher prio schedulabel item reset to wqreadyprio */
- if ((workq->queueprio < wqreadyprio) && (!(TAILQ_EMPTY(&workq->item_listhead))))
- wqreadyprio = workq->queueprio;
- }
- }
- }
-#if WQ_TRACE
- else {
- __kdebug_trace(0x9000070, self, 2, item->func_arg, workq->barrier_count, 0);
- }
-
- __kdebug_trace(0x900005c, self, item, 0, 0, 0);
-#endif
- pick_nextworkqueue_droplock();
- _pthread_workq_return(self);
-}
-
-static void
-_pthread_workq_return(pthread_t self)
-{
- __workq_kernreturn(WQOPS_THREAD_RETURN, NULL, 0, 0);
-
- /* This is the way to terminate the thread */
- _pthread_exit(self, NULL);
-}
-
-
-/* XXXXXXXXXXXXX Pthread Workqueue functions XXXXXXXXXXXXXXXXXX */
-
-int
-pthread_workqueue_setdispatch_np(void (*worker_func)(int, int, void *))
-{
- int error = 0;
-
- if (__workqueue_oldspis != 0)
- return(EPERM);
-
- __workqueue_newspis = 1;
-
- if (__libdispatch_workerfunction == NULL) {
- __libdispatch_workerfunction = worker_func;
- /* check whether the kernel supports new SPIs */
- error = __workq_kernreturn(WQOPS_QUEUE_NEWSPISUPP, NULL, 0, 0);
- if (error == -1){
- __libdispatch_workerfunction = NULL;
- error = ENOTSUP;
- __workqueue_newspis = 0;
- } else {
- /* prepare the kernel for workq action */
- (void)__workq_open();
- kernel_workq_setup = 1;
- if (__is_threaded == 0)
- __is_threaded = 1;
- __workqueue_newspis = 1;
- }
- } else {
- error = EBUSY;
- }
-
- return(error);
-}
-
-int
-pthread_workqueue_addthreads_np(int queue_priority, int options, int numthreads)
-{
- int priority = queue_priority & WQ_FLAG_THREAD_PRIOMASK;
- int error = 0;
-
- /* new spi not inited yet?? */
- if (__workqueue_newspis == 0)
- return(EPERM);
-
-
- if ((options & WORKQ_ADDTHREADS_OPTION_OVERCOMMIT) != 0)
- priority |= WORKQUEUE_OVERCOMMIT;
-
- error = __workq_kernreturn(WQOPS_QUEUE_REQTHREADS, NULL, numthreads, priority);
-
- if (error == -1)
- return(errno);
- else
- return(0);
-}
-
-int
-pthread_workqueue_create_np(pthread_workqueue_t * workqp, const pthread_workqueue_attr_t * attr)
-{
- pthread_workqueue_t wq;
- pthread_workqueue_head_t headp;
-
-#if defined(__ppc__)
- IF_ROSETTA() {
- return(ENOTSUP);
- }
-#endif
- if (__workqueue_newspis != 0)
- return(EPERM);
-
- if (__workqueue_oldspis == 0)
- __workqueue_oldspis = 1;
-
- if ((attr != NULL) && (attr->sig != PTHREAD_WORKQUEUE_ATTR_SIG)) {
- return(EINVAL);
- }
-
- if (__is_threaded == 0)
- __is_threaded = 1;
-
- workqueue_list_lock();
- if (kernel_workq_setup == 0) {
- int ret = _pthread_work_internal_init();
- if (ret != 0) {
- workqueue_list_unlock();
- return(ret);
- }
- }
-
- wq = alloc_workqueue();
-
- _pthread_workq_init(wq, attr);
-
- headp = __pthread_wq_head_tbl[wq->queueprio];
- TAILQ_INSERT_TAIL(&headp->wqhead, wq, wq_list);
- if (headp->next_workq == NULL) {
- headp->next_workq = TAILQ_FIRST(&headp->wqhead);
- }
-
- workqueue_list_unlock();
-
- *workqp = wq;
-
- return(0);
-}
-
-int
-pthread_workqueue_additem_np(pthread_workqueue_t workq, void ( *workitem_func)(void *), void * workitem_arg, pthread_workitem_handle_t * itemhandlep, unsigned int *gencountp)
-{
- pthread_workitem_t witem;
-
- if (__workqueue_newspis != 0)
- return(EPERM);
-
- if (valid_workq(workq) == 0) {
- return(EINVAL);
- }
-
- workqueue_list_lock();
-
- /*
- * Allocate the workitem here as it can drop the lock.
- * Also we can evaluate the workqueue state only once.
- */
- witem = alloc_workitem();
- witem->func = workitem_func;
- witem->func_arg = workitem_arg;
- witem->workq = workq;
-
- /* alloc workitem can drop the lock, check the state */
- if ((workq->flags & (PTHREAD_WORKQ_IN_TERMINATE | PTHREAD_WORKQ_DESTROYED)) != 0) {
- free_workitem(witem);
- workqueue_list_unlock();
- *itemhandlep = 0;
- return(ESRCH);
- }
-
- if (itemhandlep != NULL)
- *itemhandlep = (pthread_workitem_handle_t *)witem;
- if (gencountp != NULL)
- *gencountp = 0;
-#if WQ_TRACE
- __kdebug_trace(0x9008090, witem, witem->func, witem->func_arg, workq, 0);
-#endif
- TAILQ_INSERT_TAIL(&workq->item_listhead, witem, item_entry);
-#if WQ_LISTTRACE
- __kdebug_trace(0x90080a4, workq, &workq->item_listhead, workq->item_listhead.tqh_first, workq->item_listhead.tqh_last, 0);
-#endif
-
- if (((workq->flags & PTHREAD_WORKQ_BARRIER_ON) == 0) && (workq->queueprio < wqreadyprio))
- wqreadyprio = workq->queueprio;
-
- pick_nextworkqueue_droplock();
-
- return(0);
-}
-
-int
-pthread_workqueue_getovercommit_np(pthread_workqueue_t workq, unsigned int *ocommp)
-{
- if (__workqueue_newspis != 0)
- return(EPERM);
-
- if (valid_workq(workq) == 0) {
- return(EINVAL);
- }
-
- if (ocommp != NULL)
- *ocommp = workq->overcommit;
- return(0);
-}
-
-
-#else /* !BUILDING_VARIANT ] [ */
-extern int __unix_conforming;
-extern int _pthread_count;
-extern int __workqueue_newspis;
-extern int __workqueue_oldspis;
-
-extern pthread_lock_t _pthread_list_lock;
-extern void _pthread_testcancel(pthread_t thread, int isconforming);
-extern int _pthread_reap_thread(pthread_t th, mach_port_t kernel_thread, void **value_ptr, int conforming);
-
-#endif /* !BUILDING_VARIANT ] */
-
-#if __DARWIN_UNIX03
-
-__private_extern__ void
-__posix_join_cleanup(void *arg)
-{
- pthread_t thread = (pthread_t)arg;
- int already_exited, res;
- void * dummy;
- semaphore_t death;
- int newstyle;
-
- LOCK(thread->lock);
- already_exited = (thread->detached & _PTHREAD_EXITED);
-
- newstyle = thread->newstyle;
-
-#if WQ_TRACE
- __kdebug_trace(0x900002c, thread, newstyle, 0, 0, 0);
-#endif
- if (newstyle == 0) {
- death = thread->death;
- if (!already_exited){
- thread->joiner = (struct _pthread *)NULL;
- UNLOCK(thread->lock);
- restore_sem_to_pool(death);
- } else {
- UNLOCK(thread->lock);
- while ((res = _pthread_reap_thread(thread,
- thread->kernel_thread,
- &dummy, 1)) == EAGAIN)
- {
- sched_yield();
- }
- restore_sem_to_pool(death);
-
- }
-
- } else {
- /* leave another thread to join */
- thread->joiner = (struct _pthread *)NULL;
- UNLOCK(thread->lock);
- }
-}
-
-#endif /* __DARWIN_UNIX03 */
-
-
-/*
- * Wait for a thread to terminate and obtain its exit value.
- */
-/*
-int
-pthread_join(pthread_t thread,
- void **value_ptr)
-
-moved to pthread_cancelable.c */
-
-/*
- * Cancel a thread
- */
-int
-pthread_cancel(pthread_t thread)
-{
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-#endif /* __DARWIN_UNIX03 */
-
- if (_pthread_lookup_thread(thread, NULL, 0) != 0)
- return(ESRCH);
-
- /* if the thread is a workqueue thread, then return error */
- if (thread->wqthread != 0) {
- return(ENOTSUP);
- }
-#if __DARWIN_UNIX03
- int state;
-
- LOCK(thread->lock);
- state = thread->cancel_state |= _PTHREAD_CANCEL_PENDING;
- UNLOCK(thread->lock);
- if (state & PTHREAD_CANCEL_ENABLE)
- __pthread_markcancel(thread->kernel_thread);
-#else /* __DARWIN_UNIX03 */
- thread->cancel_state |= _PTHREAD_CANCEL_PENDING;
-#endif /* __DARWIN_UNIX03 */
- return (0);
-}
-
-void
-pthread_testcancel(void)
-{
- pthread_t self = pthread_self();
-
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
- _pthread_testcancel(self, 1);
-#else /* __DARWIN_UNIX03 */
- _pthread_testcancel(self, 0);
-#endif /* __DARWIN_UNIX03 */
-
-}
-
-
-/*
- * Query/update the cancelability 'state' of a thread
- */
-int
-pthread_setcancelstate(int state, int *oldstate)
-{
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0) {
- __unix_conforming = 1;
- }
- return (_pthread_setcancelstate_internal(state, oldstate, 1));
-#else /* __DARWIN_UNIX03 */
- return (_pthread_setcancelstate_internal(state, oldstate, 0));
-#endif /* __DARWIN_UNIX03 */
-
-}
-
-
-
-/*
- * Query/update the cancelability 'type' of a thread
- */
-int
-pthread_setcanceltype(int type, int *oldtype)
-{
- pthread_t self = pthread_self();
-
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-#endif /* __DARWIN_UNIX03 */
-
- if ((type != PTHREAD_CANCEL_DEFERRED) &&
- (type != PTHREAD_CANCEL_ASYNCHRONOUS))
- return EINVAL;
- self = pthread_self();
- LOCK(self->lock);
- if (oldtype)
- *oldtype = self->cancel_state & _PTHREAD_CANCEL_TYPE_MASK;
- self->cancel_state &= ~_PTHREAD_CANCEL_TYPE_MASK;
- self->cancel_state |= type;
- UNLOCK(self->lock);
-#if !__DARWIN_UNIX03
- _pthread_testcancel(self, 0); /* See if we need to 'die' now... */
-#endif /* __DARWIN_UNIX03 */
- return (0);
-}
-
-int
-pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
-{
-#if __DARWIN_UNIX03
- int err = 0;
-
- if (__pthread_sigmask(how, set, oset) == -1) {
- err = errno;
- }
- return(err);
-#else /* __DARWIN_UNIX03 */
- return(__pthread_sigmask(how, set, oset));
-#endif /* __DARWIN_UNIX03 */
-}
-
-/*
-int
-sigwait(const sigset_t * set, int * sig)
-
-moved to pthread_cancelable.c */
projects / apple / libc.git / blobdiff