Update.

2000-03-26  Ulrich Drepper  <drepper@redhat.com>

	* include/features.h: Undef and document __USE_XOPEN2K.

	* malloc/mcheck.c: Implement pedantic checking of all allocated blocks
	whenever a function is called.  Initiated by calling mcheck_pedantic
	instead of mcheck.
	* malloc/mcheck.h: Declare mcheck_pedantic.
	* malloc/Versions [libc] (GLIBC_2.2): Add mcheck_pedantic.
	* locale/programs/localdef.c: Use mcheck_pedantic instead of mcheck
	for now.

1 files changed, 125 insertions, 0 deletions

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);