From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: AS31976 209.132.180.0/23 X-Spam-Status: No, score=-2.9 required=3.0 tests=AWL,BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FORGED_GMAIL_RCVD, FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED,SPF_HELO_PASS,SPF_PASS shortcircuit=no autolearn=ham autolearn_force=no version=3.4.2 Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dcvr.yhbt.net (Postfix) with ESMTPS id 04C6B1F4C1 for ; Wed, 16 Oct 2019 23:48:16 +0000 (UTC) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-type; q=dns; s=default; b=vHLh jgrMEfmfThBIPsTU1k3xhn1M/osVnOSo76M3+Hj7V0Uhzy79MoX9dZu+4GWmJOLD /RefeREHD7MTPc17CXFERE8t/VwTukPxLeUU2sTDDvzJ2UrfCP9ILOOvARJ+Knb2 +hdYrnhPfry+1lAxQ+VkBqYZbHw2+Yp4EVpS5s8= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-type; s=default; bh=lAJ9IUwOOo jrHpYGBGjwov2CQXc=; b=xUIbPao38vliI2eIpTSgapBRO31OKjZZaMyLUpYBuG dBo2v/qIbp6+QOqNh9VHRinuu0q2YCd54EXqYs84v9/g6DYA3pHxGSE0+Kv43JFO YWPzZagf2w7N04AGBj/Te7kjzVK1f6ZGkzqUQ5jVyf97pbtvloqZHrt/8hDozkO4 s= Received: (qmail 2943 invoked by alias); 16 Oct 2019 23:48:14 -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 Received: (qmail 2922 invoked by uid 89); 16 Oct 2019 23:48:13 -0000 Authentication-Results: sourceware.org; auth=none X-HELO: mail-lf1-f65.google.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=7J+SPoYYSpWZeHK7Rvuc++a+lY/mwyz7fk/jtV2hukI=; b=J+ykD5tp8oDRcJH13kxjPqz+hpc0Wcs0PWP/8TIlJKKoMvjLOFYiuk8rlYkslW6RRy 2wl93VR7NXI4maLLdFLSUkPxRv6a4RNKW6eNHWajq/GiuXruR8IXv2bVjC0CaL+BnpbM Z9dAXpS12ZG8gAaQ5/uAilm1EsOBcEZQithVf8fe35obMH17d1BO8YDQWYnjkve9fhui qKtg3MvE0sUmvgopgLBBMnjwv2kPZU1E+FcQOJWDsMbnbQ11PNoap+nX5kd+xCwOdXWW IXaNcMZ/VFihgEw0PEdb/uL+rYcog/3RguiMyw4tce+2ay3ESEz5ABXtZVmN8a5KSKPr vh5Q== MIME-Version: 1.0 References: <68f80207b37c5c06984b7a7f62444e35dcbeff56.1567097252.git.alistair.francis@wdc.com> <20191014155950.14e84ffb@jawa> <20191015175454.7a07e37f@jawa> In-Reply-To: From: Alistair Francis Date: Wed, 16 Oct 2019 16:42:59 -0700 Message-ID: Subject: Re: [RFC v5 02/21] sysdeps/nanosleep: Use clock_nanosleep_time64 if avaliable To: Lukasz Majewski Cc: Alistair Francis , GNU C Library , Arnd Bergmann , Palmer Dabbelt , "Maciej W. Rozycki" , Zong Li , Joseph Myers , Adhemerval Zanella , Florian Weimer , Zack Weinberg Content-Type: text/plain; charset="UTF-8" On Tue, Oct 15, 2019 at 3:28 PM Alistair Francis wrote: > > On Tue, Oct 15, 2019 at 8:55 AM Lukasz Majewski wrote: > > > > Hi Alistair, > > > > > On Mon, Oct 14, 2019 at 7:00 AM Lukasz Majewski 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 > > > > > > > > > > * 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. > > > > > --- > > > > > include/time.h | 6 ++ > > > > > nptl/thrd_sleep.c | 69 > > > > > ++++++++++++++++-- sysdeps/unix/sysv/linux/clock_nanosleep.c | > > > > > 74 ++++++++++++++++++-- sysdeps/unix/sysv/linux/nanosleep.c > > > > > | 65 ++++++++++++++++- > > > > > sysdeps/unix/sysv/linux/nanosleep_nocancel.c | 64 > > > > > ++++++++++++++++- 5 files changed, 264 insertions(+), 14 > > > > > deletions(-) > > > > > > > > > > diff --git a/include/time.h b/include/time.h > > > > > index 95b31429212..6d81f91384b 100644 > > > > > --- a/include/time.h > > > > > +++ b/include/time.h > > > > > @@ -172,6 +172,12 @@ 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 > > > > > +#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 07a51808df2..e85da561c68 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 timespec* > > > > > time_point, struct timespec* 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; > > > > > + } > > > > > + > > > > > + valid_timespec64_to_timespec (time_point, &tp32); > > > > > + ret = INTERNAL_SYSCALL_CANCEL (nanosleep, err, &tp32, > > > > > &tr32); + > > > > > + if ((ret == 0 || errno != ENOSYS) && remaining) > > > > > + valid_timespec_to_timespec64(&tr32, remaining); > > > > > + } > > > > > +#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; > > > > > + timespec64 tp64, tr64; > > > > > + > > > > > + valid_timespec_to_timespec64(time_point, &tp64); > > > > > + 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) > > > > > + valid_timespec64_to_timespec(&tr32, remaining); > > > > > + } > > > > > + > > > > > + return ret; > > > > > +} > > > > > +#endif > > > > > > > > This code seems to follow the pattern introduced in clock_settime() > > > > conversion (already in the -master branch). > > > > > > I hope so :) > > > > > > > > > > > Do you plan to send this and the following patches: > > > > > > > > https://patchwork.ozlabs.org/patch/1155396/ --> clock_gettime > > > > https://patchwork.ozlabs.org/patch/1155398/ --> timespec_get > > > > > > Yes > > > > > > > > > > > As a separate patch series so we can all benefit from having them in > > > > the -master glibc branch? > > > > Those patches seems to be orthogonal to ones adding support for > > > > RISC-V. > > > > > > Yep! My plan is to send them seperatley. I have been working through > > > the RV32 tree sending patches in small batches to get them merged. I > > > have a few more batches before I get to these time64_t conversion > > > patches though. I am unfortunately seeing failures with my time64_t > > > conversion patches which I haven't had a chance to look into. > > > > > > > > > > > > > > > The gettimeofday() syscall handling code seems to being now > > > > converted to clock_gettime() in the glibc (or at least there is > > > > some ongoing effort): > > > > > > > > https://sourceware.org/git/?p=glibc.git;a=commit;h=b30d257ea8f557bdadca09f5b112538e7b807eb9 > > > > > > > > > > Yep, I have rebased all of my work on top of this. > > > > > > > > > > > Similar situation is with stat and statfs (which are now under the > > > > discussion/review): > > > > > > > > https://patchwork.ozlabs.org/patch/1155399/ --> stat > > > > https://patchwork.ozlabs.org/patch/1155401/ --> statfs > > > > > > Yep, I'm working on the next version right now. > > > > > > If you want you are welcome to split out any patches and get them > > > upstreaed. Even just fixing failing test cases would speed things up. > > > My branch is available here: > > > https://github.com/alistair23/glibc/commits/alistair/rv32.next > > > > > > > Please find some comments and my future work plan: > > > > 1. The "sysdeps/clock_getres: Use inline syscall if required" : > > https://github.com/alistair23/glibc/commit/830707a4a3f662b1a97860afe658f6bbd9731d13 > > commit does not convert this syscall. > > > > However, I can convert and post to the glibc alpha the __clock_getres64 > > (as I already have some older code available). I'm now working on > > preparing proper patch. > > Go for it! :) > > > > > > > 2. Potential compilation error for SoCs with TIMESIZE != 64: > > https://github.com/alistair23/glibc/commit/4309573e10479516fcdf75c353309497f8017c90#diff-85643011757f36e12ca60b37c3e8ec0dR75 > > What is the error? > > > > > > > 3. Would you be so kind and post (to glibc alpha) the already converted > > (in your -next tree) __clock_nanosleep64: > > https://github.com/alistair23/glibc/commit/9e3d95ad1f70909a787dd11fbc735bcafa02050e#diff-5b9f1c6457e0e10079f657f283c19861R177 > > This patch is causing build failures, so I need to investigate that. Ah, there are typos from the rebases. I am updating these and I am sending patches out. Alistair > > > > > Just one remark - please in include/time.h use the following paradigm: > > https://github.com/lmajewski/y2038_glibc/commit/7ff615859f9e111c0c4cf8a6c085201c7ed82813#diff-5b9f1c6457e0e10079f657f283c19861R128 > > Ok, I'll add this. > > Alistair > > > > > for redirection. > > > > > > > Alistair > > > > > > > > > > > > diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c > > > > > b/sysdeps/unix/sysv/linux/clock_nanosleep.c index > > > > > 0cb6614dc92..64302fbcc69 100644 --- > > > > > a/sysdeps/unix/sysv/linux/clock_nanosleep.c +++ > > > > > b/sysdeps/unix/sysv/linux/clock_nanosleep.c @@ -21,13 +21,14 @@ > > > > > #include > > > > > #include "kernel-posix-cpu-timers.h" > > > > > > > > > > - > > > > > /* 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 timespec *req, > > > > > + struct timespec *rem) > > > > > { > > > > > + int r = -1; > > > > > + > > > > > if (clock_id == CLOCK_THREAD_CPUTIME_ID) > > > > > return EINVAL; > > > > > if (clock_id == CLOCK_PROCESS_CPUTIME_ID) > > > > > @@ -36,9 +37,70 @@ __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; > > > > > + } > > > > > + > > > > > + valid_timespec64_to_timespec (req, &ts32); > > > > > + r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, err, &ts32, > > > > > &tr32); + > > > > > + if ((r == 0 || errno != ENOSYS) && rem) > > > > > + valid_timespec_to_timespec64(&tr32, rem); > > > > > + } > > > > > +#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; > > > > > + timespec64 treq64, trem64; > > > > > + > > > > > + valid_timespec_to_timespec64(req, &treq64) > > > > > + 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 (remaining) > > > > > + valid_timespec64_to_timespec(&tr32, remaining); > > > > > + } > > > > > + > > > > > + return r; > > > > > +} > > > > > +#endif > > > > > + > > > > > weak_alias (__clock_nanosleep, clock_nanosleep) > > > > > diff --git a/sysdeps/unix/sysv/linux/nanosleep.c > > > > > b/sysdeps/unix/sysv/linux/nanosleep.c index > > > > > f14ae565af5..9a8dd5a4b82 100644 --- > > > > > a/sysdeps/unix/sysv/linux/nanosleep.c +++ > > > > > b/sysdeps/unix/sysv/linux/nanosleep.c @@ -22,10 +22,71 @@ > > > > > > > > > > /* Pause execution for a number of nanoseconds. */ > > > > > int > > > > > +__nanosleep_time64 (const struct timespec *requested_time, > > > > > + struct timespec *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; > > > > > + } > > > > > + > > > > > + valid_timespec64_to_timespec (requested_time, &ts32); > > > > > + ret = SYSCALL_CANCEL (nanosleep, &ts32, &tr32); > > > > > + > > > > > + if ((ret == 0 || errno != ENOSYS) && remaining) > > > > > + valid_timespec_to_timespec64(&tr32, remaining); > > > > > + > > > > > + 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; > > > > > + timespec64 treq64, trem64; > > > > > + > > > > > + > > > > > + valid_timespec_to_timespec64(req, &treq64); > > > > > + 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) > > > > > + valid_timespec64_to_timespec(&tr32, remaining); > > > > > + } > > > > > + > > > > > + 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 > > > > > 122ba627ff3..03f5be2ff9e 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 timespec > > > > > *requested_time, > > > > > + struct timespec *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; > > > > > + } > > > > > + > > > > > + valid_timespec64_to_timespec (requested_time, &ts32); > > > > > + ret = INLINE_SYSCALL_CALL (nanosleep, &ts32, &tr32); > > > > > + > > > > > + if (ret == 0 || errno != ENOSYS) > > > > > + valid_timespec_to_timespec64(&tr32, remaining); > > > > > + > > > > > + 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; > > > > > + timespec64 treq64, trem64; > > > > > + > > > > > + valid_timespec_to_timespec64(req, &treq64) > > > > > + 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) > > > > > + valid_timespec64_to_timespec(&tr32, remaining); > > > > > + } > > > > > + > > > > > + 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 > > > > > > > > > > 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