From 73215359e184d96b415e87b585a4396b5bd0936c Mon Sep 17 00:00:00 2001 From: Lukasz Majewski Date: Fri, 6 Dec 2019 15:39:31 +0100 Subject: [PATCH] y2038: Support for Y2038 safe time on 32 bit systems The time_t type is now Y2038 safe, which means that it is aliased to __time64_t when __USE_TIME_BITS64 is defined or __time_t otherwise. On the contrary the __time_t for 32 bit systems is only 32 bit, so for Y2038 safe system it must be 64 bit (as is time_t) This patch introduces the Y2038 specific code to make clock_settime/ __clock_settime64 Y2038 safe on 32 bit systems. This goal is achieved by using aliasing to clock_settime names when __USE_TIME_BITS64 is defined. As a result user programs call 64 bit versions of functions (i.e. __clock_settime64 instead of __clock_settime), which must have been globally visible for this purpose - for non Y2038 safe code those are hidden in glibc. Additionally this patch also converts following syscalls to be Y2038: - 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 - clock_adjtime64 - adjtime - adjtimex - ntp_gettime - ntp_gettimex - ntp_adjtime - just alias to ___adjtimex64 function - *stat* conversion (WIP) - Adhemerval Zanella - https://patchwork.ozlabs.org/project/glibc/list/?series=191904 - 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 TO DO: - aio_suspend () --- 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 | 10 ++ posix/Versions | 2 + posix/sched.h | 9 ++ posix/sys/wait.h | 10 ++ resource/Versions | 1 + resource/sys/resource.h | 10 ++ rt/Versions | 6 ++ rt/mqueue.h | 25 +++++ signal/Versions | 3 + signal/signal.h | 12 +++ socket/sys/socket.h | 11 ++ sysdeps/nptl/pthread.h | 94 ++++++++++++++++++ sysdeps/pthread/semaphore.h | 23 +++++ 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 | 23 +++++ 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 | 138 ++++++++++++++++++++++++++ 36 files changed, 762 insertions(+), 9 deletions(-) diff --git a/include/features.h b/include/features.h index f3e62d3362b..c639c044b46 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 + +#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 ee468055ff1..c0e401c39b7 100644 --- a/io/Versions +++ b/io/Versions @@ -141,5 +141,7 @@ libc { __file_change_detection_for_stat; __file_change_detection_for_path; __file_change_detection_for_fp; + __ppoll64; + __utime64; } } diff --git a/io/sys/poll.h b/io/sys/poll.h index 857be0f5ac6..4a725ed18ec 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 69e333656a4..6fa55348525 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 /* To allow the `struct stat' structure and the file type `mode_t' diff --git a/io/utime.h b/io/utime.h index 07659016aba..c3e7e5fce18 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 be5050468b2..5389fb0f345 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 95666f65489..fb30af20790 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 29d011c2d57..779a6e81b63 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 aed118e7173..0425dfb28db 100644 --- a/nptl/Versions +++ b/nptl/Versions @@ -304,5 +304,15 @@ libpthread { __pthread_barrier_init; __pthread_barrier_wait; __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; } } diff --git a/posix/Versions b/posix/Versions index 7d06a6d0c0d..ef93ab78fad 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; } } diff --git a/posix/sched.h b/posix/sched.h index 60c9c3c710f..0d9cbc5bb23 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 a42e16c1b06..057e5d30f58 100644 --- a/posix/sys/wait.h +++ b/posix/sys/wait.h @@ -152,6 +152,16 @@ extern __pid_t wait3 (int *__stat_loc, int __options, /* 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/resource/Versions b/resource/Versions index d6c2ccee1bc..96a757532f3 100644 --- a/resource/Versions +++ b/resource/Versions @@ -24,5 +24,6 @@ libc { } GLIBC_PRIVATE { __getrlimit; + __getrusage64; } } diff --git a/resource/sys/resource.h b/resource/sys/resource.h index 4edafb50d57..98f05cf1c43 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 84d1345420d..81fdaf82e60 100644 --- a/rt/Versions +++ b/rt/Versions @@ -1,4 +1,10 @@ librt { + GLIBC_PRIVATE { + __timer_gettime64; + __timer_settime64; + __mq_timedsend_time64; + __mq_timedreceive_time64; + } GLIBC_2.1 { # AIO functions. aio_cancel; aio_cancel64; aio_error; aio_error64; aio_fsync; aio_fsync64; diff --git a/rt/mqueue.h b/rt/mqueue.h index a2a2aa17718..e6b8641c62b 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 a915ef400f4..d653b5de099 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 effe3d698f2..564820e3662 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 7780c00ecbd..2273c52cdf9 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 d4194da776b..5d4918f83c3 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. @@ -905,6 +928,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 @@ -912,6 +946,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. */ @@ -927,6 +973,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 @@ -934,6 +991,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. */ @@ -1015,6 +1084,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 @@ -1028,6 +1109,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 436d21cb08a..6a6055fc3a3 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/unix/sysv/linux/Versions b/sysdeps/unix/sysv/linux/Versions index c35f783e2a4..11bdef33437 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 e0962744e1c..7168ef1948a 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 9adb0bcc60d..f1d71ea9c4d 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 0ae60b65bdb..cd252476a7b 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 6979b86b722..b5271152bba 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 4c797e25ce7..f81f648960f 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 c70cfa582c2..f39c153b867 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 4ede2dd6ef0..b26c17914c0 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 6c58742c4f3..8d74911e55d 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 df22ac7f6a1..16e76d05ce6 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,7 @@ libc { # same as clock_gettime; used in other libraries __clock_gettime; __clock_gettime64; + __adjtime64; + ___adjtimex64; } } diff --git a/time/bits/types/struct_timespec.h b/time/bits/types/struct_timespec.h index d11c69cfd32..3e158ad899e 100644 --- a/time/bits/types/struct_timespec.h +++ b/time/bits/types/struct_timespec.h @@ -4,25 +4,30 @@ #include #include +#include /* 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 70394ce886d..15be3f4d7a4 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 ab8287c6fe5..84d67f6ac34 100644 --- a/time/bits/types/time_t.h +++ b/time/bits/types/time_t.h @@ -4,6 +4,10 @@ #include /* 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 21fa9ed4518..d3bf1e6588b 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 015bc1c7f3b..999a72ab937 100644 --- a/time/time.h +++ b/time/time.h @@ -78,9 +78,25 @@ extern time_t time (time_t *__timer) __THROW; 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 +134,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 +152,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 +175,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 +194,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 +241,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 +265,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 +322,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 +351,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 +385,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