X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fxnanosleep.c;h=74cb8953030ea7c6ceb8e0efde9ee3fa5f5292f6;hb=4af188706f5b07a9e57ccdc83ec6e347aa4d27b6;hp=8aa5e8a8de68c502f8499521e23e99db71fb00eb;hpb=10ce26c08f4e8ffe6ac636b1fec6a33a847b0d3a;p=gnulib.git diff --git a/lib/xnanosleep.c b/lib/xnanosleep.c index 8aa5e8a8d..74cb89530 100644 --- a/lib/xnanosleep.c +++ b/lib/xnanosleep.c @@ -1,10 +1,11 @@ /* xnanosleep.c -- a more convenient interface to nanosleep - Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or modify + Copyright (C) 2002-2007, 2009-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -12,15 +13,12 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software Foundation, - Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ /* Mostly written (for sleep.c) by Paul Eggert. Factored out (creating this file) by Jim Meyering. */ -#if HAVE_CONFIG_H -# include -#endif +#include #include "xnanosleep.h" @@ -32,35 +30,12 @@ #include #include -#include "timespec.h" -#include "gethrxtime.h" -#include "xtime.h" - -/* The extra casts work around common compiler bugs. */ -#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) -/* The outer cast is needed to work around a bug in Cray C 5.0.3.0. - It is necessary at least when t == time_t. */ -#define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \ - ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0)) -#define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t))) +#include "intprops.h" #ifndef TIME_T_MAX # define TIME_T_MAX TYPE_MAXIMUM (time_t) #endif -/* POSIX.1-2001 requires that when a process is suspended, then - resumed, nanosleep (A, B) returns -1, sets errno to EINTR, and sets - *B to the time remaining at the point of resumption. However, some - versions of the Linux kernel incorrectly return the time remaining - at the point of suspension. Work around this bug on GNU/Linux - hosts by computing the remaining time here after nanosleep returns, - rather than by relying on nanosleep's computation. */ -#ifdef __linux__ -enum { NANOSLEEP_BUG_WORKAROUND = true }; -#else -enum { NANOSLEEP_BUG_WORKAROUND = false }; -#endif - /* Sleep until the time (call it WAKE_UP_TIME) specified as SECONDS seconds after the time this function is called. SECONDS must be non-negative. If SECONDS is so large that @@ -73,73 +48,70 @@ xnanosleep (double seconds) { enum { BILLION = 1000000000 }; - bool overflow = false; - double ns; + /* For overflow checking, use naive comparison if possible, widening + to long double if double is not wide enough. Otherwise, use <=, + not <, to avoid problems when TIME_T_MAX is less than SECONDS but + compares equal to SECONDS after loss of precision when coercing + from time_t to long double. This mishandles near-maximal values + in some rare (perhaps theoretical) cases but that is better than + undefined behavior. */ + bool overflow = ((time_t) ((double) TIME_T_MAX / 2) == TIME_T_MAX / 2 + ? TIME_T_MAX < seconds + : (time_t) ((long double) TIME_T_MAX / 2) == TIME_T_MAX / 2 + ? TIME_T_MAX < (long double) seconds + : TIME_T_MAX <= (long double) seconds); + struct timespec ts_sleep; - xtime_t stop = 0; assert (0 <= seconds); - if (NANOSLEEP_BUG_WORKAROUND) + /* Separate whole seconds from nanoseconds. */ + if (! overflow) { - xtime_t now = gethrxtime (); - double increment = XTIME_PRECISION * seconds; - xtime_t incr = increment; - stop = now + incr + (incr < increment); - overflow = (stop < now); - } - - /* Separate whole seconds from nanoseconds. - Be careful to detect any overflow. */ - ts_sleep.tv_sec = seconds; - ns = BILLION * (seconds - ts_sleep.tv_sec); - overflow |= ! (ts_sleep.tv_sec <= seconds && 0 <= ns && ns <= BILLION); - ts_sleep.tv_nsec = ns; - - /* Round up to the next whole number, if necessary, so that we - always sleep for at least the requested amount of time. Assuming - the default rounding mode, we don't have to worry about the - rounding error when computing 'ns' above, since the error won't - cause 'ns' to drop below an integer boundary. */ - ts_sleep.tv_nsec += (ts_sleep.tv_nsec < ns); - - /* Normalize the interval length. nanosleep requires this. */ - if (BILLION <= ts_sleep.tv_nsec) - { - time_t t = ts_sleep.tv_sec + 1; - - /* Detect integer overflow. */ - overflow |= (t < ts_sleep.tv_sec); - - ts_sleep.tv_sec = t; - ts_sleep.tv_nsec -= BILLION; + time_t floor_seconds = seconds; + double ns = BILLION * (seconds - floor_seconds); + ts_sleep.tv_sec = floor_seconds; + + /* Round up to the next whole number, if necessary, so that we + always sleep for at least the requested amount of time. Assuming + the default rounding mode, we don't have to worry about the + rounding error when computing 'ns' above, since the error won't + cause 'ns' to drop below an integer boundary. */ + ts_sleep.tv_nsec = ns; + ts_sleep.tv_nsec += (ts_sleep.tv_nsec < ns); + + /* Normalize the interval length. nanosleep requires this. */ + if (BILLION <= ts_sleep.tv_nsec) + { + if (ts_sleep.tv_sec == TIME_T_MAX) + overflow = true; + else + { + ts_sleep.tv_sec++; + ts_sleep.tv_nsec -= BILLION; + } + } } for (;;) { if (overflow) - { - ts_sleep.tv_sec = TIME_T_MAX; - ts_sleep.tv_nsec = BILLION - 1; - } - + { + ts_sleep.tv_sec = TIME_T_MAX; + ts_sleep.tv_nsec = BILLION - 1; + } + + /* Linux-2.6.8.1's nanosleep returns -1, but doesn't set errno + when resumed after being suspended. Earlier versions would + set errno to EINTR. nanosleep from linux-2.6.10, as well as + implementations by (all?) other vendors, doesn't return -1 + in that case; either it continues sleeping (if time remains) + or it returns zero (if the wake-up time has passed). */ + errno = 0; if (nanosleep (&ts_sleep, NULL) == 0) - break; - if (errno != EINTR) - return -1; - - if (NANOSLEEP_BUG_WORKAROUND) - { - xtime_t now = gethrxtime (); - if (stop <= now) - break; - else - { - xtime_t remaining = stop - now; - ts_sleep.tv_sec = xtime_nonnegative_sec (remaining); - ts_sleep.tv_nsec = xtime_nonnegative_nsec (remaining); - } - } + break; + if (errno != EINTR && errno != 0) + return -1; } return 0;