@@ -37,8 +37,8 @@ static pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
static void *
tf1 (void *arg)
{
- struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
- __make_timespec (10000, 0));
+ struct timespec ts = __timespec_add (__xclock_now (CLOCK_REALTIME),
+ __make_timespec (10000, 0));
/* This call must never return. */
int e = pthread_mutex_timedlock (&m1, &ts);
@@ -38,8 +38,8 @@ static pthread_cond_t c = PTHREAD_COND_INITIALIZER;
static void *
tf (void *arg)
{
- struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
- __make_timespec (10000, 0));
+ struct timespec ts = __timespec_add (__xclock_now (CLOCK_REALTIME),
+ __make_timespec (10000, 0));
/* This call must never return. */
TEST_COMPARE (pthread_cond_timedwait (&c, &m, &ts), 0);
@@ -62,8 +62,8 @@ tf (void *arg)
struct timespec ts_start;
__xclock_gettime (clockid_for_get, &ts_start);
- struct timespec ts_timeout = timespec_add (ts_start,
- __make_timespec (0, 300000000));
+ struct timespec ts_timeout = __timespec_add (ts_start,
+ __make_timespec (0, 300000000));
verbose_printf ("child calling %srdlock\n", fnname);
@@ -60,8 +60,8 @@ tf (void *arg)
/* Timeout: 0.3 secs. */
struct timespec ts_start;
__xclock_gettime (clockid_for_get, &ts_start);
- const struct timespec ts_timeout = timespec_add (ts_start,
- __make_timespec (0, 300000000));
+ const struct timespec ts_timeout = __timespec_add (ts_start,
+ __make_timespec (0, 300000000));
if (clockid == CLOCK_USE_TIMEDLOCK)
TEST_COMPARE (pthread_rwlock_timedwrlock (r, &ts_timeout), ETIMEDOUT);
@@ -75,8 +75,8 @@ writer_thread (void *arg)
{
__xclock_gettime (clockid_for_get, &ts);
- ts = timespec_add (ts, timeout);
- ts = timespec_add (ts, timeout);
+ ts = __timespec_add (ts, timeout);
+ ts = __timespec_add (ts, timeout);
printf ("writer thread %d tries again\n", nr);
@@ -122,7 +122,7 @@ reader_thread (void *arg)
{
__xclock_gettime (clockid_for_get, &ts);
- ts = timespec_add (ts, timeout);
+ ts = __timespec_add (ts, timeout);
printf ("reader thread %d tries again\n", nr);
@@ -42,7 +42,7 @@ do_test_clock (clockid_t clockid)
/* We wait for half a second. */
__xclock_gettime (clockid_for_get, &ts);
- ts = timespec_add (ts, __make_timespec (0, TIMESPEC_HZ/2));
+ ts = __timespec_add (ts, __make_timespec (0, TIMESPEC_HZ/2));
errno = 0;
TEST_COMPARE (TEMP_FAILURE_RETRY ((clockid == CLOCK_USE_TIMEDWAIT)
@@ -26,7 +26,7 @@
#include "intprops.h"
struct timespec
-timespec_add (struct timespec a, struct timespec b)
+__timespec_add (struct timespec a, struct timespec b)
{
time_t rs = a.tv_sec;
time_t bs = b.tv_sec;
@@ -24,7 +24,7 @@
#include <support/check.h>
#include <support/xtime.h>
-struct timespec timespec_add (struct timespec, struct timespec)
+struct timespec __timespec_add (struct timespec, struct timespec)
__attribute__((const));
struct timespec __timespec_sub (struct timespec, struct timespec)
__attribute__((const));
@@ -131,8 +131,8 @@ __timespec_compare (const struct timespec *left, const struct timespec *right)
}
static inline void
-timespec_add (struct timespec *sum, const struct timespec *left,
- const struct timespec *right)
+__timespec_add (struct timespec *sum, const struct timespec *left,
+ const struct timespec *right)
{
sum->tv_sec = left->tv_sec + right->tv_sec;
sum->tv_nsec = left->tv_nsec + right->tv_nsec;
@@ -392,12 +392,12 @@ thread_func (void *arg)
|| timer->value.it_interval.tv_nsec != 0)
{
timer->overrun_count = 0;
- timespec_add (&timer->expirytime, &timer->expirytime,
- &timer->value.it_interval);
+ __timespec_add (&timer->expirytime, &timer->expirytime,
+ &timer->value.it_interval);
while (__timespec_compare (&timer->expirytime, &now) < 0)
{
- timespec_add (&timer->expirytime, &timer->expirytime,
- &timer->value.it_interval);
+ __timespec_add (&timer->expirytime, &timer->expirytime,
+ &timer->value.it_interval);
if (timer->overrun_count < DELAYTIMER_MAX)
++timer->overrun_count;
}
@@ -108,7 +108,7 @@ timer_settime (timer_t timerid, int flags, const struct itimerspec *value,
/* The user specified the expiration time. */
timer->expirytime = value->it_value;
else
- timespec_add (&timer->expirytime, &now, &value->it_value);
+ __timespec_add (&timer->expirytime, &now, &value->it_value);
/* Only need to wake up the thread if timer is inserted
at the head of the queue. */
@@ -42,7 +42,7 @@ do_test_clock (clockid_t clockid)
/* Waiting for the condition will fail. But we want the timeout here. */
const struct timespec ts_now = __xclock_now (clockid);
const struct timespec ts_timeout =
- timespec_add (ts_now, __make_timespec (0, 500000000));
+ __timespec_add (ts_now, __make_timespec (0, 500000000));
/* In theory pthread_cond_clockwait could return zero here due to
spurious wakeup. However that can't happen without a signal or an
@@ -53,8 +53,8 @@ do_test_clock (clockid_t clockid)
pthread_t th = xpthread_create (NULL, tf, NULL);
void *status;
- struct timespec timeout = timespec_add (__xclock_now (clockid_for_get),
- __make_timespec (0, 200000000));
+ struct timespec timeout = __timespec_add (__xclock_now (clockid_for_get),
+ __make_timespec (0, 200000000));
int val;
if (clockid == CLOCK_USE_TIMEDJOIN)
@@ -68,8 +68,8 @@ do_test_clock (clockid_t clockid)
while (1)
{
- timeout = timespec_add (__xclock_now (clockid_for_get),
- __make_timespec (0, 200000000));
+ timeout = __timespec_add (__xclock_now (clockid_for_get),
+ __make_timespec (0, 200000000));
if (clockid == CLOCK_USE_TIMEDJOIN)
val = pthread_timedjoin_np (th, &status, &timeout);
@@ -45,16 +45,16 @@ static int
thread_join (pthread_t thread, void **retval)
{
#if defined USE_PTHREAD_TIMEDJOIN_NP
- const struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
- __make_timespec (1000, 0));
+ const struct timespec ts = __timespec_add (__xclock_now (CLOCK_REALTIME),
+ __make_timespec (1000, 0));
return pthread_timedjoin_np (thread, retval, &ts);
#elif defined USE_PTHREAD_CLOCKJOIN_NP_REALTIME
- const struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
- __make_timespec (1000, 0));
+ const struct timespec ts = __timespec_add (__xclock_now (CLOCK_REALTIME),
+ __make_timespec (1000, 0));
return pthread_clockjoin_np (thread, retval, CLOCK_REALTIME, &ts);
#elif defined USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC
- const struct timespec ts = timespec_add (__xclock_now (CLOCK_MONOTONIC),
- __make_timespec (1000, 0));
+ const struct timespec ts = __timespec_add (__xclock_now (CLOCK_MONOTONIC),
+ __make_timespec (1000, 0));
return pthread_clockjoin_np (thread, retval, CLOCK_MONOTONIC, &ts);
#else
return pthread_join (thread, retval);
@@ -67,8 +67,8 @@ do_test_clock (clockid_t clockid, const char *fnname)
FAIL_EXIT1 ("mutex_trylock succeeded");
/* Wait 2 seconds. */
- struct timespec ts_timeout = timespec_add (__xclock_now (clockid_for_get),
- __make_timespec (2, 0));
+ struct timespec ts_timeout = __timespec_add (__xclock_now (clockid_for_get),
+ __make_timespec (2, 0));
if (clockid == CLOCK_USE_TIMEDLOCK)
TEST_COMPARE (pthread_mutex_timedlock (&m, &ts_timeout), ETIMEDOUT);
@@ -89,7 +89,7 @@ do_test_clock (clockid_t clockid, const char *fnname)
const struct timespec ts_start = __xclock_now (CLOCK_REALTIME);
/* Wait 2 seconds. */
- ts_timeout = timespec_add (ts_start, __make_timespec (2, 0));
+ ts_timeout = __timespec_add (ts_start, __make_timespec (2, 0));
if (clockid == CLOCK_USE_TIMEDLOCK)
TEST_COMPARE (pthread_mutex_timedlock (&m, &ts_timeout), 0);
@@ -100,7 +100,7 @@ do_test_clock (clockid_t clockid, const char *fnname)
/* Check that timedlock didn't delay. We use a limit of 0.1 secs. */
TEST_TIMESPEC_BEFORE (ts_end,
- timespec_add (ts_start, __make_timespec (0, 100000000)));
+ __timespec_add (ts_start, __make_timespec (0, 100000000)));
TEST_COMPARE (pthread_mutex_unlock (&m), 0);
TEST_COMPARE (pthread_mutex_destroy (&m), 0);
@@ -101,8 +101,8 @@ do_test_clock (clockid_t clockid)
if (pthread_mutex_unlock (m) == 0)
FAIL_EXIT1 ("child: mutex_unlock succeeded");
- const struct timespec ts = timespec_add (__xclock_now (clockid_for_get),
- __make_timespec (0, 500000000));
+ const struct timespec ts = __timespec_add (__xclock_now (clockid_for_get),
+ __make_timespec (0, 500000000));
if (clockid == CLOCK_USE_TIMEDLOCK)
TEST_COMPARE (pthread_mutex_timedlock (m, &ts), ETIMEDOUT);