int
_sem_wait(sem_t *sem)
{
struct pthread *curthread;
int retval;
if (sem_check_validity(sem) != 0)
return (-1);
curthread = _get_curthread();
if ((*sem)->syssem != 0) {
_thr_cancel_enter(curthread);
retval = ksem_wait((*sem)->semid);
_thr_cancel_leave(curthread, retval != 0);
}
else {
_pthread_testcancel();
_pthread_mutex_lock(&(*sem)->lock);
while ((*sem)->count <= 0) {
(*sem)->nwaiters++;
THR_CLEANUP_PUSH(curthread, decrease_nwaiters, sem);
_pthread_cond_wait(&(*sem)->gtzero, &(*sem)->lock);
THR_CLEANUP_POP(curthread, 0);
(*sem)->nwaiters--;
}
(*sem)->count--;
_pthread_mutex_unlock(&(*sem)->lock);
retval = 0;
}
return (retval);
}
int
__sigwaitinfo(const sigset_t *set, siginfo_t *info)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = lib_sigtimedwait(set, info, NULL);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = _pthread_cond_wait(cond, mutex);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec *abstime)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = _pthread_cond_timedwait(cond, mutex, abstime);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__sigsuspend(const sigset_t * set)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = _sigsuspend(set);
_thr_cancel_leave(curthread, 1);
return (ret);
}
ssize_t
__read(int fd, void *buf, size_t nbytes)
{
struct pthread *curthread = _get_curthread();
ssize_t ret;
_thr_cancel_enter(curthread);
ret = __sys_read(fd, buf, nbytes);
_thr_cancel_leave(curthread, 1);
return ret;
}
int
_tcdrain(int fd)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __tcdrain(fd);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
_usleep(useconds_t useconds)
{
struct pthread *curthread = _get_curthread();
unsigned int ret;
_thr_cancel_enter(curthread);
ret = __usleep(useconds);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__close(int fd)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __sys_close(fd);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__sigtimedwait(const sigset_t *set, siginfo_t *info,
const struct timespec * timeout)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = lib_sigtimedwait(set, info, timeout);
_thr_cancel_leave(curthread, 1);
return (ret);
}
pid_t
_waitpid(pid_t wpid, int *status, int options)
{
struct pthread *curthread = _get_curthread();
pid_t ret;
_thr_cancel_enter(curthread);
ret = __waitpid(wpid, status, options);
_thr_cancel_leave(curthread, 1);
return (ret);
}
pid_t
__wait4(pid_t pid, int *istat, int options, struct rusage *rusage)
{
struct pthread *curthread = _get_curthread();
pid_t ret;
_thr_cancel_enter(curthread);
ret = _wait4(pid, istat, options, rusage);
_thr_cancel_leave(curthread, 1);
return ret;
}
int
_pause(void)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __pause();
_thr_cancel_leave(curthread, 1);
return ret;
}
ssize_t
__readv(int fd, const struct iovec *iov, int iovcnt)
{
struct pthread *curthread = _get_curthread();
ssize_t ret;
_thr_cancel_enter(curthread);
ret = __sys_readv(fd, iov, iovcnt);
_thr_cancel_leave(curthread, 1);
return ret;
}
int
__poll(struct pollfd *fds, unsigned int nfds, int timeout)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __sys_poll(fds, nfds, timeout);
_thr_cancel_leave(curthread, 1);
return ret;
}
/*
* Cancellation behavior:
* If thread is canceled, file is not created.
*/
int
___creat(const char *path, mode_t mode)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __creat(path, mode);
_thr_cancel_leave(curthread, ret == -1);
return ret;
}
/*
* Cancellation behavior:
* If the thread is canceled, connection is not made.
*/
int
__connect(int fd, const struct sockaddr *name, socklen_t namelen)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __sys_connect(fd, name, namelen);
_thr_cancel_leave(curthread, ret == -1);
return (ret);
}
pid_t
_wait(int *istat)
{
struct pthread *curthread = _get_curthread();
pid_t ret;
_thr_cancel_enter(curthread);
ret = __wait(istat);
_thr_cancel_leave(curthread, 1);
return ret;
}
int
__accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
struct pthread *curthread;
int ret;
curthread = _get_curthread();
_thr_cancel_enter(curthread);
ret = __sys_accept(s, addr, addrlen);
_thr_cancel_leave(curthread, ret == -1);
return (ret);
}
int
__aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
timespec *timeout)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __sys_aio_suspend(iocbs, niocb, timeout);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__nanosleep(const struct timespec *time_to_sleep,
struct timespec *time_remaining)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = _nanosleep(time_to_sleep, time_remaining);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
___creat(const char *path, mode_t mode)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = __creat(path, mode);
/*
* To avoid possible file handle leak,
* only check cancellation point if it is failure
*/
_thr_cancel_leave(curthread, (ret == -1));
return ret;
}
/*
* Cancellation behavior:
* According to specification, only F_SETLKW is a cancellation point.
* Thread is only canceled at start, or canceled if the system call
* is failure, this means the function does not generate side effect
* if it is canceled.
*/
int
__fcntl(int fd, int cmd,...)
{
struct pthread *curthread = _get_curthread();
int ret;
va_list ap;
va_start(ap, cmd);
if (cmd == F_OSETLKW || cmd == F_SETLKW) {
_thr_cancel_enter(curthread);
#ifdef SYSCALL_COMPAT
ret = __fcntl_compat(fd, cmd, va_arg(ap, void *));
#else
ret = __sys_fcntl(fd, cmd, va_arg(ap, void *));
#endif
_thr_cancel_leave(curthread, ret == -1);
} else {
int
__sigwait(const sigset_t *set, int *sig)
{
struct pthread *curthread = _get_curthread();
int ret;
_thr_cancel_enter(curthread);
ret = lib_sigtimedwait(set, NULL, NULL);
if (ret > 0) {
*sig = ret;
ret = 0;
} else {
ret = errno;
}
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__open(const char *path, int flags,...)
{
struct pthread *curthread = _get_curthread();
int ret;
int mode = 0;
va_list ap;
_thr_cancel_enter(curthread);
/* Check if the file is being created: */
if (flags & O_CREAT) {
/* Get the creation mode: */
va_start(ap, flags);
mode = va_arg(ap, int);
va_end(ap);
}
int
__msync(void *addr, size_t len, int flags)
{
struct pthread *curthread = _get_curthread();
int ret;
/*
* XXX This is quite pointless unless we know how to get the
* file descriptor associated with the memory, and lock it for
* write. The only real use of this wrapper is to guarantee
* a cancellation point, as per the standard. sigh.
*/
_thr_cancel_enter(curthread);
ret = __sys_msync(addr, len, flags);
_thr_cancel_leave(curthread, 1);
return (ret);
}
int
__select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout)
{
struct pthread *curthread = _get_curthread();
struct timespec ts;
int ret;
if (numfds == 0 && timeout != NULL) {
TIMEVAL_TO_TIMESPEC(timeout, &ts);
ret = _nanosleep(&ts, NULL);
} else {
_thr_cancel_enter(curthread);
ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);
_thr_cancel_leave(curthread, 1);
}
return (ret);
}
/*
* Cancellation behavior:
* if the thread is canceled, joinee is not recycled.
*/
static int
join_common(pthread_t pthread, void **thread_return,
const struct timespec *abstime)
{
struct pthread *curthread = _get_curthread();
struct timespec ts, ts2, *tsp;
void *tmp;
long tid;
int ret = 0;
if (pthread == NULL)
return (EINVAL);
if (pthread == curthread)
return (EDEADLK);
if ((ret = _thr_find_thread(curthread, pthread, 1)) != 0)
return (ESRCH);
if ((pthread->flags & THR_FLAGS_DETACHED) != 0) {
ret = EINVAL;
} else if (pthread->joiner != NULL) {
/* Multiple joiners are not supported. */
ret = ENOTSUP;
}
if (ret) {
THR_THREAD_UNLOCK(curthread, pthread);
return (ret);
}
/* Set the running thread to be the joiner: */
pthread->joiner = curthread;
THR_THREAD_UNLOCK(curthread, pthread);
THR_CLEANUP_PUSH(curthread, backout_join, pthread);
_thr_cancel_enter(curthread);
tid = pthread->tid;
while (pthread->tid != TID_TERMINATED) {
_thr_testcancel(curthread);
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->tid, tid, tsp);
if (ret == ETIMEDOUT)
break;
}
_thr_cancel_leave(curthread, 0);
THR_CLEANUP_POP(curthread, 0);
if (ret == ETIMEDOUT) {
THR_THREAD_LOCK(curthread, pthread);
pthread->joiner = NULL;
THR_THREAD_UNLOCK(curthread, pthread);
} else {
ret = 0;
tmp = pthread->ret;
THR_THREAD_LOCK(curthread, pthread);
pthread->flags |= THR_FLAGS_DETACHED;
pthread->joiner = NULL;
_thr_try_gc(curthread, pthread); /* thread lock released */
if (thread_return != NULL)
*thread_return = tmp;
}
return (ret);
}
int
_pthread_join(pthread_t pthread, void **thread_return)
{
struct pthread *curthread = _get_curthread();
void *tmp;
kse_critical_t crit;
int ret = 0;
_thr_cancel_enter(curthread);
/* Check if the caller has specified an invalid thread: */
if (pthread == NULL || pthread->magic != THR_MAGIC) {
/* Invalid thread: */
_thr_cancel_leave(curthread, 1);
return (EINVAL);
}
/* Check if the caller has specified itself: */
if (pthread == curthread) {
/* Avoid a deadlock condition: */
_thr_cancel_leave(curthread, 1);
return (EDEADLK);
}
/*
* Find the thread in the list of active threads or in the
* list of dead threads:
*/
if ((ret = _thr_ref_add(curthread, pthread, /*include dead*/1)) != 0) {
/* Return an error: */
_thr_cancel_leave(curthread, 1);
return (ESRCH);
}
THR_SCHED_LOCK(curthread, pthread);
/* Check if this thread has been detached: */
if ((pthread->attr.flags & PTHREAD_DETACHED) != 0) {
THR_SCHED_UNLOCK(curthread, pthread);
/* Remove the reference and return an error: */
_thr_ref_delete(curthread, pthread);
ret = EINVAL;
} else {
/* Lock the target thread while checking its state. */
if (pthread->state == PS_DEAD) {
/* Return the thread's return value: */
tmp = pthread->ret;
/* Detach the thread. */
pthread->attr.flags |= PTHREAD_DETACHED;
/* Unlock the thread. */
THR_SCHED_UNLOCK(curthread, pthread);
/*
* Remove the thread from the list of active
* threads and add it to the GC list.
*/
crit = _kse_critical_enter();
KSE_LOCK_ACQUIRE(curthread->kse, &_thread_list_lock);
THR_LIST_REMOVE(pthread);
THR_GCLIST_ADD(pthread);
KSE_LOCK_RELEASE(curthread->kse, &_thread_list_lock);
_kse_critical_leave(crit);
/* Remove the reference. */
_thr_ref_delete(curthread, pthread);
if (thread_return != NULL)
*thread_return = tmp;
}
else if (pthread->joiner != NULL) {
/* Unlock the thread and remove the reference. */
THR_SCHED_UNLOCK(curthread, pthread);
_thr_ref_delete(curthread, pthread);
/* Multiple joiners are not supported. */
ret = ENOTSUP;
}
else {
/* Set the running thread to be the joiner: */
pthread->joiner = curthread;
/* Keep track of which thread we're joining to: */
curthread->join_status.thread = pthread;
/* Unlock the thread and remove the reference. */
THR_SCHED_UNLOCK(curthread, pthread);
_thr_ref_delete(curthread, pthread);
THR_SCHED_LOCK(curthread, curthread);
while (curthread->join_status.thread == pthread) {
THR_SET_STATE(curthread, PS_JOIN);
THR_SCHED_UNLOCK(curthread, curthread);
/* Schedule the next thread: */
_thr_sched_switch(curthread);
THR_SCHED_LOCK(curthread, curthread);
}
THR_SCHED_UNLOCK(curthread, curthread);
if ((curthread->cancelflags & THR_CANCELLING) &&
!(curthread->cancelflags & PTHREAD_CANCEL_DISABLE)) {
if (_thr_ref_add(curthread, pthread, 1) == 0) {
THR_SCHED_LOCK(curthread, pthread);
pthread->joiner = NULL;
THR_SCHED_UNLOCK(curthread, pthread);
_thr_ref_delete(curthread, pthread);
}
_pthread_exit(PTHREAD_CANCELED);
}
/*
* The thread return value and error are set by the
* thread we're joining to when it exits or detaches:
*/
ret = curthread->join_status.error;
if ((ret == 0) && (thread_return != NULL))
*thread_return = curthread->join_status.ret;
}
}
_thr_cancel_leave(curthread, 1);
/* Return the completion status: */
return (ret);
}
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);
}
