diff mbox series

[RFC,1/6] y2038: Introduce _TIME_BITS flag to support 64 bit time on 32 bit systems

Message ID 20201204233604.7430-2-lukma@denx.de
State Superseded
Headers show
Series y2038: Prepare glibc to be Y2038 safe for 32 bit ports | expand

Commit Message

Lukasz Majewski Dec. 4, 2020, 11:35 p.m. UTC
This change introduces new compile time, supported by glibc flag - namely
_TIME_BITS, which then is responsible for exporting __USE_TIME_BITS64 only
when:
- _TIME_BITS=64 && _FILE_OFFSET_BITS=64 are set in the compilation phase
  (via e.g. -D switch)
and
- The glibc port has __TIMESIZE != 64 && __WORDSIZE == 32 (those are
  internal glibc defines)

It shall be also emphasized that for proper support of 64 bit time on
ports with __TIMESIZE != 64 && __WORDSIZE == 32 (e.g. 32 bit ARM) the
Linux kernel shall be newer than v5.1. Otherwise, as a fallback, 32 bit
syscalls are used. Those will fail after Y2038 trigger date (19.01.2038
- 03:14:08 UTC).

Exported headers have been modified accordingly when __USE_TIME_BITS64 is
defined (this exported flag is set only when _TIME_BITS=64 and
_FILE_OFFSET_BITS=64 are set on compilation time).
To be more specific - structures' names have been kept (no new 64 bit
specific ones were exported), but were extended with 64 bit versions of
time related fields.
For example struct timespec now is modified when __USE_TIME_BITS64 is
defined to have __time64_t fields instead of __time_t, which are only
capable to hold 32 bit time.

Moreover, exported headers now have redirection for time related
functions. For example, when __USE_TIME_BIT64 is defined - calls to
clock_settime are redirected to clock_settime64, which supports setting
64 bit time in glibc ports with __WORDSIZE==32 and __TIMESIZE != 64.

This patch also converts following syscalls to support 64 bit time
(and hence being Y2038 safe):
- difftime
- mktime
- timegm
- ctime_r
- ctime
- gmtime_r
- gmtime
- clock_gettime64
- clock_settime64
- clock_getres64
- utimensat
- futimens
- clock_nanosleep_time64
- ppoll64
- timer_gettime
- timer_settime
- difftime
- timerfd_gettime
- timerfd_settime
- sched_rr_get_interval
- timespec_get
- settimeofday
- gettimeofday
- setitimer
- getitimer
- getrusage
- wait4_time64
- utimes
- utime
- mq_timedsend
- mq_timedreceive
- futimes
- lutimes
- futimesat
- semtimedop -> credits: Adhemerval Zanella
- pselect   -> credits: Adhemerval Zanella
- recvmmsg   -> credits: Adhemerval Zanella
- nanosleep  -> credits: Adhemerval Zanella
- select     -> credits: Adhemerval Zanella
- sigtimedwait -> credits: Adhemerval Zanella
- stat -> credits: Adhemerval Zanella
- fstat -> credits: Adhemerval Zanella
- lstat -> credits: Adhemerval Zanella
- fstatat -> credits: Adhemerval Zanella

- clock_adjtime64
- adjtime
- adjtimex
- ntp_gettime
- ntp_gettimex
- ntp_adjtime - just alias to ___adjtimex64 function

- wait3 -> credits: Adhemerval Zanella

- nptl (uses futex_time64):
        - pthread_timedjoin_np
        - pthread_clockjoin_np
        - pthread_cond_clockwait
        - pthread_cond_timedwait
        - sem_clockwait
        - sem_timedwait
        - pthread_rwlock_clockrdlock
        - pthread_rwlock_clockwrlock
        - pthread_rwlock_timedrdlock
        - pthread_rwlock_timedwrlock
        - pthread_mutex_clocklock
        - pthread_mutex_timedlock

- C11 threads
        - mtx_timedlock
        - cnd_timedwait
        - thrd_sleep

- time
- aio_suspend
- gai_suspend

Structures converted/exported:
-----------------------------
- struct timespec
- struct itimerspec
- struct timeval
- struct rusage
- WIP: export of struct stat{64}

TO DO:
------
- Make exportable struct __stat64_t64 and __rusage64 (to be usable when we
  redirect glibc syscalls symbols)
- Provide Y2038 support for struct msqid_ds (and msgctl() syscall in general
- Provide Y2038 support for struct semid_ds
- Port tests from y2038-tests repository to glibc -master branch

Dependencies:
-------------
This work depends on login and utmp{x} patches developed by Adhemerval
Zanella (from sourceware/azanella/y2038),which bring 64 bit support for
them.
---
 include/features.h                    |  19 ++++
 io/Versions                           |   2 +
 io/sys/poll.h                         |  11 ++
 io/sys/stat.h                         |  20 ++++
 io/utime.h                            |  15 +++
 manual/creature.texi                  |  28 +++++
 misc/Versions                         |   5 +
 misc/sys/select.h                     |  27 +++++
 nptl/Versions                         |  15 +++
 posix/Versions                        |   2 +
 posix/sched.h                         |   9 ++
 posix/sys/wait.h                      |  20 ++++
 resolv/Versions                       |   3 +
 resolv/netdb.h                        |  11 ++
 resource/Versions                     |   1 +
 resource/bits/types/struct_rusage.h   |   5 +
 resource/sys/resource.h               |  10 ++
 rt/Versions                           |   7 ++
 rt/aio.h                              |  25 ++++-
 rt/mqueue.h                           |  25 +++++
 signal/Versions                       |   3 +
 signal/signal.h                       |  12 +++
 socket/sys/socket.h                   |  11 ++
 sysdeps/nptl/pthread.h                | 117 +++++++++++++++++++++
 sysdeps/pthread/semaphore.h           |  23 ++++
 sysdeps/pthread/threads.h             |  33 ++++++
 sysdeps/unix/sysv/linux/Versions      |   7 ++
 sysdeps/unix/sysv/linux/bits/time.h   |  10 ++
 sysdeps/unix/sysv/linux/bits/timex.h  |  31 ++++++
 sysdeps/unix/sysv/linux/sys/timerfd.h |  22 ++++
 sysdeps/unix/sysv/linux/sys/timex.h   |  37 ++++++-
 sysvipc/Versions                      |   2 +
 sysvipc/sys/msg.h                     |  10 ++
 sysvipc/sys/sem.h                     |  21 ++++
 sysvipc/sys/shm.h                     |  10 ++
 time/Versions                         |  24 +++++
 time/bits/types/struct_timespec.h     |  17 +--
 time/bits/types/struct_timeval.h      |   5 +
 time/bits/types/time_t.h              |   4 +
 time/sys/time.h                       |  91 ++++++++++++++++
 time/time.h                           | 146 ++++++++++++++++++++++++++
 41 files changed, 884 insertions(+), 12 deletions(-)

Comments

Joseph Myers Dec. 5, 2020, 12:12 a.m. UTC | #1
On Sat, 5 Dec 2020, Lukasz Majewski wrote:

> This change introduces new compile time, supported by glibc flag - namely
> _TIME_BITS, which then is responsible for exporting __USE_TIME_BITS64 only

As a major new user-visible feature, this needs to be mentioned in NEWS.

> +/* We need to know the word size in order to check the time size.  */
> +#include <bits/wordsize.h>
> +
> +#if defined _TIME_BITS
> +# if _TIME_BITS == 64
> +#  if ! defined (_FILE_OFFSET_BITS) || _FILE_OFFSET_BITS != 64
> +#   error _TIME_BITS==64 is allowed only when _FILE_OFFSET_BITS==64
> +#  elif __WORDSIZE == 32
> +#   define __USE_TIME_BITS64	1
> +#  endif

__WORDSIZE isn't the right thing to check.  On ARC or RV32 or x32, 
_TIME_BITS == 64 should be a no-op, because time_t has always been 64-bit 
for those glibc ports.  That is, you should be checking __TIMESIZE, not 
__WORDSIZE.

> +# elif _TIME_BITS == 32
> +#  if __WORDSIZE > 32
> +#   error _TIME_BITS=32 is not compatible with __WORDSIZE > 32

Likewise, __TIMESIZE should be checked here, not __WORDSIZE.

> +@defvr Macro _TIME_BITS
> +This macro determines the bit size of @code{time_t} (and therefore the
> +bit size of all @code{time_t} derived types and the prototypes of all
> +related functions). If @code{_TIME_BITS} is undefined, the bit size of
> +time_t equals the bit size of the architecture.

Apart from "bit size of the architecture" not being well-defined, that's 
not right for ARC or RV32, 32-bit architectures with 64-bit time_t.

Note there should be two spaces after "." in Texinfo manuals.

> +If @code{_TIME_BITS} is undefined, or if @code{_TIME_BITS} is defined
> +to the value @code{32} and @code{__WORDSIZE} is defined to the value
> +@code{32}, or or if @code{_TIME_BITS} is defined to the value @code{64}
> +and @code{__WORDSIZE} is defined to the value @code{64}, nothing changes.

__WORDSIZE (and __TIMESIZE after the fix above) is not a user-visible 
interface, it's a glibc header implementation detail.  The manual (other 
than maint.texi) should not mention either such internal macro; you need 
to talk about a concept of word size / default time_t size that's 
explained purely in user-level interfaces, not glibc internal macros.

