diff mbox series

[RFC,05/12] y2038: Rename xclock_now to __xclock_now

Message ID 20200601140740.16371-6-lukma@denx.de
State New
Headers show
Series y2038: Convert timespec_{sub|add|create} in support to be Y2038 safe | expand

Commit Message

Lukasz Majewski June 1, 2020, 2:07 p.m. UTC
As the xclock_now is used locally in glibc, its name shall begin with
"__". This change adds this prefix.

Tested with glibc/glibc-many-build --keep failed glibcs
---
 nptl/tst-eintr2.c            | 2 +-
 nptl/tst-eintr5.c            | 2 +-
 support/xtime.h              | 2 +-
 sysdeps/pthread/tst-cond27.c | 2 +-
 sysdeps/pthread/tst-join3.c  | 4 ++--
 sysdeps/pthread/tst-join5.c  | 6 +++---
 sysdeps/pthread/tst-mutex5.c | 6 +++---
 sysdeps/pthread/tst-mutex9.c | 2 +-
 8 files changed, 13 insertions(+), 13 deletions(-)
diff mbox series

Patch

diff --git a/nptl/tst-eintr2.c b/nptl/tst-eintr2.c
index eba8065236..68a8453f34 100644
--- a/nptl/tst-eintr2.c
+++ b/nptl/tst-eintr2.c
@@ -37,7 +37,7 @@  static pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
 static void *
 tf1 (void *arg)
 {
-  struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME),
+  struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
                                      __make_timespec (10000, 0));
 
   /* This call must never return.  */
diff --git a/nptl/tst-eintr5.c b/nptl/tst-eintr5.c
index 4edfbaaef6..3130f0fa08 100644
--- a/nptl/tst-eintr5.c
+++ b/nptl/tst-eintr5.c
@@ -38,7 +38,7 @@  static pthread_cond_t c = PTHREAD_COND_INITIALIZER;
 static void *
 tf (void *arg)
 {
-  struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME),
+  struct timespec ts = timespec_add (__xclock_now (CLOCK_REALTIME),
                                      __make_timespec (10000, 0));
 
   /* This call must never return.  */
diff --git a/support/xtime.h b/support/xtime.h
index 0912ead0ec..0fce19a78d 100644
--- a/support/xtime.h
+++ b/support/xtime.h
@@ -32,7 +32,7 @@  void __xclock_gettime (clockid_t clock, struct timespec *ts);
 /* This helper can often simplify tests by avoiding an explicit
    variable declaration or allowing that declaration to be const. */
 
-static inline struct timespec xclock_now (clockid_t clock)
+static inline struct timespec __xclock_now (clockid_t clock)
 {
   struct timespec ts;
   __xclock_gettime (clock, &ts);
diff --git a/sysdeps/pthread/tst-cond27.c b/sysdeps/pthread/tst-cond27.c
index 3d7b8240b1..5755d25ec8 100644
--- a/sysdeps/pthread/tst-cond27.c
+++ b/sysdeps/pthread/tst-cond27.c
@@ -40,7 +40,7 @@  do_test_clock (clockid_t clockid)
   xpthread_mutex_lock (&mut);
 
   /* Waiting for the condition will fail.  But we want the timeout here.  */
-  const struct timespec ts_now = xclock_now (clockid);
+  const struct timespec ts_now = __xclock_now (clockid);
   const struct timespec ts_timeout =
     timespec_add (ts_now, __make_timespec (0, 500000000));
 
diff --git a/sysdeps/pthread/tst-join3.c b/sysdeps/pthread/tst-join3.c
index fc54f12cc9..76df44c49e 100644
--- a/sysdeps/pthread/tst-join3.c
+++ b/sysdeps/pthread/tst-join3.c
@@ -53,7 +53,7 @@  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),
+  struct timespec timeout = timespec_add (__xclock_now (clockid_for_get),
                                           __make_timespec (0, 200000000));
 
   int val;
@@ -68,7 +68,7 @@  do_test_clock (clockid_t clockid)
 
   while (1)
     {
-      timeout = timespec_add (xclock_now (clockid_for_get),
+      timeout = timespec_add (__xclock_now (clockid_for_get),
                               __make_timespec (0, 200000000));
 
       if (clockid == CLOCK_USE_TIMEDJOIN)
diff --git a/sysdeps/pthread/tst-join5.c b/sysdeps/pthread/tst-join5.c
index 525f349a4b..a72760a9ff 100644
--- a/sysdeps/pthread/tst-join5.c
+++ b/sysdeps/pthread/tst-join5.c
@@ -45,15 +45,15 @@  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),
+  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),
+  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),
+  const struct timespec ts = timespec_add (__xclock_now (CLOCK_MONOTONIC),
                                            __make_timespec (1000, 0));
   return pthread_clockjoin_np (thread, retval, CLOCK_MONOTONIC, &ts);
 #else
diff --git a/sysdeps/pthread/tst-mutex5.c b/sysdeps/pthread/tst-mutex5.c
index 72fdbdaea5..86f383a193 100644
--- a/sysdeps/pthread/tst-mutex5.c
+++ b/sysdeps/pthread/tst-mutex5.c
@@ -67,7 +67,7 @@  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),
+  struct timespec ts_timeout = timespec_add (__xclock_now (clockid_for_get),
                                              __make_timespec (2, 0));
 
   if (clockid == CLOCK_USE_TIMEDLOCK)
@@ -86,7 +86,7 @@  do_test_clock (clockid_t clockid, const char *fnname)
     TEST_COMPARE (pthread_mutex_clocklock (&m, clockid, &ts_timeout), EINVAL);
   TEST_COMPARE (pthread_mutex_unlock (&m), 0);
 
-  const struct timespec ts_start = xclock_now (CLOCK_REALTIME);
+  const struct timespec ts_start = __xclock_now (CLOCK_REALTIME);
 
   /* Wait 2 seconds.  */
   ts_timeout = timespec_add (ts_start, __make_timespec (2, 0));
@@ -96,7 +96,7 @@  do_test_clock (clockid_t clockid, const char *fnname)
   else
     TEST_COMPARE (pthread_mutex_clocklock (&m, clockid, &ts_timeout), 0);
 
-  const struct timespec ts_end = xclock_now (clockid_for_get);
+  const struct timespec ts_end = __xclock_now (clockid_for_get);
 
   /* Check that timedlock didn't delay.  We use a limit of 0.1 secs.  */
   TEST_TIMESPEC_BEFORE (ts_end,
diff --git a/sysdeps/pthread/tst-mutex9.c b/sysdeps/pthread/tst-mutex9.c
index d03a22b97a..20e6d8d009 100644
--- a/sysdeps/pthread/tst-mutex9.c
+++ b/sysdeps/pthread/tst-mutex9.c
@@ -101,7 +101,7 @@  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),
+      const struct timespec ts = timespec_add (__xclock_now (clockid_for_get),
                                                __make_timespec (0, 500000000));
 
       if (clockid == CLOCK_USE_TIMEDLOCK)