From patchwork Thu Oct 17 00:08:29 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alistair Francis X-Patchwork-Id: 35078 Received: (qmail 47055 invoked by alias); 17 Oct 2019 00:13:17 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 47042 invoked by uid 89); 17 Oct 2019 00:13:16 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3 autolearn=ham version=3.3.1 spammy= X-HELO: esa2.hgst.iphmx.com DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1571271211; x=1602807211; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=UEEbfo5OLRr+GI1mWmqxajh/Gm8MB0FSUxWff7WZouw=; b=POt3gykbbZytGJ2FDOhyX9qedESoaVA5ee/i03HYOYQVc76KaIV0rUxg /9R3NFDO6hDzZkXlMCPDWHEKGvP9Ls3YTpA8SOpOYaSjSJF3z8XFJUBI+ NbmuYAwBCb7Xprmit2Ee1SL7ZWNptQUEppFGzXEKyEOI1T4s4+vsBbiBb uvvV5Elap8Z30OXfp8qdmUjv3GWA6F4Q9FFzY1KWBXrR0XRjnu0FP8XSx TRC2qsX7J+yjNum7YPLxfEiuPgywCogQgESjyg+9c7akYkIEh8I6Z8zkA F51Ew9SqIOi3yZREiUN7lq+BYAZPMedPt8pmO9DLiJWcHIAyZMVVEp6/R g==; IronPort-SDR: 8Ua+AvMkX+i4p9Q6CHeI4YXLOFsjYNyA7Wr1Az4qEg4IqgpoSnUOHTEnFsh+lpW05f9Rzn6To3 K7Mhv/71foeeuZd473K2CZNH0GoF7cabJGK19K4vLM7FsOF526pPX+QLR4FiWeMwHjusIs7xz/ fWZbBMgGR2ebhOEaHy61bKJnXGQLUPKmINv5NQ0KPA5pW/UFEg+9cs4xEgSIf6F94NuYB5MaoR v1xJ0V8QkjbfjaNooBTOLjqCrgHp6pr/EnYtF+9hQfZWRKpuS84zpaQSKu/C10U5KtSufTdqGv OR0= IronPort-SDR: mpflZX1dK8dDBhBP+QSgGyf7vhkEJpW2OS/WND1GK3beyICZ64MtSO0sBZTKrCJ7JFSE6gaxM0 d5WyOzCRGmwiCSER5DKQOBX9EWv4oKnX7Hat7aZRAJU7PYh8LUU0jMDZ5CSi/0YRPOrekJYS1/ WV73F8QDbnHHAETE1KKstAM6nCx+7Vp7jeHD2qEzkMagZSrLtpvfs9z05jHOtTZh4pwXhMK7sG efWbhiSFlEZGJ9+qu2sdRcvYmaecBCCIHTY8oqGRuVVqdtdBEuj7LbJYdx51rXvw0fzRYzgFZx Wnc3LBtWbcB5AY1+mI/RbvC4 IronPort-SDR: CSf5qGFTyMWWk5GV4Q/soIGH5A9QK/4rvfi5hR5JgyVczB5lekxb2HIi9yCgsW1P7lN/UKshR2 UTRk/f/PTVFSDUAAf+BC3PD2XSTynn1KxkSMtmQZ98bPHXl9Uuu4gr7v1aumiG4H7ZbHrngevK OGcxWz+GnkhHkIvLPnNq+vn2nveWjJEfxmCp4mQAQbqFuJzapf3FFaUJbydpphVxijiwIatv1D XU6Tcns5Eg4yScgAHoJ3/Y6mP06AFN6seZ2cPL0EBa8FC5Uk43IWG2UlSWBKdJE/K8X0pt9YzS UUI= WDCIronportException: Internal From: Alistair Francis To: libc-alpha@sourceware.org Cc: lukma@denx.de, alistair23@gmaill.com, Alistair Francis Subject: [PATCH] sysdeps/nanosleep: Use clock_nanosleep_time64 if avaliable Date: Wed, 16 Oct 2019 17:08:29 -0700 Message-Id: <20191017000829.4462-1-alistair.francis@wdc.com> MIME-Version: 1.0 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 * 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(-) 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 #include +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)