> +If @code{_TIME_BITS} is defined to the value @code{64} and if
> +@code{__WORDSIZE} is defined to the value @code{32}, then the @w{64 bit}
> +time API and implementation are used even though the architecture word
> +size is @code{32}. Also, if the kernel provides @w{64 bit} time support,
> +it is used; otherwise, the @w{32 bit} kernel time support is used (with
> +no provision to address kernel Y2038 shortcomings).

Use "32-bit" and "64-bit" (with hyphen) as adjectives.
Lukasz Majewski Dec. 7, 2020, 1 p.m. UTC | #2
Hi Joseph,

> On Sat, 5 Dec 2020, Lukasz Majewski wrote:
> 
> > This change introduces new compile time, supported by glibc flag -
> > namely _TIME_BITS, which then is responsible for exporting
> > __USE_TIME_BITS64 only  
> 
> As a major new user-visible feature, this needs to be mentioned in
> NEWS.

Ok.

> 
> > +/* We need to know the word size in order to check the time size.
> > */ +#include <bits/wordsize.h>
> > +
> > +#if defined _TIME_BITS
> > +# if _TIME_BITS == 64
> > +#  if ! defined (_FILE_OFFSET_BITS) || _FILE_OFFSET_BITS != 64
> > +#   error _TIME_BITS==64 is allowed only when _FILE_OFFSET_BITS==64
> > +#  elif __WORDSIZE == 32
> > +#   define __USE_TIME_BITS64	1
> > +#  endif  
> 
> __WORDSIZE isn't the right thing to check.  On ARC or RV32 or x32, 
> _TIME_BITS == 64 should be a no-op, because time_t has always been
> 64-bit for those glibc ports.  That is, you should be checking
> __TIMESIZE, not __WORDSIZE.

Ok. Thanks for pointing this out

> 
> > +# elif _TIME_BITS == 32
> > +#  if __WORDSIZE > 32
> > +#   error _TIME_BITS=32 is not compatible with __WORDSIZE > 32  
> 
> Likewise, __TIMESIZE should be checked here, not __WORDSIZE.
> 

Ok.

> > +@defvr Macro _TIME_BITS
> > +This macro determines the bit size of @code{time_t} (and therefore
> > the +bit size of all @code{time_t} derived types and the prototypes
> > of all +related functions). If @code{_TIME_BITS} is undefined, the
> > bit size of +time_t equals the bit size of the architecture.  
> 
> Apart from "bit size of the architecture" not being well-defined,
> that's not right for ARC or RV32, 32-bit architectures with 64-bit
> time_t.
> 
> Note there should be two spaces after "." in Texinfo manuals.
> 
> > +If @code{_TIME_BITS} is undefined, or if @code{_TIME_BITS} is
> > defined +to the value @code{32} and @code{__WORDSIZE} is defined to
> > the value +@code{32}, or or if @code{_TIME_BITS} is defined to the
> > value @code{64} +and @code{__WORDSIZE} is defined to the value
> > @code{64}, nothing changes.  
> 
> __WORDSIZE (and __TIMESIZE after the fix above) is not a user-visible 
> interface, it's a glibc header implementation detail.  The manual
> (other than maint.texi) should not mention either such internal
> macro; you need to talk about a concept of word size / default time_t
> size that's explained purely in user-level interfaces, not glibc
> internal macros.
> 
> > +If @code{_TIME_BITS} is defined to the value @code{64} and if
> > +@code{__WORDSIZE} is defined to the value @code{32}, then the
> > @w{64 bit} +time API and implementation are used even though the
> > architecture word +size is @code{32}. Also, if the kernel provides
> > @w{64 bit} time support, +it is used; otherwise, the @w{32 bit}
> > kernel time support is used (with +no provision to address kernel
> > Y2038 shortcomings).  
> 
> Use "32-bit" and "64-bit" (with hyphen) as adjectives.
> 

Thanks for pointing this out - I will rewrite the manual entry.


Best regards,

Lukasz Majewski

--

DENX Software Engineering GmbH,      Managing Director: Wolfgang Denk
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Phone: (+49)-8142-66989-59 Fax: (+49)-8142-66989-80 Email: lukma@denx.de
diff mbox series

Patch

diff --git a/include/features.h b/include/features.h
index f3e62d3362..c639c044b4 100644
--- a/include/features.h
+++ b/include/features.h
@@ -380,6 +380,25 @@ 
 # define __USE_FILE_OFFSET64	1
 #endif
 
+/* We need to know the word size in order to check the time size.  */
+#include <bits/wordsize.h>
+
+#if defined _TIME_BITS
+# if _TIME_BITS == 64
+#  if ! defined (_FILE_OFFSET_BITS) || _FILE_OFFSET_BITS != 64
+#   error _TIME_BITS==64 is allowed only when _FILE_OFFSET_BITS==64
+#  elif __WORDSIZE == 32
+#   define __USE_TIME_BITS64	1
+#  endif
+# elif _TIME_BITS == 32
+#  if __WORDSIZE > 32
+#   error _TIME_BITS=32 is not compatible with __WORDSIZE > 32
+#  endif
+# else
+#  error Invalid _TIME_BITS value (can only be 32 or 64)
+# endif
+#endif
+
 #if defined _DEFAULT_SOURCE
 # define __USE_MISC	1
 #endif
diff --git a/io/Versions b/io/Versions
index 49c4d2d40a..15616b68f3 100644
--- a/io/Versions
+++ b/io/Versions
@@ -146,5 +146,7 @@  libc {
     __file_change_detection_for_path;
     __file_change_detection_for_fp;
     __fstat64;
+    __ppoll64;
+    __utime64;
   }
 }
diff --git a/io/sys/poll.h b/io/sys/poll.h
index 857be0f5ac..4a725ed18e 100644
--- a/io/sys/poll.h
+++ b/io/sys/poll.h
@@ -63,6 +63,17 @@  extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
 extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
 		  const struct timespec *__timeout,
 		  const __sigset_t *__ss);
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (ppoll, (struct pollfd *__fds, nfds_t __nfds,
+                               const struct timespec *__timeout,
+                               const __sigset_t *__ss),
+                       __ppoll64);
+#  else
+#  define ppoll __ppoll64
+#  endif
+# endif
 #endif
 
 __END_DECLS
diff --git a/io/sys/stat.h b/io/sys/stat.h
index 58c3770622..b3f2f0da99 100644
--- a/io/sys/stat.h
+++ b/io/sys/stat.h
@@ -361,11 +361,31 @@  extern int utimensat (int __fd, const char *__path,
 		      const struct timespec __times[2],
 		      int __flags)
      __THROW __nonnull ((2));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (utimensat, (int fd, const char *__path,
+                                       const struct timespec __times[2],
+                                       int flags),
+                           __utimensat64) __nonnull ((2));
+#  else
+#  define utimensat __utimensat64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_XOPEN2K8
 /* Set file access and modification times of the file associated with FD.  */
 extern int futimens (int __fd, const struct timespec __times[2]) __THROW;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (futimens, (int fd, const struct timespec __times[2]),
+                           __futimens64);
+#  else
+#  define futimens __futimens64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_GNU
diff --git a/io/utime.h b/io/utime.h
index 07659016ab..c3e7e5fce1 100644
--- a/io/utime.h
+++ b/io/utime.h
@@ -35,8 +35,13 @@  __BEGIN_DECLS
 /* Structure describing file times.  */
 struct utimbuf
   {
+# ifdef __USE_TIME_BITS64
+    __time64_t actime;		/* Access time.  */
+    __time64_t modtime;		/* Modification time.  */
+# else
     __time_t actime;		/* Access time.  */
     __time_t modtime;		/* Modification time.  */
+# endif
   };
 
 /* Set the access and modification times of FILE to those given in
@@ -45,6 +50,16 @@  extern int utime (const char *__file,
 		  const struct utimbuf *__file_times)
      __THROW __nonnull ((1));
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (utime, (const char *__file,
+                                   const struct utimbuf *__file_times),
+                           __utime64);
+# else
+# define utime __utime64
+# endif
+#endif
+
 __END_DECLS
 
 #endif /* utime.h */
