Message ID | 20191017000829.4462-1-alistair.francis@wdc.com |
---|---|
State | New |
Headers | show |
Series | sysdeps/nanosleep: Use clock_nanosleep_time64 if avaliable | expand |
Hi Alistair, > The nanosleep syscall is not supported on newer 32-bit platforms (such > as RV32). To fix this issue let's use clock_nanosleep_time64 if it is > avaliable. > > Let's use CLOCK_REALTIME when calling clock_nanosleep_time64 as the > Linux specification says: > "POSIX.1 specifies that nanosleep() should measure time against the > CLOCK_REALTIME clock. However, Linux measures the time using the > CLOCK_MONOTONIC clock. This probably does not matter, since the > POSIX.1 specification for clock_settime(2) says that discontinuous > changes in CLOCK_REALTIME should not affect nanosleep()" > > Signed-off-by: Alistair Francis <alistair.francis@wdc.com> > > * nptl/thrd_sleep.c: Use clock_nanosleep_time64 instead of > nanosleep. > * sysdeps/unix/sysv/linux/nanosleep.c: Likewise. > * sysdeps/unix/sysv/linux/clock_nanosleep.c: Likewise. > * sysdeps/unix/sysv/linux/nanosleep_nocancel.c: Likewise. > --- > This was patch was tested with RV32 and RV64 and build tested using ^^^^ - this was is not needed, IMHO > the glibc test scripts. > > @Lukasz do you think you could run this through your y2038 testing? I can run it via those tests. > Otherwise I'll look at setting up the same tests that you have. I think that it would be beneficial if you could setup the meta-y2038 [1] for RISC-V. From what I can see here: https://github.com/riscv/meta-riscv/blob/master/conf/machine/qemuriscv32.conf There is already available qemuriscv32.conf, so maybe you could add this platform to [1]? In that way we would have relevant archs (arm 32 bit, rv32) available for testing/validation in one place? (The other benefit is that you could run xcheck with test-wrapper='/opt/Y2038/glibc/src/scripts/cross-test-ssh.sh for risc-v). Links: [1] - https://github.com/lmajewski/meta-y2038 > > include/time.h | 20 ++++++ > nptl/thrd_sleep.c | 69 +++++++++++++++++-- > sysdeps/unix/sysv/linux/clock_nanosleep.c | 72 > ++++++++++++++++++-- sysdeps/unix/sysv/linux/nanosleep.c | > 64 ++++++++++++++++- sysdeps/unix/sysv/linux/nanosleep_nocancel.c | > 64 ++++++++++++++++- 5 files changed, 276 insertions(+), 13 > deletions(-) > > diff --git a/include/time.h b/include/time.h > index d93b16a7810..0e703f87cef 100644 > --- a/include/time.h > +++ b/include/time.h > @@ -174,6 +174,26 @@ libc_hidden_proto (__difftime64) > > extern double __difftime (time_t time1, time_t time0); > > +#if __TIMESIZE == 64 > +# define __thrd_sleep_time64 thrd_sleep > +# define __clock_nanosleep_time64 __clock_nanosleep > +# define __nanosleep_time64 __nanosleep > +# define __nanosleep_nocancel_time64 __nanosleep_nocancel > +#else > +extern int __thrd_sleep_time64 (const struct __timespec64* > time_point, > + struct __timespec64* remaining); > +libc_hidden_proto (__thrd_sleep_time64) > +extern int __clock_nanosleep_time64 (clockid_t clock_id, > + int flags, const struct > __timespec64 *req, > + struct __timespec64 *rem); > +libc_hidden_proto (__clock_nanosleep_time64) > +extern int __nanosleep_time64 (const struct __timespec64 > *requested_time, > + struct __timespec64 *remaining); > +libc_hidden_proto (__nanosleep_time64) > +extern int __nanosleep_nocancel_time64 (const struct __timespec64 > *requested_time, > + struct __timespec64 > *remaining); +libc_hidden_proto (__nanosleep_nocancel_time64) > +#endif > > /* Use in the clock_* functions. Size of the field representing the > actual clock ID. */ > diff --git a/nptl/thrd_sleep.c b/nptl/thrd_sleep.c It is a pitty that we cannot reuse the code from e.g. clock_nanosleep in the thrd_sleep.c. I guess that it is because the ntpl is a separate library... > index 2e185dd748e..bd9373b1f61 100644 > --- a/nptl/thrd_sleep.c > +++ b/nptl/thrd_sleep.c > @@ -22,18 +22,79 @@ > #include "thrd_priv.h" > > int > -thrd_sleep (const struct timespec* time_point, struct timespec* > remaining) +__thrd_sleep_time64 (const struct __timespec64* > time_point, struct __timespec64* remaining) { > INTERNAL_SYSCALL_DECL (err); > - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, > remaining); > + int ret = -1; > + > +#ifdef __ASSUME_TIME64_SYSCALLS > +# ifndef __NR_clock_nanosleep_time64 > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > +# endif > + ret = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > CLOCK_REALTIME, > + 0, time_point, remaining); > +#else > +# ifdef __NR_clock_nanosleep_time64 > + long int ret_64; > + > + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > CLOCK_REALTIME, > + 0, time_point, remaining); > + > + if (ret_64 == 0 || errno != ENOSYS) > + ret = ret_64; > +# endif /* __NR_clock_nanosleep_time64 */ > + if (ret < 0) > + { > + struct timespec tp32, tr32; > + > + if (! in_time_t_range (time_point->tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + tp32 = valid_timespec64_to_timespec (*time_point); > + ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, &tp32, &tr32); > + > + if ((ret == 0 || errno != ENOSYS) && remaining) > + *remaining = valid_timespec_to_timespec64 (tr32); > + } > +#endif /* __ASSUME_TIME64_SYSCALLS */ > + > if (INTERNAL_SYSCALL_ERROR_P (ret, err)) > { > /* C11 states thrd_sleep function returns -1 if it has been > interrupted > - by a signal, or a negative value if it fails. */ > + by a signal, or a negative value if it fails. */ > ret = INTERNAL_SYSCALL_ERRNO (ret, err); > if (ret == EINTR) > - return -1; > + return -1; > return -2; > } > return 0; > } > + > +#if __TIMESIZE != 64 > +int > +thrd_sleep (const struct timespec* time_point, struct timespec* > remaining) +{ > + int ret; > + struct __timespec64 tp64, tr64; > + > + tp64 = valid_timespec_to_timespec64 (*time_point); > + ret = __thrd_sleep_time64 (&tp64, &tr64); > + > + if (ret == 0 || errno != ENOSYS) > + { > + if (! in_time_t_range (tr64.tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + if (remaining) > + *remaining = valid_timespec64_to_timespec (tr64); > + } > + > + return ret; > +} > +#endif > diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c > b/sysdeps/unix/sysv/linux/clock_nanosleep.c index > 1f240b8720a..2f536ae42b3 100644 --- > a/sysdeps/unix/sysv/linux/clock_nanosleep.c +++ > b/sysdeps/unix/sysv/linux/clock_nanosleep.c @@ -26,9 +26,11 @@ > /* We can simply use the syscall. The CPU clocks are not supported > with this function. */ > int > -__clock_nanosleep (clockid_t clock_id, int flags, const struct > timespec *req, > - struct timespec *rem) > +__clock_nanosleep_time64 (clockid_t clock_id, int flags, const > struct __timespec64 *req, > + struct __timespec64 *rem) > { > + int r = -1; > + > if (clock_id == CLOCK_THREAD_CPUTIME_ID) > return EINVAL; > if (clock_id == CLOCK_PROCESS_CPUTIME_ID) > @@ -37,12 +39,72 @@ __clock_nanosleep (clockid_t clock_id, int flags, > const struct timespec *req, /* If the call is interrupted by a signal > handler or encounters an error, it returns a positive value similar > to errno. */ INTERNAL_SYSCALL_DECL (err); > - int r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, clock_id, > flags, > - req, rem); > + > +#ifdef __ASSUME_TIME64_SYSCALLS > +# ifndef __NR_clock_nanosleep_time64 > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > +# endif > + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, clock_id, > + flags, req, rem); > +#else > +# ifdef __NR_clock_nanosleep_time64 > + long int ret_64; > + > + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > clock_id, > + flags, req, rem); > + > + if (ret_64 == 0 || errno != ENOSYS) > + r = ret_64; > +# endif /* __NR_clock_nanosleep_time64 */ > + if (r < 0) > + { > + struct timespec ts32, tr32; > + > + if (! in_time_t_range (req->tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + ts32 = valid_timespec64_to_timespec (*req); > + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, &ts32, > &tr32); + > + if ((r == 0 || errno != ENOSYS) && rem) > + *rem = valid_timespec_to_timespec64 (tr32); > + } > +#endif /* __ASSUME_TIME64_SYSCALLS */ > + > return (INTERNAL_SYSCALL_ERROR_P (r, err) > - ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); > + ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); > } > > +#if __TIMESIZE != 64 > +int > +__clock_nanosleep (clockid_t clock_id, int flags, const struct > timespec *req, > + struct timespec *rem) > +{ > + int r; > + struct __timespec64 treq64, trem64; > + > + treq64 = valid_timespec_to_timespec64 (*req); > + r = __clock_nanosleep_time64 (clock_id, flags, &treq64, &trem64); > + > + if (r == 0 || errno != ENOSYS) > + { > + if (! in_time_t_range (trem64.tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + if (rem) > + *rem = valid_timespec64_to_timespec (trem64); > + } > + > + return r; > +} > +#endif > + > versioned_symbol (libc, __clock_nanosleep, clock_nanosleep, > GLIBC_2_17); /* clock_nanosleep moved to libc in version 2.17; > old binaries may expect the symbol version it had in librt. */ > diff --git a/sysdeps/unix/sysv/linux/nanosleep.c > b/sysdeps/unix/sysv/linux/nanosleep.c index 6787909248f..11fc6ea051b > 100644 --- a/sysdeps/unix/sysv/linux/nanosleep.c > +++ b/sysdeps/unix/sysv/linux/nanosleep.c > @@ -22,10 +22,70 @@ > > /* Pause execution for a number of nanoseconds. */ > int > +__nanosleep_time64 (const struct __timespec64 *requested_time, > + struct __timespec64 *remaining) > +{ > +#if defined(__ASSUME_TIME64_SYSCALLS) > +# ifndef __NR_clock_nanosleep_time64 > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > +# endif > + return SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, > + requested_time, remaining); > +#else > +# ifdef __NR_clock_nanosleep_time64 > + long int ret_64; > + > + ret_64 = SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, > + requested_time, remaining); > + > + if (ret_64 == 0 || errno != ENOSYS) > + return ret_64; > +# endif /* __NR_clock_nanosleep_time64 */ > + int ret; > + struct timespec ts32, tr32; > + > + if (! in_time_t_range (requested_time->tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + ts32 = valid_timespec64_to_timespec (*requested_time); > + ret = SYSCALL_CANCEL (nanosleep, &ts32, &tr32); > + > + if ((ret == 0 || errno != ENOSYS) && remaining) > + *remaining = valid_timespec_to_timespec64 (tr32); > + > + return ret; > +#endif /* __ASSUME_TIME64_SYSCALLS */ > +} > + > +#if __TIMESIZE != 64 > +int > __nanosleep (const struct timespec *requested_time, > - struct timespec *remaining) > + struct timespec *remaining) > { > - return SYSCALL_CANCEL (nanosleep, requested_time, remaining); > + int r; > + struct __timespec64 treq64, trem64; > + > + treq64 = valid_timespec_to_timespec64 (*requested_time); > + r = __nanosleep_time64 (&treq64, &trem64); > + > + if (r == 0 || errno != ENOSYS) > + { > + if (! in_time_t_range (trem64.tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + if (remaining) > + *remaining = valid_timespec64_to_timespec (trem64); > + } > + > + return r; > } > +#endif > + > hidden_def (__nanosleep) > weak_alias (__nanosleep, nanosleep) > diff --git a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c > b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c index > d6442bf4f7f..52a9df5a8f7 100644 --- > a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c +++ > b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c @@ -20,10 +20,70 @@ > #include <sysdep-cancel.h> > #include <not-cancel.h> > > +int > +__nanosleep_nocancel_time64 (const struct __timespec64 > *requested_time, > + struct __timespec64 *remaining) > +{ > +#ifdef __ASSUME_TIME64_SYSCALLS > +# ifndef __NR_clock_nanosleep_time64 > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > +# endif > + return INLINE_SYSCALL_CALL (clock_nanosleep_time64, > CLOCK_REALTIME, 0, > + requested_time, remaining); > +#else > +# ifdef __NR_clock_nanosleep_time64 > + long int ret_64; > + > + ret_64 = INLINE_SYSCALL_CALL (clock_nanosleep_time64, > CLOCK_REALTIME, 0, > + requested_time, remaining); > + > + if (ret_64 == 0 || errno != ENOSYS) > + return ret_64; > +# endif /* __NR_clock_nanosleep_time64 */ > + int ret; > + struct timespec ts32, tr32; > + > + if (! in_time_t_range (requested_time->tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + ts32 = valid_timespec64_to_timespec (*requested_time); > + ret = INLINE_SYSCALL_CALL (nanosleep, &ts32, &tr32); > + > + if (ret == 0 || errno != ENOSYS) > + *remaining = valid_timespec_to_timespec64 (tr32); > + > + return ret; > +#endif /* __ASSUME_TIME64_SYSCALLS */ > +} > + > +#if __TIMESIZE != 64 > int > __nanosleep_nocancel (const struct timespec *requested_time, > - struct timespec *remaining) > + struct timespec *remaining) > { > - return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining); > + int ret; > + struct __timespec64 treq64, trem64; > + > + treq64 = valid_timespec_to_timespec64 (*requested_time); > + ret = __nanosleep_nocancel_time64 (&treq64, &trem64); > + > + if (ret == 0 || errno != ENOSYS) > + { > + if (! in_time_t_range (trem64.tv_sec)) > + { > + __set_errno (EOVERFLOW); > + return -1; > + } > + > + if (remaining) > + *remaining = valid_timespec64_to_timespec (trem64); > + } > + > + return ret; > } > +#endif > + > hidden_def (__nanosleep_nocancel) 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
On Wed, 16 Oct 2019, Alistair Francis wrote: > diff --git a/nptl/thrd_sleep.c b/nptl/thrd_sleep.c > index 2e185dd748e..bd9373b1f61 100644 > --- a/nptl/thrd_sleep.c > +++ b/nptl/thrd_sleep.c > @@ -22,18 +22,79 @@ > #include "thrd_priv.h" > > int > -thrd_sleep (const struct timespec* time_point, struct timespec* remaining) > +__thrd_sleep_time64 (const struct __timespec64* time_point, struct __timespec64* remaining) > { > INTERNAL_SYSCALL_DECL (err); > - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, remaining); > + int ret = -1; > + > +#ifdef __ASSUME_TIME64_SYSCALLS I'd prefer any file using __ASSUME_* macros to include <kernel-features.h> explicitly. I think you're getting it here indirectly via sysdep-cancel.h which includes sysdep.h, but I don't think it should be defined as part of the API of sysdep-cancel.h that it must include kernel-features.h, and until we move __ASSUME_* to being 0/1 rather than undefined/defined, a missing include would just quietly mean the code isn't built as intended. The same applies to any other files with __ASSUME_* uses added in this or other patches.
On Thu, Oct 17, 2019 at 8:39 AM Joseph Myers <joseph@codesourcery.com> wrote: > > On Wed, 16 Oct 2019, Alistair Francis wrote: > > > diff --git a/nptl/thrd_sleep.c b/nptl/thrd_sleep.c > > index 2e185dd748e..bd9373b1f61 100644 > > --- a/nptl/thrd_sleep.c > > +++ b/nptl/thrd_sleep.c > > @@ -22,18 +22,79 @@ > > #include "thrd_priv.h" > > > > int > > -thrd_sleep (const struct timespec* time_point, struct timespec* remaining) > > +__thrd_sleep_time64 (const struct __timespec64* time_point, struct __timespec64* remaining) > > { > > INTERNAL_SYSCALL_DECL (err); > > - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, remaining); > > + int ret = -1; > > + > > +#ifdef __ASSUME_TIME64_SYSCALLS > > I'd prefer any file using __ASSUME_* macros to include <kernel-features.h> > explicitly. I think you're getting it here indirectly via > sysdep-cancel.h which includes sysdep.h, but I don't think it should be > defined as part of the API of sysdep-cancel.h that it must include > kernel-features.h, and until we move __ASSUME_* to being 0/1 rather than > undefined/defined, a missing include would just quietly mean the code > isn't built as intended. Fixed! Alistair > > The same applies to any other files with __ASSUME_* uses added in this or > other patches. > > -- > Joseph S. Myers > joseph@codesourcery.com
On Thu, Oct 17, 2019 at 1:56 AM Lukasz Majewski <lukma@denx.de> wrote: > > Hi Alistair, > > > The nanosleep syscall is not supported on newer 32-bit platforms (such > > as RV32). To fix this issue let's use clock_nanosleep_time64 if it is > > avaliable. > > > > Let's use CLOCK_REALTIME when calling clock_nanosleep_time64 as the > > Linux specification says: > > "POSIX.1 specifies that nanosleep() should measure time against the > > CLOCK_REALTIME clock. However, Linux measures the time using the > > CLOCK_MONOTONIC clock. This probably does not matter, since the > > POSIX.1 specification for clock_settime(2) says that discontinuous > > changes in CLOCK_REALTIME should not affect nanosleep()" > > > > Signed-off-by: Alistair Francis <alistair.francis@wdc.com> > > > > * nptl/thrd_sleep.c: Use clock_nanosleep_time64 instead of > > nanosleep. > > * sysdeps/unix/sysv/linux/nanosleep.c: Likewise. > > * sysdeps/unix/sysv/linux/clock_nanosleep.c: Likewise. > > * sysdeps/unix/sysv/linux/nanosleep_nocancel.c: Likewise. > > --- > > This was patch was tested with RV32 and RV64 and build tested using > ^^^^ - this was is not needed, IMHO > > > the glibc test scripts. > > > > @Lukasz do you think you could run this through your y2038 testing? > > I can run it via those tests. Thanks! My main concern is making sure this doesn't break other targets. > > > Otherwise I'll look at setting up the same tests that you have. > > I think that it would be beneficial if you could setup the meta-y2038 > [1] for RISC-V. > > From what I can see here: > https://github.com/riscv/meta-riscv/blob/master/conf/machine/qemuriscv32.conf Yep, OpenEmbedded supports RISC-V pretty well. > > There is already available qemuriscv32.conf, so maybe you could add > this platform to [1]? Yeah, I'm looking into it now. Alistair > > In that way we would have relevant archs (arm 32 bit, rv32) available > for testing/validation in one place? > (The other benefit is that you could run xcheck with > test-wrapper='/opt/Y2038/glibc/src/scripts/cross-test-ssh.sh for > risc-v). > > Links: > > [1] - https://github.com/lmajewski/meta-y2038 > > > > > include/time.h | 20 ++++++ > > nptl/thrd_sleep.c | 69 +++++++++++++++++-- > > sysdeps/unix/sysv/linux/clock_nanosleep.c | 72 > > ++++++++++++++++++-- sysdeps/unix/sysv/linux/nanosleep.c | > > 64 ++++++++++++++++- sysdeps/unix/sysv/linux/nanosleep_nocancel.c | > > 64 ++++++++++++++++- 5 files changed, 276 insertions(+), 13 > > deletions(-) > > > > diff --git a/include/time.h b/include/time.h > > index d93b16a7810..0e703f87cef 100644 > > --- a/include/time.h > > +++ b/include/time.h > > @@ -174,6 +174,26 @@ libc_hidden_proto (__difftime64) > > > > extern double __difftime (time_t time1, time_t time0); > > > > +#if __TIMESIZE == 64 > > +# define __thrd_sleep_time64 thrd_sleep > > +# define __clock_nanosleep_time64 __clock_nanosleep > > +# define __nanosleep_time64 __nanosleep > > +# define __nanosleep_nocancel_time64 __nanosleep_nocancel > > +#else > > +extern int __thrd_sleep_time64 (const struct __timespec64* > > time_point, > > + struct __timespec64* remaining); > > +libc_hidden_proto (__thrd_sleep_time64) > > +extern int __clock_nanosleep_time64 (clockid_t clock_id, > > + int flags, const struct > > __timespec64 *req, > > + struct __timespec64 *rem); > > +libc_hidden_proto (__clock_nanosleep_time64) > > +extern int __nanosleep_time64 (const struct __timespec64 > > *requested_time, > > + struct __timespec64 *remaining); > > +libc_hidden_proto (__nanosleep_time64) > > +extern int __nanosleep_nocancel_time64 (const struct __timespec64 > > *requested_time, > > + struct __timespec64 > > *remaining); +libc_hidden_proto (__nanosleep_nocancel_time64) > > +#endif > > > > /* Use in the clock_* functions. Size of the field representing the > > actual clock ID. */ > > diff --git a/nptl/thrd_sleep.c b/nptl/thrd_sleep.c > > It is a pitty that we cannot reuse the code from e.g. clock_nanosleep > in the thrd_sleep.c. I guess that it is because the ntpl is a separate > library... > > > index 2e185dd748e..bd9373b1f61 100644 > > --- a/nptl/thrd_sleep.c > > +++ b/nptl/thrd_sleep.c > > @@ -22,18 +22,79 @@ > > #include "thrd_priv.h" > > > > int > > -thrd_sleep (const struct timespec* time_point, struct timespec* > > remaining) +__thrd_sleep_time64 (const struct __timespec64* > > time_point, struct __timespec64* remaining) { > > INTERNAL_SYSCALL_DECL (err); > > - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, > > remaining); > > + int ret = -1; > > + > > +#ifdef __ASSUME_TIME64_SYSCALLS > > +# ifndef __NR_clock_nanosleep_time64 > > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > > +# endif > > + ret = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > > CLOCK_REALTIME, > > + 0, time_point, remaining); > > +#else > > +# ifdef __NR_clock_nanosleep_time64 > > + long int ret_64; > > + > > + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > > CLOCK_REALTIME, > > + 0, time_point, remaining); > > + > > + if (ret_64 == 0 || errno != ENOSYS) > > + ret = ret_64; > > +# endif /* __NR_clock_nanosleep_time64 */ > > + if (ret < 0) > > + { > > + struct timespec tp32, tr32; > > + > > + if (! in_time_t_range (time_point->tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + tp32 = valid_timespec64_to_timespec (*time_point); > > + ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, &tp32, &tr32); > > + > > + if ((ret == 0 || errno != ENOSYS) && remaining) > > + *remaining = valid_timespec_to_timespec64 (tr32); > > + } > > +#endif /* __ASSUME_TIME64_SYSCALLS */ > > + > > if (INTERNAL_SYSCALL_ERROR_P (ret, err)) > > { > > /* C11 states thrd_sleep function returns -1 if it has been > > interrupted > > - by a signal, or a negative value if it fails. */ > > + by a signal, or a negative value if it fails. */ > > ret = INTERNAL_SYSCALL_ERRNO (ret, err); > > if (ret == EINTR) > > - return -1; > > + return -1; > > return -2; > > } > > return 0; > > } > > + > > +#if __TIMESIZE != 64 > > +int > > +thrd_sleep (const struct timespec* time_point, struct timespec* > > remaining) +{ > > + int ret; > > + struct __timespec64 tp64, tr64; > > + > > + tp64 = valid_timespec_to_timespec64 (*time_point); > > + ret = __thrd_sleep_time64 (&tp64, &tr64); > > + > > + if (ret == 0 || errno != ENOSYS) > > + { > > + if (! in_time_t_range (tr64.tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + if (remaining) > > + *remaining = valid_timespec64_to_timespec (tr64); > > + } > > + > > + return ret; > > +} > > +#endif > > diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c > > b/sysdeps/unix/sysv/linux/clock_nanosleep.c index > > 1f240b8720a..2f536ae42b3 100644 --- > > a/sysdeps/unix/sysv/linux/clock_nanosleep.c +++ > > b/sysdeps/unix/sysv/linux/clock_nanosleep.c @@ -26,9 +26,11 @@ > > /* We can simply use the syscall. The CPU clocks are not supported > > with this function. */ > > int > > -__clock_nanosleep (clockid_t clock_id, int flags, const struct > > timespec *req, > > - struct timespec *rem) > > +__clock_nanosleep_time64 (clockid_t clock_id, int flags, const > > struct __timespec64 *req, > > + struct __timespec64 *rem) > > { > > + int r = -1; > > + > > if (clock_id == CLOCK_THREAD_CPUTIME_ID) > > return EINVAL; > > if (clock_id == CLOCK_PROCESS_CPUTIME_ID) > > @@ -37,12 +39,72 @@ __clock_nanosleep (clockid_t clock_id, int flags, > > const struct timespec *req, /* If the call is interrupted by a signal > > handler or encounters an error, it returns a positive value similar > > to errno. */ INTERNAL_SYSCALL_DECL (err); > > - int r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, clock_id, > > flags, > > - req, rem); > > + > > +#ifdef __ASSUME_TIME64_SYSCALLS > > +# ifndef __NR_clock_nanosleep_time64 > > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > > +# endif > > + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, clock_id, > > + flags, req, rem); > > +#else > > +# ifdef __NR_clock_nanosleep_time64 > > + long int ret_64; > > + > > + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, > > clock_id, > > + flags, req, rem); > > + > > + if (ret_64 == 0 || errno != ENOSYS) > > + r = ret_64; > > +# endif /* __NR_clock_nanosleep_time64 */ > > + if (r < 0) > > + { > > + struct timespec ts32, tr32; > > + > > + if (! in_time_t_range (req->tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + ts32 = valid_timespec64_to_timespec (*req); > > + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, &ts32, > > &tr32); + > > + if ((r == 0 || errno != ENOSYS) && rem) > > + *rem = valid_timespec_to_timespec64 (tr32); > > + } > > +#endif /* __ASSUME_TIME64_SYSCALLS */ > > + > > return (INTERNAL_SYSCALL_ERROR_P (r, err) > > - ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); > > + ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); > > } > > > > +#if __TIMESIZE != 64 > > +int > > +__clock_nanosleep (clockid_t clock_id, int flags, const struct > > timespec *req, > > + struct timespec *rem) > > +{ > > + int r; > > + struct __timespec64 treq64, trem64; > > + > > + treq64 = valid_timespec_to_timespec64 (*req); > > + r = __clock_nanosleep_time64 (clock_id, flags, &treq64, &trem64); > > + > > + if (r == 0 || errno != ENOSYS) > > + { > > + if (! in_time_t_range (trem64.tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + if (rem) > > + *rem = valid_timespec64_to_timespec (trem64); > > + } > > + > > + return r; > > +} > > +#endif > > + > > versioned_symbol (libc, __clock_nanosleep, clock_nanosleep, > > GLIBC_2_17); /* clock_nanosleep moved to libc in version 2.17; > > old binaries may expect the symbol version it had in librt. */ > > diff --git a/sysdeps/unix/sysv/linux/nanosleep.c > > b/sysdeps/unix/sysv/linux/nanosleep.c index 6787909248f..11fc6ea051b > > 100644 --- a/sysdeps/unix/sysv/linux/nanosleep.c > > +++ b/sysdeps/unix/sysv/linux/nanosleep.c > > @@ -22,10 +22,70 @@ > > > > /* Pause execution for a number of nanoseconds. */ > > int > > +__nanosleep_time64 (const struct __timespec64 *requested_time, > > + struct __timespec64 *remaining) > > +{ > > +#if defined(__ASSUME_TIME64_SYSCALLS) > > +# ifndef __NR_clock_nanosleep_time64 > > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > > +# endif > > + return SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, > > + requested_time, remaining); > > +#else > > +# ifdef __NR_clock_nanosleep_time64 > > + long int ret_64; > > + > > + ret_64 = SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, > > + requested_time, remaining); > > + > > + if (ret_64 == 0 || errno != ENOSYS) > > + return ret_64; > > +# endif /* __NR_clock_nanosleep_time64 */ > > + int ret; > > + struct timespec ts32, tr32; > > + > > + if (! in_time_t_range (requested_time->tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + ts32 = valid_timespec64_to_timespec (*requested_time); > > + ret = SYSCALL_CANCEL (nanosleep, &ts32, &tr32); > > + > > + if ((ret == 0 || errno != ENOSYS) && remaining) > > + *remaining = valid_timespec_to_timespec64 (tr32); > > + > > + return ret; > > +#endif /* __ASSUME_TIME64_SYSCALLS */ > > +} > > + > > +#if __TIMESIZE != 64 > > +int > > __nanosleep (const struct timespec *requested_time, > > - struct timespec *remaining) > > + struct timespec *remaining) > > { > > - return SYSCALL_CANCEL (nanosleep, requested_time, remaining); > > + int r; > > + struct __timespec64 treq64, trem64; > > + > > + treq64 = valid_timespec_to_timespec64 (*requested_time); > > + r = __nanosleep_time64 (&treq64, &trem64); > > + > > + if (r == 0 || errno != ENOSYS) > > + { > > + if (! in_time_t_range (trem64.tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + if (remaining) > > + *remaining = valid_timespec64_to_timespec (trem64); > > + } > > + > > + return r; > > } > > +#endif > > + > > hidden_def (__nanosleep) > > weak_alias (__nanosleep, nanosleep) > > diff --git a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c > > b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c index > > d6442bf4f7f..52a9df5a8f7 100644 --- > > a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c +++ > > b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c @@ -20,10 +20,70 @@ > > #include <sysdep-cancel.h> > > #include <not-cancel.h> > > > > +int > > +__nanosleep_nocancel_time64 (const struct __timespec64 > > *requested_time, > > + struct __timespec64 *remaining) > > +{ > > +#ifdef __ASSUME_TIME64_SYSCALLS > > +# ifndef __NR_clock_nanosleep_time64 > > +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep > > +# endif > > + return INLINE_SYSCALL_CALL (clock_nanosleep_time64, > > CLOCK_REALTIME, 0, > > + requested_time, remaining); > > +#else > > +# ifdef __NR_clock_nanosleep_time64 > > + long int ret_64; > > + > > + ret_64 = INLINE_SYSCALL_CALL (clock_nanosleep_time64, > > CLOCK_REALTIME, 0, > > + requested_time, remaining); > > + > > + if (ret_64 == 0 || errno != ENOSYS) > > + return ret_64; > > +# endif /* __NR_clock_nanosleep_time64 */ > > + int ret; > > + struct timespec ts32, tr32; > > + > > + if (! in_time_t_range (requested_time->tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + ts32 = valid_timespec64_to_timespec (*requested_time); > > + ret = INLINE_SYSCALL_CALL (nanosleep, &ts32, &tr32); > > + > > + if (ret == 0 || errno != ENOSYS) > > + *remaining = valid_timespec_to_timespec64 (tr32); > > + > > + return ret; > > +#endif /* __ASSUME_TIME64_SYSCALLS */ > > +} > > + > > +#if __TIMESIZE != 64 > > int > > __nanosleep_nocancel (const struct timespec *requested_time, > > - struct timespec *remaining) > > + struct timespec *remaining) > > { > > - return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining); > > + int ret; > > + struct __timespec64 treq64, trem64; > > + > > + treq64 = valid_timespec_to_timespec64 (*requested_time); > > + ret = __nanosleep_nocancel_time64 (&treq64, &trem64); > > + > > + if (ret == 0 || errno != ENOSYS) > > + { > > + if (! in_time_t_range (trem64.tv_sec)) > > + { > > + __set_errno (EOVERFLOW); > > + return -1; > > + } > > + > > + if (remaining) > > + *remaining = valid_timespec64_to_timespec (trem64); > > + } > > + > > + return ret; > > } > > +#endif > > + > > hidden_def (__nanosleep_nocancel) > > > > > 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 --git a/include/time.h b/include/time.h index d93b16a7810..0e703f87cef 100644 --- a/include/time.h +++ b/include/time.h @@ -174,6 +174,26 @@ libc_hidden_proto (__difftime64) extern double __difftime (time_t time1, time_t time0); +#if __TIMESIZE == 64 +# define __thrd_sleep_time64 thrd_sleep +# define __clock_nanosleep_time64 __clock_nanosleep +# define __nanosleep_time64 __nanosleep +# define __nanosleep_nocancel_time64 __nanosleep_nocancel +#else +extern int __thrd_sleep_time64 (const struct __timespec64* time_point, + struct __timespec64* remaining); +libc_hidden_proto (__thrd_sleep_time64) +extern int __clock_nanosleep_time64 (clockid_t clock_id, + int flags, const struct __timespec64 *req, + struct __timespec64 *rem); +libc_hidden_proto (__clock_nanosleep_time64) +extern int __nanosleep_time64 (const struct __timespec64 *requested_time, + struct __timespec64 *remaining); +libc_hidden_proto (__nanosleep_time64) +extern int __nanosleep_nocancel_time64 (const struct __timespec64 *requested_time, + struct __timespec64 *remaining); +libc_hidden_proto (__nanosleep_nocancel_time64) +#endif /* Use in the clock_* functions. Size of the field representing the actual clock ID. */ diff --git a/nptl/thrd_sleep.c b/nptl/thrd_sleep.c index 2e185dd748e..bd9373b1f61 100644 --- a/nptl/thrd_sleep.c +++ b/nptl/thrd_sleep.c @@ -22,18 +22,79 @@ #include "thrd_priv.h" int -thrd_sleep (const struct timespec* time_point, struct timespec* remaining) +__thrd_sleep_time64 (const struct __timespec64* time_point, struct __timespec64* remaining) { INTERNAL_SYSCALL_DECL (err); - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, remaining); + int ret = -1; + +#ifdef __ASSUME_TIME64_SYSCALLS +# ifndef __NR_clock_nanosleep_time64 +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep +# endif + ret = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, CLOCK_REALTIME, + 0, time_point, remaining); +#else +# ifdef __NR_clock_nanosleep_time64 + long int ret_64; + + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, CLOCK_REALTIME, + 0, time_point, remaining); + + if (ret_64 == 0 || errno != ENOSYS) + ret = ret_64; +# endif /* __NR_clock_nanosleep_time64 */ + if (ret < 0) + { + struct timespec tp32, tr32; + + if (! in_time_t_range (time_point->tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + tp32 = valid_timespec64_to_timespec (*time_point); + ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, &tp32, &tr32); + + if ((ret == 0 || errno != ENOSYS) && remaining) + *remaining = valid_timespec_to_timespec64 (tr32); + } +#endif /* __ASSUME_TIME64_SYSCALLS */ + if (INTERNAL_SYSCALL_ERROR_P (ret, err)) { /* C11 states thrd_sleep function returns -1 if it has been interrupted - by a signal, or a negative value if it fails. */ + by a signal, or a negative value if it fails. */ ret = INTERNAL_SYSCALL_ERRNO (ret, err); if (ret == EINTR) - return -1; + return -1; return -2; } return 0; } + +#if __TIMESIZE != 64 +int +thrd_sleep (const struct timespec* time_point, struct timespec* remaining) +{ + int ret; + struct __timespec64 tp64, tr64; + + tp64 = valid_timespec_to_timespec64 (*time_point); + ret = __thrd_sleep_time64 (&tp64, &tr64); + + if (ret == 0 || errno != ENOSYS) + { + if (! in_time_t_range (tr64.tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + if (remaining) + *remaining = valid_timespec64_to_timespec (tr64); + } + + return ret; +} +#endif diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c b/sysdeps/unix/sysv/linux/clock_nanosleep.c index 1f240b8720a..2f536ae42b3 100644 --- a/sysdeps/unix/sysv/linux/clock_nanosleep.c +++ b/sysdeps/unix/sysv/linux/clock_nanosleep.c @@ -26,9 +26,11 @@ /* We can simply use the syscall. The CPU clocks are not supported with this function. */ int -__clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req, - struct timespec *rem) +__clock_nanosleep_time64 (clockid_t clock_id, int flags, const struct __timespec64 *req, + struct __timespec64 *rem) { + int r = -1; + if (clock_id == CLOCK_THREAD_CPUTIME_ID) return EINVAL; if (clock_id == CLOCK_PROCESS_CPUTIME_ID) @@ -37,12 +39,72 @@ __clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req, /* If the call is interrupted by a signal handler or encounters an error, it returns a positive value similar to errno. */ INTERNAL_SYSCALL_DECL (err); - int r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, clock_id, flags, - req, rem); + +#ifdef __ASSUME_TIME64_SYSCALLS +# ifndef __NR_clock_nanosleep_time64 +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep +# endif + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, clock_id, + flags, req, rem); +#else +# ifdef __NR_clock_nanosleep_time64 + long int ret_64; + + ret_64 = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, err, clock_id, + flags, req, rem); + + if (ret_64 == 0 || errno != ENOSYS) + r = ret_64; +# endif /* __NR_clock_nanosleep_time64 */ + if (r < 0) + { + struct timespec ts32, tr32; + + if (! in_time_t_range (req->tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + ts32 = valid_timespec64_to_timespec (*req); + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, &ts32, &tr32); + + if ((r == 0 || errno != ENOSYS) && rem) + *rem = valid_timespec_to_timespec64 (tr32); + } +#endif /* __ASSUME_TIME64_SYSCALLS */ + return (INTERNAL_SYSCALL_ERROR_P (r, err) - ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); + ? INTERNAL_SYSCALL_ERRNO (r, err) : 0); } +#if __TIMESIZE != 64 +int +__clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req, + struct timespec *rem) +{ + int r; + struct __timespec64 treq64, trem64; + + treq64 = valid_timespec_to_timespec64 (*req); + r = __clock_nanosleep_time64 (clock_id, flags, &treq64, &trem64); + + if (r == 0 || errno != ENOSYS) + { + if (! in_time_t_range (trem64.tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + if (rem) + *rem = valid_timespec64_to_timespec (trem64); + } + + return r; +} +#endif + versioned_symbol (libc, __clock_nanosleep, clock_nanosleep, GLIBC_2_17); /* clock_nanosleep moved to libc in version 2.17; old binaries may expect the symbol version it had in librt. */ diff --git a/sysdeps/unix/sysv/linux/nanosleep.c b/sysdeps/unix/sysv/linux/nanosleep.c index 6787909248f..11fc6ea051b 100644 --- a/sysdeps/unix/sysv/linux/nanosleep.c +++ b/sysdeps/unix/sysv/linux/nanosleep.c @@ -22,10 +22,70 @@ /* Pause execution for a number of nanoseconds. */ int +__nanosleep_time64 (const struct __timespec64 *requested_time, + struct __timespec64 *remaining) +{ +#if defined(__ASSUME_TIME64_SYSCALLS) +# ifndef __NR_clock_nanosleep_time64 +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep +# endif + return SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, + requested_time, remaining); +#else +# ifdef __NR_clock_nanosleep_time64 + long int ret_64; + + ret_64 = SYSCALL_CANCEL (clock_nanosleep_time64, CLOCK_REALTIME, 0, + requested_time, remaining); + + if (ret_64 == 0 || errno != ENOSYS) + return ret_64; +# endif /* __NR_clock_nanosleep_time64 */ + int ret; + struct timespec ts32, tr32; + + if (! in_time_t_range (requested_time->tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + ts32 = valid_timespec64_to_timespec (*requested_time); + ret = SYSCALL_CANCEL (nanosleep, &ts32, &tr32); + + if ((ret == 0 || errno != ENOSYS) && remaining) + *remaining = valid_timespec_to_timespec64 (tr32); + + return ret; +#endif /* __ASSUME_TIME64_SYSCALLS */ +} + +#if __TIMESIZE != 64 +int __nanosleep (const struct timespec *requested_time, - struct timespec *remaining) + struct timespec *remaining) { - return SYSCALL_CANCEL (nanosleep, requested_time, remaining); + int r; + struct __timespec64 treq64, trem64; + + treq64 = valid_timespec_to_timespec64 (*requested_time); + r = __nanosleep_time64 (&treq64, &trem64); + + if (r == 0 || errno != ENOSYS) + { + if (! in_time_t_range (trem64.tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + if (remaining) + *remaining = valid_timespec64_to_timespec (trem64); + } + + return r; } +#endif + hidden_def (__nanosleep) weak_alias (__nanosleep, nanosleep) diff --git a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c index d6442bf4f7f..52a9df5a8f7 100644 --- a/sysdeps/unix/sysv/linux/nanosleep_nocancel.c +++ b/sysdeps/unix/sysv/linux/nanosleep_nocancel.c @@ -20,10 +20,70 @@ #include <sysdep-cancel.h> #include <not-cancel.h> +int +__nanosleep_nocancel_time64 (const struct __timespec64 *requested_time, + struct __timespec64 *remaining) +{ +#ifdef __ASSUME_TIME64_SYSCALLS +# ifndef __NR_clock_nanosleep_time64 +# define __NR_clock_nanosleep_time64 __NR_clock_nanosleep +# endif + return INLINE_SYSCALL_CALL (clock_nanosleep_time64, CLOCK_REALTIME, 0, + requested_time, remaining); +#else +# ifdef __NR_clock_nanosleep_time64 + long int ret_64; + + ret_64 = INLINE_SYSCALL_CALL (clock_nanosleep_time64, CLOCK_REALTIME, 0, + requested_time, remaining); + + if (ret_64 == 0 || errno != ENOSYS) + return ret_64; +# endif /* __NR_clock_nanosleep_time64 */ + int ret; + struct timespec ts32, tr32; + + if (! in_time_t_range (requested_time->tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + ts32 = valid_timespec64_to_timespec (*requested_time); + ret = INLINE_SYSCALL_CALL (nanosleep, &ts32, &tr32); + + if (ret == 0 || errno != ENOSYS) + *remaining = valid_timespec_to_timespec64 (tr32); + + return ret; +#endif /* __ASSUME_TIME64_SYSCALLS */ +} + +#if __TIMESIZE != 64 int __nanosleep_nocancel (const struct timespec *requested_time, - struct timespec *remaining) + struct timespec *remaining) { - return INLINE_SYSCALL_CALL (nanosleep, requested_time, remaining); + int ret; + struct __timespec64 treq64, trem64; + + treq64 = valid_timespec_to_timespec64 (*requested_time); + ret = __nanosleep_nocancel_time64 (&treq64, &trem64); + + if (ret == 0 || errno != ENOSYS) + { + if (! in_time_t_range (trem64.tv_sec)) + { + __set_errno (EOVERFLOW); + return -1; + } + + if (remaining) + *remaining = valid_timespec64_to_timespec (trem64); + } + + return ret; } +#endif + hidden_def (__nanosleep_nocancel)
The nanosleep syscall is not supported on newer 32-bit platforms (such as RV32). To fix this issue let's use clock_nanosleep_time64 if it is avaliable. Let's use CLOCK_REALTIME when calling clock_nanosleep_time64 as the Linux specification says: "POSIX.1 specifies that nanosleep() should measure time against the CLOCK_REALTIME clock. However, Linux measures the time using the CLOCK_MONOTONIC clock. This probably does not matter, since the POSIX.1 specification for clock_settime(2) says that discontinuous changes in CLOCK_REALTIME should not affect nanosleep()" Signed-off-by: Alistair Francis <alistair.francis@wdc.com> * nptl/thrd_sleep.c: Use clock_nanosleep_time64 instead of nanosleep. * sysdeps/unix/sysv/linux/nanosleep.c: Likewise. * sysdeps/unix/sysv/linux/clock_nanosleep.c: Likewise. * sysdeps/unix/sysv/linux/nanosleep_nocancel.c: Likewise. --- This was patch was tested with RV32 and RV64 and build tested using the glibc test scripts. @Lukasz do you think you could run this through your y2038 testing? Otherwise I'll look at setting up the same tests that you have. include/time.h | 20 ++++++ nptl/thrd_sleep.c | 69 +++++++++++++++++-- sysdeps/unix/sysv/linux/clock_nanosleep.c | 72 ++++++++++++++++++-- sysdeps/unix/sysv/linux/nanosleep.c | 64 ++++++++++++++++- sysdeps/unix/sysv/linux/nanosleep_nocancel.c | 64 ++++++++++++++++- 5 files changed, 276 insertions(+), 13 deletions(-)