int val = INTERNAL_SYSCALL (clock_gettime, err, 2, cond->__data.__clock, &rt);
int val; val = INTERNAL_SYSCALL (clock_gettime, err, 2, cond->__data.__clock, &rt);
__pthread_cond_timedwait (cond, mutex, abstime)     pthread_cond_t *cond;     pthread_mutex_t *mutex;     const struct timespec *abstime;{  struct _pthread_cleanup_buffer buffer;  struct _condvar_cleanup_buffer cbuffer;  int result = 0;  /* Catch invalid parameters.  */  if (abstime->tv_nsec >= 1000000000)    return EINVAL;  /* Make sure we are along.  */  lll_mutex_lock (cond->__data.__lock);  /* Now we can release the mutex.  */  int err = __pthread_mutex_unlock_usercnt (mutex, 0);  if (err)    {      lll_mutex_unlock (cond->__data.__lock);      return err;    }  /* We have one new user of the condvar.  */  ++cond->__data.__total_seq;  /* Remember the mutex we are using here.  If there is already a     different address store this is a bad user bug.  */  cond->__data.__mutex = mutex;  /* Prepare structure passed to cancellation handler.  */  cbuffer.cond = cond;  cbuffer.mutex = mutex;  /* Before we block we enable cancellation.  Therefore we have to     install a cancellation handler.  */  __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);  /* The current values of the wakeup counter.  The "woken" counter     must exceed this value.  */  unsigned long long int val;  unsigned long long int seq;  val = seq = cond->__data.__wakeup_seq;  /* The futex syscall operates on a 32-bit word.  That is fine, we     just use the low 32 bits of the sequence counter.  */#if BYTE_ORDER == LITTLE_ENDIAN  int *futex = ((int *) (&cond->__data.__wakeup_seq));#elif BYTE_ORDER == BIG_ENDIAN  int *futex = ((int *) (&cond->__data.__wakeup_seq)) + 1;#else# error "No valid byte order"#endif  while (1)    {      struct timespec rt;      {#ifdef __NR_clock_gettime	INTERNAL_SYSCALL_DECL (err);	int val = INTERNAL_SYSCALL (clock_gettime, err, 2,				    cond->__data.__clock, &rt);# ifndef __ASSUME_POSIX_TIMERS	if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (val, err), 0))	  {	    struct timeval tv;	    (void) gettimeofday (&tv, NULL);	    /* Convert the absolute timeout value to a relative timeout.  */	    rt.tv_sec = abstime->tv_sec - tv.tv_sec;	    rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;	  }	else# endif	  {	    /* Convert the absolute timeout value to a relative timeout.  */	    rt.tv_sec = abstime->tv_sec - rt.tv_sec;	    rt.tv_nsec = abstime->tv_nsec - rt.tv_nsec;	  }#else	/* Get the current time.  So far we support only one clock.  */	struct timeval tv;	(void) gettimeofday (&tv, NULL);	/* Convert the absolute timeout value to a relative timeout.  */	rt.tv_sec = abstime->tv_sec - tv.tv_sec;	rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;#endif      }      if (rt.tv_nsec < 0)	{	  rt.tv_nsec += 1000000000;	  --rt.tv_sec;	}      /* Did we already time out?  */      if (rt.tv_sec < 0)	{	  /* Yep.  Adjust the sequence counter.  */	  ++cond->__data.__wakeup_seq;	  /* The error value.  */	  result = ETIMEDOUT;	  break;	}      /* Prepare to wait.  Release the condvar futex.  */      lll_mutex_unlock (cond->__data.__lock);      /* Enable asynchronous cancellation.  Required by the standard.  */      cbuffer.oldtype = __pthread_enable_asynccancel ();      /* Wait until woken by signal or broadcast.  Note that we	 truncate the 'val' value to 32 bits.  */      err = lll_futex_timed_wait (futex, (unsigned int) val, &rt);      /* Disable asynchronous cancellation.  */      __pthread_disable_asynccancel (cbuffer.oldtype);      /* We are going to look at shared data again, so get the lock.  */      lll_mutex_lock(cond->__data.__lock);      /* Check whether we are eligible for wakeup.  */      val = cond->__data.__wakeup_seq;      if (val > seq && cond->__data.__woken_seq < val)	break;      /* Not woken yet.  Maybe the time expired?  */      if (err == -ETIMEDOUT)	{	  /* Yep.  Adjust the counters.  */	  ++cond->__data.__wakeup_seq;	  /* The error value.  */	  result = ETIMEDOUT;	  break;	}    }  /* Another thread woken up.  */  ++cond->__data.__woken_seq;  /* We are done with the condvar.  */  lll_mutex_unlock (cond->__data.__lock);  /* The cancellation handling is back to normal, remove the handler.  */  __pthread_cleanup_pop (&buffer, 0);  /* Get the mutex before returning.  */  err = __pthread_mutex_cond_lock (mutex);  return err ?: result;}