{
if (atomic_exchange_acq ((int *)ptr, 2) == 0)
return 0;
- else if (tsp->tv_nsec < 0 || tsp->tv_nsec >= 1000000000)
+ else if (! valid_nanoseconds (tsp->tv_nsec))
return EINVAL;
int mlsec = compute_reltime (tsp, clk);
#include <assert.h>
#include <stdint.h>
#include <limits.h>
+#include <time.h>
/* All user select types. */
#define SELECT_ALL (SELECT_READ | SELECT_WRITE | SELECT_URG)
{
struct timeval now;
- if (timeout->tv_sec < 0 || timeout->tv_nsec < 0 ||
- timeout->tv_nsec >= 1000000000)
+ if (timeout->tv_sec < 0 || ! valid_nanoseconds (timeout->tv_nsec))
{
errno = EINVAL;
return -1;
return tv;
}
+
+/* Check if a value is in the valid nanoseconds range. Return true if
+ it is, false otherwise. */
+static inline bool
+valid_nanoseconds (__syscall_slong_t ns)
+{
+ return __glibc_likely (0 <= ns && ns < 1000000000);
+}
#endif
#endif
#include <stddef.h> /* For NULL. */
#include <sys/poll.h>
#include <sysdep-cancel.h>
+#include <time.h>
int
/* poll uses a simple millisecond value. Convert it. */
if (timeout != NULL)
{
- if (timeout->tv_sec < 0
- || timeout->tv_nsec < 0 || timeout->tv_nsec >= 1000000000)
+ if (timeout->tv_sec < 0 || ! valid_nanoseconds (timeout->tv_nsec))
{
__set_errno (EINVAL);
return -1;
#include <errno.h>
#include <lowlevellock.h>
#include <sys/time.h>
+#include <time.h>
int
const struct timespec *abstime, int private)
{
/* Reject invalid timeouts. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Try locking. */
{
/* Check parameter validity. This should also tell the compiler that
it can assume that abstime is not NULL. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Relaxed MO is suffice because clock ID bit is only modified
{
/* Check parameter validity. This should also tell the compiler that
it can assume that abstime is not NULL. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
if (!futex_abstimed_supported_clockid (clockid))
#include "pthreadP.h"
#include <atomic.h>
#include <stap-probe.h>
+#include <time.h>
static void
cleanup (void *arg)
{
pid_t tid;
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Repeat until thread terminated. */
}
/* We are about to block; check whether the timeout is invalid. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Work around the fact that the kernel rejects negative timeout
values despite them being valid. */
if (oldval != ceilval)
{
/* Reject invalid timeouts. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
{
result = EINVAL;
goto failpp;
#include <stap-probe.h>
#include <atomic.h>
#include <futex-internal.h>
+#include <time.h>
/* A reader--writer lock that fulfills the POSIX requirements (but operations
if the lock can be immediately acquired" (i.e., we need not but may check
it). */
if (abstime && __glibc_unlikely (!futex_abstimed_supported_clockid (clockid)
- || abstime->tv_nsec >= 1000000000
- || abstime->tv_nsec < 0))
+ || ! valid_nanoseconds (abstime->tv_nsec)))
return EINVAL;
/* Make sure we are not holding the rwlock as a writer. This is a deadlock
if the lock can be immediately acquired" (i.e., we need not but may check
it). */
if (abstime && __glibc_unlikely (!futex_abstimed_supported_clockid (clockid)
- || abstime->tv_nsec >= 1000000000
- || abstime->tv_nsec < 0))
+ || ! valid_nanoseconds (abstime->tv_nsec)))
return EINVAL;
/* Make sure we are not holding the rwlock as a writer. This is a deadlock
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#include <time.h>
#include "sem_waitcommon.c"
int
return -1;
}
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
{
__set_errno (EINVAL);
return -1;
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#include <time.h>
#include "sem_waitcommon.c"
/* This is in a separate file because because sem_timedwait is only provided
int
sem_timedwait (sem_t *sem, const struct timespec *abstime)
{
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
{
__set_errno (EINVAL);
return -1;
#include <pt-internal.h>
#include <pthreadP.h>
+#include <time.h>
extern int __pthread_cond_timedwait_internal (pthread_cond_t *cond,
pthread_mutex_t *mutex,
int cancelled, oldtype, drain;
clockid_t clock_id = __pthread_default_condattr.__clock;
- if (abstime && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+ if (abstime && ! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
struct __pthread *self = _pthread_self ();
#include <pthread.h>
#include <assert.h>
+#include <time.h>
#include <pt-internal.h>
#endif
assert (mutex->__owner);
- if (abstime != NULL && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+ if (abstime != NULL && ! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Add ourselves to the queue. */
#include <pthread.h>
#include <assert.h>
+#include <time.h>
#include <pt-internal.h>
/* Better be blocked by a writer. */
assert (rwlock->__readers == 0);
- if (abstime != NULL && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+ if (abstime != NULL && ! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
self = _pthread_self ();
#include <pthread.h>
#include <assert.h>
+#include <time.h>
#include <pt-internal.h>
/* The lock is busy. */
- if (abstime != NULL && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+ if (abstime != NULL && ! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
self = _pthread_self ();
#include <semaphore.h>
#include <errno.h>
#include <assert.h>
+#include <time.h>
#include <pt-internal.h>
return 0;
}
- if (timeout != NULL && (timeout->tv_nsec < 0 || timeout->tv_nsec >= 1000000000))
+ if (timeout != NULL && ! valid_nanoseconds (timeout->tv_nsec))
{
errno = EINVAL;
return -1;
#include <pthread.h>
#include <assert.h>
#include <hurd/signal.h>
+#include <time.h>
#include <pt-internal.h>
assert (ss->intr_port == MACH_PORT_NULL); /* Sanity check for signal bugs. */
- if (abstime != NULL && (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000))
+ if (abstime != NULL && ! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
/* Atomically enqueue our thread on the condition variable's queue of
struct timeval before, after;
if (requested_time->tv_sec < 0
- || requested_time->tv_nsec < 0
- || requested_time->tv_nsec >= 1000000000)
+ || ! valid_nanoseconds (requested_time->tv_nsec))
{
errno = EINVAL;
return -1;
goto bail;
}
- if (value->it_interval.tv_nsec < 0
- || value->it_interval.tv_nsec >= 1000000000
- || value->it_value.tv_nsec < 0
- || value->it_value.tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (value->it_interval.tv_nsec)
+ || ! valid_nanoseconds (value->it_value.tv_nsec))
{
__set_errno (EINVAL);
goto bail;
#include <sysdep.h>
#include <lowlevellock.h>
#include <sys/time.h>
+#include <time.h>
void
const struct timespec *abstime, int private)
{
/* Reject invalid timeouts. */
- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (abstime->tv_nsec))
return EINVAL;
do
{
struct timespec now;
- if (__builtin_expect (req->tv_nsec, 0) < 0
- || __builtin_expect (req->tv_nsec, 0) >= 1000000000)
+ if (! valid_nanoseconds (req->tv_nsec))
return EINVAL;
if (clock_id == CLOCK_THREAD_CPUTIME_ID)
int retval = -1;
/* Make sure the time cvalue is OK. */
- if (tp->tv_nsec < 0 || tp->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (tp->tv_nsec))
{
__set_errno (EINVAL);
return -1;
__clock_settime64 (clockid_t clock_id, const struct __timespec64 *tp)
{
/* Make sure the time cvalue is OK. */
- if (tp->tv_nsec < 0 || tp->tv_nsec >= 1000000000)
+ if (! valid_nanoseconds (tp->tv_nsec))
{
__set_errno (EINVAL);
return -1;
__clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req,
struct timespec *rem)
{
- if (__builtin_expect (req->tv_nsec, 0) < 0
- || __builtin_expect (req->tv_nsec, 0) >= 1000000000)
+ if (! valid_nanoseconds (req->tv_nsec))
return EINVAL;
if (flags != TIMER_ABSTIME && flags != 0)