int
_pthread_detach(pthread_t pthread)
{
struct pthread *curthread = tls_get_curthread();
int rval;
if (pthread == NULL)
return (EINVAL);
THREAD_LIST_LOCK(curthread);
if ((rval = _thr_find_thread(curthread, pthread,
/*include dead*/1)) != 0) {
THREAD_LIST_UNLOCK(curthread);
return (rval);
}
/* Check if the thread is already detached or has a joiner. */
if ((pthread->tlflags & TLFLAGS_DETACHED) != 0 ||
(pthread->joiner != NULL)) {
THREAD_LIST_UNLOCK(curthread);
return (EINVAL);
}
/* Flag the thread as detached. */
pthread->tlflags |= TLFLAGS_DETACHED;
if (pthread->state == PS_DEAD)
THR_GCLIST_ADD(pthread);
THREAD_LIST_UNLOCK(curthread);
return (0);
}
static void backout_join(void *arg)
{
struct pthread *curthread = tls_get_curthread();
struct pthread *pthread = (struct pthread *)arg;
THREAD_LIST_LOCK(curthread);
pthread->joiner = NULL;
THREAD_LIST_UNLOCK(curthread);
}
void
_thr_gc(struct pthread *curthread)
{
struct pthread *td, *td_next;
TAILQ_HEAD(, pthread) worklist;
TAILQ_INIT(&worklist);
THREAD_LIST_LOCK(curthread);
/* Check the threads waiting for GC. */
for (td = TAILQ_FIRST(&_thread_gc_list); td != NULL; td = td_next) {
td_next = TAILQ_NEXT(td, gcle);
if (td->terminated == 0) {
/* make sure we are not still in userland */
continue;
}
_thr_stack_free(&td->attr);
if (((td->tlflags & TLFLAGS_DETACHED) != 0) &&
(td->refcount == 0)) {
THR_GCLIST_REMOVE(td);
/*
* The thread has detached and is no longer
* referenced. It is safe to remove all
* remnants of the thread.
*/
THR_LIST_REMOVE(td);
TAILQ_INSERT_HEAD(&worklist, td, gcle);
}
}
THREAD_LIST_UNLOCK(curthread);
while ((td = TAILQ_FIRST(&worklist)) != NULL) {
TAILQ_REMOVE(&worklist, td, gcle);
/*
* XXX we don't free initial thread, because there might
* have some code referencing initial thread.
*/
if (td == _thr_initial) {
DBG_MSG("Initial thread won't be freed\n");
continue;
}
_thr_free(curthread, td);
}
}
static int
join_common(pthread_t pthread, void **thread_return,
const struct timespec *abstime)
{
struct pthread *curthread = tls_get_curthread();
struct timespec ts, ts2, *tsp;
void *tmp;
long state;
int oldcancel;
int ret = 0;
if (pthread == NULL)
return (EINVAL);
if (pthread == curthread)
return (EDEADLK);
THREAD_LIST_LOCK(curthread);
if ((ret = _thr_find_thread(curthread, pthread, 1)) != 0) {
ret = ESRCH;
} else if ((pthread->tlflags & TLFLAGS_DETACHED) != 0) {
ret = ESRCH;
} else if (pthread->joiner != NULL) {
/* Multiple joiners are not supported. */
ret = ENOTSUP;
}
if (ret) {
THREAD_LIST_UNLOCK(curthread);
return (ret);
}
/* Set the running thread to be the joiner: */
pthread->joiner = curthread;
THREAD_LIST_UNLOCK(curthread);
THR_CLEANUP_PUSH(curthread, backout_join, pthread);
oldcancel = _thr_cancel_enter(curthread);
while ((state = pthread->state) != PS_DEAD) {
if (abstime != NULL) {
clock_gettime(CLOCK_REALTIME, &ts);
TIMESPEC_SUB(&ts2, abstime, &ts);
if (ts2.tv_sec < 0) {
ret = ETIMEDOUT;
break;
}
tsp = &ts2;
} else
tsp = NULL;
ret = _thr_umtx_wait(&pthread->state, state, tsp,
CLOCK_REALTIME);
if (ret == ETIMEDOUT)
break;
}
_thr_cancel_leave(curthread, oldcancel);
THR_CLEANUP_POP(curthread, 0);
if (ret == ETIMEDOUT) {
THREAD_LIST_LOCK(curthread);
pthread->joiner = NULL;
THREAD_LIST_UNLOCK(curthread);
} else {
ret = 0;
tmp = pthread->ret;
THREAD_LIST_LOCK(curthread);
pthread->tlflags |= TLFLAGS_DETACHED;
pthread->joiner = NULL;
THR_GCLIST_ADD(pthread);
THREAD_LIST_UNLOCK(curthread);
if (thread_return != NULL)
*thread_return = tmp;
}
return (ret);
}
int
_pthread_create(pthread_t * thread, const pthread_attr_t * attr,
void *(*start_routine) (void *), void *arg)
{
struct lwp_params create_params;
void *stack;
sigset_t sigmask, oldsigmask;
struct pthread *curthread, *new_thread;
int ret = 0, locked;
_thr_check_init();
/*
* Tell libc and others now they need lock to protect their data.
*/
if (_thr_isthreaded() == 0 && _thr_setthreaded(1))
return (EAGAIN);
curthread = tls_get_curthread();
if ((new_thread = _thr_alloc(curthread)) == NULL)
return (EAGAIN);
if (attr == NULL || *attr == NULL) {
/* Use the default thread attributes: */
new_thread->attr = _pthread_attr_default;
} else {
new_thread->attr = *(*attr);
}
if (new_thread->attr.sched_inherit == PTHREAD_INHERIT_SCHED) {
/* inherit scheduling contention scope */
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
new_thread->attr.flags |= PTHREAD_SCOPE_SYSTEM;
else
new_thread->attr.flags &= ~PTHREAD_SCOPE_SYSTEM;
/*
* scheduling policy and scheduling parameters will be
* inherited in following code.
*/
}
if (create_stack(&new_thread->attr) != 0) {
/* Insufficient memory to create a stack: */
new_thread->terminated = 1;
_thr_free(curthread, new_thread);
return (EAGAIN);
}
/*
* Write a magic value to the thread structure
* to help identify valid ones:
*/
new_thread->magic = THR_MAGIC;
new_thread->start_routine = start_routine;
new_thread->arg = arg;
new_thread->cancelflags = PTHREAD_CANCEL_ENABLE |
PTHREAD_CANCEL_DEFERRED;
/*
* Check if this thread is to inherit the scheduling
* attributes from its parent:
*/
if (new_thread->attr.sched_inherit == PTHREAD_INHERIT_SCHED) {
/*
* Copy the scheduling attributes. Lock the scheduling
* lock to get consistent scheduling parameters.
*/
THR_LOCK(curthread);
new_thread->base_priority = curthread->base_priority;
new_thread->attr.prio = curthread->attr.prio;
new_thread->attr.sched_policy = curthread->attr.sched_policy;
THR_UNLOCK(curthread);
} else {
/*
* Use just the thread priority, leaving the
* other scheduling attributes as their
* default values:
*/
new_thread->base_priority = new_thread->attr.prio;
}
new_thread->active_priority = new_thread->base_priority;
/* Initialize the mutex queue: */
TAILQ_INIT(&new_thread->mutexq);
/* Initialise hooks in the thread structure: */
if (new_thread->attr.suspend == THR_CREATE_SUSPENDED)
new_thread->flags = THR_FLAGS_NEED_SUSPEND;
new_thread->state = PS_RUNNING;
if (new_thread->attr.flags & PTHREAD_CREATE_DETACHED)
new_thread->tlflags |= TLFLAGS_DETACHED;
/* Add the new thread. */
new_thread->refcount = 1;
_thr_link(curthread, new_thread);
/* Return thread pointer eariler so that new thread can use it. */
(*thread) = new_thread;
if (SHOULD_REPORT_EVENT(curthread, TD_CREATE)) {
THR_THREAD_LOCK(curthread, new_thread);
locked = 1;
} else
locked = 0;
/* Schedule the new thread. */
stack = (char *)new_thread->attr.stackaddr_attr +
new_thread->attr.stacksize_attr;
bzero(&create_params, sizeof(create_params));
create_params.lwp_func = thread_start;
create_params.lwp_arg = new_thread;
create_params.lwp_stack = stack;
create_params.lwp_tid1 = &new_thread->tid;
/*
* Thread created by thr_create() inherits currrent thread
* sigmask, however, before new thread setup itself correctly,
* it can not handle signal, so we should mask all signals here.
* We do this at the very last moment, so that we don't run
* into problems while we have all signals disabled.
*/
SIGFILLSET(sigmask);
__sys_sigprocmask(SIG_SETMASK, &sigmask, &oldsigmask);
new_thread->sigmask = oldsigmask;
ret = lwp_create(&create_params);
__sys_sigprocmask(SIG_SETMASK, &oldsigmask, NULL);
if (ret != 0) {
if (!locked)
THR_THREAD_LOCK(curthread, new_thread);
new_thread->state = PS_DEAD;
new_thread->terminated = 1;
if (new_thread->flags & THR_FLAGS_NEED_SUSPEND) {
new_thread->cycle++;
_thr_umtx_wake(&new_thread->cycle, INT_MAX);
}
THR_THREAD_UNLOCK(curthread, new_thread);
THREAD_LIST_LOCK(curthread);
_thread_active_threads--;
new_thread->tlflags |= TLFLAGS_DETACHED;
_thr_ref_delete_unlocked(curthread, new_thread);
THREAD_LIST_UNLOCK(curthread);
(*thread) = NULL;
ret = EAGAIN;
} else if (locked) {
_thr_report_creation(curthread, new_thread);
THR_THREAD_UNLOCK(curthread, new_thread);
}
return (ret);
}
void
_pthread_exit(void *status)
{
struct pthread *curthread = _get_curthread();
/* Check if this thread is already in the process of exiting: */
if (curthread->cancelling) {
char msg[128];
snprintf(msg, sizeof(msg), "Thread %p has called "
"pthread_exit() from a destructor. POSIX 1003.1 "
"1996 s16.2.5.2 does not allow this!", curthread);
PANIC(msg);
}
/* Flag this thread as exiting. */
curthread->cancelling = 1;
_thr_exit_cleanup();
/* Save the return value: */
curthread->ret = status;
while (curthread->cleanup != NULL) {
_pthread_cleanup_pop(1);
}
/* Check if there is thread specific data: */
if (curthread->specific != NULL) {
/* Run the thread-specific data destructors: */
_thread_cleanupspecific();
}
if (!_thr_isthreaded())
exit(0);
THREAD_LIST_LOCK(curthread);
_thread_active_threads--;
if (_thread_active_threads == 0) {
THREAD_LIST_UNLOCK(curthread);
exit(0);
/* Never reach! */
}
THREAD_LIST_UNLOCK(curthread);
/* Tell malloc that the thread is exiting. */
_malloc_thread_cleanup();
THREAD_LIST_LOCK(curthread);
THR_LOCK(curthread);
curthread->state = PS_DEAD;
if (curthread->flags & THR_FLAGS_NEED_SUSPEND) {
curthread->cycle++;
_thr_umtx_wake(&curthread->cycle, INT_MAX, 0);
}
THR_UNLOCK(curthread);
/*
* Thread was created with initial refcount 1, we drop the
* reference count to allow it to be garbage collected.
*/
curthread->refcount--;
if (curthread->tlflags & TLFLAGS_DETACHED)
THR_GCLIST_ADD(curthread);
THREAD_LIST_UNLOCK(curthread);
if (!curthread->force_exit && SHOULD_REPORT_EVENT(curthread, TD_DEATH))
_thr_report_death(curthread);
/*
* Kernel will do wakeup at the address, so joiner thread
* will be resumed if it is sleeping at the address.
*/
thr_exit(&curthread->tid);
#ifndef __AVM2__ // might exit if we're impersonating another thread!
PANIC("thr_exit() returned");
#endif
/* Never reach! */
}
