From patchwork Tue Nov 5 23:40:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alistair Francis X-Patchwork-Id: 35662 Received: (qmail 29056 invoked by alias); 5 Nov 2019 23:46:25 -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 29047 invoked by uid 89); 5 Nov 2019 23:46:25 -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, KAM_SHORT autolearn=ham version=3.3.1 spammy=measure, 1849 X-HELO: esa1.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=1572997583; x=1604533583; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=upMHQdN53eo44iw+zOyH/jfwOm60pG6bn6ZR042QVjQ=; b=Y44bKKAo/7EgGcaJsH4Zjc4licCc98mtVqiatxdbPm21m1pVI96Is0iQ zpjjdcmY6HknQOaaV+W9V6idu8tTNvmJUWBEl40ZXEFP5EzAcgOAhOLW5 dykmT1KEVur0Rzve63XaY4rx1gSSc3tex9dvBEbRyXCTQ3VgFUY9rH36l D4zS25ligTANob9rt1gYjtMKKT/LT5li1AkfUX/LQeql1yGc4fSP/6j20 nxjXgQkjZyCaUDtichdcbzBRHQ+We6u4Zlwb5ZqqQJ3cLQSaRyimXz+CV JgmuhYz3I9scZEVmc7qskcGf9EXMNE/rl1V+5ZNKg6KnaF+oCpl9Os9sd A==; IronPort-SDR: RLO6DlZoVre/AyXh0pcs4I2coApi494Jkf3f803jaFgLSm+ardgH6pjApm0AZEphq+4V2Ak4y9 yetQPgzf705a33B2xG1l+eFykTlC6c/d91hlJ4eDIlIBL/HV6F8NbbjGNX4wkjaKqjsdmRmTqs mc7uUqIaqT3Pu5Qo7MfnJCGiDGKDeucv1hV+AurvL6C3hPfKfRuimRN8oaJVE8AXbO8XJxhrQA IkKLYQQa3zxpFVBaKlH9E40ouRWO7YDxvTXf0oEkwnTXqJppaRW6JQXLlCZT7gKKY5ioVi6esT aso= IronPort-SDR: RNeJChBWTJMNnvzWDgiz3ZfV1Tex2yuIDvkVKwhNPmHvhz7ucGdD54ThspEb4lpeJ7keGe5Z5S xQhy0wCp3p4jY0AHTrF4Pp3g2KqwFoXxU6KLioLLCHZkrgPKhC89OS3chW4y9GyPmtttvH91av D/9/ZrSXosoQbQ0k+2l3X03AKMhIeTYkIoI2offqdHhZImjshC6qrdaqu2geCtzHFgI5uWd9aH yfBKY9/9x8rrqeepHV8kM0BTUtg96XQTUvAzwKnfO+rIB7TQeZIpYdf2lOmPn3xpRzOR+yCCtX fpVBbczDoXg9/bs4kKHWL9em IronPort-SDR: lNnQBsFLnkCXpU9++URPKFUgWOFJN40dp5NwrrUr2/EC+0M0E+scR9sznGwk/DjcF/B0KIJfS7 W2Vx+u5NAuRWtaAn8q51OhuwiQEiKy0VgB47Cg8Tykj+3kgYwrJTbuLifOnezZNWhMoMZ/VJLI w3kZQuGA9NmDhKYnM+JRqz5X+DXNgO5dtJZyO9lwqi7N1CD7LJ5gtWrXHMBcsOC3L6k/Ju4RuM tk18CX0qSuyXo0H/U955CiNxbhUtvsnWPec9Pj/RP1ry0iSbP/rwKDD/aLb9GYoXKWSG9p5UIC I6g= WDCIronportException: Internal From: Alistair Francis To: libc-alpha@sourceware.org Cc: alistair23@gmail.com, Alistair Francis Subject: [PATCH v4] sysdeps/nanosleep: Use clock_nanosleep_time64 if avaliable Date: Tue, 5 Nov 2019 15:40:58 -0800 Message-Id: <20191105234058.22483-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()" Let's also expose __clock_nanosleep internally to avoid code duplication. --- This was patch was runtime tested with RV32 and RV64 It was build tested using the ./scripts/build-many-glibcs.py script. I am currently running: $ make ; make install ; make check tests on native ARM (32-bit) with the following three confiugrations: - 4.19 Kernel and 4.19 Headers - 5.2 Kernel and 4.19 Headers - 5.2 Kernel and 5.2 Headers I should have the results tomorrow. v4: - Rebase on master - Use __clock_nanosleep to avoid duplicate implementations - Fix the error handling when a syscall fails v2: - Explicitly include `#include ` include/time.h | 23 ++++++++ nptl/thrd_sleep.c | 25 ++++----- sysdeps/unix/sysv/linux/Versions | 1 + sysdeps/unix/sysv/linux/clock_nanosleep.c | 68 +++++++++++++++++++++-- sysdeps/unix/sysv/linux/nanosleep.c | 13 +++-- 5 files changed, 106 insertions(+), 24 deletions(-) diff --git a/include/time.h b/include/time.h index 8ac58e891b5..e0974309726 100644 --- a/include/time.h +++ b/include/time.h @@ -184,6 +184,9 @@ extern struct tm *__tz_convert (__time64_t timer, int use_localtime, extern int __nanosleep (const struct timespec *__requested_time, struct timespec *__remaining); hidden_proto (__nanosleep) +extern int __clock_nanosleep (clockid_t clock_id, int flags, + const struct timespec *req, struct timespec *rem); +libc_hidden_proto (__clock_nanosleep) extern int __getdate_r (const char *__string, struct tm *__resbufp) attribute_hidden; @@ -206,6 +209,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..c865f815eea 100644 --- a/nptl/thrd_sleep.c +++ b/nptl/thrd_sleep.c @@ -17,23 +17,18 @@ . */ #include -#include - -#include "thrd_priv.h" +#include int thrd_sleep (const struct timespec* time_point, struct timespec* remaining) { - INTERNAL_SYSCALL_DECL (err); - int ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, time_point, remaining); - 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. */ - ret = INTERNAL_SYSCALL_ERRNO (ret, err); - if (ret == EINTR) - return -1; - return -2; - } - return 0; + int ret = __clock_nanosleep (CLOCK_REALTIME, 0, time_point, remaining); + /* C11 states thrd_sleep function returns -1 if it has been interrupted + by a signal, or a negative value if it fails. */ + switch (ret) + { + case 0: return 0; + case EINTR: return -1; + default: return -2; + } } diff --git a/sysdeps/unix/sysv/linux/Versions b/sysdeps/unix/sysv/linux/Versions index d385085c611..475abb50040 100644 --- a/sysdeps/unix/sysv/linux/Versions +++ b/sysdeps/unix/sysv/linux/Versions @@ -187,5 +187,6 @@ libc { __sigtimedwait; # functions used by nscd __netlink_assert_response; + __clock_nanosleep; } } diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c b/sysdeps/unix/sysv/linux/clock_nanosleep.c index 1f240b8720a..13ea9c6f802 100644 --- a/sysdeps/unix/sysv/linux/clock_nanosleep.c +++ b/sysdeps/unix/sysv/linux/clock_nanosleep.c @@ -16,6 +16,7 @@ . */ #include +#include #include #include @@ -26,9 +27,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 +40,67 @@ __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) + { + return (INTERNAL_SYSCALL_ERROR_P (ret_64, err) + ? INTERNAL_SYSCALL_ERRNO (ret_64, err) : 0); + } +# endif /* __NR_clock_nanosleep_time64 */ + 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 (rem) + *rem = valid_timespec64_to_timespec (trem64); + } + + return r; +} +#endif +libc_hidden_def (__clock_nanosleep) + 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..30cc26909a7 100644 --- a/sysdeps/unix/sysv/linux/nanosleep.c +++ b/sysdeps/unix/sysv/linux/nanosleep.c @@ -17,15 +17,20 @@ . */ #include -#include -#include +#include /* Pause execution for a number of nanoseconds. */ int __nanosleep (const struct timespec *requested_time, - struct timespec *remaining) + struct timespec *remaining) { - return SYSCALL_CANCEL (nanosleep, requested_time, remaining); + int ret = __clock_nanosleep (CLOCK_REALTIME, 0, requested_time, remaining); + if (ret != 0) + { + __set_errno (ret); + return -1; + } + return ret; } hidden_def (__nanosleep) weak_alias (__nanosleep, nanosleep)