| 1 |
/* Provide a replacement for the POSIX nanosleep function. |
| 2 |
|
| 3 |
Copyright (C) 1999-2000, 2002, 2004-2024 Free Software Foundation, Inc. |
| 4 |
|
| 5 |
This file is free software: you can redistribute it and/or modify |
| 6 |
it under the terms of the GNU Lesser General Public License as |
| 7 |
published by the Free Software Foundation; either version 2.1 of the |
| 8 |
License, or (at your option) any later version. |
| 9 |
|
| 10 |
This file is distributed in the hope that it will be useful, |
| 11 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 |
GNU Lesser General Public License for more details. |
| 14 |
|
| 15 |
You should have received a copy of the GNU Lesser General Public License |
| 16 |
along with this program. If not, see <https://www.gnu.org/licenses/>. */ |
| 17 |
|
| 18 |
/* written by Jim Meyering |
| 19 |
and Bruno Haible for the native Windows part */ |
| 20 |
|
| 21 |
#include <config.h> |
| 22 |
|
| 23 |
#include <time.h> |
| 24 |
|
| 25 |
#include "intprops.h" |
| 26 |
|
| 27 |
#include <stdio.h> |
| 28 |
#include <sys/types.h> |
| 29 |
#include <sys/select.h> |
| 30 |
#include <signal.h> |
| 31 |
|
| 32 |
#include <errno.h> |
| 33 |
|
| 34 |
#include <unistd.h> |
| 35 |
|
| 36 |
|
| 37 |
enum { BILLION = 1000 * 1000 * 1000 }; |
| 38 |
|
| 39 |
#if HAVE_BUG_BIG_NANOSLEEP |
| 40 |
|
| 41 |
int |
| 42 |
nanosleep (const struct timespec *requested_delay, |
| 43 |
struct timespec *remaining_delay) |
| 44 |
# undef nanosleep |
| 45 |
{ |
| 46 |
/* nanosleep mishandles large sleeps due to internal overflow problems. |
| 47 |
The worst known case of this is Linux 2.6.9 with glibc 2.3.4, which |
| 48 |
can't sleep more than 24.85 days (2^31 milliseconds). Similarly, |
| 49 |
cygwin 1.5.x, which can't sleep more than 49.7 days (2^32 milliseconds). |
| 50 |
Solve this by breaking the sleep up into smaller chunks. */ |
| 51 |
|
| 52 |
if (requested_delay->tv_nsec < 0 || BILLION <= requested_delay->tv_nsec) |
| 53 |
{ |
| 54 |
errno = EINVAL; |
| 55 |
return -1; |
| 56 |
} |
| 57 |
|
| 58 |
{ |
| 59 |
/* Verify that time_t is large enough. */ |
| 60 |
static_assert (TYPE_MAXIMUM (time_t) / 24 / 24 / 60 / 60); |
| 61 |
const time_t limit = 24 * 24 * 60 * 60; |
| 62 |
time_t seconds = requested_delay->tv_sec; |
| 63 |
struct timespec intermediate = *requested_delay; |
| 64 |
|
| 65 |
while (limit < seconds) |
| 66 |
{ |
| 67 |
int result; |
| 68 |
intermediate.tv_sec = limit; |
| 69 |
result = nanosleep (&intermediate, remaining_delay); |
| 70 |
seconds -= limit; |
| 71 |
if (result) |
| 72 |
{ |
| 73 |
if (remaining_delay) |
| 74 |
remaining_delay->tv_sec += seconds; |
| 75 |
return result; |
| 76 |
} |
| 77 |
intermediate.tv_nsec = 0; |
| 78 |
} |
| 79 |
intermediate.tv_sec = seconds; |
| 80 |
return nanosleep (&intermediate, remaining_delay); |
| 81 |
} |
| 82 |
} |
| 83 |
|
| 84 |
#elif defined _WIN32 && ! defined __CYGWIN__ |
| 85 |
/* Native Windows platforms. */ |
| 86 |
|
| 87 |
# define WIN32_LEAN_AND_MEAN |
| 88 |
# include <windows.h> |
| 89 |
|
| 90 |
/* The Windows API function Sleep() has a resolution of about 15 ms and takes |
| 91 |
at least 5 ms to execute. We use this function for longer time periods. |
| 92 |
Additionally, we use busy-looping over short time periods, to get a |
| 93 |
resolution of about 0.01 ms. In order to measure such short timespans, |
| 94 |
we use the QueryPerformanceCounter() function. */ |
| 95 |
|
| 96 |
int |
| 97 |
nanosleep (const struct timespec *requested_delay, |
| 98 |
struct timespec *remaining_delay) |
| 99 |
{ |
| 100 |
static bool initialized; |
| 101 |
/* Number of performance counter increments per nanosecond, |
| 102 |
or zero if it could not be determined. */ |
| 103 |
static double ticks_per_nanosecond; |
| 104 |
|
| 105 |
if (requested_delay->tv_nsec < 0 || BILLION <= requested_delay->tv_nsec) |
| 106 |
{ |
| 107 |
errno = EINVAL; |
| 108 |
return -1; |
| 109 |
} |
| 110 |
|
| 111 |
/* For requested delays of one second or more, 15ms resolution is |
| 112 |
sufficient. */ |
| 113 |
if (requested_delay->tv_sec == 0) |
| 114 |
{ |
| 115 |
if (!initialized) |
| 116 |
{ |
| 117 |
/* Initialize ticks_per_nanosecond. */ |
| 118 |
LARGE_INTEGER ticks_per_second; |
| 119 |
|
| 120 |
if (QueryPerformanceFrequency (&ticks_per_second)) |
| 121 |
ticks_per_nanosecond = |
| 122 |
(double) ticks_per_second.QuadPart / 1000000000.0; |
| 123 |
|
| 124 |
initialized = true; |
| 125 |
} |
| 126 |
if (ticks_per_nanosecond) |
| 127 |
{ |
| 128 |
/* QueryPerformanceFrequency worked. We can use |
| 129 |
QueryPerformanceCounter. Use a combination of Sleep and |
| 130 |
busy-looping. */ |
| 131 |
/* Number of milliseconds to pass to the Sleep function. |
| 132 |
Since Sleep can take up to 8 ms less or 8 ms more than requested |
| 133 |
(or maybe more if the system is loaded), we subtract 10 ms. */ |
| 134 |
int sleep_millis = (int) requested_delay->tv_nsec / 1000000 - 10; |
| 135 |
/* Determine how many ticks to delay. */ |
| 136 |
LONGLONG wait_ticks = requested_delay->tv_nsec * ticks_per_nanosecond; |
| 137 |
/* Start. */ |
| 138 |
LARGE_INTEGER counter_before; |
| 139 |
if (QueryPerformanceCounter (&counter_before)) |
| 140 |
{ |
| 141 |
/* Wait until the performance counter has reached this value. |
| 142 |
We don't need to worry about overflow, because the performance |
| 143 |
counter is reset at reboot, and with a frequency of 3.6E6 |
| 144 |
ticks per second 63 bits suffice for over 80000 years. */ |
| 145 |
LONGLONG wait_until = counter_before.QuadPart + wait_ticks; |
| 146 |
/* Use Sleep for the longest part. */ |
| 147 |
if (sleep_millis > 0) |
| 148 |
Sleep (sleep_millis); |
| 149 |
/* Busy-loop for the rest. */ |
| 150 |
for (;;) |
| 151 |
{ |
| 152 |
LARGE_INTEGER counter_after; |
| 153 |
if (!QueryPerformanceCounter (&counter_after)) |
| 154 |
/* QueryPerformanceCounter failed, but succeeded earlier. |
| 155 |
Should not happen. */ |
| 156 |
break; |
| 157 |
if (counter_after.QuadPart >= wait_until) |
| 158 |
/* The requested time has elapsed. */ |
| 159 |
break; |
| 160 |
} |
| 161 |
goto done; |
| 162 |
} |
| 163 |
} |
| 164 |
} |
| 165 |
/* Implementation for long delays and as fallback. */ |
| 166 |
Sleep (requested_delay->tv_sec * 1000 + requested_delay->tv_nsec / 1000000); |
| 167 |
|
| 168 |
done: |
| 169 |
/* Sleep is not interruptible. So there is no remaining delay. */ |
| 170 |
if (remaining_delay != NULL) |
| 171 |
{ |
| 172 |
remaining_delay->tv_sec = 0; |
| 173 |
remaining_delay->tv_nsec = 0; |
| 174 |
} |
| 175 |
return 0; |
| 176 |
} |
| 177 |
|
| 178 |
#else |
| 179 |
/* Other platforms lacking nanosleep. |
| 180 |
It's not clear whether these are still practical porting targets. |
| 181 |
For now, just fall back on pselect. */ |
| 182 |
|
| 183 |
/* Suspend execution for at least *REQUESTED_DELAY seconds. The |
| 184 |
*REMAINING_DELAY part isn't implemented yet. */ |
| 185 |
|
| 186 |
int |
| 187 |
nanosleep (const struct timespec *requested_delay, |
| 188 |
struct timespec *remaining_delay) |
| 189 |
{ |
| 190 |
return pselect (0, NULL, NULL, NULL, requested_delay, NULL); |
| 191 |
} |
| 192 |
#endif |