diff --git a/manual/creature.texi b/manual/creature.texi
index be5050468b..5389fb0f34 100644
--- a/manual/creature.texi
+++ b/manual/creature.texi
@@ -165,6 +165,34 @@  This macro was introduced as part of the Large File Support extension
 (LFS).
 @end defvr
 
+@defvr Macro _TIME_BITS
+This macro determines the bit size of @code{time_t} (and therefore the
+bit size of all @code{time_t} derived types and the prototypes of all
+related functions). If @code{_TIME_BITS} is undefined, the bit size of
+time_t equals the bit size of the architecture.
+
+If @code{_TIME_BITS} is undefined, or if @code{_TIME_BITS} is defined
+to the value @code{32} and @code{__WORDSIZE} is defined to the value
+@code{32}, or or if @code{_TIME_BITS} is defined to the value @code{64}
+and @code{__WORDSIZE} is defined to the value @code{64}, nothing changes.
+
+If @code{_TIME_BITS} is defined to the value @code{64} and if
+@code{__WORDSIZE} is defined to the value @code{32}, then the @w{64 bit}
+time API and implementation are used even though the architecture word
+size is @code{32}. Also, if the kernel provides @w{64 bit} time support,
+it is used; otherwise, the @w{32 bit} kernel time support is used (with
+no provision to address kernel Y2038 shortcomings).
+
+If @code{_TIME_BITS} is defined to the value @code{32} and if
+@code{__WORDSIZE} is defined to the value @code{64}, then a compile-time
+error is emitted.
+
+If @code{_TIME_BITS} is defined to a value different from both @code{32}
+and @code{64}, then a compile-time error is emitted.
+
+This macro was introduced as part of the Y2038 support.
+@end defvr
+
 @defvr Macro _ISOC99_SOURCE
 @standards{GNU, (none)}
 If this macro is defined, features from ISO C99 are included.  Since
diff --git a/misc/Versions b/misc/Versions
index 95666f6548..fb30af2079 100644
--- a/misc/Versions
+++ b/misc/Versions
@@ -172,5 +172,10 @@  libc {
     __mmap; __munmap; __mprotect;
     __sched_get_priority_min; __sched_get_priority_max;
     __libc_allocate_once_slow;
+    __utimes64;
+    __futimes64;
+    __lutimes64;
+    __futimesat64;
+    __select64;
   }
 }
diff --git a/misc/sys/select.h b/misc/sys/select.h
index 29d011c2d5..779a6e81b6 100644
--- a/misc/sys/select.h
+++ b/misc/sys/select.h
@@ -103,6 +103,19 @@  extern int select (int __nfds, fd_set *__restrict __readfds,
 		   fd_set *__restrict __exceptfds,
 		   struct timeval *__restrict __timeout);
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT)
+extern int __REDIRECT (select,
+                       (int __nfds, fd_set *__restrict __readfds,
+                        fd_set *__restrict __writefds,
+                        fd_set *__restrict __exceptfds,
+                        struct timeval *__restrict __timeout),
+                       __select64);
+# else
+#  define select __select64
+# endif
+#endif
+
 #ifdef __USE_XOPEN2K
 /* Same as above only that the TIMEOUT value is given with higher
    resolution and a sigmask which is been set temporarily.  This version
@@ -115,6 +128,20 @@  extern int pselect (int __nfds, fd_set *__restrict __readfds,
 		    fd_set *__restrict __exceptfds,
 		    const struct timespec *__restrict __timeout,
 		    const __sigset_t *__restrict __sigmask);
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (pselect,
+                       (int __nfds, fd_set *__restrict __readfds,
+                        fd_set *__restrict __writefds,
+                        fd_set *__restrict __exceptfds,
+                        const struct timespec *__restrict __timeout,
+                        const __sigset_t *__restrict __sigmask),
+                       __pselect64);
+#  else
+#   define pselect __pselect64
+#  endif
+# endif
 #endif
 
 
diff --git a/nptl/Versions b/nptl/Versions
index 02650fe91c..b741ad1c77 100644
--- a/nptl/Versions
+++ b/nptl/Versions
@@ -305,5 +305,20 @@  libpthread {
     __futex_abstimed_wait64; __futex_abstimed_wait_cancelable64;
     __shm_directory;
     __libpthread_freeres;
+    __pthread_timedjoin_np64;
+    __pthread_clockjoin_np64;
+    __pthread_cond_timedwait64;
+    __pthread_cond_clockwait64;
+    __sem_clockwait64;
+    __sem_timedwait64;
+    __pthread_rwlock_clockrdlock64;
+    __pthread_rwlock_clockwrlock64;
+    __pthread_rwlock_timedrdlock64;
+    __pthread_rwlock_timedwrlock64;
+    __pthread_mutex_timedlock64;
+    __pthread_mutex_clocklock64;
+    __cnd_timedwait64;
+    __mtx_timedlock64;
+    __thrd_sleep64;
   }
 }
diff --git a/posix/Versions b/posix/Versions
index 7d06a6d0c0..cebbd2aeb8 100644
--- a/posix/Versions
+++ b/posix/Versions
@@ -150,5 +150,7 @@  libc {
   GLIBC_PRIVATE {
     __libc_fork; __libc_pread; __libc_pwrite;
     __nanosleep_nocancel; __pause_nocancel;
+    __wait4_time64; __pselect64;
+    __nanosleep64; __wait3_time64;
   }
 }
diff --git a/posix/sched.h b/posix/sched.h
index 60c9c3c710..0d9cbc5bb2 100644
--- a/posix/sched.h
+++ b/posix/sched.h
@@ -76,6 +76,15 @@  extern int sched_get_priority_min (int __algorithm) __THROW;
 /* Get the SCHED_RR interval for the named process.  */
 extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (sched_rr_get_interval,
+                           (__pid_t __pid, struct timespec *__t),
+                           __sched_rr_get_interval64);
+# else
+# define sched_rr_get_interval __sched_rr_get_interval64
+# endif
+#endif
 
 #ifdef __USE_GNU
 /* Access macros for `cpu_set'.  */
diff --git a/posix/sys/wait.h b/posix/sys/wait.h
index a42e16c1b0..68ec036b29 100644
--- a/posix/sys/wait.h
+++ b/posix/sys/wait.h
@@ -146,12 +146,32 @@  struct rusage;
    otherwise don't.  */
 extern __pid_t wait3 (int *__stat_loc, int __options,
 		      struct rusage * __usage) __THROWNL;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTHNL)
+extern __pid_t __REDIRECT_NTHNL (wait3, (int *__stat_loc, int __options,
+                                         struct rusage * __usage)
+                                 __wait3_time64);
+#  else
+#  define wait3 __wait3_time64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_MISC
 /* PID is like waitpid.  Other args are like wait3.  */
 extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options,
 		      struct rusage *__usage) __THROWNL;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTHNL)
+extern __pid_t __REDIRECT_NTHNL (wait4, (__pid_t __pid, int *__stat_loc,
+                                         int __options, struct rusage *__usage),
+                                 __wait4_time64);
+#  else
+#  define wait4 __wait4_time64
+#  endif
+# endif
 #endif /* Use misc.  */
 
 
diff --git a/resolv/Versions b/resolv/Versions
index 9a82704af7..d38ee438f1 100644
--- a/resolv/Versions
+++ b/resolv/Versions
@@ -105,4 +105,7 @@  libanl {
   GLIBC_2.2.3 {
     gai_cancel; gai_error; gai_suspend; getaddrinfo_a;
   }
+  GLIBC_PRIVATE {
+    __gai_suspend_time64;
+  }
 }
diff --git a/resolv/netdb.h b/resolv/netdb.h
index 575e416dac..bd0832988f 100644
--- a/resolv/netdb.h
+++ b/resolv/netdb.h
@@ -701,6 +701,17 @@  extern int getaddrinfo_a (int __mode, struct gaicb *__list[__restrict_arr],
 extern int gai_suspend (const struct gaicb *const __list[], int __ent,
 			const struct timespec *__timeout);
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (gai_suspend, (const struct gaicb *const __list[],
+                                     int __ent,
+                                     const struct timespec *__timeout),
+                       __gai_suspend_time64);
+#  else
+#   define gai_suspend __gai_suspend_time64
+#  endif
+# endif
+
 /* Get the error status of the request REQ.  */
 extern int gai_error (struct gaicb *__req) __THROW;
 
diff --git a/resource/Versions b/resource/Versions
index d6c2ccee1b..96a757532f 100644
--- a/resource/Versions
+++ b/resource/Versions
@@ -24,5 +24,6 @@  libc {
   }
   GLIBC_PRIVATE {
     __getrlimit;
+    __getrusage64;
   }
 }
diff --git a/resource/bits/types/struct_rusage.h b/resource/bits/types/struct_rusage.h
index ba0a56871d..00f07e3ee2 100644
--- a/resource/bits/types/struct_rusage.h
+++ b/resource/bits/types/struct_rusage.h
@@ -32,10 +32,15 @@ 
    for little-endian ones, like x32.  */
 struct rusage
   {
+#ifdef __USE_TIME_BITS64
+    struct __timeval64 ru_utime;
+    struct __timeval64 ru_stime;
+#else
     /* Total amount of user time used.  */
     struct timeval ru_utime;
     /* Total amount of system time used.  */
     struct timeval ru_stime;
+#endif
     /* Maximum resident set size (in kilobytes).  */
     __extension__ union
       {
diff --git a/resource/sys/resource.h b/resource/sys/resource.h
index 4edafb50d5..98f05cf1c4 100644
--- a/resource/sys/resource.h
+++ b/resource/sys/resource.h
@@ -86,6 +86,16 @@  extern int setrlimit64 (__rlimit_resource_t __resource,
    and put it in *USAGE.  Returns 0 for success, -1 for failure.  */
 extern int getrusage (__rusage_who_t __who, struct rusage *__usage) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (getrusage, (__rusage_who_t __who,
+                                       struct rusage *__usage),
+                           __getrusage64);
+# else
+# define getrusage __getrusage64
+# endif
+#endif
+
 /* Return the highest priority of any process specified by WHICH and WHO
    (see above); if WHO is zero, the current process, process group, or user
    (as specified by WHO) is used.  A lower priority number means higher
diff --git a/rt/Versions b/rt/Versions
index 84d1345420..e1e00d88fa 100644
--- a/rt/Versions
+++ b/rt/Versions
@@ -1,4 +1,11 @@ 
 librt {
+  GLIBC_PRIVATE {
+    __timer_gettime64;
+    __timer_settime64;
+    __mq_timedsend_time64;
+    __mq_timedreceive_time64;
+    __aio_suspend_time64;
+  }
   GLIBC_2.1 {
     # AIO functions.
     aio_cancel; aio_cancel64; aio_error; aio_error64; aio_fsync; aio_fsync64;
diff --git a/rt/aio.h b/rt/aio.h
index 148d31a0af..2c35f1b04c 100644
--- a/rt/aio.h
+++ b/rt/aio.h
@@ -193,12 +193,17 @@  extern __ssize_t __REDIRECT_NTH (aio_return, (struct aiocb *__aiocbp),
 extern int __REDIRECT_NTH (aio_cancel,
 			   (int __fildes, struct aiocb *__aiocbp),
 			   aio_cancel64);
-
+#  ifdef __USE_TIME_BITS64
+extern int __REDIRECT_NTH (aio_suspend,
+			   (const struct aiocb *const __list[], int __nent,
+			    const struct timespec *__restrict __timeout),
+			   __aio_suspend_time64) __nonnull ((1));
+#  else
 extern int __REDIRECT_NTH (aio_suspend,
 			   (const struct aiocb *const __list[], int __nent,
 			    const struct timespec *__restrict __timeout),
 			   aio_suspend64) __nonnull ((1));
-
+#  endif
 extern int __REDIRECT_NTH (aio_fsync,
 			   (int __operation, struct aiocb *__aiocbp),
 			   aio_fsync64) __nonnull ((2));
@@ -210,7 +215,11 @@  extern int __REDIRECT_NTH (aio_fsync,
 #  define aio_error aio_error64
 #  define aio_return aio_return64
 #  define aio_cancel aio_cancel64
-#  define aio_suspend aio_suspend64
+#  ifdef __USE_TIME_BITS64
+#   define aio_suspend __aio_suspend_time64
+#  else
+#   define aio_suspend aio_suspend64
+#  endif
 #  define aio_fsync aio_fsync64
 # endif
 #endif
@@ -234,6 +243,16 @@  extern int aio_cancel64 (int __fildes, struct aiocb64 *__aiocbp) __THROW;
 extern int aio_suspend64 (const struct aiocb64 *const __list[], int __nent,
 			  const struct timespec *__restrict __timeout)
   __THROW __nonnull ((1));
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (aio_suspend64,
+			   (const struct aiocb *const __list[], int __nent,
+			    const struct timespec *__restrict __timeout),
+			   __aio_suspend_time64) __nonnull ((1));
+#  else
+#   define aio_suspend64 __aio_suspend_time64
+#  endif
+# endif
 
 extern int aio_fsync64 (int __operation, struct aiocb64 *__aiocbp)
   __THROW __nonnull ((2));
diff --git a/rt/mqueue.h b/rt/mqueue.h
index a2a2aa1771..e6b8641c62 100644
--- a/rt/mqueue.h
+++ b/rt/mqueue.h
@@ -79,12 +79,37 @@  extern ssize_t mq_timedreceive (mqd_t __mqdes, char *__restrict __msg_ptr,
 				const struct timespec *__restrict __abs_timeout)
   __nonnull ((2, 5));
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (mq_timedreceive, (mqd_t __mqdes,
+                               char *__restrict __msg_ptr,
+                               size_t __msg_len,
+                               unsigned int *__restrict __msg_prio,
+                               const struct timespec *__restrict __abs_timeout),
+                       __mq_timedreceive_time64);
+#  else
+#   define mq_timedreceive __mq_timedreceive_time64
+#  endif
+# endif
+
 /* Add message pointed by MSG_PTR to message queue MQDES, stop blocking
    on full message queue if ABS_TIMEOUT expires.  */
 extern int mq_timedsend (mqd_t __mqdes, const char *__msg_ptr,
 			 size_t __msg_len, unsigned int __msg_prio,
 			 const struct timespec *__abs_timeout)
   __nonnull ((2, 5));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (mq_timedsend, (mqd_t __mqdes,
+                       const char *__msg_ptr, size_t __msg_len,
+                       unsigned int __msg_prio,
+                       const struct timespec *__abs_timeout),
+     __mq_timedsend_time64);
+#  else
+#   define mq_timedsend __mq_timedsend_time64
+#  endif
+# endif
 #endif
 
 /* Define some inlines helping to catch common problems.  */
diff --git a/signal/Versions b/signal/Versions
index a915ef400f..d653b5de09 100644
--- a/signal/Versions
+++ b/signal/Versions
@@ -51,4 +51,7 @@  libc {
   }
   GLIBC_2.21 {
   }
+  GLIBC_PRIVATE {
+    __sigtimedwait64;
+  }
 }
diff --git a/signal/signal.h b/signal/signal.h
index effe3d698f..564820e366 100644
--- a/signal/signal.h
+++ b/signal/signal.h
@@ -274,6 +274,18 @@  extern int sigtimedwait (const sigset_t *__restrict __set,
 			 const struct timespec *__restrict __timeout)
      __nonnull ((1));
 
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT)
+extern int __REDIRECT (sigtimedwait,
+                       (const sigset_t *__restrict __set,
+                        siginfo_t *__restrict __info,
+                        const struct timespec *__restrict __timeout),
+                       __sigtimedwait64);
+#   else
+#    define sigtimedwait __sigtimedwait64
+#   endif
+#  endif
+
 /* Send signal SIG to the process PID.  Associate data in VAL with the
    signal.  */
 extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
diff --git a/socket/sys/socket.h b/socket/sys/socket.h
index 7780c00ecb..2273c52cdf 100644
--- a/socket/sys/socket.h
+++ b/socket/sys/socket.h
@@ -199,6 +199,17 @@  extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
 extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
 		     unsigned int __vlen, int __flags,
 		     struct timespec *__tmo);
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (recvmmsg, (int __fd, struct mmsghdr *__vmessages,
+                                  unsigned int __vlen, int __flags,
+                                  struct timespec *__tmo),
+                       __recvmmsg64);
+#  else
+#   define recvmmsg __recvmmsg64
+#  endif
+# endif
 #endif
 
 
diff --git a/sysdeps/nptl/pthread.h b/sysdeps/nptl/pthread.h
index 3a34d82342..982ed32baa 100644
--- a/sysdeps/nptl/pthread.h
+++ b/sysdeps/nptl/pthread.h
@@ -230,6 +230,17 @@  extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __THROW;
 extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
 				 const struct timespec *__abstime);
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (pthread_timedjoin_np,
+                       (pthread_t __th, void **__thread_return,
+                        const struct timespec *__abstime),
+                       __pthread_timedjoin_np64);
+#  else
+#  define pthread_timedjoin_np __pthread_timedjoin_np64
+#  endif
+# endif
+
 /* Make calling thread wait for termination of the thread TH, but only
    until TIMEOUT measured against the clock specified by CLOCKID.  The
    exit status of the thread is stored in *THREAD_RETURN, if
@@ -240,6 +251,18 @@  extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
 extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
                                  clockid_t __clockid,
 				 const struct timespec *__abstime);
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (pthread_clockjoin_np,
+                       (pthread_t __th, void **__thread_return,
+                        clockid_t __clockid,
+                        const struct timespec *__abstime),
+                       __pthread_clockjoin_np64);
+#  else
+#  define pthread_clockjoin_np __pthread_clockjoin_np64
+#  endif
+# endif
 #endif
 
 /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
@@ -776,6 +799,17 @@  extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
 extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
 				    const struct timespec *__restrict
 				    __abstime) __THROWNL __nonnull ((1, 2));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_mutex_timedlock,
+                             (pthread_mutex_t *__restrict __mutex,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_mutex_timedlock64);
+#  else
+#   define pthread_mutex_timedlock __pthread_mutex_timedlock64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_GNU
@@ -783,6 +817,18 @@  extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
 				    clockid_t __clockid,
 				    const struct timespec *__restrict
 				    __abstime) __THROWNL __nonnull ((1, 3));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_mutex_clocklock,
+                             (pthread_mutex_t *__restrict __mutex,
+                              clockid_t __clockid,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_mutex_clocklock64);
+#  else
+#   define pthread_mutex_clocklock __pthread_mutex_clocklock64
+#  endif
+# endif
 #endif
 
 /* Unlock a mutex.  */
@@ -922,6 +968,17 @@  extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
 extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
 				       const struct timespec *__restrict
 				       __abstime) __THROWNL __nonnull ((1, 2));
+
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_rwlock_timedrdlock,
+                             (pthread_rwlock_t *__restrict __rwlock,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_rwlock_timedrdlock64);
+#   else
+#    define pthread_rwlock_timedrdlock __pthread_rwlock_timedrdlock64
+#   endif
+#  endif
 # endif
 
 # ifdef __USE_GNU
@@ -929,6 +986,18 @@  extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
 				       clockid_t __clockid,
 				       const struct timespec *__restrict
 				       __abstime) __THROWNL __nonnull ((1, 3));
+
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_rwlock_clockrdlock,
+                             (pthread_rwlock_t *__restrict __rwlock,
+                              clockid_t __clockid,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_rwlock_clockrdlock64);
+#   else
+#    define pthread_rwlock_clockrdlock __pthread_rwlock_clockrdlock64
+#   endif
+#  endif
 # endif
 
 /* Acquire write lock for RWLOCK.  */
@@ -944,6 +1013,17 @@  extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
 extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
 				       const struct timespec *__restrict
 				       __abstime) __THROWNL __nonnull ((1, 2));
+
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_rwlock_timedwrlock,
+                             (pthread_rwlock_t *__restrict __rwlock,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_rwlock_timedwrlock64);
+#   else
+#    define pthread_rwlock_timedwrlock __pthread_rwlock_timedwrlock64
+#   endif
+#  endif
 # endif
 
 # ifdef __USE_GNU
@@ -951,6 +1031,18 @@  extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
 				       clockid_t __clockid,
 				       const struct timespec *__restrict
 				       __abstime) __THROWNL __nonnull ((1, 3));
+
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT_NTHNL)
+extern int __REDIRECT_NTHNL (pthread_rwlock_clockwrlock,
+                             (pthread_rwlock_t *__restrict __rwlock,
+                              clockid_t __clockid,
+                              const struct timespec *__restrict __abstime),
+                             __pthread_rwlock_clockwrlock64);
+#   else
+#    define pthread_rwlock_clockwrlock __pthread_rwlock_clockwrlock64
+#   endif
+#  endif
 # endif
 
 /* Unlock RWLOCK.  */
@@ -1032,6 +1124,18 @@  extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
 				   const struct timespec *__restrict __abstime)
      __nonnull ((1, 2, 3));
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (pthread_cond_timedwait,
+                       (pthread_cond_t *__restrict __cond,
+                        pthread_mutex_t *__restrict __mutex,
+                        const struct timespec *__restrict __abstime),
+                       __pthread_cond_timedwait64);
+#  else
+#  define pthread_cond_timedwait __pthread_cond_timedwait64
+#  endif
+# endif
+
 # ifdef __USE_GNU
 /* Wait for condition variable COND to be signaled or broadcast until
    ABSTIME measured by the specified clock. MUTEX is assumed to be
@@ -1045,6 +1149,19 @@  extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
 				   __clockid_t __clock_id,
 				   const struct timespec *__restrict __abstime)
      __nonnull ((1, 2, 4));
+
+#  ifdef __USE_TIME_BITS64
+#   if defined(__REDIRECT)
+extern int __REDIRECT (pthread_cond_clockwait,
+                       (pthread_cond_t *__restrict __cond,
+                        pthread_mutex_t *__restrict __mutex,
+                        __clockid_t __clock_id,
+                        const struct timespec *__restrict __abstime),
+                       __pthread_cond_clockwait64);
+#   else
+#   define pthread_cond_clockwait __pthread_cond_clockwait64
+#   endif
+#  endif
 # endif
 
 /* Functions for handling condition variable attributes.  */
diff --git a/sysdeps/pthread/semaphore.h b/sysdeps/pthread/semaphore.h
index 436d21cb08..6a6055fc3a 100644
--- a/sysdeps/pthread/semaphore.h
+++ b/sysdeps/pthread/semaphore.h
@@ -62,6 +62,17 @@  extern int sem_wait (sem_t *__sem) __nonnull ((1));
 extern int sem_timedwait (sem_t *__restrict __sem,
 			  const struct timespec *__restrict __abstime)
   __nonnull ((1, 2));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (sem_timedwait,
+                       (sem_t *__restrict __sem,
+                        const struct timespec *__restrict __abstime),
+                        __sem_timedwait64);
+#  else
+#   define sem_timedwait __sem_timedwait64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_GNU
@@ -69,6 +80,18 @@  extern int sem_clockwait (sem_t *__restrict __sem,
 			  clockid_t clock,
 			  const struct timespec *__restrict __abstime)
   __nonnull ((1, 3));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (sem_clockwait,
+                       (sem_t *__restrict __sem,
+                        clockid_t clock,
+                        const struct timespec *__restrict __abstime),
+                        __sem_clockwait64);
+#  else
+#   define sem_clockwait __sem_clockwait64
+#  endif
+# endif
 #endif
 
 /* Test whether SEM is posted.  */
diff --git a/sysdeps/pthread/threads.h b/sysdeps/pthread/threads.h
index 0ac489b4a1..acdc7b329a 100644
--- a/sysdeps/pthread/threads.h
+++ b/sysdeps/pthread/threads.h
@@ -91,6 +91,16 @@  extern thrd_t thrd_current (void);
 extern int thrd_sleep (const struct timespec *__time_point,
 		       struct timespec *__remaining);
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT)
+extern int __REDIRECT (thrd_sleep, (const struct timespec *__time_point,
+                                    struct timespec *__remaining),
+                       __thrd_sleep64);
+# else
+#  define thrd_sleep __thrd_sleep64
+# endif
+#endif
+
 /* Terminate current thread execution, cleaning up any thread local
    storage and freeing resources.  Returns the value specified in __RES.  */
 extern void thrd_exit (int __res) __attribute__ ((__noreturn__));
@@ -134,6 +144,17 @@  extern int mtx_lock (mtx_t *__mutex);
 extern int mtx_timedlock (mtx_t *__restrict __mutex,
 			  const struct timespec *__restrict __time_point);
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT)
+extern int __REDIRECT (mtx_timedlock, (mtx_t *__restrict __mutex,
+                                       const struct timespec *__restrict
+                                       __time_point),
+                       __mtx_timedlock64);
+# else
+#  define mtx_timedlock __mtx_timedlock64
+# endif
+#endif
+
 /* Try to lock the mutex pointed by __MUTEX without blocking.  If the mutex
    is free the current threads takes control of it, otherwise it returns
    immediately.  */
@@ -175,6 +196,18 @@  extern int cnd_timedwait (cnd_t *__restrict __cond,
 			  mtx_t *__restrict __mutex,
 			  const struct timespec *__restrict __time_point);
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT)
+extern int __REDIRECT (cnd_timedwait, (cnd_t *__restrict __cond,
+                                       mtx_t *__restrict __mutex,
+                                       const struct timespec *__restrict
+                                       __time_point),
+                       __cnd_timedwait64);
+# else
+#  define cnd_timedwait __cnd_timedwait64
+# endif
+#endif
+
 /* Destroy condition variable pointed by __cond and free all of its
    resources.  */
 extern void cnd_destroy (cnd_t *__COND);
diff --git a/sysdeps/unix/sysv/linux/Versions b/sysdeps/unix/sysv/linux/Versions
index c35f783e2a..11bdef3343 100644
--- a/sysdeps/unix/sysv/linux/Versions
+++ b/sysdeps/unix/sysv/linux/Versions
@@ -179,5 +179,12 @@  libc {
     __sigtimedwait;
     # functions used by nscd
     __netlink_assert_response;
+    __timerfd_gettime64;
+    __timerfd_settime64;
+    __sched_rr_get_interval64;
+    __clock_adjtime64;
+    __ntp_gettime64;
+    __ntp_gettimex64;
+    __recvmmsg64;
   }
 }
diff --git a/sysdeps/unix/sysv/linux/bits/time.h b/sysdeps/unix/sysv/linux/bits/time.h
index e0962744e1..7168ef1948 100644
--- a/sysdeps/unix/sysv/linux/bits/time.h
+++ b/sysdeps/unix/sysv/linux/bits/time.h
@@ -77,6 +77,16 @@  __BEGIN_DECLS
 /* Tune a POSIX clock.  */
 extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (clock_adjtime, (__clockid_t __clock_id,
+                                           struct timex *__utx),
+                           __clock_adjtime64);
+# else
+# define clock_adjtime __clock_adjtime64
+# endif
+#endif
+
 __END_DECLS
 #endif /* use GNU */
 
diff --git a/sysdeps/unix/sysv/linux/bits/timex.h b/sysdeps/unix/sysv/linux/bits/timex.h
index 9adb0bcc60..f1d71ea9c4 100644
--- a/sysdeps/unix/sysv/linux/bits/timex.h
+++ b/sysdeps/unix/sysv/linux/bits/timex.h
@@ -25,6 +25,36 @@ 
 
 struct timex
 {
+# ifdef __USE_TIME_BITS64
+  unsigned int modes;          /* mode selector */
+  int :32;                     /* pad */
+  long long offset;            /* time offset (usec) */
+  long long freq;              /* frequency offset (scaled ppm) */
+  long long maxerror;          /* maximum error (usec) */
+  long long esterror;          /* estimated error (usec) */
+  int status;                  /* clock command/status */
+  int :32;                     /* pad */
+  long long constant;          /* pll time constant */
+  long long precision;         /* clock precision (usec) (read only) */
+  long long tolerance;         /* clock frequency tolerance (ppm) (ro) */
+  struct timeval time;     /* (read only, except for ADJ_SETOFFSET) */
+  long long tick;              /* (modified) usecs between clock ticks */
+  long long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
+  long long jitter;            /* pps jitter (us) (ro) */
+  int shift;                   /* interval duration (s) (shift) (ro) */
+  int :32;                     /* pad */
+  long long stabil;            /* pps stability (scaled ppm) (ro) */
+  long long jitcnt;            /* jitter limit exceeded (ro) */
+  long long calcnt;            /* calibration intervals (ro) */
+  long long errcnt;            /* calibration errors (ro) */
+  long long stbcnt;            /* stability limit exceeded (ro) */
+
+  int tai;                     /* TAI offset (ro) */
+
+  int  :32; int  :32; int  :32; int  :32;
+  int  :32; int  :32; int  :32; int  :32;
+  int  :32; int  :32; int  :32;
+# else
   unsigned int modes;		/* mode selector */
   __syscall_slong_t offset;	/* time offset (usec) */
   __syscall_slong_t freq;	/* frequency offset (scaled ppm) */
@@ -51,6 +81,7 @@  struct timex
   int  :32; int  :32; int  :32; int  :32;
   int  :32; int  :32; int  :32; int  :32;
   int  :32; int  :32; int  :32;
+# endif
 };
 
 /* Mode codes (timex.mode) */
diff --git a/sysdeps/unix/sysv/linux/sys/timerfd.h b/sysdeps/unix/sysv/linux/sys/timerfd.h
index 0ae60b65bd..cd252476a7 100644
--- a/sysdeps/unix/sysv/linux/sys/timerfd.h
+++ b/sysdeps/unix/sysv/linux/sys/timerfd.h
@@ -47,9 +47,31 @@  extern int timerfd_settime (int __ufd, int __flags,
 			    const struct itimerspec *__utmr,
 			    struct itimerspec *__otmr) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (timerfd_settime,
+                           (int __ufd, int __flags,
+                            const struct itimerspec *__restrict __value,
+                            struct itimerspec *__restrict __ovalue),
+                           __timerfd_settime64);
+# else
+# define timerfd_settime __timerfd_settime64
+# endif
+#endif
+
 /* Return the next expiration time of UFD.  */
 extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (timerfd_gettime, (int __ufd,
+                                             struct itimerspec *__otmr),
+                           __timerfd_gettime64);
+# else
+# define timerfd_gettime __timerfd_gettime64
+# endif
+#endif
+
 __END_DECLS
 
 #endif /* sys/timerfd.h */
diff --git a/sysdeps/unix/sysv/linux/sys/timex.h b/sysdeps/unix/sysv/linux/sys/timex.h
index 6979b86b72..b5271152bb 100644
--- a/sysdeps/unix/sysv/linux/sys/timex.h
+++ b/sysdeps/unix/sysv/linux/sys/timex.h
@@ -57,15 +57,46 @@  __BEGIN_DECLS
 extern int __adjtimex (struct timex *__ntx) __THROW;
 extern int adjtimex (struct timex *__ntx) __THROW;
 
-#ifdef __REDIRECT_NTH
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (adjtimex, (struct timex *__ntx),
+                           ___adjtimex64);
+# else
+# define adjtimex ___adjtimex64
+# endif
+#endif
+
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
 extern int __REDIRECT_NTH (ntp_gettime, (struct ntptimeval *__ntv),
-			   ntp_gettimex);
+                           __ntp_gettime64);
+extern int __REDIRECT_NTH (ntp_gettimex, (struct ntptimeval *__ntv),
+                           __ntp_gettimex64);
+# else
+# define ntp_gettime __ntp_gettime64
+# define ntp_gettimex __ntp_gettimex64
+# endif
 #else
+# ifdef __REDIRECT_NTH
+extern int __REDIRECT_NTH (ntp_gettime, (struct ntptimeval *__ntv),
+			   ntp_gettimex);
+# else
 extern int ntp_gettimex (struct ntptimeval *__ntv) __THROW;
-# define ntp_gettime ntp_gettimex
+#  define ntp_gettime ntp_gettimex
+# endif
 #endif
+
 extern int ntp_adjtime (struct timex *__tntx) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (ntp_adjtime, (struct timex *__ntx),
+                           ___adjtimex64);
+# else
+# define ntp_adjtime ___adjtimex64
+# endif
+#endif
+
 __END_DECLS
 
 #endif /* sys/timex.h */
diff --git a/sysvipc/Versions b/sysvipc/Versions
index 4c797e25ce..f81f648960 100644
--- a/sysvipc/Versions
+++ b/sysvipc/Versions
@@ -16,5 +16,7 @@  libc {
   GLIBC_PRIVATE {
     # Cancellation point entries.
     __libc_msgrcv; __libc_msgsnd;
+    __semtimedop64; __shmctl64;
+    __semctl64; __msgctl64;
   }
 }
diff --git a/sysvipc/sys/msg.h b/sysvipc/sys/msg.h
index c70cfa582c..f39c153b86 100644
--- a/sysvipc/sys/msg.h
+++ b/sysvipc/sys/msg.h
@@ -60,6 +60,16 @@  __BEGIN_DECLS
 /* Message queue control operation.  */
 extern int msgctl (int __msqid, int __cmd, struct msqid_ds *__buf) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (msgctl,
+                           (int __msqid, int __cmd, struct msqid_ds *__buf),
+                           __msgctl64);
+# else
+# define msgctl __msgctl64
+# endif
+#endif
+
 /* Get messages queue.  */
 extern int msgget (key_t __key, int __msgflg) __THROW;
 
diff --git a/sysvipc/sys/sem.h b/sysvipc/sys/sem.h
index 4ede2dd6ef..b26c17914c 100644
--- a/sysvipc/sys/sem.h
+++ b/sysvipc/sys/sem.h
@@ -50,6 +50,16 @@  __BEGIN_DECLS
 /* Semaphore control operation.  */
 extern int semctl (int __semid, int __semnum, int __cmd, ...) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (semctl,
+                           (int __semid, int __semnum, int __cmd, ...),
+                           __semctl64);
+# else
+# define semctl __semctl64
+# endif
+#endif
+
 /* Get semaphore.  */
 extern int semget (key_t __key, int __nsems, int __semflg) __THROW;
 
@@ -60,6 +70,17 @@  extern int semop (int __semid, struct sembuf *__sops, size_t __nsops) __THROW;
 /* Operate on semaphore with timeout.  */
 extern int semtimedop (int __semid, struct sembuf *__sops, size_t __nsops,
 		       const struct timespec *__timeout) __THROW;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (semtimedop, (int __semid, struct sembuf *__sops,
+                                        size_t __nsops,
+                                        const struct timespec *__timeout),
+                           __semtimedop64);
+#  else
+#  define semtimedop __semtimedop64
+#  endif
+# endif
 #endif
 
 __END_DECLS
diff --git a/sysvipc/sys/shm.h b/sysvipc/sys/shm.h
index 6c58742c4f..8d74911e55 100644
--- a/sysvipc/sys/shm.h
+++ b/sysvipc/sys/shm.h
@@ -48,6 +48,16 @@  __BEGIN_DECLS
 /* Shared memory control operation.  */
 extern int shmctl (int __shmid, int __cmd, struct shmid_ds *__buf) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (shmctl,
+                           (int __shmid, int __cmd, struct shmid_ds *__buf),
+                           __shmctl64);
+# else
+# define shmctl __shmctl64
+# endif
+#endif
+
 /* Get shared memory segment.  */
 extern int shmget (key_t __key, size_t __size, int __shmflg) __THROW;
 
diff --git a/time/Versions b/time/Versions
index df22ac7f6a..85a3c4d9f2 100644
--- a/time/Versions
+++ b/time/Versions
@@ -1,4 +1,25 @@ 
 libc {
+  GLIBC_PRIVATE {
+    __difftime64;
+    __mktime64;
+    __timegm64;
+    __ctime64;
+    __ctime64_r;
+    __gmtime64;
+    __gmtime64_r;
+    __clock_settime64;
+    __clock_getres64;
+    __clock_nanosleep_time64;
+    __utimensat64;
+    __futimens64;
+    __timer_gettime64;
+    __timer_settime64;
+    __timespec_get64;
+    __settimeofday64;
+    __gettimeofday64;
+    __getitimer64;
+    __setitimer64;
+  }
   GLIBC_2.0 {
     # global variables
     __daylight; __timezone; __tzname;
@@ -78,5 +99,8 @@  libc {
     # same as clock_gettime; used in other libraries
     __clock_gettime;
     __clock_gettime64;
+    __adjtime64;
+    ___adjtimex64;
+    __time64;
   }
 }
diff --git a/time/bits/types/struct_timespec.h b/time/bits/types/struct_timespec.h
index d11c69cfd3..3e158ad899 100644
--- a/time/bits/types/struct_timespec.h
+++ b/time/bits/types/struct_timespec.h
@@ -4,25 +4,30 @@ 
 
 #include <bits/types.h>
 #include <bits/endian.h>
+#include <bits/types/time_t.h>
 
 /* POSIX.1b structure for a time value.  This is like a `struct timeval' but
    has nanoseconds instead of microseconds.  */
 struct timespec
 {
+# ifdef __USE_TIME_BITS64
+  __time64_t tv_sec;		/* Seconds.  */
+# else
   __time_t tv_sec;		/* Seconds.  */
-#if __WORDSIZE == 64 \
+# endif
+# if __WORDSIZE == 64 \
   || (defined __SYSCALL_WORDSIZE && __SYSCALL_WORDSIZE == 64) \
-  || __TIMESIZE == 32
+	|| (__TIMESIZE == 32 && !defined __USE_TIME_BITS64)
   __syscall_slong_t tv_nsec;	/* Nanoseconds.  */
-#else
-# if __BYTE_ORDER == __BIG_ENDIAN
+# else
+#  if __BYTE_ORDER == __BIG_ENDIAN
   int: 32;           /* Padding.  */
   long int tv_nsec;  /* Nanoseconds.  */
-# else
+#  else
   long int tv_nsec;  /* Nanoseconds.  */
   int: 32;           /* Padding.  */
+#  endif
 # endif
-#endif
 };
 
 #endif
diff --git a/time/bits/types/struct_timeval.h b/time/bits/types/struct_timeval.h
index 70394ce886..15be3f4d7a 100644
--- a/time/bits/types/struct_timeval.h
+++ b/time/bits/types/struct_timeval.h
@@ -7,7 +7,12 @@ 
    microsecond but also has a range of years.  */
 struct timeval
 {
+# ifdef __USE_TIME_BITS64
+  __time64_t tv_sec;		/* Seconds.  */
+  __suseconds64_t tv_usec;	/* Microseconds.  */
+# else
   __time_t tv_sec;		/* Seconds.  */
   __suseconds_t tv_usec;	/* Microseconds.  */
+# endif
 };
 #endif
diff --git a/time/bits/types/time_t.h b/time/bits/types/time_t.h
index ab8287c6fe..84d67f6ac3 100644
--- a/time/bits/types/time_t.h
+++ b/time/bits/types/time_t.h
@@ -4,6 +4,10 @@ 
 #include <bits/types.h>
 
 /* Returned by `time'.  */
+#ifdef __USE_TIME_BITS64
+typedef __time64_t time_t;
+#else
 typedef __time_t time_t;
+#endif
 
 #endif
diff --git a/time/sys/time.h b/time/sys/time.h
index 21fa9ed451..d3bf1e6588 100644
--- a/time/sys/time.h
+++ b/time/sys/time.h
@@ -66,6 +66,16 @@  struct timezone
 extern int gettimeofday (struct timeval *__restrict __tv,
 			 void *__restrict __tz) __THROW __nonnull ((1));
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (gettimeofday, (struct timeval *__restrict __tv,
+                                          void *__restrict __tz),
+                           __gettimeofday64);
+# else
+# define gettimeofday __gettimeofday64
+# endif
+#endif
+
 #ifdef __USE_MISC
 /* Set the current time of day and timezone information.
    This call is restricted to the super-user.
@@ -76,12 +86,33 @@  extern int settimeofday (const struct timeval *__tv,
 			 const struct timezone *__tz)
      __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (settimeofday, (const struct timeval *__tv,
+                                          const struct timezone *__tz),
+                           __settimeofday64);
+# else
+# define settimeofday __settimeofday64
+# endif
+#endif
+
 /* Adjust the current time of day by the amount in DELTA.
    If OLDDELTA is not NULL, it is filled in with the amount
    of time adjustment remaining to be done from the last `adjtime' call.
    This call is restricted to the super-user.  */
 extern int adjtime (const struct timeval *__delta,
 		    struct timeval *__olddelta) __THROW;
+
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (adjtime, (const struct timeval *__delta,
+                                     struct timeval *__olddelta),
+                           __adjtime64);
+# else
+# define adjtime __adjtime64
+# endif
+#endif
+
 #endif
 
 
@@ -123,6 +154,16 @@  typedef int __itimer_which_t;
 extern int getitimer (__itimer_which_t __which,
 		      struct itimerval *__value) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (getitimer, (__itimer_which_t __which,
+                                       struct itimerval *__value),
+                           __getitimer64);
+# else
+# define getitimer __getitimer64
+# endif
+#endif
+
 /* Set the timer WHICH to *NEW.  If OLD is not NULL,
    set *OLD to the old value of timer WHICH.
    Returns 0 on success, -1 on errors.  */
@@ -130,19 +171,59 @@  extern int setitimer (__itimer_which_t __which,
 		      const struct itimerval *__restrict __new,
 		      struct itimerval *__restrict __old) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (setitimer, (__itimer_which_t __which,
+                                       const struct itimerval *__restrict __new,
+                                       struct itimerval *__restrict __old),
+                           __setitimer64);
+# else
+# define setitimer __setitimer64
+# endif
+#endif
+
 /* Change the access time of FILE to TVP[0] and the modification time of
    FILE to TVP[1].  If TVP is a null pointer, use the current time instead.
    Returns 0 on success, -1 on errors.  */
 extern int utimes (const char *__file, const struct timeval __tvp[2])
      __THROW __nonnull ((1));
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (utimes, (const char *__file,
+                                    const struct timeval __tvp[2]),
+                           __utimes64);
+# else
+# define utimes __utimes64
+# endif
+#endif
+
 #ifdef __USE_MISC
 /* Same as `utimes', but does not follow symbolic links.  */
 extern int lutimes (const char *__file, const struct timeval __tvp[2])
      __THROW __nonnull ((1));
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (lutimes, (const char *__file,
+                                     const struct timeval __tvp[2]),
+                           __lutimes64);
+#  else
+#   define lutimes __lutimes64
+#  endif
+# endif
+
 /* Same as `utimes', but takes an open file descriptor instead of a name.  */
 extern int futimes (int __fd, const struct timeval __tvp[2]) __THROW;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (futimes, (int __fd, const struct timeval __tvp[2]),
+                           __futimes64);
+#  else
+#   define futimes __futimes64
+#  endif
+# endif
 #endif
 
 #ifdef __USE_GNU
@@ -151,6 +232,16 @@  extern int futimes (int __fd, const struct timeval __tvp[2]) __THROW;
    the current time instead.  Returns 0 on success, -1 on errors.  */
 extern int futimesat (int __fd, const char *__file,
 		      const struct timeval __tvp[2]) __THROW;
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (futimesat, (int __fd, const char *__file,
+                                       const struct timeval __tvp[2]),
+                           __futimesat64);
+#  else
+#   define futimesat __futimesat64
+#  endif
+# endif
 #endif
 
 
diff --git a/time/time.h b/time/time.h
index 015bc1c7f3..9a74f01b2f 100644
--- a/time/time.h
+++ b/time/time.h
@@ -74,13 +74,37 @@  extern clock_t clock (void) __THROW;
 /* Return the current time and put it in *TIMER if TIMER is not NULL.  */
 extern time_t time (time_t *__timer) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern time_t __REDIRECT_NTH (time, (time_t *__timer), __time64);
+# else
+# define time __time64
+# endif
+#endif
+
 /* Return the difference between TIME1 and TIME0.  */
 extern double difftime (time_t __time1, time_t __time0)
      __THROW __attribute__ ((__const__));
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern double __REDIRECT_NTH (difftime, (time_t __time1, time_t __time0),
+                              __difftime64);
+# else
+# define difftime __difftime64
+# endif
+#endif
+
 /* Return the `time_t' representation of TP and normalize TP.  */
 extern time_t mktime (struct tm *__tp) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern time_t __REDIRECT_NTH (mktime, (struct tm *__tp), __mktime64);
+# else
+# define mktime __mktime64
+# endif
+#endif
 
 /* Format TP into S according to FORMAT.
    Write no more than MAXSIZE characters and return the number
@@ -118,6 +142,14 @@  extern char *strptime_l (const char *__restrict __s,
    in Universal Coordinated Time (aka Greenwich Mean Time).  */
 extern struct tm *gmtime (const time_t *__timer) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern struct tm*__REDIRECT_NTH (gmtime, (const time_t *__timer), __gmtime64);
+# else
+# define gmtime __gmtime64
+# endif
+#endif
+
 /* Return the `struct tm' representation
    of *TIMER in the local timezone.  */
 extern struct tm *localtime (const time_t *__timer) __THROW;
@@ -128,6 +160,16 @@  extern struct tm *localtime (const time_t *__timer) __THROW;
 extern struct tm *gmtime_r (const time_t *__restrict __timer,
 			    struct tm *__restrict __tp) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern struct tm*__REDIRECT_NTH (gmtime_r, (const time_t *__restrict __timer,
+                                            struct tm *__restrict __tp),
+                                 __gmtime64_r);
+# else
+# define gmtime_r __gmtime64_r
+# endif
+#endif
+
 /* Return the `struct tm' representation of *TIMER in local time,
    using *TP to store the result.  */
 extern struct tm *localtime_r (const time_t *__restrict __timer,
@@ -141,6 +183,14 @@  extern char *asctime (const struct tm *__tp) __THROW;
 /* Equivalent to `asctime (localtime (timer))'.  */
 extern char *ctime (const time_t *__timer) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern char *__REDIRECT_NTH (ctime, (const time_t *__timer), __ctime64);
+# else
+# define ctime __ctime64
+# endif
+#endif
+
 #if defined __USE_POSIX || __GLIBC_USE (ISOC2X)
 /* Reentrant versions of the above functions.  */
 
@@ -152,6 +202,16 @@  extern char *asctime_r (const struct tm *__restrict __tp,
 /* Equivalent to `asctime_r (localtime_r (timer, *TMP*), buf)'.  */
 extern char *ctime_r (const time_t *__restrict __timer,
 		      char *__restrict __buf) __THROW;
+
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern char *__REDIRECT_NTH (ctime_r, (const time_t *__restrict __timer,
+                                       char *__restrict __buf), __ctime64_r);
+# else
+# define ctime_r __ctime64_r
+# endif
+#endif
+
 #endif	/* POSIX || C2X */
 
 
@@ -189,6 +249,14 @@  extern long int timezone;
 /* Like `mktime', but for TP represents Universal Time, not local time.  */
 extern time_t timegm (struct tm *__tp) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern time_t __REDIRECT_NTH (timegm, (struct tm *__tp), __timegm64);
+# else
+# define timegm __timegm64
+# endif
+#endif
+
 /* Another name for `mktime'.  */
 extern time_t timelocal (struct tm *__tp) __THROW;
 
@@ -205,17 +273,54 @@  extern int dysize (int __year) __THROW  __attribute__ ((__const__));
 extern int nanosleep (const struct timespec *__requested_time,
 		      struct timespec *__remaining);
 
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT)
+extern int __REDIRECT (nanosleep, (const struct timespec *__requested_time,
+                                   struct timespec *__remaining),
+                       __nanosleep64);
+#  else
+#   define nanosleep __nanosleep64
+#  endif
+# endif
 
 /* Get resolution of clock CLOCK_ID.  */
 extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (clock_getres, (clockid_t __clock_id,
+                                          struct timespec *__res),
+                           __clock_getres64);
+# else
+# define clock_getres __clock_getres64
+# endif
+#endif
+
 /* Get current value of clock CLOCK_ID and store it in TP.  */
 extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (clock_gettime, (clockid_t __clock_id, struct
+                                           timespec *__tp), __clock_gettime64);
+# else
+# define clock_gettime __clock_gettime64
+# endif
+#endif
+
 /* Set clock CLOCK_ID to value TP.  */
 extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
      __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (clock_settime, (clockid_t __clock_id, const struct
+                                           timespec *__tp), __clock_settime64);
+# else
+# define clock_settime __clock_settime64
+# endif
+#endif
+
 # ifdef __USE_XOPEN2K
 /* High-resolution sleep with the specified clock.
 
@@ -225,6 +330,17 @@  extern int clock_nanosleep (clockid_t __clock_id, int __flags,
 			    const struct timespec *__req,
 			    struct timespec *__rem);
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT)
+extern int __REDIRECT (clock_nanosleep, (clockid_t __clock_id, int __flags,
+                                         const struct timespec *__req,
+                                         struct timespec *__rem),
+                       __clock_nanosleep_time64);
+# else
+# define clock_nanosleep __clock_nanosleep_time64
+# endif
+#endif
+
 /* Return clock ID for CPU-time clock.  */
 extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __THROW;
 # endif
@@ -243,10 +359,31 @@  extern int timer_settime (timer_t __timerid, int __flags,
 			  const struct itimerspec *__restrict __value,
 			  struct itimerspec *__restrict __ovalue) __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (timer_settime, (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue),
+                          __timer_settime64);
+# else
+# define timer_settime __timer_settime64
+# endif
+#endif
+
 /* Get current value of timer TIMERID and store it in VALUE.  */
 extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
      __THROW;
 
+#ifdef __USE_TIME_BITS64
+# if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (timer_gettime, (timer_t __timerid,
+                                           struct itimerspec *__value),
+                           __timer_gettime64) __nonnull ((1));
+# else
+# define timer_gettime __timer_gettime64
+# endif
+#endif
+
 /* Get expiration overrun for timer TIMERID.  */
 extern int timer_getoverrun (timer_t __timerid) __THROW;
 #endif
@@ -256,6 +393,15 @@  extern int timer_getoverrun (timer_t __timerid) __THROW;
 /* Set TS to calendar time based in time base BASE.  */
 extern int timespec_get (struct timespec *__ts, int __base)
      __THROW __nonnull ((1));
+
+# ifdef __USE_TIME_BITS64
+#  if defined(__REDIRECT_NTH)
+extern int __REDIRECT_NTH (timespec_get, (struct timespec *__ts, int __base),
+                           __timespec_get64);
+#  else
+#  define timespec_get __timespec_get64
+#  endif
+# endif
 #endif