diff options
Diffstat (limited to 'linuxthreads')
| -rw-r--r-- | linuxthreads/ChangeLog | 1 | ||||
| -rw-r--r-- | linuxthreads/Versions | 3 | ||||
| -rw-r--r-- | linuxthreads/semaphore.c | 125 | ||||
| -rw-r--r-- | linuxthreads/semaphore.h | 10 |
4 files changed, 139 insertions, 0 deletions
diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index 2c513dc8f3..5039a12ba8 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -3,6 +3,7 @@ * semaphore.c (sem_timedwait): New function. Patch by Carl Mailloux <carlm@oricom.ca>. * semaphore.h: Declare sem_timedwait. + * Versions [libpthread] (GLIBC_2.2): Add sem_timedwait. 2000-03-26 Roland McGrath <roland@baalperazim.frob.com> diff --git a/linuxthreads/Versions b/linuxthreads/Versions index 1b9de67b67..2e3673e1a1 100644 --- a/linuxthreads/Versions +++ b/linuxthreads/Versions @@ -129,5 +129,8 @@ libpthread { __pthread_rwlock_init; __pthread_rwlock_destroy; __pthread_rwlock_rdlock; __pthread_rwlock_tryrdlock; __pthread_rwlock_wrlock; __pthread_rwlock_trywrlock; __pthread_rwlock_unlock; + + # New functions from IEEE Std. 10003.1-200x. + sem_timedwait; } } diff --git a/linuxthreads/semaphore.c b/linuxthreads/semaphore.c index c4a4f6e042..3344d0d859 100644 --- a/linuxthreads/semaphore.c +++ b/linuxthreads/semaphore.c @@ -190,6 +190,131 @@ int sem_unlink(const char *name) return -1; } +int sem_timedwait(sem_t *sem, const struct timespec *abstime) +{ + pthread_descr self = thread_self(); + pthread_extricate_if extr; + int already_canceled = 0; + int was_signalled = 0; + sigjmp_buf jmpbuf; + sigset_t unblock; + sigset_t initial_mask; + + __pthread_lock((struct _pthread_fastlock *) &sem->__sem_lock, self); + if (sem->__sem_value > 0) { + --sem->__sem_value; + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + return 0; + } + + if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000) { + /* The standard requires that if the function would block and the + time value is illegal, the function returns with an error. */ + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + return EINVAL; + } + + /* Set up extrication interface */ + extr.pu_object = sem; + extr.pu_extricate_func = new_sem_extricate_func; + + /* Register extrication interface */ + __pthread_set_own_extricate_if(self, &extr); + /* Enqueue only if not already cancelled. */ + if (!(THREAD_GETMEM(self, p_canceled) + && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)) + enqueue(&sem->__sem_waiting, self); + else + already_canceled = 1; + __pthread_unlock((struct _pthread_fastlock *) &sem->__sem_lock); + + if (already_canceled) { + __pthread_set_own_extricate_if(self, 0); + pthread_exit(PTHREAD_CANCELED); + } + + /* Set up a longjmp handler for the restart signal, unblock + the signal and sleep. */ + + if (sigsetjmp(jmpbuf, 1) == 0) { + THREAD_SETMEM(self, p_signal_jmp, &jmpbuf); + THREAD_SETMEM(self, p_signal, 0); + /* Unblock the restart signal */ + sigemptyset(&unblock); + sigaddset(&unblock, __pthread_sig_restart); + sigprocmask(SIG_UNBLOCK, &unblock, &initial_mask); + + while (1) { + struct timeval now; + struct timespec reltime; + + /* Compute a time offset relative to now. */ + __gettimeofday (&now, NULL); + reltime.tv_nsec = abstime->tv_nsec - now.tv_usec * 1000; + reltime.tv_sec = abstime->tv_sec - now.tv_sec; + if (reltime.tv_nsec < 0) { + reltime.tv_nsec += 1000000000; + reltime.tv_sec -= 1; + } + + /* Sleep for the required duration. If woken by a signal, + resume waiting as required by Single Unix Specification. */ + if (reltime.tv_sec < 0 || __libc_nanosleep(&reltime, NULL) == 0) + break; + } + + /* Block the restart signal again */ + sigprocmask(SIG_SETMASK, &initial_mask, NULL); + was_signalled = 0; + } else { + was_signalled = 1; + } + THREAD_SETMEM(self, p_signal_jmp, NULL); + + /* Now was_signalled is true if we exited the above code + due to the delivery of a restart signal. In that case, + everything is cool. We have been removed from the queue + by the other thread, and consumed its signal. + + Otherwise we this thread woke up spontaneously, or due to a signal other + than restart. The next thing to do is to try to remove the thread + from the queue. This may fail due to a race against another thread + trying to do the same. In the failed case, we know we were signalled, + and we may also have to consume a restart signal. */ + + if (!was_signalled) { + int was_on_queue; + + /* __pthread_lock will queue back any spurious restarts that + may happen to it. */ + + __pthread_lock((struct _pthread_fastlock *)&sem->__sem_lock, self); + was_on_queue = remove_from_queue(&sem->__sem_waiting, self); + __pthread_unlock((struct _pthread_fastlock *)&sem->__sem_lock); + + if (was_on_queue) { + __pthread_set_own_extricate_if(self, 0); + return ETIMEDOUT; + } + + /* Eat the outstanding restart() from the signaller */ + suspend(self); + } + __pthread_set_own_extricate_if(self, 0); + + /* Terminate only if the wakeup came from cancellation. */ + /* Otherwise ignore cancellation because we got the semaphore. */ + + if (THREAD_GETMEM(self, p_woken_by_cancel) + && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) { + THREAD_SETMEM(self, p_woken_by_cancel, 0); + pthread_exit(PTHREAD_CANCELED); + } + /* We got the semaphore */ + return 0; +} + + versioned_symbol (libpthread, __new_sem_init, sem_init, GLIBC_2_1); versioned_symbol (libpthread, __new_sem_wait, sem_wait, GLIBC_2_1); versioned_symbol (libpthread, __new_sem_trywait, sem_trywait, GLIBC_2_1); diff --git a/linuxthreads/semaphore.h b/linuxthreads/semaphore.h index 21a9deaafe..583b65ea18 100644 --- a/linuxthreads/semaphore.h +++ b/linuxthreads/semaphore.h @@ -17,6 +17,10 @@ #include <features.h> #include <sys/types.h> +#ifdef __USE_XOPEN2K +# define __need_timespec +# include <time.h> +#endif #ifndef _PTHREAD_DESCR_DEFINED /* Thread descriptors. Needed for `sem_t' definition. */ @@ -66,6 +70,12 @@ extern int sem_unlink (__const char *__name) __THROW; /* Wait for SEM being posted. */ extern int sem_wait (sem_t *__sem) __THROW; +#ifdef __USE_XOPEN2K +/* Similar to `sem_wait' but wait only until ABSTIME. */ +extern int sem_timedwait (sem_t *__sem, __const struct timespec *__abstime) + __THROW; +#endif + /* Test whether SEM is posted. */ extern int sem_trywait (sem_t *__sem) __THROW